1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.Web.ActivityPub.ActivityPub do
7 alias Pleroma.Activity.Ir.Topics
8 alias Pleroma.ActivityExpiration
10 alias Pleroma.Conversation
11 alias Pleroma.Conversation.Participation
12 alias Pleroma.Notification
14 alias Pleroma.Object.Containment
15 alias Pleroma.Object.Fetcher
16 alias Pleroma.Pagination
20 alias Pleroma.Web.ActivityPub.MRF
21 alias Pleroma.Web.ActivityPub.Transmogrifier
22 alias Pleroma.Web.ActivityPub.Utils
23 alias Pleroma.Web.Streamer
24 alias Pleroma.Web.WebFinger
25 alias Pleroma.Workers.BackgroundWorker
28 import Pleroma.Web.ActivityPub.Utils
29 import Pleroma.Web.ActivityPub.Visibility
32 require Pleroma.Constants
34 # For Announce activities, we filter the recipients based on following status for any actors
35 # that match actual users. See issue #164 for more information about why this is necessary.
36 defp get_recipients(%{"type" => "Announce"} = data) do
37 to = Map.get(data, "to", [])
38 cc = Map.get(data, "cc", [])
39 bcc = Map.get(data, "bcc", [])
40 actor = User.get_cached_by_ap_id(data["actor"])
43 Enum.filter(Enum.concat([to, cc, bcc]), fn recipient ->
44 case User.get_cached_by_ap_id(recipient) do
46 user -> User.following?(user, actor)
53 defp get_recipients(%{"type" => "Create"} = data) do
54 to = Map.get(data, "to", [])
55 cc = Map.get(data, "cc", [])
56 bcc = Map.get(data, "bcc", [])
57 actor = Map.get(data, "actor", [])
58 recipients = [to, cc, bcc, [actor]] |> Enum.concat() |> Enum.uniq()
62 defp get_recipients(data) do
63 to = Map.get(data, "to", [])
64 cc = Map.get(data, "cc", [])
65 bcc = Map.get(data, "bcc", [])
66 recipients = Enum.concat([to, cc, bcc])
70 defp check_actor_is_active(actor) do
71 if not is_nil(actor) do
72 with user <- User.get_cached_by_ap_id(actor),
73 false <- user.deactivated do
83 defp check_remote_limit(%{"object" => %{"content" => content}}) when not is_nil(content) do
84 limit = Config.get([:instance, :remote_limit])
85 String.length(content) <= limit
88 defp check_remote_limit(_), do: true
90 def increase_note_count_if_public(actor, object) do
91 if is_public?(object), do: User.increase_note_count(actor), else: {:ok, actor}
94 def decrease_note_count_if_public(actor, object) do
95 if is_public?(object), do: User.decrease_note_count(actor), else: {:ok, actor}
98 def increase_replies_count_if_reply(%{
99 "object" => %{"inReplyTo" => reply_ap_id} = object,
102 if is_public?(object) do
103 Object.increase_replies_count(reply_ap_id)
107 def increase_replies_count_if_reply(_create_data), do: :noop
109 def decrease_replies_count_if_reply(%Object{
110 data: %{"inReplyTo" => reply_ap_id} = object
112 if is_public?(object) do
113 Object.decrease_replies_count(reply_ap_id)
117 def decrease_replies_count_if_reply(_object), do: :noop
119 def increase_poll_votes_if_vote(%{
120 "object" => %{"inReplyTo" => reply_ap_id, "name" => name},
123 Object.increase_vote_count(reply_ap_id, name)
126 def increase_poll_votes_if_vote(_create_data), do: :noop
128 def insert(map, local \\ true, fake \\ false, bypass_actor_check \\ false) when is_map(map) do
129 with nil <- Activity.normalize(map),
130 map <- lazy_put_activity_defaults(map, fake),
131 true <- bypass_actor_check || check_actor_is_active(map["actor"]),
132 {_, true} <- {:remote_limit_error, check_remote_limit(map)},
133 {:ok, map} <- MRF.filter(map),
134 {recipients, _, _} = get_recipients(map),
135 {:fake, false, map, recipients} <- {:fake, fake, map, recipients},
136 {:containment, :ok} <- {:containment, Containment.contain_child(map)},
137 {:ok, map, object} <- insert_full_object(map) do
143 recipients: recipients
146 |> maybe_create_activity_expiration()
148 # Splice in the child object if we have one.
150 if not is_nil(object) do
151 Map.put(activity, :object, object)
156 BackgroundWorker.enqueue("fetch_data_for_activity", %{"activity_id" => activity.id})
158 Notification.create_notifications(activity)
160 conversation = create_or_bump_conversation(activity, map["actor"])
161 participations = get_participations(conversation)
163 stream_out_participations(participations)
166 %Activity{} = activity ->
169 {:fake, true, map, recipients} ->
170 activity = %Activity{
174 recipients: recipients,
178 Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
186 defp maybe_create_activity_expiration({:ok, %{data: %{"expires_at" => expires_at}} = activity}) do
187 with {:ok, _} <- ActivityExpiration.create(activity, expires_at) do
192 defp maybe_create_activity_expiration(result), do: result
194 defp create_or_bump_conversation(activity, actor) do
195 with {:ok, conversation} <- Conversation.create_or_bump_for(activity),
196 %User{} = user <- User.get_cached_by_ap_id(actor),
197 Participation.mark_as_read(user, conversation) do
202 defp get_participations({:ok, conversation}) do
204 |> Repo.preload(:participations, force: true)
205 |> Map.get(:participations)
208 defp get_participations(_), do: []
210 def stream_out_participations(participations) do
213 |> Repo.preload(:user)
215 Streamer.stream("participation", participations)
218 def stream_out_participations(%Object{data: %{"context" => context}}, user) do
219 with %Conversation{} = conversation <- Conversation.get_for_ap_id(context),
220 conversation = Repo.preload(conversation, :participations),
222 fetch_latest_activity_id_for_context(conversation.ap_id, %{
224 "blocking_user" => user
226 if last_activity_id do
227 stream_out_participations(conversation.participations)
232 def stream_out_participations(_, _), do: :noop
234 def stream_out(%Activity{data: %{"type" => data_type}} = activity)
235 when data_type in ["Create", "Announce", "Delete"] do
237 |> Topics.get_activity_topics()
238 |> Streamer.stream(activity)
241 def stream_out(_activity) do
245 def create(%{to: to, actor: actor, context: context, object: object} = params, fake \\ false) do
246 additional = params[:additional] || %{}
247 # only accept false as false value
248 local = !(params[:local] == false)
249 published = params[:published]
250 quick_insert? = Pleroma.Config.get([:env]) == :benchmark
254 %{to: to, actor: actor, published: published, context: context, object: object},
257 {:ok, activity} <- insert(create_data, local, fake),
258 {:fake, false, activity} <- {:fake, fake, activity},
259 _ <- increase_replies_count_if_reply(create_data),
260 _ <- increase_poll_votes_if_vote(create_data),
261 {:quick_insert, false, activity} <- {:quick_insert, quick_insert?, activity},
262 {:ok, _actor} <- increase_note_count_if_public(actor, activity),
263 :ok <- maybe_federate(activity) do
266 {:quick_insert, true, activity} ->
269 {:fake, true, activity} ->
277 def listen(%{to: to, actor: actor, context: context, object: object} = params) do
278 additional = params[:additional] || %{}
279 # only accept false as false value
280 local = !(params[:local] == false)
281 published = params[:published]
285 %{to: to, actor: actor, published: published, context: context, object: object},
288 {:ok, activity} <- insert(listen_data, local),
289 :ok <- maybe_federate(activity) do
297 def accept(params) do
298 accept_or_reject("Accept", params)
301 def reject(params) do
302 accept_or_reject("Reject", params)
305 def accept_or_reject(type, %{to: to, actor: actor, object: object} = params) do
306 local = Map.get(params, :local, true)
307 activity_id = Map.get(params, :activity_id, nil)
310 %{"to" => to, "type" => type, "actor" => actor.ap_id, "object" => object}
311 |> Utils.maybe_put("id", activity_id),
312 {:ok, activity} <- insert(data, local),
313 :ok <- maybe_federate(activity) do
318 def update(%{to: to, cc: cc, actor: actor, object: object} = params) do
319 local = !(params[:local] == false)
320 activity_id = params[:activity_id]
329 data <- Utils.maybe_put(data, "id", activity_id),
330 {:ok, activity} <- insert(data, local),
331 :ok <- maybe_federate(activity) do
336 def react_with_emoji(user, object, emoji, options \\ []) do
337 with local <- Keyword.get(options, :local, true),
338 activity_id <- Keyword.get(options, :activity_id, nil),
339 true <- Pleroma.Emoji.is_unicode_emoji?(emoji),
340 reaction_data <- make_emoji_reaction_data(user, object, emoji, activity_id),
341 {:ok, activity} <- insert(reaction_data, local),
342 {:ok, object} <- add_emoji_reaction_to_object(activity, object),
343 :ok <- maybe_federate(activity) do
344 {:ok, activity, object}
350 def unreact_with_emoji(user, reaction_id, options \\ []) do
351 with local <- Keyword.get(options, :local, true),
352 activity_id <- Keyword.get(options, :activity_id, nil),
353 user_ap_id <- user.ap_id,
354 %Activity{actor: ^user_ap_id} = reaction_activity <- Activity.get_by_ap_id(reaction_id),
355 object <- Object.normalize(reaction_activity),
356 unreact_data <- make_undo_data(user, reaction_activity, activity_id),
357 {:ok, activity} <- insert(unreact_data, local),
358 {:ok, object} <- remove_emoji_reaction_from_object(reaction_activity, object),
359 :ok <- maybe_federate(activity) do
360 {:ok, activity, object}
366 # TODO: This is weird, maybe we shouldn't check here if we can make the activity.
368 %User{ap_id: ap_id} = user,
369 %Object{data: %{"id" => _}} = object,
373 with nil <- get_existing_like(ap_id, object),
374 like_data <- make_like_data(user, object, activity_id),
375 {:ok, activity} <- insert(like_data, local),
376 {:ok, object} <- add_like_to_object(activity, object),
377 :ok <- maybe_federate(activity) do
378 {:ok, activity, object}
380 %Activity{} = activity -> {:ok, activity, object}
381 error -> {:error, error}
385 def unlike(%User{} = actor, %Object{} = object, activity_id \\ nil, local \\ true) do
386 with %Activity{} = like_activity <- get_existing_like(actor.ap_id, object),
387 unlike_data <- make_unlike_data(actor, like_activity, activity_id),
388 {:ok, unlike_activity} <- insert(unlike_data, local),
389 {:ok, _activity} <- Repo.delete(like_activity),
390 {:ok, object} <- remove_like_from_object(like_activity, object),
391 :ok <- maybe_federate(unlike_activity) do
392 {:ok, unlike_activity, like_activity, object}
399 %User{ap_id: _} = user,
400 %Object{data: %{"id" => _}} = object,
405 with true <- is_announceable?(object, user, public),
406 announce_data <- make_announce_data(user, object, activity_id, public),
407 {:ok, activity} <- insert(announce_data, local),
408 {:ok, object} <- add_announce_to_object(activity, object),
409 :ok <- maybe_federate(activity) do
410 {:ok, activity, object}
412 error -> {:error, error}
422 with %Activity{} = announce_activity <- get_existing_announce(actor.ap_id, object),
423 unannounce_data <- make_unannounce_data(actor, announce_activity, activity_id),
424 {:ok, unannounce_activity} <- insert(unannounce_data, local),
425 :ok <- maybe_federate(unannounce_activity),
426 {:ok, _activity} <- Repo.delete(announce_activity),
427 {:ok, object} <- remove_announce_from_object(announce_activity, object) do
428 {:ok, unannounce_activity, object}
434 def follow(follower, followed, activity_id \\ nil, local \\ true) do
435 with data <- make_follow_data(follower, followed, activity_id),
436 {:ok, activity} <- insert(data, local),
437 :ok <- maybe_federate(activity),
438 _ <- User.set_follow_state_cache(follower.ap_id, followed.ap_id, activity.data["state"]) do
443 def unfollow(follower, followed, activity_id \\ nil, local \\ true) do
444 with %Activity{} = follow_activity <- fetch_latest_follow(follower, followed),
445 {:ok, follow_activity} <- update_follow_state(follow_activity, "cancelled"),
446 unfollow_data <- make_unfollow_data(follower, followed, follow_activity, activity_id),
447 {:ok, activity} <- insert(unfollow_data, local),
448 :ok <- maybe_federate(activity) do
453 def delete(%User{ap_id: ap_id, follower_address: follower_address} = user) do
455 "to" => [follower_address],
458 "object" => %{"type" => "Person", "id" => ap_id}
460 {:ok, activity} <- insert(data, true, true, true),
461 :ok <- maybe_federate(activity) do
466 def delete(%Object{data: %{"id" => id, "actor" => actor}} = object, options \\ []) do
467 local = Keyword.get(options, :local, true)
468 activity_id = Keyword.get(options, :activity_id, nil)
469 actor = Keyword.get(options, :actor, actor)
471 user = User.get_cached_by_ap_id(actor)
472 to = (object.data["to"] || []) ++ (object.data["cc"] || [])
474 with create_activity <- Activity.get_create_by_object_ap_id(id),
481 "deleted_activity_id" => create_activity && create_activity.id
483 |> maybe_put("id", activity_id),
484 {:ok, activity} <- insert(data, local, false),
485 {:ok, object, _create_activity} <- Object.delete(object),
486 stream_out_participations(object, user),
487 _ <- decrease_replies_count_if_reply(object),
488 {:ok, _actor} <- decrease_note_count_if_public(user, object),
489 :ok <- maybe_federate(activity) do
494 @spec block(User.t(), User.t(), String.t() | nil, boolean) :: {:ok, Activity.t() | nil}
495 def block(blocker, blocked, activity_id \\ nil, local \\ true) do
496 outgoing_blocks = Config.get([:activitypub, :outgoing_blocks])
497 unfollow_blocked = Config.get([:activitypub, :unfollow_blocked])
499 if unfollow_blocked do
500 follow_activity = fetch_latest_follow(blocker, blocked)
501 if follow_activity, do: unfollow(blocker, blocked, nil, local)
504 with true <- outgoing_blocks,
505 block_data <- make_block_data(blocker, blocked, activity_id),
506 {:ok, activity} <- insert(block_data, local),
507 :ok <- maybe_federate(activity) do
514 def unblock(blocker, blocked, activity_id \\ nil, local \\ true) do
515 with %Activity{} = block_activity <- fetch_latest_block(blocker, blocked),
516 unblock_data <- make_unblock_data(blocker, blocked, block_activity, activity_id),
517 {:ok, activity} <- insert(unblock_data, local),
518 :ok <- maybe_federate(activity) do
523 @spec flag(map()) :: {:ok, Activity.t()} | any
533 # only accept false as false value
534 local = !(params[:local] == false)
535 forward = !(params[:forward] == false)
537 additional = params[:additional] || %{}
541 Map.merge(additional, %{"to" => [], "cc" => [account.ap_id]})
543 Map.merge(additional, %{"to" => [], "cc" => []})
546 with flag_data <- make_flag_data(params, additional),
547 {:ok, activity} <- insert(flag_data, local),
548 {:ok, stripped_activity} <- strip_report_status_data(activity),
549 :ok <- maybe_federate(stripped_activity) do
550 Enum.each(User.all_superusers(), fn superuser ->
552 |> Pleroma.Emails.AdminEmail.report(actor, account, statuses, content)
553 |> Pleroma.Emails.Mailer.deliver_async()
560 def move(%User{} = origin, %User{} = target, local \\ true) do
563 "actor" => origin.ap_id,
564 "object" => origin.ap_id,
565 "target" => target.ap_id
568 with true <- origin.ap_id in target.also_known_as,
569 {:ok, activity} <- insert(params, local) do
570 maybe_federate(activity)
572 BackgroundWorker.enqueue("move_following", %{
573 "origin_id" => origin.id,
574 "target_id" => target.id
579 false -> {:error, "Target account must have the origin in `alsoKnownAs`"}
584 defp fetch_activities_for_context_query(context, opts) do
585 public = [Pleroma.Constants.as_public()]
589 do: [opts["user"].ap_id | User.following(opts["user"])] ++ public,
592 from(activity in Activity)
593 |> maybe_preload_objects(opts)
594 |> maybe_preload_bookmarks(opts)
595 |> maybe_set_thread_muted_field(opts)
596 |> restrict_blocked(opts)
597 |> restrict_recipients(recipients, opts["user"])
601 "?->>'type' = ? and ?->>'context' = ?",
608 |> exclude_poll_votes(opts)
610 |> order_by([activity], desc: activity.id)
613 @spec fetch_activities_for_context(String.t(), keyword() | map()) :: [Activity.t()]
614 def fetch_activities_for_context(context, opts \\ %{}) do
616 |> fetch_activities_for_context_query(opts)
620 @spec fetch_latest_activity_id_for_context(String.t(), keyword() | map()) ::
621 FlakeId.Ecto.CompatType.t() | nil
622 def fetch_latest_activity_id_for_context(context, opts \\ %{}) do
624 |> fetch_activities_for_context_query(Map.merge(%{"skip_preload" => true}, opts))
630 def fetch_public_activities(opts \\ %{}, pagination \\ :keyset) do
631 opts = Map.drop(opts, ["user"])
633 [Pleroma.Constants.as_public()]
634 |> fetch_activities_query(opts)
635 |> restrict_unlisted()
636 |> Pagination.fetch_paginated(opts, pagination)
639 @valid_visibilities ~w[direct unlisted public private]
641 defp restrict_visibility(query, %{visibility: visibility})
642 when is_list(visibility) do
643 if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
649 "activity_visibility(?, ?, ?) = ANY (?)",
659 Logger.error("Could not restrict visibility to #{visibility}")
663 defp restrict_visibility(query, %{visibility: visibility})
664 when visibility in @valid_visibilities do
668 fragment("activity_visibility(?, ?, ?) = ?", a.actor, a.recipients, a.data, ^visibility)
672 defp restrict_visibility(_query, %{visibility: visibility})
673 when visibility not in @valid_visibilities do
674 Logger.error("Could not restrict visibility to #{visibility}")
677 defp restrict_visibility(query, _visibility), do: query
679 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
680 when is_list(visibility) do
681 if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
686 "activity_visibility(?, ?, ?) = ANY (?)",
694 Logger.error("Could not exclude visibility to #{visibility}")
699 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
700 when visibility in @valid_visibilities do
705 "activity_visibility(?, ?, ?) = ?",
714 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
715 when visibility not in @valid_visibilities do
716 Logger.error("Could not exclude visibility to #{visibility}")
720 defp exclude_visibility(query, _visibility), do: query
722 defp restrict_thread_visibility(query, _, %{skip_thread_containment: true} = _),
725 defp restrict_thread_visibility(
727 %{"user" => %User{skip_thread_containment: true}},
732 defp restrict_thread_visibility(query, %{"user" => %User{ap_id: ap_id}}, _) do
735 where: fragment("thread_visibility(?, (?)->>'id') = true", ^ap_id, a.data)
739 defp restrict_thread_visibility(query, _, _), do: query
741 def fetch_user_abstract_activities(user, reading_user, params \\ %{}) do
744 |> Map.put("user", reading_user)
745 |> Map.put("actor_id", user.ap_id)
748 user_activities_recipients(%{
749 "godmode" => params["godmode"],
750 "reading_user" => reading_user
753 fetch_activities(recipients, params)
757 def fetch_user_activities(user, reading_user, params \\ %{}) do
760 |> Map.put("type", ["Create", "Announce"])
761 |> Map.put("user", reading_user)
762 |> Map.put("actor_id", user.ap_id)
763 |> Map.put("pinned_activity_ids", user.pinned_activities)
766 if User.blocks?(reading_user, user) do
770 |> Map.put("blocking_user", reading_user)
771 |> Map.put("muting_user", reading_user)
775 user_activities_recipients(%{
776 "godmode" => params["godmode"],
777 "reading_user" => reading_user
780 fetch_activities(recipients, params)
784 def fetch_instance_activities(params) do
787 |> Map.put("type", ["Create", "Announce"])
788 |> Map.put("instance", params["instance"])
790 fetch_activities([Pleroma.Constants.as_public()], params, :offset)
794 defp user_activities_recipients(%{"godmode" => true}) do
798 defp user_activities_recipients(%{"reading_user" => reading_user}) do
800 [Pleroma.Constants.as_public()] ++ [reading_user.ap_id | User.following(reading_user)]
802 [Pleroma.Constants.as_public()]
806 defp restrict_since(query, %{"since_id" => ""}), do: query
808 defp restrict_since(query, %{"since_id" => since_id}) do
809 from(activity in query, where: activity.id > ^since_id)
812 defp restrict_since(query, _), do: query
814 defp restrict_tag_reject(_query, %{"tag_reject" => _tag_reject, "skip_preload" => true}) do
815 raise "Can't use the child object without preloading!"
818 defp restrict_tag_reject(query, %{"tag_reject" => tag_reject})
819 when is_list(tag_reject) and tag_reject != [] do
821 [_activity, object] in query,
822 where: fragment("not (?)->'tag' \\?| (?)", object.data, ^tag_reject)
826 defp restrict_tag_reject(query, _), do: query
828 defp restrict_tag_all(_query, %{"tag_all" => _tag_all, "skip_preload" => true}) do
829 raise "Can't use the child object without preloading!"
832 defp restrict_tag_all(query, %{"tag_all" => tag_all})
833 when is_list(tag_all) and tag_all != [] do
835 [_activity, object] in query,
836 where: fragment("(?)->'tag' \\?& (?)", object.data, ^tag_all)
840 defp restrict_tag_all(query, _), do: query
842 defp restrict_tag(_query, %{"tag" => _tag, "skip_preload" => true}) do
843 raise "Can't use the child object without preloading!"
846 defp restrict_tag(query, %{"tag" => tag}) when is_list(tag) do
848 [_activity, object] in query,
849 where: fragment("(?)->'tag' \\?| (?)", object.data, ^tag)
853 defp restrict_tag(query, %{"tag" => tag}) when is_binary(tag) do
855 [_activity, object] in query,
856 where: fragment("(?)->'tag' \\? (?)", object.data, ^tag)
860 defp restrict_tag(query, _), do: query
862 defp restrict_recipients(query, [], _user), do: query
864 defp restrict_recipients(query, recipients, nil) do
865 from(activity in query, where: fragment("? && ?", ^recipients, activity.recipients))
868 defp restrict_recipients(query, recipients, user) do
871 where: fragment("? && ?", ^recipients, activity.recipients),
872 or_where: activity.actor == ^user.ap_id
876 defp restrict_local(query, %{"local_only" => true}) do
877 from(activity in query, where: activity.local == true)
880 defp restrict_local(query, _), do: query
882 defp restrict_actor(query, %{"actor_id" => actor_id}) do
883 from(activity in query, where: activity.actor == ^actor_id)
886 defp restrict_actor(query, _), do: query
888 defp restrict_type(query, %{"type" => type}) when is_binary(type) do
889 from(activity in query, where: fragment("?->>'type' = ?", activity.data, ^type))
892 defp restrict_type(query, %{"type" => type}) do
893 from(activity in query, where: fragment("?->>'type' = ANY(?)", activity.data, ^type))
896 defp restrict_type(query, _), do: query
898 defp restrict_state(query, %{"state" => state}) do
899 from(activity in query, where: fragment("?->>'state' = ?", activity.data, ^state))
902 defp restrict_state(query, _), do: query
904 defp restrict_favorited_by(query, %{"favorited_by" => ap_id}) do
906 [_activity, object] in query,
907 where: fragment("(?)->'likes' \\? (?)", object.data, ^ap_id)
911 defp restrict_favorited_by(query, _), do: query
913 defp restrict_media(_query, %{"only_media" => _val, "skip_preload" => true}) do
914 raise "Can't use the child object without preloading!"
917 defp restrict_media(query, %{"only_media" => val}) when val == "true" or val == "1" do
919 [_activity, object] in query,
920 where: fragment("not (?)->'attachment' = (?)", object.data, ^[])
924 defp restrict_media(query, _), do: query
926 defp restrict_replies(query, %{"exclude_replies" => val}) when val == "true" or val == "1" do
928 [_activity, object] in query,
929 where: fragment("?->>'inReplyTo' is null", object.data)
933 defp restrict_replies(query, _), do: query
935 defp restrict_reblogs(query, %{"exclude_reblogs" => val}) when val == "true" or val == "1" do
936 from(activity in query, where: fragment("?->>'type' != 'Announce'", activity.data))
939 defp restrict_reblogs(query, _), do: query
941 defp restrict_muted(query, %{"with_muted" => val}) when val in [true, "true", "1"], do: query
943 defp restrict_muted(query, %{"muting_user" => %User{} = user} = opts) do
944 mutes = opts["muted_users_ap_ids"] || User.muted_users_ap_ids(user)
947 from([activity] in query,
948 where: fragment("not (? = ANY(?))", activity.actor, ^mutes),
949 where: fragment("not (?->'to' \\?| ?)", activity.data, ^mutes)
952 unless opts["skip_preload"] do
953 from([thread_mute: tm] in query, where: is_nil(tm.user_id))
959 defp restrict_muted(query, _), do: query
961 defp restrict_blocked(query, %{"blocking_user" => %User{} = user} = opts) do
962 blocked_ap_ids = opts["blocked_users_ap_ids"] || User.blocked_users_ap_ids(user)
963 domain_blocks = user.domain_blocks || []
965 following_ap_ids = User.get_friends_ap_ids(user)
968 if has_named_binding?(query, :object), do: query, else: Activity.with_joined_object(query)
971 [activity, object: o] in query,
972 where: fragment("not (? = ANY(?))", activity.actor, ^blocked_ap_ids),
973 where: fragment("not (? && ?)", activity.recipients, ^blocked_ap_ids),
976 "not (?->>'type' = 'Announce' and ?->'to' \\?| ?)",
983 "(not (split_part(?, '/', 3) = ANY(?))) or ? = ANY(?)",
991 "(not (split_part(?->>'actor', '/', 3) = ANY(?))) or (?->>'actor') = ANY(?)",
1000 defp restrict_blocked(query, _), do: query
1002 defp restrict_unlisted(query) do
1007 "not (coalesce(?->'cc', '{}'::jsonb) \\?| ?)",
1009 ^[Pleroma.Constants.as_public()]
1014 defp restrict_pinned(query, %{"pinned" => "true", "pinned_activity_ids" => ids}) do
1015 from(activity in query, where: activity.id in ^ids)
1018 defp restrict_pinned(query, _), do: query
1020 defp restrict_muted_reblogs(query, %{"muting_user" => %User{} = user} = opts) do
1021 muted_reblogs = opts["reblog_muted_users_ap_ids"] || User.reblog_muted_users_ap_ids(user)
1027 "not ( ?->>'type' = 'Announce' and ? = ANY(?))",
1035 defp restrict_muted_reblogs(query, _), do: query
1037 defp restrict_instance(query, %{"instance" => instance}) do
1042 where: fragment("? LIKE ?", u.nickname, ^"%@#{instance}")
1046 from(activity in query, where: activity.actor in ^users)
1049 defp restrict_instance(query, _), do: query
1051 defp exclude_poll_votes(query, %{"include_poll_votes" => true}), do: query
1053 defp exclude_poll_votes(query, _) do
1054 if has_named_binding?(query, :object) do
1055 from([activity, object: o] in query,
1056 where: fragment("not(?->>'type' = ?)", o.data, "Answer")
1063 defp exclude_id(query, %{"exclude_id" => id}) when is_binary(id) do
1064 from(activity in query, where: activity.id != ^id)
1067 defp exclude_id(query, _), do: query
1069 defp maybe_preload_objects(query, %{"skip_preload" => true}), do: query
1071 defp maybe_preload_objects(query, _) do
1073 |> Activity.with_preloaded_object()
1076 defp maybe_preload_bookmarks(query, %{"skip_preload" => true}), do: query
1078 defp maybe_preload_bookmarks(query, opts) do
1080 |> Activity.with_preloaded_bookmark(opts["user"])
1083 defp maybe_preload_report_notes(query, %{"preload_report_notes" => true}) do
1085 |> Activity.with_preloaded_report_notes()
1088 defp maybe_preload_report_notes(query, _), do: query
1090 defp maybe_set_thread_muted_field(query, %{"skip_preload" => true}), do: query
1092 defp maybe_set_thread_muted_field(query, opts) do
1094 |> Activity.with_set_thread_muted_field(opts["muting_user"] || opts["user"])
1097 defp maybe_order(query, %{order: :desc}) do
1099 |> order_by(desc: :id)
1102 defp maybe_order(query, %{order: :asc}) do
1104 |> order_by(asc: :id)
1107 defp maybe_order(query, _), do: query
1109 defp fetch_activities_query_ap_ids_ops(opts) do
1110 source_user = opts["muting_user"]
1111 ap_id_relations = if source_user, do: [:mute, :reblog_mute], else: []
1115 if opts["blocking_user"] && opts["blocking_user"] == source_user do
1121 preloaded_ap_ids = User.outgoing_relations_ap_ids(source_user, ap_id_relations)
1123 restrict_blocked_opts = Map.merge(%{"blocked_users_ap_ids" => preloaded_ap_ids[:block]}, opts)
1124 restrict_muted_opts = Map.merge(%{"muted_users_ap_ids" => preloaded_ap_ids[:mute]}, opts)
1126 restrict_muted_reblogs_opts =
1127 Map.merge(%{"reblog_muted_users_ap_ids" => preloaded_ap_ids[:reblog_mute]}, opts)
1129 {restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts}
1132 def fetch_activities_query(recipients, opts \\ %{}) do
1133 {restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts} =
1134 fetch_activities_query_ap_ids_ops(opts)
1137 skip_thread_containment: Config.get([:instance, :skip_thread_containment])
1141 |> maybe_preload_objects(opts)
1142 |> maybe_preload_bookmarks(opts)
1143 |> maybe_preload_report_notes(opts)
1144 |> maybe_set_thread_muted_field(opts)
1145 |> maybe_order(opts)
1146 |> restrict_recipients(recipients, opts["user"])
1147 |> restrict_tag(opts)
1148 |> restrict_tag_reject(opts)
1149 |> restrict_tag_all(opts)
1150 |> restrict_since(opts)
1151 |> restrict_local(opts)
1152 |> restrict_actor(opts)
1153 |> restrict_type(opts)
1154 |> restrict_state(opts)
1155 |> restrict_favorited_by(opts)
1156 |> restrict_blocked(restrict_blocked_opts)
1157 |> restrict_muted(restrict_muted_opts)
1158 |> restrict_media(opts)
1159 |> restrict_visibility(opts)
1160 |> restrict_thread_visibility(opts, config)
1161 |> restrict_replies(opts)
1162 |> restrict_reblogs(opts)
1163 |> restrict_pinned(opts)
1164 |> restrict_muted_reblogs(restrict_muted_reblogs_opts)
1165 |> restrict_instance(opts)
1166 |> Activity.restrict_deactivated_users()
1167 |> exclude_poll_votes(opts)
1168 |> exclude_visibility(opts)
1171 def fetch_activities(recipients, opts \\ %{}, pagination \\ :keyset) do
1172 list_memberships = Pleroma.List.memberships(opts["user"])
1174 fetch_activities_query(recipients ++ list_memberships, opts)
1175 |> Pagination.fetch_paginated(opts, pagination)
1177 |> maybe_update_cc(list_memberships, opts["user"])
1181 Fetch favorites activities of user with order by sort adds to favorites
1183 @spec fetch_favourites(User.t(), map(), atom()) :: list(Activity.t())
1184 def fetch_favourites(user, params \\ %{}, pagination \\ :keyset) do
1186 |> Activity.Queries.by_actor()
1187 |> Activity.Queries.by_type("Like")
1188 |> Activity.with_joined_object()
1189 |> Object.with_joined_activity()
1190 |> select([_like, object, activity], %{activity | object: object})
1191 |> order_by([like, _, _], desc: like.id)
1192 |> Pagination.fetch_paginated(
1193 Map.merge(params, %{"skip_order" => true}),
1199 defp maybe_update_cc(activities, list_memberships, %User{ap_id: user_ap_id})
1200 when is_list(list_memberships) and length(list_memberships) > 0 do
1201 Enum.map(activities, fn
1202 %{data: %{"bcc" => bcc}} = activity when is_list(bcc) and length(bcc) > 0 ->
1203 if Enum.any?(bcc, &(&1 in list_memberships)) do
1204 update_in(activity.data["cc"], &[user_ap_id | &1])
1214 defp maybe_update_cc(activities, _, _), do: activities
1216 def fetch_activities_bounded_query(query, recipients, recipients_with_public) do
1217 from(activity in query,
1219 fragment("? && ?", activity.recipients, ^recipients) or
1220 (fragment("? && ?", activity.recipients, ^recipients_with_public) and
1221 ^Pleroma.Constants.as_public() in activity.recipients)
1225 def fetch_activities_bounded(
1227 recipients_with_public,
1229 pagination \\ :keyset
1231 fetch_activities_query([], opts)
1232 |> fetch_activities_bounded_query(recipients, recipients_with_public)
1233 |> Pagination.fetch_paginated(opts, pagination)
1237 def upload(file, opts \\ []) do
1238 with {:ok, data} <- Upload.store(file, opts) do
1241 Map.put(data, "actor", opts[:actor])
1246 Repo.insert(%Object{data: obj_data})
1250 defp object_to_user_data(data) do
1252 data["icon"]["url"] &&
1255 "url" => [%{"href" => data["icon"]["url"]}]
1259 data["image"]["url"] &&
1262 "url" => [%{"href" => data["image"]["url"]}]
1267 |> Map.get("attachment", [])
1268 |> Enum.filter(fn %{"type" => t} -> t == "PropertyValue" end)
1269 |> Enum.map(fn fields -> Map.take(fields, ["name", "value"]) end)
1271 locked = data["manuallyApprovesFollowers"] || false
1272 data = Transmogrifier.maybe_fix_user_object(data)
1273 discoverable = data["discoverable"] || false
1274 invisible = data["invisible"] || false
1275 actor_type = data["type"] || "Person"
1284 discoverable: discoverable,
1285 invisible: invisible,
1288 follower_address: data["followers"],
1289 following_address: data["following"],
1290 bio: data["summary"],
1291 actor_type: actor_type,
1292 also_known_as: Map.get(data, "alsoKnownAs", [])
1295 # nickname can be nil because of virtual actors
1297 if data["preferredUsername"] do
1301 "#{data["preferredUsername"]}@#{URI.parse(data["id"]).host}"
1304 Map.put(user_data, :nickname, nil)
1310 def fetch_follow_information_for_user(user) do
1311 with {:ok, following_data} <-
1312 Fetcher.fetch_and_contain_remote_object_from_id(user.following_address),
1313 {:ok, hide_follows} <- collection_private(following_data),
1314 {:ok, followers_data} <-
1315 Fetcher.fetch_and_contain_remote_object_from_id(user.follower_address),
1316 {:ok, hide_followers} <- collection_private(followers_data) do
1319 hide_follows: hide_follows,
1320 follower_count: normalize_counter(followers_data["totalItems"]),
1321 following_count: normalize_counter(following_data["totalItems"]),
1322 hide_followers: hide_followers
1325 {:error, _} = e -> e
1330 defp normalize_counter(counter) when is_integer(counter), do: counter
1331 defp normalize_counter(_), do: 0
1333 defp maybe_update_follow_information(data) do
1334 with {:enabled, true} <-
1335 {:enabled, Pleroma.Config.get([:instance, :external_user_synchronization])},
1336 {:ok, info} <- fetch_follow_information_for_user(data) do
1337 info = Map.merge(data[:info] || %{}, info)
1338 Map.put(data, :info, info)
1340 {:enabled, false} ->
1345 "Follower/Following counter update for #{data.ap_id} failed.\n" <> inspect(e)
1352 defp collection_private(%{"first" => %{"type" => type}})
1353 when type in ["CollectionPage", "OrderedCollectionPage"],
1356 defp collection_private(%{"first" => first}) do
1357 with {:ok, %{"type" => type}} when type in ["CollectionPage", "OrderedCollectionPage"] <-
1358 Fetcher.fetch_and_contain_remote_object_from_id(first) do
1361 {:error, {:ok, %{status: code}}} when code in [401, 403] -> {:ok, true}
1362 {:error, _} = e -> e
1367 defp collection_private(_data), do: {:ok, true}
1369 def user_data_from_user_object(data) do
1370 with {:ok, data} <- MRF.filter(data),
1371 {:ok, data} <- object_to_user_data(data) do
1378 def fetch_and_prepare_user_from_ap_id(ap_id) do
1379 with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id),
1380 {:ok, data} <- user_data_from_user_object(data),
1381 data <- maybe_update_follow_information(data) do
1384 {:error, "Object has been deleted"} = e ->
1385 Logger.debug("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
1389 Logger.error("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
1394 def make_user_from_ap_id(ap_id) do
1395 if _user = User.get_cached_by_ap_id(ap_id) do
1396 Transmogrifier.upgrade_user_from_ap_id(ap_id)
1398 with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id) do
1399 User.insert_or_update_user(data)
1406 def make_user_from_nickname(nickname) do
1407 with {:ok, %{"ap_id" => ap_id}} when not is_nil(ap_id) <- WebFinger.finger(nickname) do
1408 make_user_from_ap_id(ap_id)
1410 _e -> {:error, "No AP id in WebFinger"}
1414 # filter out broken threads
1415 def contain_broken_threads(%Activity{} = activity, %User{} = user) do
1416 entire_thread_visible_for_user?(activity, user)
1419 # do post-processing on a specific activity
1420 def contain_activity(%Activity{} = activity, %User{} = user) do
1421 contain_broken_threads(activity, user)
1424 def fetch_direct_messages_query do
1426 |> restrict_type(%{"type" => "Create"})
1427 |> restrict_visibility(%{visibility: "direct"})
1428 |> order_by([activity], asc: activity.id)