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(), keyword()) ::
367 {:ok, Activity.t()} | {:error, any()}
368 def follow(follower, followed, activity_id \\ nil, local \\ true, opts \\ []) do
369 with {:ok, result} <-
370 Repo.transaction(fn -> do_follow(follower, followed, activity_id, local, opts) end) do
375 defp do_follow(follower, followed, activity_id, local, opts) do
376 skip_notify_and_stream = Keyword.get(opts, :skip_notify_and_stream, false)
378 with data <- make_follow_data(follower, followed, activity_id),
379 {:ok, activity} <- insert(data, local),
380 _ <- skip_notify_and_stream || notify_and_stream(activity),
381 :ok <- maybe_federate(activity) do
384 {:error, error} -> Repo.rollback(error)
388 @spec unfollow(User.t(), User.t(), String.t() | nil, boolean()) ::
389 {:ok, Activity.t()} | nil | {:error, any()}
390 def unfollow(follower, followed, activity_id \\ nil, local \\ true) do
391 with {:ok, result} <-
392 Repo.transaction(fn -> do_unfollow(follower, followed, activity_id, local) end) do
397 defp do_unfollow(follower, followed, activity_id, local) do
398 with %Activity{} = follow_activity <- fetch_latest_follow(follower, followed),
399 {:ok, follow_activity} <- update_follow_state(follow_activity, "cancelled"),
400 unfollow_data <- make_unfollow_data(follower, followed, follow_activity, activity_id),
401 {:ok, activity} <- insert(unfollow_data, local),
402 _ <- notify_and_stream(activity),
403 :ok <- maybe_federate(activity) do
407 {:error, error} -> Repo.rollback(error)
411 @spec block(User.t(), User.t(), String.t() | nil, boolean()) ::
412 {:ok, Activity.t()} | {:error, any()}
413 def block(blocker, blocked, activity_id \\ nil, local \\ true) do
414 with {:ok, result} <-
415 Repo.transaction(fn -> do_block(blocker, blocked, activity_id, local) end) do
420 defp do_block(blocker, blocked, activity_id, local) do
421 unfollow_blocked = Config.get([:activitypub, :unfollow_blocked])
423 if unfollow_blocked do
424 follow_activity = fetch_latest_follow(blocker, blocked)
425 if follow_activity, do: unfollow(blocker, blocked, nil, local)
428 with block_data <- make_block_data(blocker, blocked, activity_id),
429 {:ok, activity} <- insert(block_data, local),
430 _ <- notify_and_stream(activity),
431 :ok <- maybe_federate(activity) do
434 {:error, error} -> Repo.rollback(error)
438 @spec flag(map()) :: {:ok, Activity.t()} | {:error, any()}
448 # only accept false as false value
449 local = !(params[:local] == false)
450 forward = !(params[:forward] == false)
452 additional = params[:additional] || %{}
456 Map.merge(additional, %{"to" => [], "cc" => [account.ap_id]})
458 Map.merge(additional, %{"to" => [], "cc" => []})
461 with flag_data <- make_flag_data(params, additional),
462 {:ok, activity} <- insert(flag_data, local),
463 {:ok, stripped_activity} <- strip_report_status_data(activity),
464 _ <- notify_and_stream(activity),
465 :ok <- maybe_federate(stripped_activity) do
466 User.all_superusers()
467 |> Enum.filter(fn user -> not is_nil(user.email) end)
468 |> Enum.each(fn superuser ->
470 |> Pleroma.Emails.AdminEmail.report(actor, account, statuses, content)
471 |> Pleroma.Emails.Mailer.deliver_async()
478 @spec move(User.t(), User.t(), boolean()) :: {:ok, Activity.t()} | {:error, any()}
479 def move(%User{} = origin, %User{} = target, local \\ true) do
482 "actor" => origin.ap_id,
483 "object" => origin.ap_id,
484 "target" => target.ap_id
487 with true <- origin.ap_id in target.also_known_as,
488 {:ok, activity} <- insert(params, local),
489 _ <- notify_and_stream(activity) do
490 maybe_federate(activity)
492 BackgroundWorker.enqueue("move_following", %{
493 "origin_id" => origin.id,
494 "target_id" => target.id
499 false -> {:error, "Target account must have the origin in `alsoKnownAs`"}
504 def fetch_activities_for_context_query(context, opts) do
505 public = [Constants.as_public()]
509 do: [opts["user"].ap_id | User.following(opts["user"])] ++ public,
512 from(activity in Activity)
513 |> maybe_preload_objects(opts)
514 |> maybe_preload_bookmarks(opts)
515 |> maybe_set_thread_muted_field(opts)
516 |> restrict_blocked(opts)
517 |> restrict_recipients(recipients, opts["user"])
521 "?->>'type' = ? and ?->>'context' = ?",
528 |> exclude_poll_votes(opts)
530 |> order_by([activity], desc: activity.id)
533 @spec fetch_activities_for_context(String.t(), keyword() | map()) :: [Activity.t()]
534 def fetch_activities_for_context(context, opts \\ %{}) do
536 |> fetch_activities_for_context_query(opts)
540 @spec fetch_latest_activity_id_for_context(String.t(), keyword() | map()) ::
541 FlakeId.Ecto.CompatType.t() | nil
542 def fetch_latest_activity_id_for_context(context, opts \\ %{}) do
544 |> fetch_activities_for_context_query(Map.merge(%{"skip_preload" => true}, opts))
550 @spec fetch_public_or_unlisted_activities(map(), Pagination.type()) :: [Activity.t()]
551 def fetch_public_or_unlisted_activities(opts \\ %{}, pagination \\ :keyset) do
552 opts = Map.drop(opts, ["user"])
554 query = fetch_activities_query([Constants.as_public()], opts)
557 if opts["restrict_unlisted"] do
558 restrict_unlisted(query)
563 Pagination.fetch_paginated(query, opts, pagination)
566 @spec fetch_public_activities(map(), Pagination.type()) :: [Activity.t()]
567 def fetch_public_activities(opts \\ %{}, pagination \\ :keyset) do
569 |> Map.put("restrict_unlisted", true)
570 |> fetch_public_or_unlisted_activities(pagination)
573 @valid_visibilities ~w[direct unlisted public private]
575 defp restrict_visibility(query, %{visibility: visibility})
576 when is_list(visibility) do
577 if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
583 "activity_visibility(?, ?, ?) = ANY (?)",
593 Logger.error("Could not restrict visibility to #{visibility}")
597 defp restrict_visibility(query, %{visibility: visibility})
598 when visibility in @valid_visibilities do
602 fragment("activity_visibility(?, ?, ?) = ?", a.actor, a.recipients, a.data, ^visibility)
606 defp restrict_visibility(_query, %{visibility: visibility})
607 when visibility not in @valid_visibilities do
608 Logger.error("Could not restrict visibility to #{visibility}")
611 defp restrict_visibility(query, _visibility), do: query
613 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
614 when is_list(visibility) do
615 if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
620 "activity_visibility(?, ?, ?) = ANY (?)",
628 Logger.error("Could not exclude visibility to #{visibility}")
633 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
634 when visibility in @valid_visibilities do
639 "activity_visibility(?, ?, ?) = ?",
648 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
649 when visibility not in [nil | @valid_visibilities] do
650 Logger.error("Could not exclude visibility to #{visibility}")
654 defp exclude_visibility(query, _visibility), do: query
656 defp restrict_thread_visibility(query, _, %{skip_thread_containment: true} = _),
659 defp restrict_thread_visibility(
661 %{"user" => %User{skip_thread_containment: true}},
666 defp restrict_thread_visibility(query, %{"user" => %User{ap_id: ap_id}}, _) do
669 where: fragment("thread_visibility(?, (?)->>'id') = true", ^ap_id, a.data)
673 defp restrict_thread_visibility(query, _, _), do: query
675 def fetch_user_abstract_activities(user, reading_user, params \\ %{}) do
678 |> Map.put("user", reading_user)
679 |> Map.put("actor_id", user.ap_id)
682 user_activities_recipients(%{
683 "godmode" => params["godmode"],
684 "reading_user" => reading_user
687 fetch_activities(recipients, params)
691 def fetch_user_activities(user, reading_user, params \\ %{}) do
694 |> Map.put("type", ["Create", "Announce"])
695 |> Map.put("user", reading_user)
696 |> Map.put("actor_id", user.ap_id)
697 |> Map.put("pinned_activity_ids", user.pinned_activities)
700 if User.blocks?(reading_user, user) do
704 |> Map.put("blocking_user", reading_user)
705 |> Map.put("muting_user", reading_user)
709 user_activities_recipients(%{
710 "godmode" => params["godmode"],
711 "reading_user" => reading_user
714 fetch_activities(recipients, params)
718 def fetch_statuses(reading_user, params) do
721 |> Map.put("type", ["Create", "Announce"])
724 user_activities_recipients(%{
725 "godmode" => params["godmode"],
726 "reading_user" => reading_user
729 fetch_activities(recipients, params, :offset)
733 defp user_activities_recipients(%{"godmode" => true}) do
737 defp user_activities_recipients(%{"reading_user" => reading_user}) do
739 [Constants.as_public()] ++ [reading_user.ap_id | User.following(reading_user)]
741 [Constants.as_public()]
745 defp restrict_since(query, %{"since_id" => ""}), do: query
747 defp restrict_since(query, %{"since_id" => since_id}) do
748 from(activity in query, where: activity.id > ^since_id)
751 defp restrict_since(query, _), do: query
753 defp restrict_tag_reject(_query, %{"tag_reject" => _tag_reject, "skip_preload" => true}) do
754 raise "Can't use the child object without preloading!"
757 defp restrict_tag_reject(query, %{"tag_reject" => tag_reject})
758 when is_list(tag_reject) and tag_reject != [] do
760 [_activity, object] in query,
761 where: fragment("not (?)->'tag' \\?| (?)", object.data, ^tag_reject)
765 defp restrict_tag_reject(query, _), do: query
767 defp restrict_tag_all(_query, %{"tag_all" => _tag_all, "skip_preload" => true}) do
768 raise "Can't use the child object without preloading!"
771 defp restrict_tag_all(query, %{"tag_all" => tag_all})
772 when is_list(tag_all) and tag_all != [] do
774 [_activity, object] in query,
775 where: fragment("(?)->'tag' \\?& (?)", object.data, ^tag_all)
779 defp restrict_tag_all(query, _), do: query
781 defp restrict_tag(_query, %{"tag" => _tag, "skip_preload" => true}) do
782 raise "Can't use the child object without preloading!"
785 defp restrict_tag(query, %{"tag" => tag}) when is_list(tag) do
787 [_activity, object] in query,
788 where: fragment("(?)->'tag' \\?| (?)", object.data, ^tag)
792 defp restrict_tag(query, %{"tag" => tag}) when is_binary(tag) do
794 [_activity, object] in query,
795 where: fragment("(?)->'tag' \\? (?)", object.data, ^tag)
799 defp restrict_tag(query, _), do: query
801 defp restrict_recipients(query, [], _user), do: query
803 defp restrict_recipients(query, recipients, nil) do
804 from(activity in query, where: fragment("? && ?", ^recipients, activity.recipients))
807 defp restrict_recipients(query, recipients, user) do
810 where: fragment("? && ?", ^recipients, activity.recipients),
811 or_where: activity.actor == ^user.ap_id
815 defp restrict_local(query, %{"local_only" => true}) do
816 from(activity in query, where: activity.local == true)
819 defp restrict_local(query, _), do: query
821 defp restrict_actor(query, %{"actor_id" => actor_id}) do
822 from(activity in query, where: activity.actor == ^actor_id)
825 defp restrict_actor(query, _), do: query
827 defp restrict_type(query, %{"type" => type}) when is_binary(type) do
828 from(activity in query, where: fragment("?->>'type' = ?", activity.data, ^type))
831 defp restrict_type(query, %{"type" => type}) do
832 from(activity in query, where: fragment("?->>'type' = ANY(?)", activity.data, ^type))
835 defp restrict_type(query, _), do: query
837 defp restrict_state(query, %{"state" => state}) do
838 from(activity in query, where: fragment("?->>'state' = ?", activity.data, ^state))
841 defp restrict_state(query, _), do: query
843 defp restrict_favorited_by(query, %{"favorited_by" => ap_id}) do
845 [_activity, object] in query,
846 where: fragment("(?)->'likes' \\? (?)", object.data, ^ap_id)
850 defp restrict_favorited_by(query, _), do: query
852 defp restrict_media(_query, %{"only_media" => _val, "skip_preload" => true}) do
853 raise "Can't use the child object without preloading!"
856 defp restrict_media(query, %{"only_media" => val}) when val in [true, "true", "1"] do
858 [_activity, object] in query,
859 where: fragment("not (?)->'attachment' = (?)", object.data, ^[])
863 defp restrict_media(query, _), do: query
865 defp restrict_replies(query, %{"exclude_replies" => val}) when val in [true, "true", "1"] do
867 [_activity, object] in query,
868 where: fragment("?->>'inReplyTo' is null", object.data)
872 defp restrict_replies(query, %{
873 "reply_filtering_user" => user,
874 "reply_visibility" => "self"
877 [activity, object] in query,
880 "?->>'inReplyTo' is null OR ? = ANY(?)",
888 defp restrict_replies(query, %{
889 "reply_filtering_user" => user,
890 "reply_visibility" => "following"
893 [activity, object] in query,
896 "?->>'inReplyTo' is null OR ? && array_remove(?, ?) OR ? = ?",
898 ^[user.ap_id | User.get_cached_user_friends_ap_ids(user)],
907 defp restrict_replies(query, _), do: query
909 defp restrict_reblogs(query, %{"exclude_reblogs" => val}) when val in [true, "true", "1"] do
910 from(activity in query, where: fragment("?->>'type' != 'Announce'", activity.data))
913 defp restrict_reblogs(query, _), do: query
915 defp restrict_muted(query, %{"with_muted" => val}) when val in [true, "true", "1"], do: query
917 defp restrict_muted(query, %{"muting_user" => %User{} = user} = opts) do
918 mutes = opts["muted_users_ap_ids"] || User.muted_users_ap_ids(user)
921 from([activity] in query,
922 where: fragment("not (? = ANY(?))", activity.actor, ^mutes),
923 where: fragment("not (?->'to' \\?| ?)", activity.data, ^mutes)
926 unless opts["skip_preload"] do
927 from([thread_mute: tm] in query, where: is_nil(tm.user_id))
933 defp restrict_muted(query, _), do: query
935 defp restrict_blocked(query, %{"blocking_user" => %User{} = user} = opts) do
936 blocked_ap_ids = opts["blocked_users_ap_ids"] || User.blocked_users_ap_ids(user)
937 domain_blocks = user.domain_blocks || []
939 following_ap_ids = User.get_friends_ap_ids(user)
942 if has_named_binding?(query, :object), do: query, else: Activity.with_joined_object(query)
945 [activity, object: o] in query,
946 where: fragment("not (? = ANY(?))", activity.actor, ^blocked_ap_ids),
947 where: fragment("not (? && ?)", activity.recipients, ^blocked_ap_ids),
950 "not (?->>'type' = 'Announce' and ?->'to' \\?| ?)",
957 "(not (split_part(?, '/', 3) = ANY(?))) or ? = ANY(?)",
965 "(not (split_part(?->>'actor', '/', 3) = ANY(?))) or (?->>'actor') = ANY(?)",
974 defp restrict_blocked(query, _), do: query
976 defp restrict_unlisted(query) do
981 "not (coalesce(?->'cc', '{}'::jsonb) \\?| ?)",
983 ^[Constants.as_public()]
988 # TODO: when all endpoints migrated to OpenAPI compare `pinned` with `true` (boolean) only,
989 # the same for `restrict_media/2`, `restrict_replies/2`, 'restrict_reblogs/2'
990 # and `restrict_muted/2`
992 defp restrict_pinned(query, %{"pinned" => pinned, "pinned_activity_ids" => ids})
993 when pinned in [true, "true", "1"] do
994 from(activity in query, where: activity.id in ^ids)
997 defp restrict_pinned(query, _), do: query
999 defp restrict_muted_reblogs(query, %{"muting_user" => %User{} = user} = opts) do
1000 muted_reblogs = opts["reblog_muted_users_ap_ids"] || User.reblog_muted_users_ap_ids(user)
1006 "not ( ?->>'type' = 'Announce' and ? = ANY(?))",
1014 defp restrict_muted_reblogs(query, _), do: query
1016 defp restrict_instance(query, %{"instance" => instance}) do
1021 where: fragment("? LIKE ?", u.nickname, ^"%@#{instance}")
1025 from(activity in query, where: activity.actor in ^users)
1028 defp restrict_instance(query, _), do: query
1030 defp exclude_poll_votes(query, %{"include_poll_votes" => true}), do: query
1032 defp exclude_poll_votes(query, _) do
1033 if has_named_binding?(query, :object) do
1034 from([activity, object: o] in query,
1035 where: fragment("not(?->>'type' = ?)", o.data, "Answer")
1042 defp exclude_chat_messages(query, %{"include_chat_messages" => true}), do: query
1044 defp exclude_chat_messages(query, _) do
1045 if has_named_binding?(query, :object) do
1046 from([activity, object: o] in query,
1047 where: fragment("not(?->>'type' = ?)", o.data, "ChatMessage")
1054 defp exclude_invisible_actors(query, %{"invisible_actors" => true}), do: query
1056 defp exclude_invisible_actors(query, _opts) do
1058 User.Query.build(%{invisible: true, select: [:ap_id]})
1060 |> Enum.map(fn %{ap_id: ap_id} -> ap_id end)
1062 from([activity] in query, where: activity.actor not in ^invisible_ap_ids)
1065 defp exclude_id(query, %{"exclude_id" => id}) when is_binary(id) do
1066 from(activity in query, where: activity.id != ^id)
1069 defp exclude_id(query, _), do: query
1071 defp maybe_preload_objects(query, %{"skip_preload" => true}), do: query
1073 defp maybe_preload_objects(query, _) do
1075 |> Activity.with_preloaded_object()
1078 defp maybe_preload_bookmarks(query, %{"skip_preload" => true}), do: query
1080 defp maybe_preload_bookmarks(query, opts) do
1082 |> Activity.with_preloaded_bookmark(opts["user"])
1085 defp maybe_preload_report_notes(query, %{"preload_report_notes" => true}) do
1087 |> Activity.with_preloaded_report_notes()
1090 defp maybe_preload_report_notes(query, _), do: query
1092 defp maybe_set_thread_muted_field(query, %{"skip_preload" => true}), do: query
1094 defp maybe_set_thread_muted_field(query, opts) do
1096 |> Activity.with_set_thread_muted_field(opts["muting_user"] || opts["user"])
1099 defp maybe_order(query, %{order: :desc}) do
1101 |> order_by(desc: :id)
1104 defp maybe_order(query, %{order: :asc}) do
1106 |> order_by(asc: :id)
1109 defp maybe_order(query, _), do: query
1111 defp fetch_activities_query_ap_ids_ops(opts) do
1112 source_user = opts["muting_user"]
1113 ap_id_relationships = if source_user, do: [:mute, :reblog_mute], else: []
1115 ap_id_relationships =
1116 ap_id_relationships ++
1117 if opts["blocking_user"] && opts["blocking_user"] == source_user do
1123 preloaded_ap_ids = User.outgoing_relationships_ap_ids(source_user, ap_id_relationships)
1125 restrict_blocked_opts = Map.merge(%{"blocked_users_ap_ids" => preloaded_ap_ids[:block]}, opts)
1126 restrict_muted_opts = Map.merge(%{"muted_users_ap_ids" => preloaded_ap_ids[:mute]}, opts)
1128 restrict_muted_reblogs_opts =
1129 Map.merge(%{"reblog_muted_users_ap_ids" => preloaded_ap_ids[:reblog_mute]}, opts)
1131 {restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts}
1134 def fetch_activities_query(recipients, opts \\ %{}) do
1135 {restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts} =
1136 fetch_activities_query_ap_ids_ops(opts)
1139 skip_thread_containment: Config.get([:instance, :skip_thread_containment])
1143 |> maybe_preload_objects(opts)
1144 |> maybe_preload_bookmarks(opts)
1145 |> maybe_preload_report_notes(opts)
1146 |> maybe_set_thread_muted_field(opts)
1147 |> maybe_order(opts)
1148 |> restrict_recipients(recipients, opts["user"])
1149 |> restrict_replies(opts)
1150 |> restrict_tag(opts)
1151 |> restrict_tag_reject(opts)
1152 |> restrict_tag_all(opts)
1153 |> restrict_since(opts)
1154 |> restrict_local(opts)
1155 |> restrict_actor(opts)
1156 |> restrict_type(opts)
1157 |> restrict_state(opts)
1158 |> restrict_favorited_by(opts)
1159 |> restrict_blocked(restrict_blocked_opts)
1160 |> restrict_muted(restrict_muted_opts)
1161 |> restrict_media(opts)
1162 |> restrict_visibility(opts)
1163 |> restrict_thread_visibility(opts, config)
1164 |> restrict_reblogs(opts)
1165 |> restrict_pinned(opts)
1166 |> restrict_muted_reblogs(restrict_muted_reblogs_opts)
1167 |> restrict_instance(opts)
1168 |> Activity.restrict_deactivated_users()
1169 |> exclude_poll_votes(opts)
1170 |> exclude_chat_messages(opts)
1171 |> exclude_invisible_actors(opts)
1172 |> exclude_visibility(opts)
1175 def fetch_activities(recipients, opts \\ %{}, pagination \\ :keyset) do
1176 list_memberships = Pleroma.List.memberships(opts["user"])
1178 fetch_activities_query(recipients ++ list_memberships, opts)
1179 |> Pagination.fetch_paginated(opts, pagination)
1181 |> maybe_update_cc(list_memberships, opts["user"])
1185 Fetch favorites activities of user with order by sort adds to favorites
1187 @spec fetch_favourites(User.t(), map(), Pagination.type()) :: list(Activity.t())
1188 def fetch_favourites(user, params \\ %{}, pagination \\ :keyset) do
1190 |> Activity.Queries.by_actor()
1191 |> Activity.Queries.by_type("Like")
1192 |> Activity.with_joined_object()
1193 |> Object.with_joined_activity()
1194 |> select([_like, object, activity], %{activity | object: object})
1195 |> order_by([like, _, _], desc_nulls_last: like.id)
1196 |> Pagination.fetch_paginated(
1197 Map.merge(params, %{"skip_order" => true}),
1203 defp maybe_update_cc(activities, list_memberships, %User{ap_id: user_ap_id})
1204 when is_list(list_memberships) and length(list_memberships) > 0 do
1205 Enum.map(activities, fn
1206 %{data: %{"bcc" => bcc}} = activity when is_list(bcc) and length(bcc) > 0 ->
1207 if Enum.any?(bcc, &(&1 in list_memberships)) do
1208 update_in(activity.data["cc"], &[user_ap_id | &1])
1218 defp maybe_update_cc(activities, _, _), do: activities
1220 def fetch_activities_bounded_query(query, recipients, recipients_with_public) do
1221 from(activity in query,
1223 fragment("? && ?", activity.recipients, ^recipients) or
1224 (fragment("? && ?", activity.recipients, ^recipients_with_public) and
1225 ^Constants.as_public() in activity.recipients)
1229 def fetch_activities_bounded(
1231 recipients_with_public,
1233 pagination \\ :keyset
1235 fetch_activities_query([], opts)
1236 |> fetch_activities_bounded_query(recipients, recipients_with_public)
1237 |> Pagination.fetch_paginated(opts, pagination)
1241 @spec upload(Upload.source(), keyword()) :: {:ok, Object.t()} | {:error, any()}
1242 def upload(file, opts \\ []) do
1243 with {:ok, data} <- Upload.store(file, opts) do
1246 Map.put(data, "actor", opts[:actor])
1251 Repo.insert(%Object{data: obj_data})
1255 @spec get_actor_url(any()) :: binary() | nil
1256 defp get_actor_url(url) when is_binary(url), do: url
1257 defp get_actor_url(%{"href" => href}) when is_binary(href), do: href
1259 defp get_actor_url(url) when is_list(url) do
1265 defp get_actor_url(_url), do: nil
1267 defp object_to_user_data(data) do
1269 data["icon"]["url"] &&
1272 "url" => [%{"href" => data["icon"]["url"]}]
1276 data["image"]["url"] &&
1279 "url" => [%{"href" => data["image"]["url"]}]
1284 |> Map.get("attachment", [])
1285 |> Enum.filter(fn %{"type" => t} -> t == "PropertyValue" end)
1286 |> Enum.map(fn fields -> Map.take(fields, ["name", "value"]) end)
1290 |> Map.get("tag", [])
1292 %{"type" => "Emoji"} -> true
1295 |> Enum.reduce(%{}, fn %{"icon" => %{"url" => url}, "name" => name}, acc ->
1296 Map.put(acc, String.trim(name, ":"), url)
1299 locked = data["manuallyApprovesFollowers"] || false
1300 data = Transmogrifier.maybe_fix_user_object(data)
1301 discoverable = data["discoverable"] || false
1302 invisible = data["invisible"] || false
1303 actor_type = data["type"] || "Person"
1306 if is_map(data["publicKey"]) && is_binary(data["publicKey"]["publicKeyPem"]) do
1307 data["publicKey"]["publicKeyPem"]
1313 if is_map(data["endpoints"]) && is_binary(data["endpoints"]["sharedInbox"]) do
1314 data["endpoints"]["sharedInbox"]
1321 uri: get_actor_url(data["url"]),
1327 discoverable: discoverable,
1328 invisible: invisible,
1331 follower_address: data["followers"],
1332 following_address: data["following"],
1333 bio: data["summary"],
1334 actor_type: actor_type,
1335 also_known_as: Map.get(data, "alsoKnownAs", []),
1336 public_key: public_key,
1337 inbox: data["inbox"],
1338 shared_inbox: shared_inbox
1341 # nickname can be nil because of virtual actors
1343 if data["preferredUsername"] do
1347 "#{data["preferredUsername"]}@#{URI.parse(data["id"]).host}"
1350 Map.put(user_data, :nickname, nil)
1356 def fetch_follow_information_for_user(user) do
1357 with {:ok, following_data} <-
1358 Fetcher.fetch_and_contain_remote_object_from_id(user.following_address),
1359 {:ok, hide_follows} <- collection_private(following_data),
1360 {:ok, followers_data} <-
1361 Fetcher.fetch_and_contain_remote_object_from_id(user.follower_address),
1362 {:ok, hide_followers} <- collection_private(followers_data) do
1365 hide_follows: hide_follows,
1366 follower_count: normalize_counter(followers_data["totalItems"]),
1367 following_count: normalize_counter(following_data["totalItems"]),
1368 hide_followers: hide_followers
1371 {:error, _} = e -> e
1376 defp normalize_counter(counter) when is_integer(counter), do: counter
1377 defp normalize_counter(_), do: 0
1379 def maybe_update_follow_information(user_data) do
1380 with {:enabled, true} <- {:enabled, Config.get([:instance, :external_user_synchronization])},
1381 {_, true} <- {:user_type_check, user_data[:type] in ["Person", "Service"]},
1383 {:collections_available,
1384 !!(user_data[:following_address] && user_data[:follower_address])},
1386 fetch_follow_information_for_user(user_data) do
1387 info = Map.merge(user_data[:info] || %{}, info)
1390 |> Map.put(:info, info)
1392 {:user_type_check, false} ->
1395 {:collections_available, false} ->
1398 {:enabled, false} ->
1403 "Follower/Following counter update for #{user_data.ap_id} failed.\n" <> inspect(e)
1410 defp collection_private(%{"first" => %{"type" => type}})
1411 when type in ["CollectionPage", "OrderedCollectionPage"],
1414 defp collection_private(%{"first" => first}) do
1415 with {:ok, %{"type" => type}} when type in ["CollectionPage", "OrderedCollectionPage"] <-
1416 Fetcher.fetch_and_contain_remote_object_from_id(first) do
1419 {:error, {:ok, %{status: code}}} when code in [401, 403] -> {:ok, true}
1420 {:error, _} = e -> e
1425 defp collection_private(_data), do: {:ok, true}
1427 def user_data_from_user_object(data) do
1428 with {:ok, data} <- MRF.filter(data),
1429 {:ok, data} <- object_to_user_data(data) do
1436 def fetch_and_prepare_user_from_ap_id(ap_id) do
1437 with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id),
1438 {:ok, data} <- user_data_from_user_object(data),
1439 data <- maybe_update_follow_information(data) do
1442 {:error, "Object has been deleted"} = e ->
1443 Logger.debug("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
1447 Logger.error("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
1452 def make_user_from_ap_id(ap_id) do
1453 user = User.get_cached_by_ap_id(ap_id)
1455 if user && !User.ap_enabled?(user) do
1456 Transmogrifier.upgrade_user_from_ap_id(ap_id)
1458 with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id) do
1461 |> User.remote_user_changeset(data)
1462 |> User.update_and_set_cache()
1465 |> User.remote_user_changeset()
1475 def make_user_from_nickname(nickname) do
1476 with {:ok, %{"ap_id" => ap_id}} when not is_nil(ap_id) <- WebFinger.finger(nickname) do
1477 make_user_from_ap_id(ap_id)
1479 _e -> {:error, "No AP id in WebFinger"}
1483 # filter out broken threads
1484 def contain_broken_threads(%Activity{} = activity, %User{} = user) do
1485 entire_thread_visible_for_user?(activity, user)
1488 # do post-processing on a specific activity
1489 def contain_activity(%Activity{} = activity, %User{} = user) do
1490 contain_broken_threads(activity, user)
1493 def fetch_direct_messages_query do
1495 |> restrict_type(%{"type" => "Create"})
1496 |> restrict_visibility(%{visibility: "direct"})
1497 |> order_by([activity], asc: activity.id)