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
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 PleromaJobQueue.enqueue(:background, Pleroma.Web.RichMedia.Helpers, [:fetch, activity])
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 accept(%{to: to, actor: actor, object: object} = params) do
252 # only accept false as false value
253 local = !(params[:local] == false)
255 with data <- %{"to" => to, "type" => "Accept", "actor" => actor.ap_id, "object" => object},
256 {:ok, activity} <- insert(data, local),
257 :ok <- maybe_federate(activity) do
262 def reject(%{to: to, actor: actor, object: object} = params) do
263 # only accept false as false value
264 local = !(params[:local] == false)
266 with data <- %{"to" => to, "type" => "Reject", "actor" => actor.ap_id, "object" => object},
267 {:ok, activity} <- insert(data, local),
268 :ok <- maybe_federate(activity) do
273 def update(%{to: to, cc: cc, actor: actor, object: object} = params) do
274 local = !(params[:local] == false)
275 activity_id = params[:activity_id]
284 data <- Utils.maybe_put(data, "id", activity_id),
285 {:ok, activity} <- insert(data, local),
286 :ok <- maybe_federate(activity) do
291 # TODO: This is weird, maybe we shouldn't check here if we can make the activity.
293 %User{ap_id: ap_id} = user,
294 %Object{data: %{"id" => _}} = object,
298 with nil <- get_existing_like(ap_id, object),
299 like_data <- make_like_data(user, object, activity_id),
300 {:ok, activity} <- insert(like_data, local),
301 {:ok, object} <- add_like_to_object(activity, object),
302 :ok <- maybe_federate(activity) do
303 {:ok, activity, object}
305 %Activity{} = activity -> {:ok, activity, object}
306 error -> {:error, error}
310 def unlike(%User{} = actor, %Object{} = object, activity_id \\ nil, local \\ true) do
311 with %Activity{} = like_activity <- get_existing_like(actor.ap_id, object),
312 unlike_data <- make_unlike_data(actor, like_activity, activity_id),
313 {:ok, unlike_activity} <- insert(unlike_data, local),
314 {:ok, _activity} <- Repo.delete(like_activity),
315 {:ok, object} <- remove_like_from_object(like_activity, object),
316 :ok <- maybe_federate(unlike_activity) do
317 {:ok, unlike_activity, like_activity, object}
324 %User{ap_id: _} = user,
325 %Object{data: %{"id" => _}} = object,
330 with true <- is_public?(object),
331 announce_data <- make_announce_data(user, object, activity_id, public),
332 {:ok, activity} <- insert(announce_data, local),
333 {:ok, object} <- add_announce_to_object(activity, object),
334 :ok <- maybe_federate(activity) do
335 {:ok, activity, object}
337 error -> {:error, error}
347 with %Activity{} = announce_activity <- get_existing_announce(actor.ap_id, object),
348 unannounce_data <- make_unannounce_data(actor, announce_activity, activity_id),
349 {:ok, unannounce_activity} <- insert(unannounce_data, local),
350 :ok <- maybe_federate(unannounce_activity),
351 {:ok, _activity} <- Repo.delete(announce_activity),
352 {:ok, object} <- remove_announce_from_object(announce_activity, object) do
353 {:ok, unannounce_activity, object}
359 def follow(follower, followed, activity_id \\ nil, local \\ true) do
360 with data <- make_follow_data(follower, followed, activity_id),
361 {:ok, activity} <- insert(data, local),
362 :ok <- maybe_federate(activity),
363 _ <- User.set_follow_state_cache(follower.ap_id, followed.ap_id, activity.data["state"]) do
368 def unfollow(follower, followed, activity_id \\ nil, local \\ true) do
369 with %Activity{} = follow_activity <- fetch_latest_follow(follower, followed),
370 {:ok, follow_activity} <- update_follow_state(follow_activity, "cancelled"),
371 unfollow_data <- make_unfollow_data(follower, followed, follow_activity, activity_id),
372 {:ok, activity} <- insert(unfollow_data, local),
373 :ok <- maybe_federate(activity) do
378 def delete(%User{ap_id: ap_id, follower_address: follower_address} = user) do
380 "to" => [follower_address],
383 "object" => %{"type" => "Person", "id" => ap_id}
385 {:ok, activity} <- insert(data, true, true, true),
386 :ok <- maybe_federate(activity) do
391 def delete(%Object{data: %{"id" => id, "actor" => actor}} = object, local \\ true) do
392 user = User.get_cached_by_ap_id(actor)
393 to = (object.data["to"] || []) ++ (object.data["cc"] || [])
395 with {:ok, object, activity} <- Object.delete(object),
401 "deleted_activity_id" => activity && activity.id
403 {:ok, activity} <- insert(data, local, false),
404 stream_out_participations(object, user),
405 _ <- decrease_replies_count_if_reply(object),
406 # Changing note count prior to enqueuing federation task in order to avoid
407 # race conditions on updating user.info
408 {:ok, _actor} <- decrease_note_count_if_public(user, object),
409 :ok <- maybe_federate(activity) do
414 def block(blocker, blocked, activity_id \\ nil, local \\ true) do
415 outgoing_blocks = Config.get([:activitypub, :outgoing_blocks])
416 unfollow_blocked = Config.get([:activitypub, :unfollow_blocked])
418 if unfollow_blocked do
419 follow_activity = fetch_latest_follow(blocker, blocked)
420 if follow_activity, do: unfollow(blocker, blocked, nil, local)
423 with true <- outgoing_blocks,
424 block_data <- make_block_data(blocker, blocked, activity_id),
425 {:ok, activity} <- insert(block_data, local),
426 :ok <- maybe_federate(activity) do
433 def unblock(blocker, blocked, activity_id \\ nil, local \\ true) do
434 with %Activity{} = block_activity <- fetch_latest_block(blocker, blocked),
435 unblock_data <- make_unblock_data(blocker, blocked, block_activity, activity_id),
436 {:ok, activity} <- insert(unblock_data, local),
437 :ok <- maybe_federate(activity) do
451 # only accept false as false value
452 local = !(params[:local] == false)
453 forward = !(params[:forward] == false)
455 additional = params[:additional] || %{}
467 Map.merge(additional, %{"to" => [], "cc" => [account.ap_id]})
469 Map.merge(additional, %{"to" => [], "cc" => []})
472 with flag_data <- make_flag_data(params, additional),
473 {:ok, activity} <- insert(flag_data, local),
474 :ok <- maybe_federate(activity) do
475 Enum.each(User.all_superusers(), fn superuser ->
477 |> Pleroma.Emails.AdminEmail.report(actor, account, statuses, content)
478 |> Pleroma.Emails.Mailer.deliver_async()
485 defp fetch_activities_for_context_query(context, opts) do
486 public = [Pleroma.Constants.as_public()]
489 if opts["user"], do: [opts["user"].ap_id | opts["user"].following] ++ public, else: public
491 from(activity in Activity)
492 |> maybe_preload_objects(opts)
493 |> maybe_preload_bookmarks(opts)
494 |> maybe_set_thread_muted_field(opts)
495 |> restrict_blocked(opts)
496 |> restrict_recipients(recipients, opts["user"])
500 "?->>'type' = ? and ?->>'context' = ?",
507 |> exclude_poll_votes(opts)
509 |> order_by([activity], desc: activity.id)
512 @spec fetch_activities_for_context(String.t(), keyword() | map()) :: [Activity.t()]
513 def fetch_activities_for_context(context, opts \\ %{}) do
515 |> fetch_activities_for_context_query(opts)
519 @spec fetch_latest_activity_id_for_context(String.t(), keyword() | map()) ::
520 FlakeId.Ecto.CompatType.t() | nil
521 def fetch_latest_activity_id_for_context(context, opts \\ %{}) do
523 |> fetch_activities_for_context_query(Map.merge(%{"skip_preload" => true}, opts))
529 def fetch_public_activities(opts \\ %{}) do
530 q = fetch_activities_query([Pleroma.Constants.as_public()], opts)
533 |> restrict_unlisted()
534 |> Pagination.fetch_paginated(opts)
538 @valid_visibilities ~w[direct unlisted public private]
540 defp restrict_visibility(query, %{visibility: visibility})
541 when is_list(visibility) do
542 if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
548 "activity_visibility(?, ?, ?) = ANY (?)",
558 Logger.error("Could not restrict visibility to #{visibility}")
562 defp restrict_visibility(query, %{visibility: visibility})
563 when visibility in @valid_visibilities do
567 fragment("activity_visibility(?, ?, ?) = ?", a.actor, a.recipients, a.data, ^visibility)
571 defp restrict_visibility(_query, %{visibility: visibility})
572 when visibility not in @valid_visibilities do
573 Logger.error("Could not restrict visibility to #{visibility}")
576 defp restrict_visibility(query, _visibility), do: query
578 defp restrict_thread_visibility(query, _, %{skip_thread_containment: true} = _),
581 defp restrict_thread_visibility(
583 %{"user" => %User{info: %{skip_thread_containment: true}}},
588 defp restrict_thread_visibility(query, %{"user" => %User{ap_id: ap_id}}, _) do
591 where: fragment("thread_visibility(?, (?)->>'id') = true", ^ap_id, a.data)
595 defp restrict_thread_visibility(query, _, _), do: query
597 def fetch_user_activities(user, reading_user, params \\ %{}) do
600 |> Map.put("type", ["Create", "Announce"])
601 |> Map.put("user", reading_user)
602 |> Map.put("actor_id", user.ap_id)
603 |> Map.put("whole_db", true)
604 |> Map.put("pinned_activity_ids", user.info.pinned_activities)
607 user_activities_recipients(%{
608 "godmode" => params["godmode"],
609 "reading_user" => reading_user
612 fetch_activities(recipients, params)
616 defp user_activities_recipients(%{"godmode" => true}) do
620 defp user_activities_recipients(%{"reading_user" => reading_user}) do
622 [Pleroma.Constants.as_public()] ++ [reading_user.ap_id | reading_user.following]
624 [Pleroma.Constants.as_public()]
628 defp restrict_since(query, %{"since_id" => ""}), do: query
630 defp restrict_since(query, %{"since_id" => since_id}) do
631 from(activity in query, where: activity.id > ^since_id)
634 defp restrict_since(query, _), do: query
636 defp restrict_tag_reject(_query, %{"tag_reject" => _tag_reject, "skip_preload" => true}) do
637 raise "Can't use the child object without preloading!"
640 defp restrict_tag_reject(query, %{"tag_reject" => tag_reject})
641 when is_list(tag_reject) and tag_reject != [] do
643 [_activity, object] in query,
644 where: fragment("not (?)->'tag' \\?| (?)", object.data, ^tag_reject)
648 defp restrict_tag_reject(query, _), do: query
650 defp restrict_tag_all(_query, %{"tag_all" => _tag_all, "skip_preload" => true}) do
651 raise "Can't use the child object without preloading!"
654 defp restrict_tag_all(query, %{"tag_all" => tag_all})
655 when is_list(tag_all) and tag_all != [] do
657 [_activity, object] in query,
658 where: fragment("(?)->'tag' \\?& (?)", object.data, ^tag_all)
662 defp restrict_tag_all(query, _), do: query
664 defp restrict_tag(_query, %{"tag" => _tag, "skip_preload" => true}) do
665 raise "Can't use the child object without preloading!"
668 defp restrict_tag(query, %{"tag" => tag}) when is_list(tag) do
670 [_activity, object] in query,
671 where: fragment("(?)->'tag' \\?| (?)", object.data, ^tag)
675 defp restrict_tag(query, %{"tag" => tag}) when is_binary(tag) do
677 [_activity, object] in query,
678 where: fragment("(?)->'tag' \\? (?)", object.data, ^tag)
682 defp restrict_tag(query, _), do: query
684 defp restrict_recipients(query, [], _user), do: query
686 defp restrict_recipients(query, recipients, nil) do
687 from(activity in query, where: fragment("? && ?", ^recipients, activity.recipients))
690 defp restrict_recipients(query, recipients, user) do
693 where: fragment("? && ?", ^recipients, activity.recipients),
694 or_where: activity.actor == ^user.ap_id
698 defp restrict_local(query, %{"local_only" => true}) do
699 from(activity in query, where: activity.local == true)
702 defp restrict_local(query, _), do: query
704 defp restrict_actor(query, %{"actor_id" => actor_id}) do
705 from(activity in query, where: activity.actor == ^actor_id)
708 defp restrict_actor(query, _), do: query
710 defp restrict_type(query, %{"type" => type}) when is_binary(type) do
711 from(activity in query, where: fragment("?->>'type' = ?", activity.data, ^type))
714 defp restrict_type(query, %{"type" => type}) do
715 from(activity in query, where: fragment("?->>'type' = ANY(?)", activity.data, ^type))
718 defp restrict_type(query, _), do: query
720 defp restrict_state(query, %{"state" => state}) do
721 from(activity in query, where: fragment("?->>'state' = ?", activity.data, ^state))
724 defp restrict_state(query, _), do: query
726 defp restrict_favorited_by(query, %{"favorited_by" => ap_id}) do
728 [_activity, object] in query,
729 where: fragment("(?)->'likes' \\? (?)", object.data, ^ap_id)
733 defp restrict_favorited_by(query, _), do: query
735 defp restrict_media(_query, %{"only_media" => _val, "skip_preload" => true}) do
736 raise "Can't use the child object without preloading!"
739 defp restrict_media(query, %{"only_media" => val}) when val == "true" or val == "1" do
741 [_activity, object] in query,
742 where: fragment("not (?)->'attachment' = (?)", object.data, ^[])
746 defp restrict_media(query, _), do: query
748 defp restrict_replies(query, %{"exclude_replies" => val}) when val == "true" or val == "1" do
751 where: fragment("?->'object'->>'inReplyTo' is null", activity.data)
755 defp restrict_replies(query, _), do: query
757 defp restrict_reblogs(query, %{"exclude_reblogs" => val}) when val == "true" or val == "1" do
758 from(activity in query, where: fragment("?->>'type' != 'Announce'", activity.data))
761 defp restrict_reblogs(query, _), do: query
763 defp restrict_muted(query, %{"with_muted" => val}) when val in [true, "true", "1"], do: query
765 defp restrict_muted(query, %{"muting_user" => %User{info: info}} = opts) do
769 from([activity] in query,
770 where: fragment("not (? = ANY(?))", activity.actor, ^mutes),
771 where: fragment("not (?->'to' \\?| ?)", activity.data, ^mutes)
774 unless opts["skip_preload"] do
775 from([thread_mute: tm] in query, where: is_nil(tm.user_id))
781 defp restrict_muted(query, _), do: query
783 defp restrict_blocked(query, %{"blocking_user" => %User{info: info}}) do
784 blocks = info.blocks || []
785 domain_blocks = info.domain_blocks || []
788 if has_named_binding?(query, :object), do: query, else: Activity.with_joined_object(query)
791 [activity, object: o] in query,
792 where: fragment("not (? = ANY(?))", activity.actor, ^blocks),
793 where: fragment("not (? && ?)", activity.recipients, ^blocks),
796 "not (?->>'type' = 'Announce' and ?->'to' \\?| ?)",
801 where: fragment("not (split_part(?, '/', 3) = ANY(?))", activity.actor, ^domain_blocks),
802 where: fragment("not (split_part(?->>'actor', '/', 3) = ANY(?))", o.data, ^domain_blocks)
806 defp restrict_blocked(query, _), do: query
808 defp restrict_unlisted(query) do
813 "not (coalesce(?->'cc', '{}'::jsonb) \\?| ?)",
815 ^[Pleroma.Constants.as_public()]
820 defp restrict_pinned(query, %{"pinned" => "true", "pinned_activity_ids" => ids}) do
821 from(activity in query, where: activity.id in ^ids)
824 defp restrict_pinned(query, _), do: query
826 defp restrict_muted_reblogs(query, %{"muting_user" => %User{info: info}}) do
827 muted_reblogs = info.muted_reblogs || []
833 "not ( ?->>'type' = 'Announce' and ? = ANY(?))",
841 defp restrict_muted_reblogs(query, _), do: query
843 defp exclude_poll_votes(query, %{"include_poll_votes" => true}), do: query
845 defp exclude_poll_votes(query, _) do
846 if has_named_binding?(query, :object) do
847 from([activity, object: o] in query,
848 where: fragment("not(?->>'type' = ?)", o.data, "Answer")
855 defp exclude_id(query, %{"exclude_id" => id}) when is_binary(id) do
856 from(activity in query, where: activity.id != ^id)
859 defp exclude_id(query, _), do: query
861 defp maybe_preload_objects(query, %{"skip_preload" => true}), do: query
863 defp maybe_preload_objects(query, _) do
865 |> Activity.with_preloaded_object()
868 defp maybe_preload_bookmarks(query, %{"skip_preload" => true}), do: query
870 defp maybe_preload_bookmarks(query, opts) do
872 |> Activity.with_preloaded_bookmark(opts["user"])
875 defp maybe_set_thread_muted_field(query, %{"skip_preload" => true}), do: query
877 defp maybe_set_thread_muted_field(query, opts) do
879 |> Activity.with_set_thread_muted_field(opts["muting_user"] || opts["user"])
882 defp maybe_order(query, %{order: :desc}) do
884 |> order_by(desc: :id)
887 defp maybe_order(query, %{order: :asc}) do
889 |> order_by(asc: :id)
892 defp maybe_order(query, _), do: query
894 def fetch_activities_query(recipients, opts \\ %{}) do
896 skip_thread_containment: Config.get([:instance, :skip_thread_containment])
900 |> maybe_preload_objects(opts)
901 |> maybe_preload_bookmarks(opts)
902 |> maybe_set_thread_muted_field(opts)
904 |> restrict_recipients(recipients, opts["user"])
905 |> restrict_tag(opts)
906 |> restrict_tag_reject(opts)
907 |> restrict_tag_all(opts)
908 |> restrict_since(opts)
909 |> restrict_local(opts)
910 |> restrict_actor(opts)
911 |> restrict_type(opts)
912 |> restrict_state(opts)
913 |> restrict_favorited_by(opts)
914 |> restrict_blocked(opts)
915 |> restrict_muted(opts)
916 |> restrict_media(opts)
917 |> restrict_visibility(opts)
918 |> restrict_thread_visibility(opts, config)
919 |> restrict_replies(opts)
920 |> restrict_reblogs(opts)
921 |> restrict_pinned(opts)
922 |> restrict_muted_reblogs(opts)
923 |> Activity.restrict_deactivated_users()
924 |> exclude_poll_votes(opts)
927 def fetch_activities(recipients, opts \\ %{}) do
928 list_memberships = Pleroma.List.memberships(opts["user"])
930 fetch_activities_query(recipients ++ list_memberships, opts)
931 |> Pagination.fetch_paginated(opts)
933 |> maybe_update_cc(list_memberships, opts["user"])
936 defp maybe_update_cc(activities, list_memberships, %User{ap_id: user_ap_id})
937 when is_list(list_memberships) and length(list_memberships) > 0 do
938 Enum.map(activities, fn
939 %{data: %{"bcc" => bcc}} = activity when is_list(bcc) and length(bcc) > 0 ->
940 if Enum.any?(bcc, &(&1 in list_memberships)) do
941 update_in(activity.data["cc"], &[user_ap_id | &1])
951 defp maybe_update_cc(activities, _, _), do: activities
953 def fetch_activities_bounded_query(query, recipients, recipients_with_public) do
954 from(activity in query,
956 fragment("? && ?", activity.recipients, ^recipients) or
957 (fragment("? && ?", activity.recipients, ^recipients_with_public) and
958 ^Pleroma.Constants.as_public() in activity.recipients)
962 def fetch_activities_bounded(recipients, recipients_with_public, opts \\ %{}) do
963 fetch_activities_query([], opts)
964 |> fetch_activities_bounded_query(recipients, recipients_with_public)
965 |> Pagination.fetch_paginated(opts)
969 def upload(file, opts \\ []) do
970 with {:ok, data} <- Upload.store(file, opts) do
973 Map.put(data, "actor", opts[:actor])
978 Repo.insert(%Object{data: obj_data})
982 defp object_to_user_data(data) do
984 data["icon"]["url"] &&
987 "url" => [%{"href" => data["icon"]["url"]}]
991 data["image"]["url"] &&
994 "url" => [%{"href" => data["image"]["url"]}]
999 |> Map.get("attachment", [])
1000 |> Enum.filter(fn %{"type" => t} -> t == "PropertyValue" end)
1001 |> Enum.map(fn fields -> Map.take(fields, ["name", "value"]) end)
1003 locked = data["manuallyApprovesFollowers"] || false
1004 data = Transmogrifier.maybe_fix_user_object(data)
1017 follower_address: data["followers"],
1018 following_address: data["following"],
1019 bio: data["summary"]
1022 # nickname can be nil because of virtual actors
1024 if data["preferredUsername"] do
1028 "#{data["preferredUsername"]}@#{URI.parse(data["id"]).host}"
1031 Map.put(user_data, :nickname, nil)
1037 def fetch_follow_information_for_user(user) do
1038 with {:ok, following_data} <-
1039 Fetcher.fetch_and_contain_remote_object_from_id(user.following_address),
1040 following_count when is_integer(following_count) <- following_data["totalItems"],
1041 {:ok, hide_follows} <- collection_private(following_data),
1042 {:ok, followers_data} <-
1043 Fetcher.fetch_and_contain_remote_object_from_id(user.follower_address),
1044 followers_count when is_integer(followers_count) <- followers_data["totalItems"],
1045 {:ok, hide_followers} <- collection_private(followers_data) do
1048 hide_follows: hide_follows,
1049 follower_count: followers_count,
1050 following_count: following_count,
1051 hide_followers: hide_followers
1062 defp maybe_update_follow_information(data) do
1063 with {:enabled, true} <-
1064 {:enabled, Pleroma.Config.get([:instance, :external_user_synchronization])},
1065 {:ok, info} <- fetch_follow_information_for_user(data) do
1066 info = Map.merge(data.info, info)
1067 Map.put(data, :info, info)
1069 {:enabled, false} ->
1074 "Follower/Following counter update for #{data.ap_id} failed.\n" <> inspect(e)
1081 defp collection_private(data) do
1082 if is_map(data["first"]) and
1083 data["first"]["type"] in ["CollectionPage", "OrderedCollectionPage"] do
1086 with {:ok, %{"type" => type}} when type in ["CollectionPage", "OrderedCollectionPage"] <-
1087 Fetcher.fetch_and_contain_remote_object_from_id(data["first"]) do
1090 {:error, {:ok, %{status: code}}} when code in [401, 403] ->
1102 def user_data_from_user_object(data) do
1103 with {:ok, data} <- MRF.filter(data),
1104 {:ok, data} <- object_to_user_data(data) do
1111 def fetch_and_prepare_user_from_ap_id(ap_id) do
1112 with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id),
1113 {:ok, data} <- user_data_from_user_object(data),
1114 data <- maybe_update_follow_information(data) do
1117 e -> Logger.error("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
1121 def make_user_from_ap_id(ap_id) do
1122 if _user = User.get_cached_by_ap_id(ap_id) do
1123 Transmogrifier.upgrade_user_from_ap_id(ap_id)
1125 with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id) do
1126 User.insert_or_update_user(data)
1133 def make_user_from_nickname(nickname) do
1134 with {:ok, %{"ap_id" => ap_id}} when not is_nil(ap_id) <- WebFinger.finger(nickname) do
1135 make_user_from_ap_id(ap_id)
1137 _e -> {:error, "No AP id in WebFinger"}
1141 # filter out broken threads
1142 def contain_broken_threads(%Activity{} = activity, %User{} = user) do
1143 entire_thread_visible_for_user?(activity, user)
1146 # do post-processing on a specific activity
1147 def contain_activity(%Activity{} = activity, %User{} = user) do
1148 contain_broken_threads(activity, user)
1151 def fetch_direct_messages_query do
1153 |> restrict_type(%{"type" => "Create"})
1154 |> restrict_visibility(%{visibility: "direct"})
1155 |> order_by([activity], asc: activity.id)