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 @spec persist(map(), keyword()) :: {:ok, Activity.t() | Object.t()}
130 def persist(object, meta) do
131 with local <- Keyword.fetch!(meta, :local),
132 {recipients, _, _} <- get_recipients(object),
134 Repo.insert(%Activity{
137 recipients: recipients,
138 actor: object["actor"]
140 {:ok, activity, meta}
144 @spec insert(map(), boolean(), boolean(), boolean()) :: {:ok, Activity.t()} | {:error, any()}
145 def insert(map, local \\ true, fake \\ false, bypass_actor_check \\ false) when is_map(map) do
146 with nil <- Activity.normalize(map),
147 map <- lazy_put_activity_defaults(map, fake),
148 true <- bypass_actor_check || check_actor_is_active(map["actor"]),
149 {_, true} <- {:remote_limit_error, check_remote_limit(map)},
150 {:ok, map} <- MRF.filter(map),
151 {recipients, _, _} = get_recipients(map),
152 {:fake, false, map, recipients} <- {:fake, fake, map, recipients},
153 {:containment, :ok} <- {:containment, Containment.contain_child(map)},
154 {:ok, map, object} <- insert_full_object(map) do
156 Repo.insert(%Activity{
160 recipients: recipients
163 # Splice in the child object if we have one.
165 if not is_nil(object) do
166 Map.put(activity, :object, object)
171 BackgroundWorker.enqueue("fetch_data_for_activity", %{"activity_id" => activity.id})
175 %Activity{} = activity ->
178 {:fake, true, map, recipients} ->
179 activity = %Activity{
183 recipients: recipients,
187 Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
195 def notify_and_stream(activity) do
196 Notification.create_notifications(activity)
198 conversation = create_or_bump_conversation(activity, activity.actor)
199 participations = get_participations(conversation)
201 stream_out_participations(participations)
204 defp create_or_bump_conversation(activity, actor) do
205 with {:ok, conversation} <- Conversation.create_or_bump_for(activity),
206 %User{} = user <- User.get_cached_by_ap_id(actor),
207 Participation.mark_as_read(user, conversation) do
212 defp get_participations({:ok, conversation}) do
214 |> Repo.preload(:participations, force: true)
215 |> Map.get(:participations)
218 defp get_participations(_), do: []
220 def stream_out_participations(participations) do
223 |> Repo.preload(:user)
225 Streamer.stream("participation", participations)
228 def stream_out_participations(%Object{data: %{"context" => context}}, user) do
229 with %Conversation{} = conversation <- Conversation.get_for_ap_id(context),
230 conversation = Repo.preload(conversation, :participations),
232 fetch_latest_activity_id_for_context(conversation.ap_id, %{
234 "blocking_user" => user
236 if last_activity_id do
237 stream_out_participations(conversation.participations)
242 def stream_out_participations(_, _), do: :noop
244 def stream_out(%Activity{data: %{"type" => data_type}} = activity)
245 when data_type in ["Create", "Announce", "Delete"] do
247 |> Topics.get_activity_topics()
248 |> Streamer.stream(activity)
251 def stream_out(_activity) do
255 @spec create(map(), boolean()) :: {:ok, Activity.t()} | {:error, any()}
256 def create(params, fake \\ false) do
257 with {:ok, result} <- Repo.transaction(fn -> do_create(params, fake) end) do
262 defp do_create(%{to: to, actor: actor, context: context, object: object} = params, fake) do
263 additional = params[:additional] || %{}
264 # only accept false as false value
265 local = !(params[:local] == false)
266 published = params[:published]
267 quick_insert? = Config.get([:env]) == :benchmark
271 %{to: to, actor: actor, published: published, context: context, object: object},
274 {:ok, activity} <- insert(create_data, local, fake),
275 {:fake, false, activity} <- {:fake, fake, activity},
276 _ <- increase_replies_count_if_reply(create_data),
277 _ <- increase_poll_votes_if_vote(create_data),
278 {:quick_insert, false, activity} <- {:quick_insert, quick_insert?, activity},
279 {:ok, _actor} <- increase_note_count_if_public(actor, activity),
280 _ <- notify_and_stream(activity),
281 :ok <- maybe_federate(activity) do
284 {:quick_insert, true, activity} ->
287 {:fake, true, activity} ->
291 Repo.rollback(message)
295 @spec listen(map()) :: {:ok, Activity.t()} | {:error, any()}
296 def listen(%{to: to, actor: actor, context: context, object: object} = params) do
297 additional = params[:additional] || %{}
298 # only accept false as false value
299 local = !(params[:local] == false)
300 published = params[:published]
304 %{to: to, actor: actor, published: published, context: context, object: object},
307 {:ok, activity} <- insert(listen_data, local),
308 _ <- notify_and_stream(activity),
309 :ok <- maybe_federate(activity) do
314 @spec accept(map()) :: {:ok, Activity.t()} | {:error, any()}
315 def accept(params) do
316 accept_or_reject("Accept", params)
319 @spec reject(map()) :: {:ok, Activity.t()} | {:error, any()}
320 def reject(params) do
321 accept_or_reject("Reject", params)
324 @spec accept_or_reject(String.t(), map()) :: {:ok, Activity.t()} | {:error, any()}
325 def accept_or_reject(type, %{to: to, actor: actor, object: object} = params) do
326 local = Map.get(params, :local, true)
327 activity_id = Map.get(params, :activity_id, nil)
330 %{"to" => to, "type" => type, "actor" => actor.ap_id, "object" => object}
331 |> Utils.maybe_put("id", activity_id),
332 {:ok, activity} <- insert(data, local),
333 _ <- notify_and_stream(activity),
334 :ok <- maybe_federate(activity) do
339 @spec update(map()) :: {:ok, Activity.t()} | {:error, any()}
340 def update(%{to: to, cc: cc, actor: actor, object: object} = params) do
341 local = !(params[:local] == false)
342 activity_id = params[:activity_id]
351 data <- Utils.maybe_put(data, "id", activity_id),
352 {:ok, activity} <- insert(data, local),
353 _ <- notify_and_stream(activity),
354 :ok <- maybe_federate(activity) do
359 @spec react_with_emoji(User.t(), Object.t(), String.t(), keyword()) ::
360 {:ok, Activity.t(), Object.t()} | {:error, any()}
361 def react_with_emoji(user, object, emoji, options \\ []) do
362 with {:ok, result} <-
363 Repo.transaction(fn -> do_react_with_emoji(user, object, emoji, options) end) do
368 defp do_react_with_emoji(user, object, emoji, options) do
369 with local <- Keyword.get(options, :local, true),
370 activity_id <- Keyword.get(options, :activity_id, nil),
371 true <- Pleroma.Emoji.is_unicode_emoji?(emoji),
372 reaction_data <- make_emoji_reaction_data(user, object, emoji, activity_id),
373 {:ok, activity} <- insert(reaction_data, local),
374 {:ok, object} <- add_emoji_reaction_to_object(activity, object),
375 _ <- notify_and_stream(activity),
376 :ok <- maybe_federate(activity) do
377 {:ok, activity, object}
379 false -> {:error, false}
380 {:error, error} -> Repo.rollback(error)
384 @spec announce(User.t(), Object.t(), String.t() | nil, boolean(), boolean()) ::
385 {:ok, Activity.t(), Object.t()} | {:error, any()}
387 %User{ap_id: _} = user,
388 %Object{data: %{"id" => _}} = object,
393 with {:ok, result} <-
394 Repo.transaction(fn -> do_announce(user, object, activity_id, local, public) end) do
399 defp do_announce(user, object, activity_id, local, public) do
400 with true <- is_announceable?(object, user, public),
401 object <- Object.get_by_id(object.id),
402 announce_data <- make_announce_data(user, object, activity_id, public),
403 {:ok, activity} <- insert(announce_data, local),
404 {:ok, object} <- add_announce_to_object(activity, object),
405 _ <- notify_and_stream(activity),
406 :ok <- maybe_federate(activity) do
407 {:ok, activity, object}
409 false -> {:error, false}
410 {:error, error} -> Repo.rollback(error)
414 @spec follow(User.t(), User.t(), String.t() | nil, boolean()) ::
415 {:ok, Activity.t()} | {:error, any()}
416 def follow(follower, followed, activity_id \\ nil, local \\ true) do
417 with {:ok, result} <-
418 Repo.transaction(fn -> do_follow(follower, followed, activity_id, local) end) do
423 defp do_follow(follower, followed, activity_id, local) do
424 with data <- make_follow_data(follower, followed, activity_id),
425 {:ok, activity} <- insert(data, local),
426 _ <- notify_and_stream(activity),
427 :ok <- maybe_federate(activity) do
430 {:error, error} -> Repo.rollback(error)
434 @spec unfollow(User.t(), User.t(), String.t() | nil, boolean()) ::
435 {:ok, Activity.t()} | nil | {:error, any()}
436 def unfollow(follower, followed, activity_id \\ nil, local \\ true) do
437 with {:ok, result} <-
438 Repo.transaction(fn -> do_unfollow(follower, followed, activity_id, local) end) do
443 defp do_unfollow(follower, followed, activity_id, local) 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 _ <- notify_and_stream(activity),
449 :ok <- maybe_federate(activity) do
453 {:error, error} -> Repo.rollback(error)
457 @spec block(User.t(), User.t(), String.t() | nil, boolean()) ::
458 {:ok, Activity.t()} | {:error, any()}
459 def block(blocker, blocked, activity_id \\ nil, local \\ true) do
460 with {:ok, result} <-
461 Repo.transaction(fn -> do_block(blocker, blocked, activity_id, local) end) do
466 defp do_block(blocker, blocked, activity_id, local) do
467 outgoing_blocks = Config.get([:activitypub, :outgoing_blocks])
468 unfollow_blocked = Config.get([:activitypub, :unfollow_blocked])
470 if unfollow_blocked do
471 follow_activity = fetch_latest_follow(blocker, blocked)
472 if follow_activity, do: unfollow(blocker, blocked, nil, local)
475 with true <- outgoing_blocks,
476 block_data <- make_block_data(blocker, blocked, activity_id),
477 {:ok, activity} <- insert(block_data, local),
478 _ <- notify_and_stream(activity),
479 :ok <- maybe_federate(activity) do
482 {:error, error} -> Repo.rollback(error)
486 @spec flag(map()) :: {:ok, Activity.t()} | {:error, any()}
496 # only accept false as false value
497 local = !(params[:local] == false)
498 forward = !(params[:forward] == false)
500 additional = params[:additional] || %{}
504 Map.merge(additional, %{"to" => [], "cc" => [account.ap_id]})
506 Map.merge(additional, %{"to" => [], "cc" => []})
509 with flag_data <- make_flag_data(params, additional),
510 {:ok, activity} <- insert(flag_data, local),
511 {:ok, stripped_activity} <- strip_report_status_data(activity),
512 _ <- notify_and_stream(activity),
513 :ok <- maybe_federate(stripped_activity) do
514 User.all_superusers()
515 |> Enum.filter(fn user -> not is_nil(user.email) end)
516 |> Enum.each(fn superuser ->
518 |> Pleroma.Emails.AdminEmail.report(actor, account, statuses, content)
519 |> Pleroma.Emails.Mailer.deliver_async()
526 @spec move(User.t(), User.t(), boolean()) :: {:ok, Activity.t()} | {:error, any()}
527 def move(%User{} = origin, %User{} = target, local \\ true) do
530 "actor" => origin.ap_id,
531 "object" => origin.ap_id,
532 "target" => target.ap_id
535 with true <- origin.ap_id in target.also_known_as,
536 {:ok, activity} <- insert(params, local),
537 _ <- notify_and_stream(activity) do
538 maybe_federate(activity)
540 BackgroundWorker.enqueue("move_following", %{
541 "origin_id" => origin.id,
542 "target_id" => target.id
547 false -> {:error, "Target account must have the origin in `alsoKnownAs`"}
552 def fetch_activities_for_context_query(context, opts) do
553 public = [Constants.as_public()]
557 do: [opts["user"].ap_id | User.following(opts["user"])] ++ public,
560 from(activity in Activity)
561 |> maybe_preload_objects(opts)
562 |> maybe_preload_bookmarks(opts)
563 |> maybe_set_thread_muted_field(opts)
564 |> restrict_blocked(opts)
565 |> restrict_recipients(recipients, opts["user"])
569 "?->>'type' = ? and ?->>'context' = ?",
576 |> exclude_poll_votes(opts)
578 |> order_by([activity], desc: activity.id)
581 @spec fetch_activities_for_context(String.t(), keyword() | map()) :: [Activity.t()]
582 def fetch_activities_for_context(context, opts \\ %{}) do
584 |> fetch_activities_for_context_query(opts)
588 @spec fetch_latest_activity_id_for_context(String.t(), keyword() | map()) ::
589 FlakeId.Ecto.CompatType.t() | nil
590 def fetch_latest_activity_id_for_context(context, opts \\ %{}) do
592 |> fetch_activities_for_context_query(Map.merge(%{"skip_preload" => true}, opts))
598 @spec fetch_public_activities(map(), Pagination.type()) :: [Activity.t()]
599 def fetch_public_activities(opts \\ %{}, pagination \\ :keyset) do
600 opts = Map.drop(opts, ["user"])
602 [Constants.as_public()]
603 |> fetch_activities_query(opts)
604 |> restrict_unlisted()
605 |> Pagination.fetch_paginated(opts, pagination)
608 @valid_visibilities ~w[direct unlisted public private]
610 defp restrict_visibility(query, %{visibility: visibility})
611 when is_list(visibility) do
612 if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
618 "activity_visibility(?, ?, ?) = ANY (?)",
628 Logger.error("Could not restrict visibility to #{visibility}")
632 defp restrict_visibility(query, %{visibility: visibility})
633 when visibility in @valid_visibilities do
637 fragment("activity_visibility(?, ?, ?) = ?", a.actor, a.recipients, a.data, ^visibility)
641 defp restrict_visibility(_query, %{visibility: visibility})
642 when visibility not in @valid_visibilities do
643 Logger.error("Could not restrict visibility to #{visibility}")
646 defp restrict_visibility(query, _visibility), do: query
648 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
649 when is_list(visibility) do
650 if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
655 "activity_visibility(?, ?, ?) = ANY (?)",
663 Logger.error("Could not exclude visibility to #{visibility}")
668 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
669 when visibility in @valid_visibilities do
674 "activity_visibility(?, ?, ?) = ?",
683 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
684 when visibility not in [nil | @valid_visibilities] do
685 Logger.error("Could not exclude visibility to #{visibility}")
689 defp exclude_visibility(query, _visibility), do: query
691 defp restrict_thread_visibility(query, _, %{skip_thread_containment: true} = _),
694 defp restrict_thread_visibility(
696 %{"user" => %User{skip_thread_containment: true}},
701 defp restrict_thread_visibility(query, %{"user" => %User{ap_id: ap_id}}, _) do
704 where: fragment("thread_visibility(?, (?)->>'id') = true", ^ap_id, a.data)
708 defp restrict_thread_visibility(query, _, _), do: query
710 def fetch_user_abstract_activities(user, reading_user, params \\ %{}) do
713 |> Map.put("user", reading_user)
714 |> Map.put("actor_id", user.ap_id)
717 user_activities_recipients(%{
718 "godmode" => params["godmode"],
719 "reading_user" => reading_user
722 fetch_activities(recipients, params)
726 def fetch_user_activities(user, reading_user, params \\ %{}) do
729 |> Map.put("type", ["Create", "Announce"])
730 |> Map.put("user", reading_user)
731 |> Map.put("actor_id", user.ap_id)
732 |> Map.put("pinned_activity_ids", user.pinned_activities)
735 if User.blocks?(reading_user, user) do
739 |> Map.put("blocking_user", reading_user)
740 |> Map.put("muting_user", reading_user)
744 user_activities_recipients(%{
745 "godmode" => params["godmode"],
746 "reading_user" => reading_user
749 fetch_activities(recipients, params)
753 def fetch_statuses(reading_user, params) do
756 |> Map.put("type", ["Create", "Announce"])
759 user_activities_recipients(%{
760 "godmode" => params["godmode"],
761 "reading_user" => reading_user
764 fetch_activities(recipients, params, :offset)
768 defp user_activities_recipients(%{"godmode" => true}) do
772 defp user_activities_recipients(%{"reading_user" => reading_user}) do
774 [Constants.as_public()] ++ [reading_user.ap_id | User.following(reading_user)]
776 [Constants.as_public()]
780 defp restrict_since(query, %{"since_id" => ""}), do: query
782 defp restrict_since(query, %{"since_id" => since_id}) do
783 from(activity in query, where: activity.id > ^since_id)
786 defp restrict_since(query, _), do: query
788 defp restrict_tag_reject(_query, %{"tag_reject" => _tag_reject, "skip_preload" => true}) do
789 raise "Can't use the child object without preloading!"
792 defp restrict_tag_reject(query, %{"tag_reject" => tag_reject})
793 when is_list(tag_reject) and tag_reject != [] do
795 [_activity, object] in query,
796 where: fragment("not (?)->'tag' \\?| (?)", object.data, ^tag_reject)
800 defp restrict_tag_reject(query, _), do: query
802 defp restrict_tag_all(_query, %{"tag_all" => _tag_all, "skip_preload" => true}) do
803 raise "Can't use the child object without preloading!"
806 defp restrict_tag_all(query, %{"tag_all" => tag_all})
807 when is_list(tag_all) and tag_all != [] do
809 [_activity, object] in query,
810 where: fragment("(?)->'tag' \\?& (?)", object.data, ^tag_all)
814 defp restrict_tag_all(query, _), do: query
816 defp restrict_tag(_query, %{"tag" => _tag, "skip_preload" => true}) do
817 raise "Can't use the child object without preloading!"
820 defp restrict_tag(query, %{"tag" => tag}) when is_list(tag) do
822 [_activity, object] in query,
823 where: fragment("(?)->'tag' \\?| (?)", object.data, ^tag)
827 defp restrict_tag(query, %{"tag" => tag}) when is_binary(tag) do
829 [_activity, object] in query,
830 where: fragment("(?)->'tag' \\? (?)", object.data, ^tag)
834 defp restrict_tag(query, _), do: query
836 defp restrict_recipients(query, [], _user), do: query
838 defp restrict_recipients(query, recipients, nil) do
839 from(activity in query, where: fragment("? && ?", ^recipients, activity.recipients))
842 defp restrict_recipients(query, recipients, user) do
845 where: fragment("? && ?", ^recipients, activity.recipients),
846 or_where: activity.actor == ^user.ap_id
850 defp restrict_local(query, %{"local_only" => true}) do
851 from(activity in query, where: activity.local == true)
854 defp restrict_local(query, _), do: query
856 defp restrict_actor(query, %{"actor_id" => actor_id}) do
857 from(activity in query, where: activity.actor == ^actor_id)
860 defp restrict_actor(query, _), do: query
862 defp restrict_type(query, %{"type" => type}) when is_binary(type) do
863 from(activity in query, where: fragment("?->>'type' = ?", activity.data, ^type))
866 defp restrict_type(query, %{"type" => type}) do
867 from(activity in query, where: fragment("?->>'type' = ANY(?)", activity.data, ^type))
870 defp restrict_type(query, _), do: query
872 defp restrict_state(query, %{"state" => state}) do
873 from(activity in query, where: fragment("?->>'state' = ?", activity.data, ^state))
876 defp restrict_state(query, _), do: query
878 defp restrict_favorited_by(query, %{"favorited_by" => ap_id}) do
880 [_activity, object] in query,
881 where: fragment("(?)->'likes' \\? (?)", object.data, ^ap_id)
885 defp restrict_favorited_by(query, _), do: query
887 defp restrict_media(_query, %{"only_media" => _val, "skip_preload" => true}) do
888 raise "Can't use the child object without preloading!"
891 defp restrict_media(query, %{"only_media" => val}) when val in [true, "true", "1"] do
893 [_activity, object] in query,
894 where: fragment("not (?)->'attachment' = (?)", object.data, ^[])
898 defp restrict_media(query, _), do: query
900 defp restrict_replies(query, %{"exclude_replies" => val}) when val in [true, "true", "1"] do
902 [_activity, object] in query,
903 where: fragment("?->>'inReplyTo' is null", object.data)
907 defp restrict_replies(query, %{
908 "reply_filtering_user" => user,
909 "reply_visibility" => "self"
912 [activity, object] in query,
915 "?->>'inReplyTo' is null OR ? = ANY(?)",
923 defp restrict_replies(query, %{
924 "reply_filtering_user" => user,
925 "reply_visibility" => "following"
928 [activity, object] in query,
931 "?->>'inReplyTo' is null OR ? && array_remove(?, ?) OR ? = ?",
933 ^[user.ap_id | User.get_cached_user_friends_ap_ids(user)],
942 defp restrict_replies(query, _), do: query
944 defp restrict_reblogs(query, %{"exclude_reblogs" => val}) when val in [true, "true", "1"] do
945 from(activity in query, where: fragment("?->>'type' != 'Announce'", activity.data))
948 defp restrict_reblogs(query, _), do: query
950 defp restrict_muted(query, %{"with_muted" => val}) when val in [true, "true", "1"], do: query
952 defp restrict_muted(query, %{"muting_user" => %User{} = user} = opts) do
953 mutes = opts["muted_users_ap_ids"] || User.muted_users_ap_ids(user)
956 from([activity] in query,
957 where: fragment("not (? = ANY(?))", activity.actor, ^mutes),
958 where: fragment("not (?->'to' \\?| ?)", activity.data, ^mutes)
961 unless opts["skip_preload"] do
962 from([thread_mute: tm] in query, where: is_nil(tm.user_id))
968 defp restrict_muted(query, _), do: query
970 defp restrict_blocked(query, %{"blocking_user" => %User{} = user} = opts) do
971 blocked_ap_ids = opts["blocked_users_ap_ids"] || User.blocked_users_ap_ids(user)
972 domain_blocks = user.domain_blocks || []
974 following_ap_ids = User.get_friends_ap_ids(user)
977 if has_named_binding?(query, :object), do: query, else: Activity.with_joined_object(query)
980 [activity, object: o] in query,
981 where: fragment("not (? = ANY(?))", activity.actor, ^blocked_ap_ids),
982 where: fragment("not (? && ?)", activity.recipients, ^blocked_ap_ids),
985 "not (?->>'type' = 'Announce' and ?->'to' \\?| ?)",
992 "(not (split_part(?, '/', 3) = ANY(?))) or ? = ANY(?)",
1000 "(not (split_part(?->>'actor', '/', 3) = ANY(?))) or (?->>'actor') = ANY(?)",
1009 defp restrict_blocked(query, _), do: query
1011 defp restrict_unlisted(query) do
1016 "not (coalesce(?->'cc', '{}'::jsonb) \\?| ?)",
1018 ^[Constants.as_public()]
1023 # TODO: when all endpoints migrated to OpenAPI compare `pinned` with `true` (boolean) only,
1024 # the same for `restrict_media/2`, `restrict_replies/2`, 'restrict_reblogs/2'
1025 # and `restrict_muted/2`
1027 defp restrict_pinned(query, %{"pinned" => pinned, "pinned_activity_ids" => ids})
1028 when pinned in [true, "true", "1"] do
1029 from(activity in query, where: activity.id in ^ids)
1032 defp restrict_pinned(query, _), do: query
1034 defp restrict_muted_reblogs(query, %{"muting_user" => %User{} = user} = opts) do
1035 muted_reblogs = opts["reblog_muted_users_ap_ids"] || User.reblog_muted_users_ap_ids(user)
1041 "not ( ?->>'type' = 'Announce' and ? = ANY(?))",
1049 defp restrict_muted_reblogs(query, _), do: query
1051 defp restrict_instance(query, %{"instance" => instance}) do
1056 where: fragment("? LIKE ?", u.nickname, ^"%@#{instance}")
1060 from(activity in query, where: activity.actor in ^users)
1063 defp restrict_instance(query, _), do: query
1065 defp exclude_poll_votes(query, %{"include_poll_votes" => true}), do: query
1067 defp exclude_poll_votes(query, _) do
1068 if has_named_binding?(query, :object) do
1069 from([activity, object: o] in query,
1070 where: fragment("not(?->>'type' = ?)", o.data, "Answer")
1077 defp exclude_id(query, %{"exclude_id" => id}) when is_binary(id) do
1078 from(activity in query, where: activity.id != ^id)
1081 defp exclude_id(query, _), do: query
1083 defp maybe_preload_objects(query, %{"skip_preload" => true}), do: query
1085 defp maybe_preload_objects(query, _) do
1087 |> Activity.with_preloaded_object()
1090 defp maybe_preload_bookmarks(query, %{"skip_preload" => true}), do: query
1092 defp maybe_preload_bookmarks(query, opts) do
1094 |> Activity.with_preloaded_bookmark(opts["user"])
1097 defp maybe_preload_report_notes(query, %{"preload_report_notes" => true}) do
1099 |> Activity.with_preloaded_report_notes()
1102 defp maybe_preload_report_notes(query, _), do: query
1104 defp maybe_set_thread_muted_field(query, %{"skip_preload" => true}), do: query
1106 defp maybe_set_thread_muted_field(query, opts) do
1108 |> Activity.with_set_thread_muted_field(opts["muting_user"] || opts["user"])
1111 defp maybe_order(query, %{order: :desc}) do
1113 |> order_by(desc: :id)
1116 defp maybe_order(query, %{order: :asc}) do
1118 |> order_by(asc: :id)
1121 defp maybe_order(query, _), do: query
1123 defp fetch_activities_query_ap_ids_ops(opts) do
1124 source_user = opts["muting_user"]
1125 ap_id_relationships = if source_user, do: [:mute, :reblog_mute], else: []
1127 ap_id_relationships =
1128 ap_id_relationships ++
1129 if opts["blocking_user"] && opts["blocking_user"] == source_user do
1135 preloaded_ap_ids = User.outgoing_relationships_ap_ids(source_user, ap_id_relationships)
1137 restrict_blocked_opts = Map.merge(%{"blocked_users_ap_ids" => preloaded_ap_ids[:block]}, opts)
1138 restrict_muted_opts = Map.merge(%{"muted_users_ap_ids" => preloaded_ap_ids[:mute]}, opts)
1140 restrict_muted_reblogs_opts =
1141 Map.merge(%{"reblog_muted_users_ap_ids" => preloaded_ap_ids[:reblog_mute]}, opts)
1143 {restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts}
1146 def fetch_activities_query(recipients, opts \\ %{}) do
1147 {restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts} =
1148 fetch_activities_query_ap_ids_ops(opts)
1151 skip_thread_containment: Config.get([:instance, :skip_thread_containment])
1155 |> maybe_preload_objects(opts)
1156 |> maybe_preload_bookmarks(opts)
1157 |> maybe_preload_report_notes(opts)
1158 |> maybe_set_thread_muted_field(opts)
1159 |> maybe_order(opts)
1160 |> restrict_recipients(recipients, opts["user"])
1161 |> restrict_replies(opts)
1162 |> restrict_tag(opts)
1163 |> restrict_tag_reject(opts)
1164 |> restrict_tag_all(opts)
1165 |> restrict_since(opts)
1166 |> restrict_local(opts)
1167 |> restrict_actor(opts)
1168 |> restrict_type(opts)
1169 |> restrict_state(opts)
1170 |> restrict_favorited_by(opts)
1171 |> restrict_blocked(restrict_blocked_opts)
1172 |> restrict_muted(restrict_muted_opts)
1173 |> restrict_media(opts)
1174 |> restrict_visibility(opts)
1175 |> restrict_thread_visibility(opts, config)
1176 |> restrict_reblogs(opts)
1177 |> restrict_pinned(opts)
1178 |> restrict_muted_reblogs(restrict_muted_reblogs_opts)
1179 |> restrict_instance(opts)
1180 |> Activity.restrict_deactivated_users()
1181 |> exclude_poll_votes(opts)
1182 |> exclude_visibility(opts)
1185 def fetch_activities(recipients, opts \\ %{}, pagination \\ :keyset) do
1186 list_memberships = Pleroma.List.memberships(opts["user"])
1188 fetch_activities_query(recipients ++ list_memberships, opts)
1189 |> Pagination.fetch_paginated(opts, pagination)
1191 |> maybe_update_cc(list_memberships, opts["user"])
1195 Fetch favorites activities of user with order by sort adds to favorites
1197 @spec fetch_favourites(User.t(), map(), Pagination.type()) :: list(Activity.t())
1198 def fetch_favourites(user, params \\ %{}, pagination \\ :keyset) do
1200 |> Activity.Queries.by_actor()
1201 |> Activity.Queries.by_type("Like")
1202 |> Activity.with_joined_object()
1203 |> Object.with_joined_activity()
1204 |> select([_like, object, activity], %{activity | object: object})
1205 |> order_by([like, _, _], desc: like.id)
1206 |> Pagination.fetch_paginated(
1207 Map.merge(params, %{"skip_order" => true}),
1213 defp maybe_update_cc(activities, list_memberships, %User{ap_id: user_ap_id})
1214 when is_list(list_memberships) and length(list_memberships) > 0 do
1215 Enum.map(activities, fn
1216 %{data: %{"bcc" => bcc}} = activity when is_list(bcc) and length(bcc) > 0 ->
1217 if Enum.any?(bcc, &(&1 in list_memberships)) do
1218 update_in(activity.data["cc"], &[user_ap_id | &1])
1228 defp maybe_update_cc(activities, _, _), do: activities
1230 def fetch_activities_bounded_query(query, recipients, recipients_with_public) do
1231 from(activity in query,
1233 fragment("? && ?", activity.recipients, ^recipients) or
1234 (fragment("? && ?", activity.recipients, ^recipients_with_public) and
1235 ^Constants.as_public() in activity.recipients)
1239 def fetch_activities_bounded(
1241 recipients_with_public,
1243 pagination \\ :keyset
1245 fetch_activities_query([], opts)
1246 |> fetch_activities_bounded_query(recipients, recipients_with_public)
1247 |> Pagination.fetch_paginated(opts, pagination)
1251 @spec upload(Upload.source(), keyword()) :: {:ok, Object.t()} | {:error, any()}
1252 def upload(file, opts \\ []) do
1253 with {:ok, data} <- Upload.store(file, opts) do
1256 Map.put(data, "actor", opts[:actor])
1261 Repo.insert(%Object{data: obj_data})
1265 @spec get_actor_url(any()) :: binary() | nil
1266 defp get_actor_url(url) when is_binary(url), do: url
1267 defp get_actor_url(%{"href" => href}) when is_binary(href), do: href
1269 defp get_actor_url(url) when is_list(url) do
1275 defp get_actor_url(_url), do: nil
1277 defp object_to_user_data(data) do
1279 data["icon"]["url"] &&
1282 "url" => [%{"href" => data["icon"]["url"]}]
1286 data["image"]["url"] &&
1289 "url" => [%{"href" => data["image"]["url"]}]
1294 |> Map.get("attachment", [])
1295 |> Enum.filter(fn %{"type" => t} -> t == "PropertyValue" end)
1296 |> Enum.map(fn fields -> Map.take(fields, ["name", "value"]) end)
1300 |> Map.get("tag", [])
1302 %{"type" => "Emoji"} -> true
1305 |> Enum.reduce(%{}, fn %{"icon" => %{"url" => url}, "name" => name}, acc ->
1306 Map.put(acc, String.trim(name, ":"), url)
1309 locked = data["manuallyApprovesFollowers"] || false
1310 data = Transmogrifier.maybe_fix_user_object(data)
1311 discoverable = data["discoverable"] || false
1312 invisible = data["invisible"] || false
1313 actor_type = data["type"] || "Person"
1316 if is_map(data["publicKey"]) && is_binary(data["publicKey"]["publicKeyPem"]) do
1317 data["publicKey"]["publicKeyPem"]
1323 if is_map(data["endpoints"]) && is_binary(data["endpoints"]["sharedInbox"]) do
1324 data["endpoints"]["sharedInbox"]
1331 uri: get_actor_url(data["url"]),
1337 discoverable: discoverable,
1338 invisible: invisible,
1341 follower_address: data["followers"],
1342 following_address: data["following"],
1343 bio: data["summary"],
1344 actor_type: actor_type,
1345 also_known_as: Map.get(data, "alsoKnownAs", []),
1346 public_key: public_key,
1347 inbox: data["inbox"],
1348 shared_inbox: shared_inbox
1351 # nickname can be nil because of virtual actors
1353 if data["preferredUsername"] do
1357 "#{data["preferredUsername"]}@#{URI.parse(data["id"]).host}"
1360 Map.put(user_data, :nickname, nil)
1366 def fetch_follow_information_for_user(user) do
1367 with {:ok, following_data} <-
1368 Fetcher.fetch_and_contain_remote_object_from_id(user.following_address),
1369 {:ok, hide_follows} <- collection_private(following_data),
1370 {:ok, followers_data} <-
1371 Fetcher.fetch_and_contain_remote_object_from_id(user.follower_address),
1372 {:ok, hide_followers} <- collection_private(followers_data) do
1375 hide_follows: hide_follows,
1376 follower_count: normalize_counter(followers_data["totalItems"]),
1377 following_count: normalize_counter(following_data["totalItems"]),
1378 hide_followers: hide_followers
1381 {:error, _} = e -> e
1386 defp normalize_counter(counter) when is_integer(counter), do: counter
1387 defp normalize_counter(_), do: 0
1389 def maybe_update_follow_information(user_data) do
1390 with {:enabled, true} <- {:enabled, Config.get([:instance, :external_user_synchronization])},
1391 {_, true} <- {:user_type_check, user_data[:type] in ["Person", "Service"]},
1393 {:collections_available,
1394 !!(user_data[:following_address] && user_data[:follower_address])},
1396 fetch_follow_information_for_user(user_data) do
1397 info = Map.merge(user_data[:info] || %{}, info)
1400 |> Map.put(:info, info)
1402 {:user_type_check, false} ->
1405 {:collections_available, false} ->
1408 {:enabled, false} ->
1413 "Follower/Following counter update for #{user_data.ap_id} failed.\n" <> inspect(e)
1420 defp collection_private(%{"first" => %{"type" => type}})
1421 when type in ["CollectionPage", "OrderedCollectionPage"],
1424 defp collection_private(%{"first" => first}) do
1425 with {:ok, %{"type" => type}} when type in ["CollectionPage", "OrderedCollectionPage"] <-
1426 Fetcher.fetch_and_contain_remote_object_from_id(first) do
1429 {:error, {:ok, %{status: code}}} when code in [401, 403] -> {:ok, true}
1430 {:error, _} = e -> e
1435 defp collection_private(_data), do: {:ok, true}
1437 def user_data_from_user_object(data) do
1438 with {:ok, data} <- MRF.filter(data),
1439 {:ok, data} <- object_to_user_data(data) do
1446 def fetch_and_prepare_user_from_ap_id(ap_id) do
1447 with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id),
1448 {:ok, data} <- user_data_from_user_object(data),
1449 data <- maybe_update_follow_information(data) do
1452 {:error, "Object has been deleted"} = e ->
1453 Logger.debug("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
1457 Logger.error("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
1462 def make_user_from_ap_id(ap_id) do
1463 user = User.get_cached_by_ap_id(ap_id)
1465 if user && !User.ap_enabled?(user) do
1466 Transmogrifier.upgrade_user_from_ap_id(ap_id)
1468 with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id) do
1471 |> User.remote_user_changeset(data)
1472 |> User.update_and_set_cache()
1475 |> User.remote_user_changeset()
1485 def make_user_from_nickname(nickname) do
1486 with {:ok, %{"ap_id" => ap_id}} when not is_nil(ap_id) <- WebFinger.finger(nickname) do
1487 make_user_from_ap_id(ap_id)
1489 _e -> {:error, "No AP id in WebFinger"}
1493 # filter out broken threads
1494 def contain_broken_threads(%Activity{} = activity, %User{} = user) do
1495 entire_thread_visible_for_user?(activity, user)
1498 # do post-processing on a specific activity
1499 def contain_activity(%Activity{} = activity, %User{} = user) do
1500 contain_broken_threads(activity, user)
1503 def fetch_direct_messages_query do
1505 |> restrict_type(%{"type" => "Create"})
1506 |> restrict_visibility(%{visibility: "direct"})
1507 |> order_by([activity], asc: activity.id)