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 {:quick_insert, false, activity} <- {:quick_insert, quick_insert?, activity},
274 _ <- increase_replies_count_if_reply(create_data),
275 _ <- increase_poll_votes_if_vote(create_data),
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 announce_data <- make_announce_data(user, object, activity_id, public),
442 {:ok, activity} <- insert(announce_data, local),
443 {:ok, object} <- add_announce_to_object(activity, object),
444 :ok <- maybe_federate(activity) do
445 {:ok, activity, object}
447 false -> {:error, false}
448 {:error, error} -> Repo.rollback(error)
452 @spec unannounce(User.t(), Object.t(), String.t() | nil, boolean()) ::
453 {:ok, Activity.t(), Object.t()} | {:ok, Object.t()} | {:error, any()}
460 with {:ok, result} <-
461 Repo.transaction(fn -> do_unannounce(actor, object, activity_id, local) end) do
466 defp do_unannounce(actor, object, activity_id, local) do
467 with %Activity{} = announce_activity <- get_existing_announce(actor.ap_id, object),
468 unannounce_data <- make_unannounce_data(actor, announce_activity, activity_id),
469 {:ok, unannounce_activity} <- insert(unannounce_data, local),
470 :ok <- maybe_federate(unannounce_activity),
471 {:ok, _activity} <- Repo.delete(announce_activity),
472 {:ok, object} <- remove_announce_from_object(announce_activity, object) do
473 {:ok, unannounce_activity, object}
476 {:error, error} -> Repo.rollback(error)
480 @spec follow(User.t(), User.t(), String.t() | nil, boolean()) ::
481 {:ok, Activity.t()} | {:error, any()}
482 def follow(follower, followed, activity_id \\ nil, local \\ true) do
483 with {:ok, result} <-
484 Repo.transaction(fn -> do_follow(follower, followed, activity_id, local) end) do
489 defp do_follow(follower, followed, activity_id, local) do
490 with data <- make_follow_data(follower, followed, activity_id),
491 {:ok, activity} <- insert(data, local),
492 :ok <- maybe_federate(activity) do
495 {:error, error} -> Repo.rollback(error)
499 @spec unfollow(User.t(), User.t(), String.t() | nil, boolean()) ::
500 {:ok, Activity.t()} | nil | {:error, any()}
501 def unfollow(follower, followed, activity_id \\ nil, local \\ true) do
502 with {:ok, result} <-
503 Repo.transaction(fn -> do_unfollow(follower, followed, activity_id, local) end) do
508 defp do_unfollow(follower, followed, activity_id, local) do
509 with %Activity{} = follow_activity <- fetch_latest_follow(follower, followed),
510 {:ok, follow_activity} <- update_follow_state(follow_activity, "cancelled"),
511 unfollow_data <- make_unfollow_data(follower, followed, follow_activity, activity_id),
512 {:ok, activity} <- insert(unfollow_data, local),
513 :ok <- maybe_federate(activity) do
517 {:error, error} -> Repo.rollback(error)
521 @spec delete(User.t() | Object.t(), keyword()) :: {:ok, User.t() | Object.t()} | {:error, any()}
522 def delete(entity, options \\ []) do
523 with {:ok, result} <- Repo.transaction(fn -> do_delete(entity, options) end) do
528 defp do_delete(%User{ap_id: ap_id, follower_address: follower_address} = user, _) do
530 "to" => [follower_address],
533 "object" => %{"type" => "Person", "id" => ap_id}
535 {:ok, activity} <- insert(data, true, true, true),
536 :ok <- maybe_federate(activity) do
541 defp do_delete(%Object{data: %{"id" => id, "actor" => actor}} = object, options) do
542 local = Keyword.get(options, :local, true)
543 activity_id = Keyword.get(options, :activity_id, nil)
544 actor = Keyword.get(options, :actor, actor)
546 user = User.get_cached_by_ap_id(actor)
547 to = (object.data["to"] || []) ++ (object.data["cc"] || [])
549 with create_activity <- Activity.get_create_by_object_ap_id(id),
556 "deleted_activity_id" => create_activity && create_activity.id
558 |> maybe_put("id", activity_id),
559 {:ok, activity} <- insert(data, local, false),
560 {:ok, object, _create_activity} <- Object.delete(object),
561 stream_out_participations(object, user),
562 _ <- decrease_replies_count_if_reply(object),
563 {:ok, _actor} <- decrease_note_count_if_public(user, object),
564 :ok <- maybe_federate(activity) do
572 defp do_delete(%Object{data: %{"type" => "Tombstone", "id" => ap_id}}, _) do
575 |> Activity.Queries.by_object_id()
576 |> Activity.Queries.by_type("Delete")
582 @spec block(User.t(), User.t(), String.t() | nil, boolean()) ::
583 {:ok, Activity.t()} | {:error, any()}
584 def block(blocker, blocked, activity_id \\ nil, local \\ true) do
585 with {:ok, result} <-
586 Repo.transaction(fn -> do_block(blocker, blocked, activity_id, local) end) do
591 defp do_block(blocker, blocked, activity_id, local) do
592 outgoing_blocks = Config.get([:activitypub, :outgoing_blocks])
593 unfollow_blocked = Config.get([:activitypub, :unfollow_blocked])
595 if unfollow_blocked do
596 follow_activity = fetch_latest_follow(blocker, blocked)
597 if follow_activity, do: unfollow(blocker, blocked, nil, local)
600 with true <- outgoing_blocks,
601 block_data <- make_block_data(blocker, blocked, activity_id),
602 {:ok, activity} <- insert(block_data, local),
603 :ok <- maybe_federate(activity) do
606 {:error, error} -> Repo.rollback(error)
610 @spec unblock(User.t(), User.t(), String.t() | nil, boolean()) ::
611 {:ok, Activity.t()} | {:error, any()} | nil
612 def unblock(blocker, blocked, activity_id \\ nil, local \\ true) do
613 with {:ok, result} <-
614 Repo.transaction(fn -> do_unblock(blocker, blocked, activity_id, local) end) do
619 defp do_unblock(blocker, blocked, activity_id, local) do
620 with %Activity{} = block_activity <- fetch_latest_block(blocker, blocked),
621 unblock_data <- make_unblock_data(blocker, blocked, block_activity, activity_id),
622 {:ok, activity} <- insert(unblock_data, local),
623 :ok <- maybe_federate(activity) do
627 {:error, error} -> Repo.rollback(error)
631 @spec flag(map()) :: {:ok, Activity.t()} | {:error, any()}
641 # only accept false as false value
642 local = !(params[:local] == false)
643 forward = !(params[:forward] == false)
645 additional = params[:additional] || %{}
649 Map.merge(additional, %{"to" => [], "cc" => [account.ap_id]})
651 Map.merge(additional, %{"to" => [], "cc" => []})
654 with flag_data <- make_flag_data(params, additional),
655 {:ok, activity} <- insert(flag_data, local),
656 {:ok, stripped_activity} <- strip_report_status_data(activity),
657 :ok <- maybe_federate(stripped_activity) do
658 User.all_superusers()
659 |> Enum.filter(fn user -> not is_nil(user.email) end)
660 |> Enum.each(fn superuser ->
662 |> Pleroma.Emails.AdminEmail.report(actor, account, statuses, content)
663 |> Pleroma.Emails.Mailer.deliver_async()
670 @spec move(User.t(), User.t(), boolean()) :: {:ok, Activity.t()} | {:error, any()}
671 def move(%User{} = origin, %User{} = target, local \\ true) do
674 "actor" => origin.ap_id,
675 "object" => origin.ap_id,
676 "target" => target.ap_id
679 with true <- origin.ap_id in target.also_known_as,
680 {:ok, activity} <- insert(params, local) do
681 maybe_federate(activity)
683 BackgroundWorker.enqueue("move_following", %{
684 "origin_id" => origin.id,
685 "target_id" => target.id
690 false -> {:error, "Target account must have the origin in `alsoKnownAs`"}
695 def fetch_activities_for_context_query(context, opts) do
696 public = [Constants.as_public()]
700 do: [opts["user"].ap_id | User.following(opts["user"])] ++ public,
703 opts = Map.put(opts, "user", opts["user"])
705 from(activity in Activity)
706 |> maybe_preload_objects(opts)
707 |> maybe_preload_bookmarks(opts)
708 |> maybe_set_thread_muted_field(opts)
709 |> restrict_blocked(opts)
710 |> restrict_recipients(recipients, opts)
714 "?->>'type' = ? and ?->>'context' = ?",
721 |> exclude_poll_votes(opts)
723 |> order_by([activity], desc: activity.id)
726 @spec fetch_activities_for_context(String.t(), keyword() | map()) :: [Activity.t()]
727 def fetch_activities_for_context(context, opts \\ %{}) do
729 |> fetch_activities_for_context_query(opts)
733 @spec fetch_latest_activity_id_for_context(String.t(), keyword() | map()) ::
734 FlakeId.Ecto.CompatType.t() | nil
735 def fetch_latest_activity_id_for_context(context, opts \\ %{}) do
737 |> fetch_activities_for_context_query(Map.merge(%{"skip_preload" => true}, opts))
743 @spec fetch_public_activities(map(), Pagination.type()) :: [Activity.t()]
744 def fetch_public_activities(opts \\ %{}, pagination \\ :keyset) do
747 |> Map.put("reply_user", opts["user"])
748 |> Map.delete("user")
750 [Constants.as_public()]
751 |> fetch_activities_query(opts)
752 |> restrict_unlisted()
753 |> Pagination.fetch_paginated(opts, pagination)
756 @valid_visibilities ~w[direct unlisted public private]
758 defp restrict_visibility(query, %{visibility: visibility})
759 when is_list(visibility) do
760 if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
766 "activity_visibility(?, ?, ?) = ANY (?)",
776 Logger.error("Could not restrict visibility to #{visibility}")
780 defp restrict_visibility(query, %{visibility: visibility})
781 when visibility in @valid_visibilities do
785 fragment("activity_visibility(?, ?, ?) = ?", a.actor, a.recipients, a.data, ^visibility)
789 defp restrict_visibility(_query, %{visibility: visibility})
790 when visibility not in @valid_visibilities do
791 Logger.error("Could not restrict visibility to #{visibility}")
794 defp restrict_visibility(query, _visibility), do: query
796 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
797 when is_list(visibility) do
798 if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
803 "activity_visibility(?, ?, ?) = ANY (?)",
811 Logger.error("Could not exclude visibility to #{visibility}")
816 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
817 when visibility in @valid_visibilities do
822 "activity_visibility(?, ?, ?) = ?",
831 defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
832 when visibility not in @valid_visibilities do
833 Logger.error("Could not exclude visibility to #{visibility}")
837 defp exclude_visibility(query, _visibility), do: query
839 defp restrict_thread_visibility(query, _, %{skip_thread_containment: true} = _),
842 defp restrict_thread_visibility(
844 %{"user" => %User{skip_thread_containment: true}},
849 defp restrict_thread_visibility(query, %{"user" => %User{ap_id: ap_id}}, _) do
852 where: fragment("thread_visibility(?, (?)->>'id') = true", ^ap_id, a.data)
856 defp restrict_thread_visibility(query, _, _), do: query
858 def fetch_user_abstract_activities(user, reading_user, params \\ %{}) do
861 |> Map.put("user", reading_user)
862 |> Map.put("actor_id", user.ap_id)
865 user_activities_recipients(%{
866 "godmode" => params["godmode"],
867 "reading_user" => reading_user
870 fetch_activities(recipients, params)
874 def fetch_user_activities(user, reading_user, params \\ %{}) do
877 |> Map.put("type", ["Create", "Announce"])
878 |> Map.put("user", reading_user)
879 |> Map.put("actor_id", user.ap_id)
880 |> Map.put("pinned_activity_ids", user.pinned_activities)
883 if User.blocks?(reading_user, user) do
887 |> Map.put("blocking_user", reading_user)
888 |> Map.put("muting_user", reading_user)
892 user_activities_recipients(%{
893 "godmode" => params["godmode"],
894 "reading_user" => reading_user
897 fetch_activities(recipients, params)
901 def fetch_statuses(reading_user, params) do
904 |> Map.put("type", ["Create", "Announce"])
907 user_activities_recipients(%{
908 "godmode" => params["godmode"],
909 "reading_user" => reading_user
912 fetch_activities(recipients, params, :offset)
916 defp user_activities_recipients(%{"godmode" => true}) do
920 defp user_activities_recipients(%{"reading_user" => reading_user}) do
922 [Constants.as_public()] ++ [reading_user.ap_id | User.following(reading_user)]
924 [Constants.as_public()]
928 defp restrict_since(query, %{"since_id" => ""}), do: query
930 defp restrict_since(query, %{"since_id" => since_id}) do
931 from(activity in query, where: activity.id > ^since_id)
934 defp restrict_since(query, _), do: query
936 defp restrict_tag_reject(_query, %{"tag_reject" => _tag_reject, "skip_preload" => true}) do
937 raise "Can't use the child object without preloading!"
940 defp restrict_tag_reject(query, %{"tag_reject" => tag_reject})
941 when is_list(tag_reject) and tag_reject != [] do
943 [_activity, object] in query,
944 where: fragment("not (?)->'tag' \\?| (?)", object.data, ^tag_reject)
948 defp restrict_tag_reject(query, _), do: query
950 defp restrict_tag_all(_query, %{"tag_all" => _tag_all, "skip_preload" => true}) do
951 raise "Can't use the child object without preloading!"
954 defp restrict_tag_all(query, %{"tag_all" => tag_all})
955 when is_list(tag_all) and tag_all != [] do
957 [_activity, object] in query,
958 where: fragment("(?)->'tag' \\?& (?)", object.data, ^tag_all)
962 defp restrict_tag_all(query, _), do: query
964 defp restrict_tag(_query, %{"tag" => _tag, "skip_preload" => true}) do
965 raise "Can't use the child object without preloading!"
968 defp restrict_tag(query, %{"tag" => tag}) when is_list(tag) do
970 [_activity, object] in query,
971 where: fragment("(?)->'tag' \\?| (?)", object.data, ^tag)
975 defp restrict_tag(query, %{"tag" => tag}) when is_binary(tag) do
977 [_activity, object] in query,
978 where: fragment("(?)->'tag' \\? (?)", object.data, ^tag)
982 defp restrict_tag(query, _), do: query
984 defp reply_recipients(user, "following") do
985 [user.ap_id | User.get_cached_user_friends_ap_ids(user)]
988 defp reply_recipients(user, "self"), do: [user.ap_id]
990 defp restrict_recipients(query, [], _opts), do: query
992 defp restrict_recipients(
995 %{"user" => nil, "reply_user" => user, "reply_visibility" => visibility}
997 when not is_nil(user) and visibility in ["following", "self"] do
998 reply_recipients = reply_recipients(user, visibility)
1000 from([activity, object] in query,
1003 "? && ? AND (?->>'inReplyTo' IS NULL OR array_remove(?, ?) && ? OR ? = ?)",
1005 activity.recipients,
1007 activity.recipients,
1016 defp restrict_recipients(query, recipients, %{"user" => nil}) do
1017 from(activity in query,
1018 where: fragment("? && ?", ^recipients, activity.recipients)
1022 defp restrict_recipients(query, recipients, %{"user" => user, "reply_visibility" => visibility})
1023 when visibility in ["following", "self"] do
1024 reply_recipients = reply_recipients(user, visibility)
1027 [activity, object] in query,
1030 "? && ? AND (?->>'inReplyTo' IS NULL OR array_remove(?, ?) && ?)",
1032 activity.recipients,
1034 activity.recipients,
1038 or_where: activity.actor == ^user.ap_id
1042 defp restrict_recipients(query, recipients, %{"user" => user}) do
1045 where: fragment("? && ?", ^recipients, activity.recipients),
1046 or_where: activity.actor == ^user.ap_id
1050 defp restrict_local(query, %{"local_only" => true}) do
1051 from(activity in query, where: activity.local == true)
1054 defp restrict_local(query, _), do: query
1056 defp restrict_actor(query, %{"actor_id" => actor_id}) do
1057 from(activity in query, where: activity.actor == ^actor_id)
1060 defp restrict_actor(query, _), do: query
1062 defp restrict_type(query, %{"type" => type}) when is_binary(type) do
1063 from(activity in query, where: fragment("?->>'type' = ?", activity.data, ^type))
1066 defp restrict_type(query, %{"type" => type}) do
1067 from(activity in query, where: fragment("?->>'type' = ANY(?)", activity.data, ^type))
1070 defp restrict_type(query, _), do: query
1072 defp restrict_state(query, %{"state" => state}) do
1073 from(activity in query, where: fragment("?->>'state' = ?", activity.data, ^state))
1076 defp restrict_state(query, _), do: query
1078 defp restrict_favorited_by(query, %{"favorited_by" => ap_id}) do
1080 [_activity, object] in query,
1081 where: fragment("(?)->'likes' \\? (?)", object.data, ^ap_id)
1085 defp restrict_favorited_by(query, _), do: query
1087 defp restrict_media(_query, %{"only_media" => _val, "skip_preload" => true}) do
1088 raise "Can't use the child object without preloading!"
1091 defp restrict_media(query, %{"only_media" => val}) when val == "true" or val == "1" do
1093 [_activity, object] in query,
1094 where: fragment("not (?)->'attachment' = (?)", object.data, ^[])
1098 defp restrict_media(query, _), do: query
1100 defp restrict_replies(query, %{"exclude_replies" => val}) when val == "true" or val == "1" do
1102 [_activity, object] in query,
1103 where: fragment("?->>'inReplyTo' is null", object.data)
1107 defp restrict_replies(query, _), do: query
1109 defp restrict_reblogs(query, %{"exclude_reblogs" => val}) when val == "true" or val == "1" do
1110 from(activity in query, where: fragment("?->>'type' != 'Announce'", activity.data))
1113 defp restrict_reblogs(query, _), do: query
1115 defp restrict_muted(query, %{"with_muted" => val}) when val in [true, "true", "1"], do: query
1117 defp restrict_muted(query, %{"muting_user" => %User{} = user} = opts) do
1118 mutes = opts["muted_users_ap_ids"] || User.muted_users_ap_ids(user)
1121 from([activity] in query,
1122 where: fragment("not (? = ANY(?))", activity.actor, ^mutes),
1123 where: fragment("not (?->'to' \\?| ?)", activity.data, ^mutes)
1126 unless opts["skip_preload"] do
1127 from([thread_mute: tm] in query, where: is_nil(tm.user_id))
1133 defp restrict_muted(query, _), do: query
1135 defp restrict_blocked(query, %{"blocking_user" => %User{} = user} = opts) do
1136 blocked_ap_ids = opts["blocked_users_ap_ids"] || User.blocked_users_ap_ids(user)
1137 domain_blocks = user.domain_blocks || []
1139 following_ap_ids = User.get_friends_ap_ids(user)
1142 if has_named_binding?(query, :object), do: query, else: Activity.with_joined_object(query)
1145 [activity, object: o] in query,
1146 where: fragment("not (? = ANY(?))", activity.actor, ^blocked_ap_ids),
1147 where: fragment("not (? && ?)", activity.recipients, ^blocked_ap_ids),
1150 "not (?->>'type' = 'Announce' and ?->'to' \\?| ?)",
1157 "(not (split_part(?, '/', 3) = ANY(?))) or ? = ANY(?)",
1165 "(not (split_part(?->>'actor', '/', 3) = ANY(?))) or (?->>'actor') = ANY(?)",
1174 defp restrict_blocked(query, _), do: query
1176 defp restrict_unlisted(query) do
1181 "not (coalesce(?->'cc', '{}'::jsonb) \\?| ?)",
1183 ^[Constants.as_public()]
1188 defp restrict_pinned(query, %{"pinned" => "true", "pinned_activity_ids" => ids}) do
1189 from(activity in query, where: activity.id in ^ids)
1192 defp restrict_pinned(query, _), do: query
1194 defp restrict_muted_reblogs(query, %{"muting_user" => %User{} = user} = opts) do
1195 muted_reblogs = opts["reblog_muted_users_ap_ids"] || User.reblog_muted_users_ap_ids(user)
1201 "not ( ?->>'type' = 'Announce' and ? = ANY(?))",
1209 defp restrict_muted_reblogs(query, _), do: query
1211 defp restrict_instance(query, %{"instance" => instance}) do
1216 where: fragment("? LIKE ?", u.nickname, ^"%@#{instance}")
1220 from(activity in query, where: activity.actor in ^users)
1223 defp restrict_instance(query, _), do: query
1225 defp exclude_poll_votes(query, %{"include_poll_votes" => true}), do: query
1227 defp exclude_poll_votes(query, _) do
1228 if has_named_binding?(query, :object) do
1229 from([activity, object: o] in query,
1230 where: fragment("not(?->>'type' = ?)", o.data, "Answer")
1237 defp exclude_id(query, %{"exclude_id" => id}) when is_binary(id) do
1238 from(activity in query, where: activity.id != ^id)
1241 defp exclude_id(query, _), do: query
1243 defp maybe_preload_objects(query, %{"skip_preload" => true}), do: query
1245 defp maybe_preload_objects(query, _) do
1247 |> Activity.with_preloaded_object()
1250 defp maybe_preload_bookmarks(query, %{"skip_preload" => true}), do: query
1252 defp maybe_preload_bookmarks(query, opts) do
1254 |> Activity.with_preloaded_bookmark(opts["user"])
1257 defp maybe_preload_report_notes(query, %{"preload_report_notes" => true}) do
1259 |> Activity.with_preloaded_report_notes()
1262 defp maybe_preload_report_notes(query, _), do: query
1264 defp maybe_set_thread_muted_field(query, %{"skip_preload" => true}), do: query
1266 defp maybe_set_thread_muted_field(query, opts) do
1268 |> Activity.with_set_thread_muted_field(opts["muting_user"] || opts["user"])
1271 defp maybe_order(query, %{order: :desc}) do
1273 |> order_by(desc: :id)
1276 defp maybe_order(query, %{order: :asc}) do
1278 |> order_by(asc: :id)
1281 defp maybe_order(query, _), do: query
1283 defp fetch_activities_query_ap_ids_ops(opts) do
1284 source_user = opts["muting_user"]
1285 ap_id_relationships = if source_user, do: [:mute, :reblog_mute], else: []
1287 ap_id_relationships =
1288 ap_id_relationships ++
1289 if opts["blocking_user"] && opts["blocking_user"] == source_user do
1295 preloaded_ap_ids = User.outgoing_relationships_ap_ids(source_user, ap_id_relationships)
1297 restrict_blocked_opts = Map.merge(%{"blocked_users_ap_ids" => preloaded_ap_ids[:block]}, opts)
1298 restrict_muted_opts = Map.merge(%{"muted_users_ap_ids" => preloaded_ap_ids[:mute]}, opts)
1300 restrict_muted_reblogs_opts =
1301 Map.merge(%{"reblog_muted_users_ap_ids" => preloaded_ap_ids[:reblog_mute]}, opts)
1303 {restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts}
1306 def fetch_activities_query(recipients, opts \\ %{}) do
1307 {restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts} =
1308 fetch_activities_query_ap_ids_ops(opts)
1311 skip_thread_containment: Config.get([:instance, :skip_thread_containment])
1314 opts = Map.put(opts, "user", opts["user"])
1317 |> maybe_preload_objects(opts)
1318 |> maybe_preload_bookmarks(opts)
1319 |> maybe_preload_report_notes(opts)
1320 |> maybe_set_thread_muted_field(opts)
1321 |> maybe_order(opts)
1322 |> restrict_recipients(recipients, opts)
1323 |> restrict_tag(opts)
1324 |> restrict_tag_reject(opts)
1325 |> restrict_tag_all(opts)
1326 |> restrict_since(opts)
1327 |> restrict_local(opts)
1328 |> restrict_actor(opts)
1329 |> restrict_type(opts)
1330 |> restrict_state(opts)
1331 |> restrict_favorited_by(opts)
1332 |> restrict_blocked(restrict_blocked_opts)
1333 |> restrict_muted(restrict_muted_opts)
1334 |> restrict_media(opts)
1335 |> restrict_visibility(opts)
1336 |> restrict_thread_visibility(opts, config)
1337 |> restrict_replies(opts)
1338 |> restrict_reblogs(opts)
1339 |> restrict_pinned(opts)
1340 |> restrict_muted_reblogs(restrict_muted_reblogs_opts)
1341 |> restrict_instance(opts)
1342 |> Activity.restrict_deactivated_users()
1343 |> exclude_poll_votes(opts)
1344 |> exclude_visibility(opts)
1347 def fetch_activities(recipients, opts \\ %{}, pagination \\ :keyset) do
1348 list_memberships = Pleroma.List.memberships(opts["user"])
1350 fetch_activities_query(recipients ++ list_memberships, opts)
1351 |> Pagination.fetch_paginated(opts, pagination)
1353 |> maybe_update_cc(list_memberships, opts["user"])
1357 Fetch favorites activities of user with order by sort adds to favorites
1359 @spec fetch_favourites(User.t(), map(), Pagination.type()) :: list(Activity.t())
1360 def fetch_favourites(user, params \\ %{}, pagination \\ :keyset) do
1362 |> Activity.Queries.by_actor()
1363 |> Activity.Queries.by_type("Like")
1364 |> Activity.with_joined_object()
1365 |> Object.with_joined_activity()
1366 |> select([_like, object, activity], %{activity | object: object})
1367 |> order_by([like, _, _], desc: like.id)
1368 |> Pagination.fetch_paginated(
1369 Map.merge(params, %{"skip_order" => true}),
1375 defp maybe_update_cc(activities, list_memberships, %User{ap_id: user_ap_id})
1376 when is_list(list_memberships) and length(list_memberships) > 0 do
1377 Enum.map(activities, fn
1378 %{data: %{"bcc" => bcc}} = activity when is_list(bcc) and length(bcc) > 0 ->
1379 if Enum.any?(bcc, &(&1 in list_memberships)) do
1380 update_in(activity.data["cc"], &[user_ap_id | &1])
1390 defp maybe_update_cc(activities, _, _), do: activities
1392 def fetch_activities_bounded_query(query, recipients, recipients_with_public) do
1393 from(activity in query,
1395 fragment("? && ?", activity.recipients, ^recipients) or
1396 (fragment("? && ?", activity.recipients, ^recipients_with_public) and
1397 ^Constants.as_public() in activity.recipients)
1401 def fetch_activities_bounded(
1403 recipients_with_public,
1405 pagination \\ :keyset
1407 fetch_activities_query([], opts)
1408 |> fetch_activities_bounded_query(recipients, recipients_with_public)
1409 |> Pagination.fetch_paginated(opts, pagination)
1413 @spec upload(Upload.source(), keyword()) :: {:ok, Object.t()} | {:error, any()}
1414 def upload(file, opts \\ []) do
1415 with {:ok, data} <- Upload.store(file, opts) do
1418 Map.put(data, "actor", opts[:actor])
1423 Repo.insert(%Object{data: obj_data})
1427 @spec get_actor_url(any()) :: binary() | nil
1428 defp get_actor_url(url) when is_binary(url), do: url
1429 defp get_actor_url(%{"href" => href}) when is_binary(href), do: href
1431 defp get_actor_url(url) when is_list(url) do
1437 defp get_actor_url(_url), do: nil
1439 defp object_to_user_data(data) do
1441 data["icon"]["url"] &&
1444 "url" => [%{"href" => data["icon"]["url"]}]
1448 data["image"]["url"] &&
1451 "url" => [%{"href" => data["image"]["url"]}]
1456 |> Map.get("attachment", [])
1457 |> Enum.filter(fn %{"type" => t} -> t == "PropertyValue" end)
1458 |> Enum.map(fn fields -> Map.take(fields, ["name", "value"]) end)
1462 |> Map.get("tag", [])
1464 %{"type" => "Emoji"} -> true
1467 |> Enum.reduce(%{}, fn %{"icon" => %{"url" => url}, "name" => name}, acc ->
1468 Map.put(acc, String.trim(name, ":"), url)
1471 locked = data["manuallyApprovesFollowers"] || false
1472 data = Transmogrifier.maybe_fix_user_object(data)
1473 discoverable = data["discoverable"] || false
1474 invisible = data["invisible"] || false
1475 actor_type = data["type"] || "Person"
1478 if is_map(data["publicKey"]) && is_binary(data["publicKey"]["publicKeyPem"]) do
1479 data["publicKey"]["publicKeyPem"]
1485 if is_map(data["endpoints"]) && is_binary(data["endpoints"]["sharedInbox"]) do
1486 data["endpoints"]["sharedInbox"]
1493 uri: get_actor_url(data["url"]),
1499 discoverable: discoverable,
1500 invisible: invisible,
1503 follower_address: data["followers"],
1504 following_address: data["following"],
1505 bio: data["summary"],
1506 actor_type: actor_type,
1507 also_known_as: Map.get(data, "alsoKnownAs", []),
1508 public_key: public_key,
1509 inbox: data["inbox"],
1510 shared_inbox: shared_inbox
1513 # nickname can be nil because of virtual actors
1515 if data["preferredUsername"] do
1519 "#{data["preferredUsername"]}@#{URI.parse(data["id"]).host}"
1522 Map.put(user_data, :nickname, nil)
1528 def fetch_follow_information_for_user(user) do
1529 with {:ok, following_data} <-
1530 Fetcher.fetch_and_contain_remote_object_from_id(user.following_address),
1531 {:ok, hide_follows} <- collection_private(following_data),
1532 {:ok, followers_data} <-
1533 Fetcher.fetch_and_contain_remote_object_from_id(user.follower_address),
1534 {:ok, hide_followers} <- collection_private(followers_data) do
1537 hide_follows: hide_follows,
1538 follower_count: normalize_counter(followers_data["totalItems"]),
1539 following_count: normalize_counter(following_data["totalItems"]),
1540 hide_followers: hide_followers
1543 {:error, _} = e -> e
1548 defp normalize_counter(counter) when is_integer(counter), do: counter
1549 defp normalize_counter(_), do: 0
1551 defp maybe_update_follow_information(data) do
1552 with {:enabled, true} <- {:enabled, Config.get([:instance, :external_user_synchronization])},
1553 {:ok, info} <- fetch_follow_information_for_user(data) do
1554 info = Map.merge(data[:info] || %{}, info)
1555 Map.put(data, :info, info)
1557 {:enabled, false} ->
1562 "Follower/Following counter update for #{data.ap_id} failed.\n" <> inspect(e)
1569 defp collection_private(%{"first" => %{"type" => type}})
1570 when type in ["CollectionPage", "OrderedCollectionPage"],
1573 defp collection_private(%{"first" => first}) do
1574 with {:ok, %{"type" => type}} when type in ["CollectionPage", "OrderedCollectionPage"] <-
1575 Fetcher.fetch_and_contain_remote_object_from_id(first) do
1578 {:error, {:ok, %{status: code}}} when code in [401, 403] -> {:ok, true}
1579 {:error, _} = e -> e
1584 defp collection_private(_data), do: {:ok, true}
1586 def user_data_from_user_object(data) do
1587 with {:ok, data} <- MRF.filter(data),
1588 {:ok, data} <- object_to_user_data(data) do
1595 def fetch_and_prepare_user_from_ap_id(ap_id) do
1596 with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id),
1597 {:ok, data} <- user_data_from_user_object(data),
1598 data <- maybe_update_follow_information(data) do
1601 {:error, "Object has been deleted"} = e ->
1602 Logger.debug("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
1606 Logger.error("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
1611 def make_user_from_ap_id(ap_id) do
1612 user = User.get_cached_by_ap_id(ap_id)
1614 if user && !User.ap_enabled?(user) do
1615 Transmogrifier.upgrade_user_from_ap_id(ap_id)
1617 with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id) do
1620 |> User.remote_user_changeset(data)
1621 |> User.update_and_set_cache()
1624 |> User.remote_user_changeset()
1634 def make_user_from_nickname(nickname) do
1635 with {:ok, %{"ap_id" => ap_id}} when not is_nil(ap_id) <- WebFinger.finger(nickname) do
1636 make_user_from_ap_id(ap_id)
1638 _e -> {:error, "No AP id in WebFinger"}
1642 # filter out broken threads
1643 def contain_broken_threads(%Activity{} = activity, %User{} = user) do
1644 entire_thread_visible_for_user?(activity, user)
1647 # do post-processing on a specific activity
1648 def contain_activity(%Activity{} = activity, %User{} = user) do
1649 contain_broken_threads(activity, user)
1652 def fetch_direct_messages_query do
1654 |> restrict_type(%{"type" => "Create"})
1655 |> restrict_visibility(%{visibility: "direct"})
1656 |> order_by([activity], asc: activity.id)