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},
123 Object.increase_vote_count(reply_ap_id, name)
126 def increase_poll_votes_if_vote(_create_data), do: :noop
128 @spec persist(map(), keyword()) :: {:ok, Activity.t() | Object.t()}
129 def persist(object, meta) do
130 with local <- Keyword.fetch!(meta, :local),
131 {recipients, _, _} <- get_recipients(object),
133 Repo.insert(%Activity{
136 recipients: recipients,
137 actor: object["actor"]
139 {:ok, activity, meta}
143 @spec insert(map(), boolean(), boolean(), boolean()) :: {:ok, Activity.t()} | {:error, any()}
144 def insert(map, local \\ true, fake \\ false, bypass_actor_check \\ false) when is_map(map) do
145 with nil <- Activity.normalize(map),
146 map <- lazy_put_activity_defaults(map, fake),
147 true <- bypass_actor_check || check_actor_is_active(map["actor"]),
148 {_, true} <- {:remote_limit_error, check_remote_limit(map)},
149 {:ok, map} <- MRF.filter(map),
150 {recipients, _, _} = get_recipients(map),
151 {:fake, false, map, recipients} <- {:fake, fake, map, recipients},
152 {:containment, :ok} <- {:containment, Containment.contain_child(map)},
153 {:ok, map, object} <- insert_full_object(map) do
155 Repo.insert(%Activity{
159 recipients: recipients
162 # Splice in the child object if we have one.
164 if not is_nil(object) do
165 Map.put(activity, :object, object)
170 BackgroundWorker.enqueue("fetch_data_for_activity", %{"activity_id" => activity.id})
172 Notification.create_notifications(activity)
174 conversation = create_or_bump_conversation(activity, map["actor"])
175 participations = get_participations(conversation)
177 stream_out_participations(participations)
180 %Activity{} = activity ->
183 {:fake, true, map, recipients} ->
184 activity = %Activity{
188 recipients: recipients,
192 Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
200 defp create_or_bump_conversation(activity, actor) do
201 with {:ok, conversation} <- Conversation.create_or_bump_for(activity),
202 %User{} = user <- User.get_cached_by_ap_id(actor),
203 Participation.mark_as_read(user, conversation) do
208 defp get_participations({:ok, conversation}) do
210 |> Repo.preload(:participations, force: true)
211 |> Map.get(:participations)
214 defp get_participations(_), do: []
216 def stream_out_participations(participations) do
219 |> Repo.preload(:user)
221 Streamer.stream("participation", participations)
224 def stream_out_participations(%Object{data: %{"context" => context}}, user) do
225 with %Conversation{} = conversation <- Conversation.get_for_ap_id(context),
226 conversation = Repo.preload(conversation, :participations),
228 fetch_latest_activity_id_for_context(conversation.ap_id, %{
230 "blocking_user" => user
232 if last_activity_id do
233 stream_out_participations(conversation.participations)
238 def stream_out_participations(_, _), do: :noop
240 def stream_out(%Activity{data: %{"type" => data_type}} = activity)
241 when data_type in ["Create", "Announce", "Delete"] do
243 |> Topics.get_activity_topics()
244 |> Streamer.stream(activity)
247 def stream_out(_activity) do
251 @spec create(map(), boolean()) :: {:ok, Activity.t()} | {:error, any()}
252 def create(params, fake \\ false) do
253 with {:ok, result} <- Repo.transaction(fn -> do_create(params, fake) end) do
258 defp do_create(%{to: to, actor: actor, context: context, object: object} = params, fake) do
259 additional = params[:additional] || %{}
260 # only accept false as false value
261 local = !(params[:local] == false)
262 published = params[:published]
263 quick_insert? = Config.get([:env]) == :benchmark
267 %{to: to, actor: actor, published: published, context: context, object: object},
270 {:ok, activity} <- insert(create_data, local, fake),
271 {:fake, false, activity} <- {:fake, fake, activity},
272 _ <- increase_replies_count_if_reply(create_data),
273 _ <- increase_poll_votes_if_vote(create_data),
274 {:quick_insert, false, activity} <- {:quick_insert, quick_insert?, activity},
275 {:ok, _actor} <- increase_note_count_if_public(actor, activity),
276 :ok <- maybe_federate(activity) do
279 {:quick_insert, true, activity} ->
282 {:fake, true, activity} ->
286 Repo.rollback(message)
290 @spec listen(map()) :: {:ok, Activity.t()} | {:error, any()}
291 def listen(%{to: to, actor: actor, context: context, object: object} = params) do
292 additional = params[:additional] || %{}
293 # only accept false as false value
294 local = !(params[:local] == false)
295 published = params[:published]
299 %{to: to, actor: actor, published: published, context: context, object: object},
302 {:ok, activity} <- insert(listen_data, local),
303 :ok <- maybe_federate(activity) do
308 @spec accept(map()) :: {:ok, Activity.t()} | {:error, any()}
309 def accept(params) do
310 accept_or_reject("Accept", params)
313 @spec reject(map()) :: {:ok, Activity.t()} | {:error, any()}
314 def reject(params) do
315 accept_or_reject("Reject", params)
318 @spec accept_or_reject(String.t(), map()) :: {:ok, Activity.t()} | {:error, any()}
319 def accept_or_reject(type, %{to: to, actor: actor, object: object} = params) do
320 local = Map.get(params, :local, true)
321 activity_id = Map.get(params, :activity_id, nil)
324 %{"to" => to, "type" => type, "actor" => actor.ap_id, "object" => object}
325 |> Utils.maybe_put("id", activity_id),
326 {:ok, activity} <- insert(data, local),
327 :ok <- maybe_federate(activity) do
332 @spec update(map()) :: {:ok, Activity.t()} | {:error, any()}
333 def update(%{to: to, cc: cc, actor: actor, object: object} = params) do
334 local = !(params[:local] == false)
335 activity_id = params[:activity_id]
344 data <- Utils.maybe_put(data, "id", activity_id),
345 {:ok, activity} <- insert(data, local),
346 :ok <- maybe_federate(activity) do
351 @spec react_with_emoji(User.t(), Object.t(), String.t(), keyword()) ::
352 {:ok, Activity.t(), Object.t()} | {:error, any()}
353 def react_with_emoji(user, object, emoji, options \\ []) do
354 with {:ok, result} <-
355 Repo.transaction(fn -> do_react_with_emoji(user, object, emoji, options) end) do
360 defp do_react_with_emoji(user, object, emoji, options) do
361 with local <- Keyword.get(options, :local, true),
362 activity_id <- Keyword.get(options, :activity_id, nil),
363 true <- Pleroma.Emoji.is_unicode_emoji?(emoji),
364 reaction_data <- make_emoji_reaction_data(user, object, emoji, activity_id),
365 {:ok, activity} <- insert(reaction_data, local),
366 {:ok, object} <- add_emoji_reaction_to_object(activity, object),
367 :ok <- maybe_federate(activity) do
368 {:ok, activity, object}
370 false -> {:error, false}
371 {:error, error} -> Repo.rollback(error)
375 @spec unreact_with_emoji(User.t(), String.t(), keyword()) ::
376 {:ok, Activity.t(), Object.t()} | {:error, any()}
377 def unreact_with_emoji(user, reaction_id, options \\ []) do
378 with {:ok, result} <-
379 Repo.transaction(fn -> do_unreact_with_emoji(user, reaction_id, options) end) do
384 defp do_unreact_with_emoji(user, reaction_id, options) do
385 with local <- Keyword.get(options, :local, true),
386 activity_id <- Keyword.get(options, :activity_id, nil),
387 user_ap_id <- user.ap_id,
388 %Activity{actor: ^user_ap_id} = reaction_activity <- Activity.get_by_ap_id(reaction_id),
389 object <- Object.normalize(reaction_activity),
390 unreact_data <- make_undo_data(user, reaction_activity, activity_id),
391 {:ok, activity} <- insert(unreact_data, local),
392 {:ok, object} <- remove_emoji_reaction_from_object(reaction_activity, object),
393 :ok <- maybe_federate(activity) do
394 {:ok, activity, object}
396 {:error, error} -> Repo.rollback(error)
400 # TODO: This is weird, maybe we shouldn't check here if we can make the activity.
401 @spec like(User.t(), Object.t(), String.t() | nil, boolean()) ::
402 {:ok, Activity.t(), Object.t()} | {:error, any()}
403 def like(user, object, activity_id \\ nil, local \\ true) do
404 with {:ok, result} <- Repo.transaction(fn -> do_like(user, object, activity_id, local) end) do
410 %User{ap_id: ap_id} = user,
411 %Object{data: %{"id" => _}} = object,
415 with nil <- get_existing_like(ap_id, object),
416 like_data <- make_like_data(user, object, activity_id),
417 {:ok, activity} <- insert(like_data, local),
418 {:ok, object} <- add_like_to_object(activity, object),
419 :ok <- maybe_federate(activity) do
420 {:ok, activity, object}
422 %Activity{} = activity ->
423 {:ok, activity, object}
430 @spec unlike(User.t(), Object.t(), String.t() | nil, boolean()) ::
431 {:ok, Activity.t(), Activity.t(), Object.t()} | {:ok, Object.t()} | {:error, any()}
432 def unlike(%User{} = actor, %Object{} = object, activity_id \\ nil, local \\ true) do
433 with {:ok, result} <-
434 Repo.transaction(fn -> do_unlike(actor, object, activity_id, local) end) do
439 defp do_unlike(actor, object, activity_id, local) do
440 with %Activity{} = like_activity <- get_existing_like(actor.ap_id, object),
441 unlike_data <- make_unlike_data(actor, like_activity, activity_id),
442 {:ok, unlike_activity} <- insert(unlike_data, local),
443 {:ok, _activity} <- Repo.delete(like_activity),
444 {:ok, object} <- remove_like_from_object(like_activity, object),
445 :ok <- maybe_federate(unlike_activity) do
446 {:ok, unlike_activity, like_activity, object}
449 {:error, error} -> Repo.rollback(error)
453 @spec announce(User.t(), Object.t(), String.t() | nil, boolean(), boolean()) ::
454 {:ok, Activity.t(), Object.t()} | {:error, any()}
456 %User{ap_id: _} = user,
457 %Object{data: %{"id" => _}} = object,
462 with {:ok, result} <-
463 Repo.transaction(fn -> do_announce(user, object, activity_id, local, public) end) do
468 defp do_announce(user, object, activity_id, local, public) do
469 with true <- is_announceable?(object, user, public),
470 announce_data <- make_announce_data(user, object, activity_id, public),
471 {:ok, activity} <- insert(announce_data, local),
472 {:ok, object} <- add_announce_to_object(activity, object),
473 :ok <- maybe_federate(activity) do
474 {:ok, activity, object}
476 false -> {:error, false}
477 {:error, error} -> Repo.rollback(error)
481 @spec unannounce(User.t(), Object.t(), String.t() | nil, boolean()) ::
482 {:ok, Activity.t(), Object.t()} | {:ok, Object.t()} | {:error, any()}
489 with {:ok, result} <-
490 Repo.transaction(fn -> do_unannounce(actor, object, activity_id, local) end) do
495 defp do_unannounce(actor, object, activity_id, local) do
496 with %Activity{} = announce_activity <- get_existing_announce(actor.ap_id, object),
497 unannounce_data <- make_unannounce_data(actor, announce_activity, activity_id),
498 {:ok, unannounce_activity} <- insert(unannounce_data, local),
499 :ok <- maybe_federate(unannounce_activity),
500 {:ok, _activity} <- Repo.delete(announce_activity),
501 {:ok, object} <- remove_announce_from_object(announce_activity, object) do
502 {:ok, unannounce_activity, object}
505 {:error, error} -> Repo.rollback(error)
509 @spec follow(User.t(), User.t(), String.t() | nil, boolean()) ::
510 {:ok, Activity.t()} | {:error, any()}
511 def follow(follower, followed, activity_id \\ nil, local \\ true) do
512 with {:ok, result} <-
513 Repo.transaction(fn -> do_follow(follower, followed, activity_id, local) end) do
518 defp do_follow(follower, followed, activity_id, local) do
519 with data <- make_follow_data(follower, followed, activity_id),
520 {:ok, activity} <- insert(data, local),
521 :ok <- maybe_federate(activity) do
524 {:error, error} -> Repo.rollback(error)
528 @spec unfollow(User.t(), User.t(), String.t() | nil, boolean()) ::
529 {:ok, Activity.t()} | nil | {:error, any()}
530 def unfollow(follower, followed, activity_id \\ nil, local \\ true) do
531 with {:ok, result} <-
532 Repo.transaction(fn -> do_unfollow(follower, followed, activity_id, local) end) do
537 defp do_unfollow(follower, followed, activity_id, local) do
538 with %Activity{} = follow_activity <- fetch_latest_follow(follower, followed),
539 {:ok, follow_activity} <- update_follow_state(follow_activity, "cancelled"),
540 unfollow_data <- make_unfollow_data(follower, followed, follow_activity, activity_id),
541 {:ok, activity} <- insert(unfollow_data, local),
542 :ok <- maybe_federate(activity) do
546 {:error, error} -> Repo.rollback(error)
550 @spec delete(User.t() | Object.t(), keyword()) :: {:ok, User.t() | Object.t()} | {:error, any()}
551 def delete(entity, options \\ []) do
552 with {:ok, result} <- Repo.transaction(fn -> do_delete(entity, options) end) do
557 defp do_delete(%User{ap_id: ap_id, follower_address: follower_address} = user, _) do
559 "to" => [follower_address],
562 "object" => %{"type" => "Person", "id" => ap_id}
564 {:ok, activity} <- insert(data, true, true, true),
565 :ok <- maybe_federate(activity) do
570 defp do_delete(%Object{data: %{"id" => id, "actor" => actor}} = object, options) do
571 local = Keyword.get(options, :local, true)
572 activity_id = Keyword.get(options, :activity_id, nil)
573 actor = Keyword.get(options, :actor, actor)
575 user = User.get_cached_by_ap_id(actor)
576 to = (object.data["to"] || []) ++ (object.data["cc"] || [])
578 with create_activity <- Activity.get_create_by_object_ap_id(id),
585 "deleted_activity_id" => create_activity && create_activity.id
587 |> maybe_put("id", activity_id),
588 {:ok, activity} <- insert(data, local, false),
589 {:ok, object, _create_activity} <- Object.delete(object),
590 stream_out_participations(object, user),
591 _ <- decrease_replies_count_if_reply(object),
592 {:ok, _actor} <- decrease_note_count_if_public(user, object),
593 :ok <- maybe_federate(activity) do
601 defp do_delete(%Object{data: %{"type" => "Tombstone", "id" => ap_id}}, _) do
604 |> Activity.Queries.by_object_id()
605 |> Activity.Queries.by_type("Delete")
611 @spec block(User.t(), User.t(), String.t() | nil, boolean()) ::
612 {:ok, Activity.t()} | {:error, any()}
613 def block(blocker, blocked, activity_id \\ nil, local \\ true) do
614 with {:ok, result} <-
615 Repo.transaction(fn -> do_block(blocker, blocked, activity_id, local) end) do
620 defp do_block(blocker, blocked, activity_id, local) do
621 outgoing_blocks = Config.get([:activitypub, :outgoing_blocks])
622 unfollow_blocked = Config.get([:activitypub, :unfollow_blocked])
624 if unfollow_blocked do
625 follow_activity = fetch_latest_follow(blocker, blocked)
626 if follow_activity, do: unfollow(blocker, blocked, nil, local)
629 with true <- outgoing_blocks,
630 block_data <- make_block_data(blocker, blocked, activity_id),
631 {:ok, activity} <- insert(block_data, local),
632 :ok <- maybe_federate(activity) do
635 {:error, error} -> Repo.rollback(error)
639 @spec unblock(User.t(), User.t(), String.t() | nil, boolean()) ::
640 {:ok, Activity.t()} | {:error, any()} | nil
641 def unblock(blocker, blocked, activity_id \\ nil, local \\ true) do
642 with {:ok, result} <-
643 Repo.transaction(fn -> do_unblock(blocker, blocked, activity_id, local) end) do
648 defp do_unblock(blocker, blocked, activity_id, local) do
649 with %Activity{} = block_activity <- fetch_latest_block(blocker, blocked),
650 unblock_data <- make_unblock_data(blocker, blocked, block_activity, activity_id),
651 {:ok, activity} <- insert(unblock_data, local),
652 :ok <- maybe_federate(activity) do
656 {:error, error} -> Repo.rollback(error)
660 @spec flag(map()) :: {:ok, Activity.t()} | {:error, any()}
670 # only accept false as false value
671 local = !(params[:local] == false)
672 forward = !(params[:forward] == false)
674 additional = params[:additional] || %{}
678 Map.merge(additional, %{"to" => [], "cc" => [account.ap_id]})
680 Map.merge(additional, %{"to" => [], "cc" => []})
683 with flag_data <- make_flag_data(params, additional),
684 {:ok, activity} <- insert(flag_data, local),
685 {:ok, stripped_activity} <- strip_report_status_data(activity),
686 :ok <- maybe_federate(stripped_activity) do
687 User.all_superusers()
688 |> Enum.filter(fn user -> not is_nil(user.email) end)
689 |> Enum.each(fn superuser ->
691 |> Pleroma.Emails.AdminEmail.report(actor, account, statuses, content)
692 |> Pleroma.Emails.Mailer.deliver_async()
699 @spec move(User.t(), User.t(), boolean()) :: {:ok, Activity.t()} | {:error, any()}
700 def move(%User{} = origin, %User{} = target, local \\ true) do
703 "actor" => origin.ap_id,
704 "object" => origin.ap_id,
705 "target" => target.ap_id
708 with true <- origin.ap_id in target.also_known_as,
709 {:ok, activity} <- insert(params, local) do
710 maybe_federate(activity)
712 BackgroundWorker.enqueue("move_following", %{
713 "origin_id" => origin.id,
714 "target_id" => target.id
719 false -> {:error, "Target account must have the origin in `alsoKnownAs`"}
724 def fetch_activities_for_context_query(context, opts) do
725 public = [Constants.as_public()]
729 do: [opts["user"].ap_id | User.following(opts["user"])] ++ public,
732 from(activity in Activity)
733 |> maybe_preload_objects(opts)
734 |> maybe_preload_bookmarks(opts)
735 |> maybe_set_thread_muted_field(opts)
736 |> restrict_blocked(opts)
737 |> restrict_recipients(recipients, opts["user"])
741 "?->>'type' = ? and ?->>'context' = ?",
748 |> exclude_poll_votes(opts)
750 |> order_by([activity], desc: activity.id)
753 @spec fetch_activities_for_context(String.t(), keyword() | map()) :: [Activity.t()]
754 def fetch_activities_for_context(context, opts \\ %{}) do
756 |> fetch_activities_for_context_query(opts)
760 @spec fetch_latest_activity_id_for_context(String.t(), keyword() | map()) ::
761 FlakeId.Ecto.CompatType.t() | nil
762 def fetch_latest_activity_id_for_context(context, opts \\ %{}) do
764 |> fetch_activities_for_context_query(Map.merge(%{"skip_preload" => true}, opts))
770 @spec fetch_public_activities(map(), Pagination.type()) :: [Activity.t()]
771 def fetch_public_activities(opts \\ %{}, pagination \\ :keyset) do
772 opts = Map.drop(opts, ["user"])
774 [Constants.as_public()]
775 |> fetch_activities_query(opts)
776 |> restrict_unlisted()
777 |> Pagination.fetch_paginated(opts, pagination)
780 @valid_visibilities ~w[direct unlisted public private]
782 defp restrict_visibility(query, %{visibility: visibility})
783 when is_list(visibility) do
784 if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
790 "activity_visibility(?, ?, ?) = ANY (?)",
800 Logger.error("Could not restrict visibility to #{visibility}")
804 defp restrict_visibility(query, %{visibility: visibility})
805 when visibility in @valid_visibilities do
809 fragment("activity_visibility(?, ?, ?) = ?", a.actor, a.recipients, a.data, ^visibility)
813 defp restrict_visibility(_query, %{visibility: visibility})
814 when visibility not in @valid_visibilities do
815 Logger.error("Could not restrict visibility to #{visibility}")
818 defp restrict_visibility(query, _visibility), do: query
820 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
821 when is_list(visibility) do
822 if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
827 "activity_visibility(?, ?, ?) = ANY (?)",
835 Logger.error("Could not exclude visibility to #{visibility}")
840 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
841 when visibility in @valid_visibilities do
846 "activity_visibility(?, ?, ?) = ?",
855 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
856 when visibility not in [nil | @valid_visibilities] do
857 Logger.error("Could not exclude visibility to #{visibility}")
861 defp exclude_visibility(query, _visibility), do: query
863 defp restrict_thread_visibility(query, _, %{skip_thread_containment: true} = _),
866 defp restrict_thread_visibility(
868 %{"user" => %User{skip_thread_containment: true}},
873 defp restrict_thread_visibility(query, %{"user" => %User{ap_id: ap_id}}, _) do
876 where: fragment("thread_visibility(?, (?)->>'id') = true", ^ap_id, a.data)
880 defp restrict_thread_visibility(query, _, _), do: query
882 def fetch_user_abstract_activities(user, reading_user, params \\ %{}) do
885 |> Map.put("user", reading_user)
886 |> Map.put("actor_id", user.ap_id)
889 user_activities_recipients(%{
890 "godmode" => params["godmode"],
891 "reading_user" => reading_user
894 fetch_activities(recipients, params)
898 def fetch_user_activities(user, reading_user, params \\ %{}) do
901 |> Map.put("type", ["Create", "Announce"])
902 |> Map.put("user", reading_user)
903 |> Map.put("actor_id", user.ap_id)
904 |> Map.put("pinned_activity_ids", user.pinned_activities)
907 if User.blocks?(reading_user, user) do
911 |> Map.put("blocking_user", reading_user)
912 |> Map.put("muting_user", reading_user)
916 user_activities_recipients(%{
917 "godmode" => params["godmode"],
918 "reading_user" => reading_user
921 fetch_activities(recipients, params)
925 def fetch_statuses(reading_user, params) do
928 |> Map.put("type", ["Create", "Announce"])
931 user_activities_recipients(%{
932 "godmode" => params["godmode"],
933 "reading_user" => reading_user
936 fetch_activities(recipients, params, :offset)
940 defp user_activities_recipients(%{"godmode" => true}) do
944 defp user_activities_recipients(%{"reading_user" => reading_user}) do
946 [Constants.as_public()] ++ [reading_user.ap_id | User.following(reading_user)]
948 [Constants.as_public()]
952 defp restrict_since(query, %{"since_id" => ""}), do: query
954 defp restrict_since(query, %{"since_id" => since_id}) do
955 from(activity in query, where: activity.id > ^since_id)
958 defp restrict_since(query, _), do: query
960 defp restrict_tag_reject(_query, %{"tag_reject" => _tag_reject, "skip_preload" => true}) do
961 raise "Can't use the child object without preloading!"
964 defp restrict_tag_reject(query, %{"tag_reject" => tag_reject})
965 when is_list(tag_reject) and tag_reject != [] do
967 [_activity, object] in query,
968 where: fragment("not (?)->'tag' \\?| (?)", object.data, ^tag_reject)
972 defp restrict_tag_reject(query, _), do: query
974 defp restrict_tag_all(_query, %{"tag_all" => _tag_all, "skip_preload" => true}) do
975 raise "Can't use the child object without preloading!"
978 defp restrict_tag_all(query, %{"tag_all" => tag_all})
979 when is_list(tag_all) and tag_all != [] do
981 [_activity, object] in query,
982 where: fragment("(?)->'tag' \\?& (?)", object.data, ^tag_all)
986 defp restrict_tag_all(query, _), do: query
988 defp restrict_tag(_query, %{"tag" => _tag, "skip_preload" => true}) do
989 raise "Can't use the child object without preloading!"
992 defp restrict_tag(query, %{"tag" => tag}) when is_list(tag) do
994 [_activity, object] in query,
995 where: fragment("(?)->'tag' \\?| (?)", object.data, ^tag)
999 defp restrict_tag(query, %{"tag" => tag}) when is_binary(tag) do
1001 [_activity, object] in query,
1002 where: fragment("(?)->'tag' \\? (?)", object.data, ^tag)
1006 defp restrict_tag(query, _), do: query
1008 defp restrict_recipients(query, [], _user), do: query
1010 defp restrict_recipients(query, recipients, nil) do
1011 from(activity in query, where: fragment("? && ?", ^recipients, activity.recipients))
1014 defp restrict_recipients(query, recipients, user) do
1017 where: fragment("? && ?", ^recipients, activity.recipients),
1018 or_where: activity.actor == ^user.ap_id
1022 defp restrict_local(query, %{"local_only" => true}) do
1023 from(activity in query, where: activity.local == true)
1026 defp restrict_local(query, _), do: query
1028 defp restrict_actor(query, %{"actor_id" => actor_id}) do
1029 from(activity in query, where: activity.actor == ^actor_id)
1032 defp restrict_actor(query, _), do: query
1034 defp restrict_type(query, %{"type" => type}) when is_binary(type) do
1035 from(activity in query, where: fragment("?->>'type' = ?", activity.data, ^type))
1038 defp restrict_type(query, %{"type" => type}) do
1039 from(activity in query, where: fragment("?->>'type' = ANY(?)", activity.data, ^type))
1042 defp restrict_type(query, _), do: query
1044 defp restrict_state(query, %{"state" => state}) do
1045 from(activity in query, where: fragment("?->>'state' = ?", activity.data, ^state))
1048 defp restrict_state(query, _), do: query
1050 defp restrict_favorited_by(query, %{"favorited_by" => ap_id}) do
1052 [_activity, object] in query,
1053 where: fragment("(?)->'likes' \\? (?)", object.data, ^ap_id)
1057 defp restrict_favorited_by(query, _), do: query
1059 defp restrict_media(_query, %{"only_media" => _val, "skip_preload" => true}) do
1060 raise "Can't use the child object without preloading!"
1063 defp restrict_media(query, %{"only_media" => val}) when val in [true, "true", "1"] do
1065 [_activity, object] in query,
1066 where: fragment("not (?)->'attachment' = (?)", object.data, ^[])
1070 defp restrict_media(query, _), do: query
1072 defp restrict_replies(query, %{"exclude_replies" => val}) when val in [true, "true", "1"] do
1074 [_activity, object] in query,
1075 where: fragment("?->>'inReplyTo' is null", object.data)
1079 defp restrict_replies(query, _), do: query
1081 defp restrict_reblogs(query, %{"exclude_reblogs" => val}) when val in [true, "true", "1"] do
1082 from(activity in query, where: fragment("?->>'type' != 'Announce'", activity.data))
1085 defp restrict_reblogs(query, _), do: query
1087 defp restrict_muted(query, %{"with_muted" => val}) when val in [true, "true", "1"], do: query
1089 defp restrict_muted(query, %{"muting_user" => %User{} = user} = opts) do
1090 mutes = opts["muted_users_ap_ids"] || User.muted_users_ap_ids(user)
1093 from([activity] in query,
1094 where: fragment("not (? = ANY(?))", activity.actor, ^mutes),
1095 where: fragment("not (?->'to' \\?| ?)", activity.data, ^mutes)
1098 unless opts["skip_preload"] do
1099 from([thread_mute: tm] in query, where: is_nil(tm.user_id))
1105 defp restrict_muted(query, _), do: query
1107 defp restrict_blocked(query, %{"blocking_user" => %User{} = user} = opts) do
1108 blocked_ap_ids = opts["blocked_users_ap_ids"] || User.blocked_users_ap_ids(user)
1109 domain_blocks = user.domain_blocks || []
1111 following_ap_ids = User.get_friends_ap_ids(user)
1114 if has_named_binding?(query, :object), do: query, else: Activity.with_joined_object(query)
1117 [activity, object: o] in query,
1118 where: fragment("not (? = ANY(?))", activity.actor, ^blocked_ap_ids),
1119 where: fragment("not (? && ?)", activity.recipients, ^blocked_ap_ids),
1122 "not (?->>'type' = 'Announce' and ?->'to' \\?| ?)",
1129 "(not (split_part(?, '/', 3) = ANY(?))) or ? = ANY(?)",
1137 "(not (split_part(?->>'actor', '/', 3) = ANY(?))) or (?->>'actor') = ANY(?)",
1146 defp restrict_blocked(query, _), do: query
1148 defp restrict_unlisted(query) do
1153 "not (coalesce(?->'cc', '{}'::jsonb) \\?| ?)",
1155 ^[Constants.as_public()]
1160 defp restrict_pinned(query, %{"pinned" => pinned, "pinned_activity_ids" => ids})
1161 when pinned in [true, "true", "1"] do
1162 from(activity in query, where: activity.id in ^ids)
1165 defp restrict_pinned(query, _), do: query
1167 defp restrict_muted_reblogs(query, %{"muting_user" => %User{} = user} = opts) do
1168 muted_reblogs = opts["reblog_muted_users_ap_ids"] || User.reblog_muted_users_ap_ids(user)
1174 "not ( ?->>'type' = 'Announce' and ? = ANY(?))",
1182 defp restrict_muted_reblogs(query, _), do: query
1184 defp restrict_instance(query, %{"instance" => instance}) do
1189 where: fragment("? LIKE ?", u.nickname, ^"%@#{instance}")
1193 from(activity in query, where: activity.actor in ^users)
1196 defp restrict_instance(query, _), do: query
1198 defp exclude_poll_votes(query, %{"include_poll_votes" => true}), do: query
1200 defp exclude_poll_votes(query, _) do
1201 if has_named_binding?(query, :object) do
1202 from([activity, object: o] in query,
1203 where: fragment("not(?->>'type' = ?)", o.data, "Answer")
1210 defp exclude_id(query, %{"exclude_id" => id}) when is_binary(id) do
1211 from(activity in query, where: activity.id != ^id)
1214 defp exclude_id(query, _), do: query
1216 defp maybe_preload_objects(query, %{"skip_preload" => true}), do: query
1218 defp maybe_preload_objects(query, _) do
1220 |> Activity.with_preloaded_object()
1223 defp maybe_preload_bookmarks(query, %{"skip_preload" => true}), do: query
1225 defp maybe_preload_bookmarks(query, opts) do
1227 |> Activity.with_preloaded_bookmark(opts["user"])
1230 defp maybe_preload_report_notes(query, %{"preload_report_notes" => true}) do
1232 |> Activity.with_preloaded_report_notes()
1235 defp maybe_preload_report_notes(query, _), do: query
1237 defp maybe_set_thread_muted_field(query, %{"skip_preload" => true}), do: query
1239 defp maybe_set_thread_muted_field(query, opts) do
1241 |> Activity.with_set_thread_muted_field(opts["muting_user"] || opts["user"])
1244 defp maybe_order(query, %{order: :desc}) do
1246 |> order_by(desc: :id)
1249 defp maybe_order(query, %{order: :asc}) do
1251 |> order_by(asc: :id)
1254 defp maybe_order(query, _), do: query
1256 defp fetch_activities_query_ap_ids_ops(opts) do
1257 source_user = opts["muting_user"]
1258 ap_id_relationships = if source_user, do: [:mute, :reblog_mute], else: []
1260 ap_id_relationships =
1261 ap_id_relationships ++
1262 if opts["blocking_user"] && opts["blocking_user"] == source_user do
1268 preloaded_ap_ids = User.outgoing_relationships_ap_ids(source_user, ap_id_relationships)
1270 restrict_blocked_opts = Map.merge(%{"blocked_users_ap_ids" => preloaded_ap_ids[:block]}, opts)
1271 restrict_muted_opts = Map.merge(%{"muted_users_ap_ids" => preloaded_ap_ids[:mute]}, opts)
1273 restrict_muted_reblogs_opts =
1274 Map.merge(%{"reblog_muted_users_ap_ids" => preloaded_ap_ids[:reblog_mute]}, opts)
1276 {restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts}
1279 def fetch_activities_query(recipients, opts \\ %{}) do
1280 {restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts} =
1281 fetch_activities_query_ap_ids_ops(opts)
1284 skip_thread_containment: Config.get([:instance, :skip_thread_containment])
1288 |> maybe_preload_objects(opts)
1289 |> maybe_preload_bookmarks(opts)
1290 |> maybe_preload_report_notes(opts)
1291 |> maybe_set_thread_muted_field(opts)
1292 |> maybe_order(opts)
1293 |> restrict_recipients(recipients, opts["user"])
1294 |> restrict_tag(opts)
1295 |> restrict_tag_reject(opts)
1296 |> restrict_tag_all(opts)
1297 |> restrict_since(opts)
1298 |> restrict_local(opts)
1299 |> restrict_actor(opts)
1300 |> restrict_type(opts)
1301 |> restrict_state(opts)
1302 |> restrict_favorited_by(opts)
1303 |> restrict_blocked(restrict_blocked_opts)
1304 |> restrict_muted(restrict_muted_opts)
1305 |> restrict_media(opts)
1306 |> restrict_visibility(opts)
1307 |> restrict_thread_visibility(opts, config)
1308 |> restrict_replies(opts)
1309 |> restrict_reblogs(opts)
1310 |> restrict_pinned(opts)
1311 |> restrict_muted_reblogs(restrict_muted_reblogs_opts)
1312 |> restrict_instance(opts)
1313 |> Activity.restrict_deactivated_users()
1314 |> exclude_poll_votes(opts)
1315 |> exclude_visibility(opts)
1318 def fetch_activities(recipients, opts \\ %{}, pagination \\ :keyset) do
1319 list_memberships = Pleroma.List.memberships(opts["user"])
1321 fetch_activities_query(recipients ++ list_memberships, opts)
1322 |> Pagination.fetch_paginated(opts, pagination)
1324 |> maybe_update_cc(list_memberships, opts["user"])
1328 Fetch favorites activities of user with order by sort adds to favorites
1330 @spec fetch_favourites(User.t(), map(), Pagination.type()) :: list(Activity.t())
1331 def fetch_favourites(user, params \\ %{}, pagination \\ :keyset) do
1333 |> Activity.Queries.by_actor()
1334 |> Activity.Queries.by_type("Like")
1335 |> Activity.with_joined_object()
1336 |> Object.with_joined_activity()
1337 |> select([_like, object, activity], %{activity | object: object})
1338 |> order_by([like, _, _], desc: like.id)
1339 |> Pagination.fetch_paginated(
1340 Map.merge(params, %{"skip_order" => true}),
1346 defp maybe_update_cc(activities, list_memberships, %User{ap_id: user_ap_id})
1347 when is_list(list_memberships) and length(list_memberships) > 0 do
1348 Enum.map(activities, fn
1349 %{data: %{"bcc" => bcc}} = activity when is_list(bcc) and length(bcc) > 0 ->
1350 if Enum.any?(bcc, &(&1 in list_memberships)) do
1351 update_in(activity.data["cc"], &[user_ap_id | &1])
1361 defp maybe_update_cc(activities, _, _), do: activities
1363 def fetch_activities_bounded_query(query, recipients, recipients_with_public) do
1364 from(activity in query,
1366 fragment("? && ?", activity.recipients, ^recipients) or
1367 (fragment("? && ?", activity.recipients, ^recipients_with_public) and
1368 ^Constants.as_public() in activity.recipients)
1372 def fetch_activities_bounded(
1374 recipients_with_public,
1376 pagination \\ :keyset
1378 fetch_activities_query([], opts)
1379 |> fetch_activities_bounded_query(recipients, recipients_with_public)
1380 |> Pagination.fetch_paginated(opts, pagination)
1384 @spec upload(Upload.source(), keyword()) :: {:ok, Object.t()} | {:error, any()}
1385 def upload(file, opts \\ []) do
1386 with {:ok, data} <- Upload.store(file, opts) do
1389 Map.put(data, "actor", opts[:actor])
1394 Repo.insert(%Object{data: obj_data})
1398 @spec get_actor_url(any()) :: binary() | nil
1399 defp get_actor_url(url) when is_binary(url), do: url
1400 defp get_actor_url(%{"href" => href}) when is_binary(href), do: href
1402 defp get_actor_url(url) when is_list(url) do
1408 defp get_actor_url(_url), do: nil
1410 defp object_to_user_data(data) do
1412 data["icon"]["url"] &&
1415 "url" => [%{"href" => data["icon"]["url"]}]
1419 data["image"]["url"] &&
1422 "url" => [%{"href" => data["image"]["url"]}]
1427 |> Map.get("attachment", [])
1428 |> Enum.filter(fn %{"type" => t} -> t == "PropertyValue" end)
1429 |> Enum.map(fn fields -> Map.take(fields, ["name", "value"]) end)
1431 locked = data["manuallyApprovesFollowers"] || false
1432 data = Transmogrifier.maybe_fix_user_object(data)
1433 discoverable = data["discoverable"] || false
1434 invisible = data["invisible"] || false
1435 actor_type = data["type"] || "Person"
1439 uri: get_actor_url(data["url"]),
1445 discoverable: discoverable,
1446 invisible: invisible,
1449 follower_address: data["followers"],
1450 following_address: data["following"],
1451 bio: data["summary"],
1452 actor_type: actor_type,
1453 also_known_as: Map.get(data, "alsoKnownAs", [])
1456 # nickname can be nil because of virtual actors
1458 if data["preferredUsername"] do
1462 "#{data["preferredUsername"]}@#{URI.parse(data["id"]).host}"
1465 Map.put(user_data, :nickname, nil)
1471 def fetch_follow_information_for_user(user) do
1472 with {:ok, following_data} <-
1473 Fetcher.fetch_and_contain_remote_object_from_id(user.following_address),
1474 {:ok, hide_follows} <- collection_private(following_data),
1475 {:ok, followers_data} <-
1476 Fetcher.fetch_and_contain_remote_object_from_id(user.follower_address),
1477 {:ok, hide_followers} <- collection_private(followers_data) do
1480 hide_follows: hide_follows,
1481 follower_count: normalize_counter(followers_data["totalItems"]),
1482 following_count: normalize_counter(following_data["totalItems"]),
1483 hide_followers: hide_followers
1486 {:error, _} = e -> e
1491 defp normalize_counter(counter) when is_integer(counter), do: counter
1492 defp normalize_counter(_), do: 0
1494 defp maybe_update_follow_information(data) do
1495 with {:enabled, true} <- {:enabled, Config.get([:instance, :external_user_synchronization])},
1496 {:ok, info} <- fetch_follow_information_for_user(data) do
1497 info = Map.merge(data[:info] || %{}, info)
1498 Map.put(data, :info, info)
1500 {:enabled, false} ->
1505 "Follower/Following counter update for #{data.ap_id} failed.\n" <> inspect(e)
1512 defp collection_private(%{"first" => %{"type" => type}})
1513 when type in ["CollectionPage", "OrderedCollectionPage"],
1516 defp collection_private(%{"first" => first}) do
1517 with {:ok, %{"type" => type}} when type in ["CollectionPage", "OrderedCollectionPage"] <-
1518 Fetcher.fetch_and_contain_remote_object_from_id(first) do
1521 {:error, {:ok, %{status: code}}} when code in [401, 403] -> {:ok, true}
1522 {:error, _} = e -> e
1527 defp collection_private(_data), do: {:ok, true}
1529 def user_data_from_user_object(data) do
1530 with {:ok, data} <- MRF.filter(data),
1531 {:ok, data} <- object_to_user_data(data) do
1538 def fetch_and_prepare_user_from_ap_id(ap_id) do
1539 with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id),
1540 {:ok, data} <- user_data_from_user_object(data),
1541 data <- maybe_update_follow_information(data) do
1544 {:error, "Object has been deleted"} = e ->
1545 Logger.debug("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
1549 Logger.error("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
1554 def make_user_from_ap_id(ap_id) do
1555 if _user = User.get_cached_by_ap_id(ap_id) do
1556 Transmogrifier.upgrade_user_from_ap_id(ap_id)
1558 with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id) do
1559 User.insert_or_update_user(data)
1566 def make_user_from_nickname(nickname) do
1567 with {:ok, %{"ap_id" => ap_id}} when not is_nil(ap_id) <- WebFinger.finger(nickname) do
1568 make_user_from_ap_id(ap_id)
1570 _e -> {:error, "No AP id in WebFinger"}
1574 # filter out broken threads
1575 def contain_broken_threads(%Activity{} = activity, %User{} = user) do
1576 entire_thread_visible_for_user?(activity, user)
1579 # do post-processing on a specific activity
1580 def contain_activity(%Activity{} = activity, %User{} = user) do
1581 contain_broken_threads(activity, user)
1584 def fetch_direct_messages_query do
1586 |> restrict_type(%{"type" => "Create"})
1587 |> restrict_visibility(%{visibility: "direct"})
1588 |> order_by([activity], asc: activity.id)