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.Notification
12 alias Pleroma.Object.Containment
13 alias Pleroma.Object.Fetcher
14 alias Pleroma.Pagination
18 alias Pleroma.Web.ActivityPub.MRF
19 alias Pleroma.Web.ActivityPub.Transmogrifier
20 alias Pleroma.Web.ActivityPub.Utils
21 alias Pleroma.Web.Streamer
22 alias Pleroma.Web.WebFinger
23 alias Pleroma.Workers.BackgroundWorker
26 import Pleroma.Web.ActivityPub.Utils
27 import Pleroma.Web.ActivityPub.Visibility
30 require Pleroma.Constants
32 # For Announce activities, we filter the recipients based on following status for any actors
33 # that match actual users. See issue #164 for more information about why this is necessary.
34 defp get_recipients(%{"type" => "Announce"} = data) do
35 to = Map.get(data, "to", [])
36 cc = Map.get(data, "cc", [])
37 bcc = Map.get(data, "bcc", [])
38 actor = User.get_cached_by_ap_id(data["actor"])
41 Enum.filter(Enum.concat([to, cc, bcc]), fn recipient ->
42 case User.get_cached_by_ap_id(recipient) do
44 user -> User.following?(user, actor)
51 defp get_recipients(%{"type" => "Create"} = data) do
52 to = Map.get(data, "to", [])
53 cc = Map.get(data, "cc", [])
54 bcc = Map.get(data, "bcc", [])
55 actor = Map.get(data, "actor", [])
56 recipients = [to, cc, bcc, [actor]] |> Enum.concat() |> Enum.uniq()
60 defp get_recipients(data) do
61 to = Map.get(data, "to", [])
62 cc = Map.get(data, "cc", [])
63 bcc = Map.get(data, "bcc", [])
64 recipients = Enum.concat([to, cc, bcc])
68 defp check_actor_is_active(actor) do
69 if not is_nil(actor) do
70 with user <- User.get_cached_by_ap_id(actor),
71 false <- user.info.deactivated do
81 defp check_remote_limit(%{"object" => %{"content" => content}}) when not is_nil(content) do
82 limit = Config.get([:instance, :remote_limit])
83 String.length(content) <= limit
86 defp check_remote_limit(_), do: true
88 def increase_note_count_if_public(actor, object) do
89 if is_public?(object), do: User.increase_note_count(actor), else: {:ok, actor}
92 def decrease_note_count_if_public(actor, object) do
93 if is_public?(object), do: User.decrease_note_count(actor), else: {:ok, actor}
96 def increase_replies_count_if_reply(%{
97 "object" => %{"inReplyTo" => reply_ap_id} = object,
100 if is_public?(object) do
101 Object.increase_replies_count(reply_ap_id)
105 def increase_replies_count_if_reply(_create_data), do: :noop
107 def decrease_replies_count_if_reply(%Object{
108 data: %{"inReplyTo" => reply_ap_id} = object
110 if is_public?(object) do
111 Object.decrease_replies_count(reply_ap_id)
115 def decrease_replies_count_if_reply(_object), do: :noop
117 def increase_poll_votes_if_vote(%{
118 "object" => %{"inReplyTo" => reply_ap_id, "name" => name},
121 Object.increase_vote_count(reply_ap_id, name)
124 def increase_poll_votes_if_vote(_create_data), do: :noop
126 def insert(map, local \\ true, fake \\ false, bypass_actor_check \\ false) when is_map(map) do
127 with nil <- Activity.normalize(map),
128 map <- lazy_put_activity_defaults(map, fake),
129 true <- bypass_actor_check || check_actor_is_active(map["actor"]),
130 {_, true} <- {:remote_limit_error, check_remote_limit(map)},
131 {:ok, map} <- MRF.filter(map),
132 {recipients, _, _} = get_recipients(map),
133 {:fake, false, map, recipients} <- {:fake, fake, map, recipients},
134 :ok <- Containment.contain_child(map),
135 {:ok, map, object} <- insert_full_object(map) do
137 Repo.insert(%Activity{
141 recipients: recipients
144 # Splice in the child object if we have one.
146 if not is_nil(object) do
147 Map.put(activity, :object, object)
152 BackgroundWorker.enqueue("fetch_data_for_activity", %{"activity_id" => activity.id})
154 Notification.create_notifications(activity)
158 |> Conversation.create_or_bump_for()
159 |> get_participations()
162 stream_out_participations(participations)
165 %Activity{} = activity ->
168 {:fake, true, map, recipients} ->
169 activity = %Activity{
173 recipients: recipients,
177 Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
185 defp get_participations({:ok, %{participations: participations}}), do: participations
186 defp get_participations(_), do: []
188 def stream_out_participations(participations) do
191 |> Repo.preload(:user)
193 Streamer.stream("participation", participations)
196 def stream_out_participations(%Object{data: %{"context" => context}}, user) do
197 with %Conversation{} = conversation <- Conversation.get_for_ap_id(context),
198 conversation = Repo.preload(conversation, :participations),
200 fetch_latest_activity_id_for_context(conversation.ap_id, %{
202 "blocking_user" => user
204 if last_activity_id do
205 stream_out_participations(conversation.participations)
210 def stream_out_participations(_, _), do: :noop
212 def stream_out(%Activity{data: %{"type" => data_type}} = activity)
213 when data_type in ["Create", "Announce", "Delete"] do
215 |> Topics.get_activity_topics()
216 |> Streamer.stream(activity)
219 def stream_out(_activity) do
223 def create(%{to: to, actor: actor, context: context, object: object} = params, fake \\ false) do
224 additional = params[:additional] || %{}
225 # only accept false as false value
226 local = !(params[:local] == false)
227 published = params[:published]
231 %{to: to, actor: actor, published: published, context: context, object: object},
234 {:ok, activity} <- insert(create_data, local, fake),
235 {:fake, false, activity} <- {:fake, fake, activity},
236 _ <- increase_replies_count_if_reply(create_data),
237 _ <- increase_poll_votes_if_vote(create_data),
238 # Changing note count prior to enqueuing federation task in order to avoid
239 # race conditions on updating user.info
240 {:ok, _actor} <- increase_note_count_if_public(actor, activity),
241 :ok <- maybe_federate(activity) do
244 {:fake, true, activity} ->
252 def listen(%{to: to, actor: actor, context: context, object: object} = params) do
253 additional = params[:additional] || %{}
254 # only accept false as false value
255 local = !(params[:local] == false)
256 published = params[:published]
260 %{to: to, actor: actor, published: published, context: context, object: object},
263 {:ok, activity} <- insert(listen_data, local),
264 :ok <- maybe_federate(activity) do
272 def accept(params) do
273 accept_or_reject("Accept", params)
276 def reject(params) do
277 accept_or_reject("Reject", params)
280 def accept_or_reject(type, %{to: to, actor: actor, object: object} = params) do
281 local = Map.get(params, :local, true)
282 activity_id = Map.get(params, :activity_id, nil)
285 %{"to" => to, "type" => type, "actor" => actor.ap_id, "object" => object}
286 |> Utils.maybe_put("id", activity_id),
287 {:ok, activity} <- insert(data, local),
288 :ok <- maybe_federate(activity) do
293 def update(%{to: to, cc: cc, actor: actor, object: object} = params) do
294 local = !(params[:local] == false)
295 activity_id = params[:activity_id]
304 data <- Utils.maybe_put(data, "id", activity_id),
305 {:ok, activity} <- insert(data, local),
306 :ok <- maybe_federate(activity) do
311 # TODO: This is weird, maybe we shouldn't check here if we can make the activity.
313 %User{ap_id: ap_id} = user,
314 %Object{data: %{"id" => _}} = object,
318 with nil <- get_existing_like(ap_id, object),
319 like_data <- make_like_data(user, object, activity_id),
320 {:ok, activity} <- insert(like_data, local),
321 {:ok, object} <- add_like_to_object(activity, object),
322 :ok <- maybe_federate(activity) do
323 {:ok, activity, object}
325 %Activity{} = activity -> {:ok, activity, object}
326 error -> {:error, error}
330 def unlike(%User{} = actor, %Object{} = object, activity_id \\ nil, local \\ true) do
331 with %Activity{} = like_activity <- get_existing_like(actor.ap_id, object),
332 unlike_data <- make_unlike_data(actor, like_activity, activity_id),
333 {:ok, unlike_activity} <- insert(unlike_data, local),
334 {:ok, _activity} <- Repo.delete(like_activity),
335 {:ok, object} <- remove_like_from_object(like_activity, object),
336 :ok <- maybe_federate(unlike_activity) do
337 {:ok, unlike_activity, like_activity, object}
344 %User{ap_id: _} = user,
345 %Object{data: %{"id" => _}} = object,
350 with true <- is_announceable?(object, user, public),
351 announce_data <- make_announce_data(user, object, activity_id, public),
352 {:ok, activity} <- insert(announce_data, local),
353 {:ok, object} <- add_announce_to_object(activity, object),
354 :ok <- maybe_federate(activity) do
355 {:ok, activity, object}
357 error -> {:error, error}
367 with %Activity{} = announce_activity <- get_existing_announce(actor.ap_id, object),
368 unannounce_data <- make_unannounce_data(actor, announce_activity, activity_id),
369 {:ok, unannounce_activity} <- insert(unannounce_data, local),
370 :ok <- maybe_federate(unannounce_activity),
371 {:ok, _activity} <- Repo.delete(announce_activity),
372 {:ok, object} <- remove_announce_from_object(announce_activity, object) do
373 {:ok, unannounce_activity, object}
379 def follow(follower, followed, activity_id \\ nil, local \\ true) do
380 with data <- make_follow_data(follower, followed, activity_id),
381 {:ok, activity} <- insert(data, local),
382 :ok <- maybe_federate(activity),
383 _ <- User.set_follow_state_cache(follower.ap_id, followed.ap_id, activity.data["state"]) do
388 def unfollow(follower, followed, activity_id \\ nil, local \\ true) do
389 with %Activity{} = follow_activity <- fetch_latest_follow(follower, followed),
390 {:ok, follow_activity} <- update_follow_state(follow_activity, "cancelled"),
391 unfollow_data <- make_unfollow_data(follower, followed, follow_activity, activity_id),
392 {:ok, activity} <- insert(unfollow_data, local),
393 :ok <- maybe_federate(activity) do
398 def delete(%User{ap_id: ap_id, follower_address: follower_address} = user) do
400 "to" => [follower_address],
403 "object" => %{"type" => "Person", "id" => ap_id}
405 {:ok, activity} <- insert(data, true, true, true),
406 :ok <- maybe_federate(activity) do
411 def delete(%Object{data: %{"id" => id, "actor" => actor}} = object, options \\ []) do
412 local = Keyword.get(options, :local, true)
413 activity_id = Keyword.get(options, :activity_id, nil)
414 actor = Keyword.get(options, :actor, actor)
416 user = User.get_cached_by_ap_id(actor)
417 to = (object.data["to"] || []) ++ (object.data["cc"] || [])
419 with {:ok, object, activity} <- Object.delete(object),
426 "deleted_activity_id" => activity && activity.id
428 |> maybe_put("id", activity_id),
429 {:ok, activity} <- insert(data, local, false),
430 stream_out_participations(object, user),
431 _ <- decrease_replies_count_if_reply(object),
432 # Changing note count prior to enqueuing federation task in order to avoid
433 # race conditions on updating user.info
434 {:ok, _actor} <- decrease_note_count_if_public(user, object),
435 :ok <- maybe_federate(activity) do
440 @spec block(User.t(), User.t(), String.t() | nil, boolean) :: {:ok, Activity.t() | nil}
441 def block(blocker, blocked, activity_id \\ nil, local \\ true) do
442 outgoing_blocks = Config.get([:activitypub, :outgoing_blocks])
443 unfollow_blocked = Config.get([:activitypub, :unfollow_blocked])
445 if unfollow_blocked do
446 follow_activity = fetch_latest_follow(blocker, blocked)
447 if follow_activity, do: unfollow(blocker, blocked, nil, local)
450 with true <- outgoing_blocks,
451 block_data <- make_block_data(blocker, blocked, activity_id),
452 {:ok, activity} <- insert(block_data, local),
453 :ok <- maybe_federate(activity) do
460 def unblock(blocker, blocked, activity_id \\ nil, local \\ true) do
461 with %Activity{} = block_activity <- fetch_latest_block(blocker, blocked),
462 unblock_data <- make_unblock_data(blocker, blocked, block_activity, activity_id),
463 {:ok, activity} <- insert(unblock_data, local),
464 :ok <- maybe_federate(activity) do
469 @spec flag(map()) :: {:ok, Activity.t()} | any
479 # only accept false as false value
480 local = !(params[:local] == false)
481 forward = !(params[:forward] == false)
483 additional = params[:additional] || %{}
487 Map.merge(additional, %{"to" => [], "cc" => [account.ap_id]})
489 Map.merge(additional, %{"to" => [], "cc" => []})
492 with flag_data <- make_flag_data(params, additional),
493 {:ok, activity} <- insert(flag_data, local),
494 :ok <- maybe_federate(activity) do
495 Enum.each(User.all_superusers(), fn superuser ->
497 |> Pleroma.Emails.AdminEmail.report(actor, account, statuses, content)
498 |> Pleroma.Emails.Mailer.deliver_async()
505 defp fetch_activities_for_context_query(context, opts) do
506 public = [Pleroma.Constants.as_public()]
509 if opts["user"], do: [opts["user"].ap_id | opts["user"].following] ++ public, else: public
511 from(activity in Activity)
512 |> maybe_preload_objects(opts)
513 |> maybe_preload_bookmarks(opts)
514 |> maybe_set_thread_muted_field(opts)
515 |> restrict_blocked(opts)
516 |> restrict_recipients(recipients, opts["user"])
520 "?->>'type' = ? and ?->>'context' = ?",
527 |> exclude_poll_votes(opts)
529 |> order_by([activity], desc: activity.id)
532 @spec fetch_activities_for_context(String.t(), keyword() | map()) :: [Activity.t()]
533 def fetch_activities_for_context(context, opts \\ %{}) do
535 |> fetch_activities_for_context_query(opts)
539 @spec fetch_latest_activity_id_for_context(String.t(), keyword() | map()) ::
540 FlakeId.Ecto.CompatType.t() | nil
541 def fetch_latest_activity_id_for_context(context, opts \\ %{}) do
543 |> fetch_activities_for_context_query(Map.merge(%{"skip_preload" => true}, opts))
549 def fetch_public_activities(opts \\ %{}, pagination \\ :keyset) do
550 opts = Map.drop(opts, ["user"])
552 [Pleroma.Constants.as_public()]
553 |> fetch_activities_query(opts)
554 |> restrict_unlisted()
555 |> Pagination.fetch_paginated(opts, pagination)
559 @valid_visibilities ~w[direct unlisted public private]
561 defp restrict_visibility(query, %{visibility: visibility})
562 when is_list(visibility) do
563 if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
569 "activity_visibility(?, ?, ?) = ANY (?)",
579 Logger.error("Could not restrict visibility to #{visibility}")
583 defp restrict_visibility(query, %{visibility: visibility})
584 when visibility in @valid_visibilities do
588 fragment("activity_visibility(?, ?, ?) = ?", a.actor, a.recipients, a.data, ^visibility)
592 defp restrict_visibility(_query, %{visibility: visibility})
593 when visibility not in @valid_visibilities do
594 Logger.error("Could not restrict visibility to #{visibility}")
597 defp restrict_visibility(query, _visibility), do: query
599 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
600 when is_list(visibility) do
601 if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
606 "activity_visibility(?, ?, ?) = ANY (?)",
614 Logger.error("Could not exclude visibility to #{visibility}")
619 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
620 when visibility in @valid_visibilities do
625 "activity_visibility(?, ?, ?) = ?",
634 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
635 when visibility not in @valid_visibilities do
636 Logger.error("Could not exclude visibility to #{visibility}")
640 defp exclude_visibility(query, _visibility), do: query
642 defp restrict_thread_visibility(query, _, %{skip_thread_containment: true} = _),
645 defp restrict_thread_visibility(
647 %{"user" => %User{info: %{skip_thread_containment: true}}},
652 defp restrict_thread_visibility(query, %{"user" => %User{ap_id: ap_id}}, _) do
655 where: fragment("thread_visibility(?, (?)->>'id') = true", ^ap_id, a.data)
659 defp restrict_thread_visibility(query, _, _), do: query
661 def fetch_user_abstract_activities(user, reading_user, params \\ %{}) do
664 |> Map.put("user", reading_user)
665 |> Map.put("actor_id", user.ap_id)
666 |> Map.put("whole_db", true)
669 user_activities_recipients(%{
670 "godmode" => params["godmode"],
671 "reading_user" => reading_user
674 fetch_activities(recipients, params)
678 def fetch_user_activities(user, reading_user, params \\ %{}) do
681 |> Map.put("type", ["Create", "Announce"])
682 |> Map.put("user", reading_user)
683 |> Map.put("actor_id", user.ap_id)
684 |> Map.put("whole_db", true)
685 |> Map.put("pinned_activity_ids", user.info.pinned_activities)
688 user_activities_recipients(%{
689 "godmode" => params["godmode"],
690 "reading_user" => reading_user
693 fetch_activities(recipients, params)
697 defp user_activities_recipients(%{"godmode" => true}) do
701 defp user_activities_recipients(%{"reading_user" => reading_user}) do
703 [Pleroma.Constants.as_public()] ++ [reading_user.ap_id | reading_user.following]
705 [Pleroma.Constants.as_public()]
709 defp restrict_since(query, %{"since_id" => ""}), do: query
711 defp restrict_since(query, %{"since_id" => since_id}) do
712 from(activity in query, where: activity.id > ^since_id)
715 defp restrict_since(query, _), do: query
717 defp restrict_tag_reject(_query, %{"tag_reject" => _tag_reject, "skip_preload" => true}) do
718 raise "Can't use the child object without preloading!"
721 defp restrict_tag_reject(query, %{"tag_reject" => tag_reject})
722 when is_list(tag_reject) and tag_reject != [] do
724 [_activity, object] in query,
725 where: fragment("not (?)->'tag' \\?| (?)", object.data, ^tag_reject)
729 defp restrict_tag_reject(query, _), do: query
731 defp restrict_tag_all(_query, %{"tag_all" => _tag_all, "skip_preload" => true}) do
732 raise "Can't use the child object without preloading!"
735 defp restrict_tag_all(query, %{"tag_all" => tag_all})
736 when is_list(tag_all) and tag_all != [] do
738 [_activity, object] in query,
739 where: fragment("(?)->'tag' \\?& (?)", object.data, ^tag_all)
743 defp restrict_tag_all(query, _), do: query
745 defp restrict_tag(_query, %{"tag" => _tag, "skip_preload" => true}) do
746 raise "Can't use the child object without preloading!"
749 defp restrict_tag(query, %{"tag" => tag}) when is_list(tag) do
751 [_activity, object] in query,
752 where: fragment("(?)->'tag' \\?| (?)", object.data, ^tag)
756 defp restrict_tag(query, %{"tag" => tag}) when is_binary(tag) do
758 [_activity, object] in query,
759 where: fragment("(?)->'tag' \\? (?)", object.data, ^tag)
763 defp restrict_tag(query, _), do: query
765 defp restrict_recipients(query, [], _user), do: query
767 defp restrict_recipients(query, recipients, nil) do
768 from(activity in query, where: fragment("? && ?", ^recipients, activity.recipients))
771 defp restrict_recipients(query, recipients, user) do
774 where: fragment("? && ?", ^recipients, activity.recipients),
775 or_where: activity.actor == ^user.ap_id
779 defp restrict_local(query, %{"local_only" => true}) do
780 from(activity in query, where: activity.local == true)
783 defp restrict_local(query, _), do: query
785 defp restrict_actor(query, %{"actor_id" => actor_id}) do
786 from(activity in query, where: activity.actor == ^actor_id)
789 defp restrict_actor(query, _), do: query
791 defp restrict_type(query, %{"type" => type}) when is_binary(type) do
792 from(activity in query, where: fragment("?->>'type' = ?", activity.data, ^type))
795 defp restrict_type(query, %{"type" => type}) do
796 from(activity in query, where: fragment("?->>'type' = ANY(?)", activity.data, ^type))
799 defp restrict_type(query, _), do: query
801 defp restrict_state(query, %{"state" => state}) do
802 from(activity in query, where: fragment("?->>'state' = ?", activity.data, ^state))
805 defp restrict_state(query, _), do: query
807 defp restrict_favorited_by(query, %{"favorited_by" => ap_id}) do
809 [_activity, object] in query,
810 where: fragment("(?)->'likes' \\? (?)", object.data, ^ap_id)
814 defp restrict_favorited_by(query, _), do: query
816 defp restrict_media(_query, %{"only_media" => _val, "skip_preload" => true}) do
817 raise "Can't use the child object without preloading!"
820 defp restrict_media(query, %{"only_media" => val}) when val == "true" or val == "1" do
822 [_activity, object] in query,
823 where: fragment("not (?)->'attachment' = (?)", object.data, ^[])
827 defp restrict_media(query, _), do: query
829 defp restrict_replies(query, %{"exclude_replies" => val}) when val == "true" or val == "1" do
831 [_activity, object] in query,
832 where: fragment("?->>'inReplyTo' is null", object.data)
836 defp restrict_replies(query, _), do: query
838 defp restrict_reblogs(query, %{"exclude_reblogs" => val}) when val == "true" or val == "1" do
839 from(activity in query, where: fragment("?->>'type' != 'Announce'", activity.data))
842 defp restrict_reblogs(query, _), do: query
844 defp restrict_muted(query, %{"with_muted" => val}) when val in [true, "true", "1"], do: query
846 defp restrict_muted(query, %{"muting_user" => %User{info: info}} = opts) do
850 from([activity] in query,
851 where: fragment("not (? = ANY(?))", activity.actor, ^mutes),
852 where: fragment("not (?->'to' \\?| ?)", activity.data, ^mutes)
855 unless opts["skip_preload"] do
856 from([thread_mute: tm] in query, where: is_nil(tm.user_id))
862 defp restrict_muted(query, _), do: query
864 defp restrict_blocked(query, %{"blocking_user" => %User{info: info}}) do
865 blocks = info.blocks || []
866 domain_blocks = info.domain_blocks || []
869 if has_named_binding?(query, :object), do: query, else: Activity.with_joined_object(query)
872 [activity, object: o] in query,
873 where: fragment("not (? = ANY(?))", activity.actor, ^blocks),
874 where: fragment("not (? && ?)", activity.recipients, ^blocks),
877 "not (?->>'type' = 'Announce' and ?->'to' \\?| ?)",
882 where: fragment("not (split_part(?, '/', 3) = ANY(?))", activity.actor, ^domain_blocks),
883 where: fragment("not (split_part(?->>'actor', '/', 3) = ANY(?))", o.data, ^domain_blocks)
887 defp restrict_blocked(query, _), do: query
889 defp restrict_unlisted(query) do
894 "not (coalesce(?->'cc', '{}'::jsonb) \\?| ?)",
896 ^[Pleroma.Constants.as_public()]
901 defp restrict_pinned(query, %{"pinned" => "true", "pinned_activity_ids" => ids}) do
902 from(activity in query, where: activity.id in ^ids)
905 defp restrict_pinned(query, _), do: query
907 defp restrict_muted_reblogs(query, %{"muting_user" => %User{info: info}}) do
908 muted_reblogs = info.muted_reblogs || []
914 "not ( ?->>'type' = 'Announce' and ? = ANY(?))",
922 defp restrict_muted_reblogs(query, _), do: query
924 defp exclude_poll_votes(query, %{"include_poll_votes" => true}), do: query
926 defp exclude_poll_votes(query, _) do
927 if has_named_binding?(query, :object) do
928 from([activity, object: o] in query,
929 where: fragment("not(?->>'type' = ?)", o.data, "Answer")
936 defp exclude_id(query, %{"exclude_id" => id}) when is_binary(id) do
937 from(activity in query, where: activity.id != ^id)
940 defp exclude_id(query, _), do: query
942 defp maybe_preload_objects(query, %{"skip_preload" => true}), do: query
944 defp maybe_preload_objects(query, _) do
946 |> Activity.with_preloaded_object()
949 defp maybe_preload_bookmarks(query, %{"skip_preload" => true}), do: query
951 defp maybe_preload_bookmarks(query, opts) do
953 |> Activity.with_preloaded_bookmark(opts["user"])
956 defp maybe_set_thread_muted_field(query, %{"skip_preload" => true}), do: query
958 defp maybe_set_thread_muted_field(query, opts) do
960 |> Activity.with_set_thread_muted_field(opts["muting_user"] || opts["user"])
963 defp maybe_order(query, %{order: :desc}) do
965 |> order_by(desc: :id)
968 defp maybe_order(query, %{order: :asc}) do
970 |> order_by(asc: :id)
973 defp maybe_order(query, _), do: query
975 def fetch_activities_query(recipients, opts \\ %{}) do
977 skip_thread_containment: Config.get([:instance, :skip_thread_containment])
981 |> maybe_preload_objects(opts)
982 |> maybe_preload_bookmarks(opts)
983 |> maybe_set_thread_muted_field(opts)
985 |> restrict_recipients(recipients, opts["user"])
986 |> restrict_tag(opts)
987 |> restrict_tag_reject(opts)
988 |> restrict_tag_all(opts)
989 |> restrict_since(opts)
990 |> restrict_local(opts)
991 |> restrict_actor(opts)
992 |> restrict_type(opts)
993 |> restrict_state(opts)
994 |> restrict_favorited_by(opts)
995 |> restrict_blocked(opts)
996 |> restrict_muted(opts)
997 |> restrict_media(opts)
998 |> restrict_visibility(opts)
999 |> restrict_thread_visibility(opts, config)
1000 |> restrict_replies(opts)
1001 |> restrict_reblogs(opts)
1002 |> restrict_pinned(opts)
1003 |> restrict_muted_reblogs(opts)
1004 |> Activity.restrict_deactivated_users()
1005 |> exclude_poll_votes(opts)
1006 |> exclude_visibility(opts)
1009 def fetch_activities(recipients, opts \\ %{}, pagination \\ :keyset) do
1010 list_memberships = Pleroma.List.memberships(opts["user"])
1012 fetch_activities_query(recipients ++ list_memberships, opts)
1013 |> Pagination.fetch_paginated(opts, pagination)
1015 |> maybe_update_cc(list_memberships, opts["user"])
1018 defp maybe_update_cc(activities, list_memberships, %User{ap_id: user_ap_id})
1019 when is_list(list_memberships) and length(list_memberships) > 0 do
1020 Enum.map(activities, fn
1021 %{data: %{"bcc" => bcc}} = activity when is_list(bcc) and length(bcc) > 0 ->
1022 if Enum.any?(bcc, &(&1 in list_memberships)) do
1023 update_in(activity.data["cc"], &[user_ap_id | &1])
1033 defp maybe_update_cc(activities, _, _), do: activities
1035 def fetch_activities_bounded_query(query, recipients, recipients_with_public) do
1036 from(activity in query,
1038 fragment("? && ?", activity.recipients, ^recipients) or
1039 (fragment("? && ?", activity.recipients, ^recipients_with_public) and
1040 ^Pleroma.Constants.as_public() in activity.recipients)
1044 def fetch_activities_bounded(
1046 recipients_with_public,
1048 pagination \\ :keyset
1050 fetch_activities_query([], opts)
1051 |> fetch_activities_bounded_query(recipients, recipients_with_public)
1052 |> Pagination.fetch_paginated(opts, pagination)
1056 def upload(file, opts \\ []) do
1057 with {:ok, data} <- Upload.store(file, opts) do
1060 Map.put(data, "actor", opts[:actor])
1065 Repo.insert(%Object{data: obj_data})
1069 defp object_to_user_data(data) do
1071 data["icon"]["url"] &&
1074 "url" => [%{"href" => data["icon"]["url"]}]
1078 data["image"]["url"] &&
1081 "url" => [%{"href" => data["image"]["url"]}]
1086 |> Map.get("attachment", [])
1087 |> Enum.filter(fn %{"type" => t} -> t == "PropertyValue" end)
1088 |> Enum.map(fn fields -> Map.take(fields, ["name", "value"]) end)
1090 locked = data["manuallyApprovesFollowers"] || false
1091 data = Transmogrifier.maybe_fix_user_object(data)
1092 discoverable = data["discoverable"] || false
1102 discoverable: discoverable
1106 follower_address: data["followers"],
1107 following_address: data["following"],
1108 bio: data["summary"]
1111 # nickname can be nil because of virtual actors
1113 if data["preferredUsername"] do
1117 "#{data["preferredUsername"]}@#{URI.parse(data["id"]).host}"
1120 Map.put(user_data, :nickname, nil)
1126 def fetch_follow_information_for_user(user) do
1127 with {:ok, following_data} <-
1128 Fetcher.fetch_and_contain_remote_object_from_id(user.following_address),
1129 following_count when is_integer(following_count) <- following_data["totalItems"],
1130 {:ok, hide_follows} <- collection_private(following_data),
1131 {:ok, followers_data} <-
1132 Fetcher.fetch_and_contain_remote_object_from_id(user.follower_address),
1133 followers_count when is_integer(followers_count) <- followers_data["totalItems"],
1134 {:ok, hide_followers} <- collection_private(followers_data) do
1137 hide_follows: hide_follows,
1138 follower_count: followers_count,
1139 following_count: following_count,
1140 hide_followers: hide_followers
1151 defp maybe_update_follow_information(data) do
1152 with {:enabled, true} <-
1153 {:enabled, Pleroma.Config.get([:instance, :external_user_synchronization])},
1154 {:ok, info} <- fetch_follow_information_for_user(data) do
1155 info = Map.merge(data.info, info)
1156 Map.put(data, :info, info)
1158 {:enabled, false} ->
1163 "Follower/Following counter update for #{data.ap_id} failed.\n" <> inspect(e)
1170 defp collection_private(data) do
1171 if is_map(data["first"]) and
1172 data["first"]["type"] in ["CollectionPage", "OrderedCollectionPage"] do
1175 with {:ok, %{"type" => type}} when type in ["CollectionPage", "OrderedCollectionPage"] <-
1176 Fetcher.fetch_and_contain_remote_object_from_id(data["first"]) do
1179 {:error, {:ok, %{status: code}}} when code in [401, 403] ->
1191 def user_data_from_user_object(data) do
1192 with {:ok, data} <- MRF.filter(data),
1193 {:ok, data} <- object_to_user_data(data) do
1200 def fetch_and_prepare_user_from_ap_id(ap_id) do
1201 with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id),
1202 {:ok, data} <- user_data_from_user_object(data),
1203 data <- maybe_update_follow_information(data) do
1206 e -> Logger.error("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
1210 def make_user_from_ap_id(ap_id) do
1211 if _user = User.get_cached_by_ap_id(ap_id) do
1212 Transmogrifier.upgrade_user_from_ap_id(ap_id)
1214 with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id) do
1215 User.insert_or_update_user(data)
1222 def make_user_from_nickname(nickname) do
1223 with {:ok, %{"ap_id" => ap_id}} when not is_nil(ap_id) <- WebFinger.finger(nickname) do
1224 make_user_from_ap_id(ap_id)
1226 _e -> {:error, "No AP id in WebFinger"}
1230 # filter out broken threads
1231 def contain_broken_threads(%Activity{} = activity, %User{} = user) do
1232 entire_thread_visible_for_user?(activity, user)
1235 # do post-processing on a specific activity
1236 def contain_activity(%Activity{} = activity, %User{} = user) do
1237 contain_broken_threads(activity, user)
1240 def fetch_direct_messages_query do
1242 |> restrict_type(%{"type" => "Create"})
1243 |> restrict_visibility(%{visibility: "direct"})
1244 |> order_by([activity], asc: activity.id)