1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2020 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
85 field(:bio, :string, default: "")
86 field(:raw_bio, :string)
87 field(:email, :string)
89 field(:nickname, :string)
90 field(:password_hash, :string)
91 field(:password, :string, virtual: true)
92 field(:password_confirmation, :string, virtual: true)
94 field(:public_key, :string)
95 field(:ap_id, :string)
96 field(:avatar, :map, default: %{})
97 field(:local, :boolean, default: true)
98 field(:follower_address, :string)
99 field(:following_address, :string)
100 field(:search_rank, :float, virtual: true)
101 field(:search_type, :integer, virtual: true)
102 field(:tags, {:array, :string}, default: [])
103 field(:last_refreshed_at, :naive_datetime_usec)
104 field(:last_digest_emailed_at, :naive_datetime)
105 field(:banner, :map, default: %{})
106 field(:background, :map, default: %{})
107 field(:note_count, :integer, default: 0)
108 field(:follower_count, :integer, default: 0)
109 field(:following_count, :integer, default: 0)
110 field(:locked, :boolean, default: false)
111 field(:confirmation_pending, :boolean, default: false)
112 field(:password_reset_pending, :boolean, default: false)
113 field(:approval_pending, :boolean, default: false)
114 field(:registration_reason, :string, default: nil)
115 field(:confirmation_token, :string, default: nil)
116 field(:default_scope, :string, default: "public")
117 field(:domain_blocks, {:array, :string}, default: [])
118 field(:deactivated, :boolean, default: false)
119 field(:no_rich_text, :boolean, default: false)
120 field(:ap_enabled, :boolean, default: false)
121 field(:is_moderator, :boolean, default: false)
122 field(:is_admin, :boolean, default: false)
123 field(:show_role, :boolean, default: true)
124 field(:mastofe_settings, :map, default: nil)
125 field(:uri, ObjectValidators.Uri, default: nil)
126 field(:hide_followers_count, :boolean, default: false)
127 field(:hide_follows_count, :boolean, default: false)
128 field(:hide_followers, :boolean, default: false)
129 field(:hide_follows, :boolean, default: false)
130 field(:hide_favorites, :boolean, default: true)
131 field(:unread_conversation_count, :integer, default: 0)
132 field(:pinned_activities, {:array, :string}, default: [])
133 field(:email_notifications, :map, default: %{"digest" => false})
134 field(:mascot, :map, default: nil)
135 field(:emoji, :map, default: %{})
136 field(:pleroma_settings_store, :map, default: %{})
137 field(:fields, {:array, :map}, default: [])
138 field(:raw_fields, {:array, :map}, default: [])
139 field(:discoverable, :boolean, default: false)
140 field(:invisible, :boolean, default: false)
141 field(:allow_following_move, :boolean, default: true)
142 field(:skip_thread_containment, :boolean, default: false)
143 field(:actor_type, :string, default: "Person")
144 field(:also_known_as, {:array, :string}, default: [])
145 field(:inbox, :string)
146 field(:shared_inbox, :string)
147 field(:accepts_chat_messages, :boolean, default: nil)
150 :notification_settings,
151 Pleroma.User.NotificationSetting,
155 has_many(:notifications, Notification)
156 has_many(:registrations, Registration)
157 has_many(:deliveries, Delivery)
159 has_many(:outgoing_relationships, UserRelationship, foreign_key: :source_id)
160 has_many(:incoming_relationships, UserRelationship, foreign_key: :target_id)
162 for {relationship_type,
164 {outgoing_relation, outgoing_relation_target},
165 {incoming_relation, incoming_relation_source}
166 ]} <- @user_relationships_config do
167 # Definitions of `has_many` relations: :blocker_blocks, :muter_mutes, :reblog_muter_mutes,
168 # :notification_muter_mutes, :subscribee_subscriptions
169 has_many(outgoing_relation, UserRelationship,
170 foreign_key: :source_id,
171 where: [relationship_type: relationship_type]
174 # Definitions of `has_many` relations: :blockee_blocks, :mutee_mutes, :reblog_mutee_mutes,
175 # :notification_mutee_mutes, :subscriber_subscriptions
176 has_many(incoming_relation, UserRelationship,
177 foreign_key: :target_id,
178 where: [relationship_type: relationship_type]
181 # Definitions of `has_many` relations: :blocked_users, :muted_users, :reblog_muted_users,
182 # :notification_muted_users, :subscriber_users
183 has_many(outgoing_relation_target, through: [outgoing_relation, :target])
185 # Definitions of `has_many` relations: :blocker_users, :muter_users, :reblog_muter_users,
186 # :notification_muter_users, :subscribee_users
187 has_many(incoming_relation_source, through: [incoming_relation, :source])
190 # `:blocks` is deprecated (replaced with `blocked_users` relation)
191 field(:blocks, {:array, :string}, default: [])
192 # `:mutes` is deprecated (replaced with `muted_users` relation)
193 field(:mutes, {:array, :string}, default: [])
194 # `:muted_reblogs` is deprecated (replaced with `reblog_muted_users` relation)
195 field(:muted_reblogs, {:array, :string}, default: [])
196 # `:muted_notifications` is deprecated (replaced with `notification_muted_users` relation)
197 field(:muted_notifications, {:array, :string}, default: [])
198 # `:subscribers` is deprecated (replaced with `subscriber_users` relation)
199 field(:subscribers, {:array, :string}, default: [])
202 :multi_factor_authentication_settings,
210 for {_relationship_type, [{_outgoing_relation, outgoing_relation_target}, _]} <-
211 @user_relationships_config do
212 # `def blocked_users_relation/2`, `def muted_users_relation/2`,
213 # `def reblog_muted_users_relation/2`, `def notification_muted_users/2`,
214 # `def subscriber_users/2`
215 def unquote(:"#{outgoing_relation_target}_relation")(user, restrict_deactivated? \\ false) do
216 target_users_query = assoc(user, unquote(outgoing_relation_target))
218 if restrict_deactivated? do
219 restrict_deactivated(target_users_query)
225 # `def blocked_users/2`, `def muted_users/2`, `def reblog_muted_users/2`,
226 # `def notification_muted_users/2`, `def subscriber_users/2`
227 def unquote(outgoing_relation_target)(user, restrict_deactivated? \\ false) do
229 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
231 restrict_deactivated?
236 # `def blocked_users_ap_ids/2`, `def muted_users_ap_ids/2`, `def reblog_muted_users_ap_ids/2`,
237 # `def notification_muted_users_ap_ids/2`, `def subscriber_users_ap_ids/2`
238 def unquote(:"#{outgoing_relation_target}_ap_ids")(user, restrict_deactivated? \\ false) do
240 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
242 restrict_deactivated?
244 |> select([u], u.ap_id)
249 defdelegate following_count(user), to: FollowingRelationship
250 defdelegate following(user), to: FollowingRelationship
251 defdelegate following?(follower, followed), to: FollowingRelationship
252 defdelegate following_ap_ids(user), to: FollowingRelationship
253 defdelegate get_follow_requests(user), to: FollowingRelationship
254 defdelegate search(query, opts \\ []), to: User.Search
257 Dumps Flake Id to SQL-compatible format (16-byte UUID).
258 E.g. "9pQtDGXuq4p3VlcJEm" -> <<0, 0, 1, 110, 179, 218, 42, 92, 213, 41, 44, 227, 95, 213, 0, 0>>
260 def binary_id(source_id) when is_binary(source_id) do
261 with {:ok, dumped_id} <- FlakeId.Ecto.CompatType.dump(source_id) do
268 def binary_id(source_ids) when is_list(source_ids) do
269 Enum.map(source_ids, &binary_id/1)
272 def binary_id(%User{} = user), do: binary_id(user.id)
274 @doc "Returns status account"
275 @spec account_status(User.t()) :: account_status()
276 def account_status(%User{deactivated: true}), do: :deactivated
277 def account_status(%User{password_reset_pending: true}), do: :password_reset_pending
278 def account_status(%User{local: true, approval_pending: true}), do: :approval_pending
280 def account_status(%User{local: true, confirmation_pending: true}) do
281 if Config.get([:instance, :account_activation_required]) do
282 :confirmation_pending
288 def account_status(%User{}), do: :active
290 @spec visible_for(User.t(), User.t() | nil) ::
293 | :restricted_unauthenticated
295 | :confirmation_pending
296 def visible_for(user, for_user \\ nil)
298 def visible_for(%User{invisible: true}, _), do: :invisible
300 def visible_for(%User{id: user_id}, %User{id: user_id}), do: :visible
302 def visible_for(%User{} = user, nil) do
303 if restrict_unauthenticated?(user) do
304 :restrict_unauthenticated
306 visible_account_status(user)
310 def visible_for(%User{} = user, for_user) do
311 if superuser?(for_user) do
314 visible_account_status(user)
318 def visible_for(_, _), do: :invisible
320 defp restrict_unauthenticated?(%User{local: true}) do
321 Config.restrict_unauthenticated_access?(:profiles, :local)
324 defp restrict_unauthenticated?(%User{local: _}) do
325 Config.restrict_unauthenticated_access?(:profiles, :remote)
328 defp visible_account_status(user) do
329 status = account_status(user)
331 if status in [:active, :password_reset_pending] do
338 @spec superuser?(User.t()) :: boolean()
339 def superuser?(%User{local: true, is_admin: true}), do: true
340 def superuser?(%User{local: true, is_moderator: true}), do: true
341 def superuser?(_), do: false
343 @spec invisible?(User.t()) :: boolean()
344 def invisible?(%User{invisible: true}), do: true
345 def invisible?(_), do: false
347 def avatar_url(user, options \\ []) do
349 %{"url" => [%{"href" => href} | _]} ->
353 unless options[:no_default] do
354 Config.get([:assets, :default_user_avatar], "#{Web.base_url()}/images/avi.png")
359 def banner_url(user, options \\ []) do
361 %{"url" => [%{"href" => href} | _]} -> href
362 _ -> !options[:no_default] && "#{Web.base_url()}/images/banner.png"
366 # Should probably be renamed or removed
367 def ap_id(%User{nickname: nickname}), do: "#{Web.base_url()}/users/#{nickname}"
369 def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
370 def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"
372 @spec ap_following(User.t()) :: String.t()
373 def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
374 def ap_following(%User{} = user), do: "#{ap_id(user)}/following"
376 @spec restrict_deactivated(Ecto.Query.t()) :: Ecto.Query.t()
377 def restrict_deactivated(query) do
378 from(u in query, where: u.deactivated != ^true)
381 defp truncate_fields_param(params) do
382 if Map.has_key?(params, :fields) do
383 Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
389 defp truncate_if_exists(params, key, max_length) do
390 if Map.has_key?(params, key) and is_binary(params[key]) do
391 {value, _chopped} = String.split_at(params[key], max_length)
392 Map.put(params, key, value)
398 defp fix_follower_address(%{follower_address: _, following_address: _} = params), do: params
400 defp fix_follower_address(%{nickname: nickname} = params),
401 do: Map.put(params, :follower_address, ap_followers(%User{nickname: nickname}))
403 defp fix_follower_address(params), do: params
405 def remote_user_changeset(struct \\ %User{local: false}, params) do
406 bio_limit = Config.get([:instance, :user_bio_length], 5000)
407 name_limit = Config.get([:instance, :user_name_length], 100)
410 case params[:name] do
411 name when is_binary(name) and byte_size(name) > 0 -> name
412 _ -> params[:nickname]
417 |> Map.put(:name, name)
418 |> Map.put_new(:last_refreshed_at, NaiveDateTime.utc_now())
419 |> truncate_if_exists(:name, name_limit)
420 |> truncate_if_exists(:bio, bio_limit)
421 |> truncate_fields_param()
422 |> fix_follower_address()
446 :hide_followers_count,
455 :accepts_chat_messages
458 |> validate_required([:name, :ap_id])
459 |> unique_constraint(:nickname)
460 |> validate_format(:nickname, @email_regex)
461 |> validate_length(:bio, max: bio_limit)
462 |> validate_length(:name, max: name_limit)
463 |> validate_fields(true)
466 def update_changeset(struct, params \\ %{}) do
467 bio_limit = Config.get([:instance, :user_bio_length], 5000)
468 name_limit = Config.get([:instance, :user_name_length], 100)
488 :hide_followers_count,
491 :allow_following_move,
494 :skip_thread_containment,
497 :pleroma_settings_store,
501 :accepts_chat_messages
504 |> unique_constraint(:nickname)
505 |> validate_format(:nickname, local_nickname_regex())
506 |> validate_length(:bio, max: bio_limit)
507 |> validate_length(:name, min: 1, max: name_limit)
508 |> validate_inclusion(:actor_type, ["Person", "Service"])
511 |> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
512 |> put_change_if_present(:avatar, &put_upload(&1, :avatar))
513 |> put_change_if_present(:banner, &put_upload(&1, :banner))
514 |> put_change_if_present(:background, &put_upload(&1, :background))
515 |> put_change_if_present(
516 :pleroma_settings_store,
517 &{:ok, Map.merge(struct.pleroma_settings_store, &1)}
519 |> validate_fields(false)
522 defp put_fields(changeset) do
523 if raw_fields = get_change(changeset, :raw_fields) do
526 |> Enum.filter(fn %{"name" => n} -> n != "" end)
530 |> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)
533 |> put_change(:raw_fields, raw_fields)
534 |> put_change(:fields, fields)
540 defp parse_fields(value) do
542 |> Formatter.linkify(mentions_format: :full)
546 defp put_emoji(changeset) do
547 emojified_fields = [:bio, :name, :raw_fields]
549 if Enum.any?(changeset.changes, fn {k, _} -> k in emojified_fields end) do
550 bio = Emoji.Formatter.get_emoji_map(get_field(changeset, :bio))
551 name = Emoji.Formatter.get_emoji_map(get_field(changeset, :name))
553 emoji = Map.merge(bio, name)
557 |> get_field(:raw_fields)
558 |> Enum.reduce(emoji, fn x, acc ->
559 Map.merge(acc, Emoji.Formatter.get_emoji_map(x["name"] <> x["value"]))
562 put_change(changeset, :emoji, emoji)
568 defp put_change_if_present(changeset, map_field, value_function) do
569 with {:ok, value} <- fetch_change(changeset, map_field),
570 {:ok, new_value} <- value_function.(value) do
571 put_change(changeset, map_field, new_value)
577 defp put_upload(value, type) do
578 with %Plug.Upload{} <- value,
579 {:ok, object} <- ActivityPub.upload(value, type: type) do
584 def update_as_admin_changeset(struct, params) do
586 |> update_changeset(params)
587 |> cast(params, [:email])
588 |> delete_change(:also_known_as)
589 |> unique_constraint(:email)
590 |> validate_format(:email, @email_regex)
591 |> validate_inclusion(:actor_type, ["Person", "Service"])
594 @spec update_as_admin(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
595 def update_as_admin(user, params) do
596 params = Map.put(params, "password_confirmation", params["password"])
597 changeset = update_as_admin_changeset(user, params)
599 if params["password"] do
600 reset_password(user, changeset, params)
602 User.update_and_set_cache(changeset)
606 def password_update_changeset(struct, params) do
608 |> cast(params, [:password, :password_confirmation])
609 |> validate_required([:password, :password_confirmation])
610 |> validate_confirmation(:password)
611 |> put_password_hash()
612 |> put_change(:password_reset_pending, false)
615 @spec reset_password(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
616 def reset_password(%User{} = user, params) do
617 reset_password(user, user, params)
620 def reset_password(%User{id: user_id} = user, struct, params) do
623 |> Multi.update(:user, password_update_changeset(struct, params))
624 |> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
625 |> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))
627 case Repo.transaction(multi) do
628 {:ok, %{user: user} = _} -> set_cache(user)
629 {:error, _, changeset, _} -> {:error, changeset}
633 def update_password_reset_pending(user, value) do
636 |> put_change(:password_reset_pending, value)
637 |> update_and_set_cache()
640 def force_password_reset_async(user) do
641 BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
644 @spec force_password_reset(User.t()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
645 def force_password_reset(user), do: update_password_reset_pending(user, true)
647 # Used to auto-register LDAP accounts which won't have a password hash stored locally
648 def register_changeset_ldap(struct, params = %{password: password})
649 when is_nil(password) do
650 params = Map.put_new(params, :accepts_chat_messages, true)
653 if Map.has_key?(params, :email) do
654 Map.put_new(params, :email, params[:email])
664 :accepts_chat_messages
666 |> validate_required([:name, :nickname])
667 |> unique_constraint(:nickname)
668 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
669 |> validate_format(:nickname, local_nickname_regex())
671 |> unique_constraint(:ap_id)
672 |> put_following_and_follower_address()
675 def register_changeset(struct, params \\ %{}, opts \\ []) do
676 bio_limit = Config.get([:instance, :user_bio_length], 5000)
677 name_limit = Config.get([:instance, :user_name_length], 100)
678 reason_limit = Config.get([:instance, :registration_reason_length], 500)
679 params = Map.put_new(params, :accepts_chat_messages, true)
682 if is_nil(opts[:need_confirmation]) do
683 Config.get([:instance, :account_activation_required])
685 opts[:need_confirmation]
689 if is_nil(opts[:need_approval]) do
690 Config.get([:instance, :account_approval_required])
696 |> confirmation_changeset(need_confirmation: need_confirmation?)
697 |> approval_changeset(need_approval: need_approval?)
705 :password_confirmation,
707 :accepts_chat_messages,
710 |> validate_required([:name, :nickname, :password, :password_confirmation])
711 |> validate_confirmation(:password)
712 |> unique_constraint(:email)
713 |> validate_format(:email, @email_regex)
714 |> validate_change(:email, fn :email, email ->
716 Config.get([User, :email_blacklist])
717 |> Enum.all?(fn blacklisted_domain ->
718 !String.ends_with?(email, ["@" <> blacklisted_domain, "." <> blacklisted_domain])
721 if valid?, do: [], else: [email: "Invalid email"]
723 |> unique_constraint(:nickname)
724 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
725 |> validate_format(:nickname, local_nickname_regex())
726 |> validate_length(:bio, max: bio_limit)
727 |> validate_length(:name, min: 1, max: name_limit)
728 |> validate_length(:registration_reason, max: reason_limit)
729 |> maybe_validate_required_email(opts[:external])
732 |> unique_constraint(:ap_id)
733 |> put_following_and_follower_address()
736 def maybe_validate_required_email(changeset, true), do: changeset
738 def maybe_validate_required_email(changeset, _) do
739 if Config.get([:instance, :account_activation_required]) do
740 validate_required(changeset, [:email])
746 defp put_ap_id(changeset) do
747 ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
748 put_change(changeset, :ap_id, ap_id)
751 defp put_following_and_follower_address(changeset) do
752 followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
755 |> put_change(:follower_address, followers)
758 defp autofollow_users(user) do
759 candidates = Config.get([:instance, :autofollowed_nicknames])
762 User.Query.build(%{nickname: candidates, local: true, deactivated: false})
765 follow_all(user, autofollowed_users)
768 @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
769 def register(%Ecto.Changeset{} = changeset) do
770 with {:ok, user} <- Repo.insert(changeset) do
771 post_register_action(user)
775 def post_register_action(%User{confirmation_pending: true} = user) do
776 with {:ok, _} <- try_send_confirmation_email(user) do
781 def post_register_action(%User{approval_pending: true} = user) do
782 with {:ok, _} <- send_user_approval_email(user),
783 {:ok, _} <- send_admin_approval_emails(user) do
788 def post_register_action(%User{approval_pending: false, confirmation_pending: false} = user) do
789 with {:ok, user} <- autofollow_users(user),
790 {:ok, user} <- set_cache(user),
791 {:ok, _} <- send_welcome_email(user),
792 {:ok, _} <- send_welcome_message(user),
793 {:ok, _} <- send_welcome_chat_message(user) do
798 defp send_user_approval_email(user) do
800 |> Pleroma.Emails.UserEmail.approval_pending_email()
801 |> Pleroma.Emails.Mailer.deliver_async()
806 defp send_admin_approval_emails(user) do
808 |> Enum.filter(fn user -> not is_nil(user.email) end)
809 |> Enum.each(fn superuser ->
811 |> Pleroma.Emails.AdminEmail.new_unapproved_registration(user)
812 |> Pleroma.Emails.Mailer.deliver_async()
818 def send_welcome_message(user) do
819 if User.WelcomeMessage.enabled?() do
820 User.WelcomeMessage.post_message(user)
827 def send_welcome_chat_message(user) do
828 if User.WelcomeChatMessage.enabled?() do
829 User.WelcomeChatMessage.post_message(user)
836 def send_welcome_email(%User{email: email} = user) when is_binary(email) do
837 if User.WelcomeEmail.enabled?() do
838 User.WelcomeEmail.send_email(user)
845 def send_welcome_email(_), do: {:ok, :noop}
847 @spec try_send_confirmation_email(User.t()) :: {:ok, :enqueued | :noop}
848 def try_send_confirmation_email(%User{confirmation_pending: true, email: email} = user)
849 when is_binary(email) do
850 if Config.get([:instance, :account_activation_required]) do
851 send_confirmation_email(user)
858 def try_send_confirmation_email(_), do: {:ok, :noop}
860 @spec send_confirmation_email(Uset.t()) :: User.t()
861 def send_confirmation_email(%User{} = user) do
863 |> Pleroma.Emails.UserEmail.account_confirmation_email()
864 |> Pleroma.Emails.Mailer.deliver_async()
869 def needs_update?(%User{local: true}), do: false
871 def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
873 def needs_update?(%User{local: false} = user) do
874 NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
877 def needs_update?(_), do: true
879 @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
881 # "Locked" (self-locked) users demand explicit authorization of follow requests
882 def maybe_direct_follow(%User{} = follower, %User{local: true, locked: true} = followed) do
883 follow(follower, followed, :follow_pending)
886 def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
887 follow(follower, followed)
890 def maybe_direct_follow(%User{} = follower, %User{} = followed) do
891 if not ap_enabled?(followed) do
892 follow(follower, followed)
898 @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
899 @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
900 def follow_all(follower, followeds) do
902 |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
903 |> Enum.each(&follow(follower, &1, :follow_accept))
908 def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
909 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
912 followed.deactivated ->
913 {:error, "Could not follow user: #{followed.nickname} is deactivated."}
915 deny_follow_blocked and blocks?(followed, follower) ->
916 {:error, "Could not follow user: #{followed.nickname} blocked you."}
919 FollowingRelationship.follow(follower, followed, state)
921 {:ok, _} = update_follower_count(followed)
924 |> update_following_count()
928 def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
929 {:error, "Not subscribed!"}
932 @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
933 def unfollow(%User{} = follower, %User{} = followed) do
934 case do_unfollow(follower, followed) do
935 {:ok, follower, followed} ->
936 {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
943 @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
944 defp do_unfollow(%User{} = follower, %User{} = followed) do
945 case get_follow_state(follower, followed) do
946 state when state in [:follow_pending, :follow_accept] ->
947 FollowingRelationship.unfollow(follower, followed)
948 {:ok, followed} = update_follower_count(followed)
950 {:ok, follower} = update_following_count(follower)
952 {:ok, follower, followed}
955 {:error, "Not subscribed!"}
959 @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
960 def get_follow_state(%User{} = follower, %User{} = following) do
961 following_relationship = FollowingRelationship.get(follower, following)
962 get_follow_state(follower, following, following_relationship)
965 def get_follow_state(
968 following_relationship
970 case {following_relationship, following.local} do
972 case Utils.fetch_latest_follow(follower, following) do
973 %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
974 FollowingRelationship.state_to_enum(state)
980 {%{state: state}, _} ->
988 def locked?(%User{} = user) do
993 Repo.get_by(User, id: id)
996 def get_by_ap_id(ap_id) do
997 Repo.get_by(User, ap_id: ap_id)
1000 def get_all_by_ap_id(ap_ids) do
1001 from(u in __MODULE__,
1002 where: u.ap_id in ^ap_ids
1007 def get_all_by_ids(ids) do
1008 from(u in __MODULE__, where: u.id in ^ids)
1012 # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
1013 # of the ap_id and the domain and tries to get that user
1014 def get_by_guessed_nickname(ap_id) do
1015 domain = URI.parse(ap_id).host
1016 name = List.last(String.split(ap_id, "/"))
1017 nickname = "#{name}@#{domain}"
1019 get_cached_by_nickname(nickname)
1022 def set_cache({:ok, user}), do: set_cache(user)
1023 def set_cache({:error, err}), do: {:error, err}
1025 def set_cache(%User{} = user) do
1026 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1027 Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
1028 Cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
1032 def update_and_set_cache(struct, params) do
1034 |> update_changeset(params)
1035 |> update_and_set_cache()
1038 def update_and_set_cache(changeset) do
1039 with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
1044 def get_user_friends_ap_ids(user) do
1045 from(u in User.get_friends_query(user), select: u.ap_id)
1049 @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
1050 def get_cached_user_friends_ap_ids(user) do
1051 Cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
1052 get_user_friends_ap_ids(user)
1056 def invalidate_cache(user) do
1057 Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
1058 Cachex.del(:user_cache, "nickname:#{user.nickname}")
1059 Cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
1062 @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
1063 def get_cached_by_ap_id(ap_id) do
1064 key = "ap_id:#{ap_id}"
1066 with {:ok, nil} <- Cachex.get(:user_cache, key),
1067 user when not is_nil(user) <- get_by_ap_id(ap_id),
1068 {:ok, true} <- Cachex.put(:user_cache, key, user) do
1076 def get_cached_by_id(id) do
1080 Cachex.fetch!(:user_cache, key, fn _ ->
1081 user = get_by_id(id)
1084 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1085 {:commit, user.ap_id}
1091 get_cached_by_ap_id(ap_id)
1094 def get_cached_by_nickname(nickname) do
1095 key = "nickname:#{nickname}"
1097 Cachex.fetch!(:user_cache, key, fn ->
1098 case get_or_fetch_by_nickname(nickname) do
1099 {:ok, user} -> {:commit, user}
1100 {:error, _error} -> {:ignore, nil}
1105 def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
1106 restrict_to_local = Config.get([:instance, :limit_to_local_content])
1109 is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
1110 get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
1112 restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
1113 get_cached_by_nickname(nickname_or_id)
1115 restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
1116 get_cached_by_nickname(nickname_or_id)
1123 @spec get_by_nickname(String.t()) :: User.t() | nil
1124 def get_by_nickname(nickname) do
1125 Repo.get_by(User, nickname: nickname) ||
1126 if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
1127 Repo.get_by(User, nickname: local_nickname(nickname))
1131 def get_by_email(email), do: Repo.get_by(User, email: email)
1133 def get_by_nickname_or_email(nickname_or_email) do
1134 get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
1137 def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
1139 def get_or_fetch_by_nickname(nickname) do
1140 with %User{} = user <- get_by_nickname(nickname) do
1144 with [_nick, _domain] <- String.split(nickname, "@"),
1145 {:ok, user} <- fetch_by_nickname(nickname) do
1148 _e -> {:error, "not found " <> nickname}
1153 @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1154 def get_followers_query(%User{} = user, nil) do
1155 User.Query.build(%{followers: user, deactivated: false})
1158 def get_followers_query(%User{} = user, page) do
1160 |> get_followers_query(nil)
1161 |> User.Query.paginate(page, 20)
1164 @spec get_followers_query(User.t()) :: Ecto.Query.t()
1165 def get_followers_query(%User{} = user), do: get_followers_query(user, nil)
1167 @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1168 def get_followers(%User{} = user, page \\ nil) do
1170 |> get_followers_query(page)
1174 @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1175 def get_external_followers(%User{} = user, page \\ nil) do
1177 |> get_followers_query(page)
1178 |> User.Query.build(%{external: true})
1182 def get_followers_ids(%User{} = user, page \\ nil) do
1184 |> get_followers_query(page)
1185 |> select([u], u.id)
1189 @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1190 def get_friends_query(%User{} = user, nil) do
1191 User.Query.build(%{friends: user, deactivated: false})
1194 def get_friends_query(%User{} = user, page) do
1196 |> get_friends_query(nil)
1197 |> User.Query.paginate(page, 20)
1200 @spec get_friends_query(User.t()) :: Ecto.Query.t()
1201 def get_friends_query(%User{} = user), do: get_friends_query(user, nil)
1203 def get_friends(%User{} = user, page \\ nil) do
1205 |> get_friends_query(page)
1209 def get_friends_ap_ids(%User{} = user) do
1211 |> get_friends_query(nil)
1212 |> select([u], u.ap_id)
1216 def get_friends_ids(%User{} = user, page \\ nil) do
1218 |> get_friends_query(page)
1219 |> select([u], u.id)
1223 def increase_note_count(%User{} = user) do
1225 |> where(id: ^user.id)
1226 |> update([u], inc: [note_count: 1])
1228 |> Repo.update_all([])
1230 {1, [user]} -> set_cache(user)
1235 def decrease_note_count(%User{} = user) do
1237 |> where(id: ^user.id)
1240 note_count: fragment("greatest(0, note_count - 1)")
1244 |> Repo.update_all([])
1246 {1, [user]} -> set_cache(user)
1251 def update_note_count(%User{} = user, note_count \\ nil) do
1256 where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1262 |> cast(%{note_count: note_count}, [:note_count])
1263 |> update_and_set_cache()
1266 @spec maybe_fetch_follow_information(User.t()) :: User.t()
1267 def maybe_fetch_follow_information(user) do
1268 with {:ok, user} <- fetch_follow_information(user) do
1272 Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1278 def fetch_follow_information(user) do
1279 with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1281 |> follow_information_changeset(info)
1282 |> update_and_set_cache()
1286 defp follow_information_changeset(user, params) do
1293 :hide_followers_count,
1298 @spec update_follower_count(User.t()) :: {:ok, User.t()}
1299 def update_follower_count(%User{} = user) do
1300 if user.local or !Config.get([:instance, :external_user_synchronization]) do
1301 follower_count = FollowingRelationship.follower_count(user)
1304 |> follow_information_changeset(%{follower_count: follower_count})
1305 |> update_and_set_cache
1307 {:ok, maybe_fetch_follow_information(user)}
1311 @spec update_following_count(User.t()) :: {:ok, User.t()}
1312 def update_following_count(%User{local: false} = user) do
1313 if Config.get([:instance, :external_user_synchronization]) do
1314 {:ok, maybe_fetch_follow_information(user)}
1320 def update_following_count(%User{local: true} = user) do
1321 following_count = FollowingRelationship.following_count(user)
1324 |> follow_information_changeset(%{following_count: following_count})
1325 |> update_and_set_cache()
1328 def set_unread_conversation_count(%User{local: true} = user) do
1329 unread_query = Participation.unread_conversation_count_for_user(user)
1332 |> join(:inner, [u], p in subquery(unread_query))
1334 set: [unread_conversation_count: p.count]
1336 |> where([u], u.id == ^user.id)
1338 |> Repo.update_all([])
1340 {1, [user]} -> set_cache(user)
1345 def set_unread_conversation_count(user), do: {:ok, user}
1347 def increment_unread_conversation_count(conversation, %User{local: true} = user) do
1349 Participation.unread_conversation_count_for_user(user)
1350 |> where([p], p.conversation_id == ^conversation.id)
1353 |> join(:inner, [u], p in subquery(unread_query))
1355 inc: [unread_conversation_count: 1]
1357 |> where([u], u.id == ^user.id)
1358 |> where([u, p], p.count == 0)
1360 |> Repo.update_all([])
1362 {1, [user]} -> set_cache(user)
1367 def increment_unread_conversation_count(_, user), do: {:ok, user}
1369 @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1370 def get_users_from_set(ap_ids, opts \\ []) do
1371 local_only = Keyword.get(opts, :local_only, true)
1372 criteria = %{ap_id: ap_ids, deactivated: false}
1373 criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1375 User.Query.build(criteria)
1379 @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1380 def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1383 query = User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
1389 @spec mute(User.t(), User.t(), boolean()) ::
1390 {:ok, list(UserRelationship.t())} | {:error, String.t()}
1391 def mute(%User{} = muter, %User{} = mutee, notifications? \\ true) do
1392 add_to_mutes(muter, mutee, notifications?)
1395 def unmute(%User{} = muter, %User{} = mutee) do
1396 remove_from_mutes(muter, mutee)
1399 def subscribe(%User{} = subscriber, %User{} = target) do
1400 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
1402 if blocks?(target, subscriber) and deny_follow_blocked do
1403 {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1405 # Note: the relationship is inverse: subscriber acts as relationship target
1406 UserRelationship.create_inverse_subscription(target, subscriber)
1410 def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1411 with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1412 subscribe(subscriber, subscribee)
1416 def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1417 # Note: the relationship is inverse: subscriber acts as relationship target
1418 UserRelationship.delete_inverse_subscription(target, unsubscriber)
1421 def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1422 with %User{} = user <- get_cached_by_ap_id(ap_id) do
1423 unsubscribe(unsubscriber, user)
1427 def block(%User{} = blocker, %User{} = blocked) do
1428 # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1430 if following?(blocker, blocked) do
1431 {:ok, blocker, _} = unfollow(blocker, blocked)
1437 # clear any requested follows as well
1439 case CommonAPI.reject_follow_request(blocked, blocker) do
1440 {:ok, %User{} = updated_blocked} -> updated_blocked
1444 unsubscribe(blocked, blocker)
1446 unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
1447 if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)
1449 {:ok, blocker} = update_follower_count(blocker)
1450 {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1451 add_to_block(blocker, blocked)
1454 # helper to handle the block given only an actor's AP id
1455 def block(%User{} = blocker, %{ap_id: ap_id}) do
1456 block(blocker, get_cached_by_ap_id(ap_id))
1459 def unblock(%User{} = blocker, %User{} = blocked) do
1460 remove_from_block(blocker, blocked)
1463 # helper to handle the block given only an actor's AP id
1464 def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1465 unblock(blocker, get_cached_by_ap_id(ap_id))
1468 def mutes?(nil, _), do: false
1469 def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1471 def mutes_user?(%User{} = user, %User{} = target) do
1472 UserRelationship.mute_exists?(user, target)
1475 @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1476 def muted_notifications?(nil, _), do: false
1478 def muted_notifications?(%User{} = user, %User{} = target),
1479 do: UserRelationship.notification_mute_exists?(user, target)
1481 def blocks?(nil, _), do: false
1483 def blocks?(%User{} = user, %User{} = target) do
1484 blocks_user?(user, target) ||
1485 (blocks_domain?(user, target) and not User.following?(user, target))
1488 def blocks_user?(%User{} = user, %User{} = target) do
1489 UserRelationship.block_exists?(user, target)
1492 def blocks_user?(_, _), do: false
1494 def blocks_domain?(%User{} = user, %User{} = target) do
1495 domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1496 %{host: host} = URI.parse(target.ap_id)
1497 Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1500 def blocks_domain?(_, _), do: false
1502 def subscribed_to?(%User{} = user, %User{} = target) do
1503 # Note: the relationship is inverse: subscriber acts as relationship target
1504 UserRelationship.inverse_subscription_exists?(target, user)
1507 def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1508 with %User{} = target <- get_cached_by_ap_id(ap_id) do
1509 subscribed_to?(user, target)
1514 Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1515 E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1517 @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1518 def outgoing_relationships_ap_ids(_user, []), do: %{}
1520 def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1522 def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1523 when is_list(relationship_types) do
1526 |> assoc(:outgoing_relationships)
1527 |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1528 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1529 |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1530 |> group_by([user_rel, u], user_rel.relationship_type)
1532 |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1537 fn rel_type -> {rel_type, db_result[rel_type] || []} end
1541 def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1543 def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1545 def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1547 def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1548 when is_list(relationship_types) do
1550 |> assoc(:incoming_relationships)
1551 |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1552 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1553 |> maybe_filter_on_ap_id(ap_ids)
1554 |> select([user_rel, u], u.ap_id)
1559 defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1560 where(query, [user_rel, u], u.ap_id in ^ap_ids)
1563 defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1565 def deactivate_async(user, status \\ true) do
1566 BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
1569 def deactivate(user, status \\ true)
1571 def deactivate(users, status) when is_list(users) do
1572 Repo.transaction(fn ->
1573 for user <- users, do: deactivate(user, status)
1577 def deactivate(%User{} = user, status) do
1578 with {:ok, user} <- set_activation_status(user, status) do
1581 |> Enum.filter(& &1.local)
1582 |> Enum.each(&set_cache(update_following_count(&1)))
1584 # Only update local user counts, remote will be update during the next pull.
1587 |> Enum.filter(& &1.local)
1588 |> Enum.each(&do_unfollow(user, &1))
1594 def approve(users) when is_list(users) do
1595 Repo.transaction(fn ->
1596 Enum.map(users, fn user ->
1597 with {:ok, user} <- approve(user), do: user
1602 def approve(%User{approval_pending: true} = user) do
1603 with chg <- change(user, approval_pending: false),
1604 {:ok, user} <- update_and_set_cache(chg) do
1605 post_register_action(user)
1610 def approve(%User{} = user), do: {:ok, user}
1612 def confirm(users) when is_list(users) do
1613 Repo.transaction(fn ->
1614 Enum.map(users, fn user ->
1615 with {:ok, user} <- confirm(user), do: user
1620 def confirm(%User{confirmation_pending: true} = user) do
1621 with chg <- confirmation_changeset(user, need_confirmation: false),
1622 {:ok, user} <- update_and_set_cache(chg) do
1623 post_register_action(user)
1628 def confirm(%User{} = user), do: {:ok, user}
1630 def update_notification_settings(%User{} = user, settings) do
1632 |> cast(%{notification_settings: settings}, [])
1633 |> cast_embed(:notification_settings)
1634 |> validate_required([:notification_settings])
1635 |> update_and_set_cache()
1638 @spec purge_user_changeset(User.t()) :: Changeset.t()
1639 def purge_user_changeset(user) do
1640 # "Right to be forgotten"
1641 # https://gdpr.eu/right-to-be-forgotten/
1652 last_refreshed_at: nil,
1653 last_digest_emailed_at: nil,
1660 confirmation_pending: false,
1661 password_reset_pending: false,
1662 approval_pending: false,
1663 registration_reason: nil,
1664 confirmation_token: nil,
1668 is_moderator: false,
1670 mastofe_settings: nil,
1673 pleroma_settings_store: %{},
1676 discoverable: false,
1681 def delete(users) when is_list(users) do
1682 for user <- users, do: delete(user)
1685 def delete(%User{} = user) do
1686 BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1689 defp delete_and_invalidate_cache(%User{} = user) do
1690 invalidate_cache(user)
1694 defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)
1696 defp delete_or_deactivate(%User{local: true} = user) do
1697 status = account_status(user)
1700 :confirmation_pending ->
1701 delete_and_invalidate_cache(user)
1703 :approval_pending ->
1704 delete_and_invalidate_cache(user)
1708 |> purge_user_changeset()
1709 |> update_and_set_cache()
1713 def perform(:force_password_reset, user), do: force_password_reset(user)
1715 @spec perform(atom(), User.t()) :: {:ok, User.t()}
1716 def perform(:delete, %User{} = user) do
1717 # Remove all relationships
1720 |> Enum.each(fn follower ->
1721 ActivityPub.unfollow(follower, user)
1722 unfollow(follower, user)
1727 |> Enum.each(fn followed ->
1728 ActivityPub.unfollow(user, followed)
1729 unfollow(user, followed)
1732 delete_user_activities(user)
1733 delete_notifications_from_user_activities(user)
1735 delete_outgoing_pending_follow_requests(user)
1737 delete_or_deactivate(user)
1740 def perform(:deactivate_async, user, status), do: deactivate(user, status)
1742 @spec external_users_query() :: Ecto.Query.t()
1743 def external_users_query do
1751 @spec external_users(keyword()) :: [User.t()]
1752 def external_users(opts \\ []) do
1754 external_users_query()
1755 |> select([u], struct(u, [:id, :ap_id]))
1759 do: where(query, [u], u.id > ^opts[:max_id]),
1764 do: limit(query, ^opts[:limit]),
1770 def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1772 |> join(:inner, [n], activity in assoc(n, :activity))
1773 |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1774 |> Repo.delete_all()
1777 def delete_user_activities(%User{ap_id: ap_id} = user) do
1779 |> Activity.Queries.by_actor()
1780 |> Repo.chunk_stream(50, :batches)
1781 |> Stream.each(fn activities ->
1782 Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1787 defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1788 with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1789 {:ok, delete_data, _} <- Builder.delete(user, object) do
1790 Pipeline.common_pipeline(delete_data, local: user.local)
1792 {:find_object, nil} ->
1793 # We have the create activity, but not the object, it was probably pruned.
1794 # Insert a tombstone and try again
1795 with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1796 {:ok, _tombstone} <- Object.create(tombstone_data) do
1797 delete_activity(activity, user)
1801 Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1802 Logger.error("Error: #{inspect(e)}")
1806 defp delete_activity(%{data: %{"type" => type}} = activity, user)
1807 when type in ["Like", "Announce"] do
1808 {:ok, undo, _} = Builder.undo(user, activity)
1809 Pipeline.common_pipeline(undo, local: user.local)
1812 defp delete_activity(_activity, _user), do: "Doing nothing"
1814 defp delete_outgoing_pending_follow_requests(user) do
1816 |> FollowingRelationship.outgoing_pending_follow_requests_query()
1817 |> Repo.delete_all()
1820 def html_filter_policy(%User{no_rich_text: true}) do
1821 Pleroma.HTML.Scrubber.TwitterText
1824 def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])
1826 def fetch_by_ap_id(ap_id, opts \\ []), do: ActivityPub.make_user_from_ap_id(ap_id, opts)
1828 def get_or_fetch_by_ap_id(ap_id, opts \\ []) do
1829 cached_user = get_cached_by_ap_id(ap_id)
1831 maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id, opts)
1833 case {cached_user, maybe_fetched_user} do
1834 {_, {:ok, %User{} = user}} ->
1837 {%User{} = user, _} ->
1841 {:error, :not_found}
1846 Creates an internal service actor by URI if missing.
1847 Optionally takes nickname for addressing.
1849 @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1850 def get_or_create_service_actor_by_ap_id(uri, nickname) do
1852 case get_cached_by_ap_id(uri) do
1854 with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1855 Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1859 %User{invisible: false} = user ->
1869 @spec set_invisible(User.t()) :: {:ok, User.t()}
1870 defp set_invisible(user) do
1872 |> change(%{invisible: true})
1873 |> update_and_set_cache()
1876 @spec create_service_actor(String.t(), String.t()) ::
1877 {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1878 defp create_service_actor(uri, nickname) do
1884 follower_address: uri <> "/followers"
1887 |> unique_constraint(:nickname)
1892 def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1895 |> :public_key.pem_decode()
1897 |> :public_key.pem_entry_decode()
1902 def public_key(_), do: {:error, "key not found"}
1904 def get_public_key_for_ap_id(ap_id, opts \\ []) do
1905 with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id, opts),
1906 {:ok, public_key} <- public_key(user) do
1913 def ap_enabled?(%User{local: true}), do: true
1914 def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1915 def ap_enabled?(_), do: false
1917 @doc "Gets or fetch a user by uri or nickname."
1918 @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1919 def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1920 def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1922 # wait a period of time and return newest version of the User structs
1923 # this is because we have synchronous follow APIs and need to simulate them
1924 # with an async handshake
1925 def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1926 with %User{} = a <- get_cached_by_id(a.id),
1927 %User{} = b <- get_cached_by_id(b.id) do
1934 def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1935 with :ok <- :timer.sleep(timeout),
1936 %User{} = a <- get_cached_by_id(a.id),
1937 %User{} = b <- get_cached_by_id(b.id) do
1944 def parse_bio(bio) when is_binary(bio) and bio != "" do
1946 |> CommonUtils.format_input("text/plain", mentions_format: :full)
1950 def parse_bio(_), do: ""
1952 def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1953 # TODO: get profile URLs other than user.ap_id
1954 profile_urls = [user.ap_id]
1957 |> CommonUtils.format_input("text/plain",
1958 mentions_format: :full,
1959 rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1964 def parse_bio(_, _), do: ""
1966 def tag(user_identifiers, tags) when is_list(user_identifiers) do
1967 Repo.transaction(fn ->
1968 for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1972 def tag(nickname, tags) when is_binary(nickname),
1973 do: tag(get_by_nickname(nickname), tags)
1975 def tag(%User{} = user, tags),
1976 do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1978 def untag(user_identifiers, tags) when is_list(user_identifiers) do
1979 Repo.transaction(fn ->
1980 for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1984 def untag(nickname, tags) when is_binary(nickname),
1985 do: untag(get_by_nickname(nickname), tags)
1987 def untag(%User{} = user, tags),
1988 do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1990 defp update_tags(%User{} = user, new_tags) do
1991 {:ok, updated_user} =
1993 |> change(%{tags: new_tags})
1994 |> update_and_set_cache()
1999 defp normalize_tags(tags) do
2002 |> Enum.map(&String.downcase/1)
2005 defp local_nickname_regex do
2006 if Config.get([:instance, :extended_nickname_format]) do
2007 @extended_local_nickname_regex
2009 @strict_local_nickname_regex
2013 def local_nickname(nickname_or_mention) do
2016 |> String.split("@")
2020 def full_nickname(nickname_or_mention),
2021 do: String.trim_leading(nickname_or_mention, "@")
2023 def error_user(ap_id) do
2027 nickname: "erroruser@example.com",
2028 inserted_at: NaiveDateTime.utc_now()
2032 @spec all_superusers() :: [User.t()]
2033 def all_superusers do
2034 User.Query.build(%{super_users: true, local: true, deactivated: false})
2038 def muting_reblogs?(%User{} = user, %User{} = target) do
2039 UserRelationship.reblog_mute_exists?(user, target)
2042 def showing_reblogs?(%User{} = user, %User{} = target) do
2043 not muting_reblogs?(user, target)
2047 The function returns a query to get users with no activity for given interval of days.
2048 Inactive users are those who didn't read any notification, or had any activity where
2049 the user is the activity's actor, during `inactivity_threshold` days.
2050 Deactivated users will not appear in this list.
2054 iex> Pleroma.User.list_inactive_users()
2057 @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
2058 def list_inactive_users_query(inactivity_threshold \\ 7) do
2059 negative_inactivity_threshold = -inactivity_threshold
2060 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2061 # Subqueries are not supported in `where` clauses, join gets too complicated.
2062 has_read_notifications =
2063 from(n in Pleroma.Notification,
2064 where: n.seen == true,
2066 having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
2069 |> Pleroma.Repo.all()
2071 from(u in Pleroma.User,
2072 left_join: a in Pleroma.Activity,
2073 on: u.ap_id == a.actor,
2074 where: not is_nil(u.nickname),
2075 where: u.deactivated != ^true,
2076 where: u.id not in ^has_read_notifications,
2079 max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
2080 is_nil(max(a.inserted_at))
2085 Enable or disable email notifications for user
2089 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
2090 Pleroma.User{email_notifications: %{"digest" => true}}
2092 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
2093 Pleroma.User{email_notifications: %{"digest" => false}}
2095 @spec switch_email_notifications(t(), String.t(), boolean()) ::
2096 {:ok, t()} | {:error, Ecto.Changeset.t()}
2097 def switch_email_notifications(user, type, status) do
2098 User.update_email_notifications(user, %{type => status})
2102 Set `last_digest_emailed_at` value for the user to current time
2104 @spec touch_last_digest_emailed_at(t()) :: t()
2105 def touch_last_digest_emailed_at(user) do
2106 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2108 {:ok, updated_user} =
2110 |> change(%{last_digest_emailed_at: now})
2111 |> update_and_set_cache()
2116 @spec need_confirmation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
2117 def need_confirmation(%User{} = user, bool) do
2119 |> confirmation_changeset(need_confirmation: bool)
2120 |> update_and_set_cache()
2123 def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
2127 def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
2128 # use instance-default
2129 config = Config.get([:assets, :mascots])
2130 default_mascot = Config.get([:assets, :default_mascot])
2131 mascot = Keyword.get(config, default_mascot)
2134 "id" => "default-mascot",
2135 "url" => mascot[:url],
2136 "preview_url" => mascot[:url],
2138 "mime_type" => mascot[:mime_type]
2143 def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
2145 def ensure_keys_present(%User{} = user) do
2146 with {:ok, pem} <- Keys.generate_rsa_pem() do
2148 |> cast(%{keys: pem}, [:keys])
2149 |> validate_required([:keys])
2150 |> update_and_set_cache()
2154 def get_ap_ids_by_nicknames(nicknames) do
2156 where: u.nickname in ^nicknames,
2162 defp put_password_hash(
2163 %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2165 change(changeset, password_hash: Pbkdf2.hash_pwd_salt(password))
2168 defp put_password_hash(changeset), do: changeset
2170 def is_internal_user?(%User{nickname: nil}), do: true
2171 def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2172 def is_internal_user?(_), do: false
2174 # A hack because user delete activities have a fake id for whatever reason
2175 # TODO: Get rid of this
2176 def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2178 def get_delivered_users_by_object_id(object_id) do
2180 inner_join: delivery in assoc(u, :deliveries),
2181 where: delivery.object_id == ^object_id
2186 def change_email(user, email) do
2188 |> cast(%{email: email}, [:email])
2189 |> validate_required([:email])
2190 |> unique_constraint(:email)
2191 |> validate_format(:email, @email_regex)
2192 |> update_and_set_cache()
2195 # Internal function; public one is `deactivate/2`
2196 defp set_activation_status(user, deactivated) do
2198 |> cast(%{deactivated: deactivated}, [:deactivated])
2199 |> update_and_set_cache()
2202 def update_banner(user, banner) do
2204 |> cast(%{banner: banner}, [:banner])
2205 |> update_and_set_cache()
2208 def update_background(user, background) do
2210 |> cast(%{background: background}, [:background])
2211 |> update_and_set_cache()
2214 def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
2217 moderator: is_moderator
2221 def validate_fields(changeset, remote? \\ false) do
2222 limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2223 limit = Config.get([:instance, limit_name], 0)
2226 |> validate_length(:fields, max: limit)
2227 |> validate_change(:fields, fn :fields, fields ->
2228 if Enum.all?(fields, &valid_field?/1) do
2236 defp valid_field?(%{"name" => name, "value" => value}) do
2237 name_limit = Config.get([:instance, :account_field_name_length], 255)
2238 value_limit = Config.get([:instance, :account_field_value_length], 255)
2240 is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2241 String.length(value) <= value_limit
2244 defp valid_field?(_), do: false
2246 defp truncate_field(%{"name" => name, "value" => value}) do
2248 String.split_at(name, Config.get([:instance, :account_field_name_length], 255))
2251 String.split_at(value, Config.get([:instance, :account_field_value_length], 255))
2253 %{"name" => name, "value" => value}
2256 def admin_api_update(user, params) do
2263 |> update_and_set_cache()
2266 @doc "Signs user out of all applications"
2267 def global_sign_out(user) do
2268 OAuth.Authorization.delete_user_authorizations(user)
2269 OAuth.Token.delete_user_tokens(user)
2272 def mascot_update(user, url) do
2274 |> cast(%{mascot: url}, [:mascot])
2275 |> validate_required([:mascot])
2276 |> update_and_set_cache()
2279 def mastodon_settings_update(user, settings) do
2281 |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
2282 |> validate_required([:mastofe_settings])
2283 |> update_and_set_cache()
2286 @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2287 def confirmation_changeset(user, need_confirmation: need_confirmation?) do
2289 if need_confirmation? do
2291 confirmation_pending: true,
2292 confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2296 confirmation_pending: false,
2297 confirmation_token: nil
2301 cast(user, params, [:confirmation_pending, :confirmation_token])
2304 @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
2305 def approval_changeset(user, need_approval: need_approval?) do
2306 params = if need_approval?, do: %{approval_pending: true}, else: %{approval_pending: false}
2307 cast(user, params, [:approval_pending])
2310 def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2311 if id not in user.pinned_activities do
2312 max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2313 params = %{pinned_activities: user.pinned_activities ++ [id]}
2315 # if pinned activity was scheduled for deletion, we remove job
2316 if expiration = Pleroma.Workers.PurgeExpiredActivity.get_expiration(id) do
2317 Oban.cancel_job(expiration.id)
2321 |> cast(params, [:pinned_activities])
2322 |> validate_length(:pinned_activities,
2323 max: max_pinned_statuses,
2324 message: "You have already pinned the maximum number of statuses"
2329 |> update_and_set_cache()
2332 def remove_pinnned_activity(user, %Pleroma.Activity{id: id, data: data}) do
2333 params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2335 # if pinned activity was scheduled for deletion, we reschedule it for deletion
2336 if data["expires_at"] do
2337 # MRF.ActivityExpirationPolicy used UTC timestamps for expires_at in original implementation
2339 data["expires_at"] |> Pleroma.EctoType.ActivityPub.ObjectValidators.DateTime.cast()
2341 Pleroma.Workers.PurgeExpiredActivity.enqueue(%{
2343 expires_at: expires_at
2348 |> cast(params, [:pinned_activities])
2349 |> update_and_set_cache()
2352 def update_email_notifications(user, settings) do
2353 email_notifications =
2354 user.email_notifications
2355 |> Map.merge(settings)
2356 |> Map.take(["digest"])
2358 params = %{email_notifications: email_notifications}
2359 fields = [:email_notifications]
2362 |> cast(params, fields)
2363 |> validate_required(fields)
2364 |> update_and_set_cache()
2367 defp set_domain_blocks(user, domain_blocks) do
2368 params = %{domain_blocks: domain_blocks}
2371 |> cast(params, [:domain_blocks])
2372 |> validate_required([:domain_blocks])
2373 |> update_and_set_cache()
2376 def block_domain(user, domain_blocked) do
2377 set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2380 def unblock_domain(user, domain_blocked) do
2381 set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2384 @spec add_to_block(User.t(), User.t()) ::
2385 {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2386 defp add_to_block(%User{} = user, %User{} = blocked) do
2387 UserRelationship.create_block(user, blocked)
2390 @spec add_to_block(User.t(), User.t()) ::
2391 {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2392 defp remove_from_block(%User{} = user, %User{} = blocked) do
2393 UserRelationship.delete_block(user, blocked)
2396 defp add_to_mutes(%User{} = user, %User{} = muted_user, notifications?) do
2397 with {:ok, user_mute} <- UserRelationship.create_mute(user, muted_user),
2398 {:ok, user_notification_mute} <-
2399 (notifications? && UserRelationship.create_notification_mute(user, muted_user)) ||
2401 {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
2405 defp remove_from_mutes(user, %User{} = muted_user) do
2406 with {:ok, user_mute} <- UserRelationship.delete_mute(user, muted_user),
2407 {:ok, user_notification_mute} <-
2408 UserRelationship.delete_notification_mute(user, muted_user) do
2409 {:ok, [user_mute, user_notification_mute]}
2413 def set_invisible(user, invisible) do
2414 params = %{invisible: invisible}
2417 |> cast(params, [:invisible])
2418 |> validate_required([:invisible])
2419 |> update_and_set_cache()
2422 def sanitize_html(%User{} = user) do
2423 sanitize_html(user, nil)
2426 # User data that mastodon isn't filtering (treated as plaintext):
2429 def sanitize_html(%User{} = user, filter) do
2431 Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2434 "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2439 |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2440 |> Map.put(:fields, fields)