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.EarmarkRenderer
11 alias Pleroma.FollowingRelationship
13 alias Pleroma.Object.Containment
16 alias Pleroma.Web.ActivityPub.ActivityPub
17 alias Pleroma.Web.ActivityPub.ObjectValidator
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)
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_content(%{"mediaType" => "text/markdown", "content" => content} = object)
362 when is_binary(content) do
365 |> Earmark.as_html!(%Earmark.Options{renderer: EarmarkRenderer})
366 |> Pleroma.HTML.filter_tags()
368 Map.merge(object, %{"content" => html_content, "mediaType" => "text/html"})
371 defp fix_content(object), do: object
373 defp mastodon_follow_hack(%{"id" => id, "actor" => follower_id}, followed) do
374 with true <- id =~ "follows",
375 %User{local: true} = follower <- User.get_cached_by_ap_id(follower_id),
376 %Activity{} = activity <- Utils.fetch_latest_follow(follower, followed) do
383 defp mastodon_follow_hack(_, _), do: {:error, nil}
385 defp get_follow_activity(follow_object, followed) do
386 with object_id when not is_nil(object_id) <- Utils.get_ap_id(follow_object),
387 {_, %Activity{} = activity} <- {:activity, Activity.get_by_ap_id(object_id)} do
390 # Can't find the activity. This might a Mastodon 2.3 "Accept"
392 mastodon_follow_hack(follow_object, followed)
399 # Reduce the object list to find the reported user.
400 defp get_reported(objects) do
401 Enum.reduce_while(objects, nil, fn ap_id, _ ->
402 with %User{} = user <- User.get_cached_by_ap_id(ap_id) do
410 def handle_incoming(data, options \\ [])
412 # Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
414 def handle_incoming(%{"type" => "Flag", "object" => objects, "actor" => actor} = data, _options) do
415 with context <- data["context"] || Utils.generate_context_id(),
416 content <- data["content"] || "",
417 %User{} = actor <- User.get_cached_by_ap_id(actor),
418 # Reduce the object list to find the reported user.
419 %User{} = account <- get_reported(objects),
420 # Remove the reported user from the object list.
421 statuses <- Enum.filter(objects, fn ap_id -> ap_id != account.ap_id end) do
428 additional: %{"cc" => [account.ap_id]}
430 |> ActivityPub.flag()
434 # disallow objects with bogus IDs
435 def handle_incoming(%{"id" => nil}, _options), do: :error
436 def handle_incoming(%{"id" => ""}, _options), do: :error
437 # length of https:// = 8, should validate better, but good enough for now.
438 def handle_incoming(%{"id" => id}, _options) when is_binary(id) and byte_size(id) < 8,
441 # TODO: validate those with a Ecto scheme
445 %{"type" => "Create", "object" => %{"type" => objtype} = object} = data,
448 when objtype in ["Article", "Event", "Note", "Video", "Page", "Question", "Answer", "Audio"] do
449 actor = Containment.get_actor(data)
452 Map.put(data, "actor", actor)
455 with nil <- Activity.get_create_by_object_ap_id(object["id"]),
456 {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
457 object = fix_object(object, options)
463 context: object["conversation"],
465 published: data["published"],
474 with {:ok, created_activity} <- ActivityPub.create(params) do
475 reply_depth = (options[:depth] || 0) + 1
477 if Federator.allowed_thread_distance?(reply_depth) do
478 for reply_id <- replies(object) do
479 Pleroma.Workers.RemoteFetcherWorker.enqueue("fetch_remote", %{
481 "depth" => reply_depth
486 {:ok, created_activity}
489 %Activity{} = activity -> {:ok, activity}
495 %{"type" => "Listen", "object" => %{"type" => "Audio"} = object} = data,
498 actor = Containment.get_actor(data)
501 Map.put(data, "actor", actor)
504 with {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
505 reply_depth = (options[:depth] || 0) + 1
506 options = Keyword.put(options, :depth, reply_depth)
507 object = fix_object(object, options)
515 published: data["published"],
516 additional: Map.take(data, ["cc", "id"])
519 ActivityPub.listen(params)
526 %{"type" => "Follow", "object" => followed, "actor" => follower, "id" => id} = data,
529 with %User{local: true} = followed <-
530 User.get_cached_by_ap_id(Containment.get_actor(%{"actor" => followed})),
531 {:ok, %User{} = follower} <-
532 User.get_or_fetch_by_ap_id(Containment.get_actor(%{"actor" => follower})),
533 {:ok, activity} <- ActivityPub.follow(follower, followed, id, false) do
534 with deny_follow_blocked <- Pleroma.Config.get([:user, :deny_follow_blocked]),
535 {_, false} <- {:user_blocked, User.blocks?(followed, follower) && deny_follow_blocked},
536 {_, false} <- {:user_locked, User.locked?(followed)},
537 {_, {:ok, follower}} <- {:follow, User.follow(follower, followed)},
539 {:follow_state_update, Utils.update_follow_state_for_all(activity, "accept")},
540 {:ok, _relationship} <-
541 FollowingRelationship.update(follower, followed, :follow_accept) do
542 ActivityPub.accept(%{
543 to: [follower.ap_id],
549 {:user_blocked, true} ->
550 {:ok, _} = Utils.update_follow_state_for_all(activity, "reject")
551 {:ok, _relationship} = FollowingRelationship.update(follower, followed, :follow_reject)
553 ActivityPub.reject(%{
554 to: [follower.ap_id],
560 {:follow, {:error, _}} ->
561 {:ok, _} = Utils.update_follow_state_for_all(activity, "reject")
562 {:ok, _relationship} = FollowingRelationship.update(follower, followed, :follow_reject)
564 ActivityPub.reject(%{
565 to: [follower.ap_id],
571 {:user_locked, true} ->
572 {:ok, _relationship} = FollowingRelationship.update(follower, followed, :follow_pending)
584 %{"type" => "Accept", "object" => follow_object, "actor" => _actor, "id" => id} = data,
587 with actor <- Containment.get_actor(data),
588 {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
589 {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
590 {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "accept"),
591 %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
592 {:ok, _relationship} <- FollowingRelationship.update(follower, followed, :follow_accept) do
593 ActivityPub.accept(%{
594 to: follow_activity.data["to"],
597 object: follow_activity.data["id"],
607 %{"type" => "Reject", "object" => follow_object, "actor" => _actor, "id" => id} = data,
610 with actor <- Containment.get_actor(data),
611 {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
612 {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
613 {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "reject"),
614 %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
615 {:ok, _relationship} <- FollowingRelationship.update(follower, followed, :follow_reject),
617 ActivityPub.reject(%{
618 to: follow_activity.data["to"],
621 object: follow_activity.data["id"],
631 @misskey_reactions %{
645 @doc "Rewrite misskey likes into EmojiReacts"
649 "_misskey_reaction" => reaction
654 |> Map.put("type", "EmojiReact")
655 |> Map.put("content", @misskey_reactions[reaction] || reaction)
656 |> handle_incoming(options)
660 %{"type" => "Create", "object" => %{"type" => "ChatMessage"}} = data,
663 with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
664 {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
669 def handle_incoming(%{"type" => "Like"} = data, _options) do
670 with :ok <- ObjectValidator.fetch_actor_and_object(data),
671 {:ok, activity, _meta} <-
672 Pipeline.common_pipeline(data, local: false) do
681 "type" => "EmojiReact",
682 "object" => object_id,
689 with actor <- Containment.get_actor(data),
690 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
691 {:ok, object} <- get_obj_helper(object_id),
692 {:ok, activity, _object} <-
693 ActivityPub.react_with_emoji(actor, object, emoji, activity_id: id, local: false) do
701 %{"type" => "Announce", "object" => object_id, "actor" => _actor, "id" => id} = data,
704 with actor <- Containment.get_actor(data),
705 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
706 {:ok, object} <- get_embedded_obj_helper(object_id, actor),
707 public <- Visibility.is_public?(data),
708 {:ok, activity, _object} <- ActivityPub.announce(actor, object, id, false, public) do
716 %{"type" => "Update", "object" => %{"type" => object_type} = object, "actor" => actor_id} =
720 when object_type in [
726 with %User{ap_id: ^actor_id} = actor <- User.get_cached_by_ap_id(object["id"]) do
727 {:ok, new_user_data} = ActivityPub.user_data_from_user_object(object)
730 |> User.remote_user_changeset(new_user_data)
731 |> User.update_and_set_cache()
733 ActivityPub.update(%{
735 to: data["to"] || [],
736 cc: data["cc"] || [],
739 activity_id: data["id"]
748 # TODO: We presently assume that any actor on the same origin domain as the object being
749 # deleted has the rights to delete that object. A better way to validate whether or not
750 # the object should be deleted is to refetch the object URI, which should return either
751 # an error or a tombstone. This would allow us to verify that a deletion actually took
754 %{"type" => "Delete", "object" => object_id, "actor" => actor, "id" => id} = data,
757 object_id = Utils.get_ap_id(object_id)
759 with actor <- Containment.get_actor(data),
760 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
761 {:ok, object} <- get_obj_helper(object_id),
762 :ok <- Containment.contain_origin(actor.ap_id, object.data),
764 ActivityPub.delete(object, local: false, activity_id: id, actor: actor.ap_id) do
768 case User.get_cached_by_ap_id(object_id) do
769 %User{ap_id: ^actor} = user ->
784 "object" => %{"type" => "Announce", "object" => object_id},
790 with actor <- Containment.get_actor(data),
791 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
792 {:ok, object} <- get_obj_helper(object_id),
793 {:ok, activity, _} <- ActivityPub.unannounce(actor, object, id, false) do
803 "object" => %{"type" => "Follow", "object" => followed},
809 with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
810 {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
811 {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
812 User.unfollow(follower, followed)
822 "object" => %{"type" => "EmojiReact", "id" => reaction_activity_id},
828 with actor <- Containment.get_actor(data),
829 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
830 {:ok, activity, _} <-
831 ActivityPub.unreact_with_emoji(actor, reaction_activity_id,
844 "object" => %{"type" => "Block", "object" => blocked},
850 with %User{local: true} = blocked <- User.get_cached_by_ap_id(blocked),
851 {:ok, %User{} = blocker} <- User.get_or_fetch_by_ap_id(blocker),
852 {:ok, activity} <- ActivityPub.unblock(blocker, blocked, id, false) do
853 User.unblock(blocker, blocked)
861 %{"type" => "Block", "object" => blocked, "actor" => blocker, "id" => id} = _data,
864 with %User{local: true} = blocked = User.get_cached_by_ap_id(blocked),
865 {:ok, %User{} = blocker} = User.get_or_fetch_by_ap_id(blocker),
866 {:ok, activity} <- ActivityPub.block(blocker, blocked, id, false) do
867 User.unfollow(blocker, blocked)
868 User.block(blocker, blocked)
878 "object" => %{"type" => "Like", "object" => object_id},
884 with actor <- Containment.get_actor(data),
885 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
886 {:ok, object} <- get_obj_helper(object_id),
887 {:ok, activity, _, _} <- ActivityPub.unlike(actor, object, id, false) do
894 # For Undos that don't have the complete object attached, try to find it in our database.
902 when is_binary(object) do
903 with %Activity{data: data} <- Activity.get_by_ap_id(object) do
905 |> Map.put("object", data)
906 |> handle_incoming(options)
915 "actor" => origin_actor,
916 "object" => origin_actor,
917 "target" => target_actor
921 with %User{} = origin_user <- User.get_cached_by_ap_id(origin_actor),
922 {:ok, %User{} = target_user} <- User.get_or_fetch_by_ap_id(target_actor),
923 true <- origin_actor in target_user.also_known_as do
924 ActivityPub.move(origin_user, target_user, false)
930 def handle_incoming(_, _), do: :error
932 @spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} | nil
933 def get_obj_helper(id, options \\ []) do
934 case Object.normalize(id, true, options) do
935 %Object{} = object -> {:ok, object}
940 @spec get_embedded_obj_helper(String.t() | Object.t(), User.t()) :: {:ok, Object.t()} | nil
941 def get_embedded_obj_helper(%{"attributedTo" => attributed_to, "id" => object_id} = data, %User{
944 when attributed_to == ap_id do
945 with {:ok, activity} <-
950 "actor" => attributed_to,
953 {:ok, Object.normalize(activity)}
955 _ -> get_obj_helper(object_id)
959 def get_embedded_obj_helper(object_id, _) do
960 get_obj_helper(object_id)
963 def set_reply_to_uri(%{"inReplyTo" => in_reply_to} = object) when is_binary(in_reply_to) do
964 with false <- String.starts_with?(in_reply_to, "http"),
965 {:ok, %{data: replied_to_object}} <- get_obj_helper(in_reply_to) do
966 Map.put(object, "inReplyTo", replied_to_object["external_url"] || in_reply_to)
972 def set_reply_to_uri(obj), do: obj
975 Serialized Mastodon-compatible `replies` collection containing _self-replies_.
976 Based on Mastodon's ActivityPub::NoteSerializer#replies.
978 def set_replies(obj_data) do
980 with limit when limit > 0 <-
981 Pleroma.Config.get([:activitypub, :note_replies_output_limit], 0),
982 %Object{} = object <- Object.get_cached_by_ap_id(obj_data["id"]) do
984 |> Object.self_replies()
985 |> select([o], fragment("?->>'id'", o.data))
992 set_replies(obj_data, replies_uris)
995 defp set_replies(obj, []) do
999 defp set_replies(obj, replies_uris) do
1000 replies_collection = %{
1001 "type" => "Collection",
1002 "items" => replies_uris
1005 Map.merge(obj, %{"replies" => replies_collection})
1008 def replies(%{"replies" => %{"first" => %{"items" => items}}}) when not is_nil(items) do
1012 def replies(%{"replies" => %{"items" => items}}) when not is_nil(items) do
1016 def replies(_), do: []
1018 # Prepares the object of an outgoing create activity.
1019 def prepare_object(object) do
1025 |> add_attributed_to
1026 |> prepare_attachments
1030 |> strip_internal_fields
1031 |> strip_internal_tags
1037 # internal -> Mastodon
1040 def prepare_outgoing(%{"type" => activity_type, "object" => object_id} = data)
1041 when activity_type in ["Create", "Listen"] do
1044 |> Object.normalize()
1050 |> Map.put("object", object)
1051 |> Map.merge(Utils.make_json_ld_header())
1052 |> Map.delete("bcc")
1057 def prepare_outgoing(%{"type" => "Announce", "actor" => ap_id, "object" => object_id} = data) do
1060 |> Object.normalize()
1063 if Visibility.is_private?(object) && object.data["actor"] == ap_id do
1064 data |> Map.put("object", object |> Map.get(:data) |> prepare_object)
1066 data |> maybe_fix_object_url
1071 |> strip_internal_fields
1072 |> Map.merge(Utils.make_json_ld_header())
1073 |> Map.delete("bcc")
1078 # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
1079 # because of course it does.
1080 def prepare_outgoing(%{"type" => "Accept"} = data) do
1081 with follow_activity <- Activity.normalize(data["object"]) do
1083 "actor" => follow_activity.actor,
1084 "object" => follow_activity.data["object"],
1085 "id" => follow_activity.data["id"],
1091 |> Map.put("object", object)
1092 |> Map.merge(Utils.make_json_ld_header())
1098 def prepare_outgoing(%{"type" => "Reject"} = data) do
1099 with follow_activity <- Activity.normalize(data["object"]) do
1101 "actor" => follow_activity.actor,
1102 "object" => follow_activity.data["object"],
1103 "id" => follow_activity.data["id"],
1109 |> Map.put("object", object)
1110 |> Map.merge(Utils.make_json_ld_header())
1116 def prepare_outgoing(%{"type" => _type} = data) do
1119 |> strip_internal_fields
1120 |> maybe_fix_object_url
1121 |> Map.merge(Utils.make_json_ld_header())
1126 def maybe_fix_object_url(%{"object" => object} = data) when is_binary(object) do
1127 with false <- String.starts_with?(object, "http"),
1128 {:fetch, {:ok, relative_object}} <- {:fetch, get_obj_helper(object)},
1129 %{data: %{"external_url" => external_url}} when not is_nil(external_url) <-
1131 Map.put(data, "object", external_url)
1134 Logger.error("Couldn't fetch #{object} #{inspect(e)}")
1142 def maybe_fix_object_url(data), do: data
1144 def add_hashtags(object) do
1146 (object["tag"] || [])
1148 # Expand internal representation tags into AS2 tags.
1149 tag when is_binary(tag) ->
1151 "href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
1152 "name" => "##{tag}",
1156 # Do not process tags which are already AS2 tag objects.
1157 tag when is_map(tag) ->
1161 Map.put(object, "tag", tags)
1164 def add_mention_tags(object) do
1165 {enabled_receivers, disabled_receivers} = Utils.get_notified_from_object(object)
1166 potential_receivers = enabled_receivers ++ disabled_receivers
1167 mentions = Enum.map(potential_receivers, &build_mention_tag/1)
1169 tags = object["tag"] || []
1170 Map.put(object, "tag", tags ++ mentions)
1173 defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
1174 %{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
1177 def take_emoji_tags(%User{emoji: emoji}) do
1180 |> Enum.map(&build_emoji_tag/1)
1183 # TODO: we should probably send mtime instead of unix epoch time for updated
1184 def add_emoji_tags(%{"emoji" => emoji} = object) do
1185 tags = object["tag"] || []
1187 out = Enum.map(emoji, &build_emoji_tag/1)
1189 Map.put(object, "tag", tags ++ out)
1192 def add_emoji_tags(object), do: object
1194 defp build_emoji_tag({name, url}) do
1196 "icon" => %{"url" => url, "type" => "Image"},
1197 "name" => ":" <> name <> ":",
1199 "updated" => "1970-01-01T00:00:00Z",
1204 def set_conversation(object) do
1205 Map.put(object, "conversation", object["context"])
1208 def set_sensitive(%{"sensitive" => true} = object) do
1212 def set_sensitive(object) do
1213 tags = object["tag"] || []
1214 Map.put(object, "sensitive", "nsfw" in tags)
1217 def set_type(%{"type" => "Answer"} = object) do
1218 Map.put(object, "type", "Note")
1221 def set_type(object), do: object
1223 def add_attributed_to(object) do
1224 attributed_to = object["attributedTo"] || object["actor"]
1225 Map.put(object, "attributedTo", attributed_to)
1228 def prepare_attachments(object) do
1231 |> Map.get("attachment", [])
1232 |> Enum.map(fn data ->
1233 [%{"mediaType" => media_type, "href" => href} | _] = data["url"]
1237 "mediaType" => media_type,
1238 "name" => data["name"],
1239 "type" => "Document"
1243 Map.put(object, "attachment", attachments)
1246 def strip_internal_fields(object) do
1247 Map.drop(object, Pleroma.Constants.object_internal_fields())
1250 defp strip_internal_tags(%{"tag" => tags} = object) do
1251 tags = Enum.filter(tags, fn x -> is_map(x) end)
1253 Map.put(object, "tag", tags)
1256 defp strip_internal_tags(object), do: object
1258 def perform(:user_upgrade, user) do
1259 # we pass a fake user so that the followers collection is stripped away
1260 old_follower_address = User.ap_followers(%User{nickname: user.nickname})
1264 where: ^old_follower_address in a.recipients,
1269 "array_replace(?,?,?)",
1271 ^old_follower_address,
1272 ^user.follower_address
1277 |> Repo.update_all([])
1280 def upgrade_user_from_ap_id(ap_id) do
1281 with %User{local: false} = user <- User.get_cached_by_ap_id(ap_id),
1282 {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id),
1283 {:ok, user} <- update_user(user, data) do
1284 TransmogrifierWorker.enqueue("user_upgrade", %{"user_id" => user.id})
1287 %User{} = user -> {:ok, user}
1292 defp update_user(user, data) do
1294 |> User.remote_user_changeset(data)
1295 |> User.update_and_set_cache()
1298 def maybe_fix_user_url(%{"url" => url} = data) when is_map(url) do
1299 Map.put(data, "url", url["href"])
1302 def maybe_fix_user_url(data), do: data
1304 def maybe_fix_user_object(data), do: maybe_fix_user_url(data)