1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2019 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.Conversation
10 alias Pleroma.Conversation.Participation
11 alias Pleroma.Notification
13 alias Pleroma.Object.Containment
14 alias Pleroma.Object.Fetcher
15 alias Pleroma.Pagination
19 alias Pleroma.Web.ActivityPub.MRF
20 alias Pleroma.Web.ActivityPub.Transmogrifier
21 alias Pleroma.Web.ActivityPub.Utils
22 alias Pleroma.Web.Streamer
23 alias Pleroma.Web.WebFinger
24 alias Pleroma.Workers.BackgroundWorker
27 import Pleroma.Web.ActivityPub.Utils
28 import Pleroma.Web.ActivityPub.Visibility
31 require Pleroma.Constants
33 # For Announce activities, we filter the recipients based on following status for any actors
34 # that match actual users. See issue #164 for more information about why this is necessary.
35 defp get_recipients(%{"type" => "Announce"} = data) do
36 to = Map.get(data, "to", [])
37 cc = Map.get(data, "cc", [])
38 bcc = Map.get(data, "bcc", [])
39 actor = User.get_cached_by_ap_id(data["actor"])
42 Enum.filter(Enum.concat([to, cc, bcc]), fn recipient ->
43 case User.get_cached_by_ap_id(recipient) do
45 user -> User.following?(user, actor)
52 defp get_recipients(%{"type" => "Create"} = data) do
53 to = Map.get(data, "to", [])
54 cc = Map.get(data, "cc", [])
55 bcc = Map.get(data, "bcc", [])
56 actor = Map.get(data, "actor", [])
57 recipients = [to, cc, bcc, [actor]] |> Enum.concat() |> Enum.uniq()
61 defp get_recipients(data) do
62 to = Map.get(data, "to", [])
63 cc = Map.get(data, "cc", [])
64 bcc = Map.get(data, "bcc", [])
65 recipients = Enum.concat([to, cc, bcc])
69 defp check_actor_is_active(actor) do
70 if not is_nil(actor) do
71 with user <- User.get_cached_by_ap_id(actor),
72 false <- user.deactivated do
82 defp check_remote_limit(%{"object" => %{"content" => content}}) when not is_nil(content) do
83 limit = Config.get([:instance, :remote_limit])
84 String.length(content) <= limit
87 defp check_remote_limit(_), do: true
89 def increase_note_count_if_public(actor, object) do
90 if is_public?(object), do: User.increase_note_count(actor), else: {:ok, actor}
93 def decrease_note_count_if_public(actor, object) do
94 if is_public?(object), do: User.decrease_note_count(actor), else: {:ok, actor}
97 def increase_replies_count_if_reply(%{
98 "object" => %{"inReplyTo" => reply_ap_id} = object,
101 if is_public?(object) do
102 Object.increase_replies_count(reply_ap_id)
106 def increase_replies_count_if_reply(_create_data), do: :noop
108 def decrease_replies_count_if_reply(%Object{
109 data: %{"inReplyTo" => reply_ap_id} = object
111 if is_public?(object) do
112 Object.decrease_replies_count(reply_ap_id)
116 def decrease_replies_count_if_reply(_object), do: :noop
118 def increase_poll_votes_if_vote(%{
119 "object" => %{"inReplyTo" => reply_ap_id, "name" => name},
122 Object.increase_vote_count(reply_ap_id, name)
125 def increase_poll_votes_if_vote(_create_data), do: :noop
127 # TODO rewrite in with style
128 @spec persist(map(), keyword()) :: {:ok, Activity.t() | Object.t()}
129 def persist(object, meta) do
130 local = Keyword.fetch!(meta, :local)
131 {recipients, _, _} = get_recipients(object)
134 Repo.insert(%Activity{
137 recipients: recipients,
138 actor: object["actor"]
141 {:ok, activity, meta}
144 def insert(map, local \\ true, fake \\ false, bypass_actor_check \\ false) when is_map(map) do
145 with nil <- Activity.normalize(map),
146 map <- lazy_put_activity_defaults(map, fake),
147 true <- bypass_actor_check || check_actor_is_active(map["actor"]),
148 {_, true} <- {:remote_limit_error, check_remote_limit(map)},
149 {:ok, map} <- MRF.filter(map),
150 {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 def create(%{to: to, actor: actor, context: context, object: object} = params, fake \\ false) do
253 additional = params[:additional] || %{}
254 # only accept false as false value
255 local = !(params[:local] == false)
256 published = params[:published]
257 quick_insert? = Pleroma.Config.get([:env]) == :benchmark
261 %{to: to, actor: actor, published: published, context: context, object: object},
264 {:ok, activity} <- insert(create_data, local, fake),
265 {:fake, false, activity} <- {:fake, fake, activity},
266 _ <- increase_replies_count_if_reply(create_data),
267 _ <- increase_poll_votes_if_vote(create_data),
268 {:quick_insert, false, activity} <- {:quick_insert, quick_insert?, activity},
269 {:ok, _actor} <- increase_note_count_if_public(actor, activity),
270 :ok <- maybe_federate(activity) do
273 {:quick_insert, true, activity} ->
276 {:fake, true, activity} ->
284 def listen(%{to: to, actor: actor, context: context, object: object} = params) do
285 additional = params[:additional] || %{}
286 # only accept false as false value
287 local = !(params[:local] == false)
288 published = params[:published]
292 %{to: to, actor: actor, published: published, context: context, object: object},
295 {:ok, activity} <- insert(listen_data, local),
296 :ok <- maybe_federate(activity) do
304 def accept(params) do
305 accept_or_reject("Accept", params)
308 def reject(params) do
309 accept_or_reject("Reject", params)
312 def accept_or_reject(type, %{to: to, actor: actor, object: object} = params) do
313 local = Map.get(params, :local, true)
314 activity_id = Map.get(params, :activity_id, nil)
317 %{"to" => to, "type" => type, "actor" => actor.ap_id, "object" => object}
318 |> Utils.maybe_put("id", activity_id),
319 {:ok, activity} <- insert(data, local),
320 :ok <- maybe_federate(activity) do
325 def update(%{to: to, cc: cc, actor: actor, object: object} = params) do
326 local = !(params[:local] == false)
327 activity_id = params[:activity_id]
336 data <- Utils.maybe_put(data, "id", activity_id),
337 {:ok, activity} <- insert(data, local),
338 :ok <- maybe_federate(activity) do
343 def react_with_emoji(user, object, emoji, options \\ []) do
344 with local <- Keyword.get(options, :local, true),
345 activity_id <- Keyword.get(options, :activity_id, nil),
346 Pleroma.Emoji.is_unicode_emoji?(emoji),
347 reaction_data <- make_emoji_reaction_data(user, object, emoji, activity_id),
348 {:ok, activity} <- insert(reaction_data, local),
349 {:ok, object} <- add_emoji_reaction_to_object(activity, object),
350 :ok <- maybe_federate(activity) do
351 {:ok, activity, object}
355 def unreact_with_emoji(user, reaction_id, options \\ []) do
356 with local <- Keyword.get(options, :local, true),
357 activity_id <- Keyword.get(options, :activity_id, nil),
358 user_ap_id <- user.ap_id,
359 %Activity{actor: ^user_ap_id} = reaction_activity <- Activity.get_by_ap_id(reaction_id),
360 object <- Object.normalize(reaction_activity),
361 unreact_data <- make_undo_data(user, reaction_activity, activity_id),
362 {:ok, activity} <- insert(unreact_data, local),
363 {:ok, object} <- remove_emoji_reaction_from_object(reaction_activity, object),
364 :ok <- maybe_federate(activity) do
365 {:ok, activity, object}
369 # TODO: This is weird, maybe we shouldn't check here if we can make the activity.
371 %User{ap_id: ap_id} = user,
372 %Object{data: %{"id" => _}} = object,
376 with nil <- get_existing_like(ap_id, object),
377 like_data <- make_like_data(user, object, activity_id),
378 {:ok, activity} <- insert(like_data, local),
379 {:ok, object} <- add_like_to_object(activity, object),
380 :ok <- maybe_federate(activity) do
381 {:ok, activity, object}
383 %Activity{} = activity -> {:ok, activity, object}
384 error -> {:error, error}
388 def unlike(%User{} = actor, %Object{} = object, activity_id \\ nil, local \\ true) do
389 with %Activity{} = like_activity <- get_existing_like(actor.ap_id, object),
390 unlike_data <- make_unlike_data(actor, like_activity, activity_id),
391 {:ok, unlike_activity} <- insert(unlike_data, local),
392 {:ok, _activity} <- Repo.delete(like_activity),
393 {:ok, object} <- remove_like_from_object(like_activity, object),
394 :ok <- maybe_federate(unlike_activity) do
395 {:ok, unlike_activity, like_activity, object}
402 %User{ap_id: _} = user,
403 %Object{data: %{"id" => _}} = object,
408 with true <- is_announceable?(object, user, public),
409 announce_data <- make_announce_data(user, object, activity_id, public),
410 {:ok, activity} <- insert(announce_data, local),
411 {:ok, object} <- add_announce_to_object(activity, object),
412 :ok <- maybe_federate(activity) do
413 {:ok, activity, object}
415 error -> {:error, error}
425 with %Activity{} = announce_activity <- get_existing_announce(actor.ap_id, object),
426 unannounce_data <- make_unannounce_data(actor, announce_activity, activity_id),
427 {:ok, unannounce_activity} <- insert(unannounce_data, local),
428 :ok <- maybe_federate(unannounce_activity),
429 {:ok, _activity} <- Repo.delete(announce_activity),
430 {:ok, object} <- remove_announce_from_object(announce_activity, object) do
431 {:ok, unannounce_activity, object}
437 def follow(follower, followed, activity_id \\ nil, local \\ true) do
438 with data <- make_follow_data(follower, followed, activity_id),
439 {:ok, activity} <- insert(data, local),
440 :ok <- maybe_federate(activity),
441 _ <- User.set_follow_state_cache(follower.ap_id, followed.ap_id, activity.data["state"]) do
446 def unfollow(follower, followed, activity_id \\ nil, local \\ true) do
447 with %Activity{} = follow_activity <- fetch_latest_follow(follower, followed),
448 {:ok, follow_activity} <- update_follow_state(follow_activity, "cancelled"),
449 unfollow_data <- make_unfollow_data(follower, followed, follow_activity, activity_id),
450 {:ok, activity} <- insert(unfollow_data, local),
451 :ok <- maybe_federate(activity) do
456 def delete(%User{ap_id: ap_id, follower_address: follower_address} = user) do
458 "to" => [follower_address],
461 "object" => %{"type" => "Person", "id" => ap_id}
463 {:ok, activity} <- insert(data, true, true, true),
464 :ok <- maybe_federate(activity) do
469 def delete(%Object{data: %{"id" => id, "actor" => actor}} = object, options \\ []) do
470 local = Keyword.get(options, :local, true)
471 activity_id = Keyword.get(options, :activity_id, nil)
472 actor = Keyword.get(options, :actor, actor)
474 user = User.get_cached_by_ap_id(actor)
475 to = (object.data["to"] || []) ++ (object.data["cc"] || [])
477 with {:ok, object, activity} <- Object.delete(object),
484 "deleted_activity_id" => activity && activity.id
486 |> maybe_put("id", activity_id),
487 {:ok, activity} <- insert(data, local, false),
488 stream_out_participations(object, user),
489 _ <- decrease_replies_count_if_reply(object),
490 {:ok, _actor} <- decrease_note_count_if_public(user, object),
491 :ok <- maybe_federate(activity) do
496 @spec block(User.t(), User.t(), String.t() | nil, boolean) :: {:ok, Activity.t() | nil}
497 def block(blocker, blocked, activity_id \\ nil, local \\ true) do
498 outgoing_blocks = Config.get([:activitypub, :outgoing_blocks])
499 unfollow_blocked = Config.get([:activitypub, :unfollow_blocked])
501 if unfollow_blocked do
502 follow_activity = fetch_latest_follow(blocker, blocked)
503 if follow_activity, do: unfollow(blocker, blocked, nil, local)
506 with true <- outgoing_blocks,
507 block_data <- make_block_data(blocker, blocked, activity_id),
508 {:ok, activity} <- insert(block_data, local),
509 :ok <- maybe_federate(activity) do
516 def unblock(blocker, blocked, activity_id \\ nil, local \\ true) do
517 with %Activity{} = block_activity <- fetch_latest_block(blocker, blocked),
518 unblock_data <- make_unblock_data(blocker, blocked, block_activity, activity_id),
519 {:ok, activity} <- insert(unblock_data, local),
520 :ok <- maybe_federate(activity) do
525 @spec flag(map()) :: {:ok, Activity.t()} | any
535 # only accept false as false value
536 local = !(params[:local] == false)
537 forward = !(params[:forward] == false)
539 additional = params[:additional] || %{}
543 Map.merge(additional, %{"to" => [], "cc" => [account.ap_id]})
545 Map.merge(additional, %{"to" => [], "cc" => []})
548 with flag_data <- make_flag_data(params, additional),
549 {:ok, activity} <- insert(flag_data, local),
550 {:ok, stripped_activity} <- strip_report_status_data(activity),
551 :ok <- maybe_federate(stripped_activity) do
552 Enum.each(User.all_superusers(), fn superuser ->
554 |> Pleroma.Emails.AdminEmail.report(actor, account, statuses, content)
555 |> Pleroma.Emails.Mailer.deliver_async()
562 def move(%User{} = origin, %User{} = target, local \\ true) do
565 "actor" => origin.ap_id,
566 "object" => origin.ap_id,
567 "target" => target.ap_id
570 with true <- origin.ap_id in target.also_known_as,
571 {:ok, activity} <- insert(params, local) do
572 maybe_federate(activity)
574 BackgroundWorker.enqueue("move_following", %{
575 "origin_id" => origin.id,
576 "target_id" => target.id
581 false -> {:error, "Target account must have the origin in `alsoKnownAs`"}
586 defp fetch_activities_for_context_query(context, opts) do
587 public = [Pleroma.Constants.as_public()]
591 do: [opts["user"].ap_id | User.following(opts["user"])] ++ public,
594 from(activity in Activity)
595 |> maybe_preload_objects(opts)
596 |> maybe_preload_bookmarks(opts)
597 |> maybe_set_thread_muted_field(opts)
598 |> restrict_blocked(opts)
599 |> restrict_recipients(recipients, opts["user"])
603 "?->>'type' = ? and ?->>'context' = ?",
610 |> exclude_poll_votes(opts)
612 |> order_by([activity], desc: activity.id)
615 @spec fetch_activities_for_context(String.t(), keyword() | map()) :: [Activity.t()]
616 def fetch_activities_for_context(context, opts \\ %{}) do
618 |> fetch_activities_for_context_query(opts)
622 @spec fetch_latest_activity_id_for_context(String.t(), keyword() | map()) ::
623 FlakeId.Ecto.CompatType.t() | nil
624 def fetch_latest_activity_id_for_context(context, opts \\ %{}) do
626 |> fetch_activities_for_context_query(Map.merge(%{"skip_preload" => true}, opts))
632 def fetch_public_activities(opts \\ %{}, pagination \\ :keyset) do
633 opts = Map.drop(opts, ["user"])
635 [Pleroma.Constants.as_public()]
636 |> fetch_activities_query(opts)
637 |> restrict_unlisted()
638 |> Pagination.fetch_paginated(opts, pagination)
641 @valid_visibilities ~w[direct unlisted public private]
643 defp restrict_visibility(query, %{visibility: visibility})
644 when is_list(visibility) do
645 if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
651 "activity_visibility(?, ?, ?) = ANY (?)",
661 Logger.error("Could not restrict visibility to #{visibility}")
665 defp restrict_visibility(query, %{visibility: visibility})
666 when visibility in @valid_visibilities do
670 fragment("activity_visibility(?, ?, ?) = ?", a.actor, a.recipients, a.data, ^visibility)
674 defp restrict_visibility(_query, %{visibility: visibility})
675 when visibility not in @valid_visibilities do
676 Logger.error("Could not restrict visibility to #{visibility}")
679 defp restrict_visibility(query, _visibility), do: query
681 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
682 when is_list(visibility) do
683 if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
688 "activity_visibility(?, ?, ?) = ANY (?)",
696 Logger.error("Could not exclude visibility to #{visibility}")
701 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
702 when visibility in @valid_visibilities do
707 "activity_visibility(?, ?, ?) = ?",
716 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
717 when visibility not in @valid_visibilities do
718 Logger.error("Could not exclude visibility to #{visibility}")
722 defp exclude_visibility(query, _visibility), do: query
724 defp restrict_thread_visibility(query, _, %{skip_thread_containment: true} = _),
727 defp restrict_thread_visibility(
729 %{"user" => %User{skip_thread_containment: true}},
734 defp restrict_thread_visibility(query, %{"user" => %User{ap_id: ap_id}}, _) do
737 where: fragment("thread_visibility(?, (?)->>'id') = true", ^ap_id, a.data)
741 defp restrict_thread_visibility(query, _, _), do: query
743 def fetch_user_abstract_activities(user, reading_user, params \\ %{}) do
746 |> Map.put("user", reading_user)
747 |> Map.put("actor_id", user.ap_id)
748 |> Map.put("whole_db", true)
751 user_activities_recipients(%{
752 "godmode" => params["godmode"],
753 "reading_user" => reading_user
756 fetch_activities(recipients, params)
760 def fetch_user_activities(user, reading_user, params \\ %{}) do
763 |> Map.put("type", ["Create", "Announce"])
764 |> Map.put("user", reading_user)
765 |> Map.put("actor_id", user.ap_id)
766 |> Map.put("whole_db", true)
767 |> Map.put("pinned_activity_ids", user.pinned_activities)
770 user_activities_recipients(%{
771 "godmode" => params["godmode"],
772 "reading_user" => reading_user
775 fetch_activities(recipients, params)
779 def fetch_instance_activities(params) do
782 |> Map.put("type", ["Create", "Announce"])
783 |> Map.put("instance", params["instance"])
784 |> Map.put("whole_db", true)
786 fetch_activities([Pleroma.Constants.as_public()], params, :offset)
790 defp user_activities_recipients(%{"godmode" => true}) do
794 defp user_activities_recipients(%{"reading_user" => reading_user}) do
796 [Pleroma.Constants.as_public()] ++ [reading_user.ap_id | User.following(reading_user)]
798 [Pleroma.Constants.as_public()]
802 defp restrict_since(query, %{"since_id" => ""}), do: query
804 defp restrict_since(query, %{"since_id" => since_id}) do
805 from(activity in query, where: activity.id > ^since_id)
808 defp restrict_since(query, _), do: query
810 defp restrict_tag_reject(_query, %{"tag_reject" => _tag_reject, "skip_preload" => true}) do
811 raise "Can't use the child object without preloading!"
814 defp restrict_tag_reject(query, %{"tag_reject" => tag_reject})
815 when is_list(tag_reject) and tag_reject != [] do
817 [_activity, object] in query,
818 where: fragment("not (?)->'tag' \\?| (?)", object.data, ^tag_reject)
822 defp restrict_tag_reject(query, _), do: query
824 defp restrict_tag_all(_query, %{"tag_all" => _tag_all, "skip_preload" => true}) do
825 raise "Can't use the child object without preloading!"
828 defp restrict_tag_all(query, %{"tag_all" => tag_all})
829 when is_list(tag_all) and tag_all != [] do
831 [_activity, object] in query,
832 where: fragment("(?)->'tag' \\?& (?)", object.data, ^tag_all)
836 defp restrict_tag_all(query, _), do: query
838 defp restrict_tag(_query, %{"tag" => _tag, "skip_preload" => true}) do
839 raise "Can't use the child object without preloading!"
842 defp restrict_tag(query, %{"tag" => tag}) when is_list(tag) do
844 [_activity, object] in query,
845 where: fragment("(?)->'tag' \\?| (?)", object.data, ^tag)
849 defp restrict_tag(query, %{"tag" => tag}) when is_binary(tag) do
851 [_activity, object] in query,
852 where: fragment("(?)->'tag' \\? (?)", object.data, ^tag)
856 defp restrict_tag(query, _), do: query
858 defp restrict_recipients(query, [], _user), do: query
860 defp restrict_recipients(query, recipients, nil) do
861 from(activity in query, where: fragment("? && ?", ^recipients, activity.recipients))
864 defp restrict_recipients(query, recipients, user) do
867 where: fragment("? && ?", ^recipients, activity.recipients),
868 or_where: activity.actor == ^user.ap_id
872 defp restrict_local(query, %{"local_only" => true}) do
873 from(activity in query, where: activity.local == true)
876 defp restrict_local(query, _), do: query
878 defp restrict_actor(query, %{"actor_id" => actor_id}) do
879 from(activity in query, where: activity.actor == ^actor_id)
882 defp restrict_actor(query, _), do: query
884 defp restrict_type(query, %{"type" => type}) when is_binary(type) do
885 from(activity in query, where: fragment("?->>'type' = ?", activity.data, ^type))
888 defp restrict_type(query, %{"type" => type}) do
889 from(activity in query, where: fragment("?->>'type' = ANY(?)", activity.data, ^type))
892 defp restrict_type(query, _), do: query
894 defp restrict_state(query, %{"state" => state}) do
895 from(activity in query, where: fragment("?->>'state' = ?", activity.data, ^state))
898 defp restrict_state(query, _), do: query
900 defp restrict_favorited_by(query, %{"favorited_by" => ap_id}) do
902 [_activity, object] in query,
903 where: fragment("(?)->'likes' \\? (?)", object.data, ^ap_id)
907 defp restrict_favorited_by(query, _), do: query
909 defp restrict_media(_query, %{"only_media" => _val, "skip_preload" => true}) do
910 raise "Can't use the child object without preloading!"
913 defp restrict_media(query, %{"only_media" => val}) when val == "true" or val == "1" do
915 [_activity, object] in query,
916 where: fragment("not (?)->'attachment' = (?)", object.data, ^[])
920 defp restrict_media(query, _), do: query
922 defp restrict_replies(query, %{"exclude_replies" => val}) when val == "true" or val == "1" do
924 [_activity, object] in query,
925 where: fragment("?->>'inReplyTo' is null", object.data)
929 defp restrict_replies(query, _), do: query
931 defp restrict_reblogs(query, %{"exclude_reblogs" => val}) when val == "true" or val == "1" do
932 from(activity in query, where: fragment("?->>'type' != 'Announce'", activity.data))
935 defp restrict_reblogs(query, _), do: query
937 defp restrict_muted(query, %{"with_muted" => val}) when val in [true, "true", "1"], do: query
939 defp restrict_muted(query, %{"muting_user" => %User{} = user} = opts) do
943 from([activity] in query,
944 where: fragment("not (? = ANY(?))", activity.actor, ^mutes),
945 where: fragment("not (?->'to' \\?| ?)", activity.data, ^mutes)
948 unless opts["skip_preload"] do
949 from([thread_mute: tm] in query, where: is_nil(tm.user_id))
955 defp restrict_muted(query, _), do: query
957 defp restrict_blocked(query, %{"blocking_user" => %User{} = user}) do
958 blocks = user.blocks || []
959 domain_blocks = user.domain_blocks || []
962 if has_named_binding?(query, :object), do: query, else: Activity.with_joined_object(query)
965 [activity, object: o] in query,
966 where: fragment("not (? = ANY(?))", activity.actor, ^blocks),
967 where: fragment("not (? && ?)", activity.recipients, ^blocks),
970 "not (?->>'type' = 'Announce' and ?->'to' \\?| ?)",
975 where: fragment("not (split_part(?, '/', 3) = ANY(?))", activity.actor, ^domain_blocks),
976 where: fragment("not (split_part(?->>'actor', '/', 3) = ANY(?))", o.data, ^domain_blocks)
980 defp restrict_blocked(query, _), do: query
982 defp restrict_unlisted(query) do
987 "not (coalesce(?->'cc', '{}'::jsonb) \\?| ?)",
989 ^[Pleroma.Constants.as_public()]
994 defp restrict_pinned(query, %{"pinned" => "true", "pinned_activity_ids" => ids}) do
995 from(activity in query, where: activity.id in ^ids)
998 defp restrict_pinned(query, _), do: query
1000 defp restrict_muted_reblogs(query, %{"muting_user" => %User{} = user}) do
1001 muted_reblogs = user.muted_reblogs || []
1007 "not ( ?->>'type' = 'Announce' and ? = ANY(?))",
1015 defp restrict_muted_reblogs(query, _), do: query
1017 defp restrict_instance(query, %{"instance" => instance}) do
1022 where: fragment("? LIKE ?", u.nickname, ^"%@#{instance}")
1026 from(activity in query, where: activity.actor in ^users)
1029 defp restrict_instance(query, _), do: query
1031 defp exclude_poll_votes(query, %{"include_poll_votes" => true}), do: query
1033 defp exclude_poll_votes(query, _) do
1034 if has_named_binding?(query, :object) do
1035 from([activity, object: o] in query,
1036 where: fragment("not(?->>'type' = ?)", o.data, "Answer")
1043 defp exclude_id(query, %{"exclude_id" => id}) when is_binary(id) do
1044 from(activity in query, where: activity.id != ^id)
1047 defp exclude_id(query, _), do: query
1049 defp maybe_preload_objects(query, %{"skip_preload" => true}), do: query
1051 defp maybe_preload_objects(query, _) do
1053 |> Activity.with_preloaded_object()
1056 defp maybe_preload_bookmarks(query, %{"skip_preload" => true}), do: query
1058 defp maybe_preload_bookmarks(query, opts) do
1060 |> Activity.with_preloaded_bookmark(opts["user"])
1063 defp maybe_set_thread_muted_field(query, %{"skip_preload" => true}), do: query
1065 defp maybe_set_thread_muted_field(query, opts) do
1067 |> Activity.with_set_thread_muted_field(opts["muting_user"] || opts["user"])
1070 defp maybe_order(query, %{order: :desc}) do
1072 |> order_by(desc: :id)
1075 defp maybe_order(query, %{order: :asc}) do
1077 |> order_by(asc: :id)
1080 defp maybe_order(query, _), do: query
1082 def fetch_activities_query(recipients, opts \\ %{}) do
1084 skip_thread_containment: Config.get([:instance, :skip_thread_containment])
1088 |> maybe_preload_objects(opts)
1089 |> maybe_preload_bookmarks(opts)
1090 |> maybe_set_thread_muted_field(opts)
1091 |> maybe_order(opts)
1092 |> restrict_recipients(recipients, opts["user"])
1093 |> restrict_tag(opts)
1094 |> restrict_tag_reject(opts)
1095 |> restrict_tag_all(opts)
1096 |> restrict_since(opts)
1097 |> restrict_local(opts)
1098 |> restrict_actor(opts)
1099 |> restrict_type(opts)
1100 |> restrict_state(opts)
1101 |> restrict_favorited_by(opts)
1102 |> restrict_blocked(opts)
1103 |> restrict_muted(opts)
1104 |> restrict_media(opts)
1105 |> restrict_visibility(opts)
1106 |> restrict_thread_visibility(opts, config)
1107 |> restrict_replies(opts)
1108 |> restrict_reblogs(opts)
1109 |> restrict_pinned(opts)
1110 |> restrict_muted_reblogs(opts)
1111 |> restrict_instance(opts)
1112 |> Activity.restrict_deactivated_users()
1113 |> exclude_poll_votes(opts)
1114 |> exclude_visibility(opts)
1117 def fetch_activities(recipients, opts \\ %{}, pagination \\ :keyset) do
1118 list_memberships = Pleroma.List.memberships(opts["user"])
1120 fetch_activities_query(recipients ++ list_memberships, opts)
1121 |> Pagination.fetch_paginated(opts, pagination)
1123 |> maybe_update_cc(list_memberships, opts["user"])
1126 defp maybe_update_cc(activities, list_memberships, %User{ap_id: user_ap_id})
1127 when is_list(list_memberships) and length(list_memberships) > 0 do
1128 Enum.map(activities, fn
1129 %{data: %{"bcc" => bcc}} = activity when is_list(bcc) and length(bcc) > 0 ->
1130 if Enum.any?(bcc, &(&1 in list_memberships)) do
1131 update_in(activity.data["cc"], &[user_ap_id | &1])
1141 defp maybe_update_cc(activities, _, _), do: activities
1143 def fetch_activities_bounded_query(query, recipients, recipients_with_public) do
1144 from(activity in query,
1146 fragment("? && ?", activity.recipients, ^recipients) or
1147 (fragment("? && ?", activity.recipients, ^recipients_with_public) and
1148 ^Pleroma.Constants.as_public() in activity.recipients)
1152 def fetch_activities_bounded(
1154 recipients_with_public,
1156 pagination \\ :keyset
1158 fetch_activities_query([], opts)
1159 |> fetch_activities_bounded_query(recipients, recipients_with_public)
1160 |> Pagination.fetch_paginated(opts, pagination)
1164 def upload(file, opts \\ []) do
1165 with {:ok, data} <- Upload.store(file, opts) do
1168 Map.put(data, "actor", opts[:actor])
1173 Repo.insert(%Object{data: obj_data})
1177 defp object_to_user_data(data) do
1179 data["icon"]["url"] &&
1182 "url" => [%{"href" => data["icon"]["url"]}]
1186 data["image"]["url"] &&
1189 "url" => [%{"href" => data["image"]["url"]}]
1194 |> Map.get("attachment", [])
1195 |> Enum.filter(fn %{"type" => t} -> t == "PropertyValue" end)
1196 |> Enum.map(fn fields -> Map.take(fields, ["name", "value"]) end)
1198 locked = data["manuallyApprovesFollowers"] || false
1199 data = Transmogrifier.maybe_fix_user_object(data)
1200 discoverable = data["discoverable"] || false
1201 invisible = data["invisible"] || false
1210 discoverable: discoverable,
1211 invisible: invisible,
1214 follower_address: data["followers"],
1215 following_address: data["following"],
1216 bio: data["summary"],
1217 also_known_as: Map.get(data, "alsoKnownAs", [])
1220 # nickname can be nil because of virtual actors
1222 if data["preferredUsername"] do
1226 "#{data["preferredUsername"]}@#{URI.parse(data["id"]).host}"
1229 Map.put(user_data, :nickname, nil)
1235 def fetch_follow_information_for_user(user) do
1236 with {:ok, following_data} <-
1237 Fetcher.fetch_and_contain_remote_object_from_id(user.following_address),
1238 following_count when is_integer(following_count) <- following_data["totalItems"],
1239 {:ok, hide_follows} <- collection_private(following_data),
1240 {:ok, followers_data} <-
1241 Fetcher.fetch_and_contain_remote_object_from_id(user.follower_address),
1242 followers_count when is_integer(followers_count) <- followers_data["totalItems"],
1243 {:ok, hide_followers} <- collection_private(followers_data) do
1246 hide_follows: hide_follows,
1247 follower_count: followers_count,
1248 following_count: following_count,
1249 hide_followers: hide_followers
1260 defp maybe_update_follow_information(data) do
1261 with {:enabled, true} <-
1262 {:enabled, Pleroma.Config.get([:instance, :external_user_synchronization])},
1263 {:ok, info} <- fetch_follow_information_for_user(data) do
1264 info = Map.merge(data[:info] || %{}, info)
1265 Map.put(data, :info, info)
1267 {:enabled, false} ->
1272 "Follower/Following counter update for #{data.ap_id} failed.\n" <> inspect(e)
1279 defp collection_private(%{"first" => first}) do
1280 if is_map(first) and
1281 first["type"] in ["CollectionPage", "OrderedCollectionPage"] do
1284 with {:ok, %{"type" => type}} when type in ["CollectionPage", "OrderedCollectionPage"] <-
1285 Fetcher.fetch_and_contain_remote_object_from_id(first) do
1288 {:error, {:ok, %{status: code}}} when code in [401, 403] ->
1300 defp collection_private(_data), do: {:ok, true}
1302 def user_data_from_user_object(data) do
1303 with {:ok, data} <- MRF.filter(data),
1304 {:ok, data} <- object_to_user_data(data) do
1311 def fetch_and_prepare_user_from_ap_id(ap_id) do
1312 with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id),
1313 {:ok, data} <- user_data_from_user_object(data),
1314 data <- maybe_update_follow_information(data) do
1318 Logger.error("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
1323 def make_user_from_ap_id(ap_id) do
1324 if _user = User.get_cached_by_ap_id(ap_id) do
1325 Transmogrifier.upgrade_user_from_ap_id(ap_id)
1327 with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id) do
1328 User.insert_or_update_user(data)
1335 def make_user_from_nickname(nickname) do
1336 with {:ok, %{"ap_id" => ap_id}} when not is_nil(ap_id) <- WebFinger.finger(nickname) do
1337 make_user_from_ap_id(ap_id)
1339 _e -> {:error, "No AP id in WebFinger"}
1343 # filter out broken threads
1344 def contain_broken_threads(%Activity{} = activity, %User{} = user) do
1345 entire_thread_visible_for_user?(activity, user)
1348 # do post-processing on a specific activity
1349 def contain_activity(%Activity{} = activity, %User{} = user) do
1350 contain_broken_threads(activity, user)
1353 def fetch_direct_messages_query do
1355 |> restrict_type(%{"type" => "Create"})
1356 |> restrict_visibility(%{visibility: "direct"})
1357 |> order_by([activity], asc: activity.id)