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})
173 Notification.create_notifications(activity)
175 conversation = create_or_bump_conversation(activity, map["actor"])
176 participations = get_participations(conversation)
178 stream_out_participations(participations)
181 %Activity{} = activity ->
184 {:fake, true, map, recipients} ->
185 activity = %Activity{
189 recipients: recipients,
193 Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
201 defp create_or_bump_conversation(activity, actor) do
202 with {:ok, conversation} <- Conversation.create_or_bump_for(activity),
203 %User{} = user <- User.get_cached_by_ap_id(actor),
204 Participation.mark_as_read(user, conversation) do
209 defp get_participations({:ok, conversation}) do
211 |> Repo.preload(:participations, force: true)
212 |> Map.get(:participations)
215 defp get_participations(_), do: []
217 def stream_out_participations(participations) do
220 |> Repo.preload(:user)
222 Streamer.stream("participation", participations)
225 def stream_out_participations(%Object{data: %{"context" => context}}, user) do
226 with %Conversation{} = conversation <- Conversation.get_for_ap_id(context),
227 conversation = Repo.preload(conversation, :participations),
229 fetch_latest_activity_id_for_context(conversation.ap_id, %{
231 "blocking_user" => user
233 if last_activity_id do
234 stream_out_participations(conversation.participations)
239 def stream_out_participations(_, _), do: :noop
241 def stream_out(%Activity{data: %{"type" => data_type}} = activity)
242 when data_type in ["Create", "Announce", "Delete"] do
244 |> Topics.get_activity_topics()
245 |> Streamer.stream(activity)
248 def stream_out(_activity) do
252 @spec create(map(), boolean()) :: {:ok, Activity.t()} | {:error, any()}
253 def create(params, fake \\ false) do
254 with {:ok, result} <- Repo.transaction(fn -> do_create(params, fake) end) do
259 defp do_create(%{to: to, actor: actor, context: context, object: object} = params, fake) do
260 additional = params[:additional] || %{}
261 # only accept false as false value
262 local = !(params[:local] == false)
263 published = params[:published]
264 quick_insert? = Config.get([:env]) == :benchmark
268 %{to: to, actor: actor, published: published, context: context, object: object},
271 {:ok, activity} <- insert(create_data, local, fake),
272 {:fake, false, activity} <- {:fake, fake, activity},
273 _ <- increase_replies_count_if_reply(create_data),
274 _ <- increase_poll_votes_if_vote(create_data),
275 {:quick_insert, false, activity} <- {:quick_insert, quick_insert?, activity},
276 {:ok, _actor} <- increase_note_count_if_public(actor, activity),
277 :ok <- maybe_federate(activity) do
280 {:quick_insert, true, activity} ->
283 {:fake, true, activity} ->
287 Repo.rollback(message)
291 @spec listen(map()) :: {:ok, Activity.t()} | {:error, any()}
292 def listen(%{to: to, actor: actor, context: context, object: object} = params) do
293 additional = params[:additional] || %{}
294 # only accept false as false value
295 local = !(params[:local] == false)
296 published = params[:published]
300 %{to: to, actor: actor, published: published, context: context, object: object},
303 {:ok, activity} <- insert(listen_data, local),
304 :ok <- maybe_federate(activity) do
309 @spec accept(map()) :: {:ok, Activity.t()} | {:error, any()}
310 def accept(params) do
311 accept_or_reject("Accept", params)
314 @spec reject(map()) :: {:ok, Activity.t()} | {:error, any()}
315 def reject(params) do
316 accept_or_reject("Reject", params)
319 @spec accept_or_reject(String.t(), map()) :: {:ok, Activity.t()} | {:error, any()}
320 def accept_or_reject(type, %{to: to, actor: actor, object: object} = params) do
321 local = Map.get(params, :local, true)
322 activity_id = Map.get(params, :activity_id, nil)
325 %{"to" => to, "type" => type, "actor" => actor.ap_id, "object" => object}
326 |> Utils.maybe_put("id", activity_id),
327 {:ok, activity} <- insert(data, local),
328 :ok <- maybe_federate(activity) do
333 @spec update(map()) :: {:ok, Activity.t()} | {:error, any()}
334 def update(%{to: to, cc: cc, actor: actor, object: object} = params) do
335 local = !(params[:local] == false)
336 activity_id = params[:activity_id]
345 data <- Utils.maybe_put(data, "id", activity_id),
346 {:ok, activity} <- insert(data, local),
347 :ok <- maybe_federate(activity) do
352 @spec unreact_with_emoji(User.t(), String.t(), keyword()) ::
353 {:ok, Activity.t(), Object.t()} | {:error, any()}
354 def unreact_with_emoji(user, reaction_id, options \\ []) do
355 with {:ok, result} <-
356 Repo.transaction(fn -> do_unreact_with_emoji(user, reaction_id, options) end) do
361 defp do_unreact_with_emoji(user, reaction_id, options) do
362 with local <- Keyword.get(options, :local, true),
363 activity_id <- Keyword.get(options, :activity_id, nil),
364 user_ap_id <- user.ap_id,
365 %Activity{actor: ^user_ap_id} = reaction_activity <- Activity.get_by_ap_id(reaction_id),
366 object <- Object.normalize(reaction_activity),
367 unreact_data <- make_undo_data(user, reaction_activity, activity_id),
368 {:ok, activity} <- insert(unreact_data, local),
369 {:ok, object} <- remove_emoji_reaction_from_object(reaction_activity, object),
370 :ok <- maybe_federate(activity) do
371 {:ok, activity, object}
373 {:error, error} -> Repo.rollback(error)
377 @spec unlike(User.t(), Object.t(), String.t() | nil, boolean()) ::
378 {:ok, Activity.t(), Activity.t(), Object.t()} | {:ok, Object.t()} | {:error, any()}
379 def unlike(%User{} = actor, %Object{} = object, activity_id \\ nil, local \\ true) do
380 with {:ok, result} <-
381 Repo.transaction(fn -> do_unlike(actor, object, activity_id, local) end) do
386 defp do_unlike(actor, object, activity_id, local) do
387 with %Activity{} = like_activity <- get_existing_like(actor.ap_id, object),
388 unlike_data <- make_unlike_data(actor, like_activity, activity_id),
389 {:ok, unlike_activity} <- insert(unlike_data, local),
390 {:ok, _activity} <- Repo.delete(like_activity),
391 {:ok, object} <- remove_like_from_object(like_activity, object),
392 :ok <- maybe_federate(unlike_activity) do
393 {:ok, unlike_activity, like_activity, object}
396 {:error, error} -> Repo.rollback(error)
400 @spec announce(User.t(), Object.t(), String.t() | nil, boolean(), boolean()) ::
401 {:ok, Activity.t(), Object.t()} | {:error, any()}
403 %User{ap_id: _} = user,
404 %Object{data: %{"id" => _}} = object,
409 with {:ok, result} <-
410 Repo.transaction(fn -> do_announce(user, object, activity_id, local, public) end) do
415 defp do_announce(user, object, activity_id, local, public) do
416 with true <- is_announceable?(object, user, public),
417 object <- Object.get_by_id(object.id),
418 announce_data <- make_announce_data(user, object, activity_id, public),
419 {:ok, activity} <- insert(announce_data, local),
420 {:ok, object} <- add_announce_to_object(activity, object),
421 :ok <- maybe_federate(activity) do
422 {:ok, activity, object}
424 false -> {:error, false}
425 {:error, error} -> Repo.rollback(error)
429 @spec unannounce(User.t(), Object.t(), String.t() | nil, boolean()) ::
430 {:ok, Activity.t(), Object.t()} | {:ok, Object.t()} | {:error, any()}
437 with {:ok, result} <-
438 Repo.transaction(fn -> do_unannounce(actor, object, activity_id, local) end) do
443 defp do_unannounce(actor, object, activity_id, local) do
444 with %Activity{} = announce_activity <- get_existing_announce(actor.ap_id, object),
445 unannounce_data <- make_unannounce_data(actor, announce_activity, activity_id),
446 {:ok, unannounce_activity} <- insert(unannounce_data, local),
447 :ok <- maybe_federate(unannounce_activity),
448 {:ok, _activity} <- Repo.delete(announce_activity),
449 {:ok, object} <- remove_announce_from_object(announce_activity, object) do
450 {:ok, unannounce_activity, object}
453 {:error, error} -> Repo.rollback(error)
457 @spec follow(User.t(), User.t(), String.t() | nil, boolean()) ::
458 {:ok, Activity.t()} | {:error, any()}
459 def follow(follower, followed, activity_id \\ nil, local \\ true) do
460 with {:ok, result} <-
461 Repo.transaction(fn -> do_follow(follower, followed, activity_id, local) end) do
466 defp do_follow(follower, followed, activity_id, local) do
467 with data <- make_follow_data(follower, followed, activity_id),
468 {:ok, activity} <- insert(data, local),
469 :ok <- maybe_federate(activity) do
472 {:error, error} -> Repo.rollback(error)
476 @spec unfollow(User.t(), User.t(), String.t() | nil, boolean()) ::
477 {:ok, Activity.t()} | nil | {:error, any()}
478 def unfollow(follower, followed, activity_id \\ nil, local \\ true) do
479 with {:ok, result} <-
480 Repo.transaction(fn -> do_unfollow(follower, followed, activity_id, local) end) do
485 defp do_unfollow(follower, followed, activity_id, local) do
486 with %Activity{} = follow_activity <- fetch_latest_follow(follower, followed),
487 {:ok, follow_activity} <- update_follow_state(follow_activity, "cancelled"),
488 unfollow_data <- make_unfollow_data(follower, followed, follow_activity, activity_id),
489 {:ok, activity} <- insert(unfollow_data, local),
490 :ok <- maybe_federate(activity) do
494 {:error, error} -> Repo.rollback(error)
498 @spec delete(User.t() | Object.t(), keyword()) :: {:ok, User.t() | Object.t()} | {:error, any()}
499 def delete(entity, options \\ []) do
500 with {:ok, result} <- Repo.transaction(fn -> do_delete(entity, options) end) do
505 defp do_delete(%User{ap_id: ap_id, follower_address: follower_address} = user, _) do
507 "to" => [follower_address],
510 "object" => %{"type" => "Person", "id" => ap_id}
512 {:ok, activity} <- insert(data, true, true, true),
513 :ok <- maybe_federate(activity) do
518 defp do_delete(%Object{data: %{"id" => id, "actor" => actor}} = object, options) do
519 local = Keyword.get(options, :local, true)
520 activity_id = Keyword.get(options, :activity_id, nil)
521 actor = Keyword.get(options, :actor, actor)
523 user = User.get_cached_by_ap_id(actor)
524 to = (object.data["to"] || []) ++ (object.data["cc"] || [])
526 with create_activity <- Activity.get_create_by_object_ap_id(id),
533 "deleted_activity_id" => create_activity && create_activity.id
535 |> maybe_put("id", activity_id),
536 {:ok, activity} <- insert(data, local, false),
537 {:ok, object, _create_activity} <- Object.delete(object),
538 stream_out_participations(object, user),
539 _ <- decrease_replies_count_if_reply(object),
540 {:ok, _actor} <- decrease_note_count_if_public(user, object),
541 :ok <- maybe_federate(activity) do
549 defp do_delete(%Object{data: %{"type" => "Tombstone", "id" => ap_id}}, _) do
552 |> Activity.Queries.by_object_id()
553 |> Activity.Queries.by_type("Delete")
559 @spec block(User.t(), User.t(), String.t() | nil, boolean()) ::
560 {:ok, Activity.t()} | {:error, any()}
561 def block(blocker, blocked, activity_id \\ nil, local \\ true) do
562 with {:ok, result} <-
563 Repo.transaction(fn -> do_block(blocker, blocked, activity_id, local) end) do
568 defp do_block(blocker, blocked, activity_id, local) do
569 outgoing_blocks = Config.get([:activitypub, :outgoing_blocks])
570 unfollow_blocked = Config.get([:activitypub, :unfollow_blocked])
572 if unfollow_blocked do
573 follow_activity = fetch_latest_follow(blocker, blocked)
574 if follow_activity, do: unfollow(blocker, blocked, nil, local)
577 with true <- outgoing_blocks,
578 block_data <- make_block_data(blocker, blocked, activity_id),
579 {:ok, activity} <- insert(block_data, local),
580 :ok <- maybe_federate(activity) do
583 {:error, error} -> Repo.rollback(error)
587 @spec unblock(User.t(), User.t(), String.t() | nil, boolean()) ::
588 {:ok, Activity.t()} | {:error, any()} | nil
589 def unblock(blocker, blocked, activity_id \\ nil, local \\ true) do
590 with {:ok, result} <-
591 Repo.transaction(fn -> do_unblock(blocker, blocked, activity_id, local) end) do
596 defp do_unblock(blocker, blocked, activity_id, local) do
597 with %Activity{} = block_activity <- fetch_latest_block(blocker, blocked),
598 unblock_data <- make_unblock_data(blocker, blocked, block_activity, activity_id),
599 {:ok, activity} <- insert(unblock_data, local),
600 :ok <- maybe_federate(activity) do
604 {:error, error} -> Repo.rollback(error)
608 @spec flag(map()) :: {:ok, Activity.t()} | {:error, any()}
618 # only accept false as false value
619 local = !(params[:local] == false)
620 forward = !(params[:forward] == false)
622 additional = params[:additional] || %{}
626 Map.merge(additional, %{"to" => [], "cc" => [account.ap_id]})
628 Map.merge(additional, %{"to" => [], "cc" => []})
631 with flag_data <- make_flag_data(params, additional),
632 {:ok, activity} <- insert(flag_data, local),
633 {:ok, stripped_activity} <- strip_report_status_data(activity),
634 :ok <- maybe_federate(stripped_activity) do
635 User.all_superusers()
636 |> Enum.filter(fn user -> not is_nil(user.email) end)
637 |> Enum.each(fn superuser ->
639 |> Pleroma.Emails.AdminEmail.report(actor, account, statuses, content)
640 |> Pleroma.Emails.Mailer.deliver_async()
647 @spec move(User.t(), User.t(), boolean()) :: {:ok, Activity.t()} | {:error, any()}
648 def move(%User{} = origin, %User{} = target, local \\ true) do
651 "actor" => origin.ap_id,
652 "object" => origin.ap_id,
653 "target" => target.ap_id
656 with true <- origin.ap_id in target.also_known_as,
657 {:ok, activity} <- insert(params, local) do
658 maybe_federate(activity)
660 BackgroundWorker.enqueue("move_following", %{
661 "origin_id" => origin.id,
662 "target_id" => target.id
667 false -> {:error, "Target account must have the origin in `alsoKnownAs`"}
672 def fetch_activities_for_context_query(context, opts) do
673 public = [Constants.as_public()]
677 do: [opts["user"].ap_id | User.following(opts["user"])] ++ public,
680 from(activity in Activity)
681 |> maybe_preload_objects(opts)
682 |> maybe_preload_bookmarks(opts)
683 |> maybe_set_thread_muted_field(opts)
684 |> restrict_blocked(opts)
685 |> restrict_recipients(recipients, opts["user"])
689 "?->>'type' = ? and ?->>'context' = ?",
696 |> exclude_poll_votes(opts)
698 |> order_by([activity], desc: activity.id)
701 @spec fetch_activities_for_context(String.t(), keyword() | map()) :: [Activity.t()]
702 def fetch_activities_for_context(context, opts \\ %{}) do
704 |> fetch_activities_for_context_query(opts)
708 @spec fetch_latest_activity_id_for_context(String.t(), keyword() | map()) ::
709 FlakeId.Ecto.CompatType.t() | nil
710 def fetch_latest_activity_id_for_context(context, opts \\ %{}) do
712 |> fetch_activities_for_context_query(Map.merge(%{"skip_preload" => true}, opts))
718 @spec fetch_public_activities(map(), Pagination.type()) :: [Activity.t()]
719 def fetch_public_activities(opts \\ %{}, pagination \\ :keyset) do
720 opts = Map.drop(opts, ["user"])
722 [Constants.as_public()]
723 |> fetch_activities_query(opts)
724 |> restrict_unlisted()
725 |> Pagination.fetch_paginated(opts, pagination)
728 @valid_visibilities ~w[direct unlisted public private]
730 defp restrict_visibility(query, %{visibility: visibility})
731 when is_list(visibility) do
732 if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
738 "activity_visibility(?, ?, ?) = ANY (?)",
748 Logger.error("Could not restrict visibility to #{visibility}")
752 defp restrict_visibility(query, %{visibility: visibility})
753 when visibility in @valid_visibilities do
757 fragment("activity_visibility(?, ?, ?) = ?", a.actor, a.recipients, a.data, ^visibility)
761 defp restrict_visibility(_query, %{visibility: visibility})
762 when visibility not in @valid_visibilities do
763 Logger.error("Could not restrict visibility to #{visibility}")
766 defp restrict_visibility(query, _visibility), do: query
768 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
769 when is_list(visibility) do
770 if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
775 "activity_visibility(?, ?, ?) = ANY (?)",
783 Logger.error("Could not exclude visibility to #{visibility}")
788 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
789 when visibility in @valid_visibilities do
794 "activity_visibility(?, ?, ?) = ?",
803 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
804 when visibility not in [nil | @valid_visibilities] do
805 Logger.error("Could not exclude visibility to #{visibility}")
809 defp exclude_visibility(query, _visibility), do: query
811 defp restrict_thread_visibility(query, _, %{skip_thread_containment: true} = _),
814 defp restrict_thread_visibility(
816 %{"user" => %User{skip_thread_containment: true}},
821 defp restrict_thread_visibility(query, %{"user" => %User{ap_id: ap_id}}, _) do
824 where: fragment("thread_visibility(?, (?)->>'id') = true", ^ap_id, a.data)
828 defp restrict_thread_visibility(query, _, _), do: query
830 def fetch_user_abstract_activities(user, reading_user, params \\ %{}) do
833 |> Map.put("user", reading_user)
834 |> Map.put("actor_id", user.ap_id)
837 user_activities_recipients(%{
838 "godmode" => params["godmode"],
839 "reading_user" => reading_user
842 fetch_activities(recipients, params)
846 def fetch_user_activities(user, reading_user, params \\ %{}) do
849 |> Map.put("type", ["Create", "Announce"])
850 |> Map.put("user", reading_user)
851 |> Map.put("actor_id", user.ap_id)
852 |> Map.put("pinned_activity_ids", user.pinned_activities)
855 if User.blocks?(reading_user, user) do
859 |> Map.put("blocking_user", reading_user)
860 |> Map.put("muting_user", reading_user)
864 user_activities_recipients(%{
865 "godmode" => params["godmode"],
866 "reading_user" => reading_user
869 fetch_activities(recipients, params)
873 def fetch_statuses(reading_user, params) do
876 |> Map.put("type", ["Create", "Announce"])
879 user_activities_recipients(%{
880 "godmode" => params["godmode"],
881 "reading_user" => reading_user
884 fetch_activities(recipients, params, :offset)
888 defp user_activities_recipients(%{"godmode" => true}) do
892 defp user_activities_recipients(%{"reading_user" => reading_user}) do
894 [Constants.as_public()] ++ [reading_user.ap_id | User.following(reading_user)]
896 [Constants.as_public()]
900 defp restrict_since(query, %{"since_id" => ""}), do: query
902 defp restrict_since(query, %{"since_id" => since_id}) do
903 from(activity in query, where: activity.id > ^since_id)
906 defp restrict_since(query, _), do: query
908 defp restrict_tag_reject(_query, %{"tag_reject" => _tag_reject, "skip_preload" => true}) do
909 raise "Can't use the child object without preloading!"
912 defp restrict_tag_reject(query, %{"tag_reject" => tag_reject})
913 when is_list(tag_reject) and tag_reject != [] do
915 [_activity, object] in query,
916 where: fragment("not (?)->'tag' \\?| (?)", object.data, ^tag_reject)
920 defp restrict_tag_reject(query, _), do: query
922 defp restrict_tag_all(_query, %{"tag_all" => _tag_all, "skip_preload" => true}) do
923 raise "Can't use the child object without preloading!"
926 defp restrict_tag_all(query, %{"tag_all" => tag_all})
927 when is_list(tag_all) and tag_all != [] do
929 [_activity, object] in query,
930 where: fragment("(?)->'tag' \\?& (?)", object.data, ^tag_all)
934 defp restrict_tag_all(query, _), do: query
936 defp restrict_tag(_query, %{"tag" => _tag, "skip_preload" => true}) do
937 raise "Can't use the child object without preloading!"
940 defp restrict_tag(query, %{"tag" => tag}) when is_list(tag) do
942 [_activity, object] in query,
943 where: fragment("(?)->'tag' \\?| (?)", object.data, ^tag)
947 defp restrict_tag(query, %{"tag" => tag}) when is_binary(tag) do
949 [_activity, object] in query,
950 where: fragment("(?)->'tag' \\? (?)", object.data, ^tag)
954 defp restrict_tag(query, _), do: query
956 defp restrict_recipients(query, [], _user), do: query
958 defp restrict_recipients(query, recipients, nil) do
959 from(activity in query, where: fragment("? && ?", ^recipients, activity.recipients))
962 defp restrict_recipients(query, recipients, user) do
965 where: fragment("? && ?", ^recipients, activity.recipients),
966 or_where: activity.actor == ^user.ap_id
970 defp restrict_local(query, %{"local_only" => true}) do
971 from(activity in query, where: activity.local == true)
974 defp restrict_local(query, _), do: query
976 defp restrict_actor(query, %{"actor_id" => actor_id}) do
977 from(activity in query, where: activity.actor == ^actor_id)
980 defp restrict_actor(query, _), do: query
982 defp restrict_type(query, %{"type" => type}) when is_binary(type) do
983 from(activity in query, where: fragment("?->>'type' = ?", activity.data, ^type))
986 defp restrict_type(query, %{"type" => type}) do
987 from(activity in query, where: fragment("?->>'type' = ANY(?)", activity.data, ^type))
990 defp restrict_type(query, _), do: query
992 defp restrict_state(query, %{"state" => state}) do
993 from(activity in query, where: fragment("?->>'state' = ?", activity.data, ^state))
996 defp restrict_state(query, _), do: query
998 defp restrict_favorited_by(query, %{"favorited_by" => ap_id}) do
1000 [_activity, object] in query,
1001 where: fragment("(?)->'likes' \\? (?)", object.data, ^ap_id)
1005 defp restrict_favorited_by(query, _), do: query
1007 defp restrict_media(_query, %{"only_media" => _val, "skip_preload" => true}) do
1008 raise "Can't use the child object without preloading!"
1011 defp restrict_media(query, %{"only_media" => val}) when val in [true, "true", "1"] do
1013 [_activity, object] in query,
1014 where: fragment("not (?)->'attachment' = (?)", object.data, ^[])
1018 defp restrict_media(query, _), do: query
1020 defp restrict_replies(query, %{"exclude_replies" => val}) when val in [true, "true", "1"] do
1022 [_activity, object] in query,
1023 where: fragment("?->>'inReplyTo' is null", object.data)
1027 defp restrict_replies(query, %{
1028 "reply_filtering_user" => user,
1029 "reply_visibility" => "self"
1032 [activity, object] in query,
1035 "?->>'inReplyTo' is null OR ? = ANY(?)",
1043 defp restrict_replies(query, %{
1044 "reply_filtering_user" => user,
1045 "reply_visibility" => "following"
1048 [activity, object] in query,
1051 "?->>'inReplyTo' is null OR ? && array_remove(?, ?) OR ? = ?",
1053 ^[user.ap_id | User.get_cached_user_friends_ap_ids(user)],
1054 activity.recipients,
1062 defp restrict_replies(query, _), do: query
1064 defp restrict_reblogs(query, %{"exclude_reblogs" => val}) when val in [true, "true", "1"] do
1065 from(activity in query, where: fragment("?->>'type' != 'Announce'", activity.data))
1068 defp restrict_reblogs(query, _), do: query
1070 defp restrict_muted(query, %{"with_muted" => val}) when val in [true, "true", "1"], do: query
1072 defp restrict_muted(query, %{"muting_user" => %User{} = user} = opts) do
1073 mutes = opts["muted_users_ap_ids"] || User.muted_users_ap_ids(user)
1076 from([activity] in query,
1077 where: fragment("not (? = ANY(?))", activity.actor, ^mutes),
1078 where: fragment("not (?->'to' \\?| ?)", activity.data, ^mutes)
1081 unless opts["skip_preload"] do
1082 from([thread_mute: tm] in query, where: is_nil(tm.user_id))
1088 defp restrict_muted(query, _), do: query
1090 defp restrict_blocked(query, %{"blocking_user" => %User{} = user} = opts) do
1091 blocked_ap_ids = opts["blocked_users_ap_ids"] || User.blocked_users_ap_ids(user)
1092 domain_blocks = user.domain_blocks || []
1094 following_ap_ids = User.get_friends_ap_ids(user)
1097 if has_named_binding?(query, :object), do: query, else: Activity.with_joined_object(query)
1100 [activity, object: o] in query,
1101 where: fragment("not (? = ANY(?))", activity.actor, ^blocked_ap_ids),
1102 where: fragment("not (? && ?)", activity.recipients, ^blocked_ap_ids),
1105 "not (?->>'type' = 'Announce' and ?->'to' \\?| ?)",
1112 "(not (split_part(?, '/', 3) = ANY(?))) or ? = ANY(?)",
1120 "(not (split_part(?->>'actor', '/', 3) = ANY(?))) or (?->>'actor') = ANY(?)",
1129 defp restrict_blocked(query, _), do: query
1131 defp restrict_unlisted(query) do
1136 "not (coalesce(?->'cc', '{}'::jsonb) \\?| ?)",
1138 ^[Constants.as_public()]
1143 # TODO: when all endpoints migrated to OpenAPI compare `pinned` with `true` (boolean) only,
1144 # the same for `restrict_media/2`, `restrict_replies/2`, 'restrict_reblogs/2'
1145 # and `restrict_muted/2`
1147 defp restrict_pinned(query, %{"pinned" => pinned, "pinned_activity_ids" => ids})
1148 when pinned in [true, "true", "1"] do
1149 from(activity in query, where: activity.id in ^ids)
1152 defp restrict_pinned(query, _), do: query
1154 defp restrict_muted_reblogs(query, %{"muting_user" => %User{} = user} = opts) do
1155 muted_reblogs = opts["reblog_muted_users_ap_ids"] || User.reblog_muted_users_ap_ids(user)
1161 "not ( ?->>'type' = 'Announce' and ? = ANY(?))",
1169 defp restrict_muted_reblogs(query, _), do: query
1171 defp restrict_instance(query, %{"instance" => instance}) do
1176 where: fragment("? LIKE ?", u.nickname, ^"%@#{instance}")
1180 from(activity in query, where: activity.actor in ^users)
1183 defp restrict_instance(query, _), do: query
1185 defp exclude_poll_votes(query, %{"include_poll_votes" => true}), do: query
1187 defp exclude_poll_votes(query, _) do
1188 if has_named_binding?(query, :object) do
1189 from([activity, object: o] in query,
1190 where: fragment("not(?->>'type' = ?)", o.data, "Answer")
1197 defp exclude_id(query, %{"exclude_id" => id}) when is_binary(id) do
1198 from(activity in query, where: activity.id != ^id)
1201 defp exclude_id(query, _), do: query
1203 defp maybe_preload_objects(query, %{"skip_preload" => true}), do: query
1205 defp maybe_preload_objects(query, _) do
1207 |> Activity.with_preloaded_object()
1210 defp maybe_preload_bookmarks(query, %{"skip_preload" => true}), do: query
1212 defp maybe_preload_bookmarks(query, opts) do
1214 |> Activity.with_preloaded_bookmark(opts["user"])
1217 defp maybe_preload_report_notes(query, %{"preload_report_notes" => true}) do
1219 |> Activity.with_preloaded_report_notes()
1222 defp maybe_preload_report_notes(query, _), do: query
1224 defp maybe_set_thread_muted_field(query, %{"skip_preload" => true}), do: query
1226 defp maybe_set_thread_muted_field(query, opts) do
1228 |> Activity.with_set_thread_muted_field(opts["muting_user"] || opts["user"])
1231 defp maybe_order(query, %{order: :desc}) do
1233 |> order_by(desc: :id)
1236 defp maybe_order(query, %{order: :asc}) do
1238 |> order_by(asc: :id)
1241 defp maybe_order(query, _), do: query
1243 defp fetch_activities_query_ap_ids_ops(opts) do
1244 source_user = opts["muting_user"]
1245 ap_id_relationships = if source_user, do: [:mute, :reblog_mute], else: []
1247 ap_id_relationships =
1248 ap_id_relationships ++
1249 if opts["blocking_user"] && opts["blocking_user"] == source_user do
1255 preloaded_ap_ids = User.outgoing_relationships_ap_ids(source_user, ap_id_relationships)
1257 restrict_blocked_opts = Map.merge(%{"blocked_users_ap_ids" => preloaded_ap_ids[:block]}, opts)
1258 restrict_muted_opts = Map.merge(%{"muted_users_ap_ids" => preloaded_ap_ids[:mute]}, opts)
1260 restrict_muted_reblogs_opts =
1261 Map.merge(%{"reblog_muted_users_ap_ids" => preloaded_ap_ids[:reblog_mute]}, opts)
1263 {restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts}
1266 def fetch_activities_query(recipients, opts \\ %{}) do
1267 {restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts} =
1268 fetch_activities_query_ap_ids_ops(opts)
1271 skip_thread_containment: Config.get([:instance, :skip_thread_containment])
1275 |> maybe_preload_objects(opts)
1276 |> maybe_preload_bookmarks(opts)
1277 |> maybe_preload_report_notes(opts)
1278 |> maybe_set_thread_muted_field(opts)
1279 |> maybe_order(opts)
1280 |> restrict_recipients(recipients, opts["user"])
1281 |> restrict_replies(opts)
1282 |> restrict_tag(opts)
1283 |> restrict_tag_reject(opts)
1284 |> restrict_tag_all(opts)
1285 |> restrict_since(opts)
1286 |> restrict_local(opts)
1287 |> restrict_actor(opts)
1288 |> restrict_type(opts)
1289 |> restrict_state(opts)
1290 |> restrict_favorited_by(opts)
1291 |> restrict_blocked(restrict_blocked_opts)
1292 |> restrict_muted(restrict_muted_opts)
1293 |> restrict_media(opts)
1294 |> restrict_visibility(opts)
1295 |> restrict_thread_visibility(opts, config)
1296 |> restrict_reblogs(opts)
1297 |> restrict_pinned(opts)
1298 |> restrict_muted_reblogs(restrict_muted_reblogs_opts)
1299 |> restrict_instance(opts)
1300 |> Activity.restrict_deactivated_users()
1301 |> exclude_poll_votes(opts)
1302 |> exclude_visibility(opts)
1305 def fetch_activities(recipients, opts \\ %{}, pagination \\ :keyset) do
1306 list_memberships = Pleroma.List.memberships(opts["user"])
1308 fetch_activities_query(recipients ++ list_memberships, opts)
1309 |> Pagination.fetch_paginated(opts, pagination)
1311 |> maybe_update_cc(list_memberships, opts["user"])
1315 Fetch favorites activities of user with order by sort adds to favorites
1317 @spec fetch_favourites(User.t(), map(), Pagination.type()) :: list(Activity.t())
1318 def fetch_favourites(user, params \\ %{}, pagination \\ :keyset) do
1320 |> Activity.Queries.by_actor()
1321 |> Activity.Queries.by_type("Like")
1322 |> Activity.with_joined_object()
1323 |> Object.with_joined_activity()
1324 |> select([_like, object, activity], %{activity | object: object})
1325 |> order_by([like, _, _], desc: like.id)
1326 |> Pagination.fetch_paginated(
1327 Map.merge(params, %{"skip_order" => true}),
1333 defp maybe_update_cc(activities, list_memberships, %User{ap_id: user_ap_id})
1334 when is_list(list_memberships) and length(list_memberships) > 0 do
1335 Enum.map(activities, fn
1336 %{data: %{"bcc" => bcc}} = activity when is_list(bcc) and length(bcc) > 0 ->
1337 if Enum.any?(bcc, &(&1 in list_memberships)) do
1338 update_in(activity.data["cc"], &[user_ap_id | &1])
1348 defp maybe_update_cc(activities, _, _), do: activities
1350 def fetch_activities_bounded_query(query, recipients, recipients_with_public) do
1351 from(activity in query,
1353 fragment("? && ?", activity.recipients, ^recipients) or
1354 (fragment("? && ?", activity.recipients, ^recipients_with_public) and
1355 ^Constants.as_public() in activity.recipients)
1359 def fetch_activities_bounded(
1361 recipients_with_public,
1363 pagination \\ :keyset
1365 fetch_activities_query([], opts)
1366 |> fetch_activities_bounded_query(recipients, recipients_with_public)
1367 |> Pagination.fetch_paginated(opts, pagination)
1371 @spec upload(Upload.source(), keyword()) :: {:ok, Object.t()} | {:error, any()}
1372 def upload(file, opts \\ []) do
1373 with {:ok, data} <- Upload.store(file, opts) do
1376 Map.put(data, "actor", opts[:actor])
1381 Repo.insert(%Object{data: obj_data})
1385 @spec get_actor_url(any()) :: binary() | nil
1386 defp get_actor_url(url) when is_binary(url), do: url
1387 defp get_actor_url(%{"href" => href}) when is_binary(href), do: href
1389 defp get_actor_url(url) when is_list(url) do
1395 defp get_actor_url(_url), do: nil
1397 defp object_to_user_data(data) do
1399 data["icon"]["url"] &&
1402 "url" => [%{"href" => data["icon"]["url"]}]
1406 data["image"]["url"] &&
1409 "url" => [%{"href" => data["image"]["url"]}]
1414 |> Map.get("attachment", [])
1415 |> Enum.filter(fn %{"type" => t} -> t == "PropertyValue" end)
1416 |> Enum.map(fn fields -> Map.take(fields, ["name", "value"]) end)
1420 |> Map.get("tag", [])
1422 %{"type" => "Emoji"} -> true
1425 |> Enum.reduce(%{}, fn %{"icon" => %{"url" => url}, "name" => name}, acc ->
1426 Map.put(acc, String.trim(name, ":"), url)
1429 locked = data["manuallyApprovesFollowers"] || false
1430 data = Transmogrifier.maybe_fix_user_object(data)
1431 discoverable = data["discoverable"] || false
1432 invisible = data["invisible"] || false
1433 actor_type = data["type"] || "Person"
1436 if is_map(data["publicKey"]) && is_binary(data["publicKey"]["publicKeyPem"]) do
1437 data["publicKey"]["publicKeyPem"]
1443 if is_map(data["endpoints"]) && is_binary(data["endpoints"]["sharedInbox"]) do
1444 data["endpoints"]["sharedInbox"]
1451 uri: get_actor_url(data["url"]),
1457 discoverable: discoverable,
1458 invisible: invisible,
1461 follower_address: data["followers"],
1462 following_address: data["following"],
1463 bio: data["summary"],
1464 actor_type: actor_type,
1465 also_known_as: Map.get(data, "alsoKnownAs", []),
1466 public_key: public_key,
1467 inbox: data["inbox"],
1468 shared_inbox: shared_inbox
1471 # nickname can be nil because of virtual actors
1473 if data["preferredUsername"] do
1477 "#{data["preferredUsername"]}@#{URI.parse(data["id"]).host}"
1480 Map.put(user_data, :nickname, nil)
1486 def fetch_follow_information_for_user(user) do
1487 with {:ok, following_data} <-
1488 Fetcher.fetch_and_contain_remote_object_from_id(user.following_address),
1489 {:ok, hide_follows} <- collection_private(following_data),
1490 {:ok, followers_data} <-
1491 Fetcher.fetch_and_contain_remote_object_from_id(user.follower_address),
1492 {:ok, hide_followers} <- collection_private(followers_data) do
1495 hide_follows: hide_follows,
1496 follower_count: normalize_counter(followers_data["totalItems"]),
1497 following_count: normalize_counter(following_data["totalItems"]),
1498 hide_followers: hide_followers
1501 {:error, _} = e -> e
1506 defp normalize_counter(counter) when is_integer(counter), do: counter
1507 defp normalize_counter(_), do: 0
1509 def maybe_update_follow_information(user_data) do
1510 with {:enabled, true} <- {:enabled, Config.get([:instance, :external_user_synchronization])},
1511 {_, true} <- {:user_type_check, user_data[:type] in ["Person", "Service"]},
1513 {:collections_available,
1514 !!(user_data[:following_address] && user_data[:follower_address])},
1516 fetch_follow_information_for_user(user_data) do
1517 info = Map.merge(user_data[:info] || %{}, info)
1520 |> Map.put(:info, info)
1522 {:user_type_check, false} ->
1525 {:collections_available, false} ->
1528 {:enabled, false} ->
1533 "Follower/Following counter update for #{user_data.ap_id} failed.\n" <> inspect(e)
1540 defp collection_private(%{"first" => %{"type" => type}})
1541 when type in ["CollectionPage", "OrderedCollectionPage"],
1544 defp collection_private(%{"first" => first}) do
1545 with {:ok, %{"type" => type}} when type in ["CollectionPage", "OrderedCollectionPage"] <-
1546 Fetcher.fetch_and_contain_remote_object_from_id(first) do
1549 {:error, {:ok, %{status: code}}} when code in [401, 403] -> {:ok, true}
1550 {:error, _} = e -> e
1555 defp collection_private(_data), do: {:ok, true}
1557 def user_data_from_user_object(data) do
1558 with {:ok, data} <- MRF.filter(data),
1559 {:ok, data} <- object_to_user_data(data) do
1566 def fetch_and_prepare_user_from_ap_id(ap_id) do
1567 with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id),
1568 {:ok, data} <- user_data_from_user_object(data),
1569 data <- maybe_update_follow_information(data) do
1572 {:error, "Object has been deleted"} = e ->
1573 Logger.debug("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
1577 Logger.error("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
1582 def make_user_from_ap_id(ap_id) do
1583 user = User.get_cached_by_ap_id(ap_id)
1585 if user && !User.ap_enabled?(user) do
1586 Transmogrifier.upgrade_user_from_ap_id(ap_id)
1588 with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id) do
1591 |> User.remote_user_changeset(data)
1592 |> User.update_and_set_cache()
1595 |> User.remote_user_changeset()
1605 def make_user_from_nickname(nickname) do
1606 with {:ok, %{"ap_id" => ap_id}} when not is_nil(ap_id) <- WebFinger.finger(nickname) do
1607 make_user_from_ap_id(ap_id)
1609 _e -> {:error, "No AP id in WebFinger"}
1613 # filter out broken threads
1614 def contain_broken_threads(%Activity{} = activity, %User{} = user) do
1615 entire_thread_visible_for_user?(activity, user)
1618 # do post-processing on a specific activity
1619 def contain_activity(%Activity{} = activity, %User{} = user) do
1620 contain_broken_threads(activity, user)
1623 def fetch_direct_messages_query do
1625 |> restrict_type(%{"type" => "Create"})
1626 |> restrict_visibility(%{visibility: "direct"})
1627 |> order_by([activity], asc: activity.id)