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