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.Streamer
21 alias Pleroma.Web.WebFinger
22 alias Pleroma.Workers.BackgroundWorker
25 import Pleroma.Web.ActivityPub.Utils
26 import Pleroma.Web.ActivityPub.Visibility
29 require Pleroma.Constants
31 # For Announce activities, we filter the recipients based on following status for any actors
32 # that match actual users. See issue #164 for more information about why this is necessary.
33 defp get_recipients(%{"type" => "Announce"} = data) do
34 to = Map.get(data, "to", [])
35 cc = Map.get(data, "cc", [])
36 bcc = Map.get(data, "bcc", [])
37 actor = User.get_cached_by_ap_id(data["actor"])
40 Enum.filter(Enum.concat([to, cc, bcc]), fn recipient ->
41 case User.get_cached_by_ap_id(recipient) do
43 user -> User.following?(user, actor)
50 defp get_recipients(%{"type" => "Create"} = data) do
51 to = Map.get(data, "to", [])
52 cc = Map.get(data, "cc", [])
53 bcc = Map.get(data, "bcc", [])
54 actor = Map.get(data, "actor", [])
55 recipients = [to, cc, bcc, [actor]] |> Enum.concat() |> Enum.uniq()
59 defp get_recipients(data) do
60 to = Map.get(data, "to", [])
61 cc = Map.get(data, "cc", [])
62 bcc = Map.get(data, "bcc", [])
63 recipients = Enum.concat([to, cc, bcc])
67 defp check_actor_is_active(actor) do
68 if not is_nil(actor) do
69 with user <- User.get_cached_by_ap_id(actor),
70 false <- user.info.deactivated do
80 defp check_remote_limit(%{"object" => %{"content" => content}}) when not is_nil(content) do
81 limit = Config.get([:instance, :remote_limit])
82 String.length(content) <= limit
85 defp check_remote_limit(_), do: true
87 def increase_note_count_if_public(actor, object) do
88 if is_public?(object), do: User.increase_note_count(actor), else: {:ok, actor}
91 def decrease_note_count_if_public(actor, object) do
92 if is_public?(object), do: User.decrease_note_count(actor), else: {:ok, actor}
95 def increase_replies_count_if_reply(%{
96 "object" => %{"inReplyTo" => reply_ap_id} = object,
99 if is_public?(object) do
100 Object.increase_replies_count(reply_ap_id)
104 def increase_replies_count_if_reply(_create_data), do: :noop
106 def decrease_replies_count_if_reply(%Object{
107 data: %{"inReplyTo" => reply_ap_id} = object
109 if is_public?(object) do
110 Object.decrease_replies_count(reply_ap_id)
114 def decrease_replies_count_if_reply(_object), do: :noop
116 def increase_poll_votes_if_vote(%{
117 "object" => %{"inReplyTo" => reply_ap_id, "name" => name},
120 Object.increase_vote_count(reply_ap_id, name)
123 def increase_poll_votes_if_vote(_create_data), do: :noop
125 def insert(map, local \\ true, fake \\ false, bypass_actor_check \\ false) when is_map(map) do
126 with nil <- Activity.normalize(map),
127 map <- lazy_put_activity_defaults(map, fake),
128 true <- bypass_actor_check || check_actor_is_active(map["actor"]),
129 {_, true} <- {:remote_limit_error, check_remote_limit(map)},
130 {:ok, map} <- MRF.filter(map),
131 {recipients, _, _} = get_recipients(map),
132 {:fake, false, map, recipients} <- {:fake, fake, map, recipients},
133 :ok <- Containment.contain_child(map),
134 {:ok, map, object} <- insert_full_object(map) do
136 Repo.insert(%Activity{
140 recipients: recipients
143 # Splice in the child object if we have one.
145 if not is_nil(object) do
146 Map.put(activity, :object, object)
151 BackgroundWorker.enqueue("fetch_data_for_activity", %{"activity_id" => activity.id})
153 Notification.create_notifications(activity)
157 |> Conversation.create_or_bump_for()
158 |> get_participations()
161 stream_out_participations(participations)
164 %Activity{} = activity ->
167 {:fake, true, map, recipients} ->
168 activity = %Activity{
172 recipients: recipients,
176 Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
184 defp get_participations({:ok, %{participations: participations}}), do: participations
185 defp get_participations(_), do: []
187 def stream_out_participations(participations) do
190 |> Repo.preload(:user)
192 Streamer.stream("participation", participations)
195 def stream_out_participations(%Object{data: %{"context" => context}}, user) do
196 with %Conversation{} = conversation <- Conversation.get_for_ap_id(context),
197 conversation = Repo.preload(conversation, :participations),
199 fetch_latest_activity_id_for_context(conversation.ap_id, %{
201 "blocking_user" => user
203 if last_activity_id do
204 stream_out_participations(conversation.participations)
209 def stream_out_participations(_, _), do: :noop
211 def stream_out(%Activity{data: %{"type" => data_type}} = activity)
212 when data_type in ["Create", "Announce", "Delete"] do
214 |> Topics.get_activity_topics()
215 |> Streamer.stream(activity)
218 def stream_out(_activity) do
222 def create(%{to: to, actor: actor, context: context, object: object} = params, fake \\ false) do
223 additional = params[:additional] || %{}
224 # only accept false as false value
225 local = !(params[:local] == false)
226 published = params[:published]
230 %{to: to, actor: actor, published: published, context: context, object: object},
233 {:ok, activity} <- insert(create_data, local, fake),
234 {:fake, false, activity} <- {:fake, fake, activity},
235 _ <- increase_replies_count_if_reply(create_data),
236 _ <- increase_poll_votes_if_vote(create_data),
237 # Changing note count prior to enqueuing federation task in order to avoid
238 # race conditions on updating user.info
239 {:ok, _actor} <- increase_note_count_if_public(actor, activity),
240 :ok <- maybe_federate(activity) do
243 {:fake, true, activity} ->
251 def listen(%{to: to, actor: actor, context: context, object: object} = params) do
252 additional = params[:additional] || %{}
253 # only accept false as false value
254 local = !(params[:local] == false)
255 published = params[:published]
259 %{to: to, actor: actor, published: published, context: context, object: object},
262 {:ok, activity} <- insert(listen_data, local),
263 :ok <- maybe_federate(activity) do
271 def accept(%{to: to, actor: actor, object: object} = params) do
272 # only accept false as false value
273 local = !(params[:local] == false)
275 with data <- %{"to" => to, "type" => "Accept", "actor" => actor.ap_id, "object" => object},
276 {:ok, activity} <- insert(data, local),
277 :ok <- maybe_federate(activity) do
282 def reject(%{to: to, actor: actor, object: object} = params) do
283 # only accept false as false value
284 local = !(params[:local] == false)
286 with data <- %{"to" => to, "type" => "Reject", "actor" => actor.ap_id, "object" => object},
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 # only accept false as false value
295 local = !(params[:local] == false)
304 {:ok, activity} <- insert(data, local),
305 :ok <- maybe_federate(activity) do
310 def react_with_emoji(user, object, emoji, options \\ []) do
311 with local <- Keyword.get(options, :local, true),
312 activity_id <- Keyword.get(options, :activity_id, nil),
313 Pleroma.Emoji.is_unicode_emoji?(emoji),
314 reaction_data <- make_emoji_reaction_data(user, object, emoji, activity_id),
315 {:ok, activity} <- insert(reaction_data, local),
316 {:ok, object} <- add_emoji_reaction_to_object(activity, object),
317 :ok <- maybe_federate(activity) do
318 {:ok, activity, object}
322 def unreact_with_emoji(user, reaction_id, option \\ []) do
323 with local <- Keyword.get(options, :local, true),
324 activity_id <- Keyword.get(options, :activity_id, nil),
325 %Activity{actor: ^user.ap_id} = reaction_activity <- Activity.get_by_ap_id(reaction_id),
329 # TODO: This is weird, maybe we shouldn't check here if we can make the activity.
331 %User{ap_id: ap_id} = user,
332 %Object{data: %{"id" => _}} = object,
336 with nil <- get_existing_like(ap_id, object),
337 like_data <- make_like_data(user, object, activity_id),
338 {:ok, activity} <- insert(like_data, local),
339 {:ok, object} <- add_like_to_object(activity, object),
340 :ok <- maybe_federate(activity) do
341 {:ok, activity, object}
343 %Activity{} = activity -> {:ok, activity, object}
344 error -> {:error, error}
348 def unlike(%User{} = actor, %Object{} = object, activity_id \\ nil, local \\ true) do
349 with %Activity{} = like_activity <- get_existing_like(actor.ap_id, object),
350 unlike_data <- make_unlike_data(actor, like_activity, activity_id),
351 {:ok, unlike_activity} <- insert(unlike_data, local),
352 {:ok, _activity} <- Repo.delete(like_activity),
353 {:ok, object} <- remove_like_from_object(like_activity, object),
354 :ok <- maybe_federate(unlike_activity) do
355 {:ok, unlike_activity, like_activity, object}
362 %User{ap_id: _} = user,
363 %Object{data: %{"id" => _}} = object,
368 with true <- is_public?(object),
369 announce_data <- make_announce_data(user, object, activity_id, public),
370 {:ok, activity} <- insert(announce_data, local),
371 {:ok, object} <- add_announce_to_object(activity, object),
372 :ok <- maybe_federate(activity) do
373 {:ok, activity, object}
375 error -> {:error, error}
385 with %Activity{} = announce_activity <- get_existing_announce(actor.ap_id, object),
386 unannounce_data <- make_unannounce_data(actor, announce_activity, activity_id),
387 {:ok, unannounce_activity} <- insert(unannounce_data, local),
388 :ok <- maybe_federate(unannounce_activity),
389 {:ok, _activity} <- Repo.delete(announce_activity),
390 {:ok, object} <- remove_announce_from_object(announce_activity, object) do
391 {:ok, unannounce_activity, object}
397 def follow(follower, followed, activity_id \\ nil, local \\ true) do
398 with data <- make_follow_data(follower, followed, activity_id),
399 {:ok, activity} <- insert(data, local),
400 :ok <- maybe_federate(activity),
401 _ <- User.set_follow_state_cache(follower.ap_id, followed.ap_id, activity.data["state"]) do
406 def unfollow(follower, followed, activity_id \\ nil, local \\ true) do
407 with %Activity{} = follow_activity <- fetch_latest_follow(follower, followed),
408 {:ok, follow_activity} <- update_follow_state(follow_activity, "cancelled"),
409 unfollow_data <- make_unfollow_data(follower, followed, follow_activity, activity_id),
410 {:ok, activity} <- insert(unfollow_data, local),
411 :ok <- maybe_federate(activity) do
416 def delete(%User{ap_id: ap_id, follower_address: follower_address} = user) do
418 "to" => [follower_address],
421 "object" => %{"type" => "Person", "id" => ap_id}
423 {:ok, activity} <- insert(data, true, true, true),
424 :ok <- maybe_federate(activity) do
429 def delete(%Object{data: %{"id" => id, "actor" => actor}} = object, local \\ true) do
430 user = User.get_cached_by_ap_id(actor)
431 to = (object.data["to"] || []) ++ (object.data["cc"] || [])
433 with {:ok, object, activity} <- Object.delete(object),
439 "deleted_activity_id" => activity && activity.id
441 {:ok, activity} <- insert(data, local, false),
442 stream_out_participations(object, user),
443 _ <- decrease_replies_count_if_reply(object),
444 # Changing note count prior to enqueuing federation task in order to avoid
445 # race conditions on updating user.info
446 {:ok, _actor} <- decrease_note_count_if_public(user, object),
447 :ok <- maybe_federate(activity) do
452 @spec block(User.t(), User.t(), String.t() | nil, boolean) :: {:ok, Activity.t() | nil}
453 def block(blocker, blocked, activity_id \\ nil, local \\ true) do
454 outgoing_blocks = Config.get([:activitypub, :outgoing_blocks])
455 unfollow_blocked = Config.get([:activitypub, :unfollow_blocked])
457 if unfollow_blocked do
458 follow_activity = fetch_latest_follow(blocker, blocked)
459 if follow_activity, do: unfollow(blocker, blocked, nil, local)
462 with true <- outgoing_blocks,
463 block_data <- make_block_data(blocker, blocked, activity_id),
464 {:ok, activity} <- insert(block_data, local),
465 :ok <- maybe_federate(activity) do
472 def unblock(blocker, blocked, activity_id \\ nil, local \\ true) do
473 with %Activity{} = block_activity <- fetch_latest_block(blocker, blocked),
474 unblock_data <- make_unblock_data(blocker, blocked, block_activity, activity_id),
475 {:ok, activity} <- insert(unblock_data, local),
476 :ok <- maybe_federate(activity) do
481 @spec flag(map()) :: {:ok, Activity.t()} | any
491 # only accept false as false value
492 local = !(params[:local] == false)
493 forward = !(params[:forward] == false)
495 additional = params[:additional] || %{}
499 Map.merge(additional, %{"to" => [], "cc" => [account.ap_id]})
501 Map.merge(additional, %{"to" => [], "cc" => []})
504 with flag_data <- make_flag_data(params, additional),
505 {:ok, activity} <- insert(flag_data, local),
506 :ok <- maybe_federate(activity) do
507 Enum.each(User.all_superusers(), fn superuser ->
509 |> Pleroma.Emails.AdminEmail.report(actor, account, statuses, content)
510 |> Pleroma.Emails.Mailer.deliver_async()
517 defp fetch_activities_for_context_query(context, opts) do
518 public = [Pleroma.Constants.as_public()]
521 if opts["user"], do: [opts["user"].ap_id | opts["user"].following] ++ public, else: public
523 from(activity in Activity)
524 |> maybe_preload_objects(opts)
525 |> maybe_preload_bookmarks(opts)
526 |> maybe_set_thread_muted_field(opts)
527 |> restrict_blocked(opts)
528 |> restrict_recipients(recipients, opts["user"])
532 "?->>'type' = ? and ?->>'context' = ?",
539 |> exclude_poll_votes(opts)
541 |> order_by([activity], desc: activity.id)
544 @spec fetch_activities_for_context(String.t(), keyword() | map()) :: [Activity.t()]
545 def fetch_activities_for_context(context, opts \\ %{}) do
547 |> fetch_activities_for_context_query(opts)
551 @spec fetch_latest_activity_id_for_context(String.t(), keyword() | map()) ::
552 FlakeId.Ecto.CompatType.t() | nil
553 def fetch_latest_activity_id_for_context(context, opts \\ %{}) do
555 |> fetch_activities_for_context_query(Map.merge(%{"skip_preload" => true}, opts))
561 def fetch_public_activities(opts \\ %{}, pagination \\ :keyset) do
562 opts = Map.drop(opts, ["user"])
564 [Pleroma.Constants.as_public()]
565 |> fetch_activities_query(opts)
566 |> restrict_unlisted()
567 |> Pagination.fetch_paginated(opts, pagination)
571 @valid_visibilities ~w[direct unlisted public private]
573 defp restrict_visibility(query, %{visibility: visibility})
574 when is_list(visibility) do
575 if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
581 "activity_visibility(?, ?, ?) = ANY (?)",
591 Logger.error("Could not restrict visibility to #{visibility}")
595 defp restrict_visibility(query, %{visibility: visibility})
596 when visibility in @valid_visibilities do
600 fragment("activity_visibility(?, ?, ?) = ?", a.actor, a.recipients, a.data, ^visibility)
604 defp restrict_visibility(_query, %{visibility: visibility})
605 when visibility not in @valid_visibilities do
606 Logger.error("Could not restrict visibility to #{visibility}")
609 defp restrict_visibility(query, _visibility), do: query
611 defp restrict_thread_visibility(query, _, %{skip_thread_containment: true} = _),
614 defp restrict_thread_visibility(
616 %{"user" => %User{info: %{skip_thread_containment: true}}},
621 defp restrict_thread_visibility(query, %{"user" => %User{ap_id: ap_id}}, _) do
624 where: fragment("thread_visibility(?, (?)->>'id') = true", ^ap_id, a.data)
628 defp restrict_thread_visibility(query, _, _), do: query
630 def fetch_user_abstract_activities(user, reading_user, params \\ %{}) do
633 |> Map.put("user", reading_user)
634 |> Map.put("actor_id", user.ap_id)
635 |> Map.put("whole_db", true)
638 user_activities_recipients(%{
639 "godmode" => params["godmode"],
640 "reading_user" => reading_user
643 fetch_activities(recipients, params)
647 def fetch_user_activities(user, reading_user, params \\ %{}) do
650 |> Map.put("type", ["Create", "Announce"])
651 |> Map.put("user", reading_user)
652 |> Map.put("actor_id", user.ap_id)
653 |> Map.put("whole_db", true)
654 |> Map.put("pinned_activity_ids", user.info.pinned_activities)
657 user_activities_recipients(%{
658 "godmode" => params["godmode"],
659 "reading_user" => reading_user
662 fetch_activities(recipients, params)
666 defp user_activities_recipients(%{"godmode" => true}) do
670 defp user_activities_recipients(%{"reading_user" => reading_user}) do
672 [Pleroma.Constants.as_public()] ++ [reading_user.ap_id | reading_user.following]
674 [Pleroma.Constants.as_public()]
678 defp restrict_since(query, %{"since_id" => ""}), do: query
680 defp restrict_since(query, %{"since_id" => since_id}) do
681 from(activity in query, where: activity.id > ^since_id)
684 defp restrict_since(query, _), do: query
686 defp restrict_tag_reject(_query, %{"tag_reject" => _tag_reject, "skip_preload" => true}) do
687 raise "Can't use the child object without preloading!"
690 defp restrict_tag_reject(query, %{"tag_reject" => tag_reject})
691 when is_list(tag_reject) and tag_reject != [] do
693 [_activity, object] in query,
694 where: fragment("not (?)->'tag' \\?| (?)", object.data, ^tag_reject)
698 defp restrict_tag_reject(query, _), do: query
700 defp restrict_tag_all(_query, %{"tag_all" => _tag_all, "skip_preload" => true}) do
701 raise "Can't use the child object without preloading!"
704 defp restrict_tag_all(query, %{"tag_all" => tag_all})
705 when is_list(tag_all) and tag_all != [] do
707 [_activity, object] in query,
708 where: fragment("(?)->'tag' \\?& (?)", object.data, ^tag_all)
712 defp restrict_tag_all(query, _), do: query
714 defp restrict_tag(_query, %{"tag" => _tag, "skip_preload" => true}) do
715 raise "Can't use the child object without preloading!"
718 defp restrict_tag(query, %{"tag" => tag}) when is_list(tag) do
720 [_activity, object] in query,
721 where: fragment("(?)->'tag' \\?| (?)", object.data, ^tag)
725 defp restrict_tag(query, %{"tag" => tag}) when is_binary(tag) do
727 [_activity, object] in query,
728 where: fragment("(?)->'tag' \\? (?)", object.data, ^tag)
732 defp restrict_tag(query, _), do: query
734 defp restrict_recipients(query, [], _user), do: query
736 defp restrict_recipients(query, recipients, nil) do
737 from(activity in query, where: fragment("? && ?", ^recipients, activity.recipients))
740 defp restrict_recipients(query, recipients, user) do
743 where: fragment("? && ?", ^recipients, activity.recipients),
744 or_where: activity.actor == ^user.ap_id
748 defp restrict_local(query, %{"local_only" => true}) do
749 from(activity in query, where: activity.local == true)
752 defp restrict_local(query, _), do: query
754 defp restrict_actor(query, %{"actor_id" => actor_id}) do
755 from(activity in query, where: activity.actor == ^actor_id)
758 defp restrict_actor(query, _), do: query
760 defp restrict_type(query, %{"type" => type}) when is_binary(type) do
761 from(activity in query, where: fragment("?->>'type' = ?", activity.data, ^type))
764 defp restrict_type(query, %{"type" => type}) do
765 from(activity in query, where: fragment("?->>'type' = ANY(?)", activity.data, ^type))
768 defp restrict_type(query, _), do: query
770 defp restrict_state(query, %{"state" => state}) do
771 from(activity in query, where: fragment("?->>'state' = ?", activity.data, ^state))
774 defp restrict_state(query, _), do: query
776 defp restrict_favorited_by(query, %{"favorited_by" => ap_id}) do
778 [_activity, object] in query,
779 where: fragment("(?)->'likes' \\? (?)", object.data, ^ap_id)
783 defp restrict_favorited_by(query, _), do: query
785 defp restrict_media(_query, %{"only_media" => _val, "skip_preload" => true}) do
786 raise "Can't use the child object without preloading!"
789 defp restrict_media(query, %{"only_media" => val}) when val == "true" or val == "1" do
791 [_activity, object] in query,
792 where: fragment("not (?)->'attachment' = (?)", object.data, ^[])
796 defp restrict_media(query, _), do: query
798 defp restrict_replies(query, %{"exclude_replies" => val}) when val == "true" or val == "1" do
801 where: fragment("?->'object'->>'inReplyTo' is null", activity.data)
805 defp restrict_replies(query, _), do: query
807 defp restrict_reblogs(query, %{"exclude_reblogs" => val}) when val == "true" or val == "1" do
808 from(activity in query, where: fragment("?->>'type' != 'Announce'", activity.data))
811 defp restrict_reblogs(query, _), do: query
813 defp restrict_muted(query, %{"with_muted" => val}) when val in [true, "true", "1"], do: query
815 defp restrict_muted(query, %{"muting_user" => %User{info: info}} = opts) do
819 from([activity] in query,
820 where: fragment("not (? = ANY(?))", activity.actor, ^mutes),
821 where: fragment("not (?->'to' \\?| ?)", activity.data, ^mutes)
824 unless opts["skip_preload"] do
825 from([thread_mute: tm] in query, where: is_nil(tm.user_id))
831 defp restrict_muted(query, _), do: query
833 defp restrict_blocked(query, %{"blocking_user" => %User{info: info}}) do
834 blocks = info.blocks || []
835 domain_blocks = info.domain_blocks || []
838 if has_named_binding?(query, :object), do: query, else: Activity.with_joined_object(query)
841 [activity, object: o] in query,
842 where: fragment("not (? = ANY(?))", activity.actor, ^blocks),
843 where: fragment("not (? && ?)", activity.recipients, ^blocks),
846 "not (?->>'type' = 'Announce' and ?->'to' \\?| ?)",
851 where: fragment("not (split_part(?, '/', 3) = ANY(?))", activity.actor, ^domain_blocks),
852 where: fragment("not (split_part(?->>'actor', '/', 3) = ANY(?))", o.data, ^domain_blocks)
856 defp restrict_blocked(query, _), do: query
858 defp restrict_unlisted(query) do
863 "not (coalesce(?->'cc', '{}'::jsonb) \\?| ?)",
865 ^[Pleroma.Constants.as_public()]
870 defp restrict_pinned(query, %{"pinned" => "true", "pinned_activity_ids" => ids}) do
871 from(activity in query, where: activity.id in ^ids)
874 defp restrict_pinned(query, _), do: query
876 defp restrict_muted_reblogs(query, %{"muting_user" => %User{info: info}}) do
877 muted_reblogs = info.muted_reblogs || []
883 "not ( ?->>'type' = 'Announce' and ? = ANY(?))",
891 defp restrict_muted_reblogs(query, _), do: query
893 defp exclude_poll_votes(query, %{"include_poll_votes" => true}), do: query
895 defp exclude_poll_votes(query, _) do
896 if has_named_binding?(query, :object) do
897 from([activity, object: o] in query,
898 where: fragment("not(?->>'type' = ?)", o.data, "Answer")
905 defp exclude_id(query, %{"exclude_id" => id}) when is_binary(id) do
906 from(activity in query, where: activity.id != ^id)
909 defp exclude_id(query, _), do: query
911 defp maybe_preload_objects(query, %{"skip_preload" => true}), do: query
913 defp maybe_preload_objects(query, _) do
915 |> Activity.with_preloaded_object()
918 defp maybe_preload_bookmarks(query, %{"skip_preload" => true}), do: query
920 defp maybe_preload_bookmarks(query, opts) do
922 |> Activity.with_preloaded_bookmark(opts["user"])
925 defp maybe_set_thread_muted_field(query, %{"skip_preload" => true}), do: query
927 defp maybe_set_thread_muted_field(query, opts) do
929 |> Activity.with_set_thread_muted_field(opts["muting_user"] || opts["user"])
932 defp maybe_order(query, %{order: :desc}) do
934 |> order_by(desc: :id)
937 defp maybe_order(query, %{order: :asc}) do
939 |> order_by(asc: :id)
942 defp maybe_order(query, _), do: query
944 def fetch_activities_query(recipients, opts \\ %{}) do
946 skip_thread_containment: Config.get([:instance, :skip_thread_containment])
950 |> maybe_preload_objects(opts)
951 |> maybe_preload_bookmarks(opts)
952 |> maybe_set_thread_muted_field(opts)
954 |> restrict_recipients(recipients, opts["user"])
955 |> restrict_tag(opts)
956 |> restrict_tag_reject(opts)
957 |> restrict_tag_all(opts)
958 |> restrict_since(opts)
959 |> restrict_local(opts)
960 |> restrict_actor(opts)
961 |> restrict_type(opts)
962 |> restrict_state(opts)
963 |> restrict_favorited_by(opts)
964 |> restrict_blocked(opts)
965 |> restrict_muted(opts)
966 |> restrict_media(opts)
967 |> restrict_visibility(opts)
968 |> restrict_thread_visibility(opts, config)
969 |> restrict_replies(opts)
970 |> restrict_reblogs(opts)
971 |> restrict_pinned(opts)
972 |> restrict_muted_reblogs(opts)
973 |> Activity.restrict_deactivated_users()
974 |> exclude_poll_votes(opts)
977 def fetch_activities(recipients, opts \\ %{}, pagination \\ :keyset) do
978 list_memberships = Pleroma.List.memberships(opts["user"])
980 fetch_activities_query(recipients ++ list_memberships, opts)
981 |> Pagination.fetch_paginated(opts, pagination)
983 |> maybe_update_cc(list_memberships, opts["user"])
986 defp maybe_update_cc(activities, list_memberships, %User{ap_id: user_ap_id})
987 when is_list(list_memberships) and length(list_memberships) > 0 do
988 Enum.map(activities, fn
989 %{data: %{"bcc" => bcc}} = activity when is_list(bcc) and length(bcc) > 0 ->
990 if Enum.any?(bcc, &(&1 in list_memberships)) do
991 update_in(activity.data["cc"], &[user_ap_id | &1])
1001 defp maybe_update_cc(activities, _, _), do: activities
1003 def fetch_activities_bounded_query(query, recipients, recipients_with_public) do
1004 from(activity in query,
1006 fragment("? && ?", activity.recipients, ^recipients) or
1007 (fragment("? && ?", activity.recipients, ^recipients_with_public) and
1008 ^Pleroma.Constants.as_public() in activity.recipients)
1012 def fetch_activities_bounded(
1014 recipients_with_public,
1016 pagination \\ :keyset
1018 fetch_activities_query([], opts)
1019 |> fetch_activities_bounded_query(recipients, recipients_with_public)
1020 |> Pagination.fetch_paginated(opts, pagination)
1024 def upload(file, opts \\ []) do
1025 with {:ok, data} <- Upload.store(file, opts) do
1028 Map.put(data, "actor", opts[:actor])
1033 Repo.insert(%Object{data: obj_data})
1037 defp object_to_user_data(data) do
1039 data["icon"]["url"] &&
1042 "url" => [%{"href" => data["icon"]["url"]}]
1046 data["image"]["url"] &&
1049 "url" => [%{"href" => data["image"]["url"]}]
1054 |> Map.get("attachment", [])
1055 |> Enum.filter(fn %{"type" => t} -> t == "PropertyValue" end)
1056 |> Enum.map(fn fields -> Map.take(fields, ["name", "value"]) end)
1058 locked = data["manuallyApprovesFollowers"] || false
1059 data = Transmogrifier.maybe_fix_user_object(data)
1060 discoverable = data["discoverable"] || false
1070 discoverable: discoverable
1074 follower_address: data["followers"],
1075 following_address: data["following"],
1076 bio: data["summary"]
1079 # nickname can be nil because of virtual actors
1081 if data["preferredUsername"] do
1085 "#{data["preferredUsername"]}@#{URI.parse(data["id"]).host}"
1088 Map.put(user_data, :nickname, nil)
1094 def fetch_follow_information_for_user(user) do
1095 with {:ok, following_data} <-
1096 Fetcher.fetch_and_contain_remote_object_from_id(user.following_address),
1097 following_count when is_integer(following_count) <- following_data["totalItems"],
1098 {:ok, hide_follows} <- collection_private(following_data),
1099 {:ok, followers_data} <-
1100 Fetcher.fetch_and_contain_remote_object_from_id(user.follower_address),
1101 followers_count when is_integer(followers_count) <- followers_data["totalItems"],
1102 {:ok, hide_followers} <- collection_private(followers_data) do
1105 hide_follows: hide_follows,
1106 follower_count: followers_count,
1107 following_count: following_count,
1108 hide_followers: hide_followers
1119 defp maybe_update_follow_information(data) do
1120 with {:enabled, true} <-
1121 {:enabled, Pleroma.Config.get([:instance, :external_user_synchronization])},
1122 {:ok, info} <- fetch_follow_information_for_user(data) do
1123 info = Map.merge(data.info, info)
1124 Map.put(data, :info, info)
1126 {:enabled, false} ->
1131 "Follower/Following counter update for #{data.ap_id} failed.\n" <> inspect(e)
1138 defp collection_private(data) do
1139 if is_map(data["first"]) and
1140 data["first"]["type"] in ["CollectionPage", "OrderedCollectionPage"] do
1143 with {:ok, %{"type" => type}} when type in ["CollectionPage", "OrderedCollectionPage"] <-
1144 Fetcher.fetch_and_contain_remote_object_from_id(data["first"]) do
1147 {:error, {:ok, %{status: code}}} when code in [401, 403] ->
1159 def user_data_from_user_object(data) do
1160 with {:ok, data} <- MRF.filter(data),
1161 {:ok, data} <- object_to_user_data(data) do
1168 def fetch_and_prepare_user_from_ap_id(ap_id) do
1169 with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id),
1170 {:ok, data} <- user_data_from_user_object(data),
1171 data <- maybe_update_follow_information(data) do
1174 e -> Logger.error("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
1178 def make_user_from_ap_id(ap_id) do
1179 if _user = User.get_cached_by_ap_id(ap_id) do
1180 Transmogrifier.upgrade_user_from_ap_id(ap_id)
1182 with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id) do
1183 User.insert_or_update_user(data)
1190 def make_user_from_nickname(nickname) do
1191 with {:ok, %{"ap_id" => ap_id}} when not is_nil(ap_id) <- WebFinger.finger(nickname) do
1192 make_user_from_ap_id(ap_id)
1194 _e -> {:error, "No AP id in WebFinger"}
1198 # filter out broken threads
1199 def contain_broken_threads(%Activity{} = activity, %User{} = user) do
1200 entire_thread_visible_for_user?(activity, user)
1203 # do post-processing on a specific activity
1204 def contain_activity(%Activity{} = activity, %User{} = user) do
1205 contain_broken_threads(activity, user)
1208 def fetch_direct_messages_query do
1210 |> restrict_type(%{"type" => "Create"})
1211 |> restrict_visibility(%{visibility: "direct"})
1212 |> order_by([activity], asc: activity.id)