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
8 alias Pleroma.Conversation
9 alias Pleroma.Notification
11 alias Pleroma.Object.Containment
12 alias Pleroma.Object.Fetcher
13 alias Pleroma.Pagination
17 alias Pleroma.Web.ActivityPub.MRF
18 alias Pleroma.Web.ActivityPub.Transmogrifier
19 alias Pleroma.Web.WebFinger
20 alias Pleroma.Workers.BackgroundWorker
23 import Pleroma.Web.ActivityPub.Utils
24 import Pleroma.Web.ActivityPub.Visibility
27 require Pleroma.Constants
29 defdelegate worker_args(queue), to: Pleroma.Workers.Helper
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 %{"op" => "fetch_data_for_activity", "activity_id" => activity.id}
152 |> BackgroundWorker.new(worker_args(:background))
155 Notification.create_notifications(activity)
159 |> Conversation.create_or_bump_for()
160 |> get_participations()
163 stream_out_participations(participations)
166 %Activity{} = activity ->
169 {:fake, true, map, recipients} ->
170 activity = %Activity{
174 recipients: recipients,
178 Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
186 defp get_participations({:ok, %{participations: participations}}), do: participations
187 defp get_participations(_), do: []
189 def stream_out_participations(participations) do
192 |> Repo.preload(:user)
194 Enum.each(participations, fn participation ->
195 Pleroma.Web.Streamer.stream("participation", participation)
199 def stream_out_participations(%Object{data: %{"context" => context}}, user) do
200 with %Conversation{} = conversation <- Conversation.get_for_ap_id(context),
201 conversation = Repo.preload(conversation, :participations),
203 fetch_latest_activity_id_for_context(conversation.ap_id, %{
205 "blocking_user" => user
207 if last_activity_id do
208 stream_out_participations(conversation.participations)
213 def stream_out_participations(_, _), do: :noop
215 def stream_out(activity) do
216 if activity.data["type"] in ["Create", "Announce", "Delete"] do
217 object = Object.normalize(activity)
218 # Do not stream out poll replies
219 unless object.data["type"] == "Answer" do
220 Pleroma.Web.Streamer.stream("user", activity)
221 Pleroma.Web.Streamer.stream("list", activity)
223 if get_visibility(activity) == "public" do
224 Pleroma.Web.Streamer.stream("public", activity)
227 Pleroma.Web.Streamer.stream("public:local", activity)
230 if activity.data["type"] in ["Create"] do
232 |> Map.get("tag", [])
233 |> Enum.filter(fn tag -> is_bitstring(tag) end)
234 |> Enum.each(fn tag -> Pleroma.Web.Streamer.stream("hashtag:" <> tag, activity) end)
236 if object.data["attachment"] != [] do
237 Pleroma.Web.Streamer.stream("public:media", activity)
240 Pleroma.Web.Streamer.stream("public:local:media", activity)
245 if get_visibility(activity) == "direct",
246 do: Pleroma.Web.Streamer.stream("direct", activity)
252 def create(%{to: to, actor: actor, context: context, object: object} = params, fake \\ false) do
253 additional = params[:additional] || %{}
254 # only accept false as false value
255 local = !(params[:local] == false)
256 published = params[:published]
260 %{to: to, actor: actor, published: published, context: context, object: object},
263 {:ok, activity} <- insert(create_data, local, fake),
264 {:fake, false, activity} <- {:fake, fake, activity},
265 _ <- increase_replies_count_if_reply(create_data),
266 _ <- increase_poll_votes_if_vote(create_data),
267 # Changing note count prior to enqueuing federation task in order to avoid
268 # race conditions on updating user.info
269 {:ok, _actor} <- increase_note_count_if_public(actor, activity),
270 :ok <- maybe_federate(activity) do
273 {:fake, true, activity} ->
281 def accept(%{to: to, actor: actor, object: object} = params) do
282 # only accept false as false value
283 local = !(params[:local] == false)
285 with data <- %{"to" => to, "type" => "Accept", "actor" => actor.ap_id, "object" => object},
286 {:ok, activity} <- insert(data, local),
287 :ok <- maybe_federate(activity) do
292 def reject(%{to: to, actor: actor, object: object} = params) do
293 # only accept false as false value
294 local = !(params[:local] == false)
296 with data <- %{"to" => to, "type" => "Reject", "actor" => actor.ap_id, "object" => object},
297 {:ok, activity} <- insert(data, local),
298 :ok <- maybe_federate(activity) do
303 def update(%{to: to, cc: cc, actor: actor, object: object} = params) do
304 # only accept false as false value
305 local = !(params[:local] == false)
314 {:ok, activity} <- insert(data, local),
315 :ok <- maybe_federate(activity) do
320 # TODO: This is weird, maybe we shouldn't check here if we can make the activity.
322 %User{ap_id: ap_id} = user,
323 %Object{data: %{"id" => _}} = object,
327 with nil <- get_existing_like(ap_id, object),
328 like_data <- make_like_data(user, object, activity_id),
329 {:ok, activity} <- insert(like_data, local),
330 {:ok, object} <- add_like_to_object(activity, object),
331 :ok <- maybe_federate(activity) do
332 {:ok, activity, object}
334 %Activity{} = activity -> {:ok, activity, object}
335 error -> {:error, error}
339 def unlike(%User{} = actor, %Object{} = object, activity_id \\ nil, local \\ true) do
340 with %Activity{} = like_activity <- get_existing_like(actor.ap_id, object),
341 unlike_data <- make_unlike_data(actor, like_activity, activity_id),
342 {:ok, unlike_activity} <- insert(unlike_data, local),
343 {:ok, _activity} <- Repo.delete(like_activity),
344 {:ok, object} <- remove_like_from_object(like_activity, object),
345 :ok <- maybe_federate(unlike_activity) do
346 {:ok, unlike_activity, like_activity, object}
353 %User{ap_id: _} = user,
354 %Object{data: %{"id" => _}} = object,
359 with true <- is_public?(object),
360 announce_data <- make_announce_data(user, object, activity_id, public),
361 {:ok, activity} <- insert(announce_data, local),
362 {:ok, object} <- add_announce_to_object(activity, object),
363 :ok <- maybe_federate(activity) do
364 {:ok, activity, object}
366 error -> {:error, error}
376 with %Activity{} = announce_activity <- get_existing_announce(actor.ap_id, object),
377 unannounce_data <- make_unannounce_data(actor, announce_activity, activity_id),
378 {:ok, unannounce_activity} <- insert(unannounce_data, local),
379 :ok <- maybe_federate(unannounce_activity),
380 {:ok, _activity} <- Repo.delete(announce_activity),
381 {:ok, object} <- remove_announce_from_object(announce_activity, object) do
382 {:ok, unannounce_activity, object}
388 def follow(follower, followed, activity_id \\ nil, local \\ true) do
389 with data <- make_follow_data(follower, followed, activity_id),
390 {:ok, activity} <- insert(data, local),
391 :ok <- maybe_federate(activity),
392 _ <- User.set_follow_state_cache(follower.ap_id, followed.ap_id, activity.data["state"]) do
397 def unfollow(follower, followed, activity_id \\ nil, local \\ true) do
398 with %Activity{} = follow_activity <- fetch_latest_follow(follower, followed),
399 {:ok, follow_activity} <- update_follow_state(follow_activity, "cancelled"),
400 unfollow_data <- make_unfollow_data(follower, followed, follow_activity, activity_id),
401 {:ok, activity} <- insert(unfollow_data, local),
402 :ok <- maybe_federate(activity) do
407 def delete(%User{ap_id: ap_id, follower_address: follower_address} = user) do
409 "to" => [follower_address],
412 "object" => %{"type" => "Person", "id" => ap_id}
414 {:ok, activity} <- insert(data, true, true, true),
415 :ok <- maybe_federate(activity) do
420 def delete(%Object{data: %{"id" => id, "actor" => actor}} = object, local \\ true) do
421 user = User.get_cached_by_ap_id(actor)
422 to = (object.data["to"] || []) ++ (object.data["cc"] || [])
424 with {:ok, object, activity} <- Object.delete(object),
430 "deleted_activity_id" => activity && activity.id
432 {:ok, activity} <- insert(data, local, false),
433 stream_out_participations(object, user),
434 _ <- decrease_replies_count_if_reply(object),
435 # Changing note count prior to enqueuing federation task in order to avoid
436 # race conditions on updating user.info
437 {:ok, _actor} <- decrease_note_count_if_public(user, object),
438 :ok <- maybe_federate(activity) do
443 def block(blocker, blocked, activity_id \\ nil, local \\ true) do
444 outgoing_blocks = Config.get([:activitypub, :outgoing_blocks])
445 unfollow_blocked = Config.get([:activitypub, :unfollow_blocked])
447 if unfollow_blocked do
448 follow_activity = fetch_latest_follow(blocker, blocked)
449 if follow_activity, do: unfollow(blocker, blocked, nil, local)
452 with true <- outgoing_blocks,
453 block_data <- make_block_data(blocker, blocked, activity_id),
454 {:ok, activity} <- insert(block_data, local),
455 :ok <- maybe_federate(activity) do
462 def unblock(blocker, blocked, activity_id \\ nil, local \\ true) do
463 with %Activity{} = block_activity <- fetch_latest_block(blocker, blocked),
464 unblock_data <- make_unblock_data(blocker, blocked, block_activity, activity_id),
465 {:ok, activity} <- insert(unblock_data, local),
466 :ok <- maybe_federate(activity) do
480 # only accept false as false value
481 local = !(params[:local] == false)
482 forward = !(params[:forward] == false)
484 additional = params[:additional] || %{}
496 Map.merge(additional, %{"to" => [], "cc" => [account.ap_id]})
498 Map.merge(additional, %{"to" => [], "cc" => []})
501 with flag_data <- make_flag_data(params, additional),
502 {:ok, activity} <- insert(flag_data, local),
503 :ok <- maybe_federate(activity) do
504 Enum.each(User.all_superusers(), fn superuser ->
506 |> Pleroma.Emails.AdminEmail.report(actor, account, statuses, content)
507 |> Pleroma.Emails.Mailer.deliver_async()
514 defp fetch_activities_for_context_query(context, opts) do
515 public = [Pleroma.Constants.as_public()]
518 if opts["user"], do: [opts["user"].ap_id | opts["user"].following] ++ public, else: public
520 from(activity in Activity)
521 |> maybe_preload_objects(opts)
522 |> maybe_preload_bookmarks(opts)
523 |> maybe_set_thread_muted_field(opts)
524 |> restrict_blocked(opts)
525 |> restrict_recipients(recipients, opts["user"])
529 "?->>'type' = ? and ?->>'context' = ?",
536 |> exclude_poll_votes(opts)
538 |> order_by([activity], desc: activity.id)
541 @spec fetch_activities_for_context(String.t(), keyword() | map()) :: [Activity.t()]
542 def fetch_activities_for_context(context, opts \\ %{}) do
544 |> fetch_activities_for_context_query(opts)
548 @spec fetch_latest_activity_id_for_context(String.t(), keyword() | map()) ::
549 Pleroma.FlakeId.t() | nil
550 def fetch_latest_activity_id_for_context(context, opts \\ %{}) do
552 |> fetch_activities_for_context_query(Map.merge(%{"skip_preload" => true}, opts))
558 def fetch_public_activities(opts \\ %{}) do
559 q = fetch_activities_query([Pleroma.Constants.as_public()], opts)
562 |> restrict_unlisted()
563 |> Pagination.fetch_paginated(opts)
567 @valid_visibilities ~w[direct unlisted public private]
569 defp restrict_visibility(query, %{visibility: visibility})
570 when is_list(visibility) do
571 if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
577 "activity_visibility(?, ?, ?) = ANY (?)",
587 Logger.error("Could not restrict visibility to #{visibility}")
591 defp restrict_visibility(query, %{visibility: visibility})
592 when visibility in @valid_visibilities do
596 fragment("activity_visibility(?, ?, ?) = ?", a.actor, a.recipients, a.data, ^visibility)
600 defp restrict_visibility(_query, %{visibility: visibility})
601 when visibility not in @valid_visibilities do
602 Logger.error("Could not restrict visibility to #{visibility}")
605 defp restrict_visibility(query, _visibility), do: query
607 defp restrict_thread_visibility(query, _, %{skip_thread_containment: true} = _),
610 defp restrict_thread_visibility(
612 %{"user" => %User{info: %{skip_thread_containment: true}}},
617 defp restrict_thread_visibility(query, %{"user" => %User{ap_id: ap_id}}, _) do
620 where: fragment("thread_visibility(?, (?)->>'id') = true", ^ap_id, a.data)
624 defp restrict_thread_visibility(query, _, _), do: query
626 def fetch_user_activities(user, reading_user, params \\ %{}) do
629 |> Map.put("type", ["Create", "Announce"])
630 |> Map.put("user", reading_user)
631 |> Map.put("actor_id", user.ap_id)
632 |> Map.put("whole_db", true)
633 |> Map.put("pinned_activity_ids", user.info.pinned_activities)
636 user_activities_recipients(%{
637 "godmode" => params["godmode"],
638 "reading_user" => reading_user
641 fetch_activities(recipients, params)
645 defp user_activities_recipients(%{"godmode" => true}) do
649 defp user_activities_recipients(%{"reading_user" => reading_user}) do
651 [Pleroma.Constants.as_public()] ++ [reading_user.ap_id | reading_user.following]
653 [Pleroma.Constants.as_public()]
657 defp restrict_since(query, %{"since_id" => ""}), do: query
659 defp restrict_since(query, %{"since_id" => since_id}) do
660 from(activity in query, where: activity.id > ^since_id)
663 defp restrict_since(query, _), do: query
665 defp restrict_tag_reject(_query, %{"tag_reject" => _tag_reject, "skip_preload" => true}) do
666 raise "Can't use the child object without preloading!"
669 defp restrict_tag_reject(query, %{"tag_reject" => tag_reject})
670 when is_list(tag_reject) and tag_reject != [] do
672 [_activity, object] in query,
673 where: fragment("not (?)->'tag' \\?| (?)", object.data, ^tag_reject)
677 defp restrict_tag_reject(query, _), do: query
679 defp restrict_tag_all(_query, %{"tag_all" => _tag_all, "skip_preload" => true}) do
680 raise "Can't use the child object without preloading!"
683 defp restrict_tag_all(query, %{"tag_all" => tag_all})
684 when is_list(tag_all) and tag_all != [] do
686 [_activity, object] in query,
687 where: fragment("(?)->'tag' \\?& (?)", object.data, ^tag_all)
691 defp restrict_tag_all(query, _), do: query
693 defp restrict_tag(_query, %{"tag" => _tag, "skip_preload" => true}) do
694 raise "Can't use the child object without preloading!"
697 defp restrict_tag(query, %{"tag" => tag}) when is_list(tag) do
699 [_activity, object] in query,
700 where: fragment("(?)->'tag' \\?| (?)", object.data, ^tag)
704 defp restrict_tag(query, %{"tag" => tag}) when is_binary(tag) do
706 [_activity, object] in query,
707 where: fragment("(?)->'tag' \\? (?)", object.data, ^tag)
711 defp restrict_tag(query, _), do: query
713 defp restrict_recipients(query, [], _user), do: query
715 defp restrict_recipients(query, recipients, nil) do
716 from(activity in query, where: fragment("? && ?", ^recipients, activity.recipients))
719 defp restrict_recipients(query, recipients, user) do
722 where: fragment("? && ?", ^recipients, activity.recipients),
723 or_where: activity.actor == ^user.ap_id
727 defp restrict_local(query, %{"local_only" => true}) do
728 from(activity in query, where: activity.local == true)
731 defp restrict_local(query, _), do: query
733 defp restrict_actor(query, %{"actor_id" => actor_id}) do
734 from(activity in query, where: activity.actor == ^actor_id)
737 defp restrict_actor(query, _), do: query
739 defp restrict_type(query, %{"type" => type}) when is_binary(type) do
740 from(activity in query, where: fragment("?->>'type' = ?", activity.data, ^type))
743 defp restrict_type(query, %{"type" => type}) do
744 from(activity in query, where: fragment("?->>'type' = ANY(?)", activity.data, ^type))
747 defp restrict_type(query, _), do: query
749 defp restrict_state(query, %{"state" => state}) do
750 from(activity in query, where: fragment("?->>'state' = ?", activity.data, ^state))
753 defp restrict_state(query, _), do: query
755 defp restrict_favorited_by(query, %{"favorited_by" => ap_id}) do
757 [_activity, object] in query,
758 where: fragment("(?)->'likes' \\? (?)", object.data, ^ap_id)
762 defp restrict_favorited_by(query, _), do: query
764 defp restrict_media(_query, %{"only_media" => _val, "skip_preload" => true}) do
765 raise "Can't use the child object without preloading!"
768 defp restrict_media(query, %{"only_media" => val}) when val == "true" or val == "1" do
770 [_activity, object] in query,
771 where: fragment("not (?)->'attachment' = (?)", object.data, ^[])
775 defp restrict_media(query, _), do: query
777 defp restrict_replies(query, %{"exclude_replies" => val}) when val == "true" or val == "1" do
780 where: fragment("?->'object'->>'inReplyTo' is null", activity.data)
784 defp restrict_replies(query, _), do: query
786 defp restrict_reblogs(query, %{"exclude_reblogs" => val}) when val == "true" or val == "1" do
787 from(activity in query, where: fragment("?->>'type' != 'Announce'", activity.data))
790 defp restrict_reblogs(query, _), do: query
792 defp restrict_muted(query, %{"with_muted" => val}) when val in [true, "true", "1"], do: query
794 defp restrict_muted(query, %{"muting_user" => %User{info: info}} = opts) do
798 from([activity] in query,
799 where: fragment("not (? = ANY(?))", activity.actor, ^mutes),
800 where: fragment("not (?->'to' \\?| ?)", activity.data, ^mutes)
803 unless opts["skip_preload"] do
804 from([thread_mute: tm] in query, where: is_nil(tm))
810 defp restrict_muted(query, _), do: query
812 defp restrict_blocked(query, %{"blocking_user" => %User{info: info}}) do
813 blocks = info.blocks || []
814 domain_blocks = info.domain_blocks || []
817 if has_named_binding?(query, :object), do: query, else: Activity.with_joined_object(query)
820 [activity, object: o] in query,
821 where: fragment("not (? = ANY(?))", activity.actor, ^blocks),
822 where: fragment("not (? && ?)", activity.recipients, ^blocks),
825 "not (?->>'type' = 'Announce' and ?->'to' \\?| ?)",
830 where: fragment("not (split_part(?, '/', 3) = ANY(?))", activity.actor, ^domain_blocks),
831 where: fragment("not (split_part(?->>'actor', '/', 3) = ANY(?))", o.data, ^domain_blocks)
835 defp restrict_blocked(query, _), do: query
837 defp restrict_unlisted(query) do
842 "not (coalesce(?->'cc', '{}'::jsonb) \\?| ?)",
844 ^[Pleroma.Constants.as_public()]
849 defp restrict_pinned(query, %{"pinned" => "true", "pinned_activity_ids" => ids}) do
850 from(activity in query, where: activity.id in ^ids)
853 defp restrict_pinned(query, _), do: query
855 defp restrict_muted_reblogs(query, %{"muting_user" => %User{info: info}}) do
856 muted_reblogs = info.muted_reblogs || []
862 "not ( ?->>'type' = 'Announce' and ? = ANY(?))",
870 defp restrict_muted_reblogs(query, _), do: query
872 defp exclude_poll_votes(query, %{"include_poll_votes" => "true"}), do: query
874 defp exclude_poll_votes(query, _) do
875 if has_named_binding?(query, :object) do
876 from([activity, object: o] in query,
877 where: fragment("not(?->>'type' = ?)", o.data, "Answer")
884 defp exclude_id(query, %{"exclude_id" => id}) when is_binary(id) do
885 from(activity in query, where: activity.id != ^id)
888 defp exclude_id(query, _), do: query
890 defp maybe_preload_objects(query, %{"skip_preload" => true}), do: query
892 defp maybe_preload_objects(query, _) do
894 |> Activity.with_preloaded_object()
897 defp maybe_preload_bookmarks(query, %{"skip_preload" => true}), do: query
899 defp maybe_preload_bookmarks(query, opts) do
901 |> Activity.with_preloaded_bookmark(opts["user"])
904 defp maybe_set_thread_muted_field(query, %{"skip_preload" => true}), do: query
906 defp maybe_set_thread_muted_field(query, opts) do
908 |> Activity.with_set_thread_muted_field(opts["muting_user"] || opts["user"])
911 defp maybe_order(query, %{order: :desc}) do
913 |> order_by(desc: :id)
916 defp maybe_order(query, %{order: :asc}) do
918 |> order_by(asc: :id)
921 defp maybe_order(query, _), do: query
923 def fetch_activities_query(recipients, opts \\ %{}) do
925 skip_thread_containment: Config.get([:instance, :skip_thread_containment])
929 |> maybe_preload_objects(opts)
930 |> maybe_preload_bookmarks(opts)
931 |> maybe_set_thread_muted_field(opts)
933 |> restrict_recipients(recipients, opts["user"])
934 |> restrict_tag(opts)
935 |> restrict_tag_reject(opts)
936 |> restrict_tag_all(opts)
937 |> restrict_since(opts)
938 |> restrict_local(opts)
939 |> restrict_actor(opts)
940 |> restrict_type(opts)
941 |> restrict_state(opts)
942 |> restrict_favorited_by(opts)
943 |> restrict_blocked(opts)
944 |> restrict_muted(opts)
945 |> restrict_media(opts)
946 |> restrict_visibility(opts)
947 |> restrict_thread_visibility(opts, config)
948 |> restrict_replies(opts)
949 |> restrict_reblogs(opts)
950 |> restrict_pinned(opts)
951 |> restrict_muted_reblogs(opts)
952 |> Activity.restrict_deactivated_users()
953 |> exclude_poll_votes(opts)
956 def fetch_activities(recipients, opts \\ %{}) do
957 list_memberships = Pleroma.List.memberships(opts["user"])
959 fetch_activities_query(recipients ++ list_memberships, opts)
960 |> Pagination.fetch_paginated(opts)
962 |> maybe_update_cc(list_memberships, opts["user"])
965 defp maybe_update_cc(activities, list_memberships, %User{ap_id: user_ap_id})
966 when is_list(list_memberships) and length(list_memberships) > 0 do
967 Enum.map(activities, fn
968 %{data: %{"bcc" => bcc}} = activity when is_list(bcc) and length(bcc) > 0 ->
969 if Enum.any?(bcc, &(&1 in list_memberships)) do
970 update_in(activity.data["cc"], &[user_ap_id | &1])
980 defp maybe_update_cc(activities, _, _), do: activities
982 def fetch_activities_bounded_query(query, recipients, recipients_with_public) do
983 from(activity in query,
985 fragment("? && ?", activity.recipients, ^recipients) or
986 (fragment("? && ?", activity.recipients, ^recipients_with_public) and
987 ^Pleroma.Constants.as_public() in activity.recipients)
991 def fetch_activities_bounded(recipients, recipients_with_public, opts \\ %{}) do
992 fetch_activities_query([], opts)
993 |> fetch_activities_bounded_query(recipients, recipients_with_public)
994 |> Pagination.fetch_paginated(opts)
998 def upload(file, opts \\ []) do
999 with {:ok, data} <- Upload.store(file, opts) do
1002 Map.put(data, "actor", opts[:actor])
1007 Repo.insert(%Object{data: obj_data})
1011 defp object_to_user_data(data) do
1013 data["icon"]["url"] &&
1016 "url" => [%{"href" => data["icon"]["url"]}]
1020 data["image"]["url"] &&
1023 "url" => [%{"href" => data["image"]["url"]}]
1028 |> Map.get("attachment", [])
1029 |> Enum.filter(fn %{"type" => t} -> t == "PropertyValue" end)
1030 |> Enum.map(fn fields -> Map.take(fields, ["name", "value"]) end)
1032 locked = data["manuallyApprovesFollowers"] || false
1033 data = Transmogrifier.maybe_fix_user_object(data)
1046 follower_address: data["followers"],
1047 following_address: data["following"],
1048 bio: data["summary"]
1051 # nickname can be nil because of virtual actors
1053 if data["preferredUsername"] do
1057 "#{data["preferredUsername"]}@#{URI.parse(data["id"]).host}"
1060 Map.put(user_data, :nickname, nil)
1066 def fetch_follow_information_for_user(user) do
1067 with {:ok, following_data} <-
1068 Fetcher.fetch_and_contain_remote_object_from_id(user.following_address),
1069 following_count when is_integer(following_count) <- following_data["totalItems"],
1070 {:ok, hide_follows} <- collection_private(following_data),
1071 {:ok, followers_data} <-
1072 Fetcher.fetch_and_contain_remote_object_from_id(user.follower_address),
1073 followers_count when is_integer(followers_count) <- followers_data["totalItems"],
1074 {:ok, hide_followers} <- collection_private(followers_data) do
1077 hide_follows: hide_follows,
1078 follower_count: followers_count,
1079 following_count: following_count,
1080 hide_followers: hide_followers
1091 defp maybe_update_follow_information(data) do
1092 with {:enabled, true} <-
1093 {:enabled, Pleroma.Config.get([:instance, :external_user_synchronization])},
1094 {:ok, info} <- fetch_follow_information_for_user(data) do
1095 info = Map.merge(data.info, info)
1096 Map.put(data, :info, info)
1098 {:enabled, false} ->
1103 "Follower/Following counter update for #{data.ap_id} failed.\n" <> inspect(e)
1110 defp collection_private(data) do
1111 if is_map(data["first"]) and
1112 data["first"]["type"] in ["CollectionPage", "OrderedCollectionPage"] do
1115 with {:ok, %{"type" => type}} when type in ["CollectionPage", "OrderedCollectionPage"] <-
1116 Fetcher.fetch_and_contain_remote_object_from_id(data["first"]) do
1119 {:error, {:ok, %{status: code}}} when code in [401, 403] ->
1131 def user_data_from_user_object(data) do
1132 with {:ok, data} <- MRF.filter(data),
1133 {:ok, data} <- object_to_user_data(data) do
1140 def fetch_and_prepare_user_from_ap_id(ap_id) do
1141 with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id),
1142 {:ok, data} <- user_data_from_user_object(data),
1143 data <- maybe_update_follow_information(data) do
1146 e -> Logger.error("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
1150 def make_user_from_ap_id(ap_id) do
1151 if _user = User.get_cached_by_ap_id(ap_id) do
1152 Transmogrifier.upgrade_user_from_ap_id(ap_id)
1154 with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id) do
1155 User.insert_or_update_user(data)
1162 def make_user_from_nickname(nickname) do
1163 with {:ok, %{"ap_id" => ap_id}} when not is_nil(ap_id) <- WebFinger.finger(nickname) do
1164 make_user_from_ap_id(ap_id)
1166 _e -> {:error, "No AP id in WebFinger"}
1170 # filter out broken threads
1171 def contain_broken_threads(%Activity{} = activity, %User{} = user) do
1172 entire_thread_visible_for_user?(activity, user)
1175 # do post-processing on a specific activity
1176 def contain_activity(%Activity{} = activity, %User{} = user) do
1177 contain_broken_threads(activity, user)
1180 def fetch_direct_messages_query do
1182 |> restrict_type(%{"type" => "Create"})
1183 |> restrict_visibility(%{visibility: "direct"})
1184 |> order_by([activity], asc: activity.id)