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 has_many(:frontend_profiles, Pleroma.Akkoma.FrontendSettingsProfile)
170 for {relationship_type,
172 {outgoing_relation, outgoing_relation_target},
173 {incoming_relation, incoming_relation_source}
174 ]} <- @user_relationships_config do
175 # Definitions of `has_many` relations: :blocker_blocks, :muter_mutes, :reblog_muter_mutes,
176 # :notification_muter_mutes, :subscribee_subscriptions
177 has_many(outgoing_relation, UserRelationship,
178 foreign_key: :source_id,
179 where: [relationship_type: relationship_type]
182 # Definitions of `has_many` relations: :blockee_blocks, :mutee_mutes, :reblog_mutee_mutes,
183 # :notification_mutee_mutes, :subscriber_subscriptions
184 has_many(incoming_relation, UserRelationship,
185 foreign_key: :target_id,
186 where: [relationship_type: relationship_type]
189 # Definitions of `has_many` relations: :blocked_users, :muted_users, :reblog_muted_users,
190 # :notification_muted_users, :subscriber_users
191 has_many(outgoing_relation_target, through: [outgoing_relation, :target])
193 # Definitions of `has_many` relations: :blocker_users, :muter_users, :reblog_muter_users,
194 # :notification_muter_users, :subscribee_users
195 has_many(incoming_relation_source, through: [incoming_relation, :source])
199 :multi_factor_authentication_settings,
207 for {_relationship_type, [{_outgoing_relation, outgoing_relation_target}, _]} <-
208 @user_relationships_config do
209 # `def blocked_users_relation/2`, `def muted_users_relation/2`,
210 # `def reblog_muted_users_relation/2`, `def notification_muted_users/2`,
211 # `def subscriber_users/2`
212 def unquote(:"#{outgoing_relation_target}_relation")(user, restrict_deactivated? \\ false) do
213 target_users_query = assoc(user, unquote(outgoing_relation_target))
215 if restrict_deactivated? do
217 |> User.Query.build(%{deactivated: false})
223 # `def blocked_users/2`, `def muted_users/2`, `def reblog_muted_users/2`,
224 # `def notification_muted_users/2`, `def subscriber_users/2`
225 def unquote(outgoing_relation_target)(user, restrict_deactivated? \\ false) do
227 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
229 restrict_deactivated?
234 # `def blocked_users_ap_ids/2`, `def muted_users_ap_ids/2`, `def reblog_muted_users_ap_ids/2`,
235 # `def notification_muted_users_ap_ids/2`, `def subscriber_users_ap_ids/2`
236 def unquote(:"#{outgoing_relation_target}_ap_ids")(user, restrict_deactivated? \\ false) do
238 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
240 restrict_deactivated?
242 |> select([u], u.ap_id)
247 def cached_blocked_users_ap_ids(user) do
248 @cachex.fetch!(:user_cache, "blocked_users_ap_ids:#{user.ap_id}", fn _ ->
249 blocked_users_ap_ids(user)
253 def cached_muted_users_ap_ids(user) do
254 @cachex.fetch!(:user_cache, "muted_users_ap_ids:#{user.ap_id}", fn _ ->
255 muted_users_ap_ids(user)
259 defdelegate following_count(user), to: FollowingRelationship
260 defdelegate following(user), to: FollowingRelationship
261 defdelegate following?(follower, followed), to: FollowingRelationship
262 defdelegate following_ap_ids(user), to: FollowingRelationship
263 defdelegate get_follow_requests(user), to: FollowingRelationship
264 defdelegate search(query, opts \\ []), to: User.Search
267 Dumps Flake Id to SQL-compatible format (16-byte UUID).
268 E.g. "9pQtDGXuq4p3VlcJEm" -> <<0, 0, 1, 110, 179, 218, 42, 92, 213, 41, 44, 227, 95, 213, 0, 0>>
270 def binary_id(source_id) when is_binary(source_id) do
271 with {:ok, dumped_id} <- FlakeId.Ecto.CompatType.dump(source_id) do
278 def binary_id(source_ids) when is_list(source_ids) do
279 Enum.map(source_ids, &binary_id/1)
282 def binary_id(%User{} = user), do: binary_id(user.id)
284 @doc "Returns status account"
285 @spec account_status(User.t()) :: account_status()
286 def account_status(%User{is_active: false}), do: :deactivated
287 def account_status(%User{password_reset_pending: true}), do: :password_reset_pending
288 def account_status(%User{local: true, is_approved: false}), do: :approval_pending
289 def account_status(%User{local: true, is_confirmed: false}), do: :confirmation_pending
290 def account_status(%User{}), do: :active
292 @spec visible_for(User.t(), User.t() | nil) ::
295 | :restricted_unauthenticated
297 | :confirmation_pending
298 def visible_for(user, for_user \\ nil)
300 def visible_for(%User{invisible: true}, _), do: :invisible
302 def visible_for(%User{id: user_id}, %User{id: user_id}), do: :visible
304 def visible_for(%User{} = user, nil) do
305 if restrict_unauthenticated?(user) do
306 :restrict_unauthenticated
308 visible_account_status(user)
312 def visible_for(%User{} = user, for_user) do
313 if superuser?(for_user) do
316 visible_account_status(user)
320 def visible_for(_, _), do: :invisible
322 defp restrict_unauthenticated?(%User{local: true}) do
323 Config.restrict_unauthenticated_access?(:profiles, :local)
326 defp restrict_unauthenticated?(%User{local: _}) do
327 Config.restrict_unauthenticated_access?(:profiles, :remote)
330 defp visible_account_status(user) do
331 status = account_status(user)
333 if status in [:active, :password_reset_pending] do
340 @spec superuser?(User.t()) :: boolean()
341 def superuser?(%User{local: true, is_admin: true}), do: true
342 def superuser?(%User{local: true, is_moderator: true}), do: true
343 def superuser?(_), do: false
345 @spec invisible?(User.t()) :: boolean()
346 def invisible?(%User{invisible: true}), do: true
347 def invisible?(_), do: false
349 def avatar_url(user, options \\ []) do
351 %{"url" => [%{"href" => href} | _]} ->
355 unless options[:no_default] do
356 Config.get([:assets, :default_user_avatar], "#{Endpoint.url()}/images/avi.png")
361 def banner_url(user, options \\ []) do
363 %{"url" => [%{"href" => href} | _]} -> href
364 _ -> !options[:no_default] && "#{Endpoint.url()}/images/banner.png"
368 # Should probably be renamed or removed
369 @spec ap_id(User.t()) :: String.t()
370 def ap_id(%User{nickname: nickname}), do: "#{Endpoint.url()}/users/#{nickname}"
372 @spec ap_followers(User.t()) :: String.t()
373 def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
374 def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"
376 @spec ap_following(User.t()) :: String.t()
377 def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
378 def ap_following(%User{} = user), do: "#{ap_id(user)}/following"
380 @spec ap_featured_collection(User.t()) :: String.t()
381 def ap_featured_collection(%User{featured_address: fa}) when is_binary(fa), do: fa
383 def ap_featured_collection(%User{} = user), do: "#{ap_id(user)}/collections/featured"
385 defp truncate_fields_param(params) do
386 if Map.has_key?(params, :fields) do
387 Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
393 defp truncate_if_exists(params, key, max_length) do
394 if Map.has_key?(params, key) and is_binary(params[key]) do
395 {value, _chopped} = String.split_at(params[key], max_length)
396 Map.put(params, key, value)
402 defp fix_follower_address(%{follower_address: _, following_address: _} = params), do: params
404 defp fix_follower_address(%{nickname: nickname} = params),
405 do: Map.put(params, :follower_address, ap_followers(%User{nickname: nickname}))
407 defp fix_follower_address(params), do: params
409 def remote_user_changeset(struct \\ %User{local: false}, params) do
410 bio_limit = Config.get([:instance, :user_bio_length], 5000)
411 name_limit = Config.get([:instance, :user_name_length], 100)
414 case params[:name] do
415 name when is_binary(name) and byte_size(name) > 0 -> name
416 _ -> params[:nickname]
421 |> Map.put(:name, name)
422 |> Map.put_new(:last_refreshed_at, NaiveDateTime.utc_now())
423 |> truncate_if_exists(:name, name_limit)
424 |> truncate_if_exists(:bio, bio_limit)
425 |> truncate_fields_param()
426 |> fix_follower_address()
450 :hide_followers_count,
462 |> cast(params, [:name], empty_values: [])
463 |> validate_required([:ap_id])
464 |> validate_required([:name], trim: false)
465 |> unique_constraint(:nickname)
466 |> validate_format(:nickname, @email_regex)
467 |> validate_length(:bio, max: bio_limit)
468 |> validate_length(:name, max: name_limit)
469 |> validate_fields(true)
470 |> validate_non_local()
473 defp validate_non_local(cng) do
474 local? = get_field(cng, :local)
478 |> add_error(:local, "User is local, can't update with this changeset.")
484 def update_changeset(struct, params \\ %{}) do
485 bio_limit = Config.get([:instance, :user_bio_length], 5000)
486 name_limit = Config.get([:instance, :user_name_length], 100)
506 :hide_followers_count,
509 :allow_following_move,
513 :skip_thread_containment,
516 :pleroma_settings_store,
522 |> unique_constraint(:nickname)
523 |> validate_format(:nickname, local_nickname_regex())
524 |> validate_length(:bio, max: bio_limit)
525 |> validate_length(:name, min: 1, max: name_limit)
526 |> validate_inclusion(:actor_type, ["Person", "Service"])
529 |> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
530 |> put_change_if_present(:avatar, &put_upload(&1, :avatar))
531 |> put_change_if_present(:banner, &put_upload(&1, :banner))
532 |> put_change_if_present(:background, &put_upload(&1, :background))
533 |> put_change_if_present(
534 :pleroma_settings_store,
535 &{:ok, Map.merge(struct.pleroma_settings_store, &1)}
537 |> validate_fields(false)
540 defp put_fields(changeset) do
541 if raw_fields = get_change(changeset, :raw_fields) do
544 |> Enum.filter(fn %{"name" => n} -> n != "" end)
548 |> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)
551 |> put_change(:raw_fields, raw_fields)
552 |> put_change(:fields, fields)
558 defp parse_fields(value) do
560 |> Formatter.linkify(mentions_format: :full)
564 defp put_emoji(changeset) do
565 emojified_fields = [:bio, :name, :raw_fields]
567 if Enum.any?(changeset.changes, fn {k, _} -> k in emojified_fields end) do
568 bio = Emoji.Formatter.get_emoji_map(get_field(changeset, :bio))
569 name = Emoji.Formatter.get_emoji_map(get_field(changeset, :name))
571 emoji = Map.merge(bio, name)
575 |> get_field(:raw_fields)
576 |> Enum.reduce(emoji, fn x, acc ->
577 Map.merge(acc, Emoji.Formatter.get_emoji_map(x["name"] <> x["value"]))
580 put_change(changeset, :emoji, emoji)
586 defp put_change_if_present(changeset, map_field, value_function) do
587 with {:ok, value} <- fetch_change(changeset, map_field),
588 {:ok, new_value} <- value_function.(value) do
589 put_change(changeset, map_field, new_value)
595 defp put_upload(value, type) do
596 with %Plug.Upload{} <- value,
597 {:ok, object} <- ActivityPub.upload(value, type: type) do
602 def update_as_admin_changeset(struct, params) do
604 |> update_changeset(params)
605 |> cast(params, [:email])
606 |> delete_change(:also_known_as)
607 |> unique_constraint(:email)
608 |> validate_format(:email, @email_regex)
609 |> validate_inclusion(:actor_type, ["Person", "Service"])
612 @spec update_as_admin(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
613 def update_as_admin(user, params) do
614 params = Map.put(params, "password_confirmation", params["password"])
615 changeset = update_as_admin_changeset(user, params)
617 if params["password"] do
618 reset_password(user, changeset, params)
620 User.update_and_set_cache(changeset)
624 def password_update_changeset(struct, params) do
626 |> cast(params, [:password, :password_confirmation])
627 |> validate_required([:password, :password_confirmation])
628 |> validate_confirmation(:password)
629 |> put_password_hash()
630 |> put_change(:password_reset_pending, false)
633 @spec reset_password(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
634 def reset_password(%User{} = user, params) do
635 reset_password(user, user, params)
638 def reset_password(%User{id: user_id} = user, struct, params) do
641 |> Multi.update(:user, password_update_changeset(struct, params))
642 |> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
643 |> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))
645 case Repo.transaction(multi) do
646 {:ok, %{user: user} = _} -> set_cache(user)
647 {:error, _, changeset, _} -> {:error, changeset}
651 def update_password_reset_pending(user, value) do
654 |> put_change(:password_reset_pending, value)
655 |> update_and_set_cache()
658 def force_password_reset_async(user) do
659 BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
662 @spec force_password_reset(User.t()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
663 def force_password_reset(user), do: update_password_reset_pending(user, true)
665 # Used to auto-register LDAP accounts which won't have a password hash stored locally
666 def register_changeset_ldap(struct, params = %{password: password})
667 when is_nil(password) do
669 if Map.has_key?(params, :email) do
670 Map.put_new(params, :email, params[:email])
681 |> validate_required([:name, :nickname])
682 |> unique_constraint(:nickname)
683 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
684 |> validate_format(:nickname, local_nickname_regex())
686 |> unique_constraint(:ap_id)
687 |> put_following_and_follower_and_featured_address()
691 def register_changeset(struct, params \\ %{}, opts \\ []) do
692 bio_limit = Config.get([:instance, :user_bio_length], 5000)
693 name_limit = Config.get([:instance, :user_name_length], 100)
694 reason_limit = Config.get([:instance, :registration_reason_length], 500)
697 if is_nil(opts[:confirmed]) do
698 !Config.get([:instance, :account_activation_required])
704 if is_nil(opts[:approved]) do
705 !Config.get([:instance, :account_approval_required])
711 |> confirmation_changeset(set_confirmation: confirmed?)
712 |> approval_changeset(set_approval: approved?)
720 :password_confirmation,
722 :registration_reason,
725 |> validate_required([:name, :nickname, :password, :password_confirmation])
726 |> validate_confirmation(:password)
727 |> unique_constraint(:email)
728 |> validate_format(:email, @email_regex)
729 |> validate_change(:email, fn :email, email ->
731 Config.get([User, :email_blacklist])
732 |> Enum.all?(fn blacklisted_domain ->
733 !String.ends_with?(email, ["@" <> blacklisted_domain, "." <> blacklisted_domain])
736 if valid?, do: [], else: [email: "Invalid email"]
738 |> unique_constraint(:nickname)
739 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
740 |> validate_format(:nickname, local_nickname_regex())
741 |> validate_length(:bio, max: bio_limit)
742 |> validate_length(:name, min: 1, max: name_limit)
743 |> validate_length(:registration_reason, max: reason_limit)
744 |> maybe_validate_required_email(opts[:external])
747 |> unique_constraint(:ap_id)
748 |> put_following_and_follower_and_featured_address()
752 def maybe_validate_required_email(changeset, true), do: changeset
754 def maybe_validate_required_email(changeset, _) do
755 if Config.get([:instance, :account_activation_required]) do
756 validate_required(changeset, [:email])
762 def put_ap_id(changeset) do
763 ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
764 put_change(changeset, :ap_id, ap_id)
767 def put_following_and_follower_and_featured_address(changeset) do
768 user = %User{nickname: get_field(changeset, :nickname)}
769 followers = ap_followers(user)
770 following = ap_following(user)
771 featured = ap_featured_collection(user)
774 |> put_change(:follower_address, followers)
775 |> put_change(:following_address, following)
776 |> put_change(:featured_address, featured)
779 defp put_private_key(changeset) do
780 {:ok, pem} = Keys.generate_rsa_pem()
781 put_change(changeset, :keys, pem)
784 defp autofollow_users(user) do
785 candidates = Config.get([:instance, :autofollowed_nicknames])
788 User.Query.build(%{nickname: candidates, local: true, is_active: true})
791 follow_all(user, autofollowed_users)
794 defp autofollowing_users(user) do
795 candidates = Config.get([:instance, :autofollowing_nicknames])
797 User.Query.build(%{nickname: candidates, local: true, deactivated: false})
799 |> Enum.each(&follow(&1, user, :follow_accept))
804 @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
805 def register(%Ecto.Changeset{} = changeset) do
806 with {:ok, user} <- Repo.insert(changeset) do
807 post_register_action(user)
811 def post_register_action(%User{is_confirmed: false} = user) do
812 with {:ok, _} <- maybe_send_confirmation_email(user) do
817 def post_register_action(%User{is_approved: false} = user) do
818 with {:ok, _} <- send_user_approval_email(user),
819 {:ok, _} <- send_admin_approval_emails(user) do
824 def post_register_action(%User{is_approved: true, is_confirmed: true} = user) do
825 with {:ok, user} <- autofollow_users(user),
826 {:ok, _} <- autofollowing_users(user),
827 {:ok, user} <- set_cache(user),
828 {:ok, _} <- maybe_send_registration_email(user),
829 {:ok, _} <- maybe_send_welcome_email(user),
830 {:ok, _} <- maybe_send_welcome_message(user) do
835 defp send_user_approval_email(user) do
837 |> Pleroma.Emails.UserEmail.approval_pending_email()
838 |> Pleroma.Emails.Mailer.deliver_async()
843 defp send_admin_approval_emails(user) do
845 |> Enum.filter(fn user -> not is_nil(user.email) end)
846 |> Enum.each(fn superuser ->
848 |> Pleroma.Emails.AdminEmail.new_unapproved_registration(user)
849 |> Pleroma.Emails.Mailer.deliver_async()
855 defp maybe_send_welcome_message(user) do
856 if User.WelcomeMessage.enabled?() do
857 User.WelcomeMessage.post_message(user)
864 defp maybe_send_welcome_email(%User{email: email} = user) when is_binary(email) do
865 if User.WelcomeEmail.enabled?() do
866 User.WelcomeEmail.send_email(user)
873 defp maybe_send_welcome_email(_), do: {:ok, :noop}
875 @spec maybe_send_confirmation_email(User.t()) :: {:ok, :enqueued | :noop}
876 def maybe_send_confirmation_email(%User{is_confirmed: false, email: email} = user)
877 when is_binary(email) do
878 if Config.get([:instance, :account_activation_required]) do
879 send_confirmation_email(user)
886 def maybe_send_confirmation_email(_), do: {:ok, :noop}
888 @spec send_confirmation_email(Uset.t()) :: User.t()
889 def send_confirmation_email(%User{} = user) do
891 |> Pleroma.Emails.UserEmail.account_confirmation_email()
892 |> Pleroma.Emails.Mailer.deliver_async()
897 @spec maybe_send_registration_email(User.t()) :: {:ok, :enqueued | :noop}
898 defp maybe_send_registration_email(%User{email: email} = user) when is_binary(email) do
899 with false <- User.WelcomeEmail.enabled?(),
900 false <- Config.get([:instance, :account_activation_required], false),
901 false <- Config.get([:instance, :account_approval_required], false) do
903 |> Pleroma.Emails.UserEmail.successful_registration_email()
904 |> Pleroma.Emails.Mailer.deliver_async()
913 defp maybe_send_registration_email(_), do: {:ok, :noop}
915 def needs_update?(%User{local: true}), do: false
917 def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
919 def needs_update?(%User{local: false} = user) do
920 NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
923 def needs_update?(_), do: true
925 @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
927 # "Locked" (self-locked) users demand explicit authorization of follow requests
928 def maybe_direct_follow(%User{} = follower, %User{local: true, is_locked: true} = followed) do
929 follow(follower, followed, :follow_pending)
932 def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
933 follow(follower, followed)
936 def maybe_direct_follow(%User{} = follower, %User{} = followed) do
937 if not ap_enabled?(followed) do
938 follow(follower, followed)
940 {:ok, follower, followed}
944 @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
945 @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
946 def follow_all(follower, followeds) do
948 |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
949 |> Enum.each(&follow(follower, &1, :follow_accept))
954 def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
955 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
958 not followed.is_active ->
959 {:error, "Could not follow user: #{followed.nickname} is deactivated."}
961 deny_follow_blocked and blocks?(followed, follower) ->
962 {:error, "Could not follow user: #{followed.nickname} blocked you."}
965 FollowingRelationship.follow(follower, followed, state)
969 def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
970 {:error, "Not subscribed!"}
973 @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
974 def unfollow(%User{} = follower, %User{} = followed) do
975 case do_unfollow(follower, followed) do
976 {:ok, follower, followed} ->
977 {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
984 @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
985 defp do_unfollow(%User{} = follower, %User{} = followed) do
986 case get_follow_state(follower, followed) do
987 state when state in [:follow_pending, :follow_accept] ->
988 FollowingRelationship.unfollow(follower, followed)
991 {:error, "Not subscribed!"}
995 @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
996 def get_follow_state(%User{} = follower, %User{} = following) do
997 following_relationship = FollowingRelationship.get(follower, following)
998 get_follow_state(follower, following, following_relationship)
1001 def get_follow_state(
1003 %User{} = following,
1004 following_relationship
1006 case {following_relationship, following.local} do
1008 case Utils.fetch_latest_follow(follower, following) do
1009 %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
1010 FollowingRelationship.state_to_enum(state)
1016 {%{state: state}, _} ->
1024 def locked?(%User{} = user) do
1025 user.is_locked || false
1028 def get_by_id(id) do
1029 Repo.get_by(User, id: id)
1032 def get_by_ap_id(ap_id) do
1033 Repo.get_by(User, ap_id: ap_id)
1036 def get_all_by_ap_id(ap_ids) do
1037 from(u in __MODULE__,
1038 where: u.ap_id in ^ap_ids
1043 def get_all_by_ids(ids) do
1044 from(u in __MODULE__, where: u.id in ^ids)
1048 # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
1049 # of the ap_id and the domain and tries to get that user
1050 def get_by_guessed_nickname(ap_id) do
1051 domain = URI.parse(ap_id).host
1052 name = List.last(String.split(ap_id, "/"))
1053 nickname = "#{name}@#{domain}"
1055 get_cached_by_nickname(nickname)
1058 def set_cache({:ok, user}), do: set_cache(user)
1059 def set_cache({:error, err}), do: {:error, err}
1061 def set_cache(%User{} = user) do
1062 @cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1063 @cachex.put(:user_cache, "nickname:#{user.nickname}", user)
1064 @cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
1068 def update_and_set_cache(struct, params) do
1070 |> update_changeset(params)
1071 |> update_and_set_cache()
1074 def update_and_set_cache(%{data: %Pleroma.User{} = user} = changeset) do
1075 was_superuser_before_update = User.superuser?(user)
1077 with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
1080 |> maybe_remove_report_notifications(was_superuser_before_update)
1083 defp maybe_remove_report_notifications({:ok, %Pleroma.User{} = user} = result, true) do
1084 if not User.superuser?(user),
1085 do: user |> Notification.destroy_multiple_from_types(["pleroma:report"])
1090 defp maybe_remove_report_notifications(result, _) do
1094 def get_user_friends_ap_ids(user) do
1095 from(u in User.get_friends_query(user), select: u.ap_id)
1099 @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
1100 def get_cached_user_friends_ap_ids(user) do
1101 @cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
1102 get_user_friends_ap_ids(user)
1106 def invalidate_cache(user) do
1107 @cachex.del(:user_cache, "ap_id:#{user.ap_id}")
1108 @cachex.del(:user_cache, "nickname:#{user.nickname}")
1109 @cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
1110 @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
1111 @cachex.del(:user_cache, "muted_users_ap_ids:#{user.ap_id}")
1114 @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
1115 def get_cached_by_ap_id(ap_id) do
1116 key = "ap_id:#{ap_id}"
1118 with {:ok, nil} <- @cachex.get(:user_cache, key),
1119 user when not is_nil(user) <- get_by_ap_id(ap_id),
1120 {:ok, true} <- @cachex.put(:user_cache, key, user) do
1128 def get_cached_by_id(id) do
1132 @cachex.fetch!(:user_cache, key, fn _ ->
1133 user = get_by_id(id)
1136 @cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1137 {:commit, user.ap_id}
1143 get_cached_by_ap_id(ap_id)
1146 def get_cached_by_nickname(nickname) do
1147 key = "nickname:#{nickname}"
1149 @cachex.fetch!(:user_cache, key, fn _ ->
1150 case get_or_fetch_by_nickname(nickname) do
1151 {:ok, user} -> {:commit, user}
1152 {:error, _error} -> {:ignore, nil}
1157 def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
1158 restrict_to_local = Config.get([:instance, :limit_to_local_content])
1161 is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
1162 get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
1164 restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
1165 get_cached_by_nickname(nickname_or_id)
1167 restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
1168 get_cached_by_nickname(nickname_or_id)
1175 @spec get_by_nickname(String.t()) :: User.t() | nil
1176 def get_by_nickname(nickname) do
1177 Repo.get_by(User, nickname: nickname) ||
1178 if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
1179 Repo.get_by(User, nickname: local_nickname(nickname))
1183 def get_by_email(email), do: Repo.get_by(User, email: email)
1185 def get_by_nickname_or_email(nickname_or_email) do
1186 get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
1189 def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
1191 def get_or_fetch_by_nickname(nickname) do
1192 with %User{} = user <- get_by_nickname(nickname) do
1196 with [_nick, _domain] <- String.split(nickname, "@"),
1197 {:ok, user} <- fetch_by_nickname(nickname) do
1200 _e -> {:error, "not found " <> nickname}
1205 @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1206 def get_followers_query(%User{} = user, nil) do
1207 User.Query.build(%{followers: user, is_active: true})
1210 def get_followers_query(%User{} = user, page) do
1212 |> get_followers_query(nil)
1213 |> User.Query.paginate(page, 20)
1216 @spec get_followers_query(User.t()) :: Ecto.Query.t()
1217 def get_followers_query(%User{} = user), do: get_followers_query(user, nil)
1219 @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1220 def get_followers(%User{} = user, page \\ nil) do
1222 |> get_followers_query(page)
1226 @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1227 def get_external_followers(%User{} = user, page \\ nil) do
1229 |> get_followers_query(page)
1230 |> User.Query.build(%{external: true})
1234 def get_followers_ids(%User{} = user, page \\ nil) do
1236 |> get_followers_query(page)
1237 |> select([u], u.id)
1241 @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1242 def get_friends_query(%User{} = user, nil) do
1243 User.Query.build(%{friends: user, deactivated: false})
1246 def get_friends_query(%User{} = user, page) do
1248 |> get_friends_query(nil)
1249 |> User.Query.paginate(page, 20)
1252 @spec get_friends_query(User.t()) :: Ecto.Query.t()
1253 def get_friends_query(%User{} = user), do: get_friends_query(user, nil)
1255 def get_friends(%User{} = user, page \\ nil) do
1257 |> get_friends_query(page)
1261 def get_friends_ap_ids(%User{} = user) do
1263 |> get_friends_query(nil)
1264 |> select([u], u.ap_id)
1268 def get_friends_ids(%User{} = user, page \\ nil) do
1270 |> get_friends_query(page)
1271 |> select([u], u.id)
1275 def increase_note_count(%User{} = user) do
1277 |> where(id: ^user.id)
1278 |> update([u], inc: [note_count: 1])
1280 |> Repo.update_all([])
1282 {1, [user]} -> set_cache(user)
1287 def decrease_note_count(%User{} = user) do
1289 |> where(id: ^user.id)
1292 note_count: fragment("greatest(0, note_count - 1)")
1296 |> Repo.update_all([])
1298 {1, [user]} -> set_cache(user)
1303 def update_note_count(%User{} = user, note_count \\ nil) do
1308 where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1314 |> cast(%{note_count: note_count}, [:note_count])
1315 |> update_and_set_cache()
1318 @spec maybe_fetch_follow_information(User.t()) :: User.t()
1319 def maybe_fetch_follow_information(user) do
1320 with {:ok, user} <- fetch_follow_information(user) do
1324 Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1330 def fetch_follow_information(user) do
1331 with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1333 |> follow_information_changeset(info)
1334 |> update_and_set_cache()
1338 defp follow_information_changeset(user, params) do
1345 :hide_followers_count,
1350 @spec update_follower_count(User.t()) :: {:ok, User.t()}
1351 def update_follower_count(%User{} = user) do
1352 if user.local or !Config.get([:instance, :external_user_synchronization]) do
1353 follower_count = FollowingRelationship.follower_count(user)
1356 |> follow_information_changeset(%{follower_count: follower_count})
1357 |> update_and_set_cache
1359 {:ok, maybe_fetch_follow_information(user)}
1363 @spec update_following_count(User.t()) :: {:ok, User.t()}
1364 def update_following_count(%User{local: false} = user) do
1365 if Config.get([:instance, :external_user_synchronization]) do
1366 {:ok, maybe_fetch_follow_information(user)}
1372 def update_following_count(%User{local: true} = user) do
1373 following_count = FollowingRelationship.following_count(user)
1376 |> follow_information_changeset(%{following_count: following_count})
1377 |> update_and_set_cache()
1380 @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1381 def get_users_from_set(ap_ids, opts \\ []) do
1382 local_only = Keyword.get(opts, :local_only, true)
1383 criteria = %{ap_id: ap_ids, is_active: true}
1384 criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1386 User.Query.build(criteria)
1390 @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1391 def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1394 query = User.Query.build(%{recipients_from_activity: to, local: true, is_active: true})
1400 @spec mute(User.t(), User.t(), map()) ::
1401 {:ok, list(UserRelationship.t())} | {:error, String.t()}
1402 def mute(%User{} = muter, %User{} = mutee, params \\ %{}) do
1403 notifications? = Map.get(params, :notifications, true)
1404 expires_in = Map.get(params, :expires_in, 0)
1406 with {:ok, user_mute} <- UserRelationship.create_mute(muter, mutee),
1407 {:ok, user_notification_mute} <-
1408 (notifications? && UserRelationship.create_notification_mute(muter, mutee)) ||
1410 if expires_in > 0 do
1411 Pleroma.Workers.MuteExpireWorker.enqueue(
1413 %{"muter_id" => muter.id, "mutee_id" => mutee.id},
1414 schedule_in: expires_in
1418 @cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
1420 {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
1424 def unmute(%User{} = muter, %User{} = mutee) do
1425 with {:ok, user_mute} <- UserRelationship.delete_mute(muter, mutee),
1426 {:ok, user_notification_mute} <-
1427 UserRelationship.delete_notification_mute(muter, mutee) do
1428 @cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
1429 {:ok, [user_mute, user_notification_mute]}
1433 def unmute(muter_id, mutee_id) do
1434 with {:muter, %User{} = muter} <- {:muter, User.get_by_id(muter_id)},
1435 {:mutee, %User{} = mutee} <- {:mutee, User.get_by_id(mutee_id)} do
1436 unmute(muter, mutee)
1438 {who, result} = error ->
1440 "User.unmute/2 failed. #{who}: #{result}, muter_id: #{muter_id}, mutee_id: #{mutee_id}"
1447 def subscribe(%User{} = subscriber, %User{} = target) do
1448 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
1450 if blocks?(target, subscriber) and deny_follow_blocked do
1451 {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1453 # Note: the relationship is inverse: subscriber acts as relationship target
1454 UserRelationship.create_inverse_subscription(target, subscriber)
1458 def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1459 with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1460 subscribe(subscriber, subscribee)
1464 def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1465 # Note: the relationship is inverse: subscriber acts as relationship target
1466 UserRelationship.delete_inverse_subscription(target, unsubscriber)
1469 def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1470 with %User{} = user <- get_cached_by_ap_id(ap_id) do
1471 unsubscribe(unsubscriber, user)
1475 def block(%User{} = blocker, %User{} = blocked) do
1476 # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1478 if following?(blocker, blocked) do
1479 {:ok, blocker, _} = unfollow(blocker, blocked)
1485 # clear any requested follows from both sides as well
1487 case CommonAPI.reject_follow_request(blocked, blocker) do
1488 {:ok, %User{} = updated_blocked} -> updated_blocked
1493 case CommonAPI.reject_follow_request(blocker, blocked) do
1494 {:ok, %User{} = updated_blocker} -> updated_blocker
1498 unsubscribe(blocked, blocker)
1500 unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
1501 if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)
1503 {:ok, blocker} = update_follower_count(blocker)
1504 {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1505 add_to_block(blocker, blocked)
1508 # helper to handle the block given only an actor's AP id
1509 def block(%User{} = blocker, %{ap_id: ap_id}) do
1510 block(blocker, get_cached_by_ap_id(ap_id))
1513 def unblock(%User{} = blocker, %User{} = blocked) do
1514 remove_from_block(blocker, blocked)
1517 # helper to handle the block given only an actor's AP id
1518 def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1519 unblock(blocker, get_cached_by_ap_id(ap_id))
1522 def mutes?(nil, _), do: false
1523 def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1525 def mutes_user?(%User{} = user, %User{} = target) do
1526 UserRelationship.mute_exists?(user, target)
1529 @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1530 def muted_notifications?(nil, _), do: false
1532 def muted_notifications?(%User{} = user, %User{} = target),
1533 do: UserRelationship.notification_mute_exists?(user, target)
1535 def blocks?(nil, _), do: false
1537 def blocks?(%User{} = user, %User{} = target) do
1538 blocks_user?(user, target) ||
1539 (blocks_domain?(user, target) and not User.following?(user, target))
1542 def blocks_user?(%User{} = user, %User{} = target) do
1543 UserRelationship.block_exists?(user, target)
1546 def blocks_user?(_, _), do: false
1548 def blocks_domain?(%User{} = user, %User{} = target) do
1549 domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1550 %{host: host} = URI.parse(target.ap_id)
1551 Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1554 def blocks_domain?(_, _), do: false
1556 def subscribed_to?(%User{} = user, %User{} = target) do
1557 # Note: the relationship is inverse: subscriber acts as relationship target
1558 UserRelationship.inverse_subscription_exists?(target, user)
1561 def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1562 with %User{} = target <- get_cached_by_ap_id(ap_id) do
1563 subscribed_to?(user, target)
1568 Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1569 E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1571 @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1572 def outgoing_relationships_ap_ids(_user, []), do: %{}
1574 def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1576 def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1577 when is_list(relationship_types) do
1580 |> assoc(:outgoing_relationships)
1581 |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1582 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1583 |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1584 |> group_by([user_rel, u], user_rel.relationship_type)
1586 |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1591 fn rel_type -> {rel_type, db_result[rel_type] || []} end
1595 def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1597 def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1599 def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1601 def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1602 when is_list(relationship_types) do
1604 |> assoc(:incoming_relationships)
1605 |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1606 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1607 |> maybe_filter_on_ap_id(ap_ids)
1608 |> select([user_rel, u], u.ap_id)
1613 defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1614 where(query, [user_rel, u], u.ap_id in ^ap_ids)
1617 defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1619 def set_activation_async(user, status \\ true) do
1620 BackgroundWorker.enqueue("user_activation", %{"user_id" => user.id, "status" => status})
1623 @spec set_activation([User.t()], boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
1624 def set_activation(users, status) when is_list(users) do
1625 Repo.transaction(fn ->
1626 for user <- users, do: set_activation(user, status)
1630 @spec set_activation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
1631 def set_activation(%User{} = user, status) do
1632 with {:ok, user} <- set_activation_status(user, status) do
1635 |> Enum.filter(& &1.local)
1636 |> Enum.each(&set_cache(update_following_count(&1)))
1638 # Only update local user counts, remote will be update during the next pull.
1641 |> Enum.filter(& &1.local)
1642 |> Enum.each(&do_unfollow(user, &1))
1648 def approve(users) when is_list(users) do
1649 Repo.transaction(fn ->
1650 Enum.map(users, fn user ->
1651 with {:ok, user} <- approve(user), do: user
1656 def approve(%User{is_approved: false} = user) do
1657 with chg <- change(user, is_approved: true),
1658 {:ok, user} <- update_and_set_cache(chg) do
1659 post_register_action(user)
1664 def approve(%User{} = user), do: {:ok, user}
1666 def confirm(users) when is_list(users) do
1667 Repo.transaction(fn ->
1668 Enum.map(users, fn user ->
1669 with {:ok, user} <- confirm(user), do: user
1674 def confirm(%User{is_confirmed: false} = user) do
1675 with chg <- confirmation_changeset(user, set_confirmation: true),
1676 {:ok, user} <- update_and_set_cache(chg) do
1677 post_register_action(user)
1682 def confirm(%User{} = user), do: {:ok, user}
1684 def set_suggestion(users, is_suggested) when is_list(users) do
1685 Repo.transaction(fn ->
1686 Enum.map(users, fn user ->
1687 with {:ok, user} <- set_suggestion(user, is_suggested), do: user
1692 def set_suggestion(%User{is_suggested: is_suggested} = user, is_suggested), do: {:ok, user}
1694 def set_suggestion(%User{} = user, is_suggested) when is_boolean(is_suggested) do
1696 |> change(is_suggested: is_suggested)
1697 |> update_and_set_cache()
1700 def update_notification_settings(%User{} = user, settings) do
1702 |> cast(%{notification_settings: settings}, [])
1703 |> cast_embed(:notification_settings)
1704 |> validate_required([:notification_settings])
1705 |> update_and_set_cache()
1708 @spec purge_user_changeset(User.t()) :: Changeset.t()
1709 def purge_user_changeset(user) do
1710 # "Right to be forgotten"
1711 # https://gdpr.eu/right-to-be-forgotten/
1720 last_refreshed_at: nil,
1721 last_digest_emailed_at: nil,
1728 password_reset_pending: false,
1729 registration_reason: nil,
1730 confirmation_token: nil,
1734 is_moderator: false,
1736 mastofe_settings: nil,
1739 pleroma_settings_store: %{},
1742 is_discoverable: false,
1746 # nickname: preserved
1750 # Purge doesn't delete the user from the database.
1751 # It just nulls all its fields and deactivates it.
1752 # See `User.purge_user_changeset/1` above.
1753 defp purge(%User{} = user) do
1755 |> purge_user_changeset()
1756 |> update_and_set_cache()
1759 def delete(users) when is_list(users) do
1760 for user <- users, do: delete(user)
1763 def delete(%User{} = user) do
1764 # Purge the user immediately
1766 BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1769 # *Actually* delete the user from the DB
1770 defp delete_from_db(%User{} = user) do
1771 invalidate_cache(user)
1775 # If the user never finalized their account, it's safe to delete them.
1776 defp maybe_delete_from_db(%User{local: true, is_confirmed: false} = user),
1777 do: delete_from_db(user)
1779 defp maybe_delete_from_db(%User{local: true, is_approved: false} = user),
1780 do: delete_from_db(user)
1782 defp maybe_delete_from_db(user), do: {:ok, user}
1784 def perform(:force_password_reset, user), do: force_password_reset(user)
1786 @spec perform(atom(), User.t()) :: {:ok, User.t()}
1787 def perform(:delete, %User{} = user) do
1788 # Purge the user again, in case perform/2 is called directly
1791 # Remove all relationships
1794 |> Enum.each(fn follower ->
1795 ActivityPub.unfollow(follower, user)
1796 unfollow(follower, user)
1801 |> Enum.each(fn followed ->
1802 ActivityPub.unfollow(user, followed)
1803 unfollow(user, followed)
1806 delete_user_activities(user)
1807 delete_notifications_from_user_activities(user)
1808 delete_outgoing_pending_follow_requests(user)
1810 maybe_delete_from_db(user)
1813 def perform(:set_activation_async, user, status), do: set_activation(user, status)
1815 @spec external_users_query() :: Ecto.Query.t()
1816 def external_users_query do
1824 @spec external_users(keyword()) :: [User.t()]
1825 def external_users(opts \\ []) do
1827 external_users_query()
1828 |> select([u], struct(u, [:id, :ap_id]))
1832 do: where(query, [u], u.id > ^opts[:max_id]),
1837 do: limit(query, ^opts[:limit]),
1843 def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1845 |> join(:inner, [n], activity in assoc(n, :activity))
1846 |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1847 |> Repo.delete_all()
1850 def delete_user_activities(%User{ap_id: ap_id} = user) do
1852 |> Activity.Queries.by_actor()
1853 |> Repo.chunk_stream(50, :batches)
1854 |> Stream.each(fn activities ->
1855 Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1860 defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1861 with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1862 {:ok, delete_data, _} <- Builder.delete(user, object) do
1863 Pipeline.common_pipeline(delete_data, local: user.local)
1865 {:find_object, nil} ->
1866 # We have the create activity, but not the object, it was probably pruned.
1867 # Insert a tombstone and try again
1868 with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1869 {:ok, _tombstone} <- Object.create(tombstone_data) do
1870 delete_activity(activity, user)
1874 Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1875 Logger.error("Error: #{inspect(e)}")
1879 defp delete_activity(%{data: %{"type" => type}} = activity, user)
1880 when type in ["Like", "Announce"] do
1881 {:ok, undo, _} = Builder.undo(user, activity)
1882 Pipeline.common_pipeline(undo, local: user.local)
1885 defp delete_activity(_activity, _user), do: "Doing nothing"
1887 defp delete_outgoing_pending_follow_requests(user) do
1889 |> FollowingRelationship.outgoing_pending_follow_requests_query()
1890 |> Repo.delete_all()
1893 def html_filter_policy(%User{no_rich_text: true}) do
1894 Pleroma.HTML.Scrubber.TwitterText
1897 def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])
1899 def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1901 def get_or_fetch_by_ap_id(ap_id) do
1902 cached_user = get_cached_by_ap_id(ap_id)
1904 maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)
1906 case {cached_user, maybe_fetched_user} do
1907 {_, {:ok, %User{} = user}} ->
1910 {%User{} = user, _} ->
1914 {:error, :not_found}
1919 Creates an internal service actor by URI if missing.
1920 Optionally takes nickname for addressing.
1922 @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1923 def get_or_create_service_actor_by_ap_id(uri, nickname) do
1925 case get_cached_by_ap_id(uri) do
1927 with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1928 Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1932 %User{invisible: false} = user ->
1942 @spec set_invisible(User.t()) :: {:ok, User.t()}
1943 defp set_invisible(user) do
1945 |> change(%{invisible: true})
1946 |> update_and_set_cache()
1949 @spec create_service_actor(String.t(), String.t()) ::
1950 {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1951 defp create_service_actor(uri, nickname) do
1957 follower_address: uri <> "/followers"
1960 |> put_private_key()
1961 |> unique_constraint(:nickname)
1966 def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1969 |> :public_key.pem_decode()
1971 |> :public_key.pem_entry_decode()
1976 def public_key(_), do: {:error, "key not found"}
1978 def get_public_key_for_ap_id(ap_id) do
1979 with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1980 {:ok, public_key} <- public_key(user) do
1987 def ap_enabled?(%User{local: true}), do: true
1988 def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1989 def ap_enabled?(_), do: false
1991 @doc "Gets or fetch a user by uri or nickname."
1992 @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1993 def get_or_fetch("http://" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1994 def get_or_fetch("https://" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1995 def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1997 # wait a period of time and return newest version of the User structs
1998 # this is because we have synchronous follow APIs and need to simulate them
1999 # with an async handshake
2000 def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
2001 with %User{} = a <- get_cached_by_id(a.id),
2002 %User{} = b <- get_cached_by_id(b.id) do
2009 def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
2010 with :ok <- :timer.sleep(timeout),
2011 %User{} = a <- get_cached_by_id(a.id),
2012 %User{} = b <- get_cached_by_id(b.id) do
2019 def parse_bio(bio) when is_binary(bio) and bio != "" do
2021 |> CommonUtils.format_input("text/plain", mentions_format: :full)
2025 def parse_bio(_), do: ""
2027 def parse_bio(bio, user) when is_binary(bio) and bio != "" do
2028 # TODO: get profile URLs other than user.ap_id
2029 profile_urls = [user.ap_id]
2032 |> CommonUtils.format_input("text/plain",
2033 mentions_format: :full,
2034 rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
2039 def parse_bio(_, _), do: ""
2041 def tag(user_identifiers, tags) when is_list(user_identifiers) do
2042 Repo.transaction(fn ->
2043 for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
2047 def tag(nickname, tags) when is_binary(nickname),
2048 do: tag(get_by_nickname(nickname), tags)
2050 def tag(%User{} = user, tags),
2051 do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
2053 def untag(user_identifiers, tags) when is_list(user_identifiers) do
2054 Repo.transaction(fn ->
2055 for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
2059 def untag(nickname, tags) when is_binary(nickname),
2060 do: untag(get_by_nickname(nickname), tags)
2062 def untag(%User{} = user, tags),
2063 do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
2065 defp update_tags(%User{} = user, new_tags) do
2066 {:ok, updated_user} =
2068 |> change(%{tags: new_tags})
2069 |> update_and_set_cache()
2074 defp normalize_tags(tags) do
2077 |> Enum.map(&String.downcase/1)
2080 def local_nickname_regex do
2081 if Config.get([:instance, :extended_nickname_format]) do
2082 @extended_local_nickname_regex
2084 @strict_local_nickname_regex
2088 def local_nickname(nickname_or_mention) do
2091 |> String.split("@")
2095 def full_nickname(%User{} = user) do
2096 if String.contains?(user.nickname, "@") do
2099 %{host: host} = URI.parse(user.ap_id)
2100 user.nickname <> "@" <> host
2104 def full_nickname(nickname_or_mention),
2105 do: String.trim_leading(nickname_or_mention, "@")
2107 def error_user(ap_id) do
2111 nickname: "erroruser@example.com",
2112 inserted_at: NaiveDateTime.utc_now()
2116 @spec all_superusers() :: [User.t()]
2117 def all_superusers do
2118 User.Query.build(%{super_users: true, local: true, is_active: true})
2122 def muting_reblogs?(%User{} = user, %User{} = target) do
2123 UserRelationship.reblog_mute_exists?(user, target)
2126 def showing_reblogs?(%User{} = user, %User{} = target) do
2127 not muting_reblogs?(user, target)
2131 The function returns a query to get users with no activity for given interval of days.
2132 Inactive users are those who didn't read any notification, or had any activity where
2133 the user is the activity's actor, during `inactivity_threshold` days.
2134 Deactivated users will not appear in this list.
2138 iex> Pleroma.User.list_inactive_users()
2141 @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
2142 def list_inactive_users_query(inactivity_threshold \\ 7) do
2143 negative_inactivity_threshold = -inactivity_threshold
2144 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2145 # Subqueries are not supported in `where` clauses, join gets too complicated.
2146 has_read_notifications =
2147 from(n in Pleroma.Notification,
2148 where: n.seen == true,
2150 having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
2153 |> Pleroma.Repo.all()
2155 from(u in Pleroma.User,
2156 left_join: a in Pleroma.Activity,
2157 on: u.ap_id == a.actor,
2158 where: not is_nil(u.nickname),
2159 where: u.is_active == ^true,
2160 where: u.id not in ^has_read_notifications,
2163 max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
2164 is_nil(max(a.inserted_at))
2169 Enable or disable email notifications for user
2173 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
2174 Pleroma.User{email_notifications: %{"digest" => true}}
2176 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
2177 Pleroma.User{email_notifications: %{"digest" => false}}
2179 @spec switch_email_notifications(t(), String.t(), boolean()) ::
2180 {:ok, t()} | {:error, Ecto.Changeset.t()}
2181 def switch_email_notifications(user, type, status) do
2182 User.update_email_notifications(user, %{type => status})
2186 Set `last_digest_emailed_at` value for the user to current time
2188 @spec touch_last_digest_emailed_at(t()) :: t()
2189 def touch_last_digest_emailed_at(user) do
2190 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2192 {:ok, updated_user} =
2194 |> change(%{last_digest_emailed_at: now})
2195 |> update_and_set_cache()
2200 @spec set_confirmation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
2201 def set_confirmation(%User{} = user, bool) do
2203 |> confirmation_changeset(set_confirmation: bool)
2204 |> update_and_set_cache()
2207 def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
2211 def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
2212 # use instance-default
2213 config = Config.get([:assets, :mascots])
2214 default_mascot = Config.get([:assets, :default_mascot])
2215 mascot = Keyword.get(config, default_mascot)
2218 "id" => "default-mascot",
2219 "url" => mascot[:url],
2220 "preview_url" => mascot[:url],
2222 "mime_type" => mascot[:mime_type]
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)