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