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
31 alias Pleroma.Web.ActivityPub.ActivityPub
32 alias Pleroma.Web.ActivityPub.Builder
33 alias Pleroma.Web.ActivityPub.Pipeline
34 alias Pleroma.Web.ActivityPub.Utils
35 alias Pleroma.Web.CommonAPI
36 alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
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(:search_rank, :float, virtual: true)
103 field(:search_type, :integer, virtual: true)
104 field(:tags, {:array, :string}, default: [])
105 field(:last_refreshed_at, :naive_datetime_usec)
106 field(:last_digest_emailed_at, :naive_datetime)
107 field(:banner, :map, default: %{})
108 field(:background, :map, default: %{})
109 field(:note_count, :integer, default: 0)
110 field(:follower_count, :integer, default: 0)
111 field(:following_count, :integer, default: 0)
112 field(:is_locked, :boolean, default: false)
113 field(:is_confirmed, :boolean, default: true)
114 field(:password_reset_pending, :boolean, default: false)
115 field(:is_approved, :boolean, default: true)
116 field(:registration_reason, :string, default: nil)
117 field(:confirmation_token, :string, default: nil)
118 field(:default_scope, :string, default: "public")
119 field(:domain_blocks, {:array, :string}, default: [])
120 field(:deactivated, :boolean, default: false)
121 field(:no_rich_text, :boolean, default: false)
122 field(:ap_enabled, :boolean, default: false)
123 field(:is_moderator, :boolean, default: false)
124 field(:is_admin, :boolean, default: false)
125 field(:show_role, :boolean, default: true)
126 field(:mastofe_settings, :map, default: nil)
127 field(:uri, ObjectValidators.Uri, default: nil)
128 field(:hide_followers_count, :boolean, default: false)
129 field(:hide_follows_count, :boolean, default: false)
130 field(:hide_followers, :boolean, default: false)
131 field(:hide_follows, :boolean, default: false)
132 field(:hide_favorites, :boolean, default: true)
133 field(:pinned_activities, {:array, :string}, default: [])
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(:accepts_chat_messages, :boolean, default: nil)
151 :notification_settings,
152 Pleroma.User.NotificationSetting,
156 has_many(:notifications, Notification)
157 has_many(:registrations, Registration)
158 has_many(:deliveries, Delivery)
160 has_many(:outgoing_relationships, UserRelationship, foreign_key: :source_id)
161 has_many(:incoming_relationships, UserRelationship, foreign_key: :target_id)
163 for {relationship_type,
165 {outgoing_relation, outgoing_relation_target},
166 {incoming_relation, incoming_relation_source}
167 ]} <- @user_relationships_config do
168 # Definitions of `has_many` relations: :blocker_blocks, :muter_mutes, :reblog_muter_mutes,
169 # :notification_muter_mutes, :subscribee_subscriptions
170 has_many(outgoing_relation, UserRelationship,
171 foreign_key: :source_id,
172 where: [relationship_type: relationship_type]
175 # Definitions of `has_many` relations: :blockee_blocks, :mutee_mutes, :reblog_mutee_mutes,
176 # :notification_mutee_mutes, :subscriber_subscriptions
177 has_many(incoming_relation, UserRelationship,
178 foreign_key: :target_id,
179 where: [relationship_type: relationship_type]
182 # Definitions of `has_many` relations: :blocked_users, :muted_users, :reblog_muted_users,
183 # :notification_muted_users, :subscriber_users
184 has_many(outgoing_relation_target, through: [outgoing_relation, :target])
186 # Definitions of `has_many` relations: :blocker_users, :muter_users, :reblog_muter_users,
187 # :notification_muter_users, :subscribee_users
188 has_many(incoming_relation_source, through: [incoming_relation, :source])
191 # `:blocks` is deprecated (replaced with `blocked_users` relation)
192 field(:blocks, {:array, :string}, default: [])
193 # `:mutes` is deprecated (replaced with `muted_users` relation)
194 field(:mutes, {:array, :string}, default: [])
195 # `:muted_reblogs` is deprecated (replaced with `reblog_muted_users` relation)
196 field(:muted_reblogs, {:array, :string}, default: [])
197 # `:muted_notifications` is deprecated (replaced with `notification_muted_users` relation)
198 field(:muted_notifications, {:array, :string}, default: [])
199 # `:subscribers` is deprecated (replaced with `subscriber_users` relation)
200 field(:subscribers, {:array, :string}, default: [])
203 :multi_factor_authentication_settings,
211 for {_relationship_type, [{_outgoing_relation, outgoing_relation_target}, _]} <-
212 @user_relationships_config do
213 # `def blocked_users_relation/2`, `def muted_users_relation/2`,
214 # `def reblog_muted_users_relation/2`, `def notification_muted_users/2`,
215 # `def subscriber_users/2`
216 def unquote(:"#{outgoing_relation_target}_relation")(user, restrict_deactivated? \\ false) do
217 target_users_query = assoc(user, unquote(outgoing_relation_target))
219 if restrict_deactivated? do
220 restrict_deactivated(target_users_query)
226 # `def blocked_users/2`, `def muted_users/2`, `def reblog_muted_users/2`,
227 # `def notification_muted_users/2`, `def subscriber_users/2`
228 def unquote(outgoing_relation_target)(user, restrict_deactivated? \\ false) do
230 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
232 restrict_deactivated?
237 # `def blocked_users_ap_ids/2`, `def muted_users_ap_ids/2`, `def reblog_muted_users_ap_ids/2`,
238 # `def notification_muted_users_ap_ids/2`, `def subscriber_users_ap_ids/2`
239 def unquote(:"#{outgoing_relation_target}_ap_ids")(user, restrict_deactivated? \\ false) do
241 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
243 restrict_deactivated?
245 |> select([u], u.ap_id)
250 def cached_blocked_users_ap_ids(user) do
251 @cachex.fetch!(:user_cache, "blocked_users_ap_ids:#{user.ap_id}", fn _ ->
252 blocked_users_ap_ids(user)
256 def cached_muted_users_ap_ids(user) do
257 @cachex.fetch!(:user_cache, "muted_users_ap_ids:#{user.ap_id}", fn _ ->
258 muted_users_ap_ids(user)
262 defdelegate following_count(user), to: FollowingRelationship
263 defdelegate following(user), to: FollowingRelationship
264 defdelegate following?(follower, followed), to: FollowingRelationship
265 defdelegate following_ap_ids(user), to: FollowingRelationship
266 defdelegate get_follow_requests(user), to: FollowingRelationship
267 defdelegate search(query, opts \\ []), to: User.Search
270 Dumps Flake Id to SQL-compatible format (16-byte UUID).
271 E.g. "9pQtDGXuq4p3VlcJEm" -> <<0, 0, 1, 110, 179, 218, 42, 92, 213, 41, 44, 227, 95, 213, 0, 0>>
273 def binary_id(source_id) when is_binary(source_id) do
274 with {:ok, dumped_id} <- FlakeId.Ecto.CompatType.dump(source_id) do
281 def binary_id(source_ids) when is_list(source_ids) do
282 Enum.map(source_ids, &binary_id/1)
285 def binary_id(%User{} = user), do: binary_id(user.id)
287 @doc "Returns status account"
288 @spec account_status(User.t()) :: account_status()
289 def account_status(%User{deactivated: true}), do: :deactivated
290 def account_status(%User{password_reset_pending: true}), do: :password_reset_pending
291 def account_status(%User{local: true, is_approved: false}), do: :approval_pending
292 def account_status(%User{local: true, is_confirmed: false}), do: :confirmation_pending
293 def account_status(%User{}), do: :active
295 @spec visible_for(User.t(), User.t() | nil) ::
298 | :restricted_unauthenticated
300 | :confirmation_pending
301 def visible_for(user, for_user \\ nil)
303 def visible_for(%User{invisible: true}, _), do: :invisible
305 def visible_for(%User{id: user_id}, %User{id: user_id}), do: :visible
307 def visible_for(%User{} = user, nil) do
308 if restrict_unauthenticated?(user) do
309 :restrict_unauthenticated
311 visible_account_status(user)
315 def visible_for(%User{} = user, for_user) do
316 if superuser?(for_user) do
319 visible_account_status(user)
323 def visible_for(_, _), do: :invisible
325 defp restrict_unauthenticated?(%User{local: true}) do
326 Config.restrict_unauthenticated_access?(:profiles, :local)
329 defp restrict_unauthenticated?(%User{local: _}) do
330 Config.restrict_unauthenticated_access?(:profiles, :remote)
333 defp visible_account_status(user) do
334 status = account_status(user)
336 if status in [:active, :password_reset_pending] do
343 @spec superuser?(User.t()) :: boolean()
344 def superuser?(%User{local: true, is_admin: true}), do: true
345 def superuser?(%User{local: true, is_moderator: true}), do: true
346 def superuser?(_), do: false
348 @spec invisible?(User.t()) :: boolean()
349 def invisible?(%User{invisible: true}), do: true
350 def invisible?(_), do: false
352 def avatar_url(user, options \\ []) do
354 %{"url" => [%{"href" => href} | _]} ->
358 unless options[:no_default] do
359 Config.get([:assets, :default_user_avatar], "#{Web.base_url()}/images/avi.png")
364 def banner_url(user, options \\ []) do
366 %{"url" => [%{"href" => href} | _]} -> href
367 _ -> !options[:no_default] && "#{Web.base_url()}/images/banner.png"
371 # Should probably be renamed or removed
372 def ap_id(%User{nickname: nickname}), do: "#{Web.base_url()}/users/#{nickname}"
374 def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
375 def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"
377 @spec ap_following(User.t()) :: String.t()
378 def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
379 def ap_following(%User{} = user), do: "#{ap_id(user)}/following"
381 @spec restrict_deactivated(Ecto.Query.t()) :: Ecto.Query.t()
382 def restrict_deactivated(query) do
383 from(u in query, where: u.deactivated != ^true)
386 defp truncate_fields_param(params) do
387 if Map.has_key?(params, :fields) do
388 Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
394 defp truncate_if_exists(params, key, max_length) do
395 if Map.has_key?(params, key) and is_binary(params[key]) do
396 {value, _chopped} = String.split_at(params[key], max_length)
397 Map.put(params, key, value)
403 defp fix_follower_address(%{follower_address: _, following_address: _} = params), do: params
405 defp fix_follower_address(%{nickname: nickname} = params),
406 do: Map.put(params, :follower_address, ap_followers(%User{nickname: nickname}))
408 defp fix_follower_address(params), do: params
410 def remote_user_changeset(struct \\ %User{local: false}, params) do
411 bio_limit = Config.get([:instance, :user_bio_length], 5000)
412 name_limit = Config.get([:instance, :user_name_length], 100)
415 case params[:name] do
416 name when is_binary(name) and byte_size(name) > 0 -> name
417 _ -> params[:nickname]
422 |> Map.put(:name, name)
423 |> Map.put_new(:last_refreshed_at, NaiveDateTime.utc_now())
424 |> truncate_if_exists(:name, name_limit)
425 |> truncate_if_exists(:bio, bio_limit)
426 |> truncate_fields_param()
427 |> fix_follower_address()
450 :hide_followers_count,
459 :accepts_chat_messages
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,
519 :accepts_chat_messages
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
668 params = Map.put_new(params, :accepts_chat_messages, true)
671 if Map.has_key?(params, :email) do
672 Map.put_new(params, :email, params[:email])
682 :accepts_chat_messages
684 |> validate_required([:name, :nickname])
685 |> unique_constraint(:nickname)
686 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
687 |> validate_format(:nickname, local_nickname_regex())
689 |> unique_constraint(:ap_id)
690 |> put_following_and_follower_address()
693 def register_changeset(struct, params \\ %{}, opts \\ []) do
694 bio_limit = Config.get([:instance, :user_bio_length], 5000)
695 name_limit = Config.get([:instance, :user_name_length], 100)
696 reason_limit = Config.get([:instance, :registration_reason_length], 500)
697 params = Map.put_new(params, :accepts_chat_messages, true)
700 if is_nil(opts[:confirmed]) do
701 !Config.get([:instance, :account_activation_required])
707 if is_nil(opts[:approved]) do
708 !Config.get([:instance, :account_approval_required])
714 |> confirmation_changeset(set_confirmation: confirmed?)
715 |> approval_changeset(set_approval: approved?)
723 :password_confirmation,
725 :accepts_chat_messages,
728 |> validate_required([:name, :nickname, :password, :password_confirmation])
729 |> validate_confirmation(:password)
730 |> unique_constraint(:email)
731 |> validate_format(:email, @email_regex)
732 |> validate_change(:email, fn :email, email ->
734 Config.get([User, :email_blacklist])
735 |> Enum.all?(fn blacklisted_domain ->
736 !String.ends_with?(email, ["@" <> blacklisted_domain, "." <> blacklisted_domain])
739 if valid?, do: [], else: [email: "Invalid email"]
741 |> unique_constraint(:nickname)
742 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
743 |> validate_format(:nickname, local_nickname_regex())
744 |> validate_length(:bio, max: bio_limit)
745 |> validate_length(:name, min: 1, max: name_limit)
746 |> validate_length(:registration_reason, max: reason_limit)
747 |> maybe_validate_required_email(opts[:external])
750 |> unique_constraint(:ap_id)
751 |> put_following_and_follower_address()
754 def maybe_validate_required_email(changeset, true), do: changeset
756 def maybe_validate_required_email(changeset, _) do
757 if Config.get([:instance, :account_activation_required]) do
758 validate_required(changeset, [:email])
764 defp put_ap_id(changeset) do
765 ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
766 put_change(changeset, :ap_id, ap_id)
769 defp put_following_and_follower_address(changeset) do
770 followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
773 |> put_change(:follower_address, followers)
776 defp autofollow_users(user) do
777 candidates = Config.get([:instance, :autofollowed_nicknames])
780 User.Query.build(%{nickname: candidates, local: true, deactivated: false})
783 follow_all(user, autofollowed_users)
786 defp autofollowing_users(user) do
787 candidates = Config.get([:instance, :autofollowing_nicknames])
789 User.Query.build(%{nickname: candidates, local: true, deactivated: false})
791 |> Enum.each(&follow(&1, user, :follow_accept))
796 @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
797 def register(%Ecto.Changeset{} = changeset) do
798 with {:ok, user} <- Repo.insert(changeset) do
799 post_register_action(user)
803 def post_register_action(%User{is_confirmed: false} = user) do
804 with {:ok, _} <- try_send_confirmation_email(user) do
809 def post_register_action(%User{is_approved: false} = user) do
810 with {:ok, _} <- send_user_approval_email(user),
811 {:ok, _} <- send_admin_approval_emails(user) do
816 def post_register_action(%User{is_approved: true, is_confirmed: true} = user) do
817 with {:ok, user} <- autofollow_users(user),
818 {:ok, _} <- autofollowing_users(user),
819 {:ok, user} <- set_cache(user),
820 {:ok, _} <- send_welcome_email(user),
821 {:ok, _} <- send_welcome_message(user),
822 {:ok, _} <- send_welcome_chat_message(user) do
827 defp send_user_approval_email(user) do
829 |> Pleroma.Emails.UserEmail.approval_pending_email()
830 |> Pleroma.Emails.Mailer.deliver_async()
835 defp send_admin_approval_emails(user) do
837 |> Enum.filter(fn user -> not is_nil(user.email) end)
838 |> Enum.each(fn superuser ->
840 |> Pleroma.Emails.AdminEmail.new_unapproved_registration(user)
841 |> Pleroma.Emails.Mailer.deliver_async()
847 def send_welcome_message(user) do
848 if User.WelcomeMessage.enabled?() do
849 User.WelcomeMessage.post_message(user)
856 def send_welcome_chat_message(user) do
857 if User.WelcomeChatMessage.enabled?() do
858 User.WelcomeChatMessage.post_message(user)
865 def send_welcome_email(%User{email: email} = user) when is_binary(email) do
866 if User.WelcomeEmail.enabled?() do
867 User.WelcomeEmail.send_email(user)
874 def send_welcome_email(_), do: {:ok, :noop}
876 @spec try_send_confirmation_email(User.t()) :: {:ok, :enqueued | :noop}
877 def try_send_confirmation_email(%User{is_confirmed: false, email: email} = user)
878 when is_binary(email) do
879 if Config.get([:instance, :account_activation_required]) do
880 send_confirmation_email(user)
887 def try_send_confirmation_email(_), do: {:ok, :noop}
889 @spec send_confirmation_email(Uset.t()) :: User.t()
890 def send_confirmation_email(%User{} = user) do
892 |> Pleroma.Emails.UserEmail.account_confirmation_email()
893 |> Pleroma.Emails.Mailer.deliver_async()
898 def needs_update?(%User{local: true}), do: false
900 def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
902 def needs_update?(%User{local: false} = user) do
903 NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
906 def needs_update?(_), do: true
908 @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
910 # "Locked" (self-locked) users demand explicit authorization of follow requests
911 def maybe_direct_follow(%User{} = follower, %User{local: true, is_locked: true} = followed) do
912 follow(follower, followed, :follow_pending)
915 def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
916 follow(follower, followed)
919 def maybe_direct_follow(%User{} = follower, %User{} = followed) do
920 if not ap_enabled?(followed) do
921 follow(follower, followed)
923 {:ok, follower, followed}
927 @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
928 @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
929 def follow_all(follower, followeds) do
931 |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
932 |> Enum.each(&follow(follower, &1, :follow_accept))
937 def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
938 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
941 followed.deactivated ->
942 {:error, "Could not follow user: #{followed.nickname} is deactivated."}
944 deny_follow_blocked and blocks?(followed, follower) ->
945 {:error, "Could not follow user: #{followed.nickname} blocked you."}
948 FollowingRelationship.follow(follower, followed, state)
952 def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
953 {:error, "Not subscribed!"}
956 @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
957 def unfollow(%User{} = follower, %User{} = followed) do
958 case do_unfollow(follower, followed) do
959 {:ok, follower, followed} ->
960 {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
967 @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
968 defp do_unfollow(%User{} = follower, %User{} = followed) do
969 case get_follow_state(follower, followed) do
970 state when state in [:follow_pending, :follow_accept] ->
971 FollowingRelationship.unfollow(follower, followed)
974 {:error, "Not subscribed!"}
978 @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
979 def get_follow_state(%User{} = follower, %User{} = following) do
980 following_relationship = FollowingRelationship.get(follower, following)
981 get_follow_state(follower, following, following_relationship)
984 def get_follow_state(
987 following_relationship
989 case {following_relationship, following.local} do
991 case Utils.fetch_latest_follow(follower, following) do
992 %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
993 FollowingRelationship.state_to_enum(state)
999 {%{state: state}, _} ->
1007 def locked?(%User{} = user) do
1008 user.is_locked || false
1011 def get_by_id(id) do
1012 Repo.get_by(User, id: id)
1015 def get_by_ap_id(ap_id) do
1016 Repo.get_by(User, ap_id: ap_id)
1019 def get_all_by_ap_id(ap_ids) do
1020 from(u in __MODULE__,
1021 where: u.ap_id in ^ap_ids
1026 def get_all_by_ids(ids) do
1027 from(u in __MODULE__, where: u.id in ^ids)
1031 # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
1032 # of the ap_id and the domain and tries to get that user
1033 def get_by_guessed_nickname(ap_id) do
1034 domain = URI.parse(ap_id).host
1035 name = List.last(String.split(ap_id, "/"))
1036 nickname = "#{name}@#{domain}"
1038 get_cached_by_nickname(nickname)
1041 def set_cache({:ok, user}), do: set_cache(user)
1042 def set_cache({:error, err}), do: {:error, err}
1044 def set_cache(%User{} = user) do
1045 @cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1046 @cachex.put(:user_cache, "nickname:#{user.nickname}", user)
1047 @cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
1051 def update_and_set_cache(struct, params) do
1053 |> update_changeset(params)
1054 |> update_and_set_cache()
1057 def update_and_set_cache(changeset) do
1058 with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
1063 def get_user_friends_ap_ids(user) do
1064 from(u in User.get_friends_query(user), select: u.ap_id)
1068 @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
1069 def get_cached_user_friends_ap_ids(user) do
1070 @cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
1071 get_user_friends_ap_ids(user)
1075 def invalidate_cache(user) do
1076 @cachex.del(:user_cache, "ap_id:#{user.ap_id}")
1077 @cachex.del(:user_cache, "nickname:#{user.nickname}")
1078 @cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
1079 @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
1080 @cachex.del(:user_cache, "muted_users_ap_ids:#{user.ap_id}")
1083 @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
1084 def get_cached_by_ap_id(ap_id) do
1085 key = "ap_id:#{ap_id}"
1087 with {:ok, nil} <- @cachex.get(:user_cache, key),
1088 user when not is_nil(user) <- get_by_ap_id(ap_id),
1089 {:ok, true} <- @cachex.put(:user_cache, key, user) do
1097 def get_cached_by_id(id) do
1101 @cachex.fetch!(:user_cache, key, fn _ ->
1102 user = get_by_id(id)
1105 @cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1106 {:commit, user.ap_id}
1112 get_cached_by_ap_id(ap_id)
1115 def get_cached_by_nickname(nickname) do
1116 key = "nickname:#{nickname}"
1118 @cachex.fetch!(:user_cache, key, fn _ ->
1119 case get_or_fetch_by_nickname(nickname) do
1120 {:ok, user} -> {:commit, user}
1121 {:error, _error} -> {:ignore, nil}
1126 def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
1127 restrict_to_local = Config.get([:instance, :limit_to_local_content])
1130 is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
1131 get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
1133 restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
1134 get_cached_by_nickname(nickname_or_id)
1136 restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
1137 get_cached_by_nickname(nickname_or_id)
1144 @spec get_by_nickname(String.t()) :: User.t() | nil
1145 def get_by_nickname(nickname) do
1146 Repo.get_by(User, nickname: nickname) ||
1147 if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
1148 Repo.get_by(User, nickname: local_nickname(nickname))
1152 def get_by_email(email), do: Repo.get_by(User, email: email)
1154 def get_by_nickname_or_email(nickname_or_email) do
1155 get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
1158 def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
1160 def get_or_fetch_by_nickname(nickname) do
1161 with %User{} = user <- get_by_nickname(nickname) do
1165 with [_nick, _domain] <- String.split(nickname, "@"),
1166 {:ok, user} <- fetch_by_nickname(nickname) do
1169 _e -> {:error, "not found " <> nickname}
1174 @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1175 def get_followers_query(%User{} = user, nil) do
1176 User.Query.build(%{followers: user, deactivated: false})
1179 def get_followers_query(%User{} = user, page) do
1181 |> get_followers_query(nil)
1182 |> User.Query.paginate(page, 20)
1185 @spec get_followers_query(User.t()) :: Ecto.Query.t()
1186 def get_followers_query(%User{} = user), do: get_followers_query(user, nil)
1188 @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1189 def get_followers(%User{} = user, page \\ nil) do
1191 |> get_followers_query(page)
1195 @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1196 def get_external_followers(%User{} = user, page \\ nil) do
1198 |> get_followers_query(page)
1199 |> User.Query.build(%{external: true})
1203 def get_followers_ids(%User{} = user, page \\ nil) do
1205 |> get_followers_query(page)
1206 |> select([u], u.id)
1210 @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1211 def get_friends_query(%User{} = user, nil) do
1212 User.Query.build(%{friends: user, deactivated: false})
1215 def get_friends_query(%User{} = user, page) do
1217 |> get_friends_query(nil)
1218 |> User.Query.paginate(page, 20)
1221 @spec get_friends_query(User.t()) :: Ecto.Query.t()
1222 def get_friends_query(%User{} = user), do: get_friends_query(user, nil)
1224 def get_friends(%User{} = user, page \\ nil) do
1226 |> get_friends_query(page)
1230 def get_friends_ap_ids(%User{} = user) do
1232 |> get_friends_query(nil)
1233 |> select([u], u.ap_id)
1237 def get_friends_ids(%User{} = user, page \\ nil) do
1239 |> get_friends_query(page)
1240 |> select([u], u.id)
1244 def increase_note_count(%User{} = user) do
1246 |> where(id: ^user.id)
1247 |> update([u], inc: [note_count: 1])
1249 |> Repo.update_all([])
1251 {1, [user]} -> set_cache(user)
1256 def decrease_note_count(%User{} = user) do
1258 |> where(id: ^user.id)
1261 note_count: fragment("greatest(0, note_count - 1)")
1265 |> Repo.update_all([])
1267 {1, [user]} -> set_cache(user)
1272 def update_note_count(%User{} = user, note_count \\ nil) do
1277 where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1283 |> cast(%{note_count: note_count}, [:note_count])
1284 |> update_and_set_cache()
1287 @spec maybe_fetch_follow_information(User.t()) :: User.t()
1288 def maybe_fetch_follow_information(user) do
1289 with {:ok, user} <- fetch_follow_information(user) do
1293 Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1299 def fetch_follow_information(user) do
1300 with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1302 |> follow_information_changeset(info)
1303 |> update_and_set_cache()
1307 defp follow_information_changeset(user, params) do
1314 :hide_followers_count,
1319 @spec update_follower_count(User.t()) :: {:ok, User.t()}
1320 def update_follower_count(%User{} = user) do
1321 if user.local or !Config.get([:instance, :external_user_synchronization]) do
1322 follower_count = FollowingRelationship.follower_count(user)
1325 |> follow_information_changeset(%{follower_count: follower_count})
1326 |> update_and_set_cache
1328 {:ok, maybe_fetch_follow_information(user)}
1332 @spec update_following_count(User.t()) :: {:ok, User.t()}
1333 def update_following_count(%User{local: false} = user) do
1334 if Config.get([:instance, :external_user_synchronization]) do
1335 {:ok, maybe_fetch_follow_information(user)}
1341 def update_following_count(%User{local: true} = user) do
1342 following_count = FollowingRelationship.following_count(user)
1345 |> follow_information_changeset(%{following_count: following_count})
1346 |> update_and_set_cache()
1349 @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1350 def get_users_from_set(ap_ids, opts \\ []) do
1351 local_only = Keyword.get(opts, :local_only, true)
1352 criteria = %{ap_id: ap_ids, deactivated: false}
1353 criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1355 User.Query.build(criteria)
1359 @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1360 def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1363 query = User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
1369 @spec mute(User.t(), User.t(), map()) ::
1370 {:ok, list(UserRelationship.t())} | {:error, String.t()}
1371 def mute(%User{} = muter, %User{} = mutee, params \\ %{}) do
1372 notifications? = Map.get(params, :notifications, true)
1373 expires_in = Map.get(params, :expires_in, 0)
1375 with {:ok, user_mute} <- UserRelationship.create_mute(muter, mutee),
1376 {:ok, user_notification_mute} <-
1377 (notifications? && UserRelationship.create_notification_mute(muter, mutee)) ||
1379 if expires_in > 0 do
1380 Pleroma.Workers.MuteExpireWorker.enqueue(
1382 %{"muter_id" => muter.id, "mutee_id" => mutee.id},
1383 schedule_in: expires_in
1387 @cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
1389 {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
1393 def unmute(%User{} = muter, %User{} = mutee) do
1394 with {:ok, user_mute} <- UserRelationship.delete_mute(muter, mutee),
1395 {:ok, user_notification_mute} <-
1396 UserRelationship.delete_notification_mute(muter, mutee) do
1397 @cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
1398 {:ok, [user_mute, user_notification_mute]}
1402 def unmute(muter_id, mutee_id) do
1403 with {:muter, %User{} = muter} <- {:muter, User.get_by_id(muter_id)},
1404 {:mutee, %User{} = mutee} <- {:mutee, User.get_by_id(mutee_id)} do
1405 unmute(muter, mutee)
1407 {who, result} = error ->
1409 "User.unmute/2 failed. #{who}: #{result}, muter_id: #{muter_id}, mutee_id: #{mutee_id}"
1416 def subscribe(%User{} = subscriber, %User{} = target) do
1417 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
1419 if blocks?(target, subscriber) and deny_follow_blocked do
1420 {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1422 # Note: the relationship is inverse: subscriber acts as relationship target
1423 UserRelationship.create_inverse_subscription(target, subscriber)
1427 def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1428 with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1429 subscribe(subscriber, subscribee)
1433 def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1434 # Note: the relationship is inverse: subscriber acts as relationship target
1435 UserRelationship.delete_inverse_subscription(target, unsubscriber)
1438 def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1439 with %User{} = user <- get_cached_by_ap_id(ap_id) do
1440 unsubscribe(unsubscriber, user)
1444 def block(%User{} = blocker, %User{} = blocked) do
1445 # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1447 if following?(blocker, blocked) do
1448 {:ok, blocker, _} = unfollow(blocker, blocked)
1454 # clear any requested follows as well
1456 case CommonAPI.reject_follow_request(blocked, blocker) do
1457 {:ok, %User{} = updated_blocked} -> updated_blocked
1461 unsubscribe(blocked, blocker)
1463 unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
1464 if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)
1466 {:ok, blocker} = update_follower_count(blocker)
1467 {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1468 add_to_block(blocker, blocked)
1471 # helper to handle the block given only an actor's AP id
1472 def block(%User{} = blocker, %{ap_id: ap_id}) do
1473 block(blocker, get_cached_by_ap_id(ap_id))
1476 def unblock(%User{} = blocker, %User{} = blocked) do
1477 remove_from_block(blocker, blocked)
1480 # helper to handle the block given only an actor's AP id
1481 def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1482 unblock(blocker, get_cached_by_ap_id(ap_id))
1485 def mutes?(nil, _), do: false
1486 def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1488 def mutes_user?(%User{} = user, %User{} = target) do
1489 UserRelationship.mute_exists?(user, target)
1492 @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1493 def muted_notifications?(nil, _), do: false
1495 def muted_notifications?(%User{} = user, %User{} = target),
1496 do: UserRelationship.notification_mute_exists?(user, target)
1498 def blocks?(nil, _), do: false
1500 def blocks?(%User{} = user, %User{} = target) do
1501 blocks_user?(user, target) ||
1502 (blocks_domain?(user, target) and not User.following?(user, target))
1505 def blocks_user?(%User{} = user, %User{} = target) do
1506 UserRelationship.block_exists?(user, target)
1509 def blocks_user?(_, _), do: false
1511 def blocks_domain?(%User{} = user, %User{} = target) do
1512 domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1513 %{host: host} = URI.parse(target.ap_id)
1514 Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1517 def blocks_domain?(_, _), do: false
1519 def subscribed_to?(%User{} = user, %User{} = target) do
1520 # Note: the relationship is inverse: subscriber acts as relationship target
1521 UserRelationship.inverse_subscription_exists?(target, user)
1524 def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1525 with %User{} = target <- get_cached_by_ap_id(ap_id) do
1526 subscribed_to?(user, target)
1531 Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1532 E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1534 @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1535 def outgoing_relationships_ap_ids(_user, []), do: %{}
1537 def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1539 def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1540 when is_list(relationship_types) do
1543 |> assoc(:outgoing_relationships)
1544 |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1545 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1546 |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1547 |> group_by([user_rel, u], user_rel.relationship_type)
1549 |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1554 fn rel_type -> {rel_type, db_result[rel_type] || []} end
1558 def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1560 def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1562 def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1564 def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1565 when is_list(relationship_types) do
1567 |> assoc(:incoming_relationships)
1568 |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1569 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1570 |> maybe_filter_on_ap_id(ap_ids)
1571 |> select([user_rel, u], u.ap_id)
1576 defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1577 where(query, [user_rel, u], u.ap_id in ^ap_ids)
1580 defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1582 def deactivate_async(user, status \\ true) do
1583 BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
1586 def deactivate(user, status \\ true)
1588 def deactivate(users, status) when is_list(users) do
1589 Repo.transaction(fn ->
1590 for user <- users, do: deactivate(user, status)
1594 def deactivate(%User{} = user, status) do
1595 with {:ok, user} <- set_activation_status(user, status) do
1598 |> Enum.filter(& &1.local)
1599 |> Enum.each(&set_cache(update_following_count(&1)))
1601 # Only update local user counts, remote will be update during the next pull.
1604 |> Enum.filter(& &1.local)
1605 |> Enum.each(&do_unfollow(user, &1))
1611 def approve(users) when is_list(users) do
1612 Repo.transaction(fn ->
1613 Enum.map(users, fn user ->
1614 with {:ok, user} <- approve(user), do: user
1619 def approve(%User{is_approved: false} = user) do
1620 with chg <- change(user, is_approved: true),
1621 {:ok, user} <- update_and_set_cache(chg) do
1622 post_register_action(user)
1627 def approve(%User{} = user), do: {:ok, user}
1629 def confirm(users) when is_list(users) do
1630 Repo.transaction(fn ->
1631 Enum.map(users, fn user ->
1632 with {:ok, user} <- confirm(user), do: user
1637 def confirm(%User{is_confirmed: false} = user) do
1638 with chg <- confirmation_changeset(user, set_confirmation: true),
1639 {:ok, user} <- update_and_set_cache(chg) do
1640 post_register_action(user)
1645 def confirm(%User{} = user), do: {:ok, user}
1647 def update_notification_settings(%User{} = user, settings) do
1649 |> cast(%{notification_settings: settings}, [])
1650 |> cast_embed(:notification_settings)
1651 |> validate_required([:notification_settings])
1652 |> update_and_set_cache()
1655 @spec purge_user_changeset(User.t()) :: Changeset.t()
1656 def purge_user_changeset(user) do
1657 # "Right to be forgotten"
1658 # https://gdpr.eu/right-to-be-forgotten/
1669 last_refreshed_at: nil,
1670 last_digest_emailed_at: nil,
1678 password_reset_pending: false,
1680 registration_reason: nil,
1681 confirmation_token: nil,
1685 is_moderator: false,
1687 mastofe_settings: nil,
1690 pleroma_settings_store: %{},
1693 is_discoverable: false,
1698 def delete(users) when is_list(users) do
1699 for user <- users, do: delete(user)
1702 def delete(%User{} = user) do
1703 BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1706 defp delete_and_invalidate_cache(%User{} = user) do
1707 invalidate_cache(user)
1711 defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)
1713 defp delete_or_deactivate(%User{local: true} = user) do
1714 status = account_status(user)
1717 :confirmation_pending ->
1718 delete_and_invalidate_cache(user)
1720 :approval_pending ->
1721 delete_and_invalidate_cache(user)
1725 |> purge_user_changeset()
1726 |> update_and_set_cache()
1730 def perform(:force_password_reset, user), do: force_password_reset(user)
1732 @spec perform(atom(), User.t()) :: {:ok, User.t()}
1733 def perform(:delete, %User{} = user) do
1734 # Remove all relationships
1737 |> Enum.each(fn follower ->
1738 ActivityPub.unfollow(follower, user)
1739 unfollow(follower, user)
1744 |> Enum.each(fn followed ->
1745 ActivityPub.unfollow(user, followed)
1746 unfollow(user, followed)
1749 delete_user_activities(user)
1750 delete_notifications_from_user_activities(user)
1752 delete_outgoing_pending_follow_requests(user)
1754 delete_or_deactivate(user)
1757 def perform(:deactivate_async, user, status), do: deactivate(user, status)
1759 @spec external_users_query() :: Ecto.Query.t()
1760 def external_users_query do
1768 @spec external_users(keyword()) :: [User.t()]
1769 def external_users(opts \\ []) do
1771 external_users_query()
1772 |> select([u], struct(u, [:id, :ap_id]))
1776 do: where(query, [u], u.id > ^opts[:max_id]),
1781 do: limit(query, ^opts[:limit]),
1787 def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1789 |> join(:inner, [n], activity in assoc(n, :activity))
1790 |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1791 |> Repo.delete_all()
1794 def delete_user_activities(%User{ap_id: ap_id} = user) do
1796 |> Activity.Queries.by_actor()
1797 |> Repo.chunk_stream(50, :batches)
1798 |> Stream.each(fn activities ->
1799 Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1804 defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1805 with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1806 {:ok, delete_data, _} <- Builder.delete(user, object) do
1807 Pipeline.common_pipeline(delete_data, local: user.local)
1809 {:find_object, nil} ->
1810 # We have the create activity, but not the object, it was probably pruned.
1811 # Insert a tombstone and try again
1812 with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1813 {:ok, _tombstone} <- Object.create(tombstone_data) do
1814 delete_activity(activity, user)
1818 Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1819 Logger.error("Error: #{inspect(e)}")
1823 defp delete_activity(%{data: %{"type" => type}} = activity, user)
1824 when type in ["Like", "Announce"] do
1825 {:ok, undo, _} = Builder.undo(user, activity)
1826 Pipeline.common_pipeline(undo, local: user.local)
1829 defp delete_activity(_activity, _user), do: "Doing nothing"
1831 defp delete_outgoing_pending_follow_requests(user) do
1833 |> FollowingRelationship.outgoing_pending_follow_requests_query()
1834 |> Repo.delete_all()
1837 def html_filter_policy(%User{no_rich_text: true}) do
1838 Pleroma.HTML.Scrubber.TwitterText
1841 def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])
1843 def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1845 def get_or_fetch_by_ap_id(ap_id) do
1846 cached_user = get_cached_by_ap_id(ap_id)
1848 maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)
1850 case {cached_user, maybe_fetched_user} do
1851 {_, {:ok, %User{} = user}} ->
1854 {%User{} = user, _} ->
1858 {:error, :not_found}
1863 Creates an internal service actor by URI if missing.
1864 Optionally takes nickname for addressing.
1866 @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1867 def get_or_create_service_actor_by_ap_id(uri, nickname) do
1869 case get_cached_by_ap_id(uri) do
1871 with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1872 Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1876 %User{invisible: false} = user ->
1886 @spec set_invisible(User.t()) :: {:ok, User.t()}
1887 defp set_invisible(user) do
1889 |> change(%{invisible: true})
1890 |> update_and_set_cache()
1893 @spec create_service_actor(String.t(), String.t()) ::
1894 {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1895 defp create_service_actor(uri, nickname) do
1901 follower_address: uri <> "/followers"
1904 |> unique_constraint(:nickname)
1909 def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1912 |> :public_key.pem_decode()
1914 |> :public_key.pem_entry_decode()
1919 def public_key(_), do: {:error, "key not found"}
1921 def get_public_key_for_ap_id(ap_id) do
1922 with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1923 {:ok, public_key} <- public_key(user) do
1930 def ap_enabled?(%User{local: true}), do: true
1931 def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1932 def ap_enabled?(_), do: false
1934 @doc "Gets or fetch a user by uri or nickname."
1935 @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1936 def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1937 def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1939 # wait a period of time and return newest version of the User structs
1940 # this is because we have synchronous follow APIs and need to simulate them
1941 # with an async handshake
1942 def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1943 with %User{} = a <- get_cached_by_id(a.id),
1944 %User{} = b <- get_cached_by_id(b.id) do
1951 def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1952 with :ok <- :timer.sleep(timeout),
1953 %User{} = a <- get_cached_by_id(a.id),
1954 %User{} = b <- get_cached_by_id(b.id) do
1961 def parse_bio(bio) when is_binary(bio) and bio != "" do
1963 |> CommonUtils.format_input("text/plain", mentions_format: :full)
1967 def parse_bio(_), do: ""
1969 def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1970 # TODO: get profile URLs other than user.ap_id
1971 profile_urls = [user.ap_id]
1974 |> CommonUtils.format_input("text/plain",
1975 mentions_format: :full,
1976 rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1981 def parse_bio(_, _), do: ""
1983 def tag(user_identifiers, tags) when is_list(user_identifiers) do
1984 Repo.transaction(fn ->
1985 for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1989 def tag(nickname, tags) when is_binary(nickname),
1990 do: tag(get_by_nickname(nickname), tags)
1992 def tag(%User{} = user, tags),
1993 do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1995 def untag(user_identifiers, tags) when is_list(user_identifiers) do
1996 Repo.transaction(fn ->
1997 for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
2001 def untag(nickname, tags) when is_binary(nickname),
2002 do: untag(get_by_nickname(nickname), tags)
2004 def untag(%User{} = user, tags),
2005 do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
2007 defp update_tags(%User{} = user, new_tags) do
2008 {:ok, updated_user} =
2010 |> change(%{tags: new_tags})
2011 |> update_and_set_cache()
2016 defp normalize_tags(tags) do
2019 |> Enum.map(&String.downcase/1)
2022 defp local_nickname_regex do
2023 if Config.get([:instance, :extended_nickname_format]) do
2024 @extended_local_nickname_regex
2026 @strict_local_nickname_regex
2030 def local_nickname(nickname_or_mention) do
2033 |> String.split("@")
2037 def full_nickname(nickname_or_mention),
2038 do: String.trim_leading(nickname_or_mention, "@")
2040 def error_user(ap_id) do
2044 nickname: "erroruser@example.com",
2045 inserted_at: NaiveDateTime.utc_now()
2049 @spec all_superusers() :: [User.t()]
2050 def all_superusers do
2051 User.Query.build(%{super_users: true, local: true, deactivated: false})
2055 def muting_reblogs?(%User{} = user, %User{} = target) do
2056 UserRelationship.reblog_mute_exists?(user, target)
2059 def showing_reblogs?(%User{} = user, %User{} = target) do
2060 not muting_reblogs?(user, target)
2064 The function returns a query to get users with no activity for given interval of days.
2065 Inactive users are those who didn't read any notification, or had any activity where
2066 the user is the activity's actor, during `inactivity_threshold` days.
2067 Deactivated users will not appear in this list.
2071 iex> Pleroma.User.list_inactive_users()
2074 @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
2075 def list_inactive_users_query(inactivity_threshold \\ 7) do
2076 negative_inactivity_threshold = -inactivity_threshold
2077 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2078 # Subqueries are not supported in `where` clauses, join gets too complicated.
2079 has_read_notifications =
2080 from(n in Pleroma.Notification,
2081 where: n.seen == true,
2083 having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
2086 |> Pleroma.Repo.all()
2088 from(u in Pleroma.User,
2089 left_join: a in Pleroma.Activity,
2090 on: u.ap_id == a.actor,
2091 where: not is_nil(u.nickname),
2092 where: u.deactivated != ^true,
2093 where: u.id not in ^has_read_notifications,
2096 max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
2097 is_nil(max(a.inserted_at))
2102 Enable or disable email notifications for user
2106 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
2107 Pleroma.User{email_notifications: %{"digest" => true}}
2109 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
2110 Pleroma.User{email_notifications: %{"digest" => false}}
2112 @spec switch_email_notifications(t(), String.t(), boolean()) ::
2113 {:ok, t()} | {:error, Ecto.Changeset.t()}
2114 def switch_email_notifications(user, type, status) do
2115 User.update_email_notifications(user, %{type => status})
2119 Set `last_digest_emailed_at` value for the user to current time
2121 @spec touch_last_digest_emailed_at(t()) :: t()
2122 def touch_last_digest_emailed_at(user) do
2123 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2125 {:ok, updated_user} =
2127 |> change(%{last_digest_emailed_at: now})
2128 |> update_and_set_cache()
2133 @spec set_confirmation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
2134 def set_confirmation(%User{} = user, bool) do
2136 |> confirmation_changeset(set_confirmation: bool)
2137 |> update_and_set_cache()
2140 def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
2144 def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
2145 # use instance-default
2146 config = Config.get([:assets, :mascots])
2147 default_mascot = Config.get([:assets, :default_mascot])
2148 mascot = Keyword.get(config, default_mascot)
2151 "id" => "default-mascot",
2152 "url" => mascot[:url],
2153 "preview_url" => mascot[:url],
2155 "mime_type" => mascot[:mime_type]
2160 def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
2162 def ensure_keys_present(%User{} = user) do
2163 with {:ok, pem} <- Keys.generate_rsa_pem() do
2165 |> cast(%{keys: pem}, [:keys])
2166 |> validate_required([:keys])
2167 |> update_and_set_cache()
2171 def get_ap_ids_by_nicknames(nicknames) do
2173 where: u.nickname in ^nicknames,
2179 defp put_password_hash(
2180 %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2182 change(changeset, password_hash: Pleroma.Password.Pbkdf2.hash_pwd_salt(password))
2185 defp put_password_hash(changeset), do: changeset
2187 def is_internal_user?(%User{nickname: nil}), do: true
2188 def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2189 def is_internal_user?(_), do: false
2191 # A hack because user delete activities have a fake id for whatever reason
2192 # TODO: Get rid of this
2193 def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2195 def get_delivered_users_by_object_id(object_id) do
2197 inner_join: delivery in assoc(u, :deliveries),
2198 where: delivery.object_id == ^object_id
2203 def change_email(user, email) do
2205 |> cast(%{email: email}, [:email])
2206 |> validate_required([:email])
2207 |> unique_constraint(:email)
2208 |> validate_format(:email, @email_regex)
2209 |> update_and_set_cache()
2212 # Internal function; public one is `deactivate/2`
2213 defp set_activation_status(user, deactivated) do
2215 |> cast(%{deactivated: deactivated}, [:deactivated])
2216 |> update_and_set_cache()
2219 def update_banner(user, banner) do
2221 |> cast(%{banner: banner}, [:banner])
2222 |> update_and_set_cache()
2225 def update_background(user, background) do
2227 |> cast(%{background: background}, [:background])
2228 |> update_and_set_cache()
2231 def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
2234 moderator: is_moderator
2238 def validate_fields(changeset, remote? \\ false) do
2239 limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2240 limit = Config.get([:instance, limit_name], 0)
2243 |> validate_length(:fields, max: limit)
2244 |> validate_change(:fields, fn :fields, fields ->
2245 if Enum.all?(fields, &valid_field?/1) do
2253 defp valid_field?(%{"name" => name, "value" => value}) do
2254 name_limit = Config.get([:instance, :account_field_name_length], 255)
2255 value_limit = Config.get([:instance, :account_field_value_length], 255)
2257 is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2258 String.length(value) <= value_limit
2261 defp valid_field?(_), do: false
2263 defp truncate_field(%{"name" => name, "value" => value}) do
2265 String.split_at(name, Config.get([:instance, :account_field_name_length], 255))
2268 String.split_at(value, Config.get([:instance, :account_field_value_length], 255))
2270 %{"name" => name, "value" => value}
2273 def admin_api_update(user, params) do
2280 |> update_and_set_cache()
2283 @doc "Signs user out of all applications"
2284 def global_sign_out(user) do
2285 OAuth.Authorization.delete_user_authorizations(user)
2286 OAuth.Token.delete_user_tokens(user)
2289 def mascot_update(user, url) do
2291 |> cast(%{mascot: url}, [:mascot])
2292 |> validate_required([:mascot])
2293 |> update_and_set_cache()
2296 def mastodon_settings_update(user, settings) do
2298 |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
2299 |> validate_required([:mastofe_settings])
2300 |> update_and_set_cache()
2303 @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2304 def confirmation_changeset(user, set_confirmation: confirmed?) do
2309 confirmation_token: nil
2313 is_confirmed: false,
2314 confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2318 cast(user, params, [:is_confirmed, :confirmation_token])
2321 @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
2322 def approval_changeset(user, set_approval: approved?) do
2323 cast(user, %{is_approved: approved?}, [:is_approved])
2326 def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2327 if id not in user.pinned_activities do
2328 max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2329 params = %{pinned_activities: user.pinned_activities ++ [id]}
2331 # if pinned activity was scheduled for deletion, we remove job
2332 if expiration = Pleroma.Workers.PurgeExpiredActivity.get_expiration(id) do
2333 Oban.cancel_job(expiration.id)
2337 |> cast(params, [:pinned_activities])
2338 |> validate_length(:pinned_activities,
2339 max: max_pinned_statuses,
2340 message: "You have already pinned the maximum number of statuses"
2345 |> update_and_set_cache()
2348 def remove_pinnned_activity(user, %Pleroma.Activity{id: id, data: data}) do
2349 params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2351 # if pinned activity was scheduled for deletion, we reschedule it for deletion
2352 if data["expires_at"] do
2353 # MRF.ActivityExpirationPolicy used UTC timestamps for expires_at in original implementation
2355 data["expires_at"] |> Pleroma.EctoType.ActivityPub.ObjectValidators.DateTime.cast()
2357 Pleroma.Workers.PurgeExpiredActivity.enqueue(%{
2359 expires_at: expires_at
2364 |> cast(params, [:pinned_activities])
2365 |> update_and_set_cache()
2368 def update_email_notifications(user, settings) do
2369 email_notifications =
2370 user.email_notifications
2371 |> Map.merge(settings)
2372 |> Map.take(["digest"])
2374 params = %{email_notifications: email_notifications}
2375 fields = [:email_notifications]
2378 |> cast(params, fields)
2379 |> validate_required(fields)
2380 |> update_and_set_cache()
2383 defp set_domain_blocks(user, domain_blocks) do
2384 params = %{domain_blocks: domain_blocks}
2387 |> cast(params, [:domain_blocks])
2388 |> validate_required([:domain_blocks])
2389 |> update_and_set_cache()
2392 def block_domain(user, domain_blocked) do
2393 set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2396 def unblock_domain(user, domain_blocked) do
2397 set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2400 @spec add_to_block(User.t(), User.t()) ::
2401 {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2402 defp add_to_block(%User{} = user, %User{} = blocked) do
2403 with {:ok, relationship} <- UserRelationship.create_block(user, blocked) do
2404 @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
2409 @spec add_to_block(User.t(), User.t()) ::
2410 {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2411 defp remove_from_block(%User{} = user, %User{} = blocked) do
2412 with {:ok, relationship} <- UserRelationship.delete_block(user, blocked) do
2413 @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
2418 def set_invisible(user, invisible) do
2419 params = %{invisible: invisible}
2422 |> cast(params, [:invisible])
2423 |> validate_required([:invisible])
2424 |> update_and_set_cache()
2427 def sanitize_html(%User{} = user) do
2428 sanitize_html(user, nil)
2431 # User data that mastodon isn't filtering (treated as plaintext):
2434 def sanitize_html(%User{} = user, filter) do
2436 Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2439 "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2444 |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2445 |> Map.put(:fields, fields)
2448 def get_host(%User{ap_id: ap_id} = _user) do
2449 URI.parse(ap_id).host