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
9 alias Pleroma.Constants
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},
124 Object.increase_vote_count(reply_ap_id, name, actor)
127 def increase_poll_votes_if_vote(_create_data), do: :noop
129 @object_types ["ChatMessage"]
130 @spec persist(map(), keyword()) :: {:ok, Activity.t() | Object.t()}
131 def persist(%{"type" => type} = object, meta) when type in @object_types do
132 with {:ok, object} <- Object.create(object) do
137 def persist(object, meta) do
138 with local <- Keyword.fetch!(meta, :local),
139 {recipients, _, _} <- get_recipients(object),
141 Repo.insert(%Activity{
144 recipients: recipients,
145 actor: object["actor"]
147 {:ok, activity, meta}
151 @spec insert(map(), boolean(), boolean(), boolean()) :: {:ok, Activity.t()} | {:error, any()}
152 def insert(map, local \\ true, fake \\ false, bypass_actor_check \\ false) when is_map(map) do
153 with nil <- Activity.normalize(map),
154 map <- lazy_put_activity_defaults(map, fake),
155 true <- bypass_actor_check || check_actor_is_active(map["actor"]),
156 {_, true} <- {:remote_limit_error, check_remote_limit(map)},
157 {:ok, map} <- MRF.filter(map),
158 {recipients, _, _} = get_recipients(map),
159 {:fake, false, map, recipients} <- {:fake, fake, map, recipients},
160 {:containment, :ok} <- {:containment, Containment.contain_child(map)},
161 {:ok, map, object} <- insert_full_object(map) do
163 Repo.insert(%Activity{
167 recipients: recipients
170 # Splice in the child object if we have one.
172 if not is_nil(object) do
173 Map.put(activity, :object, object)
178 BackgroundWorker.enqueue("fetch_data_for_activity", %{"activity_id" => activity.id})
182 %Activity{} = activity ->
185 {:fake, true, map, recipients} ->
186 activity = %Activity{
190 recipients: recipients,
194 Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
202 def notify_and_stream(activity) do
203 Notification.create_notifications(activity)
205 conversation = create_or_bump_conversation(activity, activity.actor)
206 participations = get_participations(conversation)
208 stream_out_participations(participations)
211 defp create_or_bump_conversation(activity, actor) do
212 with {:ok, conversation} <- Conversation.create_or_bump_for(activity),
213 %User{} = user <- User.get_cached_by_ap_id(actor),
214 Participation.mark_as_read(user, conversation) do
219 defp get_participations({:ok, conversation}) do
221 |> Repo.preload(:participations, force: true)
222 |> Map.get(:participations)
225 defp get_participations(_), do: []
227 def stream_out_participations(participations) do
230 |> Repo.preload(:user)
232 Streamer.stream("participation", participations)
235 def stream_out_participations(%Object{data: %{"context" => context}}, user) do
236 with %Conversation{} = conversation <- Conversation.get_for_ap_id(context),
237 conversation = Repo.preload(conversation, :participations),
239 fetch_latest_activity_id_for_context(conversation.ap_id, %{
241 "blocking_user" => user
243 if last_activity_id do
244 stream_out_participations(conversation.participations)
249 def stream_out_participations(_, _), do: :noop
251 def stream_out(%Activity{data: %{"type" => data_type}} = activity)
252 when data_type in ["Create", "Announce", "Delete"] do
254 |> Topics.get_activity_topics()
255 |> Streamer.stream(activity)
258 def stream_out(_activity) do
262 @spec create(map(), boolean()) :: {:ok, Activity.t()} | {:error, any()}
263 def create(params, fake \\ false) do
264 with {:ok, result} <- Repo.transaction(fn -> do_create(params, fake) end) do
269 defp do_create(%{to: to, actor: actor, context: context, object: object} = params, fake) do
270 additional = params[:additional] || %{}
271 # only accept false as false value
272 local = !(params[:local] == false)
273 published = params[:published]
274 quick_insert? = Config.get([:env]) == :benchmark
278 %{to: to, actor: actor, published: published, context: context, object: object},
281 {:ok, activity} <- insert(create_data, local, fake),
282 {:fake, false, activity} <- {:fake, fake, activity},
283 _ <- increase_replies_count_if_reply(create_data),
284 _ <- increase_poll_votes_if_vote(create_data),
285 {:quick_insert, false, activity} <- {:quick_insert, quick_insert?, activity},
286 {:ok, _actor} <- increase_note_count_if_public(actor, activity),
287 _ <- notify_and_stream(activity),
288 :ok <- maybe_federate(activity) do
291 {:quick_insert, true, activity} ->
294 {:fake, true, activity} ->
298 Repo.rollback(message)
302 @spec listen(map()) :: {:ok, Activity.t()} | {:error, any()}
303 def listen(%{to: to, actor: actor, context: context, object: object} = params) do
304 additional = params[:additional] || %{}
305 # only accept false as false value
306 local = !(params[:local] == false)
307 published = params[:published]
311 %{to: to, actor: actor, published: published, context: context, object: object},
314 {:ok, activity} <- insert(listen_data, local),
315 _ <- notify_and_stream(activity),
316 :ok <- maybe_federate(activity) do
321 @spec accept(map()) :: {:ok, Activity.t()} | {:error, any()}
322 def accept(params) do
323 accept_or_reject("Accept", params)
326 @spec reject(map()) :: {:ok, Activity.t()} | {:error, any()}
327 def reject(params) do
328 accept_or_reject("Reject", params)
331 @spec accept_or_reject(String.t(), map()) :: {:ok, Activity.t()} | {:error, any()}
332 def accept_or_reject(type, %{to: to, actor: actor, object: object} = params) do
333 local = Map.get(params, :local, true)
334 activity_id = Map.get(params, :activity_id, nil)
337 %{"to" => to, "type" => type, "actor" => actor.ap_id, "object" => object}
338 |> Utils.maybe_put("id", activity_id),
339 {:ok, activity} <- insert(data, local),
340 _ <- notify_and_stream(activity),
341 :ok <- maybe_federate(activity) do
346 @spec update(map()) :: {:ok, Activity.t()} | {:error, any()}
347 def update(%{to: to, cc: cc, actor: actor, object: object} = params) do
348 local = !(params[:local] == false)
349 activity_id = params[:activity_id]
358 data <- Utils.maybe_put(data, "id", activity_id),
359 {:ok, activity} <- insert(data, local),
360 _ <- notify_and_stream(activity),
361 :ok <- maybe_federate(activity) do
366 @spec follow(User.t(), User.t(), String.t() | nil, boolean()) ::
367 {:ok, Activity.t()} | {:error, any()}
368 def follow(follower, followed, activity_id \\ nil, local \\ true) do
369 with {:ok, result} <-
370 Repo.transaction(fn -> do_follow(follower, followed, activity_id, local) end) do
375 defp do_follow(follower, followed, activity_id, local) do
376 with data <- make_follow_data(follower, followed, activity_id),
377 {:ok, activity} <- insert(data, local),
378 _ <- notify_and_stream(activity),
379 :ok <- maybe_federate(activity) do
382 {:error, error} -> Repo.rollback(error)
386 @spec unfollow(User.t(), User.t(), String.t() | nil, boolean()) ::
387 {:ok, Activity.t()} | nil | {:error, any()}
388 def unfollow(follower, followed, activity_id \\ nil, local \\ true) do
389 with {:ok, result} <-
390 Repo.transaction(fn -> do_unfollow(follower, followed, activity_id, local) end) do
395 defp do_unfollow(follower, followed, activity_id, local) do
396 with %Activity{} = follow_activity <- fetch_latest_follow(follower, followed),
397 {:ok, follow_activity} <- update_follow_state(follow_activity, "cancelled"),
398 unfollow_data <- make_unfollow_data(follower, followed, follow_activity, activity_id),
399 {:ok, activity} <- insert(unfollow_data, local),
400 _ <- notify_and_stream(activity),
401 :ok <- maybe_federate(activity) do
405 {:error, error} -> Repo.rollback(error)
409 @spec block(User.t(), User.t(), String.t() | nil, boolean()) ::
410 {:ok, Activity.t()} | {:error, any()}
411 def block(blocker, blocked, activity_id \\ nil, local \\ true) do
412 with {:ok, result} <-
413 Repo.transaction(fn -> do_block(blocker, blocked, activity_id, local) end) do
418 defp do_block(blocker, blocked, activity_id, local) do
419 unfollow_blocked = Config.get([:activitypub, :unfollow_blocked])
421 if unfollow_blocked do
422 follow_activity = fetch_latest_follow(blocker, blocked)
423 if follow_activity, do: unfollow(blocker, blocked, nil, local)
426 with block_data <- make_block_data(blocker, blocked, activity_id),
427 {:ok, activity} <- insert(block_data, local),
428 _ <- notify_and_stream(activity),
429 :ok <- maybe_federate(activity) do
432 {:error, error} -> Repo.rollback(error)
436 @spec flag(map()) :: {:ok, Activity.t()} | {:error, any()}
446 # only accept false as false value
447 local = !(params[:local] == false)
448 forward = !(params[:forward] == false)
450 additional = params[:additional] || %{}
454 Map.merge(additional, %{"to" => [], "cc" => [account.ap_id]})
456 Map.merge(additional, %{"to" => [], "cc" => []})
459 with flag_data <- make_flag_data(params, additional),
460 {:ok, activity} <- insert(flag_data, local),
461 {:ok, stripped_activity} <- strip_report_status_data(activity),
462 _ <- notify_and_stream(activity),
463 :ok <- maybe_federate(stripped_activity) do
464 User.all_superusers()
465 |> Enum.filter(fn user -> not is_nil(user.email) end)
466 |> Enum.each(fn superuser ->
468 |> Pleroma.Emails.AdminEmail.report(actor, account, statuses, content)
469 |> Pleroma.Emails.Mailer.deliver_async()
476 @spec move(User.t(), User.t(), boolean()) :: {:ok, Activity.t()} | {:error, any()}
477 def move(%User{} = origin, %User{} = target, local \\ true) do
480 "actor" => origin.ap_id,
481 "object" => origin.ap_id,
482 "target" => target.ap_id
485 with true <- origin.ap_id in target.also_known_as,
486 {:ok, activity} <- insert(params, local),
487 _ <- notify_and_stream(activity) do
488 maybe_federate(activity)
490 BackgroundWorker.enqueue("move_following", %{
491 "origin_id" => origin.id,
492 "target_id" => target.id
497 false -> {:error, "Target account must have the origin in `alsoKnownAs`"}
502 def fetch_activities_for_context_query(context, opts) do
503 public = [Constants.as_public()]
507 do: [opts["user"].ap_id | User.following(opts["user"])] ++ public,
510 from(activity in Activity)
511 |> maybe_preload_objects(opts)
512 |> maybe_preload_bookmarks(opts)
513 |> maybe_set_thread_muted_field(opts)
514 |> restrict_blocked(opts)
515 |> restrict_recipients(recipients, opts["user"])
519 "?->>'type' = ? and ?->>'context' = ?",
526 |> exclude_poll_votes(opts)
528 |> order_by([activity], desc: activity.id)
531 @spec fetch_activities_for_context(String.t(), keyword() | map()) :: [Activity.t()]
532 def fetch_activities_for_context(context, opts \\ %{}) do
534 |> fetch_activities_for_context_query(opts)
538 @spec fetch_latest_activity_id_for_context(String.t(), keyword() | map()) ::
539 FlakeId.Ecto.CompatType.t() | nil
540 def fetch_latest_activity_id_for_context(context, opts \\ %{}) do
542 |> fetch_activities_for_context_query(Map.merge(%{"skip_preload" => true}, opts))
548 @spec fetch_public_activities(map(), Pagination.type()) :: [Activity.t()]
549 def fetch_public_activities(opts \\ %{}, pagination \\ :keyset) do
550 opts = Map.drop(opts, ["user"])
552 [Constants.as_public()]
553 |> fetch_activities_query(opts)
554 |> restrict_unlisted()
555 |> Pagination.fetch_paginated(opts, pagination)
558 @valid_visibilities ~w[direct unlisted public private]
560 defp restrict_visibility(query, %{visibility: visibility})
561 when is_list(visibility) do
562 if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
568 "activity_visibility(?, ?, ?) = ANY (?)",
578 Logger.error("Could not restrict visibility to #{visibility}")
582 defp restrict_visibility(query, %{visibility: visibility})
583 when visibility in @valid_visibilities do
587 fragment("activity_visibility(?, ?, ?) = ?", a.actor, a.recipients, a.data, ^visibility)
591 defp restrict_visibility(_query, %{visibility: visibility})
592 when visibility not in @valid_visibilities do
593 Logger.error("Could not restrict visibility to #{visibility}")
596 defp restrict_visibility(query, _visibility), do: query
598 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
599 when is_list(visibility) do
600 if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
605 "activity_visibility(?, ?, ?) = ANY (?)",
613 Logger.error("Could not exclude visibility to #{visibility}")
618 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
619 when visibility in @valid_visibilities do
624 "activity_visibility(?, ?, ?) = ?",
633 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
634 when visibility not in [nil | @valid_visibilities] do
635 Logger.error("Could not exclude visibility to #{visibility}")
639 defp exclude_visibility(query, _visibility), do: query
641 defp restrict_thread_visibility(query, _, %{skip_thread_containment: true} = _),
644 defp restrict_thread_visibility(
646 %{"user" => %User{skip_thread_containment: true}},
651 defp restrict_thread_visibility(query, %{"user" => %User{ap_id: ap_id}}, _) do
654 where: fragment("thread_visibility(?, (?)->>'id') = true", ^ap_id, a.data)
658 defp restrict_thread_visibility(query, _, _), do: query
660 def fetch_user_abstract_activities(user, reading_user, params \\ %{}) do
663 |> Map.put("user", reading_user)
664 |> Map.put("actor_id", user.ap_id)
667 user_activities_recipients(%{
668 "godmode" => params["godmode"],
669 "reading_user" => reading_user
672 fetch_activities(recipients, params)
676 def fetch_user_activities(user, reading_user, params \\ %{}) do
679 |> Map.put("type", ["Create", "Announce"])
680 |> Map.put("user", reading_user)
681 |> Map.put("actor_id", user.ap_id)
682 |> Map.put("pinned_activity_ids", user.pinned_activities)
685 if User.blocks?(reading_user, user) do
689 |> Map.put("blocking_user", reading_user)
690 |> Map.put("muting_user", reading_user)
694 user_activities_recipients(%{
695 "godmode" => params["godmode"],
696 "reading_user" => reading_user
699 fetch_activities(recipients, params)
703 def fetch_statuses(reading_user, params) do
706 |> Map.put("type", ["Create", "Announce"])
709 user_activities_recipients(%{
710 "godmode" => params["godmode"],
711 "reading_user" => reading_user
714 fetch_activities(recipients, params, :offset)
718 defp user_activities_recipients(%{"godmode" => true}) do
722 defp user_activities_recipients(%{"reading_user" => reading_user}) do
724 [Constants.as_public()] ++ [reading_user.ap_id | User.following(reading_user)]
726 [Constants.as_public()]
730 defp restrict_since(query, %{"since_id" => ""}), do: query
732 defp restrict_since(query, %{"since_id" => since_id}) do
733 from(activity in query, where: activity.id > ^since_id)
736 defp restrict_since(query, _), do: query
738 defp restrict_tag_reject(_query, %{"tag_reject" => _tag_reject, "skip_preload" => true}) do
739 raise "Can't use the child object without preloading!"
742 defp restrict_tag_reject(query, %{"tag_reject" => tag_reject})
743 when is_list(tag_reject) and tag_reject != [] do
745 [_activity, object] in query,
746 where: fragment("not (?)->'tag' \\?| (?)", object.data, ^tag_reject)
750 defp restrict_tag_reject(query, _), do: query
752 defp restrict_tag_all(_query, %{"tag_all" => _tag_all, "skip_preload" => true}) do
753 raise "Can't use the child object without preloading!"
756 defp restrict_tag_all(query, %{"tag_all" => tag_all})
757 when is_list(tag_all) and tag_all != [] do
759 [_activity, object] in query,
760 where: fragment("(?)->'tag' \\?& (?)", object.data, ^tag_all)
764 defp restrict_tag_all(query, _), do: query
766 defp restrict_tag(_query, %{"tag" => _tag, "skip_preload" => true}) do
767 raise "Can't use the child object without preloading!"
770 defp restrict_tag(query, %{"tag" => tag}) when is_list(tag) do
772 [_activity, object] in query,
773 where: fragment("(?)->'tag' \\?| (?)", object.data, ^tag)
777 defp restrict_tag(query, %{"tag" => tag}) when is_binary(tag) do
779 [_activity, object] in query,
780 where: fragment("(?)->'tag' \\? (?)", object.data, ^tag)
784 defp restrict_tag(query, _), do: query
786 defp restrict_recipients(query, [], _user), do: query
788 defp restrict_recipients(query, recipients, nil) do
789 from(activity in query, where: fragment("? && ?", ^recipients, activity.recipients))
792 defp restrict_recipients(query, recipients, user) do
795 where: fragment("? && ?", ^recipients, activity.recipients),
796 or_where: activity.actor == ^user.ap_id
800 defp restrict_local(query, %{"local_only" => true}) do
801 from(activity in query, where: activity.local == true)
804 defp restrict_local(query, _), do: query
806 defp restrict_actor(query, %{"actor_id" => actor_id}) do
807 from(activity in query, where: activity.actor == ^actor_id)
810 defp restrict_actor(query, _), do: query
812 defp restrict_type(query, %{"type" => type}) when is_binary(type) do
813 from(activity in query, where: fragment("?->>'type' = ?", activity.data, ^type))
816 defp restrict_type(query, %{"type" => type}) do
817 from(activity in query, where: fragment("?->>'type' = ANY(?)", activity.data, ^type))
820 defp restrict_type(query, _), do: query
822 defp restrict_state(query, %{"state" => state}) do
823 from(activity in query, where: fragment("?->>'state' = ?", activity.data, ^state))
826 defp restrict_state(query, _), do: query
828 defp restrict_favorited_by(query, %{"favorited_by" => ap_id}) do
830 [_activity, object] in query,
831 where: fragment("(?)->'likes' \\? (?)", object.data, ^ap_id)
835 defp restrict_favorited_by(query, _), do: query
837 defp restrict_media(_query, %{"only_media" => _val, "skip_preload" => true}) do
838 raise "Can't use the child object without preloading!"
841 defp restrict_media(query, %{"only_media" => val}) when val in [true, "true", "1"] do
843 [_activity, object] in query,
844 where: fragment("not (?)->'attachment' = (?)", object.data, ^[])
848 defp restrict_media(query, _), do: query
850 defp restrict_replies(query, %{"exclude_replies" => val}) when val in [true, "true", "1"] do
852 [_activity, object] in query,
853 where: fragment("?->>'inReplyTo' is null", object.data)
857 defp restrict_replies(query, %{
858 "reply_filtering_user" => user,
859 "reply_visibility" => "self"
862 [activity, object] in query,
865 "?->>'inReplyTo' is null OR ? = ANY(?)",
873 defp restrict_replies(query, %{
874 "reply_filtering_user" => user,
875 "reply_visibility" => "following"
878 [activity, object] in query,
881 "?->>'inReplyTo' is null OR ? && array_remove(?, ?) OR ? = ?",
883 ^[user.ap_id | User.get_cached_user_friends_ap_ids(user)],
892 defp restrict_replies(query, _), do: query
894 defp restrict_reblogs(query, %{"exclude_reblogs" => val}) when val in [true, "true", "1"] do
895 from(activity in query, where: fragment("?->>'type' != 'Announce'", activity.data))
898 defp restrict_reblogs(query, _), do: query
900 defp restrict_muted(query, %{"with_muted" => val}) when val in [true, "true", "1"], do: query
902 defp restrict_muted(query, %{"muting_user" => %User{} = user} = opts) do
903 mutes = opts["muted_users_ap_ids"] || User.muted_users_ap_ids(user)
906 from([activity] in query,
907 where: fragment("not (? = ANY(?))", activity.actor, ^mutes),
908 where: fragment("not (?->'to' \\?| ?)", activity.data, ^mutes)
911 unless opts["skip_preload"] do
912 from([thread_mute: tm] in query, where: is_nil(tm.user_id))
918 defp restrict_muted(query, _), do: query
920 defp restrict_blocked(query, %{"blocking_user" => %User{} = user} = opts) do
921 blocked_ap_ids = opts["blocked_users_ap_ids"] || User.blocked_users_ap_ids(user)
922 domain_blocks = user.domain_blocks || []
924 following_ap_ids = User.get_friends_ap_ids(user)
927 if has_named_binding?(query, :object), do: query, else: Activity.with_joined_object(query)
930 [activity, object: o] in query,
931 where: fragment("not (? = ANY(?))", activity.actor, ^blocked_ap_ids),
932 where: fragment("not (? && ?)", activity.recipients, ^blocked_ap_ids),
935 "not (?->>'type' = 'Announce' and ?->'to' \\?| ?)",
942 "(not (split_part(?, '/', 3) = ANY(?))) or ? = ANY(?)",
950 "(not (split_part(?->>'actor', '/', 3) = ANY(?))) or (?->>'actor') = ANY(?)",
959 defp restrict_blocked(query, _), do: query
961 defp restrict_unlisted(query) do
966 "not (coalesce(?->'cc', '{}'::jsonb) \\?| ?)",
968 ^[Constants.as_public()]
973 # TODO: when all endpoints migrated to OpenAPI compare `pinned` with `true` (boolean) only,
974 # the same for `restrict_media/2`, `restrict_replies/2`, 'restrict_reblogs/2'
975 # and `restrict_muted/2`
977 defp restrict_pinned(query, %{"pinned" => pinned, "pinned_activity_ids" => ids})
978 when pinned in [true, "true", "1"] do
979 from(activity in query, where: activity.id in ^ids)
982 defp restrict_pinned(query, _), do: query
984 defp restrict_muted_reblogs(query, %{"muting_user" => %User{} = user} = opts) do
985 muted_reblogs = opts["reblog_muted_users_ap_ids"] || User.reblog_muted_users_ap_ids(user)
991 "not ( ?->>'type' = 'Announce' and ? = ANY(?))",
999 defp restrict_muted_reblogs(query, _), do: query
1001 defp restrict_instance(query, %{"instance" => instance}) do
1006 where: fragment("? LIKE ?", u.nickname, ^"%@#{instance}")
1010 from(activity in query, where: activity.actor in ^users)
1013 defp restrict_instance(query, _), do: query
1015 defp exclude_poll_votes(query, %{"include_poll_votes" => true}), do: query
1017 defp exclude_poll_votes(query, _) do
1018 if has_named_binding?(query, :object) do
1019 from([activity, object: o] in query,
1020 where: fragment("not(?->>'type' = ?)", o.data, "Answer")
1027 defp exclude_chat_messages(query, %{"include_chat_messages" => true}), do: query
1029 defp exclude_chat_messages(query, _) do
1030 if has_named_binding?(query, :object) do
1031 from([activity, object: o] in query,
1032 where: fragment("not(?->>'type' = ?)", o.data, "ChatMessage")
1039 defp exclude_id(query, %{"exclude_id" => id}) when is_binary(id) do
1040 from(activity in query, where: activity.id != ^id)
1043 defp exclude_id(query, _), do: query
1045 defp maybe_preload_objects(query, %{"skip_preload" => true}), do: query
1047 defp maybe_preload_objects(query, _) do
1049 |> Activity.with_preloaded_object()
1052 defp maybe_preload_bookmarks(query, %{"skip_preload" => true}), do: query
1054 defp maybe_preload_bookmarks(query, opts) do
1056 |> Activity.with_preloaded_bookmark(opts["user"])
1059 defp maybe_preload_report_notes(query, %{"preload_report_notes" => true}) do
1061 |> Activity.with_preloaded_report_notes()
1064 defp maybe_preload_report_notes(query, _), do: query
1066 defp maybe_set_thread_muted_field(query, %{"skip_preload" => true}), do: query
1068 defp maybe_set_thread_muted_field(query, opts) do
1070 |> Activity.with_set_thread_muted_field(opts["muting_user"] || opts["user"])
1073 defp maybe_order(query, %{order: :desc}) do
1075 |> order_by(desc: :id)
1078 defp maybe_order(query, %{order: :asc}) do
1080 |> order_by(asc: :id)
1083 defp maybe_order(query, _), do: query
1085 defp fetch_activities_query_ap_ids_ops(opts) do
1086 source_user = opts["muting_user"]
1087 ap_id_relationships = if source_user, do: [:mute, :reblog_mute], else: []
1089 ap_id_relationships =
1090 ap_id_relationships ++
1091 if opts["blocking_user"] && opts["blocking_user"] == source_user do
1097 preloaded_ap_ids = User.outgoing_relationships_ap_ids(source_user, ap_id_relationships)
1099 restrict_blocked_opts = Map.merge(%{"blocked_users_ap_ids" => preloaded_ap_ids[:block]}, opts)
1100 restrict_muted_opts = Map.merge(%{"muted_users_ap_ids" => preloaded_ap_ids[:mute]}, opts)
1102 restrict_muted_reblogs_opts =
1103 Map.merge(%{"reblog_muted_users_ap_ids" => preloaded_ap_ids[:reblog_mute]}, opts)
1105 {restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts}
1108 def fetch_activities_query(recipients, opts \\ %{}) do
1109 {restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts} =
1110 fetch_activities_query_ap_ids_ops(opts)
1113 skip_thread_containment: Config.get([:instance, :skip_thread_containment])
1117 |> maybe_preload_objects(opts)
1118 |> maybe_preload_bookmarks(opts)
1119 |> maybe_preload_report_notes(opts)
1120 |> maybe_set_thread_muted_field(opts)
1121 |> maybe_order(opts)
1122 |> restrict_recipients(recipients, opts["user"])
1123 |> restrict_replies(opts)
1124 |> restrict_tag(opts)
1125 |> restrict_tag_reject(opts)
1126 |> restrict_tag_all(opts)
1127 |> restrict_since(opts)
1128 |> restrict_local(opts)
1129 |> restrict_actor(opts)
1130 |> restrict_type(opts)
1131 |> restrict_state(opts)
1132 |> restrict_favorited_by(opts)
1133 |> restrict_blocked(restrict_blocked_opts)
1134 |> restrict_muted(restrict_muted_opts)
1135 |> restrict_media(opts)
1136 |> restrict_visibility(opts)
1137 |> restrict_thread_visibility(opts, config)
1138 |> restrict_reblogs(opts)
1139 |> restrict_pinned(opts)
1140 |> restrict_muted_reblogs(restrict_muted_reblogs_opts)
1141 |> restrict_instance(opts)
1142 |> Activity.restrict_deactivated_users()
1143 |> exclude_poll_votes(opts)
1144 |> exclude_chat_messages(opts)
1145 |> exclude_visibility(opts)
1148 def fetch_activities(recipients, opts \\ %{}, pagination \\ :keyset) do
1149 list_memberships = Pleroma.List.memberships(opts["user"])
1151 fetch_activities_query(recipients ++ list_memberships, opts)
1152 |> Pagination.fetch_paginated(opts, pagination)
1154 |> maybe_update_cc(list_memberships, opts["user"])
1158 Fetch favorites activities of user with order by sort adds to favorites
1160 @spec fetch_favourites(User.t(), map(), Pagination.type()) :: list(Activity.t())
1161 def fetch_favourites(user, params \\ %{}, pagination \\ :keyset) do
1163 |> Activity.Queries.by_actor()
1164 |> Activity.Queries.by_type("Like")
1165 |> Activity.with_joined_object()
1166 |> Object.with_joined_activity()
1167 |> select([_like, object, activity], %{activity | object: object})
1168 |> order_by([like, _, _], desc: like.id)
1169 |> Pagination.fetch_paginated(
1170 Map.merge(params, %{"skip_order" => true}),
1176 defp maybe_update_cc(activities, list_memberships, %User{ap_id: user_ap_id})
1177 when is_list(list_memberships) and length(list_memberships) > 0 do
1178 Enum.map(activities, fn
1179 %{data: %{"bcc" => bcc}} = activity when is_list(bcc) and length(bcc) > 0 ->
1180 if Enum.any?(bcc, &(&1 in list_memberships)) do
1181 update_in(activity.data["cc"], &[user_ap_id | &1])
1191 defp maybe_update_cc(activities, _, _), do: activities
1193 def fetch_activities_bounded_query(query, recipients, recipients_with_public) do
1194 from(activity in query,
1196 fragment("? && ?", activity.recipients, ^recipients) or
1197 (fragment("? && ?", activity.recipients, ^recipients_with_public) and
1198 ^Constants.as_public() in activity.recipients)
1202 def fetch_activities_bounded(
1204 recipients_with_public,
1206 pagination \\ :keyset
1208 fetch_activities_query([], opts)
1209 |> fetch_activities_bounded_query(recipients, recipients_with_public)
1210 |> Pagination.fetch_paginated(opts, pagination)
1214 @spec upload(Upload.source(), keyword()) :: {:ok, Object.t()} | {:error, any()}
1215 def upload(file, opts \\ []) do
1216 with {:ok, data} <- Upload.store(file, opts) do
1219 Map.put(data, "actor", opts[:actor])
1224 Repo.insert(%Object{data: obj_data})
1228 @spec get_actor_url(any()) :: binary() | nil
1229 defp get_actor_url(url) when is_binary(url), do: url
1230 defp get_actor_url(%{"href" => href}) when is_binary(href), do: href
1232 defp get_actor_url(url) when is_list(url) do
1238 defp get_actor_url(_url), do: nil
1240 defp object_to_user_data(data) do
1242 data["icon"]["url"] &&
1245 "url" => [%{"href" => data["icon"]["url"]}]
1249 data["image"]["url"] &&
1252 "url" => [%{"href" => data["image"]["url"]}]
1257 |> Map.get("attachment", [])
1258 |> Enum.filter(fn %{"type" => t} -> t == "PropertyValue" end)
1259 |> Enum.map(fn fields -> Map.take(fields, ["name", "value"]) end)
1263 |> Map.get("tag", [])
1265 %{"type" => "Emoji"} -> true
1268 |> Enum.reduce(%{}, fn %{"icon" => %{"url" => url}, "name" => name}, acc ->
1269 Map.put(acc, String.trim(name, ":"), url)
1272 locked = data["manuallyApprovesFollowers"] || false
1273 data = Transmogrifier.maybe_fix_user_object(data)
1274 discoverable = data["discoverable"] || false
1275 invisible = data["invisible"] || false
1276 actor_type = data["type"] || "Person"
1279 if is_map(data["publicKey"]) && is_binary(data["publicKey"]["publicKeyPem"]) do
1280 data["publicKey"]["publicKeyPem"]
1286 if is_map(data["endpoints"]) && is_binary(data["endpoints"]["sharedInbox"]) do
1287 data["endpoints"]["sharedInbox"]
1294 uri: get_actor_url(data["url"]),
1300 discoverable: discoverable,
1301 invisible: invisible,
1304 follower_address: data["followers"],
1305 following_address: data["following"],
1306 bio: data["summary"],
1307 actor_type: actor_type,
1308 also_known_as: Map.get(data, "alsoKnownAs", []),
1309 public_key: public_key,
1310 inbox: data["inbox"],
1311 shared_inbox: shared_inbox
1314 # nickname can be nil because of virtual actors
1316 if data["preferredUsername"] do
1320 "#{data["preferredUsername"]}@#{URI.parse(data["id"]).host}"
1323 Map.put(user_data, :nickname, nil)
1329 def fetch_follow_information_for_user(user) do
1330 with {:ok, following_data} <-
1331 Fetcher.fetch_and_contain_remote_object_from_id(user.following_address),
1332 {:ok, hide_follows} <- collection_private(following_data),
1333 {:ok, followers_data} <-
1334 Fetcher.fetch_and_contain_remote_object_from_id(user.follower_address),
1335 {:ok, hide_followers} <- collection_private(followers_data) do
1338 hide_follows: hide_follows,
1339 follower_count: normalize_counter(followers_data["totalItems"]),
1340 following_count: normalize_counter(following_data["totalItems"]),
1341 hide_followers: hide_followers
1344 {:error, _} = e -> e
1349 defp normalize_counter(counter) when is_integer(counter), do: counter
1350 defp normalize_counter(_), do: 0
1352 def maybe_update_follow_information(user_data) do
1353 with {:enabled, true} <- {:enabled, Config.get([:instance, :external_user_synchronization])},
1354 {_, true} <- {:user_type_check, user_data[:type] in ["Person", "Service"]},
1356 {:collections_available,
1357 !!(user_data[:following_address] && user_data[:follower_address])},
1359 fetch_follow_information_for_user(user_data) do
1360 info = Map.merge(user_data[:info] || %{}, info)
1363 |> Map.put(:info, info)
1365 {:user_type_check, false} ->
1368 {:collections_available, false} ->
1371 {:enabled, false} ->
1376 "Follower/Following counter update for #{user_data.ap_id} failed.\n" <> inspect(e)
1383 defp collection_private(%{"first" => %{"type" => type}})
1384 when type in ["CollectionPage", "OrderedCollectionPage"],
1387 defp collection_private(%{"first" => first}) do
1388 with {:ok, %{"type" => type}} when type in ["CollectionPage", "OrderedCollectionPage"] <-
1389 Fetcher.fetch_and_contain_remote_object_from_id(first) do
1392 {:error, {:ok, %{status: code}}} when code in [401, 403] -> {:ok, true}
1393 {:error, _} = e -> e
1398 defp collection_private(_data), do: {:ok, true}
1400 def user_data_from_user_object(data) do
1401 with {:ok, data} <- MRF.filter(data),
1402 {:ok, data} <- object_to_user_data(data) do
1409 def fetch_and_prepare_user_from_ap_id(ap_id) do
1410 with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id),
1411 {:ok, data} <- user_data_from_user_object(data),
1412 data <- maybe_update_follow_information(data) do
1415 {:error, "Object has been deleted"} = e ->
1416 Logger.debug("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
1420 Logger.error("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
1425 def make_user_from_ap_id(ap_id) do
1426 user = User.get_cached_by_ap_id(ap_id)
1428 if user && !User.ap_enabled?(user) do
1429 Transmogrifier.upgrade_user_from_ap_id(ap_id)
1431 with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id) do
1434 |> User.remote_user_changeset(data)
1435 |> User.update_and_set_cache()
1438 |> User.remote_user_changeset()
1448 def make_user_from_nickname(nickname) do
1449 with {:ok, %{"ap_id" => ap_id}} when not is_nil(ap_id) <- WebFinger.finger(nickname) do
1450 make_user_from_ap_id(ap_id)
1452 _e -> {:error, "No AP id in WebFinger"}
1456 # filter out broken threads
1457 def contain_broken_threads(%Activity{} = activity, %User{} = user) do
1458 entire_thread_visible_for_user?(activity, user)
1461 # do post-processing on a specific activity
1462 def contain_activity(%Activity{} = activity, %User{} = user) do
1463 contain_broken_threads(activity, user)
1466 def fetch_direct_messages_query do
1468 |> restrict_type(%{"type" => "Create"})
1469 |> restrict_visibility(%{visibility: "direct"})
1470 |> order_by([activity], asc: activity.id)