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 react_with_emoji(User.t(), Object.t(), String.t(), keyword()) ::
353 {:ok, Activity.t(), Object.t()} | {:error, any()}
354 def react_with_emoji(user, object, emoji, options \\ []) do
355 with {:ok, result} <-
356 Repo.transaction(fn -> do_react_with_emoji(user, object, emoji, options) end) do
361 defp do_react_with_emoji(user, object, emoji, options) do
362 with local <- Keyword.get(options, :local, true),
363 activity_id <- Keyword.get(options, :activity_id, nil),
364 true <- Pleroma.Emoji.is_unicode_emoji?(emoji),
365 reaction_data <- make_emoji_reaction_data(user, object, emoji, activity_id),
366 {:ok, activity} <- insert(reaction_data, local),
367 {:ok, object} <- add_emoji_reaction_to_object(activity, object),
368 :ok <- maybe_federate(activity) do
369 {:ok, activity, object}
371 false -> {:error, false}
372 {:error, error} -> Repo.rollback(error)
376 @spec unreact_with_emoji(User.t(), String.t(), keyword()) ::
377 {:ok, Activity.t(), Object.t()} | {:error, any()}
378 def unreact_with_emoji(user, reaction_id, options \\ []) do
379 with {:ok, result} <-
380 Repo.transaction(fn -> do_unreact_with_emoji(user, reaction_id, options) end) do
385 defp do_unreact_with_emoji(user, reaction_id, options) do
386 with local <- Keyword.get(options, :local, true),
387 activity_id <- Keyword.get(options, :activity_id, nil),
388 user_ap_id <- user.ap_id,
389 %Activity{actor: ^user_ap_id} = reaction_activity <- Activity.get_by_ap_id(reaction_id),
390 object <- Object.normalize(reaction_activity),
391 unreact_data <- make_undo_data(user, reaction_activity, activity_id),
392 {:ok, activity} <- insert(unreact_data, local),
393 {:ok, object} <- remove_emoji_reaction_from_object(reaction_activity, object),
394 :ok <- maybe_federate(activity) do
395 {:ok, activity, object}
397 {:error, error} -> Repo.rollback(error)
401 @spec unlike(User.t(), Object.t(), String.t() | nil, boolean()) ::
402 {:ok, Activity.t(), Activity.t(), Object.t()} | {:ok, Object.t()} | {:error, any()}
403 def unlike(%User{} = actor, %Object{} = object, activity_id \\ nil, local \\ true) do
404 with {:ok, result} <-
405 Repo.transaction(fn -> do_unlike(actor, object, activity_id, local) end) do
410 defp do_unlike(actor, object, activity_id, local) do
411 with %Activity{} = like_activity <- get_existing_like(actor.ap_id, object),
412 unlike_data <- make_unlike_data(actor, like_activity, activity_id),
413 {:ok, unlike_activity} <- insert(unlike_data, local),
414 {:ok, _activity} <- Repo.delete(like_activity),
415 {:ok, object} <- remove_like_from_object(like_activity, object),
416 :ok <- maybe_federate(unlike_activity) do
417 {:ok, unlike_activity, like_activity, object}
420 {:error, error} -> Repo.rollback(error)
424 @spec announce(User.t(), Object.t(), String.t() | nil, boolean(), boolean()) ::
425 {:ok, Activity.t(), Object.t()} | {:error, any()}
427 %User{ap_id: _} = user,
428 %Object{data: %{"id" => _}} = object,
433 with {:ok, result} <-
434 Repo.transaction(fn -> do_announce(user, object, activity_id, local, public) end) do
439 defp do_announce(user, object, activity_id, local, public) do
440 with true <- is_announceable?(object, user, public),
441 object <- Object.get_by_id(object.id),
442 announce_data <- make_announce_data(user, object, activity_id, public),
443 {:ok, activity} <- insert(announce_data, local),
444 {:ok, object} <- add_announce_to_object(activity, object),
445 :ok <- maybe_federate(activity) do
446 {:ok, activity, object}
448 false -> {:error, false}
449 {:error, error} -> Repo.rollback(error)
453 @spec unannounce(User.t(), Object.t(), String.t() | nil, boolean()) ::
454 {:ok, Activity.t(), Object.t()} | {:ok, Object.t()} | {:error, any()}
461 with {:ok, result} <-
462 Repo.transaction(fn -> do_unannounce(actor, object, activity_id, local) end) do
467 defp do_unannounce(actor, object, activity_id, local) do
468 with %Activity{} = announce_activity <- get_existing_announce(actor.ap_id, object),
469 unannounce_data <- make_unannounce_data(actor, announce_activity, activity_id),
470 {:ok, unannounce_activity} <- insert(unannounce_data, local),
471 :ok <- maybe_federate(unannounce_activity),
472 {:ok, _activity} <- Repo.delete(announce_activity),
473 {:ok, object} <- remove_announce_from_object(announce_activity, object) do
474 {:ok, unannounce_activity, object}
477 {:error, error} -> Repo.rollback(error)
481 @spec follow(User.t(), User.t(), String.t() | nil, boolean()) ::
482 {:ok, Activity.t()} | {:error, any()}
483 def follow(follower, followed, activity_id \\ nil, local \\ true) do
484 with {:ok, result} <-
485 Repo.transaction(fn -> do_follow(follower, followed, activity_id, local) end) do
490 defp do_follow(follower, followed, activity_id, local) do
491 with data <- make_follow_data(follower, followed, activity_id),
492 {:ok, activity} <- insert(data, local),
493 :ok <- maybe_federate(activity) do
496 {:error, error} -> Repo.rollback(error)
500 @spec unfollow(User.t(), User.t(), String.t() | nil, boolean()) ::
501 {:ok, Activity.t()} | nil | {:error, any()}
502 def unfollow(follower, followed, activity_id \\ nil, local \\ true) do
503 with {:ok, result} <-
504 Repo.transaction(fn -> do_unfollow(follower, followed, activity_id, local) end) do
509 defp do_unfollow(follower, followed, activity_id, local) do
510 with %Activity{} = follow_activity <- fetch_latest_follow(follower, followed),
511 {:ok, follow_activity} <- update_follow_state(follow_activity, "cancelled"),
512 unfollow_data <- make_unfollow_data(follower, followed, follow_activity, activity_id),
513 {:ok, activity} <- insert(unfollow_data, local),
514 :ok <- maybe_federate(activity) do
518 {:error, error} -> Repo.rollback(error)
522 @spec block(User.t(), User.t(), String.t() | nil, boolean()) ::
523 {:ok, Activity.t()} | {:error, any()}
524 def block(blocker, blocked, activity_id \\ nil, local \\ true) do
525 with {:ok, result} <-
526 Repo.transaction(fn -> do_block(blocker, blocked, activity_id, local) end) do
531 defp do_block(blocker, blocked, activity_id, local) do
532 outgoing_blocks = Config.get([:activitypub, :outgoing_blocks])
533 unfollow_blocked = Config.get([:activitypub, :unfollow_blocked])
535 if unfollow_blocked do
536 follow_activity = fetch_latest_follow(blocker, blocked)
537 if follow_activity, do: unfollow(blocker, blocked, nil, local)
540 with true <- outgoing_blocks,
541 block_data <- make_block_data(blocker, blocked, activity_id),
542 {:ok, activity} <- insert(block_data, local),
543 :ok <- maybe_federate(activity) do
546 {:error, error} -> Repo.rollback(error)
550 @spec unblock(User.t(), User.t(), String.t() | nil, boolean()) ::
551 {:ok, Activity.t()} | {:error, any()} | nil
552 def unblock(blocker, blocked, activity_id \\ nil, local \\ true) do
553 with {:ok, result} <-
554 Repo.transaction(fn -> do_unblock(blocker, blocked, activity_id, local) end) do
559 defp do_unblock(blocker, blocked, activity_id, local) do
560 with %Activity{} = block_activity <- fetch_latest_block(blocker, blocked),
561 unblock_data <- make_unblock_data(blocker, blocked, block_activity, activity_id),
562 {:ok, activity} <- insert(unblock_data, local),
563 :ok <- maybe_federate(activity) do
567 {:error, error} -> Repo.rollback(error)
571 @spec flag(map()) :: {:ok, Activity.t()} | {:error, any()}
581 # only accept false as false value
582 local = !(params[:local] == false)
583 forward = !(params[:forward] == false)
585 additional = params[:additional] || %{}
589 Map.merge(additional, %{"to" => [], "cc" => [account.ap_id]})
591 Map.merge(additional, %{"to" => [], "cc" => []})
594 with flag_data <- make_flag_data(params, additional),
595 {:ok, activity} <- insert(flag_data, local),
596 {:ok, stripped_activity} <- strip_report_status_data(activity),
597 :ok <- maybe_federate(stripped_activity) do
598 User.all_superusers()
599 |> Enum.filter(fn user -> not is_nil(user.email) end)
600 |> Enum.each(fn superuser ->
602 |> Pleroma.Emails.AdminEmail.report(actor, account, statuses, content)
603 |> Pleroma.Emails.Mailer.deliver_async()
610 @spec move(User.t(), User.t(), boolean()) :: {:ok, Activity.t()} | {:error, any()}
611 def move(%User{} = origin, %User{} = target, local \\ true) do
614 "actor" => origin.ap_id,
615 "object" => origin.ap_id,
616 "target" => target.ap_id
619 with true <- origin.ap_id in target.also_known_as,
620 {:ok, activity} <- insert(params, local) do
621 maybe_federate(activity)
623 BackgroundWorker.enqueue("move_following", %{
624 "origin_id" => origin.id,
625 "target_id" => target.id
630 false -> {:error, "Target account must have the origin in `alsoKnownAs`"}
635 def fetch_activities_for_context_query(context, opts) do
636 public = [Constants.as_public()]
640 do: [opts["user"].ap_id | User.following(opts["user"])] ++ public,
643 from(activity in Activity)
644 |> maybe_preload_objects(opts)
645 |> maybe_preload_bookmarks(opts)
646 |> maybe_set_thread_muted_field(opts)
647 |> restrict_blocked(opts)
648 |> restrict_recipients(recipients, opts["user"])
652 "?->>'type' = ? and ?->>'context' = ?",
659 |> exclude_poll_votes(opts)
661 |> order_by([activity], desc: activity.id)
664 @spec fetch_activities_for_context(String.t(), keyword() | map()) :: [Activity.t()]
665 def fetch_activities_for_context(context, opts \\ %{}) do
667 |> fetch_activities_for_context_query(opts)
671 @spec fetch_latest_activity_id_for_context(String.t(), keyword() | map()) ::
672 FlakeId.Ecto.CompatType.t() | nil
673 def fetch_latest_activity_id_for_context(context, opts \\ %{}) do
675 |> fetch_activities_for_context_query(Map.merge(%{"skip_preload" => true}, opts))
681 @spec fetch_public_activities(map(), Pagination.type()) :: [Activity.t()]
682 def fetch_public_activities(opts \\ %{}, pagination \\ :keyset) do
683 opts = Map.drop(opts, ["user"])
685 [Constants.as_public()]
686 |> fetch_activities_query(opts)
687 |> restrict_unlisted()
688 |> Pagination.fetch_paginated(opts, pagination)
691 @valid_visibilities ~w[direct unlisted public private]
693 defp restrict_visibility(query, %{visibility: visibility})
694 when is_list(visibility) do
695 if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
701 "activity_visibility(?, ?, ?) = ANY (?)",
711 Logger.error("Could not restrict visibility to #{visibility}")
715 defp restrict_visibility(query, %{visibility: visibility})
716 when visibility in @valid_visibilities do
720 fragment("activity_visibility(?, ?, ?) = ?", a.actor, a.recipients, a.data, ^visibility)
724 defp restrict_visibility(_query, %{visibility: visibility})
725 when visibility not in @valid_visibilities do
726 Logger.error("Could not restrict visibility to #{visibility}")
729 defp restrict_visibility(query, _visibility), do: query
731 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
732 when is_list(visibility) do
733 if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
738 "activity_visibility(?, ?, ?) = ANY (?)",
746 Logger.error("Could not exclude visibility to #{visibility}")
751 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
752 when visibility in @valid_visibilities do
757 "activity_visibility(?, ?, ?) = ?",
766 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
767 when visibility not in [nil | @valid_visibilities] do
768 Logger.error("Could not exclude visibility to #{visibility}")
772 defp exclude_visibility(query, _visibility), do: query
774 defp restrict_thread_visibility(query, _, %{skip_thread_containment: true} = _),
777 defp restrict_thread_visibility(
779 %{"user" => %User{skip_thread_containment: true}},
784 defp restrict_thread_visibility(query, %{"user" => %User{ap_id: ap_id}}, _) do
787 where: fragment("thread_visibility(?, (?)->>'id') = true", ^ap_id, a.data)
791 defp restrict_thread_visibility(query, _, _), do: query
793 def fetch_user_abstract_activities(user, reading_user, params \\ %{}) do
796 |> Map.put("user", reading_user)
797 |> Map.put("actor_id", user.ap_id)
800 user_activities_recipients(%{
801 "godmode" => params["godmode"],
802 "reading_user" => reading_user
805 fetch_activities(recipients, params)
809 def fetch_user_activities(user, reading_user, params \\ %{}) do
812 |> Map.put("type", ["Create", "Announce"])
813 |> Map.put("user", reading_user)
814 |> Map.put("actor_id", user.ap_id)
815 |> Map.put("pinned_activity_ids", user.pinned_activities)
818 if User.blocks?(reading_user, user) do
822 |> Map.put("blocking_user", reading_user)
823 |> Map.put("muting_user", reading_user)
827 user_activities_recipients(%{
828 "godmode" => params["godmode"],
829 "reading_user" => reading_user
832 fetch_activities(recipients, params)
836 def fetch_statuses(reading_user, params) do
839 |> Map.put("type", ["Create", "Announce"])
842 user_activities_recipients(%{
843 "godmode" => params["godmode"],
844 "reading_user" => reading_user
847 fetch_activities(recipients, params, :offset)
851 defp user_activities_recipients(%{"godmode" => true}) do
855 defp user_activities_recipients(%{"reading_user" => reading_user}) do
857 [Constants.as_public()] ++ [reading_user.ap_id | User.following(reading_user)]
859 [Constants.as_public()]
863 defp restrict_since(query, %{"since_id" => ""}), do: query
865 defp restrict_since(query, %{"since_id" => since_id}) do
866 from(activity in query, where: activity.id > ^since_id)
869 defp restrict_since(query, _), do: query
871 defp restrict_tag_reject(_query, %{"tag_reject" => _tag_reject, "skip_preload" => true}) do
872 raise "Can't use the child object without preloading!"
875 defp restrict_tag_reject(query, %{"tag_reject" => tag_reject})
876 when is_list(tag_reject) and tag_reject != [] do
878 [_activity, object] in query,
879 where: fragment("not (?)->'tag' \\?| (?)", object.data, ^tag_reject)
883 defp restrict_tag_reject(query, _), do: query
885 defp restrict_tag_all(_query, %{"tag_all" => _tag_all, "skip_preload" => true}) do
886 raise "Can't use the child object without preloading!"
889 defp restrict_tag_all(query, %{"tag_all" => tag_all})
890 when is_list(tag_all) and tag_all != [] do
892 [_activity, object] in query,
893 where: fragment("(?)->'tag' \\?& (?)", object.data, ^tag_all)
897 defp restrict_tag_all(query, _), do: query
899 defp restrict_tag(_query, %{"tag" => _tag, "skip_preload" => true}) do
900 raise "Can't use the child object without preloading!"
903 defp restrict_tag(query, %{"tag" => tag}) when is_list(tag) do
905 [_activity, object] in query,
906 where: fragment("(?)->'tag' \\?| (?)", object.data, ^tag)
910 defp restrict_tag(query, %{"tag" => tag}) when is_binary(tag) do
912 [_activity, object] in query,
913 where: fragment("(?)->'tag' \\? (?)", object.data, ^tag)
917 defp restrict_tag(query, _), do: query
919 defp restrict_recipients(query, [], _user), do: query
921 defp restrict_recipients(query, recipients, nil) do
922 from(activity in query, where: fragment("? && ?", ^recipients, activity.recipients))
925 defp restrict_recipients(query, recipients, user) do
928 where: fragment("? && ?", ^recipients, activity.recipients),
929 or_where: activity.actor == ^user.ap_id
933 defp restrict_local(query, %{"local_only" => true}) do
934 from(activity in query, where: activity.local == true)
937 defp restrict_local(query, _), do: query
939 defp restrict_actor(query, %{"actor_id" => actor_id}) do
940 from(activity in query, where: activity.actor == ^actor_id)
943 defp restrict_actor(query, _), do: query
945 defp restrict_type(query, %{"type" => type}) when is_binary(type) do
946 from(activity in query, where: fragment("?->>'type' = ?", activity.data, ^type))
949 defp restrict_type(query, %{"type" => type}) do
950 from(activity in query, where: fragment("?->>'type' = ANY(?)", activity.data, ^type))
953 defp restrict_type(query, _), do: query
955 defp restrict_state(query, %{"state" => state}) do
956 from(activity in query, where: fragment("?->>'state' = ?", activity.data, ^state))
959 defp restrict_state(query, _), do: query
961 defp restrict_favorited_by(query, %{"favorited_by" => ap_id}) do
963 [_activity, object] in query,
964 where: fragment("(?)->'likes' \\? (?)", object.data, ^ap_id)
968 defp restrict_favorited_by(query, _), do: query
970 defp restrict_media(_query, %{"only_media" => _val, "skip_preload" => true}) do
971 raise "Can't use the child object without preloading!"
974 defp restrict_media(query, %{"only_media" => val}) when val in [true, "true", "1"] do
976 [_activity, object] in query,
977 where: fragment("not (?)->'attachment' = (?)", object.data, ^[])
981 defp restrict_media(query, _), do: query
983 defp restrict_replies(query, %{"exclude_replies" => val}) when val in [true, "true", "1"] do
985 [_activity, object] in query,
986 where: fragment("?->>'inReplyTo' is null", object.data)
990 defp restrict_replies(query, %{
991 "reply_filtering_user" => user,
992 "reply_visibility" => "self"
995 [activity, object] in query,
998 "?->>'inReplyTo' is null OR ? = ANY(?)",
1006 defp restrict_replies(query, %{
1007 "reply_filtering_user" => user,
1008 "reply_visibility" => "following"
1011 [activity, object] in query,
1014 "?->>'inReplyTo' is null OR ? && array_remove(?, ?) OR ? = ?",
1016 ^[user.ap_id | User.get_cached_user_friends_ap_ids(user)],
1017 activity.recipients,
1025 defp restrict_replies(query, _), do: query
1027 defp restrict_reblogs(query, %{"exclude_reblogs" => val}) when val in [true, "true", "1"] do
1028 from(activity in query, where: fragment("?->>'type' != 'Announce'", activity.data))
1031 defp restrict_reblogs(query, _), do: query
1033 defp restrict_muted(query, %{"with_muted" => val}) when val in [true, "true", "1"], do: query
1035 defp restrict_muted(query, %{"muting_user" => %User{} = user} = opts) do
1036 mutes = opts["muted_users_ap_ids"] || User.muted_users_ap_ids(user)
1039 from([activity] in query,
1040 where: fragment("not (? = ANY(?))", activity.actor, ^mutes),
1041 where: fragment("not (?->'to' \\?| ?)", activity.data, ^mutes)
1044 unless opts["skip_preload"] do
1045 from([thread_mute: tm] in query, where: is_nil(tm.user_id))
1051 defp restrict_muted(query, _), do: query
1053 defp restrict_blocked(query, %{"blocking_user" => %User{} = user} = opts) do
1054 blocked_ap_ids = opts["blocked_users_ap_ids"] || User.blocked_users_ap_ids(user)
1055 domain_blocks = user.domain_blocks || []
1057 following_ap_ids = User.get_friends_ap_ids(user)
1060 if has_named_binding?(query, :object), do: query, else: Activity.with_joined_object(query)
1063 [activity, object: o] in query,
1064 where: fragment("not (? = ANY(?))", activity.actor, ^blocked_ap_ids),
1065 where: fragment("not (? && ?)", activity.recipients, ^blocked_ap_ids),
1068 "not (?->>'type' = 'Announce' and ?->'to' \\?| ?)",
1075 "(not (split_part(?, '/', 3) = ANY(?))) or ? = ANY(?)",
1083 "(not (split_part(?->>'actor', '/', 3) = ANY(?))) or (?->>'actor') = ANY(?)",
1092 defp restrict_blocked(query, _), do: query
1094 defp restrict_unlisted(query) do
1099 "not (coalesce(?->'cc', '{}'::jsonb) \\?| ?)",
1101 ^[Constants.as_public()]
1106 # TODO: when all endpoints migrated to OpenAPI compare `pinned` with `true` (boolean) only,
1107 # the same for `restrict_media/2`, `restrict_replies/2`, 'restrict_reblogs/2'
1108 # and `restrict_muted/2`
1110 defp restrict_pinned(query, %{"pinned" => pinned, "pinned_activity_ids" => ids})
1111 when pinned in [true, "true", "1"] do
1112 from(activity in query, where: activity.id in ^ids)
1115 defp restrict_pinned(query, _), do: query
1117 defp restrict_muted_reblogs(query, %{"muting_user" => %User{} = user} = opts) do
1118 muted_reblogs = opts["reblog_muted_users_ap_ids"] || User.reblog_muted_users_ap_ids(user)
1124 "not ( ?->>'type' = 'Announce' and ? = ANY(?))",
1132 defp restrict_muted_reblogs(query, _), do: query
1134 defp restrict_instance(query, %{"instance" => instance}) do
1139 where: fragment("? LIKE ?", u.nickname, ^"%@#{instance}")
1143 from(activity in query, where: activity.actor in ^users)
1146 defp restrict_instance(query, _), do: query
1148 defp exclude_poll_votes(query, %{"include_poll_votes" => true}), do: query
1150 defp exclude_poll_votes(query, _) do
1151 if has_named_binding?(query, :object) do
1152 from([activity, object: o] in query,
1153 where: fragment("not(?->>'type' = ?)", o.data, "Answer")
1160 defp exclude_id(query, %{"exclude_id" => id}) when is_binary(id) do
1161 from(activity in query, where: activity.id != ^id)
1164 defp exclude_id(query, _), do: query
1166 defp maybe_preload_objects(query, %{"skip_preload" => true}), do: query
1168 defp maybe_preload_objects(query, _) do
1170 |> Activity.with_preloaded_object()
1173 defp maybe_preload_bookmarks(query, %{"skip_preload" => true}), do: query
1175 defp maybe_preload_bookmarks(query, opts) do
1177 |> Activity.with_preloaded_bookmark(opts["user"])
1180 defp maybe_preload_report_notes(query, %{"preload_report_notes" => true}) do
1182 |> Activity.with_preloaded_report_notes()
1185 defp maybe_preload_report_notes(query, _), do: query
1187 defp maybe_set_thread_muted_field(query, %{"skip_preload" => true}), do: query
1189 defp maybe_set_thread_muted_field(query, opts) do
1191 |> Activity.with_set_thread_muted_field(opts["muting_user"] || opts["user"])
1194 defp maybe_order(query, %{order: :desc}) do
1196 |> order_by(desc: :id)
1199 defp maybe_order(query, %{order: :asc}) do
1201 |> order_by(asc: :id)
1204 defp maybe_order(query, _), do: query
1206 defp fetch_activities_query_ap_ids_ops(opts) do
1207 source_user = opts["muting_user"]
1208 ap_id_relationships = if source_user, do: [:mute, :reblog_mute], else: []
1210 ap_id_relationships =
1211 ap_id_relationships ++
1212 if opts["blocking_user"] && opts["blocking_user"] == source_user do
1218 preloaded_ap_ids = User.outgoing_relationships_ap_ids(source_user, ap_id_relationships)
1220 restrict_blocked_opts = Map.merge(%{"blocked_users_ap_ids" => preloaded_ap_ids[:block]}, opts)
1221 restrict_muted_opts = Map.merge(%{"muted_users_ap_ids" => preloaded_ap_ids[:mute]}, opts)
1223 restrict_muted_reblogs_opts =
1224 Map.merge(%{"reblog_muted_users_ap_ids" => preloaded_ap_ids[:reblog_mute]}, opts)
1226 {restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts}
1229 def fetch_activities_query(recipients, opts \\ %{}) do
1230 {restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts} =
1231 fetch_activities_query_ap_ids_ops(opts)
1234 skip_thread_containment: Config.get([:instance, :skip_thread_containment])
1238 |> maybe_preload_objects(opts)
1239 |> maybe_preload_bookmarks(opts)
1240 |> maybe_preload_report_notes(opts)
1241 |> maybe_set_thread_muted_field(opts)
1242 |> maybe_order(opts)
1243 |> restrict_recipients(recipients, opts["user"])
1244 |> restrict_replies(opts)
1245 |> restrict_tag(opts)
1246 |> restrict_tag_reject(opts)
1247 |> restrict_tag_all(opts)
1248 |> restrict_since(opts)
1249 |> restrict_local(opts)
1250 |> restrict_actor(opts)
1251 |> restrict_type(opts)
1252 |> restrict_state(opts)
1253 |> restrict_favorited_by(opts)
1254 |> restrict_blocked(restrict_blocked_opts)
1255 |> restrict_muted(restrict_muted_opts)
1256 |> restrict_media(opts)
1257 |> restrict_visibility(opts)
1258 |> restrict_thread_visibility(opts, config)
1259 |> restrict_reblogs(opts)
1260 |> restrict_pinned(opts)
1261 |> restrict_muted_reblogs(restrict_muted_reblogs_opts)
1262 |> restrict_instance(opts)
1263 |> Activity.restrict_deactivated_users()
1264 |> exclude_poll_votes(opts)
1265 |> exclude_visibility(opts)
1268 def fetch_activities(recipients, opts \\ %{}, pagination \\ :keyset) do
1269 list_memberships = Pleroma.List.memberships(opts["user"])
1271 fetch_activities_query(recipients ++ list_memberships, opts)
1272 |> Pagination.fetch_paginated(opts, pagination)
1274 |> maybe_update_cc(list_memberships, opts["user"])
1278 Fetch favorites activities of user with order by sort adds to favorites
1280 @spec fetch_favourites(User.t(), map(), Pagination.type()) :: list(Activity.t())
1281 def fetch_favourites(user, params \\ %{}, pagination \\ :keyset) do
1283 |> Activity.Queries.by_actor()
1284 |> Activity.Queries.by_type("Like")
1285 |> Activity.with_joined_object()
1286 |> Object.with_joined_activity()
1287 |> select([_like, object, activity], %{activity | object: object})
1288 |> order_by([like, _, _], desc: like.id)
1289 |> Pagination.fetch_paginated(
1290 Map.merge(params, %{"skip_order" => true}),
1296 defp maybe_update_cc(activities, list_memberships, %User{ap_id: user_ap_id})
1297 when is_list(list_memberships) and length(list_memberships) > 0 do
1298 Enum.map(activities, fn
1299 %{data: %{"bcc" => bcc}} = activity when is_list(bcc) and length(bcc) > 0 ->
1300 if Enum.any?(bcc, &(&1 in list_memberships)) do
1301 update_in(activity.data["cc"], &[user_ap_id | &1])
1311 defp maybe_update_cc(activities, _, _), do: activities
1313 def fetch_activities_bounded_query(query, recipients, recipients_with_public) do
1314 from(activity in query,
1316 fragment("? && ?", activity.recipients, ^recipients) or
1317 (fragment("? && ?", activity.recipients, ^recipients_with_public) and
1318 ^Constants.as_public() in activity.recipients)
1322 def fetch_activities_bounded(
1324 recipients_with_public,
1326 pagination \\ :keyset
1328 fetch_activities_query([], opts)
1329 |> fetch_activities_bounded_query(recipients, recipients_with_public)
1330 |> Pagination.fetch_paginated(opts, pagination)
1334 @spec upload(Upload.source(), keyword()) :: {:ok, Object.t()} | {:error, any()}
1335 def upload(file, opts \\ []) do
1336 with {:ok, data} <- Upload.store(file, opts) do
1339 Map.put(data, "actor", opts[:actor])
1344 Repo.insert(%Object{data: obj_data})
1348 @spec get_actor_url(any()) :: binary() | nil
1349 defp get_actor_url(url) when is_binary(url), do: url
1350 defp get_actor_url(%{"href" => href}) when is_binary(href), do: href
1352 defp get_actor_url(url) when is_list(url) do
1358 defp get_actor_url(_url), do: nil
1360 defp object_to_user_data(data) do
1362 data["icon"]["url"] &&
1365 "url" => [%{"href" => data["icon"]["url"]}]
1369 data["image"]["url"] &&
1372 "url" => [%{"href" => data["image"]["url"]}]
1377 |> Map.get("attachment", [])
1378 |> Enum.filter(fn %{"type" => t} -> t == "PropertyValue" end)
1379 |> Enum.map(fn fields -> Map.take(fields, ["name", "value"]) end)
1383 |> Map.get("tag", [])
1385 %{"type" => "Emoji"} -> true
1388 |> Enum.reduce(%{}, fn %{"icon" => %{"url" => url}, "name" => name}, acc ->
1389 Map.put(acc, String.trim(name, ":"), url)
1392 locked = data["manuallyApprovesFollowers"] || false
1393 data = Transmogrifier.maybe_fix_user_object(data)
1394 discoverable = data["discoverable"] || false
1395 invisible = data["invisible"] || false
1396 actor_type = data["type"] || "Person"
1399 if is_map(data["publicKey"]) && is_binary(data["publicKey"]["publicKeyPem"]) do
1400 data["publicKey"]["publicKeyPem"]
1406 if is_map(data["endpoints"]) && is_binary(data["endpoints"]["sharedInbox"]) do
1407 data["endpoints"]["sharedInbox"]
1414 uri: get_actor_url(data["url"]),
1420 discoverable: discoverable,
1421 invisible: invisible,
1424 follower_address: data["followers"],
1425 following_address: data["following"],
1426 bio: data["summary"],
1427 actor_type: actor_type,
1428 also_known_as: Map.get(data, "alsoKnownAs", []),
1429 public_key: public_key,
1430 inbox: data["inbox"],
1431 shared_inbox: shared_inbox
1434 # nickname can be nil because of virtual actors
1436 if data["preferredUsername"] do
1440 "#{data["preferredUsername"]}@#{URI.parse(data["id"]).host}"
1443 Map.put(user_data, :nickname, nil)
1449 def fetch_follow_information_for_user(user) do
1450 with {:ok, following_data} <-
1451 Fetcher.fetch_and_contain_remote_object_from_id(user.following_address),
1452 {:ok, hide_follows} <- collection_private(following_data),
1453 {:ok, followers_data} <-
1454 Fetcher.fetch_and_contain_remote_object_from_id(user.follower_address),
1455 {:ok, hide_followers} <- collection_private(followers_data) do
1458 hide_follows: hide_follows,
1459 follower_count: normalize_counter(followers_data["totalItems"]),
1460 following_count: normalize_counter(following_data["totalItems"]),
1461 hide_followers: hide_followers
1464 {:error, _} = e -> e
1469 defp normalize_counter(counter) when is_integer(counter), do: counter
1470 defp normalize_counter(_), do: 0
1472 defp maybe_update_follow_information(data) do
1473 with {:enabled, true} <- {:enabled, Config.get([:instance, :external_user_synchronization])},
1474 {:ok, info} <- fetch_follow_information_for_user(data) do
1475 info = Map.merge(data[:info] || %{}, info)
1476 Map.put(data, :info, info)
1478 {:enabled, false} ->
1483 "Follower/Following counter update for #{data.ap_id} failed.\n" <> inspect(e)
1490 defp collection_private(%{"first" => %{"type" => type}})
1491 when type in ["CollectionPage", "OrderedCollectionPage"],
1494 defp collection_private(%{"first" => first}) do
1495 with {:ok, %{"type" => type}} when type in ["CollectionPage", "OrderedCollectionPage"] <-
1496 Fetcher.fetch_and_contain_remote_object_from_id(first) do
1499 {:error, {:ok, %{status: code}}} when code in [401, 403] -> {:ok, true}
1500 {:error, _} = e -> e
1505 defp collection_private(_data), do: {:ok, true}
1507 def user_data_from_user_object(data) do
1508 with {:ok, data} <- MRF.filter(data),
1509 {:ok, data} <- object_to_user_data(data) do
1516 def fetch_and_prepare_user_from_ap_id(ap_id) do
1517 with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id),
1518 {:ok, data} <- user_data_from_user_object(data),
1519 data <- maybe_update_follow_information(data) do
1522 {:error, "Object has been deleted"} = e ->
1523 Logger.debug("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
1527 Logger.error("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
1532 def make_user_from_ap_id(ap_id) do
1533 user = User.get_cached_by_ap_id(ap_id)
1535 if user && !User.ap_enabled?(user) do
1536 Transmogrifier.upgrade_user_from_ap_id(ap_id)
1538 with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id) do
1541 |> User.remote_user_changeset(data)
1542 |> User.update_and_set_cache()
1545 |> User.remote_user_changeset()
1555 def make_user_from_nickname(nickname) do
1556 with {:ok, %{"ap_id" => ap_id}} when not is_nil(ap_id) <- WebFinger.finger(nickname) do
1557 make_user_from_ap_id(ap_id)
1559 _e -> {:error, "No AP id in WebFinger"}
1563 # filter out broken threads
1564 def contain_broken_threads(%Activity{} = activity, %User{} = user) do
1565 entire_thread_visible_for_user?(activity, user)
1568 # do post-processing on a specific activity
1569 def contain_activity(%Activity{} = activity, %User{} = user) do
1570 contain_broken_threads(activity, user)
1573 def fetch_direct_messages_query do
1575 |> restrict_type(%{"type" => "Create"})
1576 |> restrict_visibility(%{visibility: "direct"})
1577 |> order_by([activity], asc: activity.id)