1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2020 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.Constants
10 alias Pleroma.Conversation
11 alias Pleroma.Conversation.Participation
12 alias Pleroma.Notification
14 alias Pleroma.Object.Containment
15 alias Pleroma.Object.Fetcher
16 alias Pleroma.Pagination
20 alias Pleroma.Web.ActivityPub.MRF
21 alias Pleroma.Web.ActivityPub.Transmogrifier
22 alias Pleroma.Web.ActivityPub.Utils
23 alias Pleroma.Web.Streamer
24 alias Pleroma.Web.WebFinger
25 alias Pleroma.Workers.BackgroundWorker
28 import Pleroma.Web.ActivityPub.Utils
29 import Pleroma.Web.ActivityPub.Visibility
32 require Pleroma.Constants
34 # For Announce activities, we filter the recipients based on following status for any actors
35 # that match actual users. See issue #164 for more information about why this is necessary.
36 defp get_recipients(%{"type" => "Announce"} = data) do
37 to = Map.get(data, "to", [])
38 cc = Map.get(data, "cc", [])
39 bcc = Map.get(data, "bcc", [])
40 actor = User.get_cached_by_ap_id(data["actor"])
43 Enum.filter(Enum.concat([to, cc, bcc]), fn recipient ->
44 case User.get_cached_by_ap_id(recipient) do
46 user -> User.following?(user, actor)
53 defp get_recipients(%{"type" => "Create"} = data) do
54 to = Map.get(data, "to", [])
55 cc = Map.get(data, "cc", [])
56 bcc = Map.get(data, "bcc", [])
57 actor = Map.get(data, "actor", [])
58 recipients = [to, cc, bcc, [actor]] |> Enum.concat() |> Enum.uniq()
62 defp get_recipients(data) do
63 to = Map.get(data, "to", [])
64 cc = Map.get(data, "cc", [])
65 bcc = Map.get(data, "bcc", [])
66 recipients = Enum.concat([to, cc, bcc])
70 defp check_actor_is_active(actor) do
71 if not is_nil(actor) do
72 with user <- User.get_cached_by_ap_id(actor),
73 false <- user.deactivated do
83 defp check_remote_limit(%{"object" => %{"content" => content}}) when not is_nil(content) do
84 limit = Config.get([:instance, :remote_limit])
85 String.length(content) <= limit
88 defp check_remote_limit(_), do: true
90 def increase_note_count_if_public(actor, object) do
91 if is_public?(object), do: User.increase_note_count(actor), else: {:ok, actor}
94 def decrease_note_count_if_public(actor, object) do
95 if is_public?(object), do: User.decrease_note_count(actor), else: {:ok, actor}
98 def increase_replies_count_if_reply(%{
99 "object" => %{"inReplyTo" => reply_ap_id} = object,
102 if is_public?(object) do
103 Object.increase_replies_count(reply_ap_id)
107 def increase_replies_count_if_reply(_create_data), do: :noop
109 def decrease_replies_count_if_reply(%Object{
110 data: %{"inReplyTo" => reply_ap_id} = object
112 if is_public?(object) do
113 Object.decrease_replies_count(reply_ap_id)
117 def decrease_replies_count_if_reply(_object), do: :noop
119 def increase_poll_votes_if_vote(%{
120 "object" => %{"inReplyTo" => reply_ap_id, "name" => name},
124 Object.increase_vote_count(reply_ap_id, name, actor)
127 def increase_poll_votes_if_vote(_create_data), do: :noop
129 @spec persist(map(), keyword()) :: {:ok, Activity.t() | Object.t()}
130 def persist(object, meta) do
131 with local <- Keyword.fetch!(meta, :local),
132 {recipients, _, _} <- get_recipients(object),
134 Repo.insert(%Activity{
137 recipients: recipients,
138 actor: object["actor"]
140 {:ok, activity, meta}
144 @spec insert(map(), boolean(), boolean(), boolean()) :: {:ok, Activity.t()} | {:error, any()}
145 def insert(map, local \\ true, fake \\ false, bypass_actor_check \\ false) when is_map(map) do
146 with nil <- Activity.normalize(map),
147 map <- lazy_put_activity_defaults(map, fake),
148 true <- bypass_actor_check || check_actor_is_active(map["actor"]),
149 {_, true} <- {:remote_limit_error, check_remote_limit(map)},
150 {:ok, map} <- MRF.filter(map),
151 {recipients, _, _} = get_recipients(map),
152 {:fake, false, map, recipients} <- {:fake, fake, map, recipients},
153 {:containment, :ok} <- {:containment, Containment.contain_child(map)},
154 {:ok, map, object} <- insert_full_object(map) do
156 Repo.insert(%Activity{
160 recipients: recipients
163 # Splice in the child object if we have one.
165 if not is_nil(object) do
166 Map.put(activity, :object, object)
171 BackgroundWorker.enqueue("fetch_data_for_activity", %{"activity_id" => activity.id})
173 Notification.create_notifications(activity)
175 conversation = create_or_bump_conversation(activity, map["actor"])
176 participations = get_participations(conversation)
178 stream_out_participations(participations)
181 %Activity{} = activity ->
184 {:fake, true, map, recipients} ->
185 activity = %Activity{
189 recipients: recipients,
193 Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
201 defp create_or_bump_conversation(activity, actor) do
202 with {:ok, conversation} <- Conversation.create_or_bump_for(activity),
203 %User{} = user <- User.get_cached_by_ap_id(actor),
204 Participation.mark_as_read(user, conversation) do
209 defp get_participations({:ok, conversation}) do
211 |> Repo.preload(:participations, force: true)
212 |> Map.get(:participations)
215 defp get_participations(_), do: []
217 def stream_out_participations(participations) do
220 |> Repo.preload(:user)
222 Streamer.stream("participation", participations)
225 def stream_out_participations(%Object{data: %{"context" => context}}, user) do
226 with %Conversation{} = conversation <- Conversation.get_for_ap_id(context),
227 conversation = Repo.preload(conversation, :participations),
229 fetch_latest_activity_id_for_context(conversation.ap_id, %{
231 "blocking_user" => user
233 if last_activity_id do
234 stream_out_participations(conversation.participations)
239 def stream_out_participations(_, _), do: :noop
241 def stream_out(%Activity{data: %{"type" => data_type}} = activity)
242 when data_type in ["Create", "Announce", "Delete"] do
244 |> Topics.get_activity_topics()
245 |> Streamer.stream(activity)
248 def stream_out(_activity) do
252 @spec create(map(), boolean()) :: {:ok, Activity.t()} | {:error, any()}
253 def create(params, fake \\ false) do
254 with {:ok, result} <- Repo.transaction(fn -> do_create(params, fake) end) do
259 defp do_create(%{to: to, actor: actor, context: context, object: object} = params, fake) do
260 additional = params[:additional] || %{}
261 # only accept false as false value
262 local = !(params[:local] == false)
263 published = params[:published]
264 quick_insert? = Config.get([:env]) == :benchmark
268 %{to: to, actor: actor, published: published, context: context, object: object},
271 {:ok, activity} <- insert(create_data, local, fake),
272 {:fake, false, activity} <- {:fake, fake, activity},
273 _ <- increase_replies_count_if_reply(create_data),
274 _ <- increase_poll_votes_if_vote(create_data),
275 {:quick_insert, false, activity} <- {:quick_insert, quick_insert?, activity},
276 {:ok, _actor} <- increase_note_count_if_public(actor, activity),
277 :ok <- maybe_federate(activity) do
280 {:quick_insert, true, activity} ->
283 {:fake, true, activity} ->
287 Repo.rollback(message)
291 @spec listen(map()) :: {:ok, Activity.t()} | {:error, any()}
292 def listen(%{to: to, actor: actor, context: context, object: object} = params) do
293 additional = params[:additional] || %{}
294 # only accept false as false value
295 local = !(params[:local] == false)
296 published = params[:published]
300 %{to: to, actor: actor, published: published, context: context, object: object},
303 {:ok, activity} <- insert(listen_data, local),
304 :ok <- maybe_federate(activity) do
309 @spec accept(map()) :: {:ok, Activity.t()} | {:error, any()}
310 def accept(params) do
311 accept_or_reject("Accept", params)
314 @spec reject(map()) :: {:ok, Activity.t()} | {:error, any()}
315 def reject(params) do
316 accept_or_reject("Reject", params)
319 @spec accept_or_reject(String.t(), map()) :: {:ok, Activity.t()} | {:error, any()}
320 def accept_or_reject(type, %{to: to, actor: actor, object: object} = params) do
321 local = Map.get(params, :local, true)
322 activity_id = Map.get(params, :activity_id, nil)
325 %{"to" => to, "type" => type, "actor" => actor.ap_id, "object" => object}
326 |> Utils.maybe_put("id", activity_id),
327 {:ok, activity} <- insert(data, local),
328 :ok <- maybe_federate(activity) do
333 @spec update(map()) :: {:ok, Activity.t()} | {:error, any()}
334 def update(%{to: to, cc: cc, actor: actor, object: object} = params) do
335 local = !(params[:local] == false)
336 activity_id = params[:activity_id]
345 data <- Utils.maybe_put(data, "id", activity_id),
346 {:ok, activity} <- insert(data, local),
347 :ok <- maybe_federate(activity) do
352 @spec react_with_emoji(User.t(), Object.t(), String.t(), keyword()) ::
353 {:ok, Activity.t(), Object.t()} | {:error, any()}
354 def react_with_emoji(user, object, emoji, options \\ []) do
355 with {:ok, result} <-
356 Repo.transaction(fn -> do_react_with_emoji(user, object, emoji, options) end) do
361 defp do_react_with_emoji(user, object, emoji, options) do
362 with local <- Keyword.get(options, :local, true),
363 activity_id <- Keyword.get(options, :activity_id, nil),
364 true <- Pleroma.Emoji.is_unicode_emoji?(emoji),
365 reaction_data <- make_emoji_reaction_data(user, object, emoji, activity_id),
366 {:ok, activity} <- insert(reaction_data, local),
367 {:ok, object} <- add_emoji_reaction_to_object(activity, object),
368 :ok <- maybe_federate(activity) do
369 {:ok, activity, object}
371 false -> {:error, false}
372 {:error, error} -> Repo.rollback(error)
376 @spec unreact_with_emoji(User.t(), String.t(), keyword()) ::
377 {:ok, Activity.t(), Object.t()} | {:error, any()}
378 def unreact_with_emoji(user, reaction_id, options \\ []) do
379 with {:ok, result} <-
380 Repo.transaction(fn -> do_unreact_with_emoji(user, reaction_id, options) end) do
385 defp do_unreact_with_emoji(user, reaction_id, options) do
386 with local <- Keyword.get(options, :local, true),
387 activity_id <- Keyword.get(options, :activity_id, nil),
388 user_ap_id <- user.ap_id,
389 %Activity{actor: ^user_ap_id} = reaction_activity <- Activity.get_by_ap_id(reaction_id),
390 object <- Object.normalize(reaction_activity),
391 unreact_data <- make_undo_data(user, reaction_activity, activity_id),
392 {:ok, activity} <- insert(unreact_data, local),
393 {:ok, object} <- remove_emoji_reaction_from_object(reaction_activity, object),
394 :ok <- maybe_federate(activity) do
395 {:ok, activity, object}
397 {:error, error} -> Repo.rollback(error)
401 @spec unlike(User.t(), Object.t(), String.t() | nil, boolean()) ::
402 {:ok, Activity.t(), Activity.t(), Object.t()} | {:ok, Object.t()} | {:error, any()}
403 def unlike(%User{} = actor, %Object{} = object, activity_id \\ nil, local \\ true) do
404 with {:ok, result} <-
405 Repo.transaction(fn -> do_unlike(actor, object, activity_id, local) end) do
410 defp do_unlike(actor, object, activity_id, local) do
411 with %Activity{} = like_activity <- get_existing_like(actor.ap_id, object),
412 unlike_data <- make_unlike_data(actor, like_activity, activity_id),
413 {:ok, unlike_activity} <- insert(unlike_data, local),
414 {:ok, _activity} <- Repo.delete(like_activity),
415 {:ok, object} <- remove_like_from_object(like_activity, object),
416 :ok <- maybe_federate(unlike_activity) do
417 {:ok, unlike_activity, like_activity, object}
420 {:error, error} -> Repo.rollback(error)
424 @spec announce(User.t(), Object.t(), String.t() | nil, boolean(), boolean()) ::
425 {:ok, Activity.t(), Object.t()} | {:error, any()}
427 %User{ap_id: _} = user,
428 %Object{data: %{"id" => _}} = object,
433 with {:ok, result} <-
434 Repo.transaction(fn -> do_announce(user, object, activity_id, local, public) end) do
439 defp do_announce(user, object, activity_id, local, public) do
440 with true <- is_announceable?(object, user, public),
441 object <- Object.get_by_id(object.id),
442 announce_data <- make_announce_data(user, object, activity_id, public),
443 {:ok, activity} <- insert(announce_data, local),
444 {:ok, object} <- add_announce_to_object(activity, object),
445 :ok <- maybe_federate(activity) do
446 {:ok, activity, object}
448 false -> {:error, false}
449 {:error, error} -> Repo.rollback(error)
453 @spec unannounce(User.t(), Object.t(), String.t() | nil, boolean()) ::
454 {:ok, Activity.t(), Object.t()} | {:ok, Object.t()} | {:error, any()}
461 with {:ok, result} <-
462 Repo.transaction(fn -> do_unannounce(actor, object, activity_id, local) end) do
467 defp do_unannounce(actor, object, activity_id, local) do
468 with %Activity{} = announce_activity <- get_existing_announce(actor.ap_id, object),
469 unannounce_data <- make_unannounce_data(actor, announce_activity, activity_id),
470 {:ok, unannounce_activity} <- insert(unannounce_data, local),
471 :ok <- maybe_federate(unannounce_activity),
472 {:ok, _activity} <- Repo.delete(announce_activity),
473 {:ok, object} <- remove_announce_from_object(announce_activity, object) do
474 {:ok, unannounce_activity, object}
477 {:error, error} -> Repo.rollback(error)
481 @spec follow(User.t(), User.t(), String.t() | nil, boolean()) ::
482 {:ok, Activity.t()} | {:error, any()}
483 def follow(follower, followed, activity_id \\ nil, local \\ true) do
484 with {:ok, result} <-
485 Repo.transaction(fn -> do_follow(follower, followed, activity_id, local) end) do
490 defp do_follow(follower, followed, activity_id, local) do
491 with data <- make_follow_data(follower, followed, activity_id),
492 {:ok, activity} <- insert(data, local),
493 :ok <- maybe_federate(activity) do
496 {:error, error} -> Repo.rollback(error)
500 @spec unfollow(User.t(), User.t(), String.t() | nil, boolean()) ::
501 {:ok, Activity.t()} | nil | {:error, any()}
502 def unfollow(follower, followed, activity_id \\ nil, local \\ true) do
503 with {:ok, result} <-
504 Repo.transaction(fn -> do_unfollow(follower, followed, activity_id, local) end) do
509 defp do_unfollow(follower, followed, activity_id, local) do
510 with %Activity{} = follow_activity <- fetch_latest_follow(follower, followed),
511 {:ok, follow_activity} <- update_follow_state(follow_activity, "cancelled"),
512 unfollow_data <- make_unfollow_data(follower, followed, follow_activity, activity_id),
513 {:ok, activity} <- insert(unfollow_data, local),
514 :ok <- maybe_federate(activity) do
518 {:error, error} -> Repo.rollback(error)
522 @spec delete(User.t() | Object.t(), keyword()) :: {:ok, User.t() | Object.t()} | {:error, any()}
523 def delete(entity, options \\ []) do
524 with {:ok, result} <- Repo.transaction(fn -> do_delete(entity, options) end) do
529 defp do_delete(%User{ap_id: ap_id, follower_address: follower_address} = user, _) do
531 "to" => [follower_address],
534 "object" => %{"type" => "Person", "id" => ap_id}
536 {:ok, activity} <- insert(data, true, true, true),
537 :ok <- maybe_federate(activity) do
542 defp do_delete(%Object{data: %{"id" => id, "actor" => actor}} = object, options) do
543 local = Keyword.get(options, :local, true)
544 activity_id = Keyword.get(options, :activity_id, nil)
545 actor = Keyword.get(options, :actor, actor)
547 user = User.get_cached_by_ap_id(actor)
548 to = (object.data["to"] || []) ++ (object.data["cc"] || [])
550 with create_activity <- Activity.get_create_by_object_ap_id(id),
557 "deleted_activity_id" => create_activity && create_activity.id
559 |> maybe_put("id", activity_id),
560 {:ok, activity} <- insert(data, local, false),
561 {:ok, object, _create_activity} <- Object.delete(object),
562 stream_out_participations(object, user),
563 _ <- decrease_replies_count_if_reply(object),
564 {:ok, _actor} <- decrease_note_count_if_public(user, object),
565 :ok <- maybe_federate(activity) do
573 defp do_delete(%Object{data: %{"type" => "Tombstone", "id" => ap_id}}, _) do
576 |> Activity.Queries.by_object_id()
577 |> Activity.Queries.by_type("Delete")
583 @spec block(User.t(), User.t(), String.t() | nil, boolean()) ::
584 {:ok, Activity.t()} | {:error, any()}
585 def block(blocker, blocked, activity_id \\ nil, local \\ true) do
586 with {:ok, result} <-
587 Repo.transaction(fn -> do_block(blocker, blocked, activity_id, local) end) do
592 defp do_block(blocker, blocked, activity_id, local) do
593 outgoing_blocks = Config.get([:activitypub, :outgoing_blocks])
594 unfollow_blocked = Config.get([:activitypub, :unfollow_blocked])
596 if unfollow_blocked do
597 follow_activity = fetch_latest_follow(blocker, blocked)
598 if follow_activity, do: unfollow(blocker, blocked, nil, local)
601 with true <- outgoing_blocks,
602 block_data <- make_block_data(blocker, blocked, activity_id),
603 {:ok, activity} <- insert(block_data, local),
604 :ok <- maybe_federate(activity) do
607 {:error, error} -> Repo.rollback(error)
611 @spec unblock(User.t(), User.t(), String.t() | nil, boolean()) ::
612 {:ok, Activity.t()} | {:error, any()} | nil
613 def unblock(blocker, blocked, activity_id \\ nil, local \\ true) do
614 with {:ok, result} <-
615 Repo.transaction(fn -> do_unblock(blocker, blocked, activity_id, local) end) do
620 defp do_unblock(blocker, blocked, activity_id, local) do
621 with %Activity{} = block_activity <- fetch_latest_block(blocker, blocked),
622 unblock_data <- make_unblock_data(blocker, blocked, block_activity, activity_id),
623 {:ok, activity} <- insert(unblock_data, local),
624 :ok <- maybe_federate(activity) do
628 {:error, error} -> Repo.rollback(error)
632 @spec flag(map()) :: {:ok, Activity.t()} | {:error, any()}
642 # only accept false as false value
643 local = !(params[:local] == false)
644 forward = !(params[:forward] == false)
646 additional = params[:additional] || %{}
650 Map.merge(additional, %{"to" => [], "cc" => [account.ap_id]})
652 Map.merge(additional, %{"to" => [], "cc" => []})
655 with flag_data <- make_flag_data(params, additional),
656 {:ok, activity} <- insert(flag_data, local),
657 {:ok, stripped_activity} <- strip_report_status_data(activity),
658 :ok <- maybe_federate(stripped_activity) do
659 User.all_superusers()
660 |> Enum.filter(fn user -> not is_nil(user.email) end)
661 |> Enum.each(fn superuser ->
663 |> Pleroma.Emails.AdminEmail.report(actor, account, statuses, content)
664 |> Pleroma.Emails.Mailer.deliver_async()
671 @spec move(User.t(), User.t(), boolean()) :: {:ok, Activity.t()} | {:error, any()}
672 def move(%User{} = origin, %User{} = target, local \\ true) do
675 "actor" => origin.ap_id,
676 "object" => origin.ap_id,
677 "target" => target.ap_id
680 with true <- origin.ap_id in target.also_known_as,
681 {:ok, activity} <- insert(params, local) do
682 maybe_federate(activity)
684 BackgroundWorker.enqueue("move_following", %{
685 "origin_id" => origin.id,
686 "target_id" => target.id
691 false -> {:error, "Target account must have the origin in `alsoKnownAs`"}
696 def fetch_activities_for_context_query(context, opts) do
697 public = [Constants.as_public()]
701 do: [opts["user"].ap_id | User.following(opts["user"])] ++ public,
704 from(activity in Activity)
705 |> maybe_preload_objects(opts)
706 |> maybe_preload_bookmarks(opts)
707 |> maybe_set_thread_muted_field(opts)
708 |> restrict_blocked(opts)
709 |> restrict_recipients(recipients, opts["user"])
713 "?->>'type' = ? and ?->>'context' = ?",
720 |> exclude_poll_votes(opts)
722 |> order_by([activity], desc: activity.id)
725 @spec fetch_activities_for_context(String.t(), keyword() | map()) :: [Activity.t()]
726 def fetch_activities_for_context(context, opts \\ %{}) do
728 |> fetch_activities_for_context_query(opts)
732 @spec fetch_latest_activity_id_for_context(String.t(), keyword() | map()) ::
733 FlakeId.Ecto.CompatType.t() | nil
734 def fetch_latest_activity_id_for_context(context, opts \\ %{}) do
736 |> fetch_activities_for_context_query(Map.merge(%{"skip_preload" => true}, opts))
742 @spec fetch_public_activities(map(), Pagination.type()) :: [Activity.t()]
743 def fetch_public_activities(opts \\ %{}, pagination \\ :keyset) do
744 opts = Map.drop(opts, ["user"])
746 [Constants.as_public()]
747 |> fetch_activities_query(opts)
748 |> restrict_unlisted()
749 |> Pagination.fetch_paginated(opts, pagination)
752 @valid_visibilities ~w[direct unlisted public private]
754 defp restrict_visibility(query, %{visibility: visibility})
755 when is_list(visibility) do
756 if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
762 "activity_visibility(?, ?, ?) = ANY (?)",
772 Logger.error("Could not restrict visibility to #{visibility}")
776 defp restrict_visibility(query, %{visibility: visibility})
777 when visibility in @valid_visibilities do
781 fragment("activity_visibility(?, ?, ?) = ?", a.actor, a.recipients, a.data, ^visibility)
785 defp restrict_visibility(_query, %{visibility: visibility})
786 when visibility not in @valid_visibilities do
787 Logger.error("Could not restrict visibility to #{visibility}")
790 defp restrict_visibility(query, _visibility), do: query
792 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
793 when is_list(visibility) do
794 if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
799 "activity_visibility(?, ?, ?) = ANY (?)",
807 Logger.error("Could not exclude visibility to #{visibility}")
812 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
813 when visibility in @valid_visibilities do
818 "activity_visibility(?, ?, ?) = ?",
827 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
828 when visibility not in @valid_visibilities do
829 Logger.error("Could not exclude visibility to #{visibility}")
833 defp exclude_visibility(query, _visibility), do: query
835 defp restrict_thread_visibility(query, _, %{skip_thread_containment: true} = _),
838 defp restrict_thread_visibility(
840 %{"user" => %User{skip_thread_containment: true}},
845 defp restrict_thread_visibility(query, %{"user" => %User{ap_id: ap_id}}, _) do
848 where: fragment("thread_visibility(?, (?)->>'id') = true", ^ap_id, a.data)
852 defp restrict_thread_visibility(query, _, _), do: query
854 def fetch_user_abstract_activities(user, reading_user, params \\ %{}) do
857 |> Map.put("user", reading_user)
858 |> Map.put("actor_id", user.ap_id)
861 user_activities_recipients(%{
862 "godmode" => params["godmode"],
863 "reading_user" => reading_user
866 fetch_activities(recipients, params)
870 def fetch_user_activities(user, reading_user, params \\ %{}) do
873 |> Map.put("type", ["Create", "Announce"])
874 |> Map.put("user", reading_user)
875 |> Map.put("actor_id", user.ap_id)
876 |> Map.put("pinned_activity_ids", user.pinned_activities)
879 if User.blocks?(reading_user, user) do
883 |> Map.put("blocking_user", reading_user)
884 |> Map.put("muting_user", reading_user)
888 user_activities_recipients(%{
889 "godmode" => params["godmode"],
890 "reading_user" => reading_user
893 fetch_activities(recipients, params)
897 def fetch_statuses(reading_user, params) do
900 |> Map.put("type", ["Create", "Announce"])
903 user_activities_recipients(%{
904 "godmode" => params["godmode"],
905 "reading_user" => reading_user
908 fetch_activities(recipients, params, :offset)
912 defp user_activities_recipients(%{"godmode" => true}) do
916 defp user_activities_recipients(%{"reading_user" => reading_user}) do
918 [Constants.as_public()] ++ [reading_user.ap_id | User.following(reading_user)]
920 [Constants.as_public()]
924 defp restrict_since(query, %{"since_id" => ""}), do: query
926 defp restrict_since(query, %{"since_id" => since_id}) do
927 from(activity in query, where: activity.id > ^since_id)
930 defp restrict_since(query, _), do: query
932 defp restrict_tag_reject(_query, %{"tag_reject" => _tag_reject, "skip_preload" => true}) do
933 raise "Can't use the child object without preloading!"
936 defp restrict_tag_reject(query, %{"tag_reject" => tag_reject})
937 when is_list(tag_reject) and tag_reject != [] do
939 [_activity, object] in query,
940 where: fragment("not (?)->'tag' \\?| (?)", object.data, ^tag_reject)
944 defp restrict_tag_reject(query, _), do: query
946 defp restrict_tag_all(_query, %{"tag_all" => _tag_all, "skip_preload" => true}) do
947 raise "Can't use the child object without preloading!"
950 defp restrict_tag_all(query, %{"tag_all" => tag_all})
951 when is_list(tag_all) and tag_all != [] do
953 [_activity, object] in query,
954 where: fragment("(?)->'tag' \\?& (?)", object.data, ^tag_all)
958 defp restrict_tag_all(query, _), do: query
960 defp restrict_tag(_query, %{"tag" => _tag, "skip_preload" => true}) do
961 raise "Can't use the child object without preloading!"
964 defp restrict_tag(query, %{"tag" => tag}) when is_list(tag) do
966 [_activity, object] in query,
967 where: fragment("(?)->'tag' \\?| (?)", object.data, ^tag)
971 defp restrict_tag(query, %{"tag" => tag}) when is_binary(tag) do
973 [_activity, object] in query,
974 where: fragment("(?)->'tag' \\? (?)", object.data, ^tag)
978 defp restrict_tag(query, _), do: query
980 defp restrict_recipients(query, [], _user), do: query
982 defp restrict_recipients(query, recipients, nil) do
983 from(activity in query, where: fragment("? && ?", ^recipients, activity.recipients))
986 defp restrict_recipients(query, recipients, user) do
989 where: fragment("? && ?", ^recipients, activity.recipients),
990 or_where: activity.actor == ^user.ap_id
994 defp restrict_local(query, %{"local_only" => true}) do
995 from(activity in query, where: activity.local == true)
998 defp restrict_local(query, _), do: query
1000 defp restrict_actor(query, %{"actor_id" => actor_id}) do
1001 from(activity in query, where: activity.actor == ^actor_id)
1004 defp restrict_actor(query, _), do: query
1006 defp restrict_type(query, %{"type" => type}) when is_binary(type) do
1007 from(activity in query, where: fragment("?->>'type' = ?", activity.data, ^type))
1010 defp restrict_type(query, %{"type" => type}) do
1011 from(activity in query, where: fragment("?->>'type' = ANY(?)", activity.data, ^type))
1014 defp restrict_type(query, _), do: query
1016 defp restrict_state(query, %{"state" => state}) do
1017 from(activity in query, where: fragment("?->>'state' = ?", activity.data, ^state))
1020 defp restrict_state(query, _), do: query
1022 defp restrict_favorited_by(query, %{"favorited_by" => ap_id}) do
1024 [_activity, object] in query,
1025 where: fragment("(?)->'likes' \\? (?)", object.data, ^ap_id)
1029 defp restrict_favorited_by(query, _), do: query
1031 defp restrict_media(_query, %{"only_media" => _val, "skip_preload" => true}) do
1032 raise "Can't use the child object without preloading!"
1035 defp restrict_media(query, %{"only_media" => val}) when val == "true" or val == "1" do
1037 [_activity, object] in query,
1038 where: fragment("not (?)->'attachment' = (?)", object.data, ^[])
1042 defp restrict_media(query, _), do: query
1044 defp restrict_replies(query, %{"exclude_replies" => val}) when val == "true" or val == "1" do
1046 [_activity, object] in query,
1047 where: fragment("?->>'inReplyTo' is null", object.data)
1051 defp restrict_replies(query, %{
1052 "reply_filtering_user" => user,
1053 "reply_visibility" => "self"
1056 [activity, object] in query,
1059 "?->>'inReplyTo' is null OR ? = ANY(?)",
1067 defp restrict_replies(query, %{
1068 "reply_filtering_user" => user,
1069 "reply_visibility" => "following"
1072 [activity, object] in query,
1075 "?->>'inReplyTo' is null OR ? && array_remove(?, ?) OR ? = ?",
1077 ^[user.ap_id | User.get_cached_user_friends_ap_ids(user)],
1078 activity.recipients,
1086 defp restrict_replies(query, _), do: query
1088 defp restrict_reblogs(query, %{"exclude_reblogs" => val}) when val == "true" or val == "1" do
1089 from(activity in query, where: fragment("?->>'type' != 'Announce'", activity.data))
1092 defp restrict_reblogs(query, _), do: query
1094 defp restrict_muted(query, %{"with_muted" => val}) when val in [true, "true", "1"], do: query
1096 defp restrict_muted(query, %{"muting_user" => %User{} = user} = opts) do
1097 mutes = opts["muted_users_ap_ids"] || User.muted_users_ap_ids(user)
1100 from([activity] in query,
1101 where: fragment("not (? = ANY(?))", activity.actor, ^mutes),
1102 where: fragment("not (?->'to' \\?| ?)", activity.data, ^mutes)
1105 unless opts["skip_preload"] do
1106 from([thread_mute: tm] in query, where: is_nil(tm.user_id))
1112 defp restrict_muted(query, _), do: query
1114 defp restrict_blocked(query, %{"blocking_user" => %User{} = user} = opts) do
1115 blocked_ap_ids = opts["blocked_users_ap_ids"] || User.blocked_users_ap_ids(user)
1116 domain_blocks = user.domain_blocks || []
1118 following_ap_ids = User.get_friends_ap_ids(user)
1121 if has_named_binding?(query, :object), do: query, else: Activity.with_joined_object(query)
1124 [activity, object: o] in query,
1125 where: fragment("not (? = ANY(?))", activity.actor, ^blocked_ap_ids),
1126 where: fragment("not (? && ?)", activity.recipients, ^blocked_ap_ids),
1129 "not (?->>'type' = 'Announce' and ?->'to' \\?| ?)",
1136 "(not (split_part(?, '/', 3) = ANY(?))) or ? = ANY(?)",
1144 "(not (split_part(?->>'actor', '/', 3) = ANY(?))) or (?->>'actor') = ANY(?)",
1153 defp restrict_blocked(query, _), do: query
1155 defp restrict_unlisted(query) do
1160 "not (coalesce(?->'cc', '{}'::jsonb) \\?| ?)",
1162 ^[Constants.as_public()]
1167 defp restrict_pinned(query, %{"pinned" => "true", "pinned_activity_ids" => ids}) do
1168 from(activity in query, where: activity.id in ^ids)
1171 defp restrict_pinned(query, _), do: query
1173 defp restrict_muted_reblogs(query, %{"muting_user" => %User{} = user} = opts) do
1174 muted_reblogs = opts["reblog_muted_users_ap_ids"] || User.reblog_muted_users_ap_ids(user)
1180 "not ( ?->>'type' = 'Announce' and ? = ANY(?))",
1188 defp restrict_muted_reblogs(query, _), do: query
1190 defp restrict_instance(query, %{"instance" => instance}) do
1195 where: fragment("? LIKE ?", u.nickname, ^"%@#{instance}")
1199 from(activity in query, where: activity.actor in ^users)
1202 defp restrict_instance(query, _), do: query
1204 defp exclude_poll_votes(query, %{"include_poll_votes" => true}), do: query
1206 defp exclude_poll_votes(query, _) do
1207 if has_named_binding?(query, :object) do
1208 from([activity, object: o] in query,
1209 where: fragment("not(?->>'type' = ?)", o.data, "Answer")
1216 defp exclude_chat_messages(query, %{"include_chat_messages" => true}), do: query
1218 defp exclude_chat_messages(query, _) do
1219 if has_named_binding?(query, :object) do
1220 from([activity, object: o] in query,
1221 where: fragment("not(?->>'type' = ?)", o.data, "ChatMessage")
1228 defp exclude_id(query, %{"exclude_id" => id}) when is_binary(id) do
1229 from(activity in query, where: activity.id != ^id)
1232 defp exclude_id(query, _), do: query
1234 defp maybe_preload_objects(query, %{"skip_preload" => true}), do: query
1236 defp maybe_preload_objects(query, _) do
1238 |> Activity.with_preloaded_object()
1241 defp maybe_preload_bookmarks(query, %{"skip_preload" => true}), do: query
1243 defp maybe_preload_bookmarks(query, opts) do
1245 |> Activity.with_preloaded_bookmark(opts["user"])
1248 defp maybe_preload_report_notes(query, %{"preload_report_notes" => true}) do
1250 |> Activity.with_preloaded_report_notes()
1253 defp maybe_preload_report_notes(query, _), do: query
1255 defp maybe_set_thread_muted_field(query, %{"skip_preload" => true}), do: query
1257 defp maybe_set_thread_muted_field(query, opts) do
1259 |> Activity.with_set_thread_muted_field(opts["muting_user"] || opts["user"])
1262 defp maybe_order(query, %{order: :desc}) do
1264 |> order_by(desc: :id)
1267 defp maybe_order(query, %{order: :asc}) do
1269 |> order_by(asc: :id)
1272 defp maybe_order(query, _), do: query
1274 defp fetch_activities_query_ap_ids_ops(opts) do
1275 source_user = opts["muting_user"]
1276 ap_id_relationships = if source_user, do: [:mute, :reblog_mute], else: []
1278 ap_id_relationships =
1279 ap_id_relationships ++
1280 if opts["blocking_user"] && opts["blocking_user"] == source_user do
1286 preloaded_ap_ids = User.outgoing_relationships_ap_ids(source_user, ap_id_relationships)
1288 restrict_blocked_opts = Map.merge(%{"blocked_users_ap_ids" => preloaded_ap_ids[:block]}, opts)
1289 restrict_muted_opts = Map.merge(%{"muted_users_ap_ids" => preloaded_ap_ids[:mute]}, opts)
1291 restrict_muted_reblogs_opts =
1292 Map.merge(%{"reblog_muted_users_ap_ids" => preloaded_ap_ids[:reblog_mute]}, opts)
1294 {restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts}
1297 def fetch_activities_query(recipients, opts \\ %{}) do
1298 {restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts} =
1299 fetch_activities_query_ap_ids_ops(opts)
1302 skip_thread_containment: Config.get([:instance, :skip_thread_containment])
1306 |> maybe_preload_objects(opts)
1307 |> maybe_preload_bookmarks(opts)
1308 |> maybe_preload_report_notes(opts)
1309 |> maybe_set_thread_muted_field(opts)
1310 |> maybe_order(opts)
1311 |> restrict_recipients(recipients, opts["user"])
1312 |> restrict_replies(opts)
1313 |> restrict_tag(opts)
1314 |> restrict_tag_reject(opts)
1315 |> restrict_tag_all(opts)
1316 |> restrict_since(opts)
1317 |> restrict_local(opts)
1318 |> restrict_actor(opts)
1319 |> restrict_type(opts)
1320 |> restrict_state(opts)
1321 |> restrict_favorited_by(opts)
1322 |> restrict_blocked(restrict_blocked_opts)
1323 |> restrict_muted(restrict_muted_opts)
1324 |> restrict_media(opts)
1325 |> restrict_visibility(opts)
1326 |> restrict_thread_visibility(opts, config)
1327 |> restrict_reblogs(opts)
1328 |> restrict_pinned(opts)
1329 |> restrict_muted_reblogs(restrict_muted_reblogs_opts)
1330 |> restrict_instance(opts)
1331 |> Activity.restrict_deactivated_users()
1332 |> exclude_poll_votes(opts)
1333 |> exclude_chat_messages(opts)
1334 |> exclude_visibility(opts)
1337 def fetch_activities(recipients, opts \\ %{}, pagination \\ :keyset) do
1338 list_memberships = Pleroma.List.memberships(opts["user"])
1340 fetch_activities_query(recipients ++ list_memberships, opts)
1341 |> Pagination.fetch_paginated(opts, pagination)
1343 |> maybe_update_cc(list_memberships, opts["user"])
1347 Fetch favorites activities of user with order by sort adds to favorites
1349 @spec fetch_favourites(User.t(), map(), Pagination.type()) :: list(Activity.t())
1350 def fetch_favourites(user, params \\ %{}, pagination \\ :keyset) do
1352 |> Activity.Queries.by_actor()
1353 |> Activity.Queries.by_type("Like")
1354 |> Activity.with_joined_object()
1355 |> Object.with_joined_activity()
1356 |> select([_like, object, activity], %{activity | object: object})
1357 |> order_by([like, _, _], desc: like.id)
1358 |> Pagination.fetch_paginated(
1359 Map.merge(params, %{"skip_order" => true}),
1365 defp maybe_update_cc(activities, list_memberships, %User{ap_id: user_ap_id})
1366 when is_list(list_memberships) and length(list_memberships) > 0 do
1367 Enum.map(activities, fn
1368 %{data: %{"bcc" => bcc}} = activity when is_list(bcc) and length(bcc) > 0 ->
1369 if Enum.any?(bcc, &(&1 in list_memberships)) do
1370 update_in(activity.data["cc"], &[user_ap_id | &1])
1380 defp maybe_update_cc(activities, _, _), do: activities
1382 def fetch_activities_bounded_query(query, recipients, recipients_with_public) do
1383 from(activity in query,
1385 fragment("? && ?", activity.recipients, ^recipients) or
1386 (fragment("? && ?", activity.recipients, ^recipients_with_public) and
1387 ^Constants.as_public() in activity.recipients)
1391 def fetch_activities_bounded(
1393 recipients_with_public,
1395 pagination \\ :keyset
1397 fetch_activities_query([], opts)
1398 |> fetch_activities_bounded_query(recipients, recipients_with_public)
1399 |> Pagination.fetch_paginated(opts, pagination)
1403 @spec upload(Upload.source(), keyword()) :: {:ok, Object.t()} | {:error, any()}
1404 def upload(file, opts \\ []) do
1405 with {:ok, data} <- Upload.store(file, opts) do
1408 Map.put(data, "actor", opts[:actor])
1413 Repo.insert(%Object{data: obj_data})
1417 @spec get_actor_url(any()) :: binary() | nil
1418 defp get_actor_url(url) when is_binary(url), do: url
1419 defp get_actor_url(%{"href" => href}) when is_binary(href), do: href
1421 defp get_actor_url(url) when is_list(url) do
1427 defp get_actor_url(_url), do: nil
1429 defp object_to_user_data(data) do
1431 data["icon"]["url"] &&
1434 "url" => [%{"href" => data["icon"]["url"]}]
1438 data["image"]["url"] &&
1441 "url" => [%{"href" => data["image"]["url"]}]
1446 |> Map.get("attachment", [])
1447 |> Enum.filter(fn %{"type" => t} -> t == "PropertyValue" end)
1448 |> Enum.map(fn fields -> Map.take(fields, ["name", "value"]) end)
1452 |> Map.get("tag", [])
1454 %{"type" => "Emoji"} -> true
1457 |> Enum.reduce(%{}, fn %{"icon" => %{"url" => url}, "name" => name}, acc ->
1458 Map.put(acc, String.trim(name, ":"), url)
1461 locked = data["manuallyApprovesFollowers"] || false
1462 data = Transmogrifier.maybe_fix_user_object(data)
1463 discoverable = data["discoverable"] || false
1464 invisible = data["invisible"] || false
1465 actor_type = data["type"] || "Person"
1468 if is_map(data["publicKey"]) && is_binary(data["publicKey"]["publicKeyPem"]) do
1469 data["publicKey"]["publicKeyPem"]
1475 if is_map(data["endpoints"]) && is_binary(data["endpoints"]["sharedInbox"]) do
1476 data["endpoints"]["sharedInbox"]
1483 uri: get_actor_url(data["url"]),
1489 discoverable: discoverable,
1490 invisible: invisible,
1493 follower_address: data["followers"],
1494 following_address: data["following"],
1495 bio: data["summary"],
1496 actor_type: actor_type,
1497 also_known_as: Map.get(data, "alsoKnownAs", []),
1498 public_key: public_key,
1499 inbox: data["inbox"],
1500 shared_inbox: shared_inbox
1503 # nickname can be nil because of virtual actors
1505 if data["preferredUsername"] do
1509 "#{data["preferredUsername"]}@#{URI.parse(data["id"]).host}"
1512 Map.put(user_data, :nickname, nil)
1518 def fetch_follow_information_for_user(user) do
1519 with {:ok, following_data} <-
1520 Fetcher.fetch_and_contain_remote_object_from_id(user.following_address),
1521 {:ok, hide_follows} <- collection_private(following_data),
1522 {:ok, followers_data} <-
1523 Fetcher.fetch_and_contain_remote_object_from_id(user.follower_address),
1524 {:ok, hide_followers} <- collection_private(followers_data) do
1527 hide_follows: hide_follows,
1528 follower_count: normalize_counter(followers_data["totalItems"]),
1529 following_count: normalize_counter(following_data["totalItems"]),
1530 hide_followers: hide_followers
1533 {:error, _} = e -> e
1538 defp normalize_counter(counter) when is_integer(counter), do: counter
1539 defp normalize_counter(_), do: 0
1541 defp maybe_update_follow_information(data) do
1542 with {:enabled, true} <- {:enabled, Config.get([:instance, :external_user_synchronization])},
1543 {:ok, info} <- fetch_follow_information_for_user(data) do
1544 info = Map.merge(data[:info] || %{}, info)
1545 Map.put(data, :info, info)
1547 {:enabled, false} ->
1552 "Follower/Following counter update for #{data.ap_id} failed.\n" <> inspect(e)
1559 defp collection_private(%{"first" => %{"type" => type}})
1560 when type in ["CollectionPage", "OrderedCollectionPage"],
1563 defp collection_private(%{"first" => first}) do
1564 with {:ok, %{"type" => type}} when type in ["CollectionPage", "OrderedCollectionPage"] <-
1565 Fetcher.fetch_and_contain_remote_object_from_id(first) do
1568 {:error, {:ok, %{status: code}}} when code in [401, 403] -> {:ok, true}
1569 {:error, _} = e -> e
1574 defp collection_private(_data), do: {:ok, true}
1576 def user_data_from_user_object(data) do
1577 with {:ok, data} <- MRF.filter(data),
1578 {:ok, data} <- object_to_user_data(data) do
1585 def fetch_and_prepare_user_from_ap_id(ap_id) do
1586 with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id),
1587 {:ok, data} <- user_data_from_user_object(data),
1588 data <- maybe_update_follow_information(data) do
1591 {:error, "Object has been deleted"} = e ->
1592 Logger.debug("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
1596 Logger.error("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
1601 def make_user_from_ap_id(ap_id) do
1602 user = User.get_cached_by_ap_id(ap_id)
1604 if user && !User.ap_enabled?(user) do
1605 Transmogrifier.upgrade_user_from_ap_id(ap_id)
1607 with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id) do
1610 |> User.remote_user_changeset(data)
1611 |> User.update_and_set_cache()
1614 |> User.remote_user_changeset()
1624 def make_user_from_nickname(nickname) do
1625 with {:ok, %{"ap_id" => ap_id}} when not is_nil(ap_id) <- WebFinger.finger(nickname) do
1626 make_user_from_ap_id(ap_id)
1628 _e -> {:error, "No AP id in WebFinger"}
1632 # filter out broken threads
1633 def contain_broken_threads(%Activity{} = activity, %User{} = user) do
1634 entire_thread_visible_for_user?(activity, user)
1637 # do post-processing on a specific activity
1638 def contain_activity(%Activity{} = activity, %User{} = user) do
1639 contain_broken_threads(activity, user)
1642 def fetch_direct_messages_query do
1644 |> restrict_type(%{"type" => "Create"})
1645 |> restrict_visibility(%{visibility: "direct"})
1646 |> order_by([activity], asc: activity.id)