1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.User do
10 import Ecto, only: [assoc: 2]
13 alias Pleroma.Activity
15 alias Pleroma.Conversation.Participation
16 alias Pleroma.Delivery
17 alias Pleroma.EctoType.ActivityPub.ObjectValidators
19 alias Pleroma.FollowingRelationship
20 alias Pleroma.Formatter
24 alias Pleroma.Notification
26 alias Pleroma.Registration
29 alias Pleroma.UserRelationship
30 alias Pleroma.Web.ActivityPub.ActivityPub
31 alias Pleroma.Web.ActivityPub.Builder
32 alias Pleroma.Web.ActivityPub.Pipeline
33 alias Pleroma.Web.ActivityPub.Utils
34 alias Pleroma.Web.CommonAPI
35 alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
36 alias Pleroma.Web.Endpoint
37 alias Pleroma.Web.OAuth
38 alias Pleroma.Web.RelMe
39 alias Pleroma.Workers.BackgroundWorker
43 @type t :: %__MODULE__{}
44 @type account_status ::
47 | :password_reset_pending
48 | :confirmation_pending
50 @primary_key {:id, FlakeId.Ecto.CompatType, autogenerate: true}
52 # credo:disable-for-next-line Credo.Check.Readability.MaxLineLength
53 @email_regex ~r/^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/
55 @strict_local_nickname_regex ~r/^[a-zA-Z\d]+$/
56 @extended_local_nickname_regex ~r/^[a-zA-Z\d_-]+$/
58 # AP ID user relationships (blocks, mutes etc.)
59 # Format: [rel_type: [outgoing_rel: :outgoing_rel_target, incoming_rel: :incoming_rel_source]]
60 @user_relationships_config [
62 blocker_blocks: :blocked_users,
63 blockee_blocks: :blocker_users
66 muter_mutes: :muted_users,
67 mutee_mutes: :muter_users
70 reblog_muter_mutes: :reblog_muted_users,
71 reblog_mutee_mutes: :reblog_muter_users
74 notification_muter_mutes: :notification_muted_users,
75 notification_mutee_mutes: :notification_muter_users
77 # Note: `inverse_subscription` relationship is inverse: subscriber acts as relationship target
78 inverse_subscription: [
79 subscribee_subscriptions: :subscriber_users,
80 subscriber_subscriptions: :subscribee_users
84 @cachex Pleroma.Config.get([:cachex, :provider], Cachex)
87 field(:bio, :string, default: "")
88 field(:raw_bio, :string)
89 field(:email, :string)
91 field(:nickname, :string)
92 field(:password_hash, :string)
93 field(:password, :string, virtual: true)
94 field(:password_confirmation, :string, virtual: true)
96 field(:public_key, :string)
97 field(:ap_id, :string)
98 field(:avatar, :map, default: %{})
99 field(:local, :boolean, default: true)
100 field(:follower_address, :string)
101 field(:following_address, :string)
102 field(:featured_address, :string)
103 field(:search_rank, :float, virtual: true)
104 field(:search_type, :integer, virtual: true)
105 field(:tags, {:array, :string}, default: [])
106 field(:last_refreshed_at, :naive_datetime_usec)
107 field(:last_digest_emailed_at, :naive_datetime)
108 field(:banner, :map, default: %{})
109 field(:background, :map, default: %{})
110 field(:note_count, :integer, default: 0)
111 field(:follower_count, :integer, default: 0)
112 field(:following_count, :integer, default: 0)
113 field(:is_locked, :boolean, default: false)
114 field(:is_confirmed, :boolean, default: true)
115 field(:password_reset_pending, :boolean, default: false)
116 field(:is_approved, :boolean, default: true)
117 field(:registration_reason, :string, default: nil)
118 field(:confirmation_token, :string, default: nil)
119 field(:default_scope, :string, default: "public")
120 field(:domain_blocks, {:array, :string}, default: [])
121 field(:is_active, :boolean, default: true)
122 field(:no_rich_text, :boolean, default: false)
123 field(:ap_enabled, :boolean, default: false)
124 field(:is_moderator, :boolean, default: false)
125 field(:is_admin, :boolean, default: false)
126 field(:show_role, :boolean, default: true)
127 field(:mastofe_settings, :map, default: nil)
128 field(:uri, ObjectValidators.Uri, default: nil)
129 field(:hide_followers_count, :boolean, default: false)
130 field(:hide_follows_count, :boolean, default: false)
131 field(:hide_followers, :boolean, default: false)
132 field(:hide_follows, :boolean, default: false)
133 field(:hide_favorites, :boolean, default: true)
134 field(:email_notifications, :map, default: %{"digest" => false})
135 field(:mascot, :map, default: nil)
136 field(:emoji, :map, default: %{})
137 field(:pleroma_settings_store, :map, default: %{})
138 field(:fields, {:array, :map}, default: [])
139 field(:raw_fields, {:array, :map}, default: [])
140 field(:is_discoverable, :boolean, default: false)
141 field(:invisible, :boolean, default: false)
142 field(:allow_following_move, :boolean, default: true)
143 field(:skip_thread_containment, :boolean, default: false)
144 field(:actor_type, :string, default: "Person")
145 field(:also_known_as, {:array, ObjectValidators.ObjectID}, default: [])
146 field(:inbox, :string)
147 field(:shared_inbox, :string)
148 field(:last_active_at, :naive_datetime)
149 field(:disclose_client, :boolean, default: true)
150 field(:pinned_objects, :map, default: %{})
151 field(:is_suggested, :boolean, default: false)
152 field(:last_status_at, :naive_datetime)
153 field(:language, :string)
156 :notification_settings,
157 Pleroma.User.NotificationSetting,
161 has_many(:notifications, Notification)
162 has_many(:registrations, Registration)
163 has_many(:deliveries, Delivery)
165 has_many(:outgoing_relationships, UserRelationship, foreign_key: :source_id)
166 has_many(:incoming_relationships, UserRelationship, foreign_key: :target_id)
168 for {relationship_type,
170 {outgoing_relation, outgoing_relation_target},
171 {incoming_relation, incoming_relation_source}
172 ]} <- @user_relationships_config do
173 # Definitions of `has_many` relations: :blocker_blocks, :muter_mutes, :reblog_muter_mutes,
174 # :notification_muter_mutes, :subscribee_subscriptions
175 has_many(outgoing_relation, UserRelationship,
176 foreign_key: :source_id,
177 where: [relationship_type: relationship_type]
180 # Definitions of `has_many` relations: :blockee_blocks, :mutee_mutes, :reblog_mutee_mutes,
181 # :notification_mutee_mutes, :subscriber_subscriptions
182 has_many(incoming_relation, UserRelationship,
183 foreign_key: :target_id,
184 where: [relationship_type: relationship_type]
187 # Definitions of `has_many` relations: :blocked_users, :muted_users, :reblog_muted_users,
188 # :notification_muted_users, :subscriber_users
189 has_many(outgoing_relation_target, through: [outgoing_relation, :target])
191 # Definitions of `has_many` relations: :blocker_users, :muter_users, :reblog_muter_users,
192 # :notification_muter_users, :subscribee_users
193 has_many(incoming_relation_source, through: [incoming_relation, :source])
197 :multi_factor_authentication_settings,
205 for {_relationship_type, [{_outgoing_relation, outgoing_relation_target}, _]} <-
206 @user_relationships_config do
207 # `def blocked_users_relation/2`, `def muted_users_relation/2`,
208 # `def reblog_muted_users_relation/2`, `def notification_muted_users/2`,
209 # `def subscriber_users/2`
210 def unquote(:"#{outgoing_relation_target}_relation")(user, restrict_deactivated? \\ false) do
211 target_users_query = assoc(user, unquote(outgoing_relation_target))
213 if restrict_deactivated? do
215 |> User.Query.build(%{deactivated: false})
221 # `def blocked_users/2`, `def muted_users/2`, `def reblog_muted_users/2`,
222 # `def notification_muted_users/2`, `def subscriber_users/2`
223 def unquote(outgoing_relation_target)(user, restrict_deactivated? \\ false) do
225 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
227 restrict_deactivated?
232 # `def blocked_users_ap_ids/2`, `def muted_users_ap_ids/2`, `def reblog_muted_users_ap_ids/2`,
233 # `def notification_muted_users_ap_ids/2`, `def subscriber_users_ap_ids/2`
234 def unquote(:"#{outgoing_relation_target}_ap_ids")(user, restrict_deactivated? \\ false) do
236 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
238 restrict_deactivated?
240 |> select([u], u.ap_id)
245 def cached_blocked_users_ap_ids(user) do
246 @cachex.fetch!(:user_cache, "blocked_users_ap_ids:#{user.ap_id}", fn _ ->
247 blocked_users_ap_ids(user)
251 def cached_muted_users_ap_ids(user) do
252 @cachex.fetch!(:user_cache, "muted_users_ap_ids:#{user.ap_id}", fn _ ->
253 muted_users_ap_ids(user)
257 defdelegate following_count(user), to: FollowingRelationship
258 defdelegate following(user), to: FollowingRelationship
259 defdelegate following?(follower, followed), to: FollowingRelationship
260 defdelegate following_ap_ids(user), to: FollowingRelationship
261 defdelegate get_follow_requests(user), to: FollowingRelationship
262 defdelegate search(query, opts \\ []), to: User.Search
265 Dumps Flake Id to SQL-compatible format (16-byte UUID).
266 E.g. "9pQtDGXuq4p3VlcJEm" -> <<0, 0, 1, 110, 179, 218, 42, 92, 213, 41, 44, 227, 95, 213, 0, 0>>
268 def binary_id(source_id) when is_binary(source_id) do
269 with {:ok, dumped_id} <- FlakeId.Ecto.CompatType.dump(source_id) do
276 def binary_id(source_ids) when is_list(source_ids) do
277 Enum.map(source_ids, &binary_id/1)
280 def binary_id(%User{} = user), do: binary_id(user.id)
282 @doc "Returns status account"
283 @spec account_status(User.t()) :: account_status()
284 def account_status(%User{is_active: false}), do: :deactivated
285 def account_status(%User{password_reset_pending: true}), do: :password_reset_pending
286 def account_status(%User{local: true, is_approved: false}), do: :approval_pending
287 def account_status(%User{local: true, is_confirmed: false}), do: :confirmation_pending
288 def account_status(%User{}), do: :active
290 @spec visible_for(User.t(), User.t() | nil) ::
293 | :restricted_unauthenticated
295 | :confirmation_pending
296 def visible_for(user, for_user \\ nil)
298 def visible_for(%User{invisible: true}, _), do: :invisible
300 def visible_for(%User{id: user_id}, %User{id: user_id}), do: :visible
302 def visible_for(%User{} = user, nil) do
303 if restrict_unauthenticated?(user) do
304 :restrict_unauthenticated
306 visible_account_status(user)
310 def visible_for(%User{} = user, for_user) do
311 if superuser?(for_user) do
314 visible_account_status(user)
318 def visible_for(_, _), do: :invisible
320 defp restrict_unauthenticated?(%User{local: true}) do
321 Config.restrict_unauthenticated_access?(:profiles, :local)
324 defp restrict_unauthenticated?(%User{local: _}) do
325 Config.restrict_unauthenticated_access?(:profiles, :remote)
328 defp visible_account_status(user) do
329 status = account_status(user)
331 if status in [:active, :password_reset_pending] do
338 @spec superuser?(User.t()) :: boolean()
339 def superuser?(%User{local: true, is_admin: true}), do: true
340 def superuser?(%User{local: true, is_moderator: true}), do: true
341 def superuser?(_), do: false
343 @spec invisible?(User.t()) :: boolean()
344 def invisible?(%User{invisible: true}), do: true
345 def invisible?(_), do: false
347 def avatar_url(user, options \\ []) do
349 %{"url" => [%{"href" => href} | _]} ->
353 unless options[:no_default] do
354 Config.get([:assets, :default_user_avatar], "#{Endpoint.url()}/images/avi.png")
359 def banner_url(user, options \\ []) do
361 %{"url" => [%{"href" => href} | _]} -> href
362 _ -> !options[:no_default] && "#{Endpoint.url()}/images/banner.png"
366 # Should probably be renamed or removed
367 @spec ap_id(User.t()) :: String.t()
368 def ap_id(%User{nickname: nickname}), do: "#{Endpoint.url()}/users/#{nickname}"
370 @spec ap_followers(User.t()) :: String.t()
371 def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
372 def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"
374 @spec ap_following(User.t()) :: String.t()
375 def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
376 def ap_following(%User{} = user), do: "#{ap_id(user)}/following"
378 @spec ap_featured_collection(User.t()) :: String.t()
379 def ap_featured_collection(%User{featured_address: fa}) when is_binary(fa), do: fa
381 def ap_featured_collection(%User{} = user), do: "#{ap_id(user)}/collections/featured"
383 defp truncate_fields_param(params) do
384 if Map.has_key?(params, :fields) do
385 Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
391 defp truncate_if_exists(params, key, max_length) do
392 if Map.has_key?(params, key) and is_binary(params[key]) do
393 {value, _chopped} = String.split_at(params[key], max_length)
394 Map.put(params, key, value)
400 defp fix_follower_address(%{follower_address: _, following_address: _} = params), do: params
402 defp fix_follower_address(%{nickname: nickname} = params),
403 do: Map.put(params, :follower_address, ap_followers(%User{nickname: nickname}))
405 defp fix_follower_address(params), do: params
407 def remote_user_changeset(struct \\ %User{local: false}, params) do
408 bio_limit = Config.get([:instance, :user_bio_length], 5000)
409 name_limit = Config.get([:instance, :user_name_length], 100)
412 case params[:name] do
413 name when is_binary(name) and byte_size(name) > 0 -> name
414 _ -> params[:nickname]
419 |> Map.put(:name, name)
420 |> Map.put_new(:last_refreshed_at, NaiveDateTime.utc_now())
421 |> truncate_if_exists(:name, name_limit)
422 |> truncate_if_exists(:bio, bio_limit)
423 |> truncate_fields_param()
424 |> fix_follower_address()
448 :hide_followers_count,
460 |> cast(params, [:name], empty_values: [])
461 |> validate_required([:ap_id])
462 |> validate_required([:name], trim: false)
463 |> unique_constraint(:nickname)
464 |> validate_format(:nickname, @email_regex)
465 |> validate_length(:bio, max: bio_limit)
466 |> validate_length(:name, max: name_limit)
467 |> validate_fields(true)
468 |> validate_non_local()
471 defp validate_non_local(cng) do
472 local? = get_field(cng, :local)
476 |> add_error(:local, "User is local, can't update with this changeset.")
482 def update_changeset(struct, params \\ %{}) do
483 bio_limit = Config.get([:instance, :user_bio_length], 5000)
484 name_limit = Config.get([:instance, :user_name_length], 100)
504 :hide_followers_count,
507 :allow_following_move,
511 :skip_thread_containment,
514 :pleroma_settings_store,
520 |> unique_constraint(:nickname)
521 |> validate_format(:nickname, local_nickname_regex())
522 |> validate_length(:bio, max: bio_limit)
523 |> validate_length(:name, min: 1, max: name_limit)
524 |> validate_inclusion(:actor_type, ["Person", "Service"])
527 |> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
528 |> put_change_if_present(:avatar, &put_upload(&1, :avatar))
529 |> put_change_if_present(:banner, &put_upload(&1, :banner))
530 |> put_change_if_present(:background, &put_upload(&1, :background))
531 |> put_change_if_present(
532 :pleroma_settings_store,
533 &{:ok, Map.merge(struct.pleroma_settings_store, &1)}
535 |> validate_fields(false)
538 defp put_fields(changeset) do
539 if raw_fields = get_change(changeset, :raw_fields) do
542 |> Enum.filter(fn %{"name" => n} -> n != "" end)
546 |> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)
549 |> put_change(:raw_fields, raw_fields)
550 |> put_change(:fields, fields)
556 defp parse_fields(value) do
558 |> Formatter.linkify(mentions_format: :full)
562 defp put_emoji(changeset) do
563 emojified_fields = [:bio, :name, :raw_fields]
565 if Enum.any?(changeset.changes, fn {k, _} -> k in emojified_fields end) do
566 bio = Emoji.Formatter.get_emoji_map(get_field(changeset, :bio))
567 name = Emoji.Formatter.get_emoji_map(get_field(changeset, :name))
569 emoji = Map.merge(bio, name)
573 |> get_field(:raw_fields)
574 |> Enum.reduce(emoji, fn x, acc ->
575 Map.merge(acc, Emoji.Formatter.get_emoji_map(x["name"] <> x["value"]))
578 put_change(changeset, :emoji, emoji)
584 defp put_change_if_present(changeset, map_field, value_function) do
585 with {:ok, value} <- fetch_change(changeset, map_field),
586 {:ok, new_value} <- value_function.(value) do
587 put_change(changeset, map_field, new_value)
593 defp put_upload(value, type) do
594 with %Plug.Upload{} <- value,
595 {:ok, object} <- ActivityPub.upload(value, type: type) do
600 def update_as_admin_changeset(struct, params) do
602 |> update_changeset(params)
603 |> cast(params, [:email])
604 |> delete_change(:also_known_as)
605 |> unique_constraint(:email)
606 |> validate_format(:email, @email_regex)
607 |> validate_inclusion(:actor_type, ["Person", "Service"])
610 @spec update_as_admin(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
611 def update_as_admin(user, params) do
612 params = Map.put(params, "password_confirmation", params["password"])
613 changeset = update_as_admin_changeset(user, params)
615 if params["password"] do
616 reset_password(user, changeset, params)
618 User.update_and_set_cache(changeset)
622 def password_update_changeset(struct, params) do
624 |> cast(params, [:password, :password_confirmation])
625 |> validate_required([:password, :password_confirmation])
626 |> validate_confirmation(:password)
627 |> put_password_hash()
628 |> put_change(:password_reset_pending, false)
631 @spec reset_password(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
632 def reset_password(%User{} = user, params) do
633 reset_password(user, user, params)
636 def reset_password(%User{id: user_id} = user, struct, params) do
639 |> Multi.update(:user, password_update_changeset(struct, params))
640 |> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
641 |> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))
643 case Repo.transaction(multi) do
644 {:ok, %{user: user} = _} -> set_cache(user)
645 {:error, _, changeset, _} -> {:error, changeset}
649 def update_password_reset_pending(user, value) do
652 |> put_change(:password_reset_pending, value)
653 |> update_and_set_cache()
656 def force_password_reset_async(user) do
657 BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
660 @spec force_password_reset(User.t()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
661 def force_password_reset(user), do: update_password_reset_pending(user, true)
663 # Used to auto-register LDAP accounts which won't have a password hash stored locally
664 def register_changeset_ldap(struct, params = %{password: password})
665 when is_nil(password) do
667 if Map.has_key?(params, :email) do
668 Map.put_new(params, :email, params[:email])
679 |> validate_required([:name, :nickname])
680 |> unique_constraint(:nickname)
681 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
682 |> validate_format(:nickname, local_nickname_regex())
684 |> unique_constraint(:ap_id)
685 |> put_following_and_follower_and_featured_address()
688 def register_changeset(struct, params \\ %{}, opts \\ []) do
689 bio_limit = Config.get([:instance, :user_bio_length], 5000)
690 name_limit = Config.get([:instance, :user_name_length], 100)
691 reason_limit = Config.get([:instance, :registration_reason_length], 500)
694 if is_nil(opts[:confirmed]) do
695 !Config.get([:instance, :account_activation_required])
701 if is_nil(opts[:approved]) do
702 !Config.get([:instance, :account_approval_required])
708 |> confirmation_changeset(set_confirmation: confirmed?)
709 |> approval_changeset(set_approval: approved?)
717 :password_confirmation,
719 :registration_reason,
722 |> validate_required([:name, :nickname, :password, :password_confirmation])
723 |> validate_confirmation(:password)
724 |> unique_constraint(:email)
725 |> validate_format(:email, @email_regex)
726 |> validate_change(:email, fn :email, email ->
728 Config.get([User, :email_blacklist])
729 |> Enum.all?(fn blacklisted_domain ->
730 !String.ends_with?(email, ["@" <> blacklisted_domain, "." <> blacklisted_domain])
733 if valid?, do: [], else: [email: "Invalid email"]
735 |> unique_constraint(:nickname)
736 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
737 |> validate_format(:nickname, local_nickname_regex())
738 |> validate_length(:bio, max: bio_limit)
739 |> validate_length(:name, min: 1, max: name_limit)
740 |> validate_length(:registration_reason, max: reason_limit)
741 |> maybe_validate_required_email(opts[:external])
744 |> unique_constraint(:ap_id)
745 |> put_following_and_follower_and_featured_address()
748 def maybe_validate_required_email(changeset, true), do: changeset
750 def maybe_validate_required_email(changeset, _) do
751 if Config.get([:instance, :account_activation_required]) do
752 validate_required(changeset, [:email])
758 def put_ap_id(changeset) do
759 ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
760 put_change(changeset, :ap_id, ap_id)
763 def put_following_and_follower_and_featured_address(changeset) do
764 user = %User{nickname: get_field(changeset, :nickname)}
765 followers = ap_followers(user)
766 following = ap_following(user)
767 featured = ap_featured_collection(user)
770 |> put_change(:follower_address, followers)
771 |> put_change(:following_address, following)
772 |> put_change(:featured_address, featured)
775 defp autofollow_users(user) do
776 candidates = Config.get([:instance, :autofollowed_nicknames])
779 User.Query.build(%{nickname: candidates, local: true, is_active: true})
782 follow_all(user, autofollowed_users)
785 defp autofollowing_users(user) do
786 candidates = Config.get([:instance, :autofollowing_nicknames])
788 User.Query.build(%{nickname: candidates, local: true, deactivated: false})
790 |> Enum.each(&follow(&1, user, :follow_accept))
795 @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
796 def register(%Ecto.Changeset{} = changeset) do
797 with {:ok, user} <- Repo.insert(changeset) do
798 post_register_action(user)
802 def post_register_action(%User{is_confirmed: false} = user) do
803 with {:ok, _} <- maybe_send_confirmation_email(user) do
808 def post_register_action(%User{is_approved: false} = user) do
809 with {:ok, _} <- send_user_approval_email(user),
810 {:ok, _} <- send_admin_approval_emails(user) do
815 def post_register_action(%User{is_approved: true, is_confirmed: true} = user) do
816 with {:ok, user} <- autofollow_users(user),
817 {:ok, _} <- autofollowing_users(user),
818 {:ok, user} <- set_cache(user),
819 {:ok, _} <- maybe_send_registration_email(user),
820 {:ok, _} <- maybe_send_welcome_email(user),
821 {:ok, _} <- maybe_send_welcome_message(user) do
826 defp send_user_approval_email(user) do
828 |> Pleroma.Emails.UserEmail.approval_pending_email()
829 |> Pleroma.Emails.Mailer.deliver_async()
834 defp send_admin_approval_emails(user) do
836 |> Enum.filter(fn user -> not is_nil(user.email) end)
837 |> Enum.each(fn superuser ->
839 |> Pleroma.Emails.AdminEmail.new_unapproved_registration(user)
840 |> Pleroma.Emails.Mailer.deliver_async()
846 defp maybe_send_welcome_message(user) do
847 if User.WelcomeMessage.enabled?() do
848 User.WelcomeMessage.post_message(user)
855 defp maybe_send_welcome_email(%User{email: email} = user) when is_binary(email) do
856 if User.WelcomeEmail.enabled?() do
857 User.WelcomeEmail.send_email(user)
864 defp maybe_send_welcome_email(_), do: {:ok, :noop}
866 @spec maybe_send_confirmation_email(User.t()) :: {:ok, :enqueued | :noop}
867 def maybe_send_confirmation_email(%User{is_confirmed: false, email: email} = user)
868 when is_binary(email) do
869 if Config.get([:instance, :account_activation_required]) do
870 send_confirmation_email(user)
877 def maybe_send_confirmation_email(_), do: {:ok, :noop}
879 @spec send_confirmation_email(Uset.t()) :: User.t()
880 def send_confirmation_email(%User{} = user) do
882 |> Pleroma.Emails.UserEmail.account_confirmation_email()
883 |> Pleroma.Emails.Mailer.deliver_async()
888 @spec maybe_send_registration_email(User.t()) :: {:ok, :enqueued | :noop}
889 defp maybe_send_registration_email(%User{email: email} = user) when is_binary(email) do
890 with false <- User.WelcomeEmail.enabled?(),
891 false <- Config.get([:instance, :account_activation_required], false),
892 false <- Config.get([:instance, :account_approval_required], false) do
894 |> Pleroma.Emails.UserEmail.successful_registration_email()
895 |> Pleroma.Emails.Mailer.deliver_async()
904 defp maybe_send_registration_email(_), do: {:ok, :noop}
906 def needs_update?(%User{local: true}), do: false
908 def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
910 def needs_update?(%User{local: false} = user) do
911 NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
914 def needs_update?(_), do: true
916 @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
918 # "Locked" (self-locked) users demand explicit authorization of follow requests
919 def maybe_direct_follow(%User{} = follower, %User{local: true, is_locked: true} = followed) do
920 follow(follower, followed, :follow_pending)
923 def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
924 follow(follower, followed)
927 def maybe_direct_follow(%User{} = follower, %User{} = followed) do
928 if not ap_enabled?(followed) do
929 follow(follower, followed)
931 {:ok, follower, followed}
935 @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
936 @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
937 def follow_all(follower, followeds) do
939 |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
940 |> Enum.each(&follow(follower, &1, :follow_accept))
945 def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
946 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
949 not followed.is_active ->
950 {:error, "Could not follow user: #{followed.nickname} is deactivated."}
952 deny_follow_blocked and blocks?(followed, follower) ->
953 {:error, "Could not follow user: #{followed.nickname} blocked you."}
956 FollowingRelationship.follow(follower, followed, state)
960 def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
961 {:error, "Not subscribed!"}
964 @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
965 def unfollow(%User{} = follower, %User{} = followed) do
966 case do_unfollow(follower, followed) do
967 {:ok, follower, followed} ->
968 {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
975 @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
976 defp do_unfollow(%User{} = follower, %User{} = followed) do
977 case get_follow_state(follower, followed) do
978 state when state in [:follow_pending, :follow_accept] ->
979 FollowingRelationship.unfollow(follower, followed)
982 {:error, "Not subscribed!"}
986 @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
987 def get_follow_state(%User{} = follower, %User{} = following) do
988 following_relationship = FollowingRelationship.get(follower, following)
989 get_follow_state(follower, following, following_relationship)
992 def get_follow_state(
995 following_relationship
997 case {following_relationship, following.local} do
999 case Utils.fetch_latest_follow(follower, following) do
1000 %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
1001 FollowingRelationship.state_to_enum(state)
1007 {%{state: state}, _} ->
1015 def locked?(%User{} = user) do
1016 user.is_locked || false
1019 def get_by_id(id) do
1020 Repo.get_by(User, id: id)
1023 def get_by_ap_id(ap_id) do
1024 Repo.get_by(User, ap_id: ap_id)
1027 def get_all_by_ap_id(ap_ids) do
1028 from(u in __MODULE__,
1029 where: u.ap_id in ^ap_ids
1034 def get_all_by_ids(ids) do
1035 from(u in __MODULE__, where: u.id in ^ids)
1039 # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
1040 # of the ap_id and the domain and tries to get that user
1041 def get_by_guessed_nickname(ap_id) do
1042 domain = URI.parse(ap_id).host
1043 name = List.last(String.split(ap_id, "/"))
1044 nickname = "#{name}@#{domain}"
1046 get_cached_by_nickname(nickname)
1049 def set_cache({:ok, user}), do: set_cache(user)
1050 def set_cache({:error, err}), do: {:error, err}
1052 def set_cache(%User{} = user) do
1053 @cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1054 @cachex.put(:user_cache, "nickname:#{user.nickname}", user)
1055 @cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
1059 def update_and_set_cache(struct, params) do
1061 |> update_changeset(params)
1062 |> update_and_set_cache()
1065 def update_and_set_cache(%{data: %Pleroma.User{} = user} = changeset) do
1066 was_superuser_before_update = User.superuser?(user)
1068 with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
1071 |> maybe_remove_report_notifications(was_superuser_before_update)
1074 defp maybe_remove_report_notifications({:ok, %Pleroma.User{} = user} = result, true) do
1075 if not User.superuser?(user),
1076 do: user |> Notification.destroy_multiple_from_types(["pleroma:report"])
1081 defp maybe_remove_report_notifications(result, _) do
1085 def get_user_friends_ap_ids(user) do
1086 from(u in User.get_friends_query(user), select: u.ap_id)
1090 @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
1091 def get_cached_user_friends_ap_ids(user) do
1092 @cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
1093 get_user_friends_ap_ids(user)
1097 def invalidate_cache(user) do
1098 @cachex.del(:user_cache, "ap_id:#{user.ap_id}")
1099 @cachex.del(:user_cache, "nickname:#{user.nickname}")
1100 @cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
1101 @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
1102 @cachex.del(:user_cache, "muted_users_ap_ids:#{user.ap_id}")
1105 @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
1106 def get_cached_by_ap_id(ap_id) do
1107 key = "ap_id:#{ap_id}"
1109 with {:ok, nil} <- @cachex.get(:user_cache, key),
1110 user when not is_nil(user) <- get_by_ap_id(ap_id),
1111 {:ok, true} <- @cachex.put(:user_cache, key, user) do
1119 def get_cached_by_id(id) do
1123 @cachex.fetch!(:user_cache, key, fn _ ->
1124 user = get_by_id(id)
1127 @cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1128 {:commit, user.ap_id}
1134 get_cached_by_ap_id(ap_id)
1137 def get_cached_by_nickname(nickname) do
1138 key = "nickname:#{nickname}"
1140 @cachex.fetch!(:user_cache, key, fn _ ->
1141 case get_or_fetch_by_nickname(nickname) do
1142 {:ok, user} -> {:commit, user}
1143 {:error, _error} -> {:ignore, nil}
1148 def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
1149 restrict_to_local = Config.get([:instance, :limit_to_local_content])
1152 is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
1153 get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
1155 restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
1156 get_cached_by_nickname(nickname_or_id)
1158 restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
1159 get_cached_by_nickname(nickname_or_id)
1166 @spec get_by_nickname(String.t()) :: User.t() | nil
1167 def get_by_nickname(nickname) do
1168 Repo.get_by(User, nickname: nickname) ||
1169 if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
1170 Repo.get_by(User, nickname: local_nickname(nickname))
1174 def get_by_email(email), do: Repo.get_by(User, email: email)
1176 def get_by_nickname_or_email(nickname_or_email) do
1177 get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
1180 def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
1182 def get_or_fetch_by_nickname(nickname) do
1183 with %User{} = user <- get_by_nickname(nickname) do
1187 with [_nick, _domain] <- String.split(nickname, "@"),
1188 {:ok, user} <- fetch_by_nickname(nickname) do
1191 _e -> {:error, "not found " <> nickname}
1196 @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1197 def get_followers_query(%User{} = user, nil) do
1198 User.Query.build(%{followers: user, is_active: true})
1201 def get_followers_query(%User{} = user, page) do
1203 |> get_followers_query(nil)
1204 |> User.Query.paginate(page, 20)
1207 @spec get_followers_query(User.t()) :: Ecto.Query.t()
1208 def get_followers_query(%User{} = user), do: get_followers_query(user, nil)
1210 @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1211 def get_followers(%User{} = user, page \\ nil) do
1213 |> get_followers_query(page)
1217 @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1218 def get_external_followers(%User{} = user, page \\ nil) do
1220 |> get_followers_query(page)
1221 |> User.Query.build(%{external: true})
1225 def get_followers_ids(%User{} = user, page \\ nil) do
1227 |> get_followers_query(page)
1228 |> select([u], u.id)
1232 @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1233 def get_friends_query(%User{} = user, nil) do
1234 User.Query.build(%{friends: user, deactivated: false})
1237 def get_friends_query(%User{} = user, page) do
1239 |> get_friends_query(nil)
1240 |> User.Query.paginate(page, 20)
1243 @spec get_friends_query(User.t()) :: Ecto.Query.t()
1244 def get_friends_query(%User{} = user), do: get_friends_query(user, nil)
1246 def get_friends(%User{} = user, page \\ nil) do
1248 |> get_friends_query(page)
1252 def get_friends_ap_ids(%User{} = user) do
1254 |> get_friends_query(nil)
1255 |> select([u], u.ap_id)
1259 def get_friends_ids(%User{} = user, page \\ nil) do
1261 |> get_friends_query(page)
1262 |> select([u], u.id)
1266 def increase_note_count(%User{} = user) do
1268 |> where(id: ^user.id)
1269 |> update([u], inc: [note_count: 1])
1271 |> Repo.update_all([])
1273 {1, [user]} -> set_cache(user)
1278 def decrease_note_count(%User{} = user) do
1280 |> where(id: ^user.id)
1283 note_count: fragment("greatest(0, note_count - 1)")
1287 |> Repo.update_all([])
1289 {1, [user]} -> set_cache(user)
1294 def update_note_count(%User{} = user, note_count \\ nil) do
1299 where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1305 |> cast(%{note_count: note_count}, [:note_count])
1306 |> update_and_set_cache()
1309 @spec maybe_fetch_follow_information(User.t()) :: User.t()
1310 def maybe_fetch_follow_information(user) do
1311 with {:ok, user} <- fetch_follow_information(user) do
1315 Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1321 def fetch_follow_information(user) do
1322 with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1324 |> follow_information_changeset(info)
1325 |> update_and_set_cache()
1329 defp follow_information_changeset(user, params) do
1336 :hide_followers_count,
1341 @spec update_follower_count(User.t()) :: {:ok, User.t()}
1342 def update_follower_count(%User{} = user) do
1343 if user.local or !Config.get([:instance, :external_user_synchronization]) do
1344 follower_count = FollowingRelationship.follower_count(user)
1347 |> follow_information_changeset(%{follower_count: follower_count})
1348 |> update_and_set_cache
1350 {:ok, maybe_fetch_follow_information(user)}
1354 @spec update_following_count(User.t()) :: {:ok, User.t()}
1355 def update_following_count(%User{local: false} = user) do
1356 if Config.get([:instance, :external_user_synchronization]) do
1357 {:ok, maybe_fetch_follow_information(user)}
1363 def update_following_count(%User{local: true} = user) do
1364 following_count = FollowingRelationship.following_count(user)
1367 |> follow_information_changeset(%{following_count: following_count})
1368 |> update_and_set_cache()
1371 @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1372 def get_users_from_set(ap_ids, opts \\ []) do
1373 local_only = Keyword.get(opts, :local_only, true)
1374 criteria = %{ap_id: ap_ids, is_active: true}
1375 criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1377 User.Query.build(criteria)
1381 @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1382 def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1385 query = User.Query.build(%{recipients_from_activity: to, local: true, is_active: true})
1391 @spec mute(User.t(), User.t(), map()) ::
1392 {:ok, list(UserRelationship.t())} | {:error, String.t()}
1393 def mute(%User{} = muter, %User{} = mutee, params \\ %{}) do
1394 notifications? = Map.get(params, :notifications, true)
1395 expires_in = Map.get(params, :expires_in, 0)
1397 with {:ok, user_mute} <- UserRelationship.create_mute(muter, mutee),
1398 {:ok, user_notification_mute} <-
1399 (notifications? && UserRelationship.create_notification_mute(muter, mutee)) ||
1401 if expires_in > 0 do
1402 Pleroma.Workers.MuteExpireWorker.enqueue(
1404 %{"muter_id" => muter.id, "mutee_id" => mutee.id},
1405 schedule_in: expires_in
1409 @cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
1411 {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
1415 def unmute(%User{} = muter, %User{} = mutee) do
1416 with {:ok, user_mute} <- UserRelationship.delete_mute(muter, mutee),
1417 {:ok, user_notification_mute} <-
1418 UserRelationship.delete_notification_mute(muter, mutee) do
1419 @cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
1420 {:ok, [user_mute, user_notification_mute]}
1424 def unmute(muter_id, mutee_id) do
1425 with {:muter, %User{} = muter} <- {:muter, User.get_by_id(muter_id)},
1426 {:mutee, %User{} = mutee} <- {:mutee, User.get_by_id(mutee_id)} do
1427 unmute(muter, mutee)
1429 {who, result} = error ->
1431 "User.unmute/2 failed. #{who}: #{result}, muter_id: #{muter_id}, mutee_id: #{mutee_id}"
1438 def subscribe(%User{} = subscriber, %User{} = target) do
1439 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
1441 if blocks?(target, subscriber) and deny_follow_blocked do
1442 {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1444 # Note: the relationship is inverse: subscriber acts as relationship target
1445 UserRelationship.create_inverse_subscription(target, subscriber)
1449 def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1450 with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1451 subscribe(subscriber, subscribee)
1455 def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1456 # Note: the relationship is inverse: subscriber acts as relationship target
1457 UserRelationship.delete_inverse_subscription(target, unsubscriber)
1460 def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1461 with %User{} = user <- get_cached_by_ap_id(ap_id) do
1462 unsubscribe(unsubscriber, user)
1466 def block(%User{} = blocker, %User{} = blocked) do
1467 # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1469 if following?(blocker, blocked) do
1470 {:ok, blocker, _} = unfollow(blocker, blocked)
1476 # clear any requested follows from both sides as well
1478 case CommonAPI.reject_follow_request(blocked, blocker) do
1479 {:ok, %User{} = updated_blocked} -> updated_blocked
1484 case CommonAPI.reject_follow_request(blocker, blocked) do
1485 {:ok, %User{} = updated_blocker} -> updated_blocker
1489 unsubscribe(blocked, blocker)
1491 unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
1492 if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)
1494 {:ok, blocker} = update_follower_count(blocker)
1495 {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1496 add_to_block(blocker, blocked)
1499 # helper to handle the block given only an actor's AP id
1500 def block(%User{} = blocker, %{ap_id: ap_id}) do
1501 block(blocker, get_cached_by_ap_id(ap_id))
1504 def unblock(%User{} = blocker, %User{} = blocked) do
1505 remove_from_block(blocker, blocked)
1508 # helper to handle the block given only an actor's AP id
1509 def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1510 unblock(blocker, get_cached_by_ap_id(ap_id))
1513 def mutes?(nil, _), do: false
1514 def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1516 def mutes_user?(%User{} = user, %User{} = target) do
1517 UserRelationship.mute_exists?(user, target)
1520 @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1521 def muted_notifications?(nil, _), do: false
1523 def muted_notifications?(%User{} = user, %User{} = target),
1524 do: UserRelationship.notification_mute_exists?(user, target)
1526 def blocks?(nil, _), do: false
1528 def blocks?(%User{} = user, %User{} = target) do
1529 blocks_user?(user, target) ||
1530 (blocks_domain?(user, target) and not User.following?(user, target))
1533 def blocks_user?(%User{} = user, %User{} = target) do
1534 UserRelationship.block_exists?(user, target)
1537 def blocks_user?(_, _), do: false
1539 def blocks_domain?(%User{} = user, %User{} = target) do
1540 domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1541 %{host: host} = URI.parse(target.ap_id)
1542 Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1545 def blocks_domain?(_, _), do: false
1547 def subscribed_to?(%User{} = user, %User{} = target) do
1548 # Note: the relationship is inverse: subscriber acts as relationship target
1549 UserRelationship.inverse_subscription_exists?(target, user)
1552 def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1553 with %User{} = target <- get_cached_by_ap_id(ap_id) do
1554 subscribed_to?(user, target)
1559 Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1560 E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1562 @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1563 def outgoing_relationships_ap_ids(_user, []), do: %{}
1565 def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1567 def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1568 when is_list(relationship_types) do
1571 |> assoc(:outgoing_relationships)
1572 |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1573 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1574 |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1575 |> group_by([user_rel, u], user_rel.relationship_type)
1577 |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1582 fn rel_type -> {rel_type, db_result[rel_type] || []} end
1586 def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1588 def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1590 def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1592 def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1593 when is_list(relationship_types) do
1595 |> assoc(:incoming_relationships)
1596 |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1597 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1598 |> maybe_filter_on_ap_id(ap_ids)
1599 |> select([user_rel, u], u.ap_id)
1604 defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1605 where(query, [user_rel, u], u.ap_id in ^ap_ids)
1608 defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1610 def set_activation_async(user, status \\ true) do
1611 BackgroundWorker.enqueue("user_activation", %{"user_id" => user.id, "status" => status})
1614 @spec set_activation([User.t()], boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
1615 def set_activation(users, status) when is_list(users) do
1616 Repo.transaction(fn ->
1617 for user <- users, do: set_activation(user, status)
1621 @spec set_activation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
1622 def set_activation(%User{} = user, status) do
1623 with {:ok, user} <- set_activation_status(user, status) do
1626 |> Enum.filter(& &1.local)
1627 |> Enum.each(&set_cache(update_following_count(&1)))
1629 # Only update local user counts, remote will be update during the next pull.
1632 |> Enum.filter(& &1.local)
1633 |> Enum.each(&do_unfollow(user, &1))
1639 def approve(users) when is_list(users) do
1640 Repo.transaction(fn ->
1641 Enum.map(users, fn user ->
1642 with {:ok, user} <- approve(user), do: user
1647 def approve(%User{is_approved: false} = user) do
1648 with chg <- change(user, is_approved: true),
1649 {:ok, user} <- update_and_set_cache(chg) do
1650 post_register_action(user)
1655 def approve(%User{} = user), do: {:ok, user}
1657 def confirm(users) when is_list(users) do
1658 Repo.transaction(fn ->
1659 Enum.map(users, fn user ->
1660 with {:ok, user} <- confirm(user), do: user
1665 def confirm(%User{is_confirmed: false} = user) do
1666 with chg <- confirmation_changeset(user, set_confirmation: true),
1667 {:ok, user} <- update_and_set_cache(chg) do
1668 post_register_action(user)
1673 def confirm(%User{} = user), do: {:ok, user}
1675 def set_suggestion(users, is_suggested) when is_list(users) do
1676 Repo.transaction(fn ->
1677 Enum.map(users, fn user ->
1678 with {:ok, user} <- set_suggestion(user, is_suggested), do: user
1683 def set_suggestion(%User{is_suggested: is_suggested} = user, is_suggested), do: {:ok, user}
1685 def set_suggestion(%User{} = user, is_suggested) when is_boolean(is_suggested) do
1687 |> change(is_suggested: is_suggested)
1688 |> update_and_set_cache()
1691 def update_notification_settings(%User{} = user, settings) do
1693 |> cast(%{notification_settings: settings}, [])
1694 |> cast_embed(:notification_settings)
1695 |> validate_required([:notification_settings])
1696 |> update_and_set_cache()
1699 @spec purge_user_changeset(User.t()) :: Changeset.t()
1700 def purge_user_changeset(user) do
1701 # "Right to be forgotten"
1702 # https://gdpr.eu/right-to-be-forgotten/
1711 last_refreshed_at: nil,
1712 last_digest_emailed_at: nil,
1719 password_reset_pending: false,
1720 registration_reason: nil,
1721 confirmation_token: nil,
1725 is_moderator: false,
1727 mastofe_settings: nil,
1730 pleroma_settings_store: %{},
1733 is_discoverable: false,
1737 # nickname: preserved
1741 # Purge doesn't delete the user from the database.
1742 # It just nulls all its fields and deactivates it.
1743 # See `User.purge_user_changeset/1` above.
1744 defp purge(%User{} = user) do
1746 |> purge_user_changeset()
1747 |> update_and_set_cache()
1750 def delete(users) when is_list(users) do
1751 for user <- users, do: delete(user)
1754 def delete(%User{} = user) do
1755 # Purge the user immediately
1757 BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1760 # *Actually* delete the user from the DB
1761 defp delete_from_db(%User{} = user) do
1762 invalidate_cache(user)
1766 # If the user never finalized their account, it's safe to delete them.
1767 defp maybe_delete_from_db(%User{local: true, is_confirmed: false} = user),
1768 do: delete_from_db(user)
1770 defp maybe_delete_from_db(%User{local: true, is_approved: false} = user),
1771 do: delete_from_db(user)
1773 defp maybe_delete_from_db(user), do: {:ok, user}
1775 def perform(:force_password_reset, user), do: force_password_reset(user)
1777 @spec perform(atom(), User.t()) :: {:ok, User.t()}
1778 def perform(:delete, %User{} = user) do
1779 # Purge the user again, in case perform/2 is called directly
1782 # Remove all relationships
1785 |> Enum.each(fn follower ->
1786 ActivityPub.unfollow(follower, user)
1787 unfollow(follower, user)
1792 |> Enum.each(fn followed ->
1793 ActivityPub.unfollow(user, followed)
1794 unfollow(user, followed)
1797 delete_user_activities(user)
1798 delete_notifications_from_user_activities(user)
1799 delete_outgoing_pending_follow_requests(user)
1801 maybe_delete_from_db(user)
1804 def perform(:set_activation_async, user, status), do: set_activation(user, status)
1806 @spec external_users_query() :: Ecto.Query.t()
1807 def external_users_query do
1815 @spec external_users(keyword()) :: [User.t()]
1816 def external_users(opts \\ []) do
1818 external_users_query()
1819 |> select([u], struct(u, [:id, :ap_id]))
1823 do: where(query, [u], u.id > ^opts[:max_id]),
1828 do: limit(query, ^opts[:limit]),
1834 def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1836 |> join(:inner, [n], activity in assoc(n, :activity))
1837 |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1838 |> Repo.delete_all()
1841 def delete_user_activities(%User{ap_id: ap_id} = user) do
1843 |> Activity.Queries.by_actor()
1844 |> Repo.chunk_stream(50, :batches)
1845 |> Stream.each(fn activities ->
1846 Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1851 defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1852 with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1853 {:ok, delete_data, _} <- Builder.delete(user, object) do
1854 Pipeline.common_pipeline(delete_data, local: user.local)
1856 {:find_object, nil} ->
1857 # We have the create activity, but not the object, it was probably pruned.
1858 # Insert a tombstone and try again
1859 with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1860 {:ok, _tombstone} <- Object.create(tombstone_data) do
1861 delete_activity(activity, user)
1865 Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1866 Logger.error("Error: #{inspect(e)}")
1870 defp delete_activity(%{data: %{"type" => type}} = activity, user)
1871 when type in ["Like", "Announce"] do
1872 {:ok, undo, _} = Builder.undo(user, activity)
1873 Pipeline.common_pipeline(undo, local: user.local)
1876 defp delete_activity(_activity, _user), do: "Doing nothing"
1878 defp delete_outgoing_pending_follow_requests(user) do
1880 |> FollowingRelationship.outgoing_pending_follow_requests_query()
1881 |> Repo.delete_all()
1884 def html_filter_policy(%User{no_rich_text: true}) do
1885 Pleroma.HTML.Scrubber.TwitterText
1888 def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])
1890 def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1892 def get_or_fetch_by_ap_id(ap_id) do
1893 cached_user = get_cached_by_ap_id(ap_id)
1895 maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)
1897 case {cached_user, maybe_fetched_user} do
1898 {_, {:ok, %User{} = user}} ->
1901 {%User{} = user, _} ->
1905 {:error, :not_found}
1910 Creates an internal service actor by URI if missing.
1911 Optionally takes nickname for addressing.
1913 @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1914 def get_or_create_service_actor_by_ap_id(uri, nickname) do
1916 case get_cached_by_ap_id(uri) do
1918 with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1919 Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1923 %User{invisible: false} = user ->
1933 @spec set_invisible(User.t()) :: {:ok, User.t()}
1934 defp set_invisible(user) do
1936 |> change(%{invisible: true})
1937 |> update_and_set_cache()
1940 @spec create_service_actor(String.t(), String.t()) ::
1941 {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1942 defp create_service_actor(uri, nickname) do
1948 follower_address: uri <> "/followers"
1951 |> unique_constraint(:nickname)
1956 def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1959 |> :public_key.pem_decode()
1961 |> :public_key.pem_entry_decode()
1966 def public_key(_), do: {:error, "key not found"}
1968 def get_public_key_for_ap_id(ap_id) do
1969 with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1970 {:ok, public_key} <- public_key(user) do
1977 def ap_enabled?(%User{local: true}), do: true
1978 def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1979 def ap_enabled?(_), do: false
1981 @doc "Gets or fetch a user by uri or nickname."
1982 @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1983 def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1984 def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1986 # wait a period of time and return newest version of the User structs
1987 # this is because we have synchronous follow APIs and need to simulate them
1988 # with an async handshake
1989 def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1990 with %User{} = a <- get_cached_by_id(a.id),
1991 %User{} = b <- get_cached_by_id(b.id) do
1998 def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1999 with :ok <- :timer.sleep(timeout),
2000 %User{} = a <- get_cached_by_id(a.id),
2001 %User{} = b <- get_cached_by_id(b.id) do
2008 def parse_bio(bio) when is_binary(bio) and bio != "" do
2010 |> CommonUtils.format_input("text/plain", mentions_format: :full)
2014 def parse_bio(_), do: ""
2016 def parse_bio(bio, user) when is_binary(bio) and bio != "" do
2017 # TODO: get profile URLs other than user.ap_id
2018 profile_urls = [user.ap_id]
2021 |> CommonUtils.format_input("text/plain",
2022 mentions_format: :full,
2023 rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
2028 def parse_bio(_, _), do: ""
2030 def tag(user_identifiers, tags) when is_list(user_identifiers) do
2031 Repo.transaction(fn ->
2032 for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
2036 def tag(nickname, tags) when is_binary(nickname),
2037 do: tag(get_by_nickname(nickname), tags)
2039 def tag(%User{} = user, tags),
2040 do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
2042 def untag(user_identifiers, tags) when is_list(user_identifiers) do
2043 Repo.transaction(fn ->
2044 for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
2048 def untag(nickname, tags) when is_binary(nickname),
2049 do: untag(get_by_nickname(nickname), tags)
2051 def untag(%User{} = user, tags),
2052 do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
2054 defp update_tags(%User{} = user, new_tags) do
2055 {:ok, updated_user} =
2057 |> change(%{tags: new_tags})
2058 |> update_and_set_cache()
2063 defp normalize_tags(tags) do
2066 |> Enum.map(&String.downcase/1)
2069 def local_nickname_regex do
2070 if Config.get([:instance, :extended_nickname_format]) do
2071 @extended_local_nickname_regex
2073 @strict_local_nickname_regex
2077 def local_nickname(nickname_or_mention) do
2080 |> String.split("@")
2084 def full_nickname(%User{} = user) do
2085 if String.contains?(user.nickname, "@") do
2088 %{host: host} = URI.parse(user.ap_id)
2089 user.nickname <> "@" <> host
2093 def full_nickname(nickname_or_mention),
2094 do: String.trim_leading(nickname_or_mention, "@")
2096 def error_user(ap_id) do
2100 nickname: "erroruser@example.com",
2101 inserted_at: NaiveDateTime.utc_now()
2105 @spec all_superusers() :: [User.t()]
2106 def all_superusers do
2107 User.Query.build(%{super_users: true, local: true, is_active: true})
2111 def muting_reblogs?(%User{} = user, %User{} = target) do
2112 UserRelationship.reblog_mute_exists?(user, target)
2115 def showing_reblogs?(%User{} = user, %User{} = target) do
2116 not muting_reblogs?(user, target)
2120 The function returns a query to get users with no activity for given interval of days.
2121 Inactive users are those who didn't read any notification, or had any activity where
2122 the user is the activity's actor, during `inactivity_threshold` days.
2123 Deactivated users will not appear in this list.
2127 iex> Pleroma.User.list_inactive_users()
2130 @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
2131 def list_inactive_users_query(inactivity_threshold \\ 7) do
2132 negative_inactivity_threshold = -inactivity_threshold
2133 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2134 # Subqueries are not supported in `where` clauses, join gets too complicated.
2135 has_read_notifications =
2136 from(n in Pleroma.Notification,
2137 where: n.seen == true,
2139 having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
2142 |> Pleroma.Repo.all()
2144 from(u in Pleroma.User,
2145 left_join: a in Pleroma.Activity,
2146 on: u.ap_id == a.actor,
2147 where: not is_nil(u.nickname),
2148 where: u.is_active == ^true,
2149 where: u.id not in ^has_read_notifications,
2152 max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
2153 is_nil(max(a.inserted_at))
2158 Enable or disable email notifications for user
2162 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
2163 Pleroma.User{email_notifications: %{"digest" => true}}
2165 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
2166 Pleroma.User{email_notifications: %{"digest" => false}}
2168 @spec switch_email_notifications(t(), String.t(), boolean()) ::
2169 {:ok, t()} | {:error, Ecto.Changeset.t()}
2170 def switch_email_notifications(user, type, status) do
2171 User.update_email_notifications(user, %{type => status})
2175 Set `last_digest_emailed_at` value for the user to current time
2177 @spec touch_last_digest_emailed_at(t()) :: t()
2178 def touch_last_digest_emailed_at(user) do
2179 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2181 {:ok, updated_user} =
2183 |> change(%{last_digest_emailed_at: now})
2184 |> update_and_set_cache()
2189 @spec set_confirmation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
2190 def set_confirmation(%User{} = user, bool) do
2192 |> confirmation_changeset(set_confirmation: bool)
2193 |> update_and_set_cache()
2196 def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
2200 def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
2201 # use instance-default
2202 config = Config.get([:assets, :mascots])
2203 default_mascot = Config.get([:assets, :default_mascot])
2204 mascot = Keyword.get(config, default_mascot)
2207 "id" => "default-mascot",
2208 "url" => mascot[:url],
2209 "preview_url" => mascot[:url],
2211 "mime_type" => mascot[:mime_type]
2216 def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
2218 def ensure_keys_present(%User{} = user) do
2219 with {:ok, pem} <- Keys.generate_rsa_pem() do
2221 |> cast(%{keys: pem}, [:keys])
2222 |> validate_required([:keys])
2223 |> update_and_set_cache()
2227 def get_ap_ids_by_nicknames(nicknames) do
2229 where: u.nickname in ^nicknames,
2235 defp put_password_hash(
2236 %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2238 change(changeset, password_hash: Pleroma.Password.Pbkdf2.hash_pwd_salt(password))
2241 defp put_password_hash(changeset), do: changeset
2243 def is_internal_user?(%User{nickname: nil}), do: true
2244 def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2245 def is_internal_user?(_), do: false
2247 # A hack because user delete activities have a fake id for whatever reason
2248 # TODO: Get rid of this
2249 def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2251 def get_delivered_users_by_object_id(object_id) do
2253 inner_join: delivery in assoc(u, :deliveries),
2254 where: delivery.object_id == ^object_id
2259 def change_email(user, email) do
2261 |> cast(%{email: email}, [:email])
2262 |> maybe_validate_required_email(false)
2263 |> unique_constraint(:email)
2264 |> validate_format(:email, @email_regex)
2265 |> update_and_set_cache()
2268 def alias_users(user) do
2270 |> Enum.map(&User.get_cached_by_ap_id/1)
2271 |> Enum.filter(fn user -> user != nil end)
2274 def add_alias(user, new_alias_user) do
2275 current_aliases = user.also_known_as || []
2276 new_alias_ap_id = new_alias_user.ap_id
2278 if new_alias_ap_id in current_aliases do
2282 |> cast(%{also_known_as: current_aliases ++ [new_alias_ap_id]}, [:also_known_as])
2283 |> update_and_set_cache()
2287 def delete_alias(user, alias_user) do
2288 current_aliases = user.also_known_as || []
2289 alias_ap_id = alias_user.ap_id
2291 if alias_ap_id in current_aliases do
2293 |> cast(%{also_known_as: current_aliases -- [alias_ap_id]}, [:also_known_as])
2294 |> update_and_set_cache()
2296 {:error, :no_such_alias}
2300 # Internal function; public one is `deactivate/2`
2301 defp set_activation_status(user, status) do
2303 |> cast(%{is_active: status}, [:is_active])
2304 |> update_and_set_cache()
2307 def update_banner(user, banner) do
2309 |> cast(%{banner: banner}, [:banner])
2310 |> update_and_set_cache()
2313 def update_background(user, background) do
2315 |> cast(%{background: background}, [:background])
2316 |> update_and_set_cache()
2319 def validate_fields(changeset, remote? \\ false) do
2320 limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2321 limit = Config.get([:instance, limit_name], 0)
2324 |> validate_length(:fields, max: limit)
2325 |> validate_change(:fields, fn :fields, fields ->
2326 if Enum.all?(fields, &valid_field?/1) do
2334 defp valid_field?(%{"name" => name, "value" => value}) do
2335 name_limit = Config.get([:instance, :account_field_name_length], 255)
2336 value_limit = Config.get([:instance, :account_field_value_length], 255)
2338 is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2339 String.length(value) <= value_limit
2342 defp valid_field?(_), do: false
2344 defp truncate_field(%{"name" => name, "value" => value}) do
2346 String.split_at(name, Config.get([:instance, :account_field_name_length], 255))
2349 String.split_at(value, Config.get([:instance, :account_field_value_length], 255))
2351 %{"name" => name, "value" => value}
2354 def admin_api_update(user, params) do
2361 |> update_and_set_cache()
2364 @doc "Signs user out of all applications"
2365 def global_sign_out(user) do
2366 OAuth.Authorization.delete_user_authorizations(user)
2367 OAuth.Token.delete_user_tokens(user)
2370 def mascot_update(user, url) do
2372 |> cast(%{mascot: url}, [:mascot])
2373 |> validate_required([:mascot])
2374 |> update_and_set_cache()
2377 def mastodon_settings_update(user, settings) do
2379 |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
2380 |> validate_required([:mastofe_settings])
2381 |> update_and_set_cache()
2384 @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2385 def confirmation_changeset(user, set_confirmation: confirmed?) do
2390 confirmation_token: nil
2394 is_confirmed: false,
2395 confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2399 cast(user, params, [:is_confirmed, :confirmation_token])
2402 @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
2403 def approval_changeset(user, set_approval: approved?) do
2404 cast(user, %{is_approved: approved?}, [:is_approved])
2407 @spec add_pinned_object_id(User.t(), String.t()) :: {:ok, User.t()} | {:error, term()}
2408 def add_pinned_object_id(%User{} = user, object_id) do
2409 if !user.pinned_objects[object_id] do
2410 params = %{pinned_objects: Map.put(user.pinned_objects, object_id, NaiveDateTime.utc_now())}
2413 |> cast(params, [:pinned_objects])
2414 |> validate_change(:pinned_objects, fn :pinned_objects, pinned_objects ->
2415 max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2417 if Enum.count(pinned_objects) <= max_pinned_statuses do
2420 [pinned_objects: "You have already pinned the maximum number of statuses"]
2426 |> update_and_set_cache()
2429 @spec remove_pinned_object_id(User.t(), String.t()) :: {:ok, t()} | {:error, term()}
2430 def remove_pinned_object_id(%User{} = user, object_id) do
2433 %{pinned_objects: Map.delete(user.pinned_objects, object_id)},
2436 |> update_and_set_cache()
2439 def update_email_notifications(user, settings) do
2440 email_notifications =
2441 user.email_notifications
2442 |> Map.merge(settings)
2443 |> Map.take(["digest"])
2445 params = %{email_notifications: email_notifications}
2446 fields = [:email_notifications]
2449 |> cast(params, fields)
2450 |> validate_required(fields)
2451 |> update_and_set_cache()
2454 defp set_domain_blocks(user, domain_blocks) do
2455 params = %{domain_blocks: domain_blocks}
2458 |> cast(params, [:domain_blocks])
2459 |> validate_required([:domain_blocks])
2460 |> update_and_set_cache()
2463 def block_domain(user, domain_blocked) do
2464 set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2467 def unblock_domain(user, domain_blocked) do
2468 set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2471 @spec add_to_block(User.t(), User.t()) ::
2472 {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2473 defp add_to_block(%User{} = user, %User{} = blocked) do
2474 with {:ok, relationship} <- UserRelationship.create_block(user, blocked) do
2475 @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
2480 @spec add_to_block(User.t(), User.t()) ::
2481 {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2482 defp remove_from_block(%User{} = user, %User{} = blocked) do
2483 with {:ok, relationship} <- UserRelationship.delete_block(user, blocked) do
2484 @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
2489 def set_invisible(user, invisible) do
2490 params = %{invisible: invisible}
2493 |> cast(params, [:invisible])
2494 |> validate_required([:invisible])
2495 |> update_and_set_cache()
2498 def sanitize_html(%User{} = user) do
2499 sanitize_html(user, nil)
2502 # User data that mastodon isn't filtering (treated as plaintext):
2505 def sanitize_html(%User{} = user, filter) do
2507 Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2510 "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2515 |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2516 |> Map.put(:fields, fields)
2519 def get_host(%User{ap_id: ap_id} = _user) do
2520 URI.parse(ap_id).host
2523 def update_last_active_at(%__MODULE__{local: true} = user) do
2525 |> cast(%{last_active_at: NaiveDateTime.utc_now()}, [:last_active_at])
2526 |> update_and_set_cache()
2529 def active_user_count(days \\ 30) do
2530 active_after = Timex.shift(NaiveDateTime.utc_now(), days: -days)
2533 |> where([u], u.last_active_at >= ^active_after)
2534 |> where([u], u.local == true)
2535 |> Repo.aggregate(:count)
2538 def update_last_status_at(user) do
2540 |> where(id: ^user.id)
2541 |> update([u], set: [last_status_at: fragment("NOW()")])
2543 |> Repo.update_all([])
2545 {1, [user]} -> set_cache(user)