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
40 |> fix_in_reply_to(options)
49 def fix_summary(%{"summary" => nil} = object) do
50 Map.put(object, "summary", "")
53 def fix_summary(%{"summary" => _} = object) do
54 # summary is present, nothing to do
58 def fix_summary(object), do: Map.put(object, "summary", "")
60 def fix_addressing_list(map, field) do
62 is_binary(map[field]) ->
63 Map.put(map, field, [map[field]])
66 Map.put(map, field, [])
73 def fix_explicit_addressing(
74 %{"to" => to, "cc" => cc} = object,
78 explicit_to = Enum.filter(to, fn x -> x in explicit_mentions end)
80 explicit_cc = Enum.filter(to, fn x -> x not in explicit_mentions end)
84 |> Enum.reject(fn x -> String.ends_with?(x, "/followers") and x != follower_collection end)
88 |> Map.put("to", explicit_to)
89 |> Map.put("cc", final_cc)
92 def fix_explicit_addressing(object, _explicit_mentions, _followers_collection), do: object
94 # if directMessage flag is set to true, leave the addressing alone
95 def fix_explicit_addressing(%{"directMessage" => true} = object), do: object
97 def fix_explicit_addressing(object) do
98 explicit_mentions = Utils.determine_explicit_mentions(object)
100 %User{follower_address: follower_collection} =
102 |> Containment.get_actor()
103 |> User.get_cached_by_ap_id()
108 Pleroma.Constants.as_public(),
112 fix_explicit_addressing(object, explicit_mentions, follower_collection)
115 # if as:Public is addressed, then make sure the followers collection is also addressed
116 # so that the activities will be delivered to local users.
117 def fix_implicit_addressing(%{"to" => to, "cc" => cc} = object, followers_collection) do
118 recipients = to ++ cc
120 if followers_collection not in recipients do
122 Pleroma.Constants.as_public() in cc ->
123 to = to ++ [followers_collection]
124 Map.put(object, "to", to)
126 Pleroma.Constants.as_public() in to ->
127 cc = cc ++ [followers_collection]
128 Map.put(object, "cc", cc)
138 def fix_implicit_addressing(object, _), do: object
140 def fix_addressing(object) do
141 {:ok, %User{} = user} = User.get_or_fetch_by_ap_id(object["actor"])
142 followers_collection = User.ap_followers(user)
145 |> fix_addressing_list("to")
146 |> fix_addressing_list("cc")
147 |> fix_addressing_list("bto")
148 |> fix_addressing_list("bcc")
149 |> fix_explicit_addressing()
150 |> fix_implicit_addressing(followers_collection)
153 def fix_actor(%{"attributedTo" => actor} = object) do
154 Map.put(object, "actor", Containment.get_actor(%{"actor" => actor}))
157 def fix_in_reply_to(object, options \\ [])
159 def fix_in_reply_to(%{"inReplyTo" => in_reply_to} = object, options)
160 when not is_nil(in_reply_to) do
161 in_reply_to_id = prepare_in_reply_to(in_reply_to)
162 object = Map.put(object, "inReplyToAtomUri", in_reply_to_id)
163 depth = (options[:depth] || 0) + 1
165 if Federator.allowed_thread_distance?(depth) do
166 with {:ok, replied_object} <- get_obj_helper(in_reply_to_id, options),
167 %Activity{} <- Activity.get_create_by_object_ap_id(replied_object.data["id"]) do
169 |> Map.put("inReplyTo", replied_object.data["id"])
170 |> Map.put("inReplyToAtomUri", object["inReplyToAtomUri"] || in_reply_to_id)
171 |> Map.put("conversation", replied_object.data["context"] || object["conversation"])
172 |> Map.put("context", replied_object.data["context"] || object["conversation"])
175 Logger.error("Couldn't fetch #{inspect(in_reply_to_id)}, error: #{inspect(e)}")
183 def fix_in_reply_to(object, _options), do: object
185 defp prepare_in_reply_to(in_reply_to) do
187 is_bitstring(in_reply_to) ->
190 is_map(in_reply_to) && is_bitstring(in_reply_to["id"]) ->
193 is_list(in_reply_to) && is_bitstring(Enum.at(in_reply_to, 0)) ->
194 Enum.at(in_reply_to, 0)
201 def fix_context(object) do
202 context = object["context"] || object["conversation"] || Utils.generate_context_id()
205 |> Map.put("context", context)
206 |> Map.put("conversation", context)
209 defp add_if_present(map, _key, nil), do: map
211 defp add_if_present(map, key, value) do
212 Map.put(map, key, value)
215 def fix_attachments(%{"attachment" => attachment} = object) when is_list(attachment) do
217 Enum.map(attachment, fn data ->
220 is_list(data["url"]) -> List.first(data["url"])
221 is_map(data["url"]) -> data["url"]
227 is_map(url) && is_binary(url["mediaType"]) -> url["mediaType"]
228 is_binary(data["mediaType"]) -> data["mediaType"]
229 is_binary(data["mimeType"]) -> data["mimeType"]
235 is_map(url) && is_binary(url["href"]) -> url["href"]
236 is_binary(data["url"]) -> data["url"]
237 is_binary(data["href"]) -> data["href"]
242 |> add_if_present("mediaType", media_type)
243 |> add_if_present("type", Map.get(url || %{}, "type"))
245 %{"url" => [attachment_url]}
246 |> add_if_present("mediaType", media_type)
247 |> add_if_present("type", data["type"])
248 |> add_if_present("name", data["name"])
251 Map.put(object, "attachment", attachments)
254 def fix_attachments(%{"attachment" => attachment} = object) when is_map(attachment) do
256 |> Map.put("attachment", [attachment])
260 def fix_attachments(object), do: object
262 def fix_url(%{"url" => url} = object) when is_map(url) do
263 Map.put(object, "url", url["href"])
266 def fix_url(%{"type" => object_type, "url" => url} = object)
267 when object_type in ["Video", "Audio"] and is_list(url) do
268 first_element = Enum.at(url, 0)
270 link_element = Enum.find(url, fn x -> is_map(x) and x["mimeType"] == "text/html" end)
273 |> Map.put("attachment", [first_element])
274 |> Map.put("url", link_element["href"])
277 def fix_url(%{"type" => object_type, "url" => url} = object)
278 when object_type != "Video" and is_list(url) do
279 first_element = Enum.at(url, 0)
283 is_bitstring(first_element) -> first_element
284 is_map(first_element) -> first_element["href"] || ""
288 Map.put(object, "url", url_string)
291 def fix_url(object), do: object
293 def fix_emoji(%{"tag" => tags} = object) when is_list(tags) do
296 |> Enum.filter(fn data -> data["type"] == "Emoji" and data["icon"] end)
297 |> Enum.reduce(%{}, fn data, mapping ->
298 name = String.trim(data["name"], ":")
300 Map.put(mapping, name, data["icon"]["url"])
303 # we merge mastodon and pleroma emoji into a single mapping, to allow for both wire formats
304 emoji = Map.merge(object["emoji"] || %{}, emoji)
306 Map.put(object, "emoji", emoji)
309 def fix_emoji(%{"tag" => %{"type" => "Emoji"} = tag} = object) do
310 name = String.trim(tag["name"], ":")
311 emoji = %{name => tag["icon"]["url"]}
313 Map.put(object, "emoji", emoji)
316 def fix_emoji(object), do: object
318 def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
321 |> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
322 |> Enum.map(fn data -> String.slice(data["name"], 1..-1) end)
324 Map.put(object, "tag", tag ++ tags)
327 def fix_tag(%{"tag" => %{"type" => "Hashtag", "name" => hashtag} = tag} = object) do
328 combined = [tag, String.slice(hashtag, 1..-1)]
330 Map.put(object, "tag", combined)
333 def fix_tag(%{"tag" => %{} = tag} = object), do: Map.put(object, "tag", [tag])
335 def fix_tag(object), do: object
337 # content map usually only has one language so this will do for now.
338 def fix_content_map(%{"contentMap" => content_map} = object) do
339 content_groups = Map.to_list(content_map)
340 {_, content} = Enum.at(content_groups, 0)
342 Map.put(object, "content", content)
345 def fix_content_map(object), do: object
347 def fix_type(object, options \\ [])
349 def fix_type(%{"inReplyTo" => reply_id, "name" => _} = object, options)
350 when is_binary(reply_id) do
351 with true <- Federator.allowed_thread_distance?(options[:depth]),
352 {:ok, %{data: %{"type" => "Question"} = _} = _} <- get_obj_helper(reply_id, options) do
353 Map.put(object, "type", "Answer")
359 def fix_type(object, _), do: object
361 defp fix_media_type(%{"mediaType" => _} = object) do
362 Map.put(object, "mediaType", "text/html")
365 defp fix_media_type(object), do: object
367 defp mastodon_follow_hack(%{"id" => id, "actor" => follower_id}, followed) do
368 with true <- id =~ "follows",
369 %User{local: true} = follower <- User.get_cached_by_ap_id(follower_id),
370 %Activity{} = activity <- Utils.fetch_latest_follow(follower, followed) do
377 defp mastodon_follow_hack(_, _), do: {:error, nil}
379 defp get_follow_activity(follow_object, followed) do
380 with object_id when not is_nil(object_id) <- Utils.get_ap_id(follow_object),
381 {_, %Activity{} = activity} <- {:activity, Activity.get_by_ap_id(object_id)} do
384 # Can't find the activity. This might a Mastodon 2.3 "Accept"
386 mastodon_follow_hack(follow_object, followed)
393 # Reduce the object list to find the reported user.
394 defp get_reported(objects) do
395 Enum.reduce_while(objects, nil, fn ap_id, _ ->
396 with %User{} = user <- User.get_cached_by_ap_id(ap_id) do
404 def handle_incoming(data, options \\ [])
406 # Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
408 def handle_incoming(%{"type" => "Flag", "object" => objects, "actor" => actor} = data, _options) do
409 with context <- data["context"] || Utils.generate_context_id(),
410 content <- data["content"] || "",
411 %User{} = actor <- User.get_cached_by_ap_id(actor),
412 # Reduce the object list to find the reported user.
413 %User{} = account <- get_reported(objects),
414 # Remove the reported user from the object list.
415 statuses <- Enum.filter(objects, fn ap_id -> ap_id != account.ap_id end) do
422 additional: %{"cc" => [account.ap_id]}
424 |> ActivityPub.flag()
428 # disallow objects with bogus IDs
429 def handle_incoming(%{"id" => nil}, _options), do: :error
430 def handle_incoming(%{"id" => ""}, _options), do: :error
431 # length of https:// = 8, should validate better, but good enough for now.
432 def handle_incoming(%{"id" => id}, _options) when is_binary(id) and byte_size(id) < 8,
435 # TODO: validate those with a Ecto scheme
439 %{"type" => "Create", "object" => %{"type" => objtype} = object} = data,
442 when objtype in ["Article", "Event", "Note", "Video", "Page", "Question", "Answer", "Audio"] do
443 actor = Containment.get_actor(data)
446 Map.put(data, "actor", actor)
449 with nil <- Activity.get_create_by_object_ap_id(object["id"]),
450 {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
451 object = fix_object(object, options)
457 context: object["conversation"],
459 published: data["published"],
468 with {:ok, created_activity} <- ActivityPub.create(params) do
469 reply_depth = (options[:depth] || 0) + 1
471 if Federator.allowed_thread_distance?(reply_depth) do
472 for reply_id <- replies(object) do
473 Pleroma.Workers.RemoteFetcherWorker.enqueue("fetch_remote", %{
475 "depth" => reply_depth
480 {:ok, created_activity}
483 %Activity{} = activity -> {:ok, activity}
489 %{"type" => "Listen", "object" => %{"type" => "Audio"} = object} = data,
492 actor = Containment.get_actor(data)
495 Map.put(data, "actor", actor)
498 with {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
499 reply_depth = (options[:depth] || 0) + 1
500 options = Keyword.put(options, :depth, reply_depth)
501 object = fix_object(object, options)
509 published: data["published"],
510 additional: Map.take(data, ["cc", "id"])
513 ActivityPub.listen(params)
520 %{"type" => "Follow", "object" => followed, "actor" => follower, "id" => id} = data,
523 with %User{local: true} = followed <-
524 User.get_cached_by_ap_id(Containment.get_actor(%{"actor" => followed})),
525 {:ok, %User{} = follower} <-
526 User.get_or_fetch_by_ap_id(Containment.get_actor(%{"actor" => follower})),
527 {:ok, activity} <- ActivityPub.follow(follower, followed, id, false) do
528 with deny_follow_blocked <- Pleroma.Config.get([:user, :deny_follow_blocked]),
529 {_, false} <- {:user_blocked, User.blocks?(followed, follower) && deny_follow_blocked},
530 {_, false} <- {:user_locked, User.locked?(followed)},
531 {_, {:ok, follower}} <- {:follow, User.follow(follower, followed)},
533 {:follow_state_update, Utils.update_follow_state_for_all(activity, "accept")},
534 {:ok, _relationship} <-
535 FollowingRelationship.update(follower, followed, :follow_accept) do
536 ActivityPub.accept(%{
537 to: [follower.ap_id],
543 {:user_blocked, true} ->
544 {:ok, _} = Utils.update_follow_state_for_all(activity, "reject")
545 {:ok, _relationship} = FollowingRelationship.update(follower, followed, :follow_reject)
547 ActivityPub.reject(%{
548 to: [follower.ap_id],
554 {:follow, {:error, _}} ->
555 {:ok, _} = Utils.update_follow_state_for_all(activity, "reject")
556 {:ok, _relationship} = FollowingRelationship.update(follower, followed, :follow_reject)
558 ActivityPub.reject(%{
559 to: [follower.ap_id],
565 {:user_locked, true} ->
566 {:ok, _relationship} = FollowingRelationship.update(follower, followed, :follow_pending)
578 %{"type" => "Accept", "object" => follow_object, "actor" => _actor, "id" => id} = data,
581 with actor <- Containment.get_actor(data),
582 {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
583 {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
584 {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "accept"),
585 %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
586 {:ok, _relationship} <- FollowingRelationship.update(follower, followed, :follow_accept) do
587 ActivityPub.accept(%{
588 to: follow_activity.data["to"],
591 object: follow_activity.data["id"],
601 %{"type" => "Reject", "object" => follow_object, "actor" => _actor, "id" => id} = data,
604 with actor <- Containment.get_actor(data),
605 {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
606 {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
607 {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "reject"),
608 %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
609 {:ok, _relationship} <- FollowingRelationship.update(follower, followed, :follow_reject),
611 ActivityPub.reject(%{
612 to: follow_activity.data["to"],
615 object: follow_activity.data["id"],
625 @misskey_reactions %{
639 @doc "Rewrite misskey likes into EmojiReacts"
643 "_misskey_reaction" => reaction
648 |> Map.put("type", "EmojiReact")
649 |> Map.put("content", @misskey_reactions[reaction] || reaction)
650 |> handle_incoming(options)
653 def handle_incoming(%{"type" => "Like"} = data, _options) do
654 with {_, {:ok, cast_data_sym}} <-
656 data |> LikeValidator.cast_data() |> Ecto.Changeset.apply_action(:insert)},
657 cast_data = ObjectValidator.stringify_keys(Map.from_struct(cast_data_sym)),
658 :ok <- ObjectValidator.fetch_actor_and_object(cast_data),
659 {_, {:ok, cast_data}} <- {:ensure_context_presence, ensure_context_presence(cast_data)},
660 {_, {:ok, cast_data}} <-
661 {:ensure_recipients_presence, ensure_recipients_presence(cast_data)},
662 {_, {:ok, activity, _meta}} <-
663 {:common_pipeline, Pipeline.common_pipeline(cast_data, local: false)} do
672 "type" => "EmojiReact",
673 "object" => object_id,
680 with actor <- Containment.get_actor(data),
681 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
682 {:ok, object} <- get_obj_helper(object_id),
683 {:ok, activity, _object} <-
684 ActivityPub.react_with_emoji(actor, object, emoji, activity_id: id, local: false) do
692 %{"type" => "Announce", "object" => object_id, "actor" => _actor, "id" => id} = data,
695 with actor <- Containment.get_actor(data),
696 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
697 {:ok, object} <- get_embedded_obj_helper(object_id, actor),
698 public <- Visibility.is_public?(data),
699 {:ok, activity, _object} <- ActivityPub.announce(actor, object, id, false, public) do
707 %{"type" => "Update", "object" => %{"type" => object_type} = object, "actor" => actor_id} =
711 when object_type in [
717 with %User{ap_id: ^actor_id} = actor <- User.get_cached_by_ap_id(object["id"]) do
718 {:ok, new_user_data} = ActivityPub.user_data_from_user_object(object)
721 |> User.upgrade_changeset(new_user_data, true)
722 |> User.update_and_set_cache()
724 ActivityPub.update(%{
726 to: data["to"] || [],
727 cc: data["cc"] || [],
730 activity_id: data["id"]
739 # TODO: We presently assume that any actor on the same origin domain as the object being
740 # deleted has the rights to delete that object. A better way to validate whether or not
741 # the object should be deleted is to refetch the object URI, which should return either
742 # an error or a tombstone. This would allow us to verify that a deletion actually took
745 %{"type" => "Delete", "object" => object_id, "actor" => actor, "id" => id} = data,
748 object_id = Utils.get_ap_id(object_id)
750 with actor <- Containment.get_actor(data),
751 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
752 {:ok, object} <- get_obj_helper(object_id),
753 :ok <- Containment.contain_origin(actor.ap_id, object.data),
755 ActivityPub.delete(object, local: false, activity_id: id, actor: actor.ap_id) do
759 case User.get_cached_by_ap_id(object_id) do
760 %User{ap_id: ^actor} = user ->
775 "object" => %{"type" => "Announce", "object" => object_id},
781 with actor <- Containment.get_actor(data),
782 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
783 {:ok, object} <- get_obj_helper(object_id),
784 {:ok, activity, _} <- ActivityPub.unannounce(actor, object, id, false) do
794 "object" => %{"type" => "Follow", "object" => followed},
800 with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
801 {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
802 {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
803 User.unfollow(follower, followed)
813 "object" => %{"type" => "EmojiReact", "id" => reaction_activity_id},
819 with actor <- Containment.get_actor(data),
820 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
821 {:ok, activity, _} <-
822 ActivityPub.unreact_with_emoji(actor, reaction_activity_id,
835 "object" => %{"type" => "Block", "object" => blocked},
841 with %User{local: true} = blocked <- User.get_cached_by_ap_id(blocked),
842 {:ok, %User{} = blocker} <- User.get_or_fetch_by_ap_id(blocker),
843 {:ok, activity} <- ActivityPub.unblock(blocker, blocked, id, false) do
844 User.unblock(blocker, blocked)
852 %{"type" => "Block", "object" => blocked, "actor" => blocker, "id" => id} = _data,
855 with %User{local: true} = blocked = User.get_cached_by_ap_id(blocked),
856 {:ok, %User{} = blocker} = User.get_or_fetch_by_ap_id(blocker),
857 {:ok, activity} <- ActivityPub.block(blocker, blocked, id, false) do
858 User.unfollow(blocker, blocked)
859 User.block(blocker, blocked)
869 "object" => %{"type" => "Like", "object" => object_id},
875 with actor <- Containment.get_actor(data),
876 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
877 {:ok, object} <- get_obj_helper(object_id),
878 {:ok, activity, _, _} <- ActivityPub.unlike(actor, object, id, false) do
885 # For Undos that don't have the complete object attached, try to find it in our database.
893 when is_binary(object) do
894 with %Activity{data: data} <- Activity.get_by_ap_id(object) do
896 |> Map.put("object", data)
897 |> handle_incoming(options)
906 "actor" => origin_actor,
907 "object" => origin_actor,
908 "target" => target_actor
912 with %User{} = origin_user <- User.get_cached_by_ap_id(origin_actor),
913 {:ok, %User{} = target_user} <- User.get_or_fetch_by_ap_id(target_actor),
914 true <- origin_actor in target_user.also_known_as do
915 ActivityPub.move(origin_user, target_user, false)
921 def handle_incoming(_, _), do: :error
923 @spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} | nil
924 def get_obj_helper(id, options \\ []) do
925 case Object.normalize(id, true, options) do
926 %Object{} = object -> {:ok, object}
931 @spec get_embedded_obj_helper(String.t() | Object.t(), User.t()) :: {:ok, Object.t()} | nil
932 def get_embedded_obj_helper(%{"attributedTo" => attributed_to, "id" => object_id} = data, %User{
935 when attributed_to == ap_id do
936 with {:ok, activity} <-
941 "actor" => attributed_to,
944 {:ok, Object.normalize(activity)}
946 _ -> get_obj_helper(object_id)
950 def get_embedded_obj_helper(object_id, _) do
951 get_obj_helper(object_id)
954 def set_reply_to_uri(%{"inReplyTo" => in_reply_to} = object) when is_binary(in_reply_to) do
955 with false <- String.starts_with?(in_reply_to, "http"),
956 {:ok, %{data: replied_to_object}} <- get_obj_helper(in_reply_to) do
957 Map.put(object, "inReplyTo", replied_to_object["external_url"] || in_reply_to)
963 def set_reply_to_uri(obj), do: obj
966 Serialized Mastodon-compatible `replies` collection containing _self-replies_.
967 Based on Mastodon's ActivityPub::NoteSerializer#replies.
969 def set_replies(obj_data) do
971 with limit when limit > 0 <-
972 Pleroma.Config.get([:activitypub, :note_replies_output_limit], 0),
973 %Object{} = object <- Object.get_cached_by_ap_id(obj_data["id"]) do
975 |> Object.self_replies()
976 |> select([o], fragment("?->>'id'", o.data))
983 set_replies(obj_data, replies_uris)
986 defp set_replies(obj, []) do
990 defp set_replies(obj, replies_uris) do
991 replies_collection = %{
992 "type" => "Collection",
993 "items" => replies_uris
996 Map.merge(obj, %{"replies" => replies_collection})
999 def replies(%{"replies" => %{"first" => %{"items" => items}}}) when not is_nil(items) do
1003 def replies(%{"replies" => %{"items" => items}}) when not is_nil(items) do
1007 def replies(_), do: []
1009 # Prepares the object of an outgoing create activity.
1010 def prepare_object(object) do
1016 |> add_attributed_to
1017 |> prepare_attachments
1021 |> strip_internal_fields
1022 |> strip_internal_tags
1028 # internal -> Mastodon
1031 def prepare_outgoing(%{"type" => activity_type, "object" => object_id} = data)
1032 when activity_type in ["Create", "Listen"] do
1035 |> Object.normalize()
1041 |> Map.put("object", object)
1042 |> Map.merge(Utils.make_json_ld_header())
1043 |> Map.delete("bcc")
1048 def prepare_outgoing(%{"type" => "Announce", "actor" => ap_id, "object" => object_id} = data) do
1051 |> Object.normalize()
1054 if Visibility.is_private?(object) && object.data["actor"] == ap_id do
1055 data |> Map.put("object", object |> Map.get(:data) |> prepare_object)
1057 data |> maybe_fix_object_url
1062 |> strip_internal_fields
1063 |> Map.merge(Utils.make_json_ld_header())
1064 |> Map.delete("bcc")
1069 # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
1070 # because of course it does.
1071 def prepare_outgoing(%{"type" => "Accept"} = data) do
1072 with follow_activity <- Activity.normalize(data["object"]) do
1074 "actor" => follow_activity.actor,
1075 "object" => follow_activity.data["object"],
1076 "id" => follow_activity.data["id"],
1082 |> Map.put("object", object)
1083 |> Map.merge(Utils.make_json_ld_header())
1089 def prepare_outgoing(%{"type" => "Reject"} = data) do
1090 with follow_activity <- Activity.normalize(data["object"]) do
1092 "actor" => follow_activity.actor,
1093 "object" => follow_activity.data["object"],
1094 "id" => follow_activity.data["id"],
1100 |> Map.put("object", object)
1101 |> Map.merge(Utils.make_json_ld_header())
1107 def prepare_outgoing(%{"type" => _type} = data) do
1110 |> strip_internal_fields
1111 |> maybe_fix_object_url
1112 |> Map.merge(Utils.make_json_ld_header())
1117 def maybe_fix_object_url(%{"object" => object} = data) when is_binary(object) do
1118 with false <- String.starts_with?(object, "http"),
1119 {:fetch, {:ok, relative_object}} <- {:fetch, get_obj_helper(object)},
1120 %{data: %{"external_url" => external_url}} when not is_nil(external_url) <-
1122 Map.put(data, "object", external_url)
1125 Logger.error("Couldn't fetch #{object} #{inspect(e)}")
1133 def maybe_fix_object_url(data), do: data
1135 def add_hashtags(object) do
1137 (object["tag"] || [])
1139 # Expand internal representation tags into AS2 tags.
1140 tag when is_binary(tag) ->
1142 "href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
1143 "name" => "##{tag}",
1147 # Do not process tags which are already AS2 tag objects.
1148 tag when is_map(tag) ->
1152 Map.put(object, "tag", tags)
1155 def add_mention_tags(object) do
1156 {enabled_receivers, disabled_receivers} = Utils.get_notified_from_object(object)
1157 potential_receivers = enabled_receivers ++ disabled_receivers
1158 mentions = Enum.map(potential_receivers, &build_mention_tag/1)
1160 tags = object["tag"] || []
1161 Map.put(object, "tag", tags ++ mentions)
1164 defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
1165 %{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
1168 def take_emoji_tags(%User{emoji: emoji}) do
1170 |> Enum.flat_map(&Map.to_list/1)
1171 |> Enum.map(&build_emoji_tag/1)
1174 # TODO: we should probably send mtime instead of unix epoch time for updated
1175 def add_emoji_tags(%{"emoji" => emoji} = object) do
1176 tags = object["tag"] || []
1178 out = Enum.map(emoji, &build_emoji_tag/1)
1180 Map.put(object, "tag", tags ++ out)
1183 def add_emoji_tags(object), do: object
1185 defp build_emoji_tag({name, url}) do
1187 "icon" => %{"url" => url, "type" => "Image"},
1188 "name" => ":" <> name <> ":",
1190 "updated" => "1970-01-01T00:00:00Z",
1195 def set_conversation(object) do
1196 Map.put(object, "conversation", object["context"])
1199 def set_sensitive(object) do
1200 tags = object["tag"] || []
1201 Map.put(object, "sensitive", "nsfw" in tags)
1204 def set_type(%{"type" => "Answer"} = object) do
1205 Map.put(object, "type", "Note")
1208 def set_type(object), do: object
1210 def add_attributed_to(object) do
1211 attributed_to = object["attributedTo"] || object["actor"]
1212 Map.put(object, "attributedTo", attributed_to)
1215 def prepare_attachments(object) do
1218 |> Map.get("attachment", [])
1219 |> Enum.map(fn data ->
1220 [%{"mediaType" => media_type, "href" => href} | _] = data["url"]
1224 "mediaType" => media_type,
1225 "name" => data["name"],
1226 "type" => "Document"
1230 Map.put(object, "attachment", attachments)
1233 def strip_internal_fields(object) do
1234 Map.drop(object, Pleroma.Constants.object_internal_fields())
1237 defp strip_internal_tags(%{"tag" => tags} = object) do
1238 tags = Enum.filter(tags, fn x -> is_map(x) end)
1240 Map.put(object, "tag", tags)
1243 defp strip_internal_tags(object), do: object
1245 def perform(:user_upgrade, user) do
1246 # we pass a fake user so that the followers collection is stripped away
1247 old_follower_address = User.ap_followers(%User{nickname: user.nickname})
1251 where: ^old_follower_address in a.recipients,
1256 "array_replace(?,?,?)",
1258 ^old_follower_address,
1259 ^user.follower_address
1264 |> Repo.update_all([])
1267 def upgrade_user_from_ap_id(ap_id) do
1268 with %User{local: false} = user <- User.get_cached_by_ap_id(ap_id),
1269 {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id),
1270 already_ap <- User.ap_enabled?(user),
1271 {:ok, user} <- upgrade_user(user, data) do
1272 if not already_ap do
1273 TransmogrifierWorker.enqueue("user_upgrade", %{"user_id" => user.id})
1278 %User{} = user -> {:ok, user}
1283 defp upgrade_user(user, data) do
1285 |> User.upgrade_changeset(data, true)
1286 |> User.update_and_set_cache()
1289 def maybe_fix_user_url(%{"url" => url} = data) when is_map(url) do
1290 Map.put(data, "url", url["href"])
1293 def maybe_fix_user_url(data), do: data
1295 def maybe_fix_user_object(data), do: maybe_fix_user_url(data)
1297 defp ensure_context_presence(%{"context" => context} = data) when is_binary(context),
1300 defp ensure_context_presence(%{"object" => object} = data) when is_binary(object) do
1301 with %{data: %{"context" => context}} when is_binary(context) <- Object.normalize(object) do
1302 {:ok, Map.put(data, "context", context)}
1305 {:error, :no_context}
1309 defp ensure_context_presence(_) do
1310 {:error, :no_context}
1313 defp ensure_recipients_presence(%{"to" => [_ | _], "cc" => [_ | _]} = data),
1316 defp ensure_recipients_presence(%{"object" => object} = data) do
1317 case Object.normalize(object) do
1318 %{data: %{"actor" => actor}} ->
1321 |> Map.put("to", [actor])
1322 |> Map.put("cc", data["cc"] || [])
1327 {:error, :no_object}
1334 defp ensure_recipients_presence(_) do
1335 {:error, :no_object}