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())
685 |> unique_constraint(:ap_id)
686 |> put_following_and_follower_and_featured_address()
689 def register_changeset(struct, params \\ %{}, opts \\ []) do
690 bio_limit = Config.get([:instance, :user_bio_length], 5000)
691 name_limit = Config.get([:instance, :user_name_length], 100)
692 reason_limit = Config.get([:instance, :registration_reason_length], 500)
695 if is_nil(opts[:confirmed]) do
696 !Config.get([:instance, :account_activation_required])
702 if is_nil(opts[:approved]) do
703 !Config.get([:instance, :account_approval_required])
709 |> confirmation_changeset(set_confirmation: confirmed?)
710 |> approval_changeset(set_approval: approved?)
718 :password_confirmation,
720 :registration_reason,
723 |> validate_required([:name, :nickname, :password, :password_confirmation])
724 |> validate_confirmation(:password)
725 |> unique_constraint(:email)
726 |> validate_format(:email, @email_regex)
727 |> validate_change(:email, fn :email, email ->
729 Config.get([User, :email_blacklist])
730 |> Enum.all?(fn blacklisted_domain ->
731 !String.ends_with?(email, ["@" <> blacklisted_domain, "." <> blacklisted_domain])
734 if valid?, do: [], else: [email: "Invalid email"]
736 |> unique_constraint(:nickname)
737 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
738 |> validate_format(:nickname, local_nickname_regex())
739 |> validate_length(:bio, max: bio_limit)
740 |> validate_length(:name, min: 1, max: name_limit)
741 |> validate_length(:registration_reason, max: reason_limit)
742 |> maybe_validate_required_email(opts[:external])
746 |> unique_constraint(:ap_id)
747 |> put_following_and_follower_and_featured_address()
750 def maybe_validate_required_email(changeset, true), do: changeset
752 def maybe_validate_required_email(changeset, _) do
753 if Config.get([:instance, :account_activation_required]) do
754 validate_required(changeset, [:email])
760 def put_keys(changeset) do
761 {:ok, pem} = Keys.generate_rsa_pem()
762 put_change(changeset, :keys, pem)
765 def put_ap_id(changeset) do
766 ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
767 put_change(changeset, :ap_id, ap_id)
770 def put_following_and_follower_and_featured_address(changeset) do
771 user = %User{nickname: get_field(changeset, :nickname)}
772 followers = ap_followers(user)
773 following = ap_following(user)
774 featured = ap_featured_collection(user)
777 |> put_change(:follower_address, followers)
778 |> put_change(:following_address, following)
779 |> put_change(:featured_address, featured)
782 defp autofollow_users(user) do
783 candidates = Config.get([:instance, :autofollowed_nicknames])
786 User.Query.build(%{nickname: candidates, local: true, is_active: true})
789 follow_all(user, autofollowed_users)
792 defp autofollowing_users(user) do
793 candidates = Config.get([:instance, :autofollowing_nicknames])
795 User.Query.build(%{nickname: candidates, local: true, deactivated: false})
797 |> Enum.each(&follow(&1, user, :follow_accept))
802 @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
803 def register(%Ecto.Changeset{} = changeset) do
804 with {:ok, user} <- Repo.insert(changeset) do
805 post_register_action(user)
809 def post_register_action(%User{is_confirmed: false} = user) do
810 with {:ok, _} <- maybe_send_confirmation_email(user) do
815 def post_register_action(%User{is_approved: false} = user) do
816 with {:ok, _} <- send_user_approval_email(user),
817 {:ok, _} <- send_admin_approval_emails(user) do
822 def post_register_action(%User{is_approved: true, is_confirmed: true} = user) do
823 with {:ok, user} <- autofollow_users(user),
824 {:ok, _} <- autofollowing_users(user),
825 {:ok, user} <- set_cache(user),
826 {:ok, _} <- maybe_send_registration_email(user),
827 {:ok, _} <- maybe_send_welcome_email(user),
828 {:ok, _} <- maybe_send_welcome_message(user) do
833 defp send_user_approval_email(user) do
835 |> Pleroma.Emails.UserEmail.approval_pending_email()
836 |> Pleroma.Emails.Mailer.deliver_async()
841 defp send_admin_approval_emails(user) do
843 |> Enum.filter(fn user -> not is_nil(user.email) end)
844 |> Enum.each(fn superuser ->
846 |> Pleroma.Emails.AdminEmail.new_unapproved_registration(user)
847 |> Pleroma.Emails.Mailer.deliver_async()
853 defp maybe_send_welcome_message(user) do
854 if User.WelcomeMessage.enabled?() do
855 User.WelcomeMessage.post_message(user)
862 defp maybe_send_welcome_email(%User{email: email} = user) when is_binary(email) do
863 if User.WelcomeEmail.enabled?() do
864 User.WelcomeEmail.send_email(user)
871 defp maybe_send_welcome_email(_), do: {:ok, :noop}
873 @spec maybe_send_confirmation_email(User.t()) :: {:ok, :enqueued | :noop}
874 def maybe_send_confirmation_email(%User{is_confirmed: false, email: email} = user)
875 when is_binary(email) do
876 if Config.get([:instance, :account_activation_required]) do
877 send_confirmation_email(user)
884 def maybe_send_confirmation_email(_), do: {:ok, :noop}
886 @spec send_confirmation_email(Uset.t()) :: User.t()
887 def send_confirmation_email(%User{} = user) do
889 |> Pleroma.Emails.UserEmail.account_confirmation_email()
890 |> Pleroma.Emails.Mailer.deliver_async()
895 @spec maybe_send_registration_email(User.t()) :: {:ok, :enqueued | :noop}
896 defp maybe_send_registration_email(%User{email: email} = user) when is_binary(email) do
897 with false <- User.WelcomeEmail.enabled?(),
898 false <- Config.get([:instance, :account_activation_required], false),
899 false <- Config.get([:instance, :account_approval_required], false) do
901 |> Pleroma.Emails.UserEmail.successful_registration_email()
902 |> Pleroma.Emails.Mailer.deliver_async()
911 defp maybe_send_registration_email(_), do: {:ok, :noop}
913 def needs_update?(%User{local: true}), do: false
915 def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
917 def needs_update?(%User{local: false} = user) do
918 NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
921 def needs_update?(_), do: true
923 @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
925 # "Locked" (self-locked) users demand explicit authorization of follow requests
926 def maybe_direct_follow(%User{} = follower, %User{local: true, is_locked: true} = followed) do
927 follow(follower, followed, :follow_pending)
930 def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
931 follow(follower, followed)
934 def maybe_direct_follow(%User{} = follower, %User{} = followed) do
935 if not ap_enabled?(followed) do
936 follow(follower, followed)
938 {:ok, follower, followed}
942 @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
943 @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
944 def follow_all(follower, followeds) do
946 |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
947 |> Enum.each(&follow(follower, &1, :follow_accept))
952 def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
953 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
956 not followed.is_active ->
957 {:error, "Could not follow user: #{followed.nickname} is deactivated."}
959 deny_follow_blocked and blocks?(followed, follower) ->
960 {:error, "Could not follow user: #{followed.nickname} blocked you."}
963 FollowingRelationship.follow(follower, followed, state)
967 def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
968 {:error, "Not subscribed!"}
971 @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
972 def unfollow(%User{} = follower, %User{} = followed) do
973 case do_unfollow(follower, followed) do
974 {:ok, follower, followed} ->
975 {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
982 @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
983 defp do_unfollow(%User{} = follower, %User{} = followed) do
984 case get_follow_state(follower, followed) do
985 state when state in [:follow_pending, :follow_accept] ->
986 FollowingRelationship.unfollow(follower, followed)
989 {:error, "Not subscribed!"}
993 @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
994 def get_follow_state(%User{} = follower, %User{} = following) do
995 following_relationship = FollowingRelationship.get(follower, following)
996 get_follow_state(follower, following, following_relationship)
999 def get_follow_state(
1001 %User{} = following,
1002 following_relationship
1004 case {following_relationship, following.local} do
1006 case Utils.fetch_latest_follow(follower, following) do
1007 %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
1008 FollowingRelationship.state_to_enum(state)
1014 {%{state: state}, _} ->
1022 def locked?(%User{} = user) do
1023 user.is_locked || false
1026 def get_by_id(id) do
1027 Repo.get_by(User, id: id)
1030 def get_by_ap_id(ap_id) do
1031 Repo.get_by(User, ap_id: ap_id)
1034 def get_all_by_ap_id(ap_ids) do
1035 from(u in __MODULE__,
1036 where: u.ap_id in ^ap_ids
1041 def get_all_by_ids(ids) do
1042 from(u in __MODULE__, where: u.id in ^ids)
1046 # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
1047 # of the ap_id and the domain and tries to get that user
1048 def get_by_guessed_nickname(ap_id) do
1049 domain = URI.parse(ap_id).host
1050 name = List.last(String.split(ap_id, "/"))
1051 nickname = "#{name}@#{domain}"
1053 get_cached_by_nickname(nickname)
1056 def set_cache({:ok, user}), do: set_cache(user)
1057 def set_cache({:error, err}), do: {:error, err}
1059 def set_cache(%User{} = user) do
1060 @cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1061 @cachex.put(:user_cache, "nickname:#{user.nickname}", user)
1062 @cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
1066 def update_and_set_cache(struct, params) do
1068 |> update_changeset(params)
1069 |> update_and_set_cache()
1072 def update_and_set_cache(%{data: %Pleroma.User{} = user} = changeset) do
1073 was_superuser_before_update = User.superuser?(user)
1075 with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
1078 |> maybe_remove_report_notifications(was_superuser_before_update)
1081 defp maybe_remove_report_notifications({:ok, %Pleroma.User{} = user} = result, true) do
1082 if not User.superuser?(user),
1083 do: user |> Notification.destroy_multiple_from_types(["pleroma:report"])
1088 defp maybe_remove_report_notifications(result, _) do
1092 def get_user_friends_ap_ids(user) do
1093 from(u in User.get_friends_query(user), select: u.ap_id)
1097 @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
1098 def get_cached_user_friends_ap_ids(user) do
1099 @cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
1100 get_user_friends_ap_ids(user)
1104 def invalidate_cache(user) do
1105 @cachex.del(:user_cache, "ap_id:#{user.ap_id}")
1106 @cachex.del(:user_cache, "nickname:#{user.nickname}")
1107 @cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
1108 @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
1109 @cachex.del(:user_cache, "muted_users_ap_ids:#{user.ap_id}")
1112 @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
1113 def get_cached_by_ap_id(ap_id) do
1114 key = "ap_id:#{ap_id}"
1116 with {:ok, nil} <- @cachex.get(:user_cache, key),
1117 user when not is_nil(user) <- get_by_ap_id(ap_id),
1118 {:ok, true} <- @cachex.put(:user_cache, key, user) do
1126 def get_cached_by_id(id) do
1130 @cachex.fetch!(:user_cache, key, fn _ ->
1131 user = get_by_id(id)
1134 @cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1135 {:commit, user.ap_id}
1141 get_cached_by_ap_id(ap_id)
1144 def get_cached_by_nickname(nickname) do
1145 key = "nickname:#{nickname}"
1147 @cachex.fetch!(:user_cache, key, fn _ ->
1148 case get_or_fetch_by_nickname(nickname) do
1149 {:ok, user} -> {:commit, user}
1150 {:error, _error} -> {:ignore, nil}
1155 def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
1156 restrict_to_local = Config.get([:instance, :limit_to_local_content])
1159 is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
1160 get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
1162 restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
1163 get_cached_by_nickname(nickname_or_id)
1165 restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
1166 get_cached_by_nickname(nickname_or_id)
1173 @spec get_by_nickname(String.t()) :: User.t() | nil
1174 def get_by_nickname(nickname) do
1175 Repo.get_by(User, nickname: nickname) ||
1176 if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
1177 Repo.get_by(User, nickname: local_nickname(nickname))
1181 def get_by_email(email), do: Repo.get_by(User, email: email)
1183 def get_by_nickname_or_email(nickname_or_email) do
1184 get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
1187 def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
1189 def get_or_fetch_by_nickname(nickname) do
1190 with %User{} = user <- get_by_nickname(nickname) do
1194 with [_nick, _domain] <- String.split(nickname, "@"),
1195 {:ok, user} <- fetch_by_nickname(nickname) do
1198 _e -> {:error, "not found " <> nickname}
1203 @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1204 def get_followers_query(%User{} = user, nil) do
1205 User.Query.build(%{followers: user, is_active: true})
1208 def get_followers_query(%User{} = user, page) do
1210 |> get_followers_query(nil)
1211 |> User.Query.paginate(page, 20)
1214 @spec get_followers_query(User.t()) :: Ecto.Query.t()
1215 def get_followers_query(%User{} = user), do: get_followers_query(user, nil)
1217 @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1218 def get_followers(%User{} = user, page \\ nil) do
1220 |> get_followers_query(page)
1224 @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1225 def get_external_followers(%User{} = user, page \\ nil) do
1227 |> get_followers_query(page)
1228 |> User.Query.build(%{external: true})
1232 def get_followers_ids(%User{} = user, page \\ nil) do
1234 |> get_followers_query(page)
1235 |> select([u], u.id)
1239 @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1240 def get_friends_query(%User{} = user, nil) do
1241 User.Query.build(%{friends: user, deactivated: false})
1244 def get_friends_query(%User{} = user, page) do
1246 |> get_friends_query(nil)
1247 |> User.Query.paginate(page, 20)
1250 @spec get_friends_query(User.t()) :: Ecto.Query.t()
1251 def get_friends_query(%User{} = user), do: get_friends_query(user, nil)
1253 def get_friends(%User{} = user, page \\ nil) do
1255 |> get_friends_query(page)
1259 def get_friends_ap_ids(%User{} = user) do
1261 |> get_friends_query(nil)
1262 |> select([u], u.ap_id)
1266 def get_friends_ids(%User{} = user, page \\ nil) do
1268 |> get_friends_query(page)
1269 |> select([u], u.id)
1273 def increase_note_count(%User{} = user) do
1275 |> where(id: ^user.id)
1276 |> update([u], inc: [note_count: 1])
1278 |> Repo.update_all([])
1280 {1, [user]} -> set_cache(user)
1285 def decrease_note_count(%User{} = user) do
1287 |> where(id: ^user.id)
1290 note_count: fragment("greatest(0, note_count - 1)")
1294 |> Repo.update_all([])
1296 {1, [user]} -> set_cache(user)
1301 def update_note_count(%User{} = user, note_count \\ nil) do
1306 where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1312 |> cast(%{note_count: note_count}, [:note_count])
1313 |> update_and_set_cache()
1316 @spec maybe_fetch_follow_information(User.t()) :: User.t()
1317 def maybe_fetch_follow_information(user) do
1318 with {:ok, user} <- fetch_follow_information(user) do
1322 Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1328 def fetch_follow_information(user) do
1329 with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1331 |> follow_information_changeset(info)
1332 |> update_and_set_cache()
1336 defp follow_information_changeset(user, params) do
1343 :hide_followers_count,
1348 @spec update_follower_count(User.t()) :: {:ok, User.t()}
1349 def update_follower_count(%User{} = user) do
1350 if user.local or !Config.get([:instance, :external_user_synchronization]) do
1351 follower_count = FollowingRelationship.follower_count(user)
1354 |> follow_information_changeset(%{follower_count: follower_count})
1355 |> update_and_set_cache
1357 {:ok, maybe_fetch_follow_information(user)}
1361 @spec update_following_count(User.t()) :: {:ok, User.t()}
1362 def update_following_count(%User{local: false} = user) do
1363 if Config.get([:instance, :external_user_synchronization]) do
1364 {:ok, maybe_fetch_follow_information(user)}
1370 def update_following_count(%User{local: true} = user) do
1371 following_count = FollowingRelationship.following_count(user)
1374 |> follow_information_changeset(%{following_count: following_count})
1375 |> update_and_set_cache()
1378 @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1379 def get_users_from_set(ap_ids, opts \\ []) do
1380 local_only = Keyword.get(opts, :local_only, true)
1381 criteria = %{ap_id: ap_ids, is_active: true}
1382 criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1384 User.Query.build(criteria)
1388 @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1389 def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1392 query = User.Query.build(%{recipients_from_activity: to, local: true, is_active: true})
1398 @spec mute(User.t(), User.t(), map()) ::
1399 {:ok, list(UserRelationship.t())} | {:error, String.t()}
1400 def mute(%User{} = muter, %User{} = mutee, params \\ %{}) do
1401 notifications? = Map.get(params, :notifications, true)
1402 expires_in = Map.get(params, :expires_in, 0)
1404 with {:ok, user_mute} <- UserRelationship.create_mute(muter, mutee),
1405 {:ok, user_notification_mute} <-
1406 (notifications? && UserRelationship.create_notification_mute(muter, mutee)) ||
1408 if expires_in > 0 do
1409 Pleroma.Workers.MuteExpireWorker.enqueue(
1411 %{"muter_id" => muter.id, "mutee_id" => mutee.id},
1412 schedule_in: expires_in
1416 @cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
1418 {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
1422 def unmute(%User{} = muter, %User{} = mutee) do
1423 with {:ok, user_mute} <- UserRelationship.delete_mute(muter, mutee),
1424 {:ok, user_notification_mute} <-
1425 UserRelationship.delete_notification_mute(muter, mutee) do
1426 @cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
1427 {:ok, [user_mute, user_notification_mute]}
1431 def unmute(muter_id, mutee_id) do
1432 with {:muter, %User{} = muter} <- {:muter, User.get_by_id(muter_id)},
1433 {:mutee, %User{} = mutee} <- {:mutee, User.get_by_id(mutee_id)} do
1434 unmute(muter, mutee)
1436 {who, result} = error ->
1438 "User.unmute/2 failed. #{who}: #{result}, muter_id: #{muter_id}, mutee_id: #{mutee_id}"
1445 def subscribe(%User{} = subscriber, %User{} = target) do
1446 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
1448 if blocks?(target, subscriber) and deny_follow_blocked do
1449 {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1451 # Note: the relationship is inverse: subscriber acts as relationship target
1452 UserRelationship.create_inverse_subscription(target, subscriber)
1456 def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1457 with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1458 subscribe(subscriber, subscribee)
1462 def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1463 # Note: the relationship is inverse: subscriber acts as relationship target
1464 UserRelationship.delete_inverse_subscription(target, unsubscriber)
1467 def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1468 with %User{} = user <- get_cached_by_ap_id(ap_id) do
1469 unsubscribe(unsubscriber, user)
1473 def block(%User{} = blocker, %User{} = blocked) do
1474 # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1476 if following?(blocker, blocked) do
1477 {:ok, blocker, _} = unfollow(blocker, blocked)
1483 # clear any requested follows from both sides as well
1485 case CommonAPI.reject_follow_request(blocked, blocker) do
1486 {:ok, %User{} = updated_blocked} -> updated_blocked
1491 case CommonAPI.reject_follow_request(blocker, blocked) do
1492 {:ok, %User{} = updated_blocker} -> updated_blocker
1496 unsubscribe(blocked, blocker)
1498 unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
1499 if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)
1501 {:ok, blocker} = update_follower_count(blocker)
1502 {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1503 add_to_block(blocker, blocked)
1506 # helper to handle the block given only an actor's AP id
1507 def block(%User{} = blocker, %{ap_id: ap_id}) do
1508 block(blocker, get_cached_by_ap_id(ap_id))
1511 def unblock(%User{} = blocker, %User{} = blocked) do
1512 remove_from_block(blocker, blocked)
1515 # helper to handle the block given only an actor's AP id
1516 def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1517 unblock(blocker, get_cached_by_ap_id(ap_id))
1520 def mutes?(nil, _), do: false
1521 def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1523 def mutes_user?(%User{} = user, %User{} = target) do
1524 UserRelationship.mute_exists?(user, target)
1527 @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1528 def muted_notifications?(nil, _), do: false
1530 def muted_notifications?(%User{} = user, %User{} = target),
1531 do: UserRelationship.notification_mute_exists?(user, target)
1533 def blocks?(nil, _), do: false
1535 def blocks?(%User{} = user, %User{} = target) do
1536 blocks_user?(user, target) ||
1537 (blocks_domain?(user, target) and not User.following?(user, target))
1540 def blocks_user?(%User{} = user, %User{} = target) do
1541 UserRelationship.block_exists?(user, target)
1544 def blocks_user?(_, _), do: false
1546 def blocks_domain?(%User{} = user, %User{} = target) do
1547 domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1548 %{host: host} = URI.parse(target.ap_id)
1549 Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1552 def blocks_domain?(_, _), do: false
1554 def subscribed_to?(%User{} = user, %User{} = target) do
1555 # Note: the relationship is inverse: subscriber acts as relationship target
1556 UserRelationship.inverse_subscription_exists?(target, user)
1559 def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1560 with %User{} = target <- get_cached_by_ap_id(ap_id) do
1561 subscribed_to?(user, target)
1566 Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1567 E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1569 @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1570 def outgoing_relationships_ap_ids(_user, []), do: %{}
1572 def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1574 def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1575 when is_list(relationship_types) do
1578 |> assoc(:outgoing_relationships)
1579 |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1580 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1581 |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1582 |> group_by([user_rel, u], user_rel.relationship_type)
1584 |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1589 fn rel_type -> {rel_type, db_result[rel_type] || []} end
1593 def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1595 def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1597 def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1599 def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1600 when is_list(relationship_types) do
1602 |> assoc(:incoming_relationships)
1603 |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1604 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1605 |> maybe_filter_on_ap_id(ap_ids)
1606 |> select([user_rel, u], u.ap_id)
1611 defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1612 where(query, [user_rel, u], u.ap_id in ^ap_ids)
1615 defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1617 def set_activation_async(user, status \\ true) do
1618 BackgroundWorker.enqueue("user_activation", %{"user_id" => user.id, "status" => status})
1621 @spec set_activation([User.t()], boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
1622 def set_activation(users, status) when is_list(users) do
1623 Repo.transaction(fn ->
1624 for user <- users, do: set_activation(user, status)
1628 @spec set_activation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
1629 def set_activation(%User{} = user, status) do
1630 with {:ok, user} <- set_activation_status(user, status) do
1633 |> Enum.filter(& &1.local)
1634 |> Enum.each(&set_cache(update_following_count(&1)))
1636 # Only update local user counts, remote will be update during the next pull.
1639 |> Enum.filter(& &1.local)
1640 |> Enum.each(&do_unfollow(user, &1))
1646 def approve(users) when is_list(users) do
1647 Repo.transaction(fn ->
1648 Enum.map(users, fn user ->
1649 with {:ok, user} <- approve(user), do: user
1654 def approve(%User{is_approved: false} = user) do
1655 with chg <- change(user, is_approved: true),
1656 {:ok, user} <- update_and_set_cache(chg) do
1657 post_register_action(user)
1662 def approve(%User{} = user), do: {:ok, user}
1664 def confirm(users) when is_list(users) do
1665 Repo.transaction(fn ->
1666 Enum.map(users, fn user ->
1667 with {:ok, user} <- confirm(user), do: user
1672 def confirm(%User{is_confirmed: false} = user) do
1673 with chg <- confirmation_changeset(user, set_confirmation: true),
1674 {:ok, user} <- update_and_set_cache(chg) do
1675 post_register_action(user)
1680 def confirm(%User{} = user), do: {:ok, user}
1682 def set_suggestion(users, is_suggested) when is_list(users) do
1683 Repo.transaction(fn ->
1684 Enum.map(users, fn user ->
1685 with {:ok, user} <- set_suggestion(user, is_suggested), do: user
1690 def set_suggestion(%User{is_suggested: is_suggested} = user, is_suggested), do: {:ok, user}
1692 def set_suggestion(%User{} = user, is_suggested) when is_boolean(is_suggested) do
1694 |> change(is_suggested: is_suggested)
1695 |> update_and_set_cache()
1698 def update_notification_settings(%User{} = user, settings) do
1700 |> cast(%{notification_settings: settings}, [])
1701 |> cast_embed(:notification_settings)
1702 |> validate_required([:notification_settings])
1703 |> update_and_set_cache()
1706 @spec purge_user_changeset(User.t()) :: Changeset.t()
1707 def purge_user_changeset(user) do
1708 # "Right to be forgotten"
1709 # https://gdpr.eu/right-to-be-forgotten/
1718 last_refreshed_at: nil,
1719 last_digest_emailed_at: nil,
1726 password_reset_pending: false,
1727 registration_reason: nil,
1728 confirmation_token: nil,
1732 is_moderator: false,
1734 mastofe_settings: nil,
1737 pleroma_settings_store: %{},
1740 is_discoverable: false,
1744 # nickname: preserved
1748 # Purge doesn't delete the user from the database.
1749 # It just nulls all its fields and deactivates it.
1750 # See `User.purge_user_changeset/1` above.
1751 defp purge(%User{} = user) do
1753 |> purge_user_changeset()
1754 |> update_and_set_cache()
1757 def delete(users) when is_list(users) do
1758 for user <- users, do: delete(user)
1761 def delete(%User{} = user) do
1762 # Purge the user immediately
1764 BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1767 # *Actually* delete the user from the DB
1768 defp delete_from_db(%User{} = user) do
1769 invalidate_cache(user)
1773 # If the user never finalized their account, it's safe to delete them.
1774 defp maybe_delete_from_db(%User{local: true, is_confirmed: false} = user),
1775 do: delete_from_db(user)
1777 defp maybe_delete_from_db(%User{local: true, is_approved: false} = user),
1778 do: delete_from_db(user)
1780 defp maybe_delete_from_db(user), do: {:ok, user}
1782 def perform(:force_password_reset, user), do: force_password_reset(user)
1784 @spec perform(atom(), User.t()) :: {:ok, User.t()}
1785 def perform(:delete, %User{} = user) do
1786 # Purge the user again, in case perform/2 is called directly
1789 # Remove all relationships
1792 |> Enum.each(fn follower ->
1793 ActivityPub.unfollow(follower, user)
1794 unfollow(follower, user)
1799 |> Enum.each(fn followed ->
1800 ActivityPub.unfollow(user, followed)
1801 unfollow(user, followed)
1804 delete_user_activities(user)
1805 delete_notifications_from_user_activities(user)
1806 delete_outgoing_pending_follow_requests(user)
1808 maybe_delete_from_db(user)
1811 def perform(:set_activation_async, user, status), do: set_activation(user, status)
1813 @spec external_users_query() :: Ecto.Query.t()
1814 def external_users_query do
1822 @spec external_users(keyword()) :: [User.t()]
1823 def external_users(opts \\ []) do
1825 external_users_query()
1826 |> select([u], struct(u, [:id, :ap_id]))
1830 do: where(query, [u], u.id > ^opts[:max_id]),
1835 do: limit(query, ^opts[:limit]),
1841 def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1843 |> join(:inner, [n], activity in assoc(n, :activity))
1844 |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1845 |> Repo.delete_all()
1848 def delete_user_activities(%User{ap_id: ap_id} = user) do
1850 |> Activity.Queries.by_actor()
1851 |> Repo.chunk_stream(50, :batches)
1852 |> Stream.each(fn activities ->
1853 Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1858 defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1859 with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1860 {:ok, delete_data, _} <- Builder.delete(user, object) do
1861 Pipeline.common_pipeline(delete_data, local: user.local)
1863 {:find_object, nil} ->
1864 # We have the create activity, but not the object, it was probably pruned.
1865 # Insert a tombstone and try again
1866 with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1867 {:ok, _tombstone} <- Object.create(tombstone_data) do
1868 delete_activity(activity, user)
1872 Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1873 Logger.error("Error: #{inspect(e)}")
1877 defp delete_activity(%{data: %{"type" => type}} = activity, user)
1878 when type in ["Like", "Announce"] do
1879 {:ok, undo, _} = Builder.undo(user, activity)
1880 Pipeline.common_pipeline(undo, local: user.local)
1883 defp delete_activity(_activity, _user), do: "Doing nothing"
1885 defp delete_outgoing_pending_follow_requests(user) do
1887 |> FollowingRelationship.outgoing_pending_follow_requests_query()
1888 |> Repo.delete_all()
1891 def html_filter_policy(%User{no_rich_text: true}) do
1892 Pleroma.HTML.Scrubber.TwitterText
1895 def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])
1897 def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1899 def get_or_fetch_by_ap_id(ap_id) do
1900 cached_user = get_cached_by_ap_id(ap_id)
1902 maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)
1904 case {cached_user, maybe_fetched_user} do
1905 {_, {:ok, %User{} = user}} ->
1908 {%User{} = user, _} ->
1912 {:error, :not_found}
1917 Creates an internal service actor by URI if missing.
1918 Optionally takes nickname for addressing.
1920 @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1921 def get_or_create_service_actor_by_ap_id(uri, nickname) do
1923 case get_cached_by_ap_id(uri) do
1925 with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1926 Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1930 %User{invisible: false} = user ->
1940 @spec set_invisible(User.t()) :: {:ok, User.t()}
1941 defp set_invisible(user) do
1943 |> change(%{invisible: true})
1944 |> update_and_set_cache()
1947 @spec create_service_actor(String.t(), String.t()) ::
1948 {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1949 defp create_service_actor(uri, nickname) do
1955 follower_address: uri <> "/followers"
1958 |> unique_constraint(:nickname)
1963 def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1966 |> :public_key.pem_decode()
1968 |> :public_key.pem_entry_decode()
1973 def public_key(_), do: {:error, "key not found"}
1975 def get_public_key_for_ap_id(ap_id) do
1976 with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1977 {:ok, public_key} <- public_key(user) do
1984 def ap_enabled?(%User{local: true}), do: true
1985 def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1986 def ap_enabled?(_), do: false
1988 @doc "Gets or fetch a user by uri or nickname."
1989 @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1990 def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1991 def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1993 # wait a period of time and return newest version of the User structs
1994 # this is because we have synchronous follow APIs and need to simulate them
1995 # with an async handshake
1996 def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1997 with %User{} = a <- get_cached_by_id(a.id),
1998 %User{} = b <- get_cached_by_id(b.id) do
2005 def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
2006 with :ok <- :timer.sleep(timeout),
2007 %User{} = a <- get_cached_by_id(a.id),
2008 %User{} = b <- get_cached_by_id(b.id) do
2015 def parse_bio(bio) when is_binary(bio) and bio != "" do
2017 |> CommonUtils.format_input("text/plain", mentions_format: :full)
2021 def parse_bio(_), do: ""
2023 def parse_bio(bio, user) when is_binary(bio) and bio != "" do
2024 # TODO: get profile URLs other than user.ap_id
2025 profile_urls = [user.ap_id]
2028 |> CommonUtils.format_input("text/plain",
2029 mentions_format: :full,
2030 rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
2035 def parse_bio(_, _), do: ""
2037 def tag(user_identifiers, tags) when is_list(user_identifiers) do
2038 Repo.transaction(fn ->
2039 for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
2043 def tag(nickname, tags) when is_binary(nickname),
2044 do: tag(get_by_nickname(nickname), tags)
2046 def tag(%User{} = user, tags),
2047 do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
2049 def untag(user_identifiers, tags) when is_list(user_identifiers) do
2050 Repo.transaction(fn ->
2051 for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
2055 def untag(nickname, tags) when is_binary(nickname),
2056 do: untag(get_by_nickname(nickname), tags)
2058 def untag(%User{} = user, tags),
2059 do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
2061 defp update_tags(%User{} = user, new_tags) do
2062 {:ok, updated_user} =
2064 |> change(%{tags: new_tags})
2065 |> update_and_set_cache()
2070 defp normalize_tags(tags) do
2073 |> Enum.map(&String.downcase/1)
2076 def local_nickname_regex do
2077 if Config.get([:instance, :extended_nickname_format]) do
2078 @extended_local_nickname_regex
2080 @strict_local_nickname_regex
2084 def local_nickname(nickname_or_mention) do
2087 |> String.split("@")
2091 def full_nickname(%User{} = user) do
2092 if String.contains?(user.nickname, "@") do
2095 %{host: host} = URI.parse(user.ap_id)
2096 user.nickname <> "@" <> host
2100 def full_nickname(nickname_or_mention),
2101 do: String.trim_leading(nickname_or_mention, "@")
2103 def error_user(ap_id) do
2107 nickname: "erroruser@example.com",
2108 inserted_at: NaiveDateTime.utc_now()
2112 @spec all_superusers() :: [User.t()]
2113 def all_superusers do
2114 User.Query.build(%{super_users: true, local: true, is_active: true})
2118 def muting_reblogs?(%User{} = user, %User{} = target) do
2119 UserRelationship.reblog_mute_exists?(user, target)
2122 def showing_reblogs?(%User{} = user, %User{} = target) do
2123 not muting_reblogs?(user, target)
2127 The function returns a query to get users with no activity for given interval of days.
2128 Inactive users are those who didn't read any notification, or had any activity where
2129 the user is the activity's actor, during `inactivity_threshold` days.
2130 Deactivated users will not appear in this list.
2134 iex> Pleroma.User.list_inactive_users()
2137 @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
2138 def list_inactive_users_query(inactivity_threshold \\ 7) do
2139 negative_inactivity_threshold = -inactivity_threshold
2140 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2141 # Subqueries are not supported in `where` clauses, join gets too complicated.
2142 has_read_notifications =
2143 from(n in Pleroma.Notification,
2144 where: n.seen == true,
2146 having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
2149 |> Pleroma.Repo.all()
2151 from(u in Pleroma.User,
2152 left_join: a in Pleroma.Activity,
2153 on: u.ap_id == a.actor,
2154 where: not is_nil(u.nickname),
2155 where: u.is_active == ^true,
2156 where: u.id not in ^has_read_notifications,
2159 max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
2160 is_nil(max(a.inserted_at))
2165 Enable or disable email notifications for user
2169 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
2170 Pleroma.User{email_notifications: %{"digest" => true}}
2172 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
2173 Pleroma.User{email_notifications: %{"digest" => false}}
2175 @spec switch_email_notifications(t(), String.t(), boolean()) ::
2176 {:ok, t()} | {:error, Ecto.Changeset.t()}
2177 def switch_email_notifications(user, type, status) do
2178 User.update_email_notifications(user, %{type => status})
2182 Set `last_digest_emailed_at` value for the user to current time
2184 @spec touch_last_digest_emailed_at(t()) :: t()
2185 def touch_last_digest_emailed_at(user) do
2186 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2188 {:ok, updated_user} =
2190 |> change(%{last_digest_emailed_at: now})
2191 |> update_and_set_cache()
2196 @spec set_confirmation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
2197 def set_confirmation(%User{} = user, bool) do
2199 |> confirmation_changeset(set_confirmation: bool)
2200 |> update_and_set_cache()
2203 def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
2207 def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
2208 # use instance-default
2209 config = Config.get([:assets, :mascots])
2210 default_mascot = Config.get([:assets, :default_mascot])
2211 mascot = Keyword.get(config, default_mascot)
2214 "id" => "default-mascot",
2215 "url" => mascot[:url],
2216 "preview_url" => mascot[:url],
2218 "mime_type" => mascot[:mime_type]
2223 def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
2225 def ensure_keys_present(%User{} = user) do
2226 with {:ok, pem} <- Keys.generate_rsa_pem() do
2228 |> cast(%{keys: pem}, [:keys])
2229 |> validate_required([:keys])
2230 |> update_and_set_cache()
2234 def get_ap_ids_by_nicknames(nicknames) do
2236 where: u.nickname in ^nicknames,
2242 defp put_password_hash(
2243 %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2245 change(changeset, password_hash: Pleroma.Password.Pbkdf2.hash_pwd_salt(password))
2248 defp put_password_hash(changeset), do: changeset
2250 def is_internal_user?(%User{nickname: nil}), do: true
2251 def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2252 def is_internal_user?(_), do: false
2254 # A hack because user delete activities have a fake id for whatever reason
2255 # TODO: Get rid of this
2256 def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2258 def get_delivered_users_by_object_id(object_id) do
2260 inner_join: delivery in assoc(u, :deliveries),
2261 where: delivery.object_id == ^object_id
2266 def change_email(user, email) do
2268 |> cast(%{email: email}, [:email])
2269 |> maybe_validate_required_email(false)
2270 |> unique_constraint(:email)
2271 |> validate_format(:email, @email_regex)
2272 |> update_and_set_cache()
2275 def alias_users(user) do
2277 |> Enum.map(&User.get_cached_by_ap_id/1)
2278 |> Enum.filter(fn user -> user != nil end)
2281 def add_alias(user, new_alias_user) do
2282 current_aliases = user.also_known_as || []
2283 new_alias_ap_id = new_alias_user.ap_id
2285 if new_alias_ap_id in current_aliases do
2289 |> cast(%{also_known_as: current_aliases ++ [new_alias_ap_id]}, [:also_known_as])
2290 |> update_and_set_cache()
2294 def delete_alias(user, alias_user) do
2295 current_aliases = user.also_known_as || []
2296 alias_ap_id = alias_user.ap_id
2298 if alias_ap_id in current_aliases do
2300 |> cast(%{also_known_as: current_aliases -- [alias_ap_id]}, [:also_known_as])
2301 |> update_and_set_cache()
2303 {:error, :no_such_alias}
2307 # Internal function; public one is `deactivate/2`
2308 defp set_activation_status(user, status) do
2310 |> cast(%{is_active: status}, [:is_active])
2311 |> update_and_set_cache()
2314 def update_banner(user, banner) do
2316 |> cast(%{banner: banner}, [:banner])
2317 |> update_and_set_cache()
2320 def update_background(user, background) do
2322 |> cast(%{background: background}, [:background])
2323 |> update_and_set_cache()
2326 def validate_fields(changeset, remote? \\ false) do
2327 limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2328 limit = Config.get([:instance, limit_name], 0)
2331 |> validate_length(:fields, max: limit)
2332 |> validate_change(:fields, fn :fields, fields ->
2333 if Enum.all?(fields, &valid_field?/1) do
2341 defp valid_field?(%{"name" => name, "value" => value}) do
2342 name_limit = Config.get([:instance, :account_field_name_length], 255)
2343 value_limit = Config.get([:instance, :account_field_value_length], 255)
2345 is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2346 String.length(value) <= value_limit
2349 defp valid_field?(_), do: false
2351 defp truncate_field(%{"name" => name, "value" => value}) do
2353 String.split_at(name, Config.get([:instance, :account_field_name_length], 255))
2356 String.split_at(value, Config.get([:instance, :account_field_value_length], 255))
2358 %{"name" => name, "value" => value}
2361 def admin_api_update(user, params) do
2368 |> update_and_set_cache()
2371 @doc "Signs user out of all applications"
2372 def global_sign_out(user) do
2373 OAuth.Authorization.delete_user_authorizations(user)
2374 OAuth.Token.delete_user_tokens(user)
2377 def mascot_update(user, url) do
2379 |> cast(%{mascot: url}, [:mascot])
2380 |> validate_required([:mascot])
2381 |> update_and_set_cache()
2384 def mastodon_settings_update(user, settings) do
2386 |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
2387 |> validate_required([:mastofe_settings])
2388 |> update_and_set_cache()
2391 @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2392 def confirmation_changeset(user, set_confirmation: confirmed?) do
2397 confirmation_token: nil
2401 is_confirmed: false,
2402 confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2406 cast(user, params, [:is_confirmed, :confirmation_token])
2409 @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
2410 def approval_changeset(user, set_approval: approved?) do
2411 cast(user, %{is_approved: approved?}, [:is_approved])
2414 @spec add_pinned_object_id(User.t(), String.t()) :: {:ok, User.t()} | {:error, term()}
2415 def add_pinned_object_id(%User{} = user, object_id) do
2416 if !user.pinned_objects[object_id] do
2417 params = %{pinned_objects: Map.put(user.pinned_objects, object_id, NaiveDateTime.utc_now())}
2420 |> cast(params, [:pinned_objects])
2421 |> validate_change(:pinned_objects, fn :pinned_objects, pinned_objects ->
2422 max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2424 if Enum.count(pinned_objects) <= max_pinned_statuses do
2427 [pinned_objects: "You have already pinned the maximum number of statuses"]
2433 |> update_and_set_cache()
2436 @spec remove_pinned_object_id(User.t(), String.t()) :: {:ok, t()} | {:error, term()}
2437 def remove_pinned_object_id(%User{} = user, object_id) do
2440 %{pinned_objects: Map.delete(user.pinned_objects, object_id)},
2443 |> update_and_set_cache()
2446 def update_email_notifications(user, settings) do
2447 email_notifications =
2448 user.email_notifications
2449 |> Map.merge(settings)
2450 |> Map.take(["digest"])
2452 params = %{email_notifications: email_notifications}
2453 fields = [:email_notifications]
2456 |> cast(params, fields)
2457 |> validate_required(fields)
2458 |> update_and_set_cache()
2461 defp set_domain_blocks(user, domain_blocks) do
2462 params = %{domain_blocks: domain_blocks}
2465 |> cast(params, [:domain_blocks])
2466 |> validate_required([:domain_blocks])
2467 |> update_and_set_cache()
2470 def block_domain(user, domain_blocked) do
2471 set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2474 def unblock_domain(user, domain_blocked) do
2475 set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2478 @spec add_to_block(User.t(), User.t()) ::
2479 {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2480 defp add_to_block(%User{} = user, %User{} = blocked) do
2481 with {:ok, relationship} <- UserRelationship.create_block(user, blocked) do
2482 @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
2487 @spec add_to_block(User.t(), User.t()) ::
2488 {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2489 defp remove_from_block(%User{} = user, %User{} = blocked) do
2490 with {:ok, relationship} <- UserRelationship.delete_block(user, blocked) do
2491 @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
2496 def set_invisible(user, invisible) do
2497 params = %{invisible: invisible}
2500 |> cast(params, [:invisible])
2501 |> validate_required([:invisible])
2502 |> update_and_set_cache()
2505 def sanitize_html(%User{} = user) do
2506 sanitize_html(user, nil)
2509 # User data that mastodon isn't filtering (treated as plaintext):
2512 def sanitize_html(%User{} = user, filter) do
2514 Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2517 "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2522 |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2523 |> Map.put(:fields, fields)
2526 def get_host(%User{ap_id: ap_id} = _user) do
2527 URI.parse(ap_id).host
2530 def update_last_active_at(%__MODULE__{local: true} = user) do
2532 |> cast(%{last_active_at: NaiveDateTime.utc_now()}, [:last_active_at])
2533 |> update_and_set_cache()
2536 def active_user_count(days \\ 30) do
2537 active_after = Timex.shift(NaiveDateTime.utc_now(), days: -days)
2540 |> where([u], u.last_active_at >= ^active_after)
2541 |> where([u], u.local == true)
2542 |> Repo.aggregate(:count)
2545 def update_last_status_at(user) do
2547 |> where(id: ^user.id)
2548 |> update([u], set: [last_status_at: fragment("NOW()")])
2550 |> Repo.update_all([])
2552 {1, [user]} -> set_cache(user)