projects / akkoma / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merging with develop
[akkoma] / lib / pleroma / web / activity_pub / activity_pub.ex
1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
4
5 defmodule Pleroma.Web.ActivityPub.ActivityPub do
6 alias Pleroma.Activity
7 alias Pleroma.Instances
8 alias Pleroma.Notification
9 alias Pleroma.Object
10 alias Pleroma.Object.Fetcher
11 alias Pleroma.Pagination
12 alias Pleroma.Repo
13 alias Pleroma.Upload
14 alias Pleroma.User
15 alias Pleroma.Web.ActivityPub.MRF
16 alias Pleroma.Web.ActivityPub.Transmogrifier
17 alias Pleroma.Web.Federator
18 alias Pleroma.Web.WebFinger
19
20 import Ecto.Query
21 import Pleroma.Web.ActivityPub.Utils
22 import Pleroma.Web.ActivityPub.Visibility
23
24 require Logger
25
26 @httpoison Application.get_env(:pleroma, :httpoison)
27
28 # For Announce activities, we filter the recipients based on following status for any actors
29 # that match actual users. See issue #164 for more information about why this is necessary.
30 defp get_recipients(%{"type" => "Announce"} = data) do
31 to = data["to"] || []
32 cc = data["cc"] || []
33 actor = User.get_cached_by_ap_id(data["actor"])
34
35 recipients =
36 (to ++ cc)
37 |> Enum.filter(fn recipient ->
38 case User.get_cached_by_ap_id(recipient) do
39 nil ->
40 true
41
42 user ->
43 User.following?(user, actor)
44 end
45 end)
46
47 {recipients, to, cc}
48 end
49
50 defp get_recipients(%{"type" => "Create"} = data) do
51 to = data["to"] || []
52 cc = data["cc"] || []
53 actor = data["actor"] || []
54 recipients = (to ++ cc ++ [actor]) |> Enum.uniq()
55 {recipients, to, cc}
56 end
57
58 defp get_recipients(data) do
59 to = data["to"] || []
60 cc = data["cc"] || []
61 recipients = to ++ cc
62 {recipients, to, cc}
63 end
64
65 defp check_actor_is_active(actor) do
66 if not is_nil(actor) do
67 with user <- User.get_cached_by_ap_id(actor),
68 false <- user.info.deactivated do
69 :ok
70 else
71 _e -> :reject
72 end
73 else
74 :ok
75 end
76 end
77
78 defp check_remote_limit(%{"object" => %{"content" => content}}) when not is_nil(content) do
79 limit = Pleroma.Config.get([:instance, :remote_limit])
80 String.length(content) <= limit
81 end
82
83 defp check_remote_limit(_), do: true
84
85 def increase_note_count_if_public(actor, object) do
86 if is_public?(object), do: User.increase_note_count(actor), else: {:ok, actor}
87 end
88
89 def decrease_note_count_if_public(actor, object) do
90 if is_public?(object), do: User.decrease_note_count(actor), else: {:ok, actor}
91 end
92
93 def increase_replies_count_if_reply(%{
94 "object" => %{"inReplyTo" => reply_ap_id} = object,
95 "type" => "Create"
96 }) do
97 if is_public?(object) do
98 Object.increase_replies_count(reply_ap_id)
99 end
100 end
101
102 def increase_replies_count_if_reply(_create_data), do: :noop
103
104 def decrease_replies_count_if_reply(%Object{
105 data: %{"inReplyTo" => reply_ap_id} = object
106 }) do
107 if is_public?(object) do
108 Object.decrease_replies_count(reply_ap_id)
109 end
110 end
111
112 def decrease_replies_count_if_reply(_object), do: :noop
113
114 def insert(map, local \\ true, fake \\ false) when is_map(map) do
115 with nil <- Activity.normalize(map),
116 map <- lazy_put_activity_defaults(map, fake),
117 :ok <- check_actor_is_active(map["actor"]),
118 {_, true} <- {:remote_limit_error, check_remote_limit(map)},
119 {:ok, map} <- MRF.filter(map),
120 {recipients, _, _} = get_recipients(map),
121 {:fake, false, map, recipients} <- {:fake, fake, map, recipients},
122 {:ok, map, object} <- insert_full_object(map) do
123 {:ok, activity} =
124 Repo.insert(%Activity{
125 data: map,
126 local: local,
127 actor: map["actor"],
128 recipients: recipients
129 })
130
131 # Splice in the child object if we have one.
132 activity =
133 if !is_nil(object) do
134 Map.put(activity, :object, object)
135 else
136 activity
137 end
138
139 Task.start(fn ->
140 Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
141 end)
142
143 Notification.create_notifications(activity)
144 stream_out(activity)
145 {:ok, activity}
146 else
147 %Activity{} = activity ->
148 {:ok, activity}
149
150 {:fake, true, map, recipients} ->
151 activity = %Activity{
152 data: map,
153 local: local,
154 actor: map["actor"],
155 recipients: recipients,
156 id: "pleroma:fakeid"
157 }
158
159 Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
160 {:ok, activity}
161
162 error ->
163 {:error, error}
164 end
165 end
166
167 def stream_out(activity) do
168 public = "https://www.w3.org/ns/activitystreams#Public"
169
170 if activity.data["type"] in ["Create", "Announce", "Delete"] do
171 Pleroma.Web.Streamer.stream("user", activity)
172 Pleroma.Web.Streamer.stream("list", activity)
173
174 if Enum.member?(activity.data["to"], public) do
175 Pleroma.Web.Streamer.stream("public", activity)
176
177 if activity.local do
178 Pleroma.Web.Streamer.stream("public:local", activity)
179 end
180
181 if activity.data["type"] in ["Create"] do
182 object = Object.normalize(activity)
183
184 object.data
185 |> Map.get("tag", [])
186 |> Enum.filter(fn tag -> is_bitstring(tag) end)
187 |> Enum.each(fn tag -> Pleroma.Web.Streamer.stream("hashtag:" <> tag, activity) end)
188
189 if object.data["attachment"] != [] do
190 Pleroma.Web.Streamer.stream("public:media", activity)
191
192 if activity.local do
193 Pleroma.Web.Streamer.stream("public:local:media", activity)
194 end
195 end
196 end
197 else
198 if !Enum.member?(activity.data["cc"] || [], public) &&
199 !Enum.member?(
200 activity.data["to"],
201 User.get_cached_by_ap_id(activity.data["actor"]).follower_address
202 ),
203 do: Pleroma.Web.Streamer.stream("direct", activity)
204 end
205 end
206 end
207
208 def create(%{to: to, actor: actor, context: context, object: object} = params, fake \\ false) do
209 additional = params[:additional] || %{}
210 # only accept false as false value
211 local = !(params[:local] == false)
212 published = params[:published]
213
214 with create_data <-
215 make_create_data(
216 %{to: to, actor: actor, published: published, context: context, object: object},
217 additional
218 ),
219 {:ok, activity} <- insert(create_data, local, fake),
220 {:fake, false, activity} <- {:fake, fake, activity},
221 _ <- increase_replies_count_if_reply(create_data),
222 # Changing note count prior to enqueuing federation task in order to avoid
223 # race conditions on updating user.info
224 {:ok, _actor} <- increase_note_count_if_public(actor, activity),
225 :ok <- maybe_federate(activity) do
226 {:ok, activity}
227 else
228 {:fake, true, activity} ->
229 {:ok, activity}
230 end
231 end
232
233 def accept(%{to: to, actor: actor, object: object} = params) do
234 # only accept false as false value
235 local = !(params[:local] == false)
236
237 with data <- %{"to" => to, "type" => "Accept", "actor" => actor.ap_id, "object" => object},
238 {:ok, activity} <- insert(data, local),
239 :ok <- maybe_federate(activity) do
240 {:ok, activity}
241 end
242 end
243
244 def reject(%{to: to, actor: actor, object: object} = params) do
245 # only accept false as false value
246 local = !(params[:local] == false)
247
248 with data <- %{"to" => to, "type" => "Reject", "actor" => actor.ap_id, "object" => object},
249 {:ok, activity} <- insert(data, local),
250 :ok <- maybe_federate(activity) do
251 {:ok, activity}
252 end
253 end
254
255 def update(%{to: to, cc: cc, actor: actor, object: object} = params) do
256 # only accept false as false value
257 local = !(params[:local] == false)
258
259 with data <- %{
260 "to" => to,
261 "cc" => cc,
262 "type" => "Update",
263 "actor" => actor,
264 "object" => object
265 },
266 {:ok, activity} <- insert(data, local),
267 :ok <- maybe_federate(activity) do
268 {:ok, activity}
269 end
270 end
271
272 # TODO: This is weird, maybe we shouldn't check here if we can make the activity.
273 def like(
274 %User{ap_id: ap_id} = user,
275 %Object{data: %{"id" => _}} = object,
276 activity_id \\ nil,
277 local \\ true
278 ) do
279 with nil <- get_existing_like(ap_id, object),
280 like_data <- make_like_data(user, object, activity_id),
281 {:ok, activity} <- insert(like_data, local),
282 {:ok, object} <- add_like_to_object(activity, object),
283 :ok <- maybe_federate(activity) do
284 {:ok, activity, object}
285 else
286 %Activity{} = activity -> {:ok, activity, object}
287 error -> {:error, error}
288 end
289 end
290
291 def unlike(
292 %User{} = actor,
293 %Object{} = object,
294 activity_id \\ nil,
295 local \\ true
296 ) do
297 with %Activity{} = like_activity <- get_existing_like(actor.ap_id, object),
298 unlike_data <- make_unlike_data(actor, like_activity, activity_id),
299 {:ok, unlike_activity} <- insert(unlike_data, local),
300 {:ok, _activity} <- Repo.delete(like_activity),
301 {:ok, object} <- remove_like_from_object(like_activity, object),
302 :ok <- maybe_federate(unlike_activity) do
303 {:ok, unlike_activity, like_activity, object}
304 else
305 _e -> {:ok, object}
306 end
307 end
308
309 def announce(
310 %User{ap_id: _} = user,
311 %Object{data: %{"id" => _}} = object,
312 activity_id \\ nil,
313 local \\ true,
314 public \\ true
315 ) do
316 with true <- is_public?(object),
317 announce_data <- make_announce_data(user, object, activity_id, public),
318 {:ok, activity} <- insert(announce_data, local),
319 {:ok, object} <- add_announce_to_object(activity, object),
320 :ok <- maybe_federate(activity) do
321 {:ok, activity, object}
322 else
323 error -> {:error, error}
324 end
325 end
326
327 def unannounce(
328 %User{} = actor,
329 %Object{} = object,
330 activity_id \\ nil,
331 local \\ true
332 ) do
333 with %Activity{} = announce_activity <- get_existing_announce(actor.ap_id, object),
334 unannounce_data <- make_unannounce_data(actor, announce_activity, activity_id),
335 {:ok, unannounce_activity} <- insert(unannounce_data, local),
336 :ok <- maybe_federate(unannounce_activity),
337 {:ok, _activity} <- Repo.delete(announce_activity),
338 {:ok, object} <- remove_announce_from_object(announce_activity, object) do
339 {:ok, unannounce_activity, object}
340 else
341 _e -> {:ok, object}
342 end
343 end
344
345 def follow(follower, followed, activity_id \\ nil, local \\ true) do
346 with data <- make_follow_data(follower, followed, activity_id),
347 {:ok, activity} <- insert(data, local),
348 :ok <- maybe_federate(activity) do
349 {:ok, activity}
350 end
351 end
352
353 def unfollow(follower, followed, activity_id \\ nil, local \\ true) do
354 with %Activity{} = follow_activity <- fetch_latest_follow(follower, followed),
355 {:ok, follow_activity} <- update_follow_state(follow_activity, "cancelled"),
356 unfollow_data <- make_unfollow_data(follower, followed, follow_activity, activity_id),
357 {:ok, activity} <- insert(unfollow_data, local),
358 :ok <- maybe_federate(activity) do
359 {:ok, activity}
360 end
361 end
362
363 def delete(%Object{data: %{"id" => id, "actor" => actor}} = object, local \\ true) do
364 user = User.get_cached_by_ap_id(actor)
365 to = (object.data["to"] || []) ++ (object.data["cc"] || [])
366
367 with {:ok, object, activity} <- Object.delete(object),
368 data <- %{
369 "type" => "Delete",
370 "actor" => actor,
371 "object" => id,
372 "to" => to,
373 "deleted_activity_id" => activity && activity.id
374 },
375 {:ok, activity} <- insert(data, local),
376 _ <- decrease_replies_count_if_reply(object),
377 # Changing note count prior to enqueuing federation task in order to avoid
378 # race conditions on updating user.info
379 {:ok, _actor} <- decrease_note_count_if_public(user, object),
380 :ok <- maybe_federate(activity) do
381 {:ok, activity}
382 end
383 end
384
385 def block(blocker, blocked, activity_id \\ nil, local \\ true) do
386 ap_config = Application.get_env(:pleroma, :activitypub)
387 unfollow_blocked = Keyword.get(ap_config, :unfollow_blocked)
388 outgoing_blocks = Keyword.get(ap_config, :outgoing_blocks)
389
390 with true <- unfollow_blocked do
391 follow_activity = fetch_latest_follow(blocker, blocked)
392
393 if follow_activity do
394 unfollow(blocker, blocked, nil, local)
395 end
396 end
397
398 with true <- outgoing_blocks,
399 block_data <- make_block_data(blocker, blocked, activity_id),
400 {:ok, activity} <- insert(block_data, local),
401 :ok <- maybe_federate(activity) do
402 {:ok, activity}
403 else
404 _e -> {:ok, nil}
405 end
406 end
407
408 def unblock(blocker, blocked, activity_id \\ nil, local \\ true) do
409 with %Activity{} = block_activity <- fetch_latest_block(blocker, blocked),
410 unblock_data <- make_unblock_data(blocker, blocked, block_activity, activity_id),
411 {:ok, activity} <- insert(unblock_data, local),
412 :ok <- maybe_federate(activity) do
413 {:ok, activity}
414 end
415 end
416
417 def flag(
418 %{
419 actor: actor,
420 context: context,
421 account: account,
422 statuses: statuses,
423 content: content
424 } = params
425 ) do
426 # only accept false as false value
427 local = !(params[:local] == false)
428 forward = !(params[:forward] == false)
429
430 additional = params[:additional] || %{}
431
432 params = %{
433 actor: actor,
434 context: context,
435 account: account,
436 statuses: statuses,
437 content: content
438 }
439
440 additional =
441 if forward do
442 Map.merge(additional, %{"to" => [], "cc" => [account.ap_id]})
443 else
444 Map.merge(additional, %{"to" => [], "cc" => []})
445 end
446
447 with flag_data <- make_flag_data(params, additional),
448 {:ok, activity} <- insert(flag_data, local),
449 :ok <- maybe_federate(activity) do
450 Enum.each(User.all_superusers(), fn superuser ->
451 superuser
452 |> Pleroma.Emails.AdminEmail.report(actor, account, statuses, content)
453 |> Pleroma.Emails.Mailer.deliver_async()
454 end)
455
456 {:ok, activity}
457 end
458 end
459
460 def fetch_activities_for_context(context, opts \\ %{}) do
461 public = ["https://www.w3.org/ns/activitystreams#Public"]
462
463 recipients =
464 if opts["user"], do: [opts["user"].ap_id | opts["user"].following] ++ public, else: public
465
466 query = from(activity in Activity)
467
468 query =
469 query
470 |> restrict_blocked(opts)
471 |> restrict_recipients(recipients, opts["user"])
472
473 query =
474 from(
475 activity in query,
476 where:
477 fragment(
478 "?->>'type' = ? and ?->>'context' = ?",
479 activity.data,
480 "Create",
481 activity.data,
482 ^context
483 ),
484 order_by: [desc: :id]
485 )
486 |> Activity.with_preloaded_object()
487
488 Repo.all(query)
489 end
490
491 def fetch_public_activities(opts \\ %{}) do
492 q = fetch_activities_query(["https://www.w3.org/ns/activitystreams#Public"], opts)
493
494 q
495 |> restrict_unlisted()
496 |> Pagination.fetch_paginated(opts)
497 |> Enum.reverse()
498 end
499
500 @valid_visibilities ~w[direct unlisted public private]
501
502 defp restrict_visibility(query, %{visibility: visibility})
503 when is_list(visibility) do
504 if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
505 query =
506 from(
507 a in query,
508 where:
509 fragment(
510 "activity_visibility(?, ?, ?) = ANY (?)",
511 a.actor,
512 a.recipients,
513 a.data,
514 ^visibility
515 )
516 )
517
518 Ecto.Adapters.SQL.to_sql(:all, Repo, query)
519
520 query
521 else
522 Logger.error("Could not restrict visibility to #{visibility}")
523 end
524 end
525
526 defp restrict_visibility(query, %{visibility: visibility})
527 when visibility in @valid_visibilities do
528 query =
529 from(
530 a in query,
531 where:
532 fragment("activity_visibility(?, ?, ?) = ?", a.actor, a.recipients, a.data, ^visibility)
533 )
534
535 Ecto.Adapters.SQL.to_sql(:all, Repo, query)
536
537 query
538 end
539
540 defp restrict_visibility(_query, %{visibility: visibility})
541 when visibility not in @valid_visibilities do
542 Logger.error("Could not restrict visibility to #{visibility}")
543 end
544
545 defp restrict_visibility(query, _visibility), do: query
546
547 def fetch_user_activities(user, reading_user, params \\ %{}) do
548 params =
549 params
550 |> Map.put("type", ["Create", "Announce"])
551 |> Map.put("actor_id", user.ap_id)
552 |> Map.put("whole_db", true)
553 |> Map.put("pinned_activity_ids", user.info.pinned_activities)
554
555 recipients =
556 if reading_user do
557 ["https://www.w3.org/ns/activitystreams#Public"] ++
558 [reading_user.ap_id | reading_user.following]
559 else
560 ["https://www.w3.org/ns/activitystreams#Public"]
561 end
562
563 fetch_activities(recipients, params)
564 |> Enum.reverse()
565 end
566
567 defp restrict_since(query, %{"since_id" => ""}), do: query
568
569 defp restrict_since(query, %{"since_id" => since_id}) do
570 from(activity in query, where: activity.id > ^since_id)
571 end
572
573 defp restrict_since(query, _), do: query
574
575 defp restrict_tag_reject(_query, %{"tag_reject" => _tag_reject, "skip_preload" => true}) do
576 raise "Can't use the child object without preloading!"
577 end
578
579 defp restrict_tag_reject(query, %{"tag_reject" => tag_reject})
580 when is_list(tag_reject) and tag_reject != [] do
581 from(
582 [_activity, object] in query,
583 where: fragment("not (?)->'tag' \\?| (?)", object.data, ^tag_reject)
584 )
585 end
586
587 defp restrict_tag_reject(query, _), do: query
588
589 defp restrict_tag_all(_query, %{"tag_all" => _tag_all, "skip_preload" => true}) do
590 raise "Can't use the child object without preloading!"
591 end
592
593 defp restrict_tag_all(query, %{"tag_all" => tag_all})
594 when is_list(tag_all) and tag_all != [] do
595 from(
596 [_activity, object] in query,
597 where: fragment("(?)->'tag' \\?& (?)", object.data, ^tag_all)
598 )
599 end
600
601 defp restrict_tag_all(query, _), do: query
602
603 defp restrict_tag(_query, %{"tag" => _tag, "skip_preload" => true}) do
604 raise "Can't use the child object without preloading!"
605 end
606
607 defp restrict_tag(query, %{"tag" => tag}) when is_list(tag) do
608 from(
609 [_activity, object] in query,
610 where: fragment("(?)->'tag' \\?| (?)", object.data, ^tag)
611 )
612 end
613
614 defp restrict_tag(query, %{"tag" => tag}) when is_binary(tag) do
615 from(
616 [_activity, object] in query,
617 where: fragment("(?)->'tag' \\? (?)", object.data, ^tag)
618 )
619 end
620
621 defp restrict_tag(query, _), do: query
622
623 defp restrict_to_cc(query, recipients_to, recipients_cc) do
624 from(
625 activity in query,
626 where:
627 fragment(
628 "(?->'to' \\?| ?) or (?->'cc' \\?| ?)",
629 activity.data,
630 ^recipients_to,
631 activity.data,
632 ^recipients_cc
633 )
634 )
635 end
636
637 defp restrict_recipients(query, [], _user), do: query
638
639 defp restrict_recipients(query, recipients, nil) do
640 from(activity in query, where: fragment("? && ?", ^recipients, activity.recipients))
641 end
642
643 defp restrict_recipients(query, recipients, user) do
644 from(
645 activity in query,
646 where: fragment("? && ?", ^recipients, activity.recipients),
647 or_where: activity.actor == ^user.ap_id
648 )
649 end
650
651 defp restrict_local(query, %{"local_only" => true}) do
652 from(activity in query, where: activity.local == true)
653 end
654
655 defp restrict_local(query, _), do: query
656
657 defp restrict_actor(query, %{"actor_id" => actor_id}) do
658 from(activity in query, where: activity.actor == ^actor_id)
659 end
660
661 defp restrict_actor(query, _), do: query
662
663 defp restrict_type(query, %{"type" => type}) when is_binary(type) do
664 from(activity in query, where: fragment("?->>'type' = ?", activity.data, ^type))
665 end
666
667 defp restrict_type(query, %{"type" => type}) do
668 from(activity in query, where: fragment("?->>'type' = ANY(?)", activity.data, ^type))
669 end
670
671 defp restrict_type(query, _), do: query
672
673 defp restrict_favorited_by(query, %{"favorited_by" => ap_id}) do
674 from(
675 activity in query,
676 where: fragment(~s(? <@ (? #> '{"object","likes"}'\)), ^ap_id, activity.data)
677 )
678 end
679
680 defp restrict_favorited_by(query, _), do: query
681
682 defp restrict_media(_query, %{"only_media" => _val, "skip_preload" => true}) do
683 raise "Can't use the child object without preloading!"
684 end
685
686 defp restrict_media(query, %{"only_media" => val}) when val == "true" or val == "1" do
687 from(
688 [_activity, object] in query,
689 where: fragment("not (?)->'attachment' = (?)", object.data, ^[])
690 )
691 end
692
693 defp restrict_media(query, _), do: query
694
695 defp restrict_replies(query, %{"exclude_replies" => val}) when val == "true" or val == "1" do
696 from(
697 activity in query,
698 where: fragment("?->'object'->>'inReplyTo' is null", activity.data)
699 )
700 end
701
702 defp restrict_replies(query, _), do: query
703
704 defp restrict_reblogs(query, %{"exclude_reblogs" => val}) when val == "true" or val == "1" do
705 from(activity in query, where: fragment("?->>'type' != 'Announce'", activity.data))
706 end
707
708 defp restrict_reblogs(query, _), do: query
709
710 defp restrict_muted(query, %{"with_muted" => val}) when val in [true, "true", "1"], do: query
711
712 defp restrict_muted(query, %{"muting_user" => %User{info: info}}) do
713 mutes = info.mutes
714
715 from(
716 activity in query,
717 where: fragment("not (? = ANY(?))", activity.actor, ^mutes),
718 where: fragment("not (?->'to' \\?| ?)", activity.data, ^mutes)
719 )
720 end
721
722 defp restrict_muted(query, _), do: query
723
724 defp restrict_blocked(query, %{"blocking_user" => %User{info: info}}) do
725 blocks = info.blocks || []
726 domain_blocks = info.domain_blocks || []
727
728 from(
729 activity in query,
730 where: fragment("not (? = ANY(?))", activity.actor, ^blocks),
731 where: fragment("not (? && ?)", activity.recipients, ^blocks),
732 where:
733 fragment(
734 "not (?->>'type' = 'Announce' and ?->'to' \\?| ?)",
735 activity.data,
736 activity.data,
737 ^blocks
738 ),
739 where: fragment("not (split_part(?, '/', 3) = ANY(?))", activity.actor, ^domain_blocks)
740 )
741 end
742
743 defp restrict_blocked(query, _), do: query
744
745 defp restrict_unlisted(query) do
746 from(
747 activity in query,
748 where:
749 fragment(
750 "not (coalesce(?->'cc', '{}'::jsonb) \\?| ?)",
751 activity.data,
752 ^["https://www.w3.org/ns/activitystreams#Public"]
753 )
754 )
755 end
756
757 defp restrict_pinned(query, %{"pinned" => "true", "pinned_activity_ids" => ids}) do
758 from(activity in query, where: activity.id in ^ids)
759 end
760
761 defp restrict_pinned(query, _), do: query
762
763 defp restrict_muted_reblogs(query, %{"muting_user" => %User{info: info}}) do
764 muted_reblogs = info.muted_reblogs || []
765
766 from(
767 activity in query,
768 where:
769 fragment(
770 "not ( ?->>'type' = 'Announce' and ? = ANY(?))",
771 activity.data,
772 activity.actor,
773 ^muted_reblogs
774 )
775 )
776 end
777
778 defp restrict_muted_reblogs(query, _), do: query
779
780 defp maybe_preload_objects(query, %{"skip_preload" => true}), do: query
781
782 defp maybe_preload_objects(query, _) do
783 query
784 |> Activity.with_preloaded_object()
785 end
786
787 def fetch_activities_query(recipients, opts \\ %{}) do
788 base_query = from(activity in Activity)
789
790 base_query
791 |> maybe_preload_objects(opts)
792 |> restrict_recipients(recipients, opts["user"])
793 |> restrict_tag(opts)
794 |> restrict_tag_reject(opts)
795 |> restrict_tag_all(opts)
796 |> restrict_since(opts)
797 |> restrict_local(opts)
798 |> restrict_actor(opts)
799 |> restrict_type(opts)
800 |> restrict_favorited_by(opts)
801 |> restrict_blocked(opts)
802 |> restrict_muted(opts)
803 |> restrict_media(opts)
804 |> restrict_visibility(opts)
805 |> restrict_replies(opts)
806 |> restrict_reblogs(opts)
807 |> restrict_pinned(opts)
808 |> restrict_muted_reblogs(opts)
809 end
810
811 def fetch_activities(recipients, opts \\ %{}) do
812 fetch_activities_query(recipients, opts)
813 |> Pagination.fetch_paginated(opts)
814 |> Enum.reverse()
815 end
816
817 def fetch_activities_bounded(recipients_to, recipients_cc, opts \\ %{}) do
818 fetch_activities_query([], opts)
819 |> restrict_to_cc(recipients_to, recipients_cc)
820 |> Pagination.fetch_paginated(opts)
821 |> Enum.reverse()
822 end
823
824 def upload(file, opts \\ []) do
825 with {:ok, data} <- Upload.store(file, opts) do
826 obj_data =
827 if opts[:actor] do
828 Map.put(data, "actor", opts[:actor])
829 else
830 data
831 end
832
833 Repo.insert(%Object{data: obj_data})
834 end
835 end
836
837 def user_data_from_user_object(data) do
838 avatar =
839 data["icon"]["url"] &&
840 %{
841 "type" => "Image",
842 "url" => [%{"href" => data["icon"]["url"]}]
843 }
844
845 banner =
846 data["image"]["url"] &&
847 %{
848 "type" => "Image",
849 "url" => [%{"href" => data["image"]["url"]}]
850 }
851
852 locked = data["manuallyApprovesFollowers"] || false
853 data = Transmogrifier.maybe_fix_user_object(data)
854
855 user_data = %{
856 ap_id: data["id"],
857 info: %{
858 "ap_enabled" => true,
859 "source_data" => data,
860 "banner" => banner,
861 "locked" => locked
862 },
863 avatar: avatar,
864 name: data["name"],
865 follower_address: data["followers"],
866 bio: data["summary"]
867 }
868
869 # nickname can be nil because of virtual actors
870 user_data =
871 if data["preferredUsername"] do
872 Map.put(
873 user_data,
874 :nickname,
875 "#{data["preferredUsername"]}@#{URI.parse(data["id"]).host}"
876 )
877 else
878 Map.put(user_data, :nickname, nil)
879 end
880
881 {:ok, user_data}
882 end
883
884 def fetch_and_prepare_user_from_ap_id(ap_id) do
885 with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id) do
886 user_data_from_user_object(data)
887 else
888 e -> Logger.error("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
889 end
890 end
891
892 def make_user_from_ap_id(ap_id) do
893 if _user = User.get_cached_by_ap_id(ap_id) do
894 Transmogrifier.upgrade_user_from_ap_id(ap_id)
895 else
896 with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id) do
897 User.insert_or_update_user(data)
898 else
899 e -> {:error, e}
900 end
901 end
902 end
903
904 def make_user_from_nickname(nickname) do
905 with {:ok, %{"ap_id" => ap_id}} when not is_nil(ap_id) <- WebFinger.finger(nickname) do
906 make_user_from_ap_id(ap_id)
907 else
908 _e -> {:error, "No AP id in WebFinger"}
909 end
910 end
911
912 def should_federate?(inbox, public) do
913 if public do
914 true
915 else
916 inbox_info = URI.parse(inbox)
917 !Enum.member?(Pleroma.Config.get([:instance, :quarantined_instances], []), inbox_info.host)
918 end
919 end
920
921 def publish(actor, activity) do
922 remote_followers =
923 if actor.follower_address in activity.recipients do
924 {:ok, followers} = User.get_followers(actor)
925 followers |> Enum.filter(&(!&1.local))
926 else
927 []
928 end
929
930 public = is_public?(activity)
931
932 {:ok, data} = Transmogrifier.prepare_outgoing(activity.data)
933 json = Jason.encode!(data)
934
935 (Pleroma.Web.Salmon.remote_users(activity) ++ remote_followers)
936 |> Enum.filter(fn user -> User.ap_enabled?(user) end)
937 |> Enum.map(fn %{info: %{source_data: data}} ->
938 (is_map(data["endpoints"]) && Map.get(data["endpoints"], "sharedInbox")) || data["inbox"]
939 end)
940 |> Enum.uniq()
941 |> Enum.filter(fn inbox -> should_federate?(inbox, public) end)
942 |> Instances.filter_reachable()
943 |> Enum.each(fn {inbox, unreachable_since} ->
944 Federator.publish_single_ap(%{
945 inbox: inbox,
946 json: json,
947 actor: actor,
948 id: activity.data["id"],
949 unreachable_since: unreachable_since
950 })
951 end)
952 end
953
954 def publish_one(%{inbox: inbox, json: json, actor: actor, id: id} = params) do
955 Logger.info("Federating #{id} to #{inbox}")
956 host = URI.parse(inbox).host
957
958 digest = "SHA-256=" <> (:crypto.hash(:sha256, json) |> Base.encode64())
959
960 date =
961 NaiveDateTime.utc_now()
962 |> Timex.format!("{WDshort}, {0D} {Mshort} {YYYY} {h24}:{m}:{s} GMT")
963
964 signature =
965 Pleroma.Web.HTTPSignatures.sign(actor, %{
966 host: host,
967 "content-length": byte_size(json),
968 digest: digest,
969 date: date
970 })
971
972 with {:ok, %{status: code}} when code in 200..299 <-
973 result =
974 @httpoison.post(
975 inbox,
976 json,
977 [
978 {"Content-Type", "application/activity+json"},
979 {"Date", date},
980 {"signature", signature},
981 {"digest", digest}
982 ]
983 ) do
984 if !Map.has_key?(params, :unreachable_since) || params[:unreachable_since],
985 do: Instances.set_reachable(inbox)
986
987 result
988 else
989 {_post_result, response} ->
990 unless params[:unreachable_since], do: Instances.set_unreachable(inbox)
991 {:error, response}
992 end
993 end
994
995 # filter out broken threads
996 def contain_broken_threads(%Activity{} = activity, %User{} = user) do
997 entire_thread_visible_for_user?(activity, user)
998 end
999
1000 # do post-processing on a specific activity
1001 def contain_activity(%Activity{} = activity, %User{} = user) do
1002 contain_broken_threads(activity, user)
1003 end
1004
1005 # do post-processing on a timeline
1006 def contain_timeline(timeline, user) do
1007 timeline
1008 |> Enum.filter(fn activity ->
1009 contain_activity(activity, user)
1010 end)
1011 end
1012 end
Fork of https://akkoma.dev/AkkomaGang/akkoma.git