1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.Web.ActivityPub.ActivityPub do
7 alias Pleroma.Activity.Ir.Topics
9 alias Pleroma.Conversation
10 alias Pleroma.Notification
12 alias Pleroma.Object.Containment
13 alias Pleroma.Object.Fetcher
14 alias Pleroma.Pagination
18 alias Pleroma.Web.ActivityPub.MRF
19 alias Pleroma.Web.ActivityPub.Transmogrifier
20 alias Pleroma.Web.Streamer
21 alias Pleroma.Web.WebFinger
22 alias Pleroma.Workers.BackgroundWorker
25 import Pleroma.Web.ActivityPub.Utils
26 import Pleroma.Web.ActivityPub.Visibility
29 require Pleroma.Constants
31 # For Announce activities, we filter the recipients based on following status for any actors
32 # that match actual users. See issue #164 for more information about why this is necessary.
33 defp get_recipients(%{"type" => "Announce"} = data) do
34 to = Map.get(data, "to", [])
35 cc = Map.get(data, "cc", [])
36 bcc = Map.get(data, "bcc", [])
37 actor = User.get_cached_by_ap_id(data["actor"])
40 Enum.filter(Enum.concat([to, cc, bcc]), fn recipient ->
41 case User.get_cached_by_ap_id(recipient) do
43 user -> User.following?(user, actor)
50 defp get_recipients(%{"type" => "Create"} = data) do
51 to = Map.get(data, "to", [])
52 cc = Map.get(data, "cc", [])
53 bcc = Map.get(data, "bcc", [])
54 actor = Map.get(data, "actor", [])
55 recipients = [to, cc, bcc, [actor]] |> Enum.concat() |> Enum.uniq()
59 defp get_recipients(data) do
60 to = Map.get(data, "to", [])
61 cc = Map.get(data, "cc", [])
62 bcc = Map.get(data, "bcc", [])
63 recipients = Enum.concat([to, cc, bcc])
67 defp check_actor_is_active(actor) do
68 if not is_nil(actor) do
69 with user <- User.get_cached_by_ap_id(actor),
70 false <- user.info.deactivated do
80 defp check_remote_limit(%{"object" => %{"content" => content}}) when not is_nil(content) do
81 limit = Config.get([:instance, :remote_limit])
82 String.length(content) <= limit
85 defp check_remote_limit(_), do: true
87 def increase_note_count_if_public(actor, object) do
88 if is_public?(object), do: User.increase_note_count(actor), else: {:ok, actor}
91 def decrease_note_count_if_public(actor, object) do
92 if is_public?(object), do: User.decrease_note_count(actor), else: {:ok, actor}
95 def increase_replies_count_if_reply(%{
96 "object" => %{"inReplyTo" => reply_ap_id} = object,
99 if is_public?(object) do
100 Object.increase_replies_count(reply_ap_id)
104 def increase_replies_count_if_reply(_create_data), do: :noop
106 def decrease_replies_count_if_reply(%Object{
107 data: %{"inReplyTo" => reply_ap_id} = object
109 if is_public?(object) do
110 Object.decrease_replies_count(reply_ap_id)
114 def decrease_replies_count_if_reply(_object), do: :noop
116 def increase_poll_votes_if_vote(%{
117 "object" => %{"inReplyTo" => reply_ap_id, "name" => name},
120 Object.increase_vote_count(reply_ap_id, name)
123 def increase_poll_votes_if_vote(_create_data), do: :noop
125 def insert(map, local \\ true, fake \\ false, bypass_actor_check \\ false) when is_map(map) do
126 with nil <- Activity.normalize(map),
127 map <- lazy_put_activity_defaults(map, fake),
128 true <- bypass_actor_check || check_actor_is_active(map["actor"]),
129 {_, true} <- {:remote_limit_error, check_remote_limit(map)},
130 {:ok, map} <- MRF.filter(map),
131 {recipients, _, _} = get_recipients(map),
132 {:fake, false, map, recipients} <- {:fake, fake, map, recipients},
133 :ok <- Containment.contain_child(map),
134 {:ok, map, object} <- insert_full_object(map) do
136 Repo.insert(%Activity{
140 recipients: recipients
143 # Splice in the child object if we have one.
145 if not is_nil(object) do
146 Map.put(activity, :object, object)
151 BackgroundWorker.enqueue("fetch_data_for_activity", %{"activity_id" => activity.id})
153 Notification.create_notifications(activity)
157 |> Conversation.create_or_bump_for()
158 |> get_participations()
161 stream_out_participations(participations)
164 %Activity{} = activity ->
167 {:fake, true, map, recipients} ->
168 activity = %Activity{
172 recipients: recipients,
176 Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
184 defp get_participations({:ok, %{participations: participations}}), do: participations
185 defp get_participations(_), do: []
187 def stream_out_participations(participations) do
190 |> Repo.preload(:user)
192 Streamer.stream("participation", participations)
195 def stream_out_participations(%Object{data: %{"context" => context}}, user) do
196 with %Conversation{} = conversation <- Conversation.get_for_ap_id(context),
197 conversation = Repo.preload(conversation, :participations),
199 fetch_latest_activity_id_for_context(conversation.ap_id, %{
201 "blocking_user" => user
203 if last_activity_id do
204 stream_out_participations(conversation.participations)
209 def stream_out_participations(_, _), do: :noop
211 def stream_out(%Activity{data: %{"type" => data_type}} = activity)
212 when data_type in ["Create", "Announce", "Delete"] do
214 |> Topics.get_activity_topics()
215 |> Streamer.stream(activity)
218 def stream_out(_activity) do
222 def create(%{to: to, actor: actor, context: context, object: object} = params, fake \\ false) do
223 additional = params[:additional] || %{}
224 # only accept false as false value
225 local = !(params[:local] == false)
226 published = params[:published]
230 %{to: to, actor: actor, published: published, context: context, object: object},
233 {:ok, activity} <- insert(create_data, local, fake),
234 {:fake, false, activity} <- {:fake, fake, activity},
235 _ <- increase_replies_count_if_reply(create_data),
236 _ <- increase_poll_votes_if_vote(create_data),
237 # Changing note count prior to enqueuing federation task in order to avoid
238 # race conditions on updating user.info
239 {:ok, _actor} <- increase_note_count_if_public(actor, activity),
240 :ok <- maybe_federate(activity) do
243 {:fake, true, activity} ->
251 def listen(%{to: to, actor: actor, context: context, object: object} = params) do
252 additional = params[:additional] || %{}
253 # only accept false as false value
254 local = !(params[:local] == false)
255 published = params[:published]
259 %{to: to, actor: actor, published: published, context: context, object: object},
262 {:ok, activity} <- insert(listen_data, local),
263 :ok <- maybe_federate(activity) do
271 def accept(%{to: to, actor: actor, object: object} = params) do
272 # only accept false as false value
273 local = !(params[:local] == false)
275 with data <- %{"to" => to, "type" => "Accept", "actor" => actor.ap_id, "object" => object},
276 {:ok, activity} <- insert(data, local),
277 :ok <- maybe_federate(activity) do
282 def reject(%{to: to, actor: actor, object: object} = params) do
283 # only accept false as false value
284 local = !(params[:local] == false)
286 with data <- %{"to" => to, "type" => "Reject", "actor" => actor.ap_id, "object" => object},
287 {:ok, activity} <- insert(data, local),
288 :ok <- maybe_federate(activity) do
293 def update(%{to: to, cc: cc, actor: actor, object: object} = params) do
294 # only accept false as false value
295 local = !(params[:local] == false)
304 {:ok, activity} <- insert(data, local),
305 :ok <- maybe_federate(activity) do
310 def react_with_emoji(user, object, emoji, options \\ []) do
311 with local <- Keyword.get(options, :local, true),
312 activity_id <- Keyword.get(options, :activity_id, nil),
313 Pleroma.Emoji.is_unicode_emoji?(emoji),
314 reaction_data <- make_emoji_reaction_data(user, object, emoji, activity_id),
315 {:ok, activity} <- insert(reaction_data, local),
316 {:ok, object} <- add_emoji_reaction_to_object(activity, object),
317 :ok <- maybe_federate(activity) do
318 {:ok, activity, object}
322 def unreact_with_emoji(user, reaction_id, options \\ []) do
323 with local <- Keyword.get(options, :local, true),
324 activity_id <- Keyword.get(options, :activity_id, nil),
325 user_ap_id <- user.ap_id,
326 %Activity{actor: ^user_ap_id} = reaction_activity <- Activity.get_by_ap_id(reaction_id),
327 object <- Object.normalize(reaction_activity),
328 unreact_data <- make_undo_data(user, reaction_activity, activity_id),
329 {:ok, activity} <- insert(unreact_data, local),
330 {:ok, object} <- remove_emoji_reaction_from_object(reaction_activity, object),
331 :ok <- maybe_federate(activity) do
332 {:ok, activity, object}
336 # TODO: This is weird, maybe we shouldn't check here if we can make the activity.
338 %User{ap_id: ap_id} = user,
339 %Object{data: %{"id" => _}} = object,
343 with nil <- get_existing_like(ap_id, object),
344 like_data <- make_like_data(user, object, activity_id),
345 {:ok, activity} <- insert(like_data, local),
346 {:ok, object} <- add_like_to_object(activity, object),
347 :ok <- maybe_federate(activity) do
348 {:ok, activity, object}
350 %Activity{} = activity -> {:ok, activity, object}
351 error -> {:error, error}
355 def unlike(%User{} = actor, %Object{} = object, activity_id \\ nil, local \\ true) do
356 with %Activity{} = like_activity <- get_existing_like(actor.ap_id, object),
357 unlike_data <- make_unlike_data(actor, like_activity, activity_id),
358 {:ok, unlike_activity} <- insert(unlike_data, local),
359 {:ok, _activity} <- Repo.delete(like_activity),
360 {:ok, object} <- remove_like_from_object(like_activity, object),
361 :ok <- maybe_federate(unlike_activity) do
362 {:ok, unlike_activity, like_activity, object}
369 %User{ap_id: _} = user,
370 %Object{data: %{"id" => _}} = object,
375 with true <- is_announceable?(object, user, public),
376 announce_data <- make_announce_data(user, object, activity_id, public),
377 {:ok, activity} <- insert(announce_data, local),
378 {:ok, object} <- add_announce_to_object(activity, object),
379 :ok <- maybe_federate(activity) do
380 {:ok, activity, object}
382 error -> {:error, error}
392 with %Activity{} = announce_activity <- get_existing_announce(actor.ap_id, object),
393 unannounce_data <- make_unannounce_data(actor, announce_activity, activity_id),
394 {:ok, unannounce_activity} <- insert(unannounce_data, local),
395 :ok <- maybe_federate(unannounce_activity),
396 {:ok, _activity} <- Repo.delete(announce_activity),
397 {:ok, object} <- remove_announce_from_object(announce_activity, object) do
398 {:ok, unannounce_activity, object}
404 def follow(follower, followed, activity_id \\ nil, local \\ true) do
405 with data <- make_follow_data(follower, followed, activity_id),
406 {:ok, activity} <- insert(data, local),
407 :ok <- maybe_federate(activity),
408 _ <- User.set_follow_state_cache(follower.ap_id, followed.ap_id, activity.data["state"]) do
413 def unfollow(follower, followed, activity_id \\ nil, local \\ true) do
414 with %Activity{} = follow_activity <- fetch_latest_follow(follower, followed),
415 {:ok, follow_activity} <- update_follow_state(follow_activity, "cancelled"),
416 unfollow_data <- make_unfollow_data(follower, followed, follow_activity, activity_id),
417 {:ok, activity} <- insert(unfollow_data, local),
418 :ok <- maybe_federate(activity) do
423 def delete(%User{ap_id: ap_id, follower_address: follower_address} = user) do
425 "to" => [follower_address],
428 "object" => %{"type" => "Person", "id" => ap_id}
430 {:ok, activity} <- insert(data, true, true, true),
431 :ok <- maybe_federate(activity) do
436 def delete(%Object{data: %{"id" => id, "actor" => actor}} = object, local \\ true) do
437 user = User.get_cached_by_ap_id(actor)
438 to = (object.data["to"] || []) ++ (object.data["cc"] || [])
440 with {:ok, object, activity} <- Object.delete(object),
446 "deleted_activity_id" => activity && activity.id
448 {:ok, activity} <- insert(data, local, false),
449 stream_out_participations(object, user),
450 _ <- decrease_replies_count_if_reply(object),
451 # Changing note count prior to enqueuing federation task in order to avoid
452 # race conditions on updating user.info
453 {:ok, _actor} <- decrease_note_count_if_public(user, object),
454 :ok <- maybe_federate(activity) do
459 @spec block(User.t(), User.t(), String.t() | nil, boolean) :: {:ok, Activity.t() | nil}
460 def block(blocker, blocked, activity_id \\ nil, local \\ true) do
461 outgoing_blocks = Config.get([:activitypub, :outgoing_blocks])
462 unfollow_blocked = Config.get([:activitypub, :unfollow_blocked])
464 if unfollow_blocked do
465 follow_activity = fetch_latest_follow(blocker, blocked)
466 if follow_activity, do: unfollow(blocker, blocked, nil, local)
469 with true <- outgoing_blocks,
470 block_data <- make_block_data(blocker, blocked, activity_id),
471 {:ok, activity} <- insert(block_data, local),
472 :ok <- maybe_federate(activity) do
479 def unblock(blocker, blocked, activity_id \\ nil, local \\ true) do
480 with %Activity{} = block_activity <- fetch_latest_block(blocker, blocked),
481 unblock_data <- make_unblock_data(blocker, blocked, block_activity, activity_id),
482 {:ok, activity} <- insert(unblock_data, local),
483 :ok <- maybe_federate(activity) do
488 @spec flag(map()) :: {:ok, Activity.t()} | any
498 # only accept false as false value
499 local = !(params[:local] == false)
500 forward = !(params[:forward] == false)
502 additional = params[:additional] || %{}
506 Map.merge(additional, %{"to" => [], "cc" => [account.ap_id]})
508 Map.merge(additional, %{"to" => [], "cc" => []})
511 with flag_data <- make_flag_data(params, additional),
512 {:ok, activity} <- insert(flag_data, local),
513 :ok <- maybe_federate(activity) do
514 Enum.each(User.all_superusers(), fn superuser ->
516 |> Pleroma.Emails.AdminEmail.report(actor, account, statuses, content)
517 |> Pleroma.Emails.Mailer.deliver_async()
524 defp fetch_activities_for_context_query(context, opts) do
525 public = [Pleroma.Constants.as_public()]
528 if opts["user"], do: [opts["user"].ap_id | opts["user"].following] ++ public, else: public
530 from(activity in Activity)
531 |> maybe_preload_objects(opts)
532 |> maybe_preload_bookmarks(opts)
533 |> maybe_set_thread_muted_field(opts)
534 |> restrict_blocked(opts)
535 |> restrict_recipients(recipients, opts["user"])
539 "?->>'type' = ? and ?->>'context' = ?",
546 |> exclude_poll_votes(opts)
548 |> order_by([activity], desc: activity.id)
551 @spec fetch_activities_for_context(String.t(), keyword() | map()) :: [Activity.t()]
552 def fetch_activities_for_context(context, opts \\ %{}) do
554 |> fetch_activities_for_context_query(opts)
558 @spec fetch_latest_activity_id_for_context(String.t(), keyword() | map()) ::
559 FlakeId.Ecto.CompatType.t() | nil
560 def fetch_latest_activity_id_for_context(context, opts \\ %{}) do
562 |> fetch_activities_for_context_query(Map.merge(%{"skip_preload" => true}, opts))
568 def fetch_public_activities(opts \\ %{}, pagination \\ :keyset) do
569 opts = Map.drop(opts, ["user"])
571 [Pleroma.Constants.as_public()]
572 |> fetch_activities_query(opts)
573 |> restrict_unlisted()
574 |> Pagination.fetch_paginated(opts, pagination)
578 @valid_visibilities ~w[direct unlisted public private]
580 defp restrict_visibility(query, %{visibility: visibility})
581 when is_list(visibility) do
582 if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
588 "activity_visibility(?, ?, ?) = ANY (?)",
598 Logger.error("Could not restrict visibility to #{visibility}")
602 defp restrict_visibility(query, %{visibility: visibility})
603 when visibility in @valid_visibilities do
607 fragment("activity_visibility(?, ?, ?) = ?", a.actor, a.recipients, a.data, ^visibility)
611 defp restrict_visibility(_query, %{visibility: visibility})
612 when visibility not in @valid_visibilities do
613 Logger.error("Could not restrict visibility to #{visibility}")
616 defp restrict_visibility(query, _visibility), do: query
618 defp restrict_thread_visibility(query, _, %{skip_thread_containment: true} = _),
621 defp restrict_thread_visibility(
623 %{"user" => %User{info: %{skip_thread_containment: true}}},
628 defp restrict_thread_visibility(query, %{"user" => %User{ap_id: ap_id}}, _) do
631 where: fragment("thread_visibility(?, (?)->>'id') = true", ^ap_id, a.data)
635 defp restrict_thread_visibility(query, _, _), do: query
637 def fetch_user_abstract_activities(user, reading_user, params \\ %{}) do
640 |> Map.put("user", reading_user)
641 |> Map.put("actor_id", user.ap_id)
642 |> Map.put("whole_db", true)
645 user_activities_recipients(%{
646 "godmode" => params["godmode"],
647 "reading_user" => reading_user
650 fetch_activities(recipients, params)
654 def fetch_user_activities(user, reading_user, params \\ %{}) do
657 |> Map.put("type", ["Create", "Announce"])
658 |> Map.put("user", reading_user)
659 |> Map.put("actor_id", user.ap_id)
660 |> Map.put("whole_db", true)
661 |> Map.put("pinned_activity_ids", user.info.pinned_activities)
664 user_activities_recipients(%{
665 "godmode" => params["godmode"],
666 "reading_user" => reading_user
669 fetch_activities(recipients, params)
673 defp user_activities_recipients(%{"godmode" => true}) do
677 defp user_activities_recipients(%{"reading_user" => reading_user}) do
679 [Pleroma.Constants.as_public()] ++ [reading_user.ap_id | reading_user.following]
681 [Pleroma.Constants.as_public()]
685 defp restrict_since(query, %{"since_id" => ""}), do: query
687 defp restrict_since(query, %{"since_id" => since_id}) do
688 from(activity in query, where: activity.id > ^since_id)
691 defp restrict_since(query, _), do: query
693 defp restrict_tag_reject(_query, %{"tag_reject" => _tag_reject, "skip_preload" => true}) do
694 raise "Can't use the child object without preloading!"
697 defp restrict_tag_reject(query, %{"tag_reject" => tag_reject})
698 when is_list(tag_reject) and tag_reject != [] do
700 [_activity, object] in query,
701 where: fragment("not (?)->'tag' \\?| (?)", object.data, ^tag_reject)
705 defp restrict_tag_reject(query, _), do: query
707 defp restrict_tag_all(_query, %{"tag_all" => _tag_all, "skip_preload" => true}) do
708 raise "Can't use the child object without preloading!"
711 defp restrict_tag_all(query, %{"tag_all" => tag_all})
712 when is_list(tag_all) and tag_all != [] do
714 [_activity, object] in query,
715 where: fragment("(?)->'tag' \\?& (?)", object.data, ^tag_all)
719 defp restrict_tag_all(query, _), do: query
721 defp restrict_tag(_query, %{"tag" => _tag, "skip_preload" => true}) do
722 raise "Can't use the child object without preloading!"
725 defp restrict_tag(query, %{"tag" => tag}) when is_list(tag) do
727 [_activity, object] in query,
728 where: fragment("(?)->'tag' \\?| (?)", object.data, ^tag)
732 defp restrict_tag(query, %{"tag" => tag}) when is_binary(tag) do
734 [_activity, object] in query,
735 where: fragment("(?)->'tag' \\? (?)", object.data, ^tag)
739 defp restrict_tag(query, _), do: query
741 defp restrict_recipients(query, [], _user), do: query
743 defp restrict_recipients(query, recipients, nil) do
744 from(activity in query, where: fragment("? && ?", ^recipients, activity.recipients))
747 defp restrict_recipients(query, recipients, user) do
750 where: fragment("? && ?", ^recipients, activity.recipients),
751 or_where: activity.actor == ^user.ap_id
755 defp restrict_local(query, %{"local_only" => true}) do
756 from(activity in query, where: activity.local == true)
759 defp restrict_local(query, _), do: query
761 defp restrict_actor(query, %{"actor_id" => actor_id}) do
762 from(activity in query, where: activity.actor == ^actor_id)
765 defp restrict_actor(query, _), do: query
767 defp restrict_type(query, %{"type" => type}) when is_binary(type) do
768 from(activity in query, where: fragment("?->>'type' = ?", activity.data, ^type))
771 defp restrict_type(query, %{"type" => type}) do
772 from(activity in query, where: fragment("?->>'type' = ANY(?)", activity.data, ^type))
775 defp restrict_type(query, _), do: query
777 defp restrict_state(query, %{"state" => state}) do
778 from(activity in query, where: fragment("?->>'state' = ?", activity.data, ^state))
781 defp restrict_state(query, _), do: query
783 defp restrict_favorited_by(query, %{"favorited_by" => ap_id}) do
785 [_activity, object] in query,
786 where: fragment("(?)->'likes' \\? (?)", object.data, ^ap_id)
790 defp restrict_favorited_by(query, _), do: query
792 defp restrict_media(_query, %{"only_media" => _val, "skip_preload" => true}) do
793 raise "Can't use the child object without preloading!"
796 defp restrict_media(query, %{"only_media" => val}) when val == "true" or val == "1" do
798 [_activity, object] in query,
799 where: fragment("not (?)->'attachment' = (?)", object.data, ^[])
803 defp restrict_media(query, _), do: query
805 defp restrict_replies(query, %{"exclude_replies" => val}) when val == "true" or val == "1" do
808 where: fragment("?->'object'->>'inReplyTo' is null", activity.data)
812 defp restrict_replies(query, _), do: query
814 defp restrict_reblogs(query, %{"exclude_reblogs" => val}) when val == "true" or val == "1" do
815 from(activity in query, where: fragment("?->>'type' != 'Announce'", activity.data))
818 defp restrict_reblogs(query, _), do: query
820 defp restrict_muted(query, %{"with_muted" => val}) when val in [true, "true", "1"], do: query
822 defp restrict_muted(query, %{"muting_user" => %User{info: info}} = opts) do
826 from([activity] in query,
827 where: fragment("not (? = ANY(?))", activity.actor, ^mutes),
828 where: fragment("not (?->'to' \\?| ?)", activity.data, ^mutes)
831 unless opts["skip_preload"] do
832 from([thread_mute: tm] in query, where: is_nil(tm.user_id))
838 defp restrict_muted(query, _), do: query
840 defp restrict_blocked(query, %{"blocking_user" => %User{info: info}}) do
841 blocks = info.blocks || []
842 domain_blocks = info.domain_blocks || []
845 if has_named_binding?(query, :object), do: query, else: Activity.with_joined_object(query)
848 [activity, object: o] in query,
849 where: fragment("not (? = ANY(?))", activity.actor, ^blocks),
850 where: fragment("not (? && ?)", activity.recipients, ^blocks),
853 "not (?->>'type' = 'Announce' and ?->'to' \\?| ?)",
858 where: fragment("not (split_part(?, '/', 3) = ANY(?))", activity.actor, ^domain_blocks),
859 where: fragment("not (split_part(?->>'actor', '/', 3) = ANY(?))", o.data, ^domain_blocks)
863 defp restrict_blocked(query, _), do: query
865 defp restrict_unlisted(query) do
870 "not (coalesce(?->'cc', '{}'::jsonb) \\?| ?)",
872 ^[Pleroma.Constants.as_public()]
877 defp restrict_pinned(query, %{"pinned" => "true", "pinned_activity_ids" => ids}) do
878 from(activity in query, where: activity.id in ^ids)
881 defp restrict_pinned(query, _), do: query
883 defp restrict_muted_reblogs(query, %{"muting_user" => %User{info: info}}) do
884 muted_reblogs = info.muted_reblogs || []
890 "not ( ?->>'type' = 'Announce' and ? = ANY(?))",
898 defp restrict_muted_reblogs(query, _), do: query
900 defp exclude_poll_votes(query, %{"include_poll_votes" => true}), do: query
902 defp exclude_poll_votes(query, _) do
903 if has_named_binding?(query, :object) do
904 from([activity, object: o] in query,
905 where: fragment("not(?->>'type' = ?)", o.data, "Answer")
912 defp exclude_id(query, %{"exclude_id" => id}) when is_binary(id) do
913 from(activity in query, where: activity.id != ^id)
916 defp exclude_id(query, _), do: query
918 defp maybe_preload_objects(query, %{"skip_preload" => true}), do: query
920 defp maybe_preload_objects(query, _) do
922 |> Activity.with_preloaded_object()
925 defp maybe_preload_bookmarks(query, %{"skip_preload" => true}), do: query
927 defp maybe_preload_bookmarks(query, opts) do
929 |> Activity.with_preloaded_bookmark(opts["user"])
932 defp maybe_set_thread_muted_field(query, %{"skip_preload" => true}), do: query
934 defp maybe_set_thread_muted_field(query, opts) do
936 |> Activity.with_set_thread_muted_field(opts["muting_user"] || opts["user"])
939 defp maybe_order(query, %{order: :desc}) do
941 |> order_by(desc: :id)
944 defp maybe_order(query, %{order: :asc}) do
946 |> order_by(asc: :id)
949 defp maybe_order(query, _), do: query
951 def fetch_activities_query(recipients, opts \\ %{}) do
953 skip_thread_containment: Config.get([:instance, :skip_thread_containment])
957 |> maybe_preload_objects(opts)
958 |> maybe_preload_bookmarks(opts)
959 |> maybe_set_thread_muted_field(opts)
961 |> restrict_recipients(recipients, opts["user"])
962 |> restrict_tag(opts)
963 |> restrict_tag_reject(opts)
964 |> restrict_tag_all(opts)
965 |> restrict_since(opts)
966 |> restrict_local(opts)
967 |> restrict_actor(opts)
968 |> restrict_type(opts)
969 |> restrict_state(opts)
970 |> restrict_favorited_by(opts)
971 |> restrict_blocked(opts)
972 |> restrict_muted(opts)
973 |> restrict_media(opts)
974 |> restrict_visibility(opts)
975 |> restrict_thread_visibility(opts, config)
976 |> restrict_replies(opts)
977 |> restrict_reblogs(opts)
978 |> restrict_pinned(opts)
979 |> restrict_muted_reblogs(opts)
980 |> Activity.restrict_deactivated_users()
981 |> exclude_poll_votes(opts)
984 def fetch_activities(recipients, opts \\ %{}, pagination \\ :keyset) do
985 list_memberships = Pleroma.List.memberships(opts["user"])
987 fetch_activities_query(recipients ++ list_memberships, opts)
988 |> Pagination.fetch_paginated(opts, pagination)
990 |> maybe_update_cc(list_memberships, opts["user"])
993 defp maybe_update_cc(activities, list_memberships, %User{ap_id: user_ap_id})
994 when is_list(list_memberships) and length(list_memberships) > 0 do
995 Enum.map(activities, fn
996 %{data: %{"bcc" => bcc}} = activity when is_list(bcc) and length(bcc) > 0 ->
997 if Enum.any?(bcc, &(&1 in list_memberships)) do
998 update_in(activity.data["cc"], &[user_ap_id | &1])
1008 defp maybe_update_cc(activities, _, _), do: activities
1010 def fetch_activities_bounded_query(query, recipients, recipients_with_public) do
1011 from(activity in query,
1013 fragment("? && ?", activity.recipients, ^recipients) or
1014 (fragment("? && ?", activity.recipients, ^recipients_with_public) and
1015 ^Pleroma.Constants.as_public() in activity.recipients)
1019 def fetch_activities_bounded(
1021 recipients_with_public,
1023 pagination \\ :keyset
1025 fetch_activities_query([], opts)
1026 |> fetch_activities_bounded_query(recipients, recipients_with_public)
1027 |> Pagination.fetch_paginated(opts, pagination)
1031 def upload(file, opts \\ []) do
1032 with {:ok, data} <- Upload.store(file, opts) do
1035 Map.put(data, "actor", opts[:actor])
1040 Repo.insert(%Object{data: obj_data})
1044 defp object_to_user_data(data) do
1046 data["icon"]["url"] &&
1049 "url" => [%{"href" => data["icon"]["url"]}]
1053 data["image"]["url"] &&
1056 "url" => [%{"href" => data["image"]["url"]}]
1061 |> Map.get("attachment", [])
1062 |> Enum.filter(fn %{"type" => t} -> t == "PropertyValue" end)
1063 |> Enum.map(fn fields -> Map.take(fields, ["name", "value"]) end)
1065 locked = data["manuallyApprovesFollowers"] || false
1066 data = Transmogrifier.maybe_fix_user_object(data)
1067 discoverable = data["discoverable"] || false
1077 discoverable: discoverable
1081 follower_address: data["followers"],
1082 following_address: data["following"],
1083 bio: data["summary"]
1086 # nickname can be nil because of virtual actors
1088 if data["preferredUsername"] do
1092 "#{data["preferredUsername"]}@#{URI.parse(data["id"]).host}"
1095 Map.put(user_data, :nickname, nil)
1101 def fetch_follow_information_for_user(user) do
1102 with {:ok, following_data} <-
1103 Fetcher.fetch_and_contain_remote_object_from_id(user.following_address),
1104 following_count when is_integer(following_count) <- following_data["totalItems"],
1105 {:ok, hide_follows} <- collection_private(following_data),
1106 {:ok, followers_data} <-
1107 Fetcher.fetch_and_contain_remote_object_from_id(user.follower_address),
1108 followers_count when is_integer(followers_count) <- followers_data["totalItems"],
1109 {:ok, hide_followers} <- collection_private(followers_data) do
1112 hide_follows: hide_follows,
1113 follower_count: followers_count,
1114 following_count: following_count,
1115 hide_followers: hide_followers
1126 defp maybe_update_follow_information(data) do
1127 with {:enabled, true} <-
1128 {:enabled, Pleroma.Config.get([:instance, :external_user_synchronization])},
1129 {:ok, info} <- fetch_follow_information_for_user(data) do
1130 info = Map.merge(data.info, info)
1131 Map.put(data, :info, info)
1133 {:enabled, false} ->
1138 "Follower/Following counter update for #{data.ap_id} failed.\n" <> inspect(e)
1145 defp collection_private(data) do
1146 if is_map(data["first"]) and
1147 data["first"]["type"] in ["CollectionPage", "OrderedCollectionPage"] do
1150 with {:ok, %{"type" => type}} when type in ["CollectionPage", "OrderedCollectionPage"] <-
1151 Fetcher.fetch_and_contain_remote_object_from_id(data["first"]) do
1154 {:error, {:ok, %{status: code}}} when code in [401, 403] ->
1166 def user_data_from_user_object(data) do
1167 with {:ok, data} <- MRF.filter(data),
1168 {:ok, data} <- object_to_user_data(data) do
1175 def fetch_and_prepare_user_from_ap_id(ap_id) do
1176 with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id),
1177 {:ok, data} <- user_data_from_user_object(data),
1178 data <- maybe_update_follow_information(data) do
1181 e -> Logger.error("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
1185 def make_user_from_ap_id(ap_id) do
1186 if _user = User.get_cached_by_ap_id(ap_id) do
1187 Transmogrifier.upgrade_user_from_ap_id(ap_id)
1189 with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id) do
1190 User.insert_or_update_user(data)
1197 def make_user_from_nickname(nickname) do
1198 with {:ok, %{"ap_id" => ap_id}} when not is_nil(ap_id) <- WebFinger.finger(nickname) do
1199 make_user_from_ap_id(ap_id)
1201 _e -> {:error, "No AP id in WebFinger"}
1205 # filter out broken threads
1206 def contain_broken_threads(%Activity{} = activity, %User{} = user) do
1207 entire_thread_visible_for_user?(activity, user)
1210 # do post-processing on a specific activity
1211 def contain_activity(%Activity{} = activity, %User{} = user) do
1212 contain_broken_threads(activity, user)
1215 def fetch_direct_messages_query do
1217 |> restrict_type(%{"type" => "Create"})
1218 |> restrict_visibility(%{visibility: "direct"})
1219 |> order_by([activity], asc: activity.id)