Merge remote-tracking branch 'pleroma/develop' into cycles-views
[akkoma] / lib / pleroma / web / activity_pub / transmogrifier.ex
1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
4
5 defmodule Pleroma.Web.ActivityPub.Transmogrifier do
6 @moduledoc """
7 A module to handle coding from internal to wire ActivityPub and back.
8 """
9 alias Pleroma.Activity
10 alias Pleroma.EctoType.ActivityPub.ObjectValidators
11 alias Pleroma.Maps
12 alias Pleroma.Object
13 alias Pleroma.Object.Containment
14 alias Pleroma.Repo
15 alias Pleroma.User
16 alias Pleroma.Web.ActivityPub.ActivityPub
17 alias Pleroma.Web.ActivityPub.Builder
18 alias Pleroma.Web.ActivityPub.ObjectValidator
19 alias Pleroma.Web.ActivityPub.Pipeline
20 alias Pleroma.Web.ActivityPub.Utils
21 alias Pleroma.Web.ActivityPub.Visibility
22 alias Pleroma.Web.Federator
23 alias Pleroma.Workers.TransmogrifierWorker
24
25 import Ecto.Query
26
27 require Logger
28 require Pleroma.Constants
29
30 @doc """
31 Modifies an incoming AP object (mastodon format) to our internal format.
32 """
33 def fix_object(object, options \\ []) do
34 object
35 |> strip_internal_fields()
36 |> fix_actor()
37 |> fix_url()
38 |> fix_attachments()
39 |> fix_context()
40 |> fix_in_reply_to(options)
41 |> fix_emoji()
42 |> fix_tag()
43 |> fix_content_map()
44 |> fix_addressing()
45 |> fix_summary()
46 |> fix_type(options)
47 end
48
49 def fix_summary(%{"summary" => nil} = object) do
50 Map.put(object, "summary", "")
51 end
52
53 def fix_summary(%{"summary" => _} = object) do
54 # summary is present, nothing to do
55 object
56 end
57
58 def fix_summary(object), do: Map.put(object, "summary", "")
59
60 def fix_addressing_list(map, field) do
61 addrs = map[field]
62
63 cond do
64 is_list(addrs) ->
65 Map.put(map, field, Enum.filter(addrs, &is_binary/1))
66
67 is_binary(addrs) ->
68 Map.put(map, field, [addrs])
69
70 true ->
71 Map.put(map, field, [])
72 end
73 end
74
75 def fix_explicit_addressing(
76 %{"to" => to, "cc" => cc} = object,
77 explicit_mentions,
78 follower_collection
79 ) do
80 explicit_to = Enum.filter(to, fn x -> x in explicit_mentions end)
81
82 explicit_cc = Enum.filter(to, fn x -> x not in explicit_mentions end)
83
84 final_cc =
85 (cc ++ explicit_cc)
86 |> Enum.reject(fn x -> String.ends_with?(x, "/followers") and x != follower_collection end)
87 |> Enum.uniq()
88
89 object
90 |> Map.put("to", explicit_to)
91 |> Map.put("cc", final_cc)
92 end
93
94 def fix_explicit_addressing(object, _explicit_mentions, _followers_collection), do: object
95
96 # if directMessage flag is set to true, leave the addressing alone
97 def fix_explicit_addressing(%{"directMessage" => true} = object), do: object
98
99 def fix_explicit_addressing(object) do
100 explicit_mentions = Utils.determine_explicit_mentions(object)
101
102 %User{follower_address: follower_collection} =
103 object
104 |> Containment.get_actor()
105 |> User.get_cached_by_ap_id()
106
107 explicit_mentions =
108 explicit_mentions ++
109 [
110 Pleroma.Constants.as_public(),
111 follower_collection
112 ]
113
114 fix_explicit_addressing(object, explicit_mentions, follower_collection)
115 end
116
117 # if as:Public is addressed, then make sure the followers collection is also addressed
118 # so that the activities will be delivered to local users.
119 def fix_implicit_addressing(%{"to" => to, "cc" => cc} = object, followers_collection) do
120 recipients = to ++ cc
121
122 if followers_collection not in recipients do
123 cond do
124 Pleroma.Constants.as_public() in cc ->
125 to = to ++ [followers_collection]
126 Map.put(object, "to", to)
127
128 Pleroma.Constants.as_public() in to ->
129 cc = cc ++ [followers_collection]
130 Map.put(object, "cc", cc)
131
132 true ->
133 object
134 end
135 else
136 object
137 end
138 end
139
140 def fix_implicit_addressing(object, _), do: object
141
142 def fix_addressing(object) do
143 {:ok, %User{} = user} = User.get_or_fetch_by_ap_id(object["actor"])
144 followers_collection = User.ap_followers(user)
145
146 object
147 |> fix_addressing_list("to")
148 |> fix_addressing_list("cc")
149 |> fix_addressing_list("bto")
150 |> fix_addressing_list("bcc")
151 |> fix_explicit_addressing()
152 |> fix_implicit_addressing(followers_collection)
153 end
154
155 def fix_actor(%{"attributedTo" => actor} = object) do
156 actor = Containment.get_actor(%{"actor" => actor})
157
158 # TODO: Remove actor field for Objects
159 object
160 |> Map.put("actor", actor)
161 |> Map.put("attributedTo", actor)
162 end
163
164 def fix_in_reply_to(object, options \\ [])
165
166 def fix_in_reply_to(%{"inReplyTo" => in_reply_to} = object, options)
167 when not is_nil(in_reply_to) do
168 in_reply_to_id = prepare_in_reply_to(in_reply_to)
169 depth = (options[:depth] || 0) + 1
170
171 if Federator.allowed_thread_distance?(depth) do
172 with {:ok, replied_object} <- get_obj_helper(in_reply_to_id, options),
173 %Activity{} <- Activity.get_create_by_object_ap_id(replied_object.data["id"]) do
174 object
175 |> Map.put("inReplyTo", replied_object.data["id"])
176 |> Map.put("context", replied_object.data["context"] || object["conversation"])
177 |> Map.drop(["conversation", "inReplyToAtomUri"])
178 else
179 e ->
180 Logger.warn("Couldn't fetch #{inspect(in_reply_to_id)}, error: #{inspect(e)}")
181 object
182 end
183 else
184 object
185 end
186 end
187
188 def fix_in_reply_to(object, _options), do: object
189
190 defp prepare_in_reply_to(in_reply_to) do
191 cond do
192 is_bitstring(in_reply_to) ->
193 in_reply_to
194
195 is_map(in_reply_to) && is_bitstring(in_reply_to["id"]) ->
196 in_reply_to["id"]
197
198 is_list(in_reply_to) && is_bitstring(Enum.at(in_reply_to, 0)) ->
199 Enum.at(in_reply_to, 0)
200
201 true ->
202 ""
203 end
204 end
205
206 def fix_context(object) do
207 context = object["context"] || object["conversation"] || Utils.generate_context_id()
208
209 object
210 |> Map.put("context", context)
211 |> Map.drop(["conversation"])
212 end
213
214 def fix_attachments(%{"attachment" => attachment} = object) when is_list(attachment) do
215 attachments =
216 Enum.map(attachment, fn data ->
217 url =
218 cond do
219 is_list(data["url"]) -> List.first(data["url"])
220 is_map(data["url"]) -> data["url"]
221 true -> nil
222 end
223
224 media_type =
225 cond do
226 is_map(url) && MIME.valid?(url["mediaType"]) -> url["mediaType"]
227 MIME.valid?(data["mediaType"]) -> data["mediaType"]
228 MIME.valid?(data["mimeType"]) -> data["mimeType"]
229 true -> nil
230 end
231
232 href =
233 cond do
234 is_map(url) && is_binary(url["href"]) -> url["href"]
235 is_binary(data["url"]) -> data["url"]
236 is_binary(data["href"]) -> data["href"]
237 true -> nil
238 end
239
240 if href do
241 attachment_url =
242 %{
243 "href" => href,
244 "type" => Map.get(url || %{}, "type", "Link")
245 }
246 |> Maps.put_if_present("mediaType", media_type)
247 |> Maps.put_if_present("width", (url || %{})["width"] || data["width"])
248 |> Maps.put_if_present("height", (url || %{})["height"] || data["height"])
249
250 %{
251 "url" => [attachment_url],
252 "type" => data["type"] || "Document"
253 }
254 |> Maps.put_if_present("mediaType", media_type)
255 |> Maps.put_if_present("name", data["name"])
256 |> Maps.put_if_present("blurhash", data["blurhash"])
257 else
258 nil
259 end
260 end)
261 |> Enum.filter(& &1)
262
263 Map.put(object, "attachment", attachments)
264 end
265
266 def fix_attachments(%{"attachment" => attachment} = object) when is_map(attachment) do
267 object
268 |> Map.put("attachment", [attachment])
269 |> fix_attachments()
270 end
271
272 def fix_attachments(object), do: object
273
274 def fix_url(%{"url" => url} = object) when is_map(url) do
275 Map.put(object, "url", url["href"])
276 end
277
278 def fix_url(%{"url" => url} = object) when is_list(url) do
279 first_element = Enum.at(url, 0)
280
281 url_string =
282 cond do
283 is_bitstring(first_element) -> first_element
284 is_map(first_element) -> first_element["href"] || ""
285 true -> ""
286 end
287
288 Map.put(object, "url", url_string)
289 end
290
291 def fix_url(object), do: object
292
293 def fix_emoji(%{"tag" => tags} = object) when is_list(tags) do
294 emoji =
295 tags
296 |> Enum.filter(fn data -> is_map(data) and data["type"] == "Emoji" and data["icon"] end)
297 |> Enum.reduce(%{}, fn data, mapping ->
298 name = String.trim(data["name"], ":")
299
300 Map.put(mapping, name, data["icon"]["url"])
301 end)
302
303 Map.put(object, "emoji", emoji)
304 end
305
306 def fix_emoji(%{"tag" => %{"type" => "Emoji"} = tag} = object) do
307 name = String.trim(tag["name"], ":")
308 emoji = %{name => tag["icon"]["url"]}
309
310 Map.put(object, "emoji", emoji)
311 end
312
313 def fix_emoji(object), do: object
314
315 def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
316 tags =
317 tag
318 |> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
319 |> Enum.map(fn
320 %{"name" => "#" <> hashtag} -> String.downcase(hashtag)
321 %{"name" => hashtag} -> String.downcase(hashtag)
322 end)
323
324 Map.put(object, "tag", tag ++ tags)
325 end
326
327 def fix_tag(%{"tag" => %{} = tag} = object) do
328 object
329 |> Map.put("tag", [tag])
330 |> fix_tag
331 end
332
333 def fix_tag(object), do: object
334
335 # content map usually only has one language so this will do for now.
336 def fix_content_map(%{"contentMap" => content_map} = object) do
337 content_groups = Map.to_list(content_map)
338 {_, content} = Enum.at(content_groups, 0)
339
340 Map.put(object, "content", content)
341 end
342
343 def fix_content_map(object), do: object
344
345 def fix_type(object, options \\ [])
346
347 def fix_type(%{"inReplyTo" => reply_id, "name" => _} = object, options)
348 when is_binary(reply_id) do
349 with true <- Federator.allowed_thread_distance?(options[:depth]),
350 {:ok, %{data: %{"type" => "Question"} = _} = _} <- get_obj_helper(reply_id, options) do
351 Map.put(object, "type", "Answer")
352 else
353 _ -> object
354 end
355 end
356
357 def fix_type(object, _), do: object
358
359 # Reduce the object list to find the reported user.
360 defp get_reported(objects) do
361 Enum.reduce_while(objects, nil, fn ap_id, _ ->
362 with %User{} = user <- User.get_cached_by_ap_id(ap_id) do
363 {:halt, user}
364 else
365 _ -> {:cont, nil}
366 end
367 end)
368 end
369
370 # Compatibility wrapper for Mastodon votes
371 defp handle_create(%{"object" => %{"type" => "Answer"}} = data, _user) do
372 handle_incoming(data)
373 end
374
375 defp handle_create(%{"object" => object} = data, user) do
376 %{
377 to: data["to"],
378 object: object,
379 actor: user,
380 context: object["context"],
381 local: false,
382 published: data["published"],
383 additional:
384 Map.take(data, [
385 "cc",
386 "directMessage",
387 "id"
388 ])
389 }
390 |> ActivityPub.create()
391 end
392
393 def handle_incoming(data, options \\ [])
394
395 # Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
396 # with nil ID.
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
405 %{
406 actor: actor,
407 context: context,
408 account: account,
409 statuses: statuses,
410 content: content,
411 additional: %{"cc" => [account.ap_id]}
412 }
413 |> ActivityPub.flag()
414 end
415 end
416
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,
422 do: :error
423
424 # TODO: validate those with a Ecto scheme
425 # - tags
426 # - emoji
427 def handle_incoming(
428 %{"type" => "Create", "object" => %{"type" => objtype} = object} = data,
429 options
430 )
431 when objtype in ~w{Note Page} do
432 actor = Containment.get_actor(data)
433
434 with nil <- Activity.get_create_by_object_ap_id(object["id"]),
435 {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(actor) do
436 data =
437 data
438 |> Map.put("object", fix_object(object, options))
439 |> Map.put("actor", actor)
440 |> fix_addressing()
441
442 with {:ok, created_activity} <- handle_create(data, user) do
443 reply_depth = (options[:depth] || 0) + 1
444
445 if Federator.allowed_thread_distance?(reply_depth) do
446 for reply_id <- replies(object) do
447 Pleroma.Workers.RemoteFetcherWorker.enqueue("fetch_remote", %{
448 "id" => reply_id,
449 "depth" => reply_depth
450 })
451 end
452 end
453
454 {:ok, created_activity}
455 end
456 else
457 %Activity{} = activity -> {:ok, activity}
458 _e -> :error
459 end
460 end
461
462 def handle_incoming(
463 %{"type" => "Listen", "object" => %{"type" => "Audio"} = object} = data,
464 options
465 ) do
466 actor = Containment.get_actor(data)
467
468 data =
469 Map.put(data, "actor", actor)
470 |> fix_addressing
471
472 with {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
473 reply_depth = (options[:depth] || 0) + 1
474 options = Keyword.put(options, :depth, reply_depth)
475 object = fix_object(object, options)
476
477 params = %{
478 to: data["to"],
479 object: object,
480 actor: user,
481 context: nil,
482 local: false,
483 published: data["published"],
484 additional: Map.take(data, ["cc", "id"])
485 }
486
487 ActivityPub.listen(params)
488 else
489 _e -> :error
490 end
491 end
492
493 @misskey_reactions %{
494 "like" => "👍",
495 "love" => "❤️",
496 "laugh" => "😆",
497 "hmm" => "🤔",
498 "surprise" => "😮",
499 "congrats" => "🎉",
500 "angry" => "💢",
501 "confused" => "😥",
502 "rip" => "😇",
503 "pudding" => "🍮",
504 "star" => "⭐"
505 }
506
507 @doc "Rewrite misskey likes into EmojiReacts"
508 def handle_incoming(
509 %{
510 "type" => "Like",
511 "_misskey_reaction" => reaction
512 } = data,
513 options
514 ) do
515 data
516 |> Map.put("type", "EmojiReact")
517 |> Map.put("content", @misskey_reactions[reaction] || reaction)
518 |> handle_incoming(options)
519 end
520
521 def handle_incoming(
522 %{"type" => "Create", "object" => %{"type" => objtype, "id" => obj_id}} = data,
523 _options
524 )
525 when objtype in ~w{Question Answer ChatMessage Audio Video Event Article} do
526 data = Map.put(data, "object", strip_internal_fields(data["object"]))
527
528 with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
529 nil <- Activity.get_create_by_object_ap_id(obj_id),
530 {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
531 {:ok, activity}
532 else
533 %Activity{} = activity -> {:ok, activity}
534 e -> e
535 end
536 end
537
538 def handle_incoming(%{"type" => type} = data, _options)
539 when type in ~w{Like EmojiReact Announce Add Remove} do
540 with :ok <- ObjectValidator.fetch_actor_and_object(data),
541 {:ok, activity, _meta} <-
542 Pipeline.common_pipeline(data, local: false) do
543 {:ok, activity}
544 else
545 e -> {:error, e}
546 end
547 end
548
549 def handle_incoming(
550 %{"type" => type} = data,
551 _options
552 )
553 when type in ~w{Update Block Follow Accept Reject} do
554 with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
555 {:ok, activity, _} <-
556 Pipeline.common_pipeline(data, local: false) do
557 {:ok, activity}
558 end
559 end
560
561 def handle_incoming(
562 %{"type" => "Delete"} = data,
563 _options
564 ) do
565 with {:ok, activity, _} <-
566 Pipeline.common_pipeline(data, local: false) do
567 {:ok, activity}
568 else
569 {:error, {:validate, _}} = e ->
570 # Check if we have a create activity for this
571 with {:ok, object_id} <- ObjectValidators.ObjectID.cast(data["object"]),
572 %Activity{data: %{"actor" => actor}} <-
573 Activity.create_by_object_ap_id(object_id) |> Repo.one(),
574 # We have one, insert a tombstone and retry
575 {:ok, tombstone_data, _} <- Builder.tombstone(actor, object_id),
576 {:ok, _tombstone} <- Object.create(tombstone_data) do
577 handle_incoming(data)
578 else
579 _ -> e
580 end
581 end
582 end
583
584 def handle_incoming(
585 %{
586 "type" => "Undo",
587 "object" => %{"type" => "Follow", "object" => followed},
588 "actor" => follower,
589 "id" => id
590 } = _data,
591 _options
592 ) do
593 with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
594 {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
595 {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
596 User.unfollow(follower, followed)
597 {:ok, activity}
598 else
599 _e -> :error
600 end
601 end
602
603 def handle_incoming(
604 %{
605 "type" => "Undo",
606 "object" => %{"type" => type}
607 } = data,
608 _options
609 )
610 when type in ["Like", "EmojiReact", "Announce", "Block"] do
611 with {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
612 {:ok, activity}
613 end
614 end
615
616 # For Undos that don't have the complete object attached, try to find it in our database.
617 def handle_incoming(
618 %{
619 "type" => "Undo",
620 "object" => object
621 } = activity,
622 options
623 )
624 when is_binary(object) do
625 with %Activity{data: data} <- Activity.get_by_ap_id(object) do
626 activity
627 |> Map.put("object", data)
628 |> handle_incoming(options)
629 else
630 _e -> :error
631 end
632 end
633
634 def handle_incoming(
635 %{
636 "type" => "Move",
637 "actor" => origin_actor,
638 "object" => origin_actor,
639 "target" => target_actor
640 },
641 _options
642 ) do
643 with %User{} = origin_user <- User.get_cached_by_ap_id(origin_actor),
644 {:ok, %User{} = target_user} <- User.get_or_fetch_by_ap_id(target_actor),
645 true <- origin_actor in target_user.also_known_as do
646 ActivityPub.move(origin_user, target_user, false)
647 else
648 _e -> :error
649 end
650 end
651
652 def handle_incoming(_, _), do: :error
653
654 @spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} | nil
655 def get_obj_helper(id, options \\ []) do
656 options = Keyword.put(options, :fetch, true)
657
658 case Object.normalize(id, options) do
659 %Object{} = object -> {:ok, object}
660 _ -> nil
661 end
662 end
663
664 @spec get_embedded_obj_helper(String.t() | Object.t(), User.t()) :: {:ok, Object.t()} | nil
665 def get_embedded_obj_helper(%{"attributedTo" => attributed_to, "id" => object_id} = data, %User{
666 ap_id: ap_id
667 })
668 when attributed_to == ap_id do
669 with {:ok, activity} <-
670 handle_incoming(%{
671 "type" => "Create",
672 "to" => data["to"],
673 "cc" => data["cc"],
674 "actor" => attributed_to,
675 "object" => data
676 }) do
677 {:ok, Object.normalize(activity, fetch: false)}
678 else
679 _ -> get_obj_helper(object_id)
680 end
681 end
682
683 def get_embedded_obj_helper(object_id, _) do
684 get_obj_helper(object_id)
685 end
686
687 def set_reply_to_uri(%{"inReplyTo" => in_reply_to} = object) when is_binary(in_reply_to) do
688 with false <- String.starts_with?(in_reply_to, "http"),
689 {:ok, %{data: replied_to_object}} <- get_obj_helper(in_reply_to) do
690 Map.put(object, "inReplyTo", replied_to_object["external_url"] || in_reply_to)
691 else
692 _e -> object
693 end
694 end
695
696 def set_reply_to_uri(obj), do: obj
697
698 @doc """
699 Serialized Mastodon-compatible `replies` collection containing _self-replies_.
700 Based on Mastodon's ActivityPub::NoteSerializer#replies.
701 """
702 def set_replies(obj_data) do
703 replies_uris =
704 with limit when limit > 0 <-
705 Pleroma.Config.get([:activitypub, :note_replies_output_limit], 0),
706 %Object{} = object <- Object.get_cached_by_ap_id(obj_data["id"]) do
707 object
708 |> Object.self_replies()
709 |> select([o], fragment("?->>'id'", o.data))
710 |> limit(^limit)
711 |> Repo.all()
712 else
713 _ -> []
714 end
715
716 set_replies(obj_data, replies_uris)
717 end
718
719 defp set_replies(obj, []) do
720 obj
721 end
722
723 defp set_replies(obj, replies_uris) do
724 replies_collection = %{
725 "type" => "Collection",
726 "items" => replies_uris
727 }
728
729 Map.merge(obj, %{"replies" => replies_collection})
730 end
731
732 def replies(%{"replies" => %{"first" => %{"items" => items}}}) when not is_nil(items) do
733 items
734 end
735
736 def replies(%{"replies" => %{"items" => items}}) when not is_nil(items) do
737 items
738 end
739
740 def replies(_), do: []
741
742 # Prepares the object of an outgoing create activity.
743 def prepare_object(object) do
744 object
745 |> add_hashtags
746 |> add_mention_tags
747 |> add_emoji_tags
748 |> add_attributed_to
749 |> prepare_attachments
750 |> set_conversation
751 |> set_reply_to_uri
752 |> set_replies
753 |> strip_internal_fields
754 |> strip_internal_tags
755 |> set_type
756 end
757
758 # @doc
759 # """
760 # internal -> Mastodon
761 # """
762
763 def prepare_outgoing(%{"type" => activity_type, "object" => object_id} = data)
764 when activity_type in ["Create", "Listen"] do
765 object =
766 object_id
767 |> Object.normalize(fetch: false)
768 |> Map.get(:data)
769 |> prepare_object
770
771 data =
772 data
773 |> Map.put("object", object)
774 |> Map.merge(Utils.make_json_ld_header())
775 |> Map.delete("bcc")
776
777 {:ok, data}
778 end
779
780 def prepare_outgoing(%{"type" => "Announce", "actor" => ap_id, "object" => object_id} = data) do
781 object =
782 object_id
783 |> Object.normalize(fetch: false)
784
785 data =
786 if Visibility.is_private?(object) && object.data["actor"] == ap_id do
787 data |> Map.put("object", object |> Map.get(:data) |> prepare_object)
788 else
789 data |> maybe_fix_object_url
790 end
791
792 data =
793 data
794 |> strip_internal_fields
795 |> Map.merge(Utils.make_json_ld_header())
796 |> Map.delete("bcc")
797
798 {:ok, data}
799 end
800
801 # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
802 # because of course it does.
803 def prepare_outgoing(%{"type" => "Accept"} = data) do
804 with follow_activity <- Activity.normalize(data["object"]) do
805 object = %{
806 "actor" => follow_activity.actor,
807 "object" => follow_activity.data["object"],
808 "id" => follow_activity.data["id"],
809 "type" => "Follow"
810 }
811
812 data =
813 data
814 |> Map.put("object", object)
815 |> Map.merge(Utils.make_json_ld_header())
816
817 {:ok, data}
818 end
819 end
820
821 def prepare_outgoing(%{"type" => "Reject"} = data) do
822 with follow_activity <- Activity.normalize(data["object"]) do
823 object = %{
824 "actor" => follow_activity.actor,
825 "object" => follow_activity.data["object"],
826 "id" => follow_activity.data["id"],
827 "type" => "Follow"
828 }
829
830 data =
831 data
832 |> Map.put("object", object)
833 |> Map.merge(Utils.make_json_ld_header())
834
835 {:ok, data}
836 end
837 end
838
839 def prepare_outgoing(%{"type" => _type} = data) do
840 data =
841 data
842 |> strip_internal_fields
843 |> maybe_fix_object_url
844 |> Map.merge(Utils.make_json_ld_header())
845
846 {:ok, data}
847 end
848
849 def maybe_fix_object_url(%{"object" => object} = data) when is_binary(object) do
850 with false <- String.starts_with?(object, "http"),
851 {:fetch, {:ok, relative_object}} <- {:fetch, get_obj_helper(object)},
852 %{data: %{"external_url" => external_url}} when not is_nil(external_url) <-
853 relative_object do
854 Map.put(data, "object", external_url)
855 else
856 {:fetch, e} ->
857 Logger.error("Couldn't fetch #{object} #{inspect(e)}")
858 data
859
860 _ ->
861 data
862 end
863 end
864
865 def maybe_fix_object_url(data), do: data
866
867 def add_hashtags(object) do
868 tags =
869 (object["tag"] || [])
870 |> Enum.map(fn
871 # Expand internal representation tags into AS2 tags.
872 tag when is_binary(tag) ->
873 %{
874 "href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
875 "name" => "##{tag}",
876 "type" => "Hashtag"
877 }
878
879 # Do not process tags which are already AS2 tag objects.
880 tag when is_map(tag) ->
881 tag
882 end)
883
884 Map.put(object, "tag", tags)
885 end
886
887 # TODO These should be added on our side on insertion, it doesn't make much
888 # sense to regenerate these all the time
889 def add_mention_tags(object) do
890 to = object["to"] || []
891 cc = object["cc"] || []
892 mentioned = User.get_users_from_set(to ++ cc, local_only: false)
893
894 mentions = Enum.map(mentioned, &build_mention_tag/1)
895
896 tags = object["tag"] || []
897 Map.put(object, "tag", tags ++ mentions)
898 end
899
900 defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
901 %{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
902 end
903
904 def take_emoji_tags(%User{emoji: emoji}) do
905 emoji
906 |> Map.to_list()
907 |> Enum.map(&build_emoji_tag/1)
908 end
909
910 # TODO: we should probably send mtime instead of unix epoch time for updated
911 def add_emoji_tags(%{"emoji" => emoji} = object) do
912 tags = object["tag"] || []
913
914 out = Enum.map(emoji, &build_emoji_tag/1)
915
916 Map.put(object, "tag", tags ++ out)
917 end
918
919 def add_emoji_tags(object), do: object
920
921 defp build_emoji_tag({name, url}) do
922 %{
923 "icon" => %{"url" => "#{URI.encode(url)}", "type" => "Image"},
924 "name" => ":" <> name <> ":",
925 "type" => "Emoji",
926 "updated" => "1970-01-01T00:00:00Z",
927 "id" => url
928 }
929 end
930
931 def set_conversation(object) do
932 Map.put(object, "conversation", object["context"])
933 end
934
935 def set_type(%{"type" => "Answer"} = object) do
936 Map.put(object, "type", "Note")
937 end
938
939 def set_type(object), do: object
940
941 def add_attributed_to(object) do
942 attributed_to = object["attributedTo"] || object["actor"]
943 Map.put(object, "attributedTo", attributed_to)
944 end
945
946 # TODO: Revisit this
947 def prepare_attachments(%{"type" => "ChatMessage"} = object), do: object
948
949 def prepare_attachments(object) do
950 attachments =
951 object
952 |> Map.get("attachment", [])
953 |> Enum.map(fn data ->
954 [%{"mediaType" => media_type, "href" => href} = url | _] = data["url"]
955
956 %{
957 "url" => href,
958 "mediaType" => media_type,
959 "name" => data["name"],
960 "type" => "Document"
961 }
962 |> Maps.put_if_present("width", url["width"])
963 |> Maps.put_if_present("height", url["height"])
964 |> Maps.put_if_present("blurhash", data["blurhash"])
965 end)
966
967 Map.put(object, "attachment", attachments)
968 end
969
970 def strip_internal_fields(object) do
971 Map.drop(object, Pleroma.Constants.object_internal_fields())
972 end
973
974 defp strip_internal_tags(%{"tag" => tags} = object) do
975 tags = Enum.filter(tags, fn x -> is_map(x) end)
976
977 Map.put(object, "tag", tags)
978 end
979
980 defp strip_internal_tags(object), do: object
981
982 def perform(:user_upgrade, user) do
983 # we pass a fake user so that the followers collection is stripped away
984 old_follower_address = User.ap_followers(%User{nickname: user.nickname})
985
986 from(
987 a in Activity,
988 where: ^old_follower_address in a.recipients,
989 update: [
990 set: [
991 recipients:
992 fragment(
993 "array_replace(?,?,?)",
994 a.recipients,
995 ^old_follower_address,
996 ^user.follower_address
997 )
998 ]
999 ]
1000 )
1001 |> Repo.update_all([])
1002 end
1003
1004 def upgrade_user_from_ap_id(ap_id) do
1005 with %User{local: false} = user <- User.get_cached_by_ap_id(ap_id),
1006 {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id),
1007 {:ok, user} <- update_user(user, data) do
1008 {:ok, _pid} = Task.start(fn -> ActivityPub.pinned_fetch_task(user) end)
1009 TransmogrifierWorker.enqueue("user_upgrade", %{"user_id" => user.id})
1010 {:ok, user}
1011 else
1012 %User{} = user -> {:ok, user}
1013 e -> e
1014 end
1015 end
1016
1017 defp update_user(user, data) do
1018 user
1019 |> User.remote_user_changeset(data)
1020 |> User.update_and_set_cache()
1021 end
1022
1023 def maybe_fix_user_url(%{"url" => url} = data) when is_map(url) do
1024 Map.put(data, "url", url["href"])
1025 end
1026
1027 def maybe_fix_user_url(data), do: data
1028
1029 def maybe_fix_user_object(data), do: maybe_fix_user_url(data)
1030 end