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 insert(map(), boolean(), boolean(), boolean()) :: {:ok, Activity.t()} | {:error, any()}
129 def insert(map, local \\ true, fake \\ false, bypass_actor_check \\ false) when is_map(map) do
130 with nil <- Activity.normalize(map),
131 map <- lazy_put_activity_defaults(map, fake),
132 true <- bypass_actor_check || check_actor_is_active(map["actor"]),
133 {_, true} <- {:remote_limit_error, check_remote_limit(map)},
134 {:ok, map} <- MRF.filter(map),
135 {recipients, _, _} = get_recipients(map),
136 {:fake, false, map, recipients} <- {:fake, fake, map, recipients},
137 {:containment, :ok} <- {:containment, Containment.contain_child(map)},
138 {:ok, map, object} <- insert_full_object(map) do
140 Repo.insert(%Activity{
144 recipients: recipients
147 # Splice in the child object if we have one.
149 if not is_nil(object) do
150 Map.put(activity, :object, object)
155 BackgroundWorker.enqueue("fetch_data_for_activity", %{"activity_id" => activity.id})
157 Notification.create_notifications(activity)
159 conversation = create_or_bump_conversation(activity, map["actor"])
160 participations = get_participations(conversation)
162 stream_out_participations(participations)
165 %Activity{} = activity ->
168 {:fake, true, map, recipients} ->
169 activity = %Activity{
173 recipients: recipients,
177 Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
185 defp create_or_bump_conversation(activity, actor) do
186 with {:ok, conversation} <- Conversation.create_or_bump_for(activity),
187 %User{} = user <- User.get_cached_by_ap_id(actor),
188 Participation.mark_as_read(user, conversation) do
193 defp get_participations({:ok, conversation}) do
195 |> Repo.preload(:participations, force: true)
196 |> Map.get(:participations)
199 defp get_participations(_), do: []
201 def stream_out_participations(participations) do
204 |> Repo.preload(:user)
206 Streamer.stream("participation", participations)
209 def stream_out_participations(%Object{data: %{"context" => context}}, user) do
210 with %Conversation{} = conversation <- Conversation.get_for_ap_id(context),
211 conversation = Repo.preload(conversation, :participations),
213 fetch_latest_activity_id_for_context(conversation.ap_id, %{
215 "blocking_user" => user
217 if last_activity_id do
218 stream_out_participations(conversation.participations)
223 def stream_out_participations(_, _), do: :noop
225 def stream_out(%Activity{data: %{"type" => data_type}} = activity)
226 when data_type in ["Create", "Announce", "Delete"] do
228 |> Topics.get_activity_topics()
229 |> Streamer.stream(activity)
232 def stream_out(_activity) do
236 @spec create(map(), boolean()) :: {:ok, Activity.t()} | {:error, any()}
237 def create(params, fake \\ false) do
238 with {:ok, result} <- Repo.transaction(fn -> do_create(params, fake) end) do
243 defp do_create(%{to: to, actor: actor, context: context, object: object} = params, fake) do
244 additional = params[:additional] || %{}
245 # only accept false as false value
246 local = !(params[:local] == false)
247 published = params[:published]
248 quick_insert? = Config.get([:env]) == :benchmark
252 %{to: to, actor: actor, published: published, context: context, object: object},
255 {:ok, activity} <- insert(create_data, local, fake),
256 {:fake, false, activity} <- {:fake, fake, activity},
257 _ <- increase_replies_count_if_reply(create_data),
258 _ <- increase_poll_votes_if_vote(create_data),
259 {:quick_insert, false, activity} <- {:quick_insert, quick_insert?, activity},
260 {:ok, _actor} <- increase_note_count_if_public(actor, activity),
261 :ok <- maybe_federate(activity) do
264 {:quick_insert, true, activity} ->
267 {:fake, true, activity} ->
271 Repo.rollback(message)
275 @spec listen(map()) :: {:ok, Activity.t()} | {:error, any()}
276 def listen(%{to: to, actor: actor, context: context, object: object} = params) do
277 additional = params[:additional] || %{}
278 # only accept false as false value
279 local = !(params[:local] == false)
280 published = params[:published]
284 %{to: to, actor: actor, published: published, context: context, object: object},
287 {:ok, activity} <- insert(listen_data, local),
288 :ok <- maybe_federate(activity) do
293 @spec accept(map()) :: {:ok, Activity.t()} | {:error, any()}
294 def accept(params) do
295 accept_or_reject("Accept", params)
298 @spec reject(map()) :: {:ok, Activity.t()} | {:error, any()}
299 def reject(params) do
300 accept_or_reject("Reject", params)
303 @spec accept_or_reject(String.t(), map()) :: {:ok, Activity.t()} | {:error, any()}
304 def accept_or_reject(type, %{to: to, actor: actor, object: object} = params) do
305 local = Map.get(params, :local, true)
306 activity_id = Map.get(params, :activity_id, nil)
309 %{"to" => to, "type" => type, "actor" => actor.ap_id, "object" => object}
310 |> Utils.maybe_put("id", activity_id),
311 {:ok, activity} <- insert(data, local),
312 :ok <- maybe_federate(activity) do
317 @spec update(map()) :: {:ok, Activity.t()} | {:error, any()}
318 def update(%{to: to, cc: cc, actor: actor, object: object} = params) do
319 local = !(params[:local] == false)
320 activity_id = params[:activity_id]
329 data <- Utils.maybe_put(data, "id", activity_id),
330 {:ok, activity} <- insert(data, local),
331 :ok <- maybe_federate(activity) do
336 @spec react_with_emoji(User.t(), Object.t(), String.t(), keyword()) ::
337 {:ok, Activity.t(), Object.t()} | {:error, any()}
338 def react_with_emoji(user, object, emoji, options \\ []) do
339 with {:ok, result} <-
340 Repo.transaction(fn -> do_react_with_emoji(user, object, emoji, options) end) do
345 defp do_react_with_emoji(user, object, emoji, options) do
346 with local <- Keyword.get(options, :local, true),
347 activity_id <- Keyword.get(options, :activity_id, nil),
348 true <- Pleroma.Emoji.is_unicode_emoji?(emoji),
349 reaction_data <- make_emoji_reaction_data(user, object, emoji, activity_id),
350 {:ok, activity} <- insert(reaction_data, local),
351 {:ok, object} <- add_emoji_reaction_to_object(activity, object),
352 :ok <- maybe_federate(activity) do
353 {:ok, activity, object}
355 false -> {:error, false}
356 {:error, error} -> Repo.rollback(error)
360 @spec unreact_with_emoji(User.t(), String.t(), keyword()) ::
361 {:ok, Activity.t(), Object.t()} | {:error, any()}
362 def unreact_with_emoji(user, reaction_id, options \\ []) do
363 with {:ok, result} <-
364 Repo.transaction(fn -> do_unreact_with_emoji(user, reaction_id, options) end) do
369 defp do_unreact_with_emoji(user, reaction_id, options) do
370 with local <- Keyword.get(options, :local, true),
371 activity_id <- Keyword.get(options, :activity_id, nil),
372 user_ap_id <- user.ap_id,
373 %Activity{actor: ^user_ap_id} = reaction_activity <- Activity.get_by_ap_id(reaction_id),
374 object <- Object.normalize(reaction_activity),
375 unreact_data <- make_undo_data(user, reaction_activity, activity_id),
376 {:ok, activity} <- insert(unreact_data, local),
377 {:ok, object} <- remove_emoji_reaction_from_object(reaction_activity, object),
378 :ok <- maybe_federate(activity) do
379 {:ok, activity, object}
381 {:error, error} -> Repo.rollback(error)
385 # TODO: This is weird, maybe we shouldn't check here if we can make the activity.
386 @spec like(User.t(), Object.t(), String.t() | nil, boolean()) ::
387 {:ok, Activity.t(), Object.t()} | {:error, any()}
388 def like(user, object, activity_id \\ nil, local \\ true) do
389 with {:ok, result} <- Repo.transaction(fn -> do_like(user, object, activity_id, local) end) do
395 %User{ap_id: ap_id} = user,
396 %Object{data: %{"id" => _}} = object,
400 with nil <- get_existing_like(ap_id, object),
401 like_data <- make_like_data(user, object, activity_id),
402 {:ok, activity} <- insert(like_data, local),
403 {:ok, object} <- add_like_to_object(activity, object),
404 :ok <- maybe_federate(activity) do
405 {:ok, activity, object}
407 %Activity{} = activity ->
408 {:ok, activity, object}
415 @spec unlike(User.t(), Object.t(), String.t() | nil, boolean()) ::
416 {:ok, Activity.t(), Activity.t(), Object.t()} | {:ok, Object.t()} | {:error, any()}
417 def unlike(%User{} = actor, %Object{} = object, activity_id \\ nil, local \\ true) do
418 with {:ok, result} <-
419 Repo.transaction(fn -> do_unlike(actor, object, activity_id, local) end) do
424 defp do_unlike(actor, object, activity_id, local) do
425 with %Activity{} = like_activity <- get_existing_like(actor.ap_id, object),
426 unlike_data <- make_unlike_data(actor, like_activity, activity_id),
427 {:ok, unlike_activity} <- insert(unlike_data, local),
428 {:ok, _activity} <- Repo.delete(like_activity),
429 {:ok, object} <- remove_like_from_object(like_activity, object),
430 :ok <- maybe_federate(unlike_activity) do
431 {:ok, unlike_activity, like_activity, object}
434 {:error, error} -> Repo.rollback(error)
438 @spec announce(User.t(), Object.t(), String.t() | nil, boolean(), boolean()) ::
439 {:ok, Activity.t(), Object.t()} | {:error, any()}
441 %User{ap_id: _} = user,
442 %Object{data: %{"id" => _}} = object,
447 with {:ok, result} <-
448 Repo.transaction(fn -> do_announce(user, object, activity_id, local, public) end) do
453 defp do_announce(user, object, activity_id, local, public) do
454 with true <- is_announceable?(object, user, public),
455 announce_data <- make_announce_data(user, object, activity_id, public),
456 {:ok, activity} <- insert(announce_data, local),
457 {:ok, object} <- add_announce_to_object(activity, object),
458 :ok <- maybe_federate(activity) do
459 {:ok, activity, object}
461 false -> {:error, false}
462 {:error, error} -> Repo.rollback(error)
466 @spec unannounce(User.t(), Object.t(), String.t() | nil, boolean()) ::
467 {:ok, Activity.t(), Object.t()} | {:ok, Object.t()} | {:error, any()}
474 with {:ok, result} <-
475 Repo.transaction(fn -> do_unannounce(actor, object, activity_id, local) end) do
480 defp do_unannounce(actor, object, activity_id, local) do
481 with %Activity{} = announce_activity <- get_existing_announce(actor.ap_id, object),
482 unannounce_data <- make_unannounce_data(actor, announce_activity, activity_id),
483 {:ok, unannounce_activity} <- insert(unannounce_data, local),
484 :ok <- maybe_federate(unannounce_activity),
485 {:ok, _activity} <- Repo.delete(announce_activity),
486 {:ok, object} <- remove_announce_from_object(announce_activity, object) do
487 {:ok, unannounce_activity, object}
490 {:error, error} -> Repo.rollback(error)
494 @spec follow(User.t(), User.t(), String.t() | nil, boolean()) ::
495 {:ok, Activity.t()} | {:error, any()}
496 def follow(follower, followed, activity_id \\ nil, local \\ true) do
497 with {:ok, result} <-
498 Repo.transaction(fn -> do_follow(follower, followed, activity_id, local) end) do
503 defp do_follow(follower, followed, activity_id, local) do
504 with data <- make_follow_data(follower, followed, activity_id),
505 {:ok, activity} <- insert(data, local),
506 :ok <- maybe_federate(activity),
507 _ <- User.set_follow_state_cache(follower.ap_id, followed.ap_id, activity.data["state"]) do
510 {:error, error} -> Repo.rollback(error)
514 @spec unfollow(User.t(), User.t(), String.t() | nil, boolean()) ::
515 {:ok, Activity.t()} | nil | {:error, any()}
516 def unfollow(follower, followed, activity_id \\ nil, local \\ true) do
517 with {:ok, result} <-
518 Repo.transaction(fn -> do_unfollow(follower, followed, activity_id, local) end) do
523 defp do_unfollow(follower, followed, activity_id, local) do
524 with %Activity{} = follow_activity <- fetch_latest_follow(follower, followed),
525 {:ok, follow_activity} <- update_follow_state(follow_activity, "cancelled"),
526 unfollow_data <- make_unfollow_data(follower, followed, follow_activity, activity_id),
527 {:ok, activity} <- insert(unfollow_data, local),
528 :ok <- maybe_federate(activity) do
532 {:error, error} -> Repo.rollback(error)
536 @spec delete(User.t() | Object.t(), keyword()) :: {:ok, User.t() | Object.t()} | {:error, any()}
537 def delete(entity, options \\ []) do
538 with {:ok, result} <- Repo.transaction(fn -> do_delete(entity, options) end) do
543 defp do_delete(%User{ap_id: ap_id, follower_address: follower_address} = user, _) do
545 "to" => [follower_address],
548 "object" => %{"type" => "Person", "id" => ap_id}
550 {:ok, activity} <- insert(data, true, true, true),
551 :ok <- maybe_federate(activity) do
556 defp do_delete(%Object{data: %{"id" => id, "actor" => actor}} = object, options) do
557 local = Keyword.get(options, :local, true)
558 activity_id = Keyword.get(options, :activity_id, nil)
559 actor = Keyword.get(options, :actor, actor)
561 user = User.get_cached_by_ap_id(actor)
562 to = (object.data["to"] || []) ++ (object.data["cc"] || [])
564 with create_activity <- Activity.get_create_by_object_ap_id(id),
571 "deleted_activity_id" => create_activity && create_activity.id
573 |> maybe_put("id", activity_id),
574 {:ok, activity} <- insert(data, local, false),
575 {:ok, object, _create_activity} <- Object.delete(object),
576 stream_out_participations(object, user),
577 _ <- decrease_replies_count_if_reply(object),
578 {:ok, _actor} <- decrease_note_count_if_public(user, object),
579 :ok <- maybe_federate(activity) do
587 defp do_delete(%Object{data: %{"type" => "Tombstone", "id" => ap_id}}, _) do
590 |> Activity.Queries.by_object_id()
591 |> Activity.Queries.by_type("Delete")
597 @spec block(User.t(), User.t(), String.t() | nil, boolean()) ::
598 {:ok, Activity.t()} | {:error, any()}
599 def block(blocker, blocked, activity_id \\ nil, local \\ true) do
600 with {:ok, result} <-
601 Repo.transaction(fn -> do_block(blocker, blocked, activity_id, local) end) do
606 defp do_block(blocker, blocked, activity_id, local) do
607 outgoing_blocks = Config.get([:activitypub, :outgoing_blocks])
608 unfollow_blocked = Config.get([:activitypub, :unfollow_blocked])
610 if unfollow_blocked do
611 follow_activity = fetch_latest_follow(blocker, blocked)
612 if follow_activity, do: unfollow(blocker, blocked, nil, local)
615 with true <- outgoing_blocks,
616 block_data <- make_block_data(blocker, blocked, activity_id),
617 {:ok, activity} <- insert(block_data, local),
618 :ok <- maybe_federate(activity) do
621 {:error, error} -> Repo.rollback(error)
625 @spec unblock(User.t(), User.t(), String.t() | nil, boolean()) ::
626 {:ok, Activity.t()} | {:error, any()} | nil
627 def unblock(blocker, blocked, activity_id \\ nil, local \\ true) do
628 with {:ok, result} <-
629 Repo.transaction(fn -> do_unblock(blocker, blocked, activity_id, local) end) do
634 defp do_unblock(blocker, blocked, activity_id, local) do
635 with %Activity{} = block_activity <- fetch_latest_block(blocker, blocked),
636 unblock_data <- make_unblock_data(blocker, blocked, block_activity, activity_id),
637 {:ok, activity} <- insert(unblock_data, local),
638 :ok <- maybe_federate(activity) do
642 {:error, error} -> Repo.rollback(error)
646 @spec flag(map()) :: {:ok, Activity.t()} | {:error, any()}
656 # only accept false as false value
657 local = !(params[:local] == false)
658 forward = !(params[:forward] == false)
660 additional = params[:additional] || %{}
664 Map.merge(additional, %{"to" => [], "cc" => [account.ap_id]})
666 Map.merge(additional, %{"to" => [], "cc" => []})
669 with flag_data <- make_flag_data(params, additional),
670 {:ok, activity} <- insert(flag_data, local),
671 {:ok, stripped_activity} <- strip_report_status_data(activity),
672 :ok <- maybe_federate(stripped_activity) do
673 User.all_superusers()
674 |> Enum.filter(fn user -> not is_nil(user.email) end)
675 |> Enum.each(fn superuser ->
677 |> Pleroma.Emails.AdminEmail.report(actor, account, statuses, content)
678 |> Pleroma.Emails.Mailer.deliver_async()
685 @spec move(User.t(), User.t(), boolean()) :: {:ok, Activity.t()} | {:error, any()}
686 def move(%User{} = origin, %User{} = target, local \\ true) do
689 "actor" => origin.ap_id,
690 "object" => origin.ap_id,
691 "target" => target.ap_id
694 with true <- origin.ap_id in target.also_known_as,
695 {:ok, activity} <- insert(params, local) do
696 maybe_federate(activity)
698 BackgroundWorker.enqueue("move_following", %{
699 "origin_id" => origin.id,
700 "target_id" => target.id
705 false -> {:error, "Target account must have the origin in `alsoKnownAs`"}
710 defp fetch_activities_for_context_query(context, opts) do
711 public = [Constants.as_public()]
715 do: [opts["user"].ap_id | User.following(opts["user"])] ++ public,
718 from(activity in Activity)
719 |> maybe_preload_objects(opts)
720 |> maybe_preload_bookmarks(opts)
721 |> maybe_set_thread_muted_field(opts)
722 |> restrict_blocked(opts)
723 |> restrict_recipients(recipients, opts["user"])
727 "?->>'type' = ? and ?->>'context' = ?",
734 |> exclude_poll_votes(opts)
736 |> order_by([activity], desc: activity.id)
739 @spec fetch_activities_for_context(String.t(), keyword() | map()) :: [Activity.t()]
740 def fetch_activities_for_context(context, opts \\ %{}) do
742 |> fetch_activities_for_context_query(opts)
746 @spec fetch_latest_activity_id_for_context(String.t(), keyword() | map()) ::
747 FlakeId.Ecto.CompatType.t() | nil
748 def fetch_latest_activity_id_for_context(context, opts \\ %{}) do
750 |> fetch_activities_for_context_query(Map.merge(%{"skip_preload" => true}, opts))
756 @spec fetch_public_activities(map(), Pagination.type()) :: [Activity.t()]
757 def fetch_public_activities(opts \\ %{}, pagination \\ :keyset) do
758 opts = Map.drop(opts, ["user"])
760 [Constants.as_public()]
761 |> fetch_activities_query(opts)
762 |> restrict_unlisted()
763 |> Pagination.fetch_paginated(opts, pagination)
766 @valid_visibilities ~w[direct unlisted public private]
768 defp restrict_visibility(query, %{visibility: visibility})
769 when is_list(visibility) do
770 if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
776 "activity_visibility(?, ?, ?) = ANY (?)",
786 Logger.error("Could not restrict visibility to #{visibility}")
790 defp restrict_visibility(query, %{visibility: visibility})
791 when visibility in @valid_visibilities do
795 fragment("activity_visibility(?, ?, ?) = ?", a.actor, a.recipients, a.data, ^visibility)
799 defp restrict_visibility(_query, %{visibility: visibility})
800 when visibility not in @valid_visibilities do
801 Logger.error("Could not restrict visibility to #{visibility}")
804 defp restrict_visibility(query, _visibility), do: query
806 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
807 when is_list(visibility) do
808 if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
813 "activity_visibility(?, ?, ?) = ANY (?)",
821 Logger.error("Could not exclude visibility to #{visibility}")
826 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
827 when visibility in @valid_visibilities do
832 "activity_visibility(?, ?, ?) = ?",
841 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
842 when visibility not in @valid_visibilities do
843 Logger.error("Could not exclude visibility to #{visibility}")
847 defp exclude_visibility(query, _visibility), do: query
849 defp restrict_thread_visibility(query, _, %{skip_thread_containment: true} = _),
852 defp restrict_thread_visibility(
854 %{"user" => %User{skip_thread_containment: true}},
859 defp restrict_thread_visibility(query, %{"user" => %User{ap_id: ap_id}}, _) do
862 where: fragment("thread_visibility(?, (?)->>'id') = true", ^ap_id, a.data)
866 defp restrict_thread_visibility(query, _, _), do: query
868 def fetch_user_abstract_activities(user, reading_user, params \\ %{}) do
871 |> Map.put("user", reading_user)
872 |> Map.put("actor_id", user.ap_id)
875 user_activities_recipients(%{
876 "godmode" => params["godmode"],
877 "reading_user" => reading_user
880 fetch_activities(recipients, params)
884 def fetch_user_activities(user, reading_user, params \\ %{}) do
887 |> Map.put("type", ["Create", "Announce"])
888 |> Map.put("user", reading_user)
889 |> Map.put("actor_id", user.ap_id)
890 |> Map.put("pinned_activity_ids", user.pinned_activities)
893 if User.blocks?(reading_user, user) do
897 |> Map.put("blocking_user", reading_user)
898 |> Map.put("muting_user", reading_user)
902 user_activities_recipients(%{
903 "godmode" => params["godmode"],
904 "reading_user" => reading_user
907 fetch_activities(recipients, params)
911 def fetch_statuses(reading_user, params) do
914 |> Map.put("type", ["Create", "Announce"])
917 user_activities_recipients(%{
918 "godmode" => params["godmode"],
919 "reading_user" => reading_user
922 fetch_activities(recipients, params, :offset)
926 defp user_activities_recipients(%{"godmode" => true}) do
930 defp user_activities_recipients(%{"reading_user" => reading_user}) do
932 [Constants.as_public()] ++ [reading_user.ap_id | User.following(reading_user)]
934 [Constants.as_public()]
938 defp restrict_since(query, %{"since_id" => ""}), do: query
940 defp restrict_since(query, %{"since_id" => since_id}) do
941 from(activity in query, where: activity.id > ^since_id)
944 defp restrict_since(query, _), do: query
946 defp restrict_tag_reject(_query, %{"tag_reject" => _tag_reject, "skip_preload" => true}) do
947 raise "Can't use the child object without preloading!"
950 defp restrict_tag_reject(query, %{"tag_reject" => tag_reject})
951 when is_list(tag_reject) and tag_reject != [] do
953 [_activity, object] in query,
954 where: fragment("not (?)->'tag' \\?| (?)", object.data, ^tag_reject)
958 defp restrict_tag_reject(query, _), do: query
960 defp restrict_tag_all(_query, %{"tag_all" => _tag_all, "skip_preload" => true}) do
961 raise "Can't use the child object without preloading!"
964 defp restrict_tag_all(query, %{"tag_all" => tag_all})
965 when is_list(tag_all) and tag_all != [] do
967 [_activity, object] in query,
968 where: fragment("(?)->'tag' \\?& (?)", object.data, ^tag_all)
972 defp restrict_tag_all(query, _), do: query
974 defp restrict_tag(_query, %{"tag" => _tag, "skip_preload" => true}) do
975 raise "Can't use the child object without preloading!"
978 defp restrict_tag(query, %{"tag" => tag}) when is_list(tag) do
980 [_activity, object] in query,
981 where: fragment("(?)->'tag' \\?| (?)", object.data, ^tag)
985 defp restrict_tag(query, %{"tag" => tag}) when is_binary(tag) do
987 [_activity, object] in query,
988 where: fragment("(?)->'tag' \\? (?)", object.data, ^tag)
992 defp restrict_tag(query, _), do: query
994 defp restrict_recipients(query, [], _user), do: query
996 defp restrict_recipients(query, recipients, nil) do
997 from(activity in query, where: fragment("? && ?", ^recipients, activity.recipients))
1000 defp restrict_recipients(query, recipients, user) do
1003 where: fragment("? && ?", ^recipients, activity.recipients),
1004 or_where: activity.actor == ^user.ap_id
1008 defp restrict_local(query, %{"local_only" => true}) do
1009 from(activity in query, where: activity.local == true)
1012 defp restrict_local(query, _), do: query
1014 defp restrict_actor(query, %{"actor_id" => actor_id}) do
1015 from(activity in query, where: activity.actor == ^actor_id)
1018 defp restrict_actor(query, _), do: query
1020 defp restrict_type(query, %{"type" => type}) when is_binary(type) do
1021 from(activity in query, where: fragment("?->>'type' = ?", activity.data, ^type))
1024 defp restrict_type(query, %{"type" => type}) do
1025 from(activity in query, where: fragment("?->>'type' = ANY(?)", activity.data, ^type))
1028 defp restrict_type(query, _), do: query
1030 defp restrict_state(query, %{"state" => state}) do
1031 from(activity in query, where: fragment("?->>'state' = ?", activity.data, ^state))
1034 defp restrict_state(query, _), do: query
1036 defp restrict_favorited_by(query, %{"favorited_by" => ap_id}) do
1038 [_activity, object] in query,
1039 where: fragment("(?)->'likes' \\? (?)", object.data, ^ap_id)
1043 defp restrict_favorited_by(query, _), do: query
1045 defp restrict_media(_query, %{"only_media" => _val, "skip_preload" => true}) do
1046 raise "Can't use the child object without preloading!"
1049 defp restrict_media(query, %{"only_media" => val}) when val == "true" or val == "1" do
1051 [_activity, object] in query,
1052 where: fragment("not (?)->'attachment' = (?)", object.data, ^[])
1056 defp restrict_media(query, _), do: query
1058 defp restrict_replies(query, %{"exclude_replies" => val}) when val == "true" or val == "1" do
1060 [_activity, object] in query,
1061 where: fragment("?->>'inReplyTo' is null", object.data)
1065 defp restrict_replies(query, _), do: query
1067 defp restrict_reblogs(query, %{"exclude_reblogs" => val}) when val == "true" or val == "1" do
1068 from(activity in query, where: fragment("?->>'type' != 'Announce'", activity.data))
1071 defp restrict_reblogs(query, _), do: query
1073 defp restrict_muted(query, %{"with_muted" => val}) when val in [true, "true", "1"], do: query
1075 defp restrict_muted(query, %{"muting_user" => %User{} = user} = opts) do
1076 mutes = opts["muted_users_ap_ids"] || User.muted_users_ap_ids(user)
1079 from([activity] in query,
1080 where: fragment("not (? = ANY(?))", activity.actor, ^mutes),
1081 where: fragment("not (?->'to' \\?| ?)", activity.data, ^mutes)
1084 unless opts["skip_preload"] do
1085 from([thread_mute: tm] in query, where: is_nil(tm.user_id))
1091 defp restrict_muted(query, _), do: query
1093 defp restrict_blocked(query, %{"blocking_user" => %User{} = user} = opts) do
1094 blocked_ap_ids = opts["blocked_users_ap_ids"] || User.blocked_users_ap_ids(user)
1095 domain_blocks = user.domain_blocks || []
1097 following_ap_ids = User.get_friends_ap_ids(user)
1100 if has_named_binding?(query, :object), do: query, else: Activity.with_joined_object(query)
1103 [activity, object: o] in query,
1104 where: fragment("not (? = ANY(?))", activity.actor, ^blocked_ap_ids),
1105 where: fragment("not (? && ?)", activity.recipients, ^blocked_ap_ids),
1108 "not (?->>'type' = 'Announce' and ?->'to' \\?| ?)",
1115 "(not (split_part(?, '/', 3) = ANY(?))) or ? = ANY(?)",
1123 "(not (split_part(?->>'actor', '/', 3) = ANY(?))) or (?->>'actor') = ANY(?)",
1132 defp restrict_blocked(query, _), do: query
1134 defp restrict_unlisted(query) do
1139 "not (coalesce(?->'cc', '{}'::jsonb) \\?| ?)",
1141 ^[Constants.as_public()]
1146 defp restrict_pinned(query, %{"pinned" => "true", "pinned_activity_ids" => ids}) do
1147 from(activity in query, where: activity.id in ^ids)
1150 defp restrict_pinned(query, _), do: query
1152 defp restrict_muted_reblogs(query, %{"muting_user" => %User{} = user} = opts) do
1153 muted_reblogs = opts["reblog_muted_users_ap_ids"] || User.reblog_muted_users_ap_ids(user)
1159 "not ( ?->>'type' = 'Announce' and ? = ANY(?))",
1167 defp restrict_muted_reblogs(query, _), do: query
1169 defp restrict_instance(query, %{"instance" => instance}) do
1174 where: fragment("? LIKE ?", u.nickname, ^"%@#{instance}")
1178 from(activity in query, where: activity.actor in ^users)
1181 defp restrict_instance(query, _), do: query
1183 defp exclude_poll_votes(query, %{"include_poll_votes" => true}), do: query
1185 defp exclude_poll_votes(query, _) do
1186 if has_named_binding?(query, :object) do
1187 from([activity, object: o] in query,
1188 where: fragment("not(?->>'type' = ?)", o.data, "Answer")
1195 defp exclude_id(query, %{"exclude_id" => id}) when is_binary(id) do
1196 from(activity in query, where: activity.id != ^id)
1199 defp exclude_id(query, _), do: query
1201 defp maybe_preload_objects(query, %{"skip_preload" => true}), do: query
1203 defp maybe_preload_objects(query, _) do
1205 |> Activity.with_preloaded_object()
1208 defp maybe_preload_bookmarks(query, %{"skip_preload" => true}), do: query
1210 defp maybe_preload_bookmarks(query, opts) do
1212 |> Activity.with_preloaded_bookmark(opts["user"])
1215 defp maybe_preload_report_notes(query, %{"preload_report_notes" => true}) do
1217 |> Activity.with_preloaded_report_notes()
1220 defp maybe_preload_report_notes(query, _), do: query
1222 defp maybe_set_thread_muted_field(query, %{"skip_preload" => true}), do: query
1224 defp maybe_set_thread_muted_field(query, opts) do
1226 |> Activity.with_set_thread_muted_field(opts["muting_user"] || opts["user"])
1229 defp maybe_order(query, %{order: :desc}) do
1231 |> order_by(desc: :id)
1234 defp maybe_order(query, %{order: :asc}) do
1236 |> order_by(asc: :id)
1239 defp maybe_order(query, _), do: query
1241 defp fetch_activities_query_ap_ids_ops(opts) do
1242 source_user = opts["muting_user"]
1243 ap_id_relationships = if source_user, do: [:mute, :reblog_mute], else: []
1245 ap_id_relationships =
1246 ap_id_relationships ++
1247 if opts["blocking_user"] && opts["blocking_user"] == source_user do
1253 preloaded_ap_ids = User.outgoing_relationships_ap_ids(source_user, ap_id_relationships)
1255 restrict_blocked_opts = Map.merge(%{"blocked_users_ap_ids" => preloaded_ap_ids[:block]}, opts)
1256 restrict_muted_opts = Map.merge(%{"muted_users_ap_ids" => preloaded_ap_ids[:mute]}, opts)
1258 restrict_muted_reblogs_opts =
1259 Map.merge(%{"reblog_muted_users_ap_ids" => preloaded_ap_ids[:reblog_mute]}, opts)
1261 {restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts}
1264 def fetch_activities_query(recipients, opts \\ %{}) do
1265 {restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts} =
1266 fetch_activities_query_ap_ids_ops(opts)
1269 skip_thread_containment: Config.get([:instance, :skip_thread_containment])
1273 |> maybe_preload_objects(opts)
1274 |> maybe_preload_bookmarks(opts)
1275 |> maybe_preload_report_notes(opts)
1276 |> maybe_set_thread_muted_field(opts)
1277 |> maybe_order(opts)
1278 |> restrict_recipients(recipients, opts["user"])
1279 |> restrict_tag(opts)
1280 |> restrict_tag_reject(opts)
1281 |> restrict_tag_all(opts)
1282 |> restrict_since(opts)
1283 |> restrict_local(opts)
1284 |> restrict_actor(opts)
1285 |> restrict_type(opts)
1286 |> restrict_state(opts)
1287 |> restrict_favorited_by(opts)
1288 |> restrict_blocked(restrict_blocked_opts)
1289 |> restrict_muted(restrict_muted_opts)
1290 |> restrict_media(opts)
1291 |> restrict_visibility(opts)
1292 |> restrict_thread_visibility(opts, config)
1293 |> restrict_replies(opts)
1294 |> restrict_reblogs(opts)
1295 |> restrict_pinned(opts)
1296 |> restrict_muted_reblogs(restrict_muted_reblogs_opts)
1297 |> restrict_instance(opts)
1298 |> Activity.restrict_deactivated_users()
1299 |> exclude_poll_votes(opts)
1300 |> exclude_visibility(opts)
1303 def fetch_activities(recipients, opts \\ %{}, pagination \\ :keyset) do
1304 list_memberships = Pleroma.List.memberships(opts["user"])
1306 fetch_activities_query(recipients ++ list_memberships, opts)
1307 |> Pagination.fetch_paginated(opts, pagination)
1309 |> maybe_update_cc(list_memberships, opts["user"])
1313 Fetch favorites activities of user with order by sort adds to favorites
1315 @spec fetch_favourites(User.t(), map(), Pagination.type()) :: list(Activity.t())
1316 def fetch_favourites(user, params \\ %{}, pagination \\ :keyset) do
1318 |> Activity.Queries.by_actor()
1319 |> Activity.Queries.by_type("Like")
1320 |> Activity.with_joined_object()
1321 |> Object.with_joined_activity()
1322 |> select([_like, object, activity], %{activity | object: object})
1323 |> order_by([like, _, _], desc: like.id)
1324 |> Pagination.fetch_paginated(
1325 Map.merge(params, %{"skip_order" => true}),
1331 defp maybe_update_cc(activities, list_memberships, %User{ap_id: user_ap_id})
1332 when is_list(list_memberships) and length(list_memberships) > 0 do
1333 Enum.map(activities, fn
1334 %{data: %{"bcc" => bcc}} = activity when is_list(bcc) and length(bcc) > 0 ->
1335 if Enum.any?(bcc, &(&1 in list_memberships)) do
1336 update_in(activity.data["cc"], &[user_ap_id | &1])
1346 defp maybe_update_cc(activities, _, _), do: activities
1348 def fetch_activities_bounded_query(query, recipients, recipients_with_public) do
1349 from(activity in query,
1351 fragment("? && ?", activity.recipients, ^recipients) or
1352 (fragment("? && ?", activity.recipients, ^recipients_with_public) and
1353 ^Constants.as_public() in activity.recipients)
1357 def fetch_activities_bounded(
1359 recipients_with_public,
1361 pagination \\ :keyset
1363 fetch_activities_query([], opts)
1364 |> fetch_activities_bounded_query(recipients, recipients_with_public)
1365 |> Pagination.fetch_paginated(opts, pagination)
1369 @spec upload(Upload.source(), keyword()) :: {:ok, Object.t()} | {:error, any()}
1370 def upload(file, opts \\ []) do
1371 with {:ok, data} <- Upload.store(file, opts) do
1374 Map.put(data, "actor", opts[:actor])
1379 Repo.insert(%Object{data: obj_data})
1383 defp object_to_user_data(data) do
1385 data["icon"]["url"] &&
1388 "url" => [%{"href" => data["icon"]["url"]}]
1392 data["image"]["url"] &&
1395 "url" => [%{"href" => data["image"]["url"]}]
1400 |> Map.get("attachment", [])
1401 |> Enum.filter(fn %{"type" => t} -> t == "PropertyValue" end)
1402 |> Enum.map(fn fields -> Map.take(fields, ["name", "value"]) end)
1404 locked = data["manuallyApprovesFollowers"] || false
1405 data = Transmogrifier.maybe_fix_user_object(data)
1406 discoverable = data["discoverable"] || false
1407 invisible = data["invisible"] || false
1408 actor_type = data["type"] || "Person"
1417 discoverable: discoverable,
1418 invisible: invisible,
1421 follower_address: data["followers"],
1422 following_address: data["following"],
1423 bio: data["summary"],
1424 actor_type: actor_type,
1425 also_known_as: Map.get(data, "alsoKnownAs", [])
1428 # nickname can be nil because of virtual actors
1430 if data["preferredUsername"] do
1434 "#{data["preferredUsername"]}@#{URI.parse(data["id"]).host}"
1437 Map.put(user_data, :nickname, nil)
1443 def fetch_follow_information_for_user(user) do
1444 with {:ok, following_data} <-
1445 Fetcher.fetch_and_contain_remote_object_from_id(user.following_address),
1446 {:ok, hide_follows} <- collection_private(following_data),
1447 {:ok, followers_data} <-
1448 Fetcher.fetch_and_contain_remote_object_from_id(user.follower_address),
1449 {:ok, hide_followers} <- collection_private(followers_data) do
1452 hide_follows: hide_follows,
1453 follower_count: normalize_counter(followers_data["totalItems"]),
1454 following_count: normalize_counter(following_data["totalItems"]),
1455 hide_followers: hide_followers
1458 {:error, _} = e -> e
1463 defp normalize_counter(counter) when is_integer(counter), do: counter
1464 defp normalize_counter(_), do: 0
1466 defp maybe_update_follow_information(data) do
1467 with {:enabled, true} <- {:enabled, Config.get([:instance, :external_user_synchronization])},
1468 {:ok, info} <- fetch_follow_information_for_user(data) do
1469 info = Map.merge(data[:info] || %{}, info)
1470 Map.put(data, :info, info)
1472 {:enabled, false} ->
1477 "Follower/Following counter update for #{data.ap_id} failed.\n" <> inspect(e)
1484 defp collection_private(%{"first" => %{"type" => type}})
1485 when type in ["CollectionPage", "OrderedCollectionPage"],
1488 defp collection_private(%{"first" => first}) do
1489 with {:ok, %{"type" => type}} when type in ["CollectionPage", "OrderedCollectionPage"] <-
1490 Fetcher.fetch_and_contain_remote_object_from_id(first) do
1493 {:error, {:ok, %{status: code}}} when code in [401, 403] -> {:ok, true}
1494 {:error, _} = e -> e
1499 defp collection_private(_data), do: {:ok, true}
1501 def user_data_from_user_object(data) do
1502 with {:ok, data} <- MRF.filter(data),
1503 {:ok, data} <- object_to_user_data(data) do
1510 def fetch_and_prepare_user_from_ap_id(ap_id) do
1511 with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id),
1512 {:ok, data} <- user_data_from_user_object(data),
1513 data <- maybe_update_follow_information(data) do
1516 {:error, "Object has been deleted"} = e ->
1517 Logger.debug("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
1521 Logger.error("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
1526 def make_user_from_ap_id(ap_id) do
1527 if _user = User.get_cached_by_ap_id(ap_id) do
1528 Transmogrifier.upgrade_user_from_ap_id(ap_id)
1530 with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id) do
1531 User.insert_or_update_user(data)
1538 def make_user_from_nickname(nickname) do
1539 with {:ok, %{"ap_id" => ap_id}} when not is_nil(ap_id) <- WebFinger.finger(nickname) do
1540 make_user_from_ap_id(ap_id)
1542 _e -> {:error, "No AP id in WebFinger"}
1546 # filter out broken threads
1547 def contain_broken_threads(%Activity{} = activity, %User{} = user) do
1548 entire_thread_visible_for_user?(activity, user)
1551 # do post-processing on a specific activity
1552 def contain_activity(%Activity{} = activity, %User{} = user) do
1553 contain_broken_threads(activity, user)
1556 def fetch_direct_messages_query do
1558 |> restrict_type(%{"type" => "Create"})
1559 |> restrict_visibility(%{visibility: "direct"})
1560 |> order_by([activity], asc: activity.id)