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(%{to: to, actor: actor, object: object} = params) do
273 # only accept false as false value
274 local = !(params[:local] == false)
276 with data <- %{"to" => to, "type" => "Accept", "actor" => actor.ap_id, "object" => object},
277 {:ok, activity} <- insert(data, local),
278 :ok <- maybe_federate(activity) do
283 def reject(%{to: to, actor: actor, object: object} = params) do
284 # only accept false as false value
285 local = !(params[:local] == false)
287 with data <- %{"to" => to, "type" => "Reject", "actor" => actor.ap_id, "object" => object},
288 {:ok, activity} <- insert(data, local),
289 :ok <- maybe_federate(activity) do
294 def update(%{to: to, cc: cc, actor: actor, object: object} = params) do
295 local = !(params[:local] == false)
296 activity_id = params[:activity_id]
305 data <- Utils.maybe_put(data, "id", activity_id),
306 {:ok, activity} <- insert(data, local),
307 :ok <- maybe_federate(activity) do
312 # TODO: This is weird, maybe we shouldn't check here if we can make the activity.
314 %User{ap_id: ap_id} = user,
315 %Object{data: %{"id" => _}} = object,
319 with nil <- get_existing_like(ap_id, object),
320 like_data <- make_like_data(user, object, activity_id),
321 {:ok, activity} <- insert(like_data, local),
322 {:ok, object} <- add_like_to_object(activity, object),
323 :ok <- maybe_federate(activity) do
324 {:ok, activity, object}
326 %Activity{} = activity -> {:ok, activity, object}
327 error -> {:error, error}
331 def unlike(%User{} = actor, %Object{} = object, activity_id \\ nil, local \\ true) do
332 with %Activity{} = like_activity <- get_existing_like(actor.ap_id, object),
333 unlike_data <- make_unlike_data(actor, like_activity, activity_id),
334 {:ok, unlike_activity} <- insert(unlike_data, local),
335 {:ok, _activity} <- Repo.delete(like_activity),
336 {:ok, object} <- remove_like_from_object(like_activity, object),
337 :ok <- maybe_federate(unlike_activity) do
338 {:ok, unlike_activity, like_activity, object}
345 %User{ap_id: _} = user,
346 %Object{data: %{"id" => _}} = object,
351 with true <- is_announceable?(object, user, public),
352 announce_data <- make_announce_data(user, object, activity_id, public),
353 {:ok, activity} <- insert(announce_data, local),
354 {:ok, object} <- add_announce_to_object(activity, object),
355 :ok <- maybe_federate(activity) do
356 {:ok, activity, object}
358 error -> {:error, error}
368 with %Activity{} = announce_activity <- get_existing_announce(actor.ap_id, object),
369 unannounce_data <- make_unannounce_data(actor, announce_activity, activity_id),
370 {:ok, unannounce_activity} <- insert(unannounce_data, local),
371 :ok <- maybe_federate(unannounce_activity),
372 {:ok, _activity} <- Repo.delete(announce_activity),
373 {:ok, object} <- remove_announce_from_object(announce_activity, object) do
374 {:ok, unannounce_activity, object}
380 def follow(follower, followed, activity_id \\ nil, local \\ true) do
381 with data <- make_follow_data(follower, followed, activity_id),
382 {:ok, activity} <- insert(data, local),
383 :ok <- maybe_federate(activity),
384 _ <- User.set_follow_state_cache(follower.ap_id, followed.ap_id, activity.data["state"]) do
389 def unfollow(follower, followed, activity_id \\ nil, local \\ true) do
390 with %Activity{} = follow_activity <- fetch_latest_follow(follower, followed),
391 {:ok, follow_activity} <- update_follow_state(follow_activity, "cancelled"),
392 unfollow_data <- make_unfollow_data(follower, followed, follow_activity, activity_id),
393 {:ok, activity} <- insert(unfollow_data, local),
394 :ok <- maybe_federate(activity) do
399 def delete(%User{ap_id: ap_id, follower_address: follower_address} = user) do
401 "to" => [follower_address],
404 "object" => %{"type" => "Person", "id" => ap_id}
406 {:ok, activity} <- insert(data, true, true, true),
407 :ok <- maybe_federate(activity) do
412 def delete(%Object{data: %{"id" => id, "actor" => actor}} = object, options \\ []) do
413 local = Keyword.get(options, :local, true)
414 activity_id = Keyword.get(options, :activity_id, nil)
415 actor = Keyword.get(options, :actor, actor)
417 user = User.get_cached_by_ap_id(actor)
418 to = (object.data["to"] || []) ++ (object.data["cc"] || [])
420 with {:ok, object, activity} <- Object.delete(object),
427 "deleted_activity_id" => activity && activity.id
429 |> maybe_put("id", activity_id),
430 {:ok, activity} <- insert(data, local, false),
431 stream_out_participations(object, user),
432 _ <- decrease_replies_count_if_reply(object),
433 # Changing note count prior to enqueuing federation task in order to avoid
434 # race conditions on updating user.info
435 {:ok, _actor} <- decrease_note_count_if_public(user, object),
436 :ok <- maybe_federate(activity) do
441 @spec block(User.t(), User.t(), String.t() | nil, boolean) :: {:ok, Activity.t() | nil}
442 def block(blocker, blocked, activity_id \\ nil, local \\ true) do
443 outgoing_blocks = Config.get([:activitypub, :outgoing_blocks])
444 unfollow_blocked = Config.get([:activitypub, :unfollow_blocked])
446 if unfollow_blocked do
447 follow_activity = fetch_latest_follow(blocker, blocked)
448 if follow_activity, do: unfollow(blocker, blocked, nil, local)
451 with true <- outgoing_blocks,
452 block_data <- make_block_data(blocker, blocked, activity_id),
453 {:ok, activity} <- insert(block_data, local),
454 :ok <- maybe_federate(activity) do
461 def unblock(blocker, blocked, activity_id \\ nil, local \\ true) do
462 with %Activity{} = block_activity <- fetch_latest_block(blocker, blocked),
463 unblock_data <- make_unblock_data(blocker, blocked, block_activity, activity_id),
464 {:ok, activity} <- insert(unblock_data, local),
465 :ok <- maybe_federate(activity) do
470 @spec flag(map()) :: {:ok, Activity.t()} | any
480 # only accept false as false value
481 local = !(params[:local] == false)
482 forward = !(params[:forward] == false)
484 additional = params[:additional] || %{}
488 Map.merge(additional, %{"to" => [], "cc" => [account.ap_id]})
490 Map.merge(additional, %{"to" => [], "cc" => []})
493 with flag_data <- make_flag_data(params, additional),
494 {:ok, activity} <- insert(flag_data, local),
495 :ok <- maybe_federate(activity) do
496 Enum.each(User.all_superusers(), fn superuser ->
498 |> Pleroma.Emails.AdminEmail.report(actor, account, statuses, content)
499 |> Pleroma.Emails.Mailer.deliver_async()
506 defp fetch_activities_for_context_query(context, opts) do
507 public = [Pleroma.Constants.as_public()]
510 if opts["user"], do: [opts["user"].ap_id | opts["user"].following] ++ public, else: public
512 from(activity in Activity)
513 |> maybe_preload_objects(opts)
514 |> maybe_preload_bookmarks(opts)
515 |> maybe_set_thread_muted_field(opts)
516 |> restrict_blocked(opts)
517 |> restrict_recipients(recipients, opts["user"])
521 "?->>'type' = ? and ?->>'context' = ?",
528 |> exclude_poll_votes(opts)
530 |> order_by([activity], desc: activity.id)
533 @spec fetch_activities_for_context(String.t(), keyword() | map()) :: [Activity.t()]
534 def fetch_activities_for_context(context, opts \\ %{}) do
536 |> fetch_activities_for_context_query(opts)
540 @spec fetch_latest_activity_id_for_context(String.t(), keyword() | map()) ::
541 FlakeId.Ecto.CompatType.t() | nil
542 def fetch_latest_activity_id_for_context(context, opts \\ %{}) do
544 |> fetch_activities_for_context_query(Map.merge(%{"skip_preload" => true}, opts))
550 def fetch_public_activities(opts \\ %{}, pagination \\ :keyset) do
551 opts = Map.drop(opts, ["user"])
553 [Pleroma.Constants.as_public()]
554 |> fetch_activities_query(opts)
555 |> restrict_unlisted()
556 |> Pagination.fetch_paginated(opts, pagination)
560 @valid_visibilities ~w[direct unlisted public private]
562 defp restrict_visibility(query, %{visibility: visibility})
563 when is_list(visibility) do
564 if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
570 "activity_visibility(?, ?, ?) = ANY (?)",
580 Logger.error("Could not restrict visibility to #{visibility}")
584 defp restrict_visibility(query, %{visibility: visibility})
585 when visibility in @valid_visibilities do
589 fragment("activity_visibility(?, ?, ?) = ?", a.actor, a.recipients, a.data, ^visibility)
593 defp restrict_visibility(_query, %{visibility: visibility})
594 when visibility not in @valid_visibilities do
595 Logger.error("Could not restrict visibility to #{visibility}")
598 defp restrict_visibility(query, _visibility), do: query
600 defp restrict_thread_visibility(query, _, %{skip_thread_containment: true} = _),
603 defp restrict_thread_visibility(
605 %{"user" => %User{info: %{skip_thread_containment: true}}},
610 defp restrict_thread_visibility(query, %{"user" => %User{ap_id: ap_id}}, _) do
613 where: fragment("thread_visibility(?, (?)->>'id') = true", ^ap_id, a.data)
617 defp restrict_thread_visibility(query, _, _), do: query
619 def fetch_user_abstract_activities(user, reading_user, params \\ %{}) do
622 |> Map.put("user", reading_user)
623 |> Map.put("actor_id", user.ap_id)
624 |> Map.put("whole_db", true)
627 user_activities_recipients(%{
628 "godmode" => params["godmode"],
629 "reading_user" => reading_user
632 fetch_activities(recipients, params)
636 def fetch_user_activities(user, reading_user, params \\ %{}) do
639 |> Map.put("type", ["Create", "Announce"])
640 |> Map.put("user", reading_user)
641 |> Map.put("actor_id", user.ap_id)
642 |> Map.put("whole_db", true)
643 |> Map.put("pinned_activity_ids", user.info.pinned_activities)
646 user_activities_recipients(%{
647 "godmode" => params["godmode"],
648 "reading_user" => reading_user
651 fetch_activities(recipients, params)
655 defp user_activities_recipients(%{"godmode" => true}) do
659 defp user_activities_recipients(%{"reading_user" => reading_user}) do
661 [Pleroma.Constants.as_public()] ++ [reading_user.ap_id | reading_user.following]
663 [Pleroma.Constants.as_public()]
667 defp restrict_since(query, %{"since_id" => ""}), do: query
669 defp restrict_since(query, %{"since_id" => since_id}) do
670 from(activity in query, where: activity.id > ^since_id)
673 defp restrict_since(query, _), do: query
675 defp restrict_tag_reject(_query, %{"tag_reject" => _tag_reject, "skip_preload" => true}) do
676 raise "Can't use the child object without preloading!"
679 defp restrict_tag_reject(query, %{"tag_reject" => tag_reject})
680 when is_list(tag_reject) and tag_reject != [] do
682 [_activity, object] in query,
683 where: fragment("not (?)->'tag' \\?| (?)", object.data, ^tag_reject)
687 defp restrict_tag_reject(query, _), do: query
689 defp restrict_tag_all(_query, %{"tag_all" => _tag_all, "skip_preload" => true}) do
690 raise "Can't use the child object without preloading!"
693 defp restrict_tag_all(query, %{"tag_all" => tag_all})
694 when is_list(tag_all) and tag_all != [] do
696 [_activity, object] in query,
697 where: fragment("(?)->'tag' \\?& (?)", object.data, ^tag_all)
701 defp restrict_tag_all(query, _), do: query
703 defp restrict_tag(_query, %{"tag" => _tag, "skip_preload" => true}) do
704 raise "Can't use the child object without preloading!"
707 defp restrict_tag(query, %{"tag" => tag}) when is_list(tag) do
709 [_activity, object] in query,
710 where: fragment("(?)->'tag' \\?| (?)", object.data, ^tag)
714 defp restrict_tag(query, %{"tag" => tag}) when is_binary(tag) do
716 [_activity, object] in query,
717 where: fragment("(?)->'tag' \\? (?)", object.data, ^tag)
721 defp restrict_tag(query, _), do: query
723 defp restrict_recipients(query, [], _user), do: query
725 defp restrict_recipients(query, recipients, nil) do
726 from(activity in query, where: fragment("? && ?", ^recipients, activity.recipients))
729 defp restrict_recipients(query, recipients, user) do
732 where: fragment("? && ?", ^recipients, activity.recipients),
733 or_where: activity.actor == ^user.ap_id
737 defp restrict_local(query, %{"local_only" => true}) do
738 from(activity in query, where: activity.local == true)
741 defp restrict_local(query, _), do: query
743 defp restrict_actor(query, %{"actor_id" => actor_id}) do
744 from(activity in query, where: activity.actor == ^actor_id)
747 defp restrict_actor(query, _), do: query
749 defp restrict_type(query, %{"type" => type}) when is_binary(type) do
750 from(activity in query, where: fragment("?->>'type' = ?", activity.data, ^type))
753 defp restrict_type(query, %{"type" => type}) do
754 from(activity in query, where: fragment("?->>'type' = ANY(?)", activity.data, ^type))
757 defp restrict_type(query, _), do: query
759 defp restrict_state(query, %{"state" => state}) do
760 from(activity in query, where: fragment("?->>'state' = ?", activity.data, ^state))
763 defp restrict_state(query, _), do: query
765 defp restrict_favorited_by(query, %{"favorited_by" => ap_id}) do
767 [_activity, object] in query,
768 where: fragment("(?)->'likes' \\? (?)", object.data, ^ap_id)
772 defp restrict_favorited_by(query, _), do: query
774 defp restrict_media(_query, %{"only_media" => _val, "skip_preload" => true}) do
775 raise "Can't use the child object without preloading!"
778 defp restrict_media(query, %{"only_media" => val}) when val == "true" or val == "1" do
780 [_activity, object] in query,
781 where: fragment("not (?)->'attachment' = (?)", object.data, ^[])
785 defp restrict_media(query, _), do: query
787 defp restrict_replies(query, %{"exclude_replies" => val}) when val == "true" or val == "1" do
789 [_activity, object] in query,
790 where: fragment("?->>'inReplyTo' is null", object.data)
794 defp restrict_replies(query, _), do: query
796 defp restrict_reblogs(query, %{"exclude_reblogs" => val}) when val == "true" or val == "1" do
797 from(activity in query, where: fragment("?->>'type' != 'Announce'", activity.data))
800 defp restrict_reblogs(query, _), do: query
802 defp restrict_muted(query, %{"with_muted" => val}) when val in [true, "true", "1"], do: query
804 defp restrict_muted(query, %{"muting_user" => %User{info: info}} = opts) do
808 from([activity] in query,
809 where: fragment("not (? = ANY(?))", activity.actor, ^mutes),
810 where: fragment("not (?->'to' \\?| ?)", activity.data, ^mutes)
813 unless opts["skip_preload"] do
814 from([thread_mute: tm] in query, where: is_nil(tm.user_id))
820 defp restrict_muted(query, _), do: query
822 defp restrict_blocked(query, %{"blocking_user" => %User{info: info}}) do
823 blocks = info.blocks || []
824 domain_blocks = info.domain_blocks || []
827 if has_named_binding?(query, :object), do: query, else: Activity.with_joined_object(query)
830 [activity, object: o] in query,
831 where: fragment("not (? = ANY(?))", activity.actor, ^blocks),
832 where: fragment("not (? && ?)", activity.recipients, ^blocks),
835 "not (?->>'type' = 'Announce' and ?->'to' \\?| ?)",
840 where: fragment("not (split_part(?, '/', 3) = ANY(?))", activity.actor, ^domain_blocks),
841 where: fragment("not (split_part(?->>'actor', '/', 3) = ANY(?))", o.data, ^domain_blocks)
845 defp restrict_blocked(query, _), do: query
847 defp restrict_unlisted(query) do
852 "not (coalesce(?->'cc', '{}'::jsonb) \\?| ?)",
854 ^[Pleroma.Constants.as_public()]
859 defp restrict_pinned(query, %{"pinned" => "true", "pinned_activity_ids" => ids}) do
860 from(activity in query, where: activity.id in ^ids)
863 defp restrict_pinned(query, _), do: query
865 defp restrict_muted_reblogs(query, %{"muting_user" => %User{info: info}}) do
866 muted_reblogs = info.muted_reblogs || []
872 "not ( ?->>'type' = 'Announce' and ? = ANY(?))",
880 defp restrict_muted_reblogs(query, _), do: query
882 defp exclude_poll_votes(query, %{"include_poll_votes" => true}), do: query
884 defp exclude_poll_votes(query, _) do
885 if has_named_binding?(query, :object) do
886 from([activity, object: o] in query,
887 where: fragment("not(?->>'type' = ?)", o.data, "Answer")
894 defp exclude_id(query, %{"exclude_id" => id}) when is_binary(id) do
895 from(activity in query, where: activity.id != ^id)
898 defp exclude_id(query, _), do: query
900 defp maybe_preload_objects(query, %{"skip_preload" => true}), do: query
902 defp maybe_preload_objects(query, _) do
904 |> Activity.with_preloaded_object()
907 defp maybe_preload_bookmarks(query, %{"skip_preload" => true}), do: query
909 defp maybe_preload_bookmarks(query, opts) do
911 |> Activity.with_preloaded_bookmark(opts["user"])
914 defp maybe_set_thread_muted_field(query, %{"skip_preload" => true}), do: query
916 defp maybe_set_thread_muted_field(query, opts) do
918 |> Activity.with_set_thread_muted_field(opts["muting_user"] || opts["user"])
921 defp maybe_order(query, %{order: :desc}) do
923 |> order_by(desc: :id)
926 defp maybe_order(query, %{order: :asc}) do
928 |> order_by(asc: :id)
931 defp maybe_order(query, _), do: query
933 def fetch_activities_query(recipients, opts \\ %{}) do
935 skip_thread_containment: Config.get([:instance, :skip_thread_containment])
939 |> maybe_preload_objects(opts)
940 |> maybe_preload_bookmarks(opts)
941 |> maybe_set_thread_muted_field(opts)
943 |> restrict_recipients(recipients, opts["user"])
944 |> restrict_tag(opts)
945 |> restrict_tag_reject(opts)
946 |> restrict_tag_all(opts)
947 |> restrict_since(opts)
948 |> restrict_local(opts)
949 |> restrict_actor(opts)
950 |> restrict_type(opts)
951 |> restrict_state(opts)
952 |> restrict_favorited_by(opts)
953 |> restrict_blocked(opts)
954 |> restrict_muted(opts)
955 |> restrict_media(opts)
956 |> restrict_visibility(opts)
957 |> restrict_thread_visibility(opts, config)
958 |> restrict_replies(opts)
959 |> restrict_reblogs(opts)
960 |> restrict_pinned(opts)
961 |> restrict_muted_reblogs(opts)
962 |> Activity.restrict_deactivated_users()
963 |> exclude_poll_votes(opts)
966 def fetch_activities(recipients, opts \\ %{}, pagination \\ :keyset) do
967 list_memberships = Pleroma.List.memberships(opts["user"])
969 fetch_activities_query(recipients ++ list_memberships, opts)
970 |> Pagination.fetch_paginated(opts, pagination)
972 |> maybe_update_cc(list_memberships, opts["user"])
975 defp maybe_update_cc(activities, list_memberships, %User{ap_id: user_ap_id})
976 when is_list(list_memberships) and length(list_memberships) > 0 do
977 Enum.map(activities, fn
978 %{data: %{"bcc" => bcc}} = activity when is_list(bcc) and length(bcc) > 0 ->
979 if Enum.any?(bcc, &(&1 in list_memberships)) do
980 update_in(activity.data["cc"], &[user_ap_id | &1])
990 defp maybe_update_cc(activities, _, _), do: activities
992 def fetch_activities_bounded_query(query, recipients, recipients_with_public) do
993 from(activity in query,
995 fragment("? && ?", activity.recipients, ^recipients) or
996 (fragment("? && ?", activity.recipients, ^recipients_with_public) and
997 ^Pleroma.Constants.as_public() in activity.recipients)
1001 def fetch_activities_bounded(
1003 recipients_with_public,
1005 pagination \\ :keyset
1007 fetch_activities_query([], opts)
1008 |> fetch_activities_bounded_query(recipients, recipients_with_public)
1009 |> Pagination.fetch_paginated(opts, pagination)
1013 def upload(file, opts \\ []) do
1014 with {:ok, data} <- Upload.store(file, opts) do
1017 Map.put(data, "actor", opts[:actor])
1022 Repo.insert(%Object{data: obj_data})
1026 defp object_to_user_data(data) do
1028 data["icon"]["url"] &&
1031 "url" => [%{"href" => data["icon"]["url"]}]
1035 data["image"]["url"] &&
1038 "url" => [%{"href" => data["image"]["url"]}]
1043 |> Map.get("attachment", [])
1044 |> Enum.filter(fn %{"type" => t} -> t == "PropertyValue" end)
1045 |> Enum.map(fn fields -> Map.take(fields, ["name", "value"]) end)
1047 locked = data["manuallyApprovesFollowers"] || false
1048 data = Transmogrifier.maybe_fix_user_object(data)
1049 discoverable = data["discoverable"] || false
1059 discoverable: discoverable
1063 follower_address: data["followers"],
1064 following_address: data["following"],
1065 bio: data["summary"]
1068 # nickname can be nil because of virtual actors
1070 if data["preferredUsername"] do
1074 "#{data["preferredUsername"]}@#{URI.parse(data["id"]).host}"
1077 Map.put(user_data, :nickname, nil)
1083 def fetch_follow_information_for_user(user) do
1084 with {:ok, following_data} <-
1085 Fetcher.fetch_and_contain_remote_object_from_id(user.following_address),
1086 following_count when is_integer(following_count) <- following_data["totalItems"],
1087 {:ok, hide_follows} <- collection_private(following_data),
1088 {:ok, followers_data} <-
1089 Fetcher.fetch_and_contain_remote_object_from_id(user.follower_address),
1090 followers_count when is_integer(followers_count) <- followers_data["totalItems"],
1091 {:ok, hide_followers} <- collection_private(followers_data) do
1094 hide_follows: hide_follows,
1095 follower_count: followers_count,
1096 following_count: following_count,
1097 hide_followers: hide_followers
1108 defp maybe_update_follow_information(data) do
1109 with {:enabled, true} <-
1110 {:enabled, Pleroma.Config.get([:instance, :external_user_synchronization])},
1111 {:ok, info} <- fetch_follow_information_for_user(data) do
1112 info = Map.merge(data.info, info)
1113 Map.put(data, :info, info)
1115 {:enabled, false} ->
1120 "Follower/Following counter update for #{data.ap_id} failed.\n" <> inspect(e)
1127 defp collection_private(data) do
1128 if is_map(data["first"]) and
1129 data["first"]["type"] in ["CollectionPage", "OrderedCollectionPage"] do
1132 with {:ok, %{"type" => type}} when type in ["CollectionPage", "OrderedCollectionPage"] <-
1133 Fetcher.fetch_and_contain_remote_object_from_id(data["first"]) do
1136 {:error, {:ok, %{status: code}}} when code in [401, 403] ->
1148 def user_data_from_user_object(data) do
1149 with {:ok, data} <- MRF.filter(data),
1150 {:ok, data} <- object_to_user_data(data) do
1157 def fetch_and_prepare_user_from_ap_id(ap_id) do
1158 with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id),
1159 {:ok, data} <- user_data_from_user_object(data),
1160 data <- maybe_update_follow_information(data) do
1163 e -> Logger.error("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
1167 def make_user_from_ap_id(ap_id) do
1168 if _user = User.get_cached_by_ap_id(ap_id) do
1169 Transmogrifier.upgrade_user_from_ap_id(ap_id)
1171 with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id) do
1172 User.insert_or_update_user(data)
1179 def make_user_from_nickname(nickname) do
1180 with {:ok, %{"ap_id" => ap_id}} when not is_nil(ap_id) <- WebFinger.finger(nickname) do
1181 make_user_from_ap_id(ap_id)
1183 _e -> {:error, "No AP id in WebFinger"}
1187 # filter out broken threads
1188 def contain_broken_threads(%Activity{} = activity, %User{} = user) do
1189 entire_thread_visible_for_user?(activity, user)
1192 # do post-processing on a specific activity
1193 def contain_activity(%Activity{} = activity, %User{} = user) do
1194 contain_broken_threads(activity, user)
1197 def fetch_direct_messages_query do
1199 |> restrict_type(%{"type" => "Create"})
1200 |> restrict_visibility(%{visibility: "direct"})
1201 |> order_by([activity], asc: activity.id)