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(:is_active, :boolean, default: true)
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
221 |> User.Query.build(%{deactivated: false})
227 # `def blocked_users/2`, `def muted_users/2`, `def reblog_muted_users/2`,
228 # `def notification_muted_users/2`, `def subscriber_users/2`
229 def unquote(outgoing_relation_target)(user, restrict_deactivated? \\ false) do
231 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
233 restrict_deactivated?
238 # `def blocked_users_ap_ids/2`, `def muted_users_ap_ids/2`, `def reblog_muted_users_ap_ids/2`,
239 # `def notification_muted_users_ap_ids/2`, `def subscriber_users_ap_ids/2`
240 def unquote(:"#{outgoing_relation_target}_ap_ids")(user, restrict_deactivated? \\ false) do
242 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
244 restrict_deactivated?
246 |> select([u], u.ap_id)
251 def cached_blocked_users_ap_ids(user) do
252 @cachex.fetch!(:user_cache, "blocked_users_ap_ids:#{user.ap_id}", fn _ ->
253 blocked_users_ap_ids(user)
257 def cached_muted_users_ap_ids(user) do
258 @cachex.fetch!(:user_cache, "muted_users_ap_ids:#{user.ap_id}", fn _ ->
259 muted_users_ap_ids(user)
263 defdelegate following_count(user), to: FollowingRelationship
264 defdelegate following(user), to: FollowingRelationship
265 defdelegate following?(follower, followed), to: FollowingRelationship
266 defdelegate following_ap_ids(user), to: FollowingRelationship
267 defdelegate get_follow_requests(user), to: FollowingRelationship
268 defdelegate search(query, opts \\ []), to: User.Search
271 Dumps Flake Id to SQL-compatible format (16-byte UUID).
272 E.g. "9pQtDGXuq4p3VlcJEm" -> <<0, 0, 1, 110, 179, 218, 42, 92, 213, 41, 44, 227, 95, 213, 0, 0>>
274 def binary_id(source_id) when is_binary(source_id) do
275 with {:ok, dumped_id} <- FlakeId.Ecto.CompatType.dump(source_id) do
282 def binary_id(source_ids) when is_list(source_ids) do
283 Enum.map(source_ids, &binary_id/1)
286 def binary_id(%User{} = user), do: binary_id(user.id)
288 @doc "Returns status account"
289 @spec account_status(User.t()) :: account_status()
290 def account_status(%User{is_active: false}), do: :deactivated
291 def account_status(%User{password_reset_pending: true}), do: :password_reset_pending
292 def account_status(%User{local: true, is_approved: false}), do: :approval_pending
293 def account_status(%User{local: true, is_confirmed: false}), do: :confirmation_pending
294 def account_status(%User{}), do: :active
296 @spec visible_for(User.t(), User.t() | nil) ::
299 | :restricted_unauthenticated
301 | :confirmation_pending
302 def visible_for(user, for_user \\ nil)
304 def visible_for(%User{invisible: true}, _), do: :invisible
306 def visible_for(%User{id: user_id}, %User{id: user_id}), do: :visible
308 def visible_for(%User{} = user, nil) do
309 if restrict_unauthenticated?(user) do
310 :restrict_unauthenticated
312 visible_account_status(user)
316 def visible_for(%User{} = user, for_user) do
317 if superuser?(for_user) do
320 visible_account_status(user)
324 def visible_for(_, _), do: :invisible
326 defp restrict_unauthenticated?(%User{local: true}) do
327 Config.restrict_unauthenticated_access?(:profiles, :local)
330 defp restrict_unauthenticated?(%User{local: _}) do
331 Config.restrict_unauthenticated_access?(:profiles, :remote)
334 defp visible_account_status(user) do
335 status = account_status(user)
337 if status in [:active, :password_reset_pending] do
344 @spec superuser?(User.t()) :: boolean()
345 def superuser?(%User{local: true, is_admin: true}), do: true
346 def superuser?(%User{local: true, is_moderator: true}), do: true
347 def superuser?(_), do: false
349 @spec invisible?(User.t()) :: boolean()
350 def invisible?(%User{invisible: true}), do: true
351 def invisible?(_), do: false
353 def avatar_url(user, options \\ []) do
355 %{"url" => [%{"href" => href} | _]} ->
359 unless options[:no_default] do
360 Config.get([:assets, :default_user_avatar], "#{Web.base_url()}/images/avi.png")
365 def banner_url(user, options \\ []) do
367 %{"url" => [%{"href" => href} | _]} -> href
368 _ -> !options[:no_default] && "#{Web.base_url()}/images/banner.png"
372 # Should probably be renamed or removed
373 def ap_id(%User{nickname: nickname}), do: "#{Web.base_url()}/users/#{nickname}"
375 def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
376 def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"
378 @spec ap_following(User.t()) :: String.t()
379 def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
380 def ap_following(%User{} = user), do: "#{ap_id(user)}/following"
382 defp truncate_fields_param(params) do
383 if Map.has_key?(params, :fields) do
384 Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
390 defp truncate_if_exists(params, key, max_length) do
391 if Map.has_key?(params, key) and is_binary(params[key]) do
392 {value, _chopped} = String.split_at(params[key], max_length)
393 Map.put(params, key, value)
399 defp fix_follower_address(%{follower_address: _, following_address: _} = params), do: params
401 defp fix_follower_address(%{nickname: nickname} = params),
402 do: Map.put(params, :follower_address, ap_followers(%User{nickname: nickname}))
404 defp fix_follower_address(params), do: params
406 def remote_user_changeset(struct \\ %User{local: false}, params) do
407 bio_limit = Config.get([:instance, :user_bio_length], 5000)
408 name_limit = Config.get([:instance, :user_name_length], 100)
411 case params[:name] do
412 name when is_binary(name) and byte_size(name) > 0 -> name
413 _ -> params[:nickname]
418 |> Map.put(:name, name)
419 |> Map.put_new(:last_refreshed_at, NaiveDateTime.utc_now())
420 |> truncate_if_exists(:name, name_limit)
421 |> truncate_if_exists(:bio, bio_limit)
422 |> truncate_fields_param()
423 |> fix_follower_address()
446 :hide_followers_count,
455 :accepts_chat_messages
458 |> cast(params, [:name], empty_values: [])
459 |> validate_required([:ap_id])
460 |> validate_required([:name], trim: false)
461 |> unique_constraint(:nickname)
462 |> validate_format(:nickname, @email_regex)
463 |> validate_length(:bio, max: bio_limit)
464 |> validate_length(:name, max: name_limit)
465 |> validate_fields(true)
466 |> validate_non_local()
469 defp validate_non_local(cng) do
470 local? = get_field(cng, :local)
474 |> add_error(:local, "User is local, can't update with this changeset.")
480 def update_changeset(struct, params \\ %{}) do
481 bio_limit = Config.get([:instance, :user_bio_length], 5000)
482 name_limit = Config.get([:instance, :user_name_length], 100)
502 :hide_followers_count,
505 :allow_following_move,
509 :skip_thread_containment,
512 :pleroma_settings_store,
515 :accepts_chat_messages
518 |> unique_constraint(:nickname)
519 |> validate_format(:nickname, local_nickname_regex())
520 |> validate_length(:bio, max: bio_limit)
521 |> validate_length(:name, min: 1, max: name_limit)
522 |> validate_inclusion(:actor_type, ["Person", "Service"])
525 |> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
526 |> put_change_if_present(:avatar, &put_upload(&1, :avatar))
527 |> put_change_if_present(:banner, &put_upload(&1, :banner))
528 |> put_change_if_present(:background, &put_upload(&1, :background))
529 |> put_change_if_present(
530 :pleroma_settings_store,
531 &{:ok, Map.merge(struct.pleroma_settings_store, &1)}
533 |> validate_fields(false)
536 defp put_fields(changeset) do
537 if raw_fields = get_change(changeset, :raw_fields) do
540 |> Enum.filter(fn %{"name" => n} -> n != "" end)
544 |> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)
547 |> put_change(:raw_fields, raw_fields)
548 |> put_change(:fields, fields)
554 defp parse_fields(value) do
556 |> Formatter.linkify(mentions_format: :full)
560 defp put_emoji(changeset) do
561 emojified_fields = [:bio, :name, :raw_fields]
563 if Enum.any?(changeset.changes, fn {k, _} -> k in emojified_fields end) do
564 bio = Emoji.Formatter.get_emoji_map(get_field(changeset, :bio))
565 name = Emoji.Formatter.get_emoji_map(get_field(changeset, :name))
567 emoji = Map.merge(bio, name)
571 |> get_field(:raw_fields)
572 |> Enum.reduce(emoji, fn x, acc ->
573 Map.merge(acc, Emoji.Formatter.get_emoji_map(x["name"] <> x["value"]))
576 put_change(changeset, :emoji, emoji)
582 defp put_change_if_present(changeset, map_field, value_function) do
583 with {:ok, value} <- fetch_change(changeset, map_field),
584 {:ok, new_value} <- value_function.(value) do
585 put_change(changeset, map_field, new_value)
591 defp put_upload(value, type) do
592 with %Plug.Upload{} <- value,
593 {:ok, object} <- ActivityPub.upload(value, type: type) do
598 def update_as_admin_changeset(struct, params) do
600 |> update_changeset(params)
601 |> cast(params, [:email])
602 |> delete_change(:also_known_as)
603 |> unique_constraint(:email)
604 |> validate_format(:email, @email_regex)
605 |> validate_inclusion(:actor_type, ["Person", "Service"])
608 @spec update_as_admin(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
609 def update_as_admin(user, params) do
610 params = Map.put(params, "password_confirmation", params["password"])
611 changeset = update_as_admin_changeset(user, params)
613 if params["password"] do
614 reset_password(user, changeset, params)
616 User.update_and_set_cache(changeset)
620 def password_update_changeset(struct, params) do
622 |> cast(params, [:password, :password_confirmation])
623 |> validate_required([:password, :password_confirmation])
624 |> validate_confirmation(:password)
625 |> put_password_hash()
626 |> put_change(:password_reset_pending, false)
629 @spec reset_password(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
630 def reset_password(%User{} = user, params) do
631 reset_password(user, user, params)
634 def reset_password(%User{id: user_id} = user, struct, params) do
637 |> Multi.update(:user, password_update_changeset(struct, params))
638 |> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
639 |> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))
641 case Repo.transaction(multi) do
642 {:ok, %{user: user} = _} -> set_cache(user)
643 {:error, _, changeset, _} -> {:error, changeset}
647 def update_password_reset_pending(user, value) do
650 |> put_change(:password_reset_pending, value)
651 |> update_and_set_cache()
654 def force_password_reset_async(user) do
655 BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
658 @spec force_password_reset(User.t()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
659 def force_password_reset(user), do: update_password_reset_pending(user, true)
661 # Used to auto-register LDAP accounts which won't have a password hash stored locally
662 def register_changeset_ldap(struct, params = %{password: password})
663 when is_nil(password) do
664 params = Map.put_new(params, :accepts_chat_messages, true)
667 if Map.has_key?(params, :email) do
668 Map.put_new(params, :email, params[:email])
678 :accepts_chat_messages
680 |> validate_required([:name, :nickname])
681 |> unique_constraint(:nickname)
682 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
683 |> validate_format(:nickname, local_nickname_regex())
685 |> unique_constraint(:ap_id)
686 |> put_following_and_follower_address()
689 def register_changeset(struct, params \\ %{}, opts \\ []) do
690 bio_limit = Config.get([:instance, :user_bio_length], 5000)
691 name_limit = Config.get([:instance, :user_name_length], 100)
692 reason_limit = Config.get([:instance, :registration_reason_length], 500)
693 params = Map.put_new(params, :accepts_chat_messages, true)
696 if is_nil(opts[:confirmed]) do
697 !Config.get([:instance, :account_activation_required])
703 if is_nil(opts[:approved]) do
704 !Config.get([:instance, :account_approval_required])
710 |> confirmation_changeset(set_confirmation: confirmed?)
711 |> approval_changeset(set_approval: approved?)
719 :password_confirmation,
721 :accepts_chat_messages,
724 |> validate_required([:name, :nickname, :password, :password_confirmation])
725 |> validate_confirmation(:password)
726 |> unique_constraint(:email)
727 |> validate_format(:email, @email_regex)
728 |> validate_change(:email, fn :email, email ->
730 Config.get([User, :email_blacklist])
731 |> Enum.all?(fn blacklisted_domain ->
732 !String.ends_with?(email, ["@" <> blacklisted_domain, "." <> blacklisted_domain])
735 if valid?, do: [], else: [email: "Invalid email"]
737 |> unique_constraint(:nickname)
738 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
739 |> validate_format(:nickname, local_nickname_regex())
740 |> validate_length(:bio, max: bio_limit)
741 |> validate_length(:name, min: 1, max: name_limit)
742 |> validate_length(:registration_reason, max: reason_limit)
743 |> maybe_validate_required_email(opts[:external])
746 |> unique_constraint(:ap_id)
747 |> put_following_and_follower_address()
750 def maybe_validate_required_email(changeset, true), do: changeset
752 def maybe_validate_required_email(changeset, _) do
753 if Config.get([:instance, :account_activation_required]) do
754 validate_required(changeset, [:email])
760 defp put_ap_id(changeset) do
761 ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
762 put_change(changeset, :ap_id, ap_id)
765 defp put_following_and_follower_address(changeset) do
766 followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
769 |> put_change(:follower_address, followers)
772 defp autofollow_users(user) do
773 candidates = Config.get([:instance, :autofollowed_nicknames])
776 User.Query.build(%{nickname: candidates, local: true, is_active: true})
779 follow_all(user, autofollowed_users)
782 defp autofollowing_users(user) do
783 candidates = Config.get([:instance, :autofollowing_nicknames])
785 User.Query.build(%{nickname: candidates, local: true, deactivated: false})
787 |> Enum.each(&follow(&1, user, :follow_accept))
792 @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
793 def register(%Ecto.Changeset{} = changeset) do
794 with {:ok, user} <- Repo.insert(changeset) do
795 post_register_action(user)
799 def post_register_action(%User{is_confirmed: false} = user) do
800 with {:ok, _} <- try_send_confirmation_email(user) do
805 def post_register_action(%User{is_approved: false} = user) do
806 with {:ok, _} <- send_user_approval_email(user),
807 {:ok, _} <- send_admin_approval_emails(user) do
812 def post_register_action(%User{is_approved: true, is_confirmed: true} = user) do
813 with {:ok, user} <- autofollow_users(user),
814 {:ok, _} <- autofollowing_users(user),
815 {:ok, user} <- set_cache(user),
816 {:ok, _} <- send_welcome_email(user),
817 {:ok, _} <- send_welcome_message(user),
818 {:ok, _} <- send_welcome_chat_message(user) do
823 defp send_user_approval_email(user) do
825 |> Pleroma.Emails.UserEmail.approval_pending_email()
826 |> Pleroma.Emails.Mailer.deliver_async()
831 defp send_admin_approval_emails(user) do
833 |> Enum.filter(fn user -> not is_nil(user.email) end)
834 |> Enum.each(fn superuser ->
836 |> Pleroma.Emails.AdminEmail.new_unapproved_registration(user)
837 |> Pleroma.Emails.Mailer.deliver_async()
843 def send_welcome_message(user) do
844 if User.WelcomeMessage.enabled?() do
845 User.WelcomeMessage.post_message(user)
852 def send_welcome_chat_message(user) do
853 if User.WelcomeChatMessage.enabled?() do
854 User.WelcomeChatMessage.post_message(user)
861 def send_welcome_email(%User{email: email} = user) when is_binary(email) do
862 if User.WelcomeEmail.enabled?() do
863 User.WelcomeEmail.send_email(user)
870 def send_welcome_email(_), do: {:ok, :noop}
872 @spec try_send_confirmation_email(User.t()) :: {:ok, :enqueued | :noop}
873 def try_send_confirmation_email(%User{is_confirmed: false, email: email} = user)
874 when is_binary(email) do
875 if Config.get([:instance, :account_activation_required]) do
876 send_confirmation_email(user)
883 def try_send_confirmation_email(_), do: {:ok, :noop}
885 @spec send_confirmation_email(Uset.t()) :: User.t()
886 def send_confirmation_email(%User{} = user) do
888 |> Pleroma.Emails.UserEmail.account_confirmation_email()
889 |> Pleroma.Emails.Mailer.deliver_async()
894 def needs_update?(%User{local: true}), do: false
896 def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
898 def needs_update?(%User{local: false} = user) do
899 NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
902 def needs_update?(_), do: true
904 @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
906 # "Locked" (self-locked) users demand explicit authorization of follow requests
907 def maybe_direct_follow(%User{} = follower, %User{local: true, is_locked: true} = followed) do
908 follow(follower, followed, :follow_pending)
911 def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
912 follow(follower, followed)
915 def maybe_direct_follow(%User{} = follower, %User{} = followed) do
916 if not ap_enabled?(followed) do
917 follow(follower, followed)
919 {:ok, follower, followed}
923 @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
924 @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
925 def follow_all(follower, followeds) do
927 |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
928 |> Enum.each(&follow(follower, &1, :follow_accept))
933 def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
934 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
937 not followed.is_active ->
938 {:error, "Could not follow user: #{followed.nickname} is deactivated."}
940 deny_follow_blocked and blocks?(followed, follower) ->
941 {:error, "Could not follow user: #{followed.nickname} blocked you."}
944 FollowingRelationship.follow(follower, followed, state)
948 def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
949 {:error, "Not subscribed!"}
952 @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
953 def unfollow(%User{} = follower, %User{} = followed) do
954 case do_unfollow(follower, followed) do
955 {:ok, follower, followed} ->
956 {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
963 @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
964 defp do_unfollow(%User{} = follower, %User{} = followed) do
965 case get_follow_state(follower, followed) do
966 state when state in [:follow_pending, :follow_accept] ->
967 FollowingRelationship.unfollow(follower, followed)
970 {:error, "Not subscribed!"}
974 @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
975 def get_follow_state(%User{} = follower, %User{} = following) do
976 following_relationship = FollowingRelationship.get(follower, following)
977 get_follow_state(follower, following, following_relationship)
980 def get_follow_state(
983 following_relationship
985 case {following_relationship, following.local} do
987 case Utils.fetch_latest_follow(follower, following) do
988 %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
989 FollowingRelationship.state_to_enum(state)
995 {%{state: state}, _} ->
1003 def locked?(%User{} = user) do
1004 user.is_locked || false
1007 def get_by_id(id) do
1008 Repo.get_by(User, id: id)
1011 def get_by_ap_id(ap_id) do
1012 Repo.get_by(User, ap_id: ap_id)
1015 def get_all_by_ap_id(ap_ids) do
1016 from(u in __MODULE__,
1017 where: u.ap_id in ^ap_ids
1022 def get_all_by_ids(ids) do
1023 from(u in __MODULE__, where: u.id in ^ids)
1027 # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
1028 # of the ap_id and the domain and tries to get that user
1029 def get_by_guessed_nickname(ap_id) do
1030 domain = URI.parse(ap_id).host
1031 name = List.last(String.split(ap_id, "/"))
1032 nickname = "#{name}@#{domain}"
1034 get_cached_by_nickname(nickname)
1037 def set_cache({:ok, user}), do: set_cache(user)
1038 def set_cache({:error, err}), do: {:error, err}
1040 def set_cache(%User{} = user) do
1041 @cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1042 @cachex.put(:user_cache, "nickname:#{user.nickname}", user)
1043 @cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
1047 def update_and_set_cache(struct, params) do
1049 |> update_changeset(params)
1050 |> update_and_set_cache()
1053 def update_and_set_cache(changeset) do
1054 with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
1059 def get_user_friends_ap_ids(user) do
1060 from(u in User.get_friends_query(user), select: u.ap_id)
1064 @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
1065 def get_cached_user_friends_ap_ids(user) do
1066 @cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
1067 get_user_friends_ap_ids(user)
1071 def invalidate_cache(user) do
1072 @cachex.del(:user_cache, "ap_id:#{user.ap_id}")
1073 @cachex.del(:user_cache, "nickname:#{user.nickname}")
1074 @cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
1075 @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
1076 @cachex.del(:user_cache, "muted_users_ap_ids:#{user.ap_id}")
1079 @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
1080 def get_cached_by_ap_id(ap_id) do
1081 key = "ap_id:#{ap_id}"
1083 with {:ok, nil} <- @cachex.get(:user_cache, key),
1084 user when not is_nil(user) <- get_by_ap_id(ap_id),
1085 {:ok, true} <- @cachex.put(:user_cache, key, user) do
1093 def get_cached_by_id(id) do
1097 @cachex.fetch!(:user_cache, key, fn _ ->
1098 user = get_by_id(id)
1101 @cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1102 {:commit, user.ap_id}
1108 get_cached_by_ap_id(ap_id)
1111 def get_cached_by_nickname(nickname) do
1112 key = "nickname:#{nickname}"
1114 @cachex.fetch!(:user_cache, key, fn _ ->
1115 case get_or_fetch_by_nickname(nickname) do
1116 {:ok, user} -> {:commit, user}
1117 {:error, _error} -> {:ignore, nil}
1122 def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
1123 restrict_to_local = Config.get([:instance, :limit_to_local_content])
1126 is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
1127 get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
1129 restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
1130 get_cached_by_nickname(nickname_or_id)
1132 restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
1133 get_cached_by_nickname(nickname_or_id)
1140 @spec get_by_nickname(String.t()) :: User.t() | nil
1141 def get_by_nickname(nickname) do
1142 Repo.get_by(User, nickname: nickname) ||
1143 if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
1144 Repo.get_by(User, nickname: local_nickname(nickname))
1148 def get_by_email(email), do: Repo.get_by(User, email: email)
1150 def get_by_nickname_or_email(nickname_or_email) do
1151 get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
1154 def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
1156 def get_or_fetch_by_nickname(nickname) do
1157 with %User{} = user <- get_by_nickname(nickname) do
1161 with [_nick, _domain] <- String.split(nickname, "@"),
1162 {:ok, user} <- fetch_by_nickname(nickname) do
1165 _e -> {:error, "not found " <> nickname}
1170 @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1171 def get_followers_query(%User{} = user, nil) do
1172 User.Query.build(%{followers: user, is_active: true})
1175 def get_followers_query(%User{} = user, page) do
1177 |> get_followers_query(nil)
1178 |> User.Query.paginate(page, 20)
1181 @spec get_followers_query(User.t()) :: Ecto.Query.t()
1182 def get_followers_query(%User{} = user), do: get_followers_query(user, nil)
1184 @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1185 def get_followers(%User{} = user, page \\ nil) do
1187 |> get_followers_query(page)
1191 @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1192 def get_external_followers(%User{} = user, page \\ nil) do
1194 |> get_followers_query(page)
1195 |> User.Query.build(%{external: true})
1199 def get_followers_ids(%User{} = user, page \\ nil) do
1201 |> get_followers_query(page)
1202 |> select([u], u.id)
1206 @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1207 def get_friends_query(%User{} = user, nil) do
1208 User.Query.build(%{friends: user, deactivated: false})
1211 def get_friends_query(%User{} = user, page) do
1213 |> get_friends_query(nil)
1214 |> User.Query.paginate(page, 20)
1217 @spec get_friends_query(User.t()) :: Ecto.Query.t()
1218 def get_friends_query(%User{} = user), do: get_friends_query(user, nil)
1220 def get_friends(%User{} = user, page \\ nil) do
1222 |> get_friends_query(page)
1226 def get_friends_ap_ids(%User{} = user) do
1228 |> get_friends_query(nil)
1229 |> select([u], u.ap_id)
1233 def get_friends_ids(%User{} = user, page \\ nil) do
1235 |> get_friends_query(page)
1236 |> select([u], u.id)
1240 def increase_note_count(%User{} = user) do
1242 |> where(id: ^user.id)
1243 |> update([u], inc: [note_count: 1])
1245 |> Repo.update_all([])
1247 {1, [user]} -> set_cache(user)
1252 def decrease_note_count(%User{} = user) do
1254 |> where(id: ^user.id)
1257 note_count: fragment("greatest(0, note_count - 1)")
1261 |> Repo.update_all([])
1263 {1, [user]} -> set_cache(user)
1268 def update_note_count(%User{} = user, note_count \\ nil) do
1273 where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1279 |> cast(%{note_count: note_count}, [:note_count])
1280 |> update_and_set_cache()
1283 @spec maybe_fetch_follow_information(User.t()) :: User.t()
1284 def maybe_fetch_follow_information(user) do
1285 with {:ok, user} <- fetch_follow_information(user) do
1289 Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1295 def fetch_follow_information(user) do
1296 with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1298 |> follow_information_changeset(info)
1299 |> update_and_set_cache()
1303 defp follow_information_changeset(user, params) do
1310 :hide_followers_count,
1315 @spec update_follower_count(User.t()) :: {:ok, User.t()}
1316 def update_follower_count(%User{} = user) do
1317 if user.local or !Config.get([:instance, :external_user_synchronization]) do
1318 follower_count = FollowingRelationship.follower_count(user)
1321 |> follow_information_changeset(%{follower_count: follower_count})
1322 |> update_and_set_cache
1324 {:ok, maybe_fetch_follow_information(user)}
1328 @spec update_following_count(User.t()) :: {:ok, User.t()}
1329 def update_following_count(%User{local: false} = user) do
1330 if Config.get([:instance, :external_user_synchronization]) do
1331 {:ok, maybe_fetch_follow_information(user)}
1337 def update_following_count(%User{local: true} = user) do
1338 following_count = FollowingRelationship.following_count(user)
1341 |> follow_information_changeset(%{following_count: following_count})
1342 |> update_and_set_cache()
1345 @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1346 def get_users_from_set(ap_ids, opts \\ []) do
1347 local_only = Keyword.get(opts, :local_only, true)
1348 criteria = %{ap_id: ap_ids, is_active: true}
1349 criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1351 User.Query.build(criteria)
1355 @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1356 def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1359 query = User.Query.build(%{recipients_from_activity: to, local: true, is_active: true})
1365 @spec mute(User.t(), User.t(), map()) ::
1366 {:ok, list(UserRelationship.t())} | {:error, String.t()}
1367 def mute(%User{} = muter, %User{} = mutee, params \\ %{}) do
1368 notifications? = Map.get(params, :notifications, true)
1369 expires_in = Map.get(params, :expires_in, 0)
1371 with {:ok, user_mute} <- UserRelationship.create_mute(muter, mutee),
1372 {:ok, user_notification_mute} <-
1373 (notifications? && UserRelationship.create_notification_mute(muter, mutee)) ||
1375 if expires_in > 0 do
1376 Pleroma.Workers.MuteExpireWorker.enqueue(
1378 %{"muter_id" => muter.id, "mutee_id" => mutee.id},
1379 schedule_in: expires_in
1383 @cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
1385 {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
1389 def unmute(%User{} = muter, %User{} = mutee) do
1390 with {:ok, user_mute} <- UserRelationship.delete_mute(muter, mutee),
1391 {:ok, user_notification_mute} <-
1392 UserRelationship.delete_notification_mute(muter, mutee) do
1393 @cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
1394 {:ok, [user_mute, user_notification_mute]}
1398 def unmute(muter_id, mutee_id) do
1399 with {:muter, %User{} = muter} <- {:muter, User.get_by_id(muter_id)},
1400 {:mutee, %User{} = mutee} <- {:mutee, User.get_by_id(mutee_id)} do
1401 unmute(muter, mutee)
1403 {who, result} = error ->
1405 "User.unmute/2 failed. #{who}: #{result}, muter_id: #{muter_id}, mutee_id: #{mutee_id}"
1412 def subscribe(%User{} = subscriber, %User{} = target) do
1413 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
1415 if blocks?(target, subscriber) and deny_follow_blocked do
1416 {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1418 # Note: the relationship is inverse: subscriber acts as relationship target
1419 UserRelationship.create_inverse_subscription(target, subscriber)
1423 def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1424 with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1425 subscribe(subscriber, subscribee)
1429 def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1430 # Note: the relationship is inverse: subscriber acts as relationship target
1431 UserRelationship.delete_inverse_subscription(target, unsubscriber)
1434 def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1435 with %User{} = user <- get_cached_by_ap_id(ap_id) do
1436 unsubscribe(unsubscriber, user)
1440 def block(%User{} = blocker, %User{} = blocked) do
1441 # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1443 if following?(blocker, blocked) do
1444 {:ok, blocker, _} = unfollow(blocker, blocked)
1450 # clear any requested follows as well
1452 case CommonAPI.reject_follow_request(blocked, blocker) do
1453 {:ok, %User{} = updated_blocked} -> updated_blocked
1457 unsubscribe(blocked, blocker)
1459 unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
1460 if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)
1462 {:ok, blocker} = update_follower_count(blocker)
1463 {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1464 add_to_block(blocker, blocked)
1467 # helper to handle the block given only an actor's AP id
1468 def block(%User{} = blocker, %{ap_id: ap_id}) do
1469 block(blocker, get_cached_by_ap_id(ap_id))
1472 def unblock(%User{} = blocker, %User{} = blocked) do
1473 remove_from_block(blocker, blocked)
1476 # helper to handle the block given only an actor's AP id
1477 def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1478 unblock(blocker, get_cached_by_ap_id(ap_id))
1481 def mutes?(nil, _), do: false
1482 def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1484 def mutes_user?(%User{} = user, %User{} = target) do
1485 UserRelationship.mute_exists?(user, target)
1488 @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1489 def muted_notifications?(nil, _), do: false
1491 def muted_notifications?(%User{} = user, %User{} = target),
1492 do: UserRelationship.notification_mute_exists?(user, target)
1494 def blocks?(nil, _), do: false
1496 def blocks?(%User{} = user, %User{} = target) do
1497 blocks_user?(user, target) ||
1498 (blocks_domain?(user, target) and not User.following?(user, target))
1501 def blocks_user?(%User{} = user, %User{} = target) do
1502 UserRelationship.block_exists?(user, target)
1505 def blocks_user?(_, _), do: false
1507 def blocks_domain?(%User{} = user, %User{} = target) do
1508 domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1509 %{host: host} = URI.parse(target.ap_id)
1510 Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1513 def blocks_domain?(_, _), do: false
1515 def subscribed_to?(%User{} = user, %User{} = target) do
1516 # Note: the relationship is inverse: subscriber acts as relationship target
1517 UserRelationship.inverse_subscription_exists?(target, user)
1520 def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1521 with %User{} = target <- get_cached_by_ap_id(ap_id) do
1522 subscribed_to?(user, target)
1527 Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1528 E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1530 @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1531 def outgoing_relationships_ap_ids(_user, []), do: %{}
1533 def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1535 def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1536 when is_list(relationship_types) do
1539 |> assoc(:outgoing_relationships)
1540 |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1541 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1542 |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1543 |> group_by([user_rel, u], user_rel.relationship_type)
1545 |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1550 fn rel_type -> {rel_type, db_result[rel_type] || []} end
1554 def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1556 def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1558 def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1560 def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1561 when is_list(relationship_types) do
1563 |> assoc(:incoming_relationships)
1564 |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1565 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1566 |> maybe_filter_on_ap_id(ap_ids)
1567 |> select([user_rel, u], u.ap_id)
1572 defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1573 where(query, [user_rel, u], u.ap_id in ^ap_ids)
1576 defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1578 def set_activation_async(user, status \\ true) do
1579 BackgroundWorker.enqueue("user_activation", %{"user_id" => user.id, "status" => status})
1582 @spec set_activation([User.t()], boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
1583 def set_activation(users, status) when is_list(users) do
1584 Repo.transaction(fn ->
1585 for user <- users, do: set_activation(user, status)
1589 @spec set_activation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
1590 def set_activation(%User{} = user, status) do
1591 with {:ok, user} <- set_activation_status(user, status) do
1594 |> Enum.filter(& &1.local)
1595 |> Enum.each(&set_cache(update_following_count(&1)))
1597 # Only update local user counts, remote will be update during the next pull.
1600 |> Enum.filter(& &1.local)
1601 |> Enum.each(&do_unfollow(user, &1))
1607 def approve(users) when is_list(users) do
1608 Repo.transaction(fn ->
1609 Enum.map(users, fn user ->
1610 with {:ok, user} <- approve(user), do: user
1615 def approve(%User{is_approved: false} = user) do
1616 with chg <- change(user, is_approved: true),
1617 {:ok, user} <- update_and_set_cache(chg) do
1618 post_register_action(user)
1623 def approve(%User{} = user), do: {:ok, user}
1625 def confirm(users) when is_list(users) do
1626 Repo.transaction(fn ->
1627 Enum.map(users, fn user ->
1628 with {:ok, user} <- confirm(user), do: user
1633 def confirm(%User{is_confirmed: false} = user) do
1634 with chg <- confirmation_changeset(user, set_confirmation: true),
1635 {:ok, user} <- update_and_set_cache(chg) do
1636 post_register_action(user)
1641 def confirm(%User{} = user), do: {:ok, user}
1643 def update_notification_settings(%User{} = user, settings) do
1645 |> cast(%{notification_settings: settings}, [])
1646 |> cast_embed(:notification_settings)
1647 |> validate_required([:notification_settings])
1648 |> update_and_set_cache()
1651 @spec purge_user_changeset(User.t()) :: Changeset.t()
1652 def purge_user_changeset(user) do
1653 # "Right to be forgotten"
1654 # https://gdpr.eu/right-to-be-forgotten/
1665 last_refreshed_at: nil,
1666 last_digest_emailed_at: nil,
1674 password_reset_pending: false,
1676 registration_reason: nil,
1677 confirmation_token: nil,
1681 is_moderator: false,
1683 mastofe_settings: nil,
1686 pleroma_settings_store: %{},
1689 is_discoverable: false,
1694 def delete(users) when is_list(users) do
1695 for user <- users, do: delete(user)
1698 def delete(%User{} = user) do
1699 BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1702 defp delete_and_invalidate_cache(%User{} = user) do
1703 invalidate_cache(user)
1707 defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)
1709 defp delete_or_deactivate(%User{local: true} = user) do
1710 status = account_status(user)
1713 :confirmation_pending ->
1714 delete_and_invalidate_cache(user)
1716 :approval_pending ->
1717 delete_and_invalidate_cache(user)
1721 |> purge_user_changeset()
1722 |> update_and_set_cache()
1726 def perform(:force_password_reset, user), do: force_password_reset(user)
1728 @spec perform(atom(), User.t()) :: {:ok, User.t()}
1729 def perform(:delete, %User{} = user) do
1730 # Remove all relationships
1733 |> Enum.each(fn follower ->
1734 ActivityPub.unfollow(follower, user)
1735 unfollow(follower, user)
1740 |> Enum.each(fn followed ->
1741 ActivityPub.unfollow(user, followed)
1742 unfollow(user, followed)
1745 delete_user_activities(user)
1746 delete_notifications_from_user_activities(user)
1748 delete_outgoing_pending_follow_requests(user)
1750 delete_or_deactivate(user)
1753 def perform(:set_activation_async, user, status), do: set_activation(user, status)
1755 @spec external_users_query() :: Ecto.Query.t()
1756 def external_users_query do
1764 @spec external_users(keyword()) :: [User.t()]
1765 def external_users(opts \\ []) do
1767 external_users_query()
1768 |> select([u], struct(u, [:id, :ap_id]))
1772 do: where(query, [u], u.id > ^opts[:max_id]),
1777 do: limit(query, ^opts[:limit]),
1783 def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1785 |> join(:inner, [n], activity in assoc(n, :activity))
1786 |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1787 |> Repo.delete_all()
1790 def delete_user_activities(%User{ap_id: ap_id} = user) do
1792 |> Activity.Queries.by_actor()
1793 |> Repo.chunk_stream(50, :batches)
1794 |> Stream.each(fn activities ->
1795 Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1800 defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1801 with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1802 {:ok, delete_data, _} <- Builder.delete(user, object) do
1803 Pipeline.common_pipeline(delete_data, local: user.local)
1805 {:find_object, nil} ->
1806 # We have the create activity, but not the object, it was probably pruned.
1807 # Insert a tombstone and try again
1808 with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1809 {:ok, _tombstone} <- Object.create(tombstone_data) do
1810 delete_activity(activity, user)
1814 Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1815 Logger.error("Error: #{inspect(e)}")
1819 defp delete_activity(%{data: %{"type" => type}} = activity, user)
1820 when type in ["Like", "Announce"] do
1821 {:ok, undo, _} = Builder.undo(user, activity)
1822 Pipeline.common_pipeline(undo, local: user.local)
1825 defp delete_activity(_activity, _user), do: "Doing nothing"
1827 defp delete_outgoing_pending_follow_requests(user) do
1829 |> FollowingRelationship.outgoing_pending_follow_requests_query()
1830 |> Repo.delete_all()
1833 def html_filter_policy(%User{no_rich_text: true}) do
1834 Pleroma.HTML.Scrubber.TwitterText
1837 def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])
1839 def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1841 def get_or_fetch_by_ap_id(ap_id) do
1842 cached_user = get_cached_by_ap_id(ap_id)
1844 maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)
1846 case {cached_user, maybe_fetched_user} do
1847 {_, {:ok, %User{} = user}} ->
1850 {%User{} = user, _} ->
1854 {:error, :not_found}
1859 Creates an internal service actor by URI if missing.
1860 Optionally takes nickname for addressing.
1862 @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1863 def get_or_create_service_actor_by_ap_id(uri, nickname) do
1865 case get_cached_by_ap_id(uri) do
1867 with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1868 Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1872 %User{invisible: false} = user ->
1882 @spec set_invisible(User.t()) :: {:ok, User.t()}
1883 defp set_invisible(user) do
1885 |> change(%{invisible: true})
1886 |> update_and_set_cache()
1889 @spec create_service_actor(String.t(), String.t()) ::
1890 {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1891 defp create_service_actor(uri, nickname) do
1897 follower_address: uri <> "/followers"
1900 |> unique_constraint(:nickname)
1905 def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1908 |> :public_key.pem_decode()
1910 |> :public_key.pem_entry_decode()
1915 def public_key(_), do: {:error, "key not found"}
1917 def get_public_key_for_ap_id(ap_id) do
1918 with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1919 {:ok, public_key} <- public_key(user) do
1926 def ap_enabled?(%User{local: true}), do: true
1927 def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1928 def ap_enabled?(_), do: false
1930 @doc "Gets or fetch a user by uri or nickname."
1931 @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1932 def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1933 def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1935 # wait a period of time and return newest version of the User structs
1936 # this is because we have synchronous follow APIs and need to simulate them
1937 # with an async handshake
1938 def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1939 with %User{} = a <- get_cached_by_id(a.id),
1940 %User{} = b <- get_cached_by_id(b.id) do
1947 def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1948 with :ok <- :timer.sleep(timeout),
1949 %User{} = a <- get_cached_by_id(a.id),
1950 %User{} = b <- get_cached_by_id(b.id) do
1957 def parse_bio(bio) when is_binary(bio) and bio != "" do
1959 |> CommonUtils.format_input("text/plain", mentions_format: :full)
1963 def parse_bio(_), do: ""
1965 def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1966 # TODO: get profile URLs other than user.ap_id
1967 profile_urls = [user.ap_id]
1970 |> CommonUtils.format_input("text/plain",
1971 mentions_format: :full,
1972 rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1977 def parse_bio(_, _), do: ""
1979 def tag(user_identifiers, tags) when is_list(user_identifiers) do
1980 Repo.transaction(fn ->
1981 for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1985 def tag(nickname, tags) when is_binary(nickname),
1986 do: tag(get_by_nickname(nickname), tags)
1988 def tag(%User{} = user, tags),
1989 do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1991 def untag(user_identifiers, tags) when is_list(user_identifiers) do
1992 Repo.transaction(fn ->
1993 for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1997 def untag(nickname, tags) when is_binary(nickname),
1998 do: untag(get_by_nickname(nickname), tags)
2000 def untag(%User{} = user, tags),
2001 do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
2003 defp update_tags(%User{} = user, new_tags) do
2004 {:ok, updated_user} =
2006 |> change(%{tags: new_tags})
2007 |> update_and_set_cache()
2012 defp normalize_tags(tags) do
2015 |> Enum.map(&String.downcase/1)
2018 defp local_nickname_regex do
2019 if Config.get([:instance, :extended_nickname_format]) do
2020 @extended_local_nickname_regex
2022 @strict_local_nickname_regex
2026 def local_nickname(nickname_or_mention) do
2029 |> String.split("@")
2033 def full_nickname(nickname_or_mention),
2034 do: String.trim_leading(nickname_or_mention, "@")
2036 def error_user(ap_id) do
2040 nickname: "erroruser@example.com",
2041 inserted_at: NaiveDateTime.utc_now()
2045 @spec all_superusers() :: [User.t()]
2046 def all_superusers do
2047 User.Query.build(%{super_users: true, local: true, is_active: true})
2051 def muting_reblogs?(%User{} = user, %User{} = target) do
2052 UserRelationship.reblog_mute_exists?(user, target)
2055 def showing_reblogs?(%User{} = user, %User{} = target) do
2056 not muting_reblogs?(user, target)
2060 The function returns a query to get users with no activity for given interval of days.
2061 Inactive users are those who didn't read any notification, or had any activity where
2062 the user is the activity's actor, during `inactivity_threshold` days.
2063 Deactivated users will not appear in this list.
2067 iex> Pleroma.User.list_inactive_users()
2070 @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
2071 def list_inactive_users_query(inactivity_threshold \\ 7) do
2072 negative_inactivity_threshold = -inactivity_threshold
2073 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2074 # Subqueries are not supported in `where` clauses, join gets too complicated.
2075 has_read_notifications =
2076 from(n in Pleroma.Notification,
2077 where: n.seen == true,
2079 having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
2082 |> Pleroma.Repo.all()
2084 from(u in Pleroma.User,
2085 left_join: a in Pleroma.Activity,
2086 on: u.ap_id == a.actor,
2087 where: not is_nil(u.nickname),
2088 where: u.is_active == ^true,
2089 where: u.id not in ^has_read_notifications,
2092 max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
2093 is_nil(max(a.inserted_at))
2098 Enable or disable email notifications for user
2102 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
2103 Pleroma.User{email_notifications: %{"digest" => true}}
2105 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
2106 Pleroma.User{email_notifications: %{"digest" => false}}
2108 @spec switch_email_notifications(t(), String.t(), boolean()) ::
2109 {:ok, t()} | {:error, Ecto.Changeset.t()}
2110 def switch_email_notifications(user, type, status) do
2111 User.update_email_notifications(user, %{type => status})
2115 Set `last_digest_emailed_at` value for the user to current time
2117 @spec touch_last_digest_emailed_at(t()) :: t()
2118 def touch_last_digest_emailed_at(user) do
2119 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2121 {:ok, updated_user} =
2123 |> change(%{last_digest_emailed_at: now})
2124 |> update_and_set_cache()
2129 @spec set_confirmation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
2130 def set_confirmation(%User{} = user, bool) do
2132 |> confirmation_changeset(set_confirmation: bool)
2133 |> update_and_set_cache()
2136 def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
2140 def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
2141 # use instance-default
2142 config = Config.get([:assets, :mascots])
2143 default_mascot = Config.get([:assets, :default_mascot])
2144 mascot = Keyword.get(config, default_mascot)
2147 "id" => "default-mascot",
2148 "url" => mascot[:url],
2149 "preview_url" => mascot[:url],
2151 "mime_type" => mascot[:mime_type]
2156 def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
2158 def ensure_keys_present(%User{} = user) do
2159 with {:ok, pem} <- Keys.generate_rsa_pem() do
2161 |> cast(%{keys: pem}, [:keys])
2162 |> validate_required([:keys])
2163 |> update_and_set_cache()
2167 def get_ap_ids_by_nicknames(nicknames) do
2169 where: u.nickname in ^nicknames,
2175 defp put_password_hash(
2176 %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2178 change(changeset, password_hash: Pleroma.Password.Pbkdf2.hash_pwd_salt(password))
2181 defp put_password_hash(changeset), do: changeset
2183 def is_internal_user?(%User{nickname: nil}), do: true
2184 def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2185 def is_internal_user?(_), do: false
2187 # A hack because user delete activities have a fake id for whatever reason
2188 # TODO: Get rid of this
2189 def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2191 def get_delivered_users_by_object_id(object_id) do
2193 inner_join: delivery in assoc(u, :deliveries),
2194 where: delivery.object_id == ^object_id
2199 def change_email(user, email) do
2201 |> cast(%{email: email}, [:email])
2202 |> validate_required([:email])
2203 |> unique_constraint(:email)
2204 |> validate_format(:email, @email_regex)
2205 |> update_and_set_cache()
2208 # Internal function; public one is `deactivate/2`
2209 defp set_activation_status(user, status) do
2211 |> cast(%{is_active: status}, [:is_active])
2212 |> update_and_set_cache()
2215 def update_banner(user, banner) do
2217 |> cast(%{banner: banner}, [:banner])
2218 |> update_and_set_cache()
2221 def update_background(user, background) do
2223 |> cast(%{background: background}, [:background])
2224 |> update_and_set_cache()
2227 def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
2230 moderator: is_moderator
2234 def validate_fields(changeset, remote? \\ false) do
2235 limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2236 limit = Config.get([:instance, limit_name], 0)
2239 |> validate_length(:fields, max: limit)
2240 |> validate_change(:fields, fn :fields, fields ->
2241 if Enum.all?(fields, &valid_field?/1) do
2249 defp valid_field?(%{"name" => name, "value" => value}) do
2250 name_limit = Config.get([:instance, :account_field_name_length], 255)
2251 value_limit = Config.get([:instance, :account_field_value_length], 255)
2253 is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2254 String.length(value) <= value_limit
2257 defp valid_field?(_), do: false
2259 defp truncate_field(%{"name" => name, "value" => value}) do
2261 String.split_at(name, Config.get([:instance, :account_field_name_length], 255))
2264 String.split_at(value, Config.get([:instance, :account_field_value_length], 255))
2266 %{"name" => name, "value" => value}
2269 def admin_api_update(user, params) do
2276 |> update_and_set_cache()
2279 @doc "Signs user out of all applications"
2280 def global_sign_out(user) do
2281 OAuth.Authorization.delete_user_authorizations(user)
2282 OAuth.Token.delete_user_tokens(user)
2285 def mascot_update(user, url) do
2287 |> cast(%{mascot: url}, [:mascot])
2288 |> validate_required([:mascot])
2289 |> update_and_set_cache()
2292 def mastodon_settings_update(user, settings) do
2294 |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
2295 |> validate_required([:mastofe_settings])
2296 |> update_and_set_cache()
2299 @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2300 def confirmation_changeset(user, set_confirmation: confirmed?) do
2305 confirmation_token: nil
2309 is_confirmed: false,
2310 confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2314 cast(user, params, [:is_confirmed, :confirmation_token])
2317 @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
2318 def approval_changeset(user, set_approval: approved?) do
2319 cast(user, %{is_approved: approved?}, [:is_approved])
2322 def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2323 if id not in user.pinned_activities do
2324 max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2325 params = %{pinned_activities: user.pinned_activities ++ [id]}
2327 # if pinned activity was scheduled for deletion, we remove job
2328 if expiration = Pleroma.Workers.PurgeExpiredActivity.get_expiration(id) do
2329 Oban.cancel_job(expiration.id)
2333 |> cast(params, [:pinned_activities])
2334 |> validate_length(:pinned_activities,
2335 max: max_pinned_statuses,
2336 message: "You have already pinned the maximum number of statuses"
2341 |> update_and_set_cache()
2344 def remove_pinnned_activity(user, %Pleroma.Activity{id: id, data: data}) do
2345 params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2347 # if pinned activity was scheduled for deletion, we reschedule it for deletion
2348 if data["expires_at"] do
2349 # MRF.ActivityExpirationPolicy used UTC timestamps for expires_at in original implementation
2351 data["expires_at"] |> Pleroma.EctoType.ActivityPub.ObjectValidators.DateTime.cast()
2353 Pleroma.Workers.PurgeExpiredActivity.enqueue(%{
2355 expires_at: expires_at
2360 |> cast(params, [:pinned_activities])
2361 |> update_and_set_cache()
2364 def update_email_notifications(user, settings) do
2365 email_notifications =
2366 user.email_notifications
2367 |> Map.merge(settings)
2368 |> Map.take(["digest"])
2370 params = %{email_notifications: email_notifications}
2371 fields = [:email_notifications]
2374 |> cast(params, fields)
2375 |> validate_required(fields)
2376 |> update_and_set_cache()
2379 defp set_domain_blocks(user, domain_blocks) do
2380 params = %{domain_blocks: domain_blocks}
2383 |> cast(params, [:domain_blocks])
2384 |> validate_required([:domain_blocks])
2385 |> update_and_set_cache()
2388 def block_domain(user, domain_blocked) do
2389 set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2392 def unblock_domain(user, domain_blocked) do
2393 set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2396 @spec add_to_block(User.t(), User.t()) ::
2397 {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2398 defp add_to_block(%User{} = user, %User{} = blocked) do
2399 with {:ok, relationship} <- UserRelationship.create_block(user, blocked) do
2400 @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
2405 @spec add_to_block(User.t(), User.t()) ::
2406 {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2407 defp remove_from_block(%User{} = user, %User{} = blocked) do
2408 with {:ok, relationship} <- UserRelationship.delete_block(user, blocked) do
2409 @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
2414 def set_invisible(user, invisible) do
2415 params = %{invisible: invisible}
2418 |> cast(params, [:invisible])
2419 |> validate_required([:invisible])
2420 |> update_and_set_cache()
2423 def sanitize_html(%User{} = user) do
2424 sanitize_html(user, nil)
2427 # User data that mastodon isn't filtering (treated as plaintext):
2430 def sanitize_html(%User{} = user, filter) do
2432 Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2435 "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2440 |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2441 |> Map.put(:fields, fields)
2444 def get_host(%User{ap_id: ap_id} = _user) do
2445 URI.parse(ap_id).host