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