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(:confirmation_pending, :boolean, default: false)
114 field(:password_reset_pending, :boolean, default: false)
115 field(:approval_pending, :boolean, default: false)
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, approval_pending: true}), do: :approval_pending
294 def account_status(%User{local: true, confirmation_pending: true}) do
295 if Config.get([:instance, :account_activation_required]) do
296 :confirmation_pending
302 def account_status(%User{}), do: :active
304 @spec visible_for(User.t(), User.t() | nil) ::
307 | :restricted_unauthenticated
309 | :confirmation_pending
310 def visible_for(user, for_user \\ nil)
312 def visible_for(%User{invisible: true}, _), do: :invisible
314 def visible_for(%User{id: user_id}, %User{id: user_id}), do: :visible
316 def visible_for(%User{} = user, nil) do
317 if restrict_unauthenticated?(user) do
318 :restrict_unauthenticated
320 visible_account_status(user)
324 def visible_for(%User{} = user, for_user) do
325 if superuser?(for_user) do
328 visible_account_status(user)
332 def visible_for(_, _), do: :invisible
334 defp restrict_unauthenticated?(%User{local: true}) do
335 Config.restrict_unauthenticated_access?(:profiles, :local)
338 defp restrict_unauthenticated?(%User{local: _}) do
339 Config.restrict_unauthenticated_access?(:profiles, :remote)
342 defp visible_account_status(user) do
343 status = account_status(user)
345 if status in [:active, :password_reset_pending] do
352 @spec superuser?(User.t()) :: boolean()
353 def superuser?(%User{local: true, is_admin: true}), do: true
354 def superuser?(%User{local: true, is_moderator: true}), do: true
355 def superuser?(_), do: false
357 @spec invisible?(User.t()) :: boolean()
358 def invisible?(%User{invisible: true}), do: true
359 def invisible?(_), do: false
361 def avatar_url(user, options \\ []) do
363 %{"url" => [%{"href" => href} | _]} ->
367 unless options[:no_default] do
368 Config.get([:assets, :default_user_avatar], "#{Web.base_url()}/images/avi.png")
373 def banner_url(user, options \\ []) do
375 %{"url" => [%{"href" => href} | _]} -> href
376 _ -> !options[:no_default] && "#{Web.base_url()}/images/banner.png"
380 # Should probably be renamed or removed
381 def ap_id(%User{nickname: nickname}), do: "#{Web.base_url()}/users/#{nickname}"
383 def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
384 def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"
386 @spec ap_following(User.t()) :: String.t()
387 def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
388 def ap_following(%User{} = user), do: "#{ap_id(user)}/following"
390 defp truncate_fields_param(params) do
391 if Map.has_key?(params, :fields) do
392 Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
398 defp truncate_if_exists(params, key, max_length) do
399 if Map.has_key?(params, key) and is_binary(params[key]) do
400 {value, _chopped} = String.split_at(params[key], max_length)
401 Map.put(params, key, value)
407 defp fix_follower_address(%{follower_address: _, following_address: _} = params), do: params
409 defp fix_follower_address(%{nickname: nickname} = params),
410 do: Map.put(params, :follower_address, ap_followers(%User{nickname: nickname}))
412 defp fix_follower_address(params), do: params
414 def remote_user_changeset(struct \\ %User{local: false}, params) do
415 bio_limit = Config.get([:instance, :user_bio_length], 5000)
416 name_limit = Config.get([:instance, :user_name_length], 100)
419 case params[:name] do
420 name when is_binary(name) and byte_size(name) > 0 -> name
421 _ -> params[:nickname]
426 |> Map.put(:name, name)
427 |> Map.put_new(:last_refreshed_at, NaiveDateTime.utc_now())
428 |> truncate_if_exists(:name, name_limit)
429 |> truncate_if_exists(:bio, bio_limit)
430 |> truncate_fields_param()
431 |> fix_follower_address()
454 :hide_followers_count,
463 :accepts_chat_messages
466 |> cast(params, [:name], empty_values: [])
467 |> validate_required([:ap_id])
468 |> validate_required([:name], trim: false)
469 |> unique_constraint(:nickname)
470 |> validate_format(:nickname, @email_regex)
471 |> validate_length(:bio, max: bio_limit)
472 |> validate_length(:name, max: name_limit)
473 |> validate_fields(true)
474 |> validate_non_local()
477 defp validate_non_local(cng) do
478 local? = get_field(cng, :local)
482 |> add_error(:local, "User is local, can't update with this changeset.")
488 def update_changeset(struct, params \\ %{}) do
489 bio_limit = Config.get([:instance, :user_bio_length], 5000)
490 name_limit = Config.get([:instance, :user_name_length], 100)
510 :hide_followers_count,
513 :allow_following_move,
517 :skip_thread_containment,
520 :pleroma_settings_store,
523 :accepts_chat_messages
526 |> unique_constraint(:nickname)
527 |> validate_format(:nickname, local_nickname_regex())
528 |> validate_length(:bio, max: bio_limit)
529 |> validate_length(:name, min: 1, max: name_limit)
530 |> validate_inclusion(:actor_type, ["Person", "Service"])
533 |> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
534 |> put_change_if_present(:avatar, &put_upload(&1, :avatar))
535 |> put_change_if_present(:banner, &put_upload(&1, :banner))
536 |> put_change_if_present(:background, &put_upload(&1, :background))
537 |> put_change_if_present(
538 :pleroma_settings_store,
539 &{:ok, Map.merge(struct.pleroma_settings_store, &1)}
541 |> validate_fields(false)
544 defp put_fields(changeset) do
545 if raw_fields = get_change(changeset, :raw_fields) do
548 |> Enum.filter(fn %{"name" => n} -> n != "" end)
552 |> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)
555 |> put_change(:raw_fields, raw_fields)
556 |> put_change(:fields, fields)
562 defp parse_fields(value) do
564 |> Formatter.linkify(mentions_format: :full)
568 defp put_emoji(changeset) do
569 emojified_fields = [:bio, :name, :raw_fields]
571 if Enum.any?(changeset.changes, fn {k, _} -> k in emojified_fields end) do
572 bio = Emoji.Formatter.get_emoji_map(get_field(changeset, :bio))
573 name = Emoji.Formatter.get_emoji_map(get_field(changeset, :name))
575 emoji = Map.merge(bio, name)
579 |> get_field(:raw_fields)
580 |> Enum.reduce(emoji, fn x, acc ->
581 Map.merge(acc, Emoji.Formatter.get_emoji_map(x["name"] <> x["value"]))
584 put_change(changeset, :emoji, emoji)
590 defp put_change_if_present(changeset, map_field, value_function) do
591 with {:ok, value} <- fetch_change(changeset, map_field),
592 {:ok, new_value} <- value_function.(value) do
593 put_change(changeset, map_field, new_value)
599 defp put_upload(value, type) do
600 with %Plug.Upload{} <- value,
601 {:ok, object} <- ActivityPub.upload(value, type: type) do
606 def update_as_admin_changeset(struct, params) do
608 |> update_changeset(params)
609 |> cast(params, [:email])
610 |> delete_change(:also_known_as)
611 |> unique_constraint(:email)
612 |> validate_format(:email, @email_regex)
613 |> validate_inclusion(:actor_type, ["Person", "Service"])
616 @spec update_as_admin(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
617 def update_as_admin(user, params) do
618 params = Map.put(params, "password_confirmation", params["password"])
619 changeset = update_as_admin_changeset(user, params)
621 if params["password"] do
622 reset_password(user, changeset, params)
624 User.update_and_set_cache(changeset)
628 def password_update_changeset(struct, params) do
630 |> cast(params, [:password, :password_confirmation])
631 |> validate_required([:password, :password_confirmation])
632 |> validate_confirmation(:password)
633 |> put_password_hash()
634 |> put_change(:password_reset_pending, false)
637 @spec reset_password(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
638 def reset_password(%User{} = user, params) do
639 reset_password(user, user, params)
642 def reset_password(%User{id: user_id} = user, struct, params) do
645 |> Multi.update(:user, password_update_changeset(struct, params))
646 |> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
647 |> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))
649 case Repo.transaction(multi) do
650 {:ok, %{user: user} = _} -> set_cache(user)
651 {:error, _, changeset, _} -> {:error, changeset}
655 def update_password_reset_pending(user, value) do
658 |> put_change(:password_reset_pending, value)
659 |> update_and_set_cache()
662 def force_password_reset_async(user) do
663 BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
666 @spec force_password_reset(User.t()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
667 def force_password_reset(user), do: update_password_reset_pending(user, true)
669 # Used to auto-register LDAP accounts which won't have a password hash stored locally
670 def register_changeset_ldap(struct, params = %{password: password})
671 when is_nil(password) do
672 params = Map.put_new(params, :accepts_chat_messages, true)
675 if Map.has_key?(params, :email) do
676 Map.put_new(params, :email, params[:email])
686 :accepts_chat_messages
688 |> validate_required([:name, :nickname])
689 |> unique_constraint(:nickname)
690 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
691 |> validate_format(:nickname, local_nickname_regex())
693 |> unique_constraint(:ap_id)
694 |> put_following_and_follower_address()
697 def register_changeset(struct, params \\ %{}, opts \\ []) do
698 bio_limit = Config.get([:instance, :user_bio_length], 5000)
699 name_limit = Config.get([:instance, :user_name_length], 100)
700 reason_limit = Config.get([:instance, :registration_reason_length], 500)
701 params = Map.put_new(params, :accepts_chat_messages, true)
704 if is_nil(opts[:need_confirmation]) do
705 Config.get([:instance, :account_activation_required])
707 opts[:need_confirmation]
711 if is_nil(opts[:need_approval]) do
712 Config.get([:instance, :account_approval_required])
718 |> confirmation_changeset(need_confirmation: need_confirmation?)
719 |> approval_changeset(need_approval: need_approval?)
727 :password_confirmation,
729 :accepts_chat_messages,
732 |> validate_required([:name, :nickname, :password, :password_confirmation])
733 |> validate_confirmation(:password)
734 |> unique_constraint(:email)
735 |> validate_format(:email, @email_regex)
736 |> validate_change(:email, fn :email, email ->
738 Config.get([User, :email_blacklist])
739 |> Enum.all?(fn blacklisted_domain ->
740 !String.ends_with?(email, ["@" <> blacklisted_domain, "." <> blacklisted_domain])
743 if valid?, do: [], else: [email: "Invalid email"]
745 |> unique_constraint(:nickname)
746 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
747 |> validate_format(:nickname, local_nickname_regex())
748 |> validate_length(:bio, max: bio_limit)
749 |> validate_length(:name, min: 1, max: name_limit)
750 |> validate_length(:registration_reason, max: reason_limit)
751 |> maybe_validate_required_email(opts[:external])
754 |> unique_constraint(:ap_id)
755 |> put_following_and_follower_address()
758 def maybe_validate_required_email(changeset, true), do: changeset
760 def maybe_validate_required_email(changeset, _) do
761 if Config.get([:instance, :account_activation_required]) do
762 validate_required(changeset, [:email])
768 defp put_ap_id(changeset) do
769 ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
770 put_change(changeset, :ap_id, ap_id)
773 defp put_following_and_follower_address(changeset) do
774 followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
777 |> put_change(:follower_address, followers)
780 defp autofollow_users(user) do
781 candidates = Config.get([:instance, :autofollowed_nicknames])
784 User.Query.build(%{nickname: candidates, local: true, is_active: true})
787 follow_all(user, autofollowed_users)
790 defp autofollowing_users(user) do
791 candidates = Config.get([:instance, :autofollowing_nicknames])
793 User.Query.build(%{nickname: candidates, local: true, deactivated: false})
795 |> Enum.each(&follow(&1, user, :follow_accept))
800 @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
801 def register(%Ecto.Changeset{} = changeset) do
802 with {:ok, user} <- Repo.insert(changeset) do
803 post_register_action(user)
807 def post_register_action(%User{confirmation_pending: true} = user) do
808 with {:ok, _} <- try_send_confirmation_email(user) do
813 def post_register_action(%User{approval_pending: true} = user) do
814 with {:ok, _} <- send_user_approval_email(user),
815 {:ok, _} <- send_admin_approval_emails(user) do
820 def post_register_action(%User{approval_pending: false, confirmation_pending: false} = user) do
821 with {:ok, user} <- autofollow_users(user),
822 {:ok, _} <- autofollowing_users(user),
823 {:ok, user} <- set_cache(user),
824 {:ok, _} <- send_welcome_email(user),
825 {:ok, _} <- send_welcome_message(user),
826 {:ok, _} <- send_welcome_chat_message(user) do
831 defp send_user_approval_email(user) do
833 |> Pleroma.Emails.UserEmail.approval_pending_email()
834 |> Pleroma.Emails.Mailer.deliver_async()
839 defp send_admin_approval_emails(user) do
841 |> Enum.filter(fn user -> not is_nil(user.email) end)
842 |> Enum.each(fn superuser ->
844 |> Pleroma.Emails.AdminEmail.new_unapproved_registration(user)
845 |> Pleroma.Emails.Mailer.deliver_async()
851 def send_welcome_message(user) do
852 if User.WelcomeMessage.enabled?() do
853 User.WelcomeMessage.post_message(user)
860 def send_welcome_chat_message(user) do
861 if User.WelcomeChatMessage.enabled?() do
862 User.WelcomeChatMessage.post_message(user)
869 def send_welcome_email(%User{email: email} = user) when is_binary(email) do
870 if User.WelcomeEmail.enabled?() do
871 User.WelcomeEmail.send_email(user)
878 def send_welcome_email(_), do: {:ok, :noop}
880 @spec try_send_confirmation_email(User.t()) :: {:ok, :enqueued | :noop}
881 def try_send_confirmation_email(%User{confirmation_pending: true, email: email} = user)
882 when is_binary(email) do
883 if Config.get([:instance, :account_activation_required]) do
884 send_confirmation_email(user)
891 def try_send_confirmation_email(_), do: {:ok, :noop}
893 @spec send_confirmation_email(Uset.t()) :: User.t()
894 def send_confirmation_email(%User{} = user) do
896 |> Pleroma.Emails.UserEmail.account_confirmation_email()
897 |> Pleroma.Emails.Mailer.deliver_async()
902 def needs_update?(%User{local: true}), do: false
904 def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
906 def needs_update?(%User{local: false} = user) do
907 NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
910 def needs_update?(_), do: true
912 @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
914 # "Locked" (self-locked) users demand explicit authorization of follow requests
915 def maybe_direct_follow(%User{} = follower, %User{local: true, is_locked: true} = followed) do
916 follow(follower, followed, :follow_pending)
919 def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
920 follow(follower, followed)
923 def maybe_direct_follow(%User{} = follower, %User{} = followed) do
924 if not ap_enabled?(followed) do
925 follow(follower, followed)
927 {:ok, follower, followed}
931 @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
932 @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
933 def follow_all(follower, followeds) do
935 |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
936 |> Enum.each(&follow(follower, &1, :follow_accept))
941 def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
942 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
945 followed.is_active == false ->
946 {:error, "Could not follow user: #{followed.nickname} is deactivated."}
948 deny_follow_blocked and blocks?(followed, follower) ->
949 {:error, "Could not follow user: #{followed.nickname} blocked you."}
952 FollowingRelationship.follow(follower, followed, state)
956 def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
957 {:error, "Not subscribed!"}
960 @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
961 def unfollow(%User{} = follower, %User{} = followed) do
962 case do_unfollow(follower, followed) do
963 {:ok, follower, followed} ->
964 {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
971 @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
972 defp do_unfollow(%User{} = follower, %User{} = followed) do
973 case get_follow_state(follower, followed) do
974 state when state in [:follow_pending, :follow_accept] ->
975 FollowingRelationship.unfollow(follower, followed)
978 {:error, "Not subscribed!"}
982 @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
983 def get_follow_state(%User{} = follower, %User{} = following) do
984 following_relationship = FollowingRelationship.get(follower, following)
985 get_follow_state(follower, following, following_relationship)
988 def get_follow_state(
991 following_relationship
993 case {following_relationship, following.local} do
995 case Utils.fetch_latest_follow(follower, following) do
996 %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
997 FollowingRelationship.state_to_enum(state)
1003 {%{state: state}, _} ->
1011 def locked?(%User{} = user) do
1012 user.is_locked || false
1015 def get_by_id(id) do
1016 Repo.get_by(User, id: id)
1019 def get_by_ap_id(ap_id) do
1020 Repo.get_by(User, ap_id: ap_id)
1023 def get_all_by_ap_id(ap_ids) do
1024 from(u in __MODULE__,
1025 where: u.ap_id in ^ap_ids
1030 def get_all_by_ids(ids) do
1031 from(u in __MODULE__, where: u.id in ^ids)
1035 # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
1036 # of the ap_id and the domain and tries to get that user
1037 def get_by_guessed_nickname(ap_id) do
1038 domain = URI.parse(ap_id).host
1039 name = List.last(String.split(ap_id, "/"))
1040 nickname = "#{name}@#{domain}"
1042 get_cached_by_nickname(nickname)
1045 def set_cache({:ok, user}), do: set_cache(user)
1046 def set_cache({:error, err}), do: {:error, err}
1048 def set_cache(%User{} = user) do
1049 @cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1050 @cachex.put(:user_cache, "nickname:#{user.nickname}", user)
1051 @cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
1055 def update_and_set_cache(struct, params) do
1057 |> update_changeset(params)
1058 |> update_and_set_cache()
1061 def update_and_set_cache(changeset) do
1062 with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
1067 def get_user_friends_ap_ids(user) do
1068 from(u in User.get_friends_query(user), select: u.ap_id)
1072 @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
1073 def get_cached_user_friends_ap_ids(user) do
1074 @cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
1075 get_user_friends_ap_ids(user)
1079 def invalidate_cache(user) do
1080 @cachex.del(:user_cache, "ap_id:#{user.ap_id}")
1081 @cachex.del(:user_cache, "nickname:#{user.nickname}")
1082 @cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
1083 @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
1084 @cachex.del(:user_cache, "muted_users_ap_ids:#{user.ap_id}")
1087 @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
1088 def get_cached_by_ap_id(ap_id) do
1089 key = "ap_id:#{ap_id}"
1091 with {:ok, nil} <- @cachex.get(:user_cache, key),
1092 user when not is_nil(user) <- get_by_ap_id(ap_id),
1093 {:ok, true} <- @cachex.put(:user_cache, key, user) do
1101 def get_cached_by_id(id) do
1105 @cachex.fetch!(:user_cache, key, fn _ ->
1106 user = get_by_id(id)
1109 @cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1110 {:commit, user.ap_id}
1116 get_cached_by_ap_id(ap_id)
1119 def get_cached_by_nickname(nickname) do
1120 key = "nickname:#{nickname}"
1122 @cachex.fetch!(:user_cache, key, fn _ ->
1123 case get_or_fetch_by_nickname(nickname) do
1124 {:ok, user} -> {:commit, user}
1125 {:error, _error} -> {:ignore, nil}
1130 def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
1131 restrict_to_local = Config.get([:instance, :limit_to_local_content])
1134 is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
1135 get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
1137 restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
1138 get_cached_by_nickname(nickname_or_id)
1140 restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
1141 get_cached_by_nickname(nickname_or_id)
1148 @spec get_by_nickname(String.t()) :: User.t() | nil
1149 def get_by_nickname(nickname) do
1150 Repo.get_by(User, nickname: nickname) ||
1151 if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
1152 Repo.get_by(User, nickname: local_nickname(nickname))
1156 def get_by_email(email), do: Repo.get_by(User, email: email)
1158 def get_by_nickname_or_email(nickname_or_email) do
1159 get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
1162 def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
1164 def get_or_fetch_by_nickname(nickname) do
1165 with %User{} = user <- get_by_nickname(nickname) do
1169 with [_nick, _domain] <- String.split(nickname, "@"),
1170 {:ok, user} <- fetch_by_nickname(nickname) do
1173 _e -> {:error, "not found " <> nickname}
1178 @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1179 def get_followers_query(%User{} = user, nil) do
1180 User.Query.build(%{followers: user, is_active: true})
1183 def get_followers_query(%User{} = user, page) do
1185 |> get_followers_query(nil)
1186 |> User.Query.paginate(page, 20)
1189 @spec get_followers_query(User.t()) :: Ecto.Query.t()
1190 def get_followers_query(%User{} = user), do: get_followers_query(user, nil)
1192 @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1193 def get_followers(%User{} = user, page \\ nil) do
1195 |> get_followers_query(page)
1199 @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1200 def get_external_followers(%User{} = user, page \\ nil) do
1202 |> get_followers_query(page)
1203 |> User.Query.build(%{external: true})
1207 def get_followers_ids(%User{} = user, page \\ nil) do
1209 |> get_followers_query(page)
1210 |> select([u], u.id)
1214 @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1215 def get_friends_query(%User{} = user, nil) do
1216 User.Query.build(%{friends: user, deactivated: false})
1219 def get_friends_query(%User{} = user, page) do
1221 |> get_friends_query(nil)
1222 |> User.Query.paginate(page, 20)
1225 @spec get_friends_query(User.t()) :: Ecto.Query.t()
1226 def get_friends_query(%User{} = user), do: get_friends_query(user, nil)
1228 def get_friends(%User{} = user, page \\ nil) do
1230 |> get_friends_query(page)
1234 def get_friends_ap_ids(%User{} = user) do
1236 |> get_friends_query(nil)
1237 |> select([u], u.ap_id)
1241 def get_friends_ids(%User{} = user, page \\ nil) do
1243 |> get_friends_query(page)
1244 |> select([u], u.id)
1248 def increase_note_count(%User{} = user) do
1250 |> where(id: ^user.id)
1251 |> update([u], inc: [note_count: 1])
1253 |> Repo.update_all([])
1255 {1, [user]} -> set_cache(user)
1260 def decrease_note_count(%User{} = user) do
1262 |> where(id: ^user.id)
1265 note_count: fragment("greatest(0, note_count - 1)")
1269 |> Repo.update_all([])
1271 {1, [user]} -> set_cache(user)
1276 def update_note_count(%User{} = user, note_count \\ nil) do
1281 where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1287 |> cast(%{note_count: note_count}, [:note_count])
1288 |> update_and_set_cache()
1291 @spec maybe_fetch_follow_information(User.t()) :: User.t()
1292 def maybe_fetch_follow_information(user) do
1293 with {:ok, user} <- fetch_follow_information(user) do
1297 Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1303 def fetch_follow_information(user) do
1304 with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1306 |> follow_information_changeset(info)
1307 |> update_and_set_cache()
1311 defp follow_information_changeset(user, params) do
1318 :hide_followers_count,
1323 @spec update_follower_count(User.t()) :: {:ok, User.t()}
1324 def update_follower_count(%User{} = user) do
1325 if user.local or !Config.get([:instance, :external_user_synchronization]) do
1326 follower_count = FollowingRelationship.follower_count(user)
1329 |> follow_information_changeset(%{follower_count: follower_count})
1330 |> update_and_set_cache
1332 {:ok, maybe_fetch_follow_information(user)}
1336 @spec update_following_count(User.t()) :: {:ok, User.t()}
1337 def update_following_count(%User{local: false} = user) do
1338 if Config.get([:instance, :external_user_synchronization]) do
1339 {:ok, maybe_fetch_follow_information(user)}
1345 def update_following_count(%User{local: true} = user) do
1346 following_count = FollowingRelationship.following_count(user)
1349 |> follow_information_changeset(%{following_count: following_count})
1350 |> update_and_set_cache()
1353 @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1354 def get_users_from_set(ap_ids, opts \\ []) do
1355 local_only = Keyword.get(opts, :local_only, true)
1356 criteria = %{ap_id: ap_ids, is_active: true}
1357 criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1359 User.Query.build(criteria)
1363 @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1364 def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1367 query = User.Query.build(%{recipients_from_activity: to, local: true, is_active: true})
1373 @spec mute(User.t(), User.t(), map()) ::
1374 {:ok, list(UserRelationship.t())} | {:error, String.t()}
1375 def mute(%User{} = muter, %User{} = mutee, params \\ %{}) do
1376 notifications? = Map.get(params, :notifications, true)
1377 expires_in = Map.get(params, :expires_in, 0)
1379 with {:ok, user_mute} <- UserRelationship.create_mute(muter, mutee),
1380 {:ok, user_notification_mute} <-
1381 (notifications? && UserRelationship.create_notification_mute(muter, mutee)) ||
1383 if expires_in > 0 do
1384 Pleroma.Workers.MuteExpireWorker.enqueue(
1386 %{"muter_id" => muter.id, "mutee_id" => mutee.id},
1387 schedule_in: expires_in
1391 @cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
1393 {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
1397 def unmute(%User{} = muter, %User{} = mutee) do
1398 with {:ok, user_mute} <- UserRelationship.delete_mute(muter, mutee),
1399 {:ok, user_notification_mute} <-
1400 UserRelationship.delete_notification_mute(muter, mutee) do
1401 @cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
1402 {:ok, [user_mute, user_notification_mute]}
1406 def unmute(muter_id, mutee_id) do
1407 with {:muter, %User{} = muter} <- {:muter, User.get_by_id(muter_id)},
1408 {:mutee, %User{} = mutee} <- {:mutee, User.get_by_id(mutee_id)} do
1409 unmute(muter, mutee)
1411 {who, result} = error ->
1413 "User.unmute/2 failed. #{who}: #{result}, muter_id: #{muter_id}, mutee_id: #{mutee_id}"
1420 def subscribe(%User{} = subscriber, %User{} = target) do
1421 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
1423 if blocks?(target, subscriber) and deny_follow_blocked do
1424 {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1426 # Note: the relationship is inverse: subscriber acts as relationship target
1427 UserRelationship.create_inverse_subscription(target, subscriber)
1431 def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1432 with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1433 subscribe(subscriber, subscribee)
1437 def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1438 # Note: the relationship is inverse: subscriber acts as relationship target
1439 UserRelationship.delete_inverse_subscription(target, unsubscriber)
1442 def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1443 with %User{} = user <- get_cached_by_ap_id(ap_id) do
1444 unsubscribe(unsubscriber, user)
1448 def block(%User{} = blocker, %User{} = blocked) do
1449 # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1451 if following?(blocker, blocked) do
1452 {:ok, blocker, _} = unfollow(blocker, blocked)
1458 # clear any requested follows as well
1460 case CommonAPI.reject_follow_request(blocked, blocker) do
1461 {:ok, %User{} = updated_blocked} -> updated_blocked
1465 unsubscribe(blocked, blocker)
1467 unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
1468 if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)
1470 {:ok, blocker} = update_follower_count(blocker)
1471 {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1472 add_to_block(blocker, blocked)
1475 # helper to handle the block given only an actor's AP id
1476 def block(%User{} = blocker, %{ap_id: ap_id}) do
1477 block(blocker, get_cached_by_ap_id(ap_id))
1480 def unblock(%User{} = blocker, %User{} = blocked) do
1481 remove_from_block(blocker, blocked)
1484 # helper to handle the block given only an actor's AP id
1485 def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1486 unblock(blocker, get_cached_by_ap_id(ap_id))
1489 def mutes?(nil, _), do: false
1490 def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1492 def mutes_user?(%User{} = user, %User{} = target) do
1493 UserRelationship.mute_exists?(user, target)
1496 @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1497 def muted_notifications?(nil, _), do: false
1499 def muted_notifications?(%User{} = user, %User{} = target),
1500 do: UserRelationship.notification_mute_exists?(user, target)
1502 def blocks?(nil, _), do: false
1504 def blocks?(%User{} = user, %User{} = target) do
1505 blocks_user?(user, target) ||
1506 (blocks_domain?(user, target) and not User.following?(user, target))
1509 def blocks_user?(%User{} = user, %User{} = target) do
1510 UserRelationship.block_exists?(user, target)
1513 def blocks_user?(_, _), do: false
1515 def blocks_domain?(%User{} = user, %User{} = target) do
1516 domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1517 %{host: host} = URI.parse(target.ap_id)
1518 Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1521 def blocks_domain?(_, _), do: false
1523 def subscribed_to?(%User{} = user, %User{} = target) do
1524 # Note: the relationship is inverse: subscriber acts as relationship target
1525 UserRelationship.inverse_subscription_exists?(target, user)
1528 def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1529 with %User{} = target <- get_cached_by_ap_id(ap_id) do
1530 subscribed_to?(user, target)
1535 Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1536 E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1538 @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1539 def outgoing_relationships_ap_ids(_user, []), do: %{}
1541 def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1543 def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1544 when is_list(relationship_types) do
1547 |> assoc(:outgoing_relationships)
1548 |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1549 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1550 |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1551 |> group_by([user_rel, u], user_rel.relationship_type)
1553 |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1558 fn rel_type -> {rel_type, db_result[rel_type] || []} end
1562 def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1564 def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1566 def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1568 def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1569 when is_list(relationship_types) do
1571 |> assoc(:incoming_relationships)
1572 |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1573 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1574 |> maybe_filter_on_ap_id(ap_ids)
1575 |> select([user_rel, u], u.ap_id)
1580 defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1581 where(query, [user_rel, u], u.ap_id in ^ap_ids)
1584 defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1586 def set_activation_async(user, status \\ true) do
1587 BackgroundWorker.enqueue("user_activation", %{"user_id" => user.id, "status" => status})
1590 @spec set_activation([User.t()], boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
1591 def set_activation(users, status) when is_list(users) do
1592 Repo.transaction(fn ->
1593 for user <- users, do: set_activation(user, status)
1597 @spec set_activation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
1598 def set_activation(%User{} = user, status) do
1599 with {:ok, user} <- set_activation_status(user, status) do
1602 |> Enum.filter(& &1.local)
1603 |> Enum.each(&set_cache(update_following_count(&1)))
1605 # Only update local user counts, remote will be update during the next pull.
1608 |> Enum.filter(& &1.local)
1609 |> Enum.each(&do_unfollow(user, &1))
1615 def approve(users) when is_list(users) do
1616 Repo.transaction(fn ->
1617 Enum.map(users, fn user ->
1618 with {:ok, user} <- approve(user), do: user
1623 def approve(%User{approval_pending: true} = user) do
1624 with chg <- change(user, approval_pending: false),
1625 {:ok, user} <- update_and_set_cache(chg) do
1626 post_register_action(user)
1631 def approve(%User{} = user), do: {:ok, user}
1633 def confirm(users) when is_list(users) do
1634 Repo.transaction(fn ->
1635 Enum.map(users, fn user ->
1636 with {:ok, user} <- confirm(user), do: user
1641 def confirm(%User{confirmation_pending: true} = user) do
1642 with chg <- confirmation_changeset(user, need_confirmation: false),
1643 {:ok, user} <- update_and_set_cache(chg) do
1644 post_register_action(user)
1649 def confirm(%User{} = user), do: {:ok, user}
1651 def update_notification_settings(%User{} = user, settings) do
1653 |> cast(%{notification_settings: settings}, [])
1654 |> cast_embed(:notification_settings)
1655 |> validate_required([:notification_settings])
1656 |> update_and_set_cache()
1659 @spec purge_user_changeset(User.t()) :: Changeset.t()
1660 def purge_user_changeset(user) do
1661 # "Right to be forgotten"
1662 # https://gdpr.eu/right-to-be-forgotten/
1673 last_refreshed_at: nil,
1674 last_digest_emailed_at: nil,
1681 confirmation_pending: false,
1682 password_reset_pending: false,
1683 approval_pending: false,
1684 registration_reason: nil,
1685 confirmation_token: nil,
1689 is_moderator: false,
1691 mastofe_settings: nil,
1694 pleroma_settings_store: %{},
1697 is_discoverable: false,
1702 def delete(users) when is_list(users) do
1703 for user <- users, do: delete(user)
1706 def delete(%User{} = user) do
1707 BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1710 defp delete_and_invalidate_cache(%User{} = user) do
1711 invalidate_cache(user)
1715 defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)
1717 defp delete_or_deactivate(%User{local: true} = user) do
1718 status = account_status(user)
1721 :confirmation_pending ->
1722 delete_and_invalidate_cache(user)
1724 :approval_pending ->
1725 delete_and_invalidate_cache(user)
1729 |> purge_user_changeset()
1730 |> update_and_set_cache()
1734 def perform(:force_password_reset, user), do: force_password_reset(user)
1736 @spec perform(atom(), User.t()) :: {:ok, User.t()}
1737 def perform(:delete, %User{} = user) do
1738 # Remove all relationships
1741 |> Enum.each(fn follower ->
1742 ActivityPub.unfollow(follower, user)
1743 unfollow(follower, user)
1748 |> Enum.each(fn followed ->
1749 ActivityPub.unfollow(user, followed)
1750 unfollow(user, followed)
1753 delete_user_activities(user)
1754 delete_notifications_from_user_activities(user)
1756 delete_outgoing_pending_follow_requests(user)
1758 delete_or_deactivate(user)
1761 def perform(:set_activation_async, user, status), do: set_activation(user, status)
1763 @spec external_users_query() :: Ecto.Query.t()
1764 def external_users_query do
1772 @spec external_users(keyword()) :: [User.t()]
1773 def external_users(opts \\ []) do
1775 external_users_query()
1776 |> select([u], struct(u, [:id, :ap_id]))
1780 do: where(query, [u], u.id > ^opts[:max_id]),
1785 do: limit(query, ^opts[:limit]),
1791 def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1793 |> join(:inner, [n], activity in assoc(n, :activity))
1794 |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1795 |> Repo.delete_all()
1798 def delete_user_activities(%User{ap_id: ap_id} = user) do
1800 |> Activity.Queries.by_actor()
1801 |> Repo.chunk_stream(50, :batches)
1802 |> Stream.each(fn activities ->
1803 Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1808 defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1809 with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1810 {:ok, delete_data, _} <- Builder.delete(user, object) do
1811 Pipeline.common_pipeline(delete_data, local: user.local)
1813 {:find_object, nil} ->
1814 # We have the create activity, but not the object, it was probably pruned.
1815 # Insert a tombstone and try again
1816 with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1817 {:ok, _tombstone} <- Object.create(tombstone_data) do
1818 delete_activity(activity, user)
1822 Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1823 Logger.error("Error: #{inspect(e)}")
1827 defp delete_activity(%{data: %{"type" => type}} = activity, user)
1828 when type in ["Like", "Announce"] do
1829 {:ok, undo, _} = Builder.undo(user, activity)
1830 Pipeline.common_pipeline(undo, local: user.local)
1833 defp delete_activity(_activity, _user), do: "Doing nothing"
1835 defp delete_outgoing_pending_follow_requests(user) do
1837 |> FollowingRelationship.outgoing_pending_follow_requests_query()
1838 |> Repo.delete_all()
1841 def html_filter_policy(%User{no_rich_text: true}) do
1842 Pleroma.HTML.Scrubber.TwitterText
1845 def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])
1847 def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1849 def get_or_fetch_by_ap_id(ap_id) do
1850 cached_user = get_cached_by_ap_id(ap_id)
1852 maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)
1854 case {cached_user, maybe_fetched_user} do
1855 {_, {:ok, %User{} = user}} ->
1858 {%User{} = user, _} ->
1862 {:error, :not_found}
1867 Creates an internal service actor by URI if missing.
1868 Optionally takes nickname for addressing.
1870 @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1871 def get_or_create_service_actor_by_ap_id(uri, nickname) do
1873 case get_cached_by_ap_id(uri) do
1875 with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1876 Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1880 %User{invisible: false} = user ->
1890 @spec set_invisible(User.t()) :: {:ok, User.t()}
1891 defp set_invisible(user) do
1893 |> change(%{invisible: true})
1894 |> update_and_set_cache()
1897 @spec create_service_actor(String.t(), String.t()) ::
1898 {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1899 defp create_service_actor(uri, nickname) do
1905 follower_address: uri <> "/followers"
1908 |> unique_constraint(:nickname)
1913 def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1916 |> :public_key.pem_decode()
1918 |> :public_key.pem_entry_decode()
1923 def public_key(_), do: {:error, "key not found"}
1925 def get_public_key_for_ap_id(ap_id) do
1926 with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1927 {:ok, public_key} <- public_key(user) do
1934 def ap_enabled?(%User{local: true}), do: true
1935 def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1936 def ap_enabled?(_), do: false
1938 @doc "Gets or fetch a user by uri or nickname."
1939 @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1940 def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1941 def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1943 # wait a period of time and return newest version of the User structs
1944 # this is because we have synchronous follow APIs and need to simulate them
1945 # with an async handshake
1946 def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1947 with %User{} = a <- get_cached_by_id(a.id),
1948 %User{} = b <- get_cached_by_id(b.id) do
1955 def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1956 with :ok <- :timer.sleep(timeout),
1957 %User{} = a <- get_cached_by_id(a.id),
1958 %User{} = b <- get_cached_by_id(b.id) do
1965 def parse_bio(bio) when is_binary(bio) and bio != "" do
1967 |> CommonUtils.format_input("text/plain", mentions_format: :full)
1971 def parse_bio(_), do: ""
1973 def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1974 # TODO: get profile URLs other than user.ap_id
1975 profile_urls = [user.ap_id]
1978 |> CommonUtils.format_input("text/plain",
1979 mentions_format: :full,
1980 rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1985 def parse_bio(_, _), do: ""
1987 def tag(user_identifiers, tags) when is_list(user_identifiers) do
1988 Repo.transaction(fn ->
1989 for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1993 def tag(nickname, tags) when is_binary(nickname),
1994 do: tag(get_by_nickname(nickname), tags)
1996 def tag(%User{} = user, tags),
1997 do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1999 def untag(user_identifiers, tags) when is_list(user_identifiers) do
2000 Repo.transaction(fn ->
2001 for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
2005 def untag(nickname, tags) when is_binary(nickname),
2006 do: untag(get_by_nickname(nickname), tags)
2008 def untag(%User{} = user, tags),
2009 do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
2011 defp update_tags(%User{} = user, new_tags) do
2012 {:ok, updated_user} =
2014 |> change(%{tags: new_tags})
2015 |> update_and_set_cache()
2020 defp normalize_tags(tags) do
2023 |> Enum.map(&String.downcase/1)
2026 defp local_nickname_regex do
2027 if Config.get([:instance, :extended_nickname_format]) do
2028 @extended_local_nickname_regex
2030 @strict_local_nickname_regex
2034 def local_nickname(nickname_or_mention) do
2037 |> String.split("@")
2041 def full_nickname(nickname_or_mention),
2042 do: String.trim_leading(nickname_or_mention, "@")
2044 def error_user(ap_id) do
2048 nickname: "erroruser@example.com",
2049 inserted_at: NaiveDateTime.utc_now()
2053 @spec all_superusers() :: [User.t()]
2054 def all_superusers do
2055 User.Query.build(%{super_users: true, local: true, is_active: true})
2059 def muting_reblogs?(%User{} = user, %User{} = target) do
2060 UserRelationship.reblog_mute_exists?(user, target)
2063 def showing_reblogs?(%User{} = user, %User{} = target) do
2064 not muting_reblogs?(user, target)
2068 The function returns a query to get users with no activity for given interval of days.
2069 Inactive users are those who didn't read any notification, or had any activity where
2070 the user is the activity's actor, during `inactivity_threshold` days.
2071 Deactivated users will not appear in this list.
2075 iex> Pleroma.User.list_inactive_users()
2078 @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
2079 def list_inactive_users_query(inactivity_threshold \\ 7) do
2080 negative_inactivity_threshold = -inactivity_threshold
2081 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2082 # Subqueries are not supported in `where` clauses, join gets too complicated.
2083 has_read_notifications =
2084 from(n in Pleroma.Notification,
2085 where: n.seen == true,
2087 having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
2090 |> Pleroma.Repo.all()
2092 from(u in Pleroma.User,
2093 left_join: a in Pleroma.Activity,
2094 on: u.ap_id == a.actor,
2095 where: not is_nil(u.nickname),
2096 where: u.is_active == ^true,
2097 where: u.id not in ^has_read_notifications,
2100 max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
2101 is_nil(max(a.inserted_at))
2106 Enable or disable email notifications for user
2110 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
2111 Pleroma.User{email_notifications: %{"digest" => true}}
2113 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
2114 Pleroma.User{email_notifications: %{"digest" => false}}
2116 @spec switch_email_notifications(t(), String.t(), boolean()) ::
2117 {:ok, t()} | {:error, Ecto.Changeset.t()}
2118 def switch_email_notifications(user, type, status) do
2119 User.update_email_notifications(user, %{type => status})
2123 Set `last_digest_emailed_at` value for the user to current time
2125 @spec touch_last_digest_emailed_at(t()) :: t()
2126 def touch_last_digest_emailed_at(user) do
2127 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2129 {:ok, updated_user} =
2131 |> change(%{last_digest_emailed_at: now})
2132 |> update_and_set_cache()
2137 @spec need_confirmation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
2138 def need_confirmation(%User{} = user, bool) do
2140 |> confirmation_changeset(need_confirmation: bool)
2141 |> update_and_set_cache()
2144 def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
2148 def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
2149 # use instance-default
2150 config = Config.get([:assets, :mascots])
2151 default_mascot = Config.get([:assets, :default_mascot])
2152 mascot = Keyword.get(config, default_mascot)
2155 "id" => "default-mascot",
2156 "url" => mascot[:url],
2157 "preview_url" => mascot[:url],
2159 "mime_type" => mascot[:mime_type]
2164 def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
2166 def ensure_keys_present(%User{} = user) do
2167 with {:ok, pem} <- Keys.generate_rsa_pem() do
2169 |> cast(%{keys: pem}, [:keys])
2170 |> validate_required([:keys])
2171 |> update_and_set_cache()
2175 def get_ap_ids_by_nicknames(nicknames) do
2177 where: u.nickname in ^nicknames,
2183 defp put_password_hash(
2184 %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2186 change(changeset, password_hash: Pleroma.Password.Pbkdf2.hash_pwd_salt(password))
2189 defp put_password_hash(changeset), do: changeset
2191 def is_internal_user?(%User{nickname: nil}), do: true
2192 def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2193 def is_internal_user?(_), do: false
2195 # A hack because user delete activities have a fake id for whatever reason
2196 # TODO: Get rid of this
2197 def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2199 def get_delivered_users_by_object_id(object_id) do
2201 inner_join: delivery in assoc(u, :deliveries),
2202 where: delivery.object_id == ^object_id
2207 def change_email(user, email) do
2209 |> cast(%{email: email}, [:email])
2210 |> validate_required([:email])
2211 |> unique_constraint(:email)
2212 |> validate_format(:email, @email_regex)
2213 |> update_and_set_cache()
2216 # Internal function; public one is `deactivate/2`
2217 defp set_activation_status(user, status) do
2219 |> cast(%{is_active: status}, [:is_active])
2220 |> update_and_set_cache()
2223 def update_banner(user, banner) do
2225 |> cast(%{banner: banner}, [:banner])
2226 |> update_and_set_cache()
2229 def update_background(user, background) do
2231 |> cast(%{background: background}, [:background])
2232 |> update_and_set_cache()
2235 def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
2238 moderator: is_moderator
2242 def validate_fields(changeset, remote? \\ false) do
2243 limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2244 limit = Config.get([:instance, limit_name], 0)
2247 |> validate_length(:fields, max: limit)
2248 |> validate_change(:fields, fn :fields, fields ->
2249 if Enum.all?(fields, &valid_field?/1) do
2257 defp valid_field?(%{"name" => name, "value" => value}) do
2258 name_limit = Config.get([:instance, :account_field_name_length], 255)
2259 value_limit = Config.get([:instance, :account_field_value_length], 255)
2261 is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2262 String.length(value) <= value_limit
2265 defp valid_field?(_), do: false
2267 defp truncate_field(%{"name" => name, "value" => value}) do
2269 String.split_at(name, Config.get([:instance, :account_field_name_length], 255))
2272 String.split_at(value, Config.get([:instance, :account_field_value_length], 255))
2274 %{"name" => name, "value" => value}
2277 def admin_api_update(user, params) do
2284 |> update_and_set_cache()
2287 @doc "Signs user out of all applications"
2288 def global_sign_out(user) do
2289 OAuth.Authorization.delete_user_authorizations(user)
2290 OAuth.Token.delete_user_tokens(user)
2293 def mascot_update(user, url) do
2295 |> cast(%{mascot: url}, [:mascot])
2296 |> validate_required([:mascot])
2297 |> update_and_set_cache()
2300 def mastodon_settings_update(user, settings) do
2302 |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
2303 |> validate_required([:mastofe_settings])
2304 |> update_and_set_cache()
2307 @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2308 def confirmation_changeset(user, need_confirmation: need_confirmation?) do
2310 if need_confirmation? do
2312 confirmation_pending: true,
2313 confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2317 confirmation_pending: false,
2318 confirmation_token: nil
2322 cast(user, params, [:confirmation_pending, :confirmation_token])
2325 @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
2326 def approval_changeset(user, need_approval: need_approval?) do
2327 params = if need_approval?, do: %{approval_pending: true}, else: %{approval_pending: false}
2328 cast(user, params, [:approval_pending])
2331 def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2332 if id not in user.pinned_activities do
2333 max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2334 params = %{pinned_activities: user.pinned_activities ++ [id]}
2336 # if pinned activity was scheduled for deletion, we remove job
2337 if expiration = Pleroma.Workers.PurgeExpiredActivity.get_expiration(id) do
2338 Oban.cancel_job(expiration.id)
2342 |> cast(params, [:pinned_activities])
2343 |> validate_length(:pinned_activities,
2344 max: max_pinned_statuses,
2345 message: "You have already pinned the maximum number of statuses"
2350 |> update_and_set_cache()
2353 def remove_pinnned_activity(user, %Pleroma.Activity{id: id, data: data}) do
2354 params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2356 # if pinned activity was scheduled for deletion, we reschedule it for deletion
2357 if data["expires_at"] do
2358 # MRF.ActivityExpirationPolicy used UTC timestamps for expires_at in original implementation
2360 data["expires_at"] |> Pleroma.EctoType.ActivityPub.ObjectValidators.DateTime.cast()
2362 Pleroma.Workers.PurgeExpiredActivity.enqueue(%{
2364 expires_at: expires_at
2369 |> cast(params, [:pinned_activities])
2370 |> update_and_set_cache()
2373 def update_email_notifications(user, settings) do
2374 email_notifications =
2375 user.email_notifications
2376 |> Map.merge(settings)
2377 |> Map.take(["digest"])
2379 params = %{email_notifications: email_notifications}
2380 fields = [:email_notifications]
2383 |> cast(params, fields)
2384 |> validate_required(fields)
2385 |> update_and_set_cache()
2388 defp set_domain_blocks(user, domain_blocks) do
2389 params = %{domain_blocks: domain_blocks}
2392 |> cast(params, [:domain_blocks])
2393 |> validate_required([:domain_blocks])
2394 |> update_and_set_cache()
2397 def block_domain(user, domain_blocked) do
2398 set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2401 def unblock_domain(user, domain_blocked) do
2402 set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2405 @spec add_to_block(User.t(), User.t()) ::
2406 {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2407 defp add_to_block(%User{} = user, %User{} = blocked) do
2408 with {:ok, relationship} <- UserRelationship.create_block(user, blocked) do
2409 @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
2414 @spec add_to_block(User.t(), User.t()) ::
2415 {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2416 defp remove_from_block(%User{} = user, %User{} = blocked) do
2417 with {:ok, relationship} <- UserRelationship.delete_block(user, blocked) do
2418 @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
2423 def set_invisible(user, invisible) do
2424 params = %{invisible: invisible}
2427 |> cast(params, [:invisible])
2428 |> validate_required([:invisible])
2429 |> update_and_set_cache()
2432 def sanitize_html(%User{} = user) do
2433 sanitize_html(user, nil)
2436 # User data that mastodon isn't filtering (treated as plaintext):
2439 def sanitize_html(%User{} = user, filter) do
2441 Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2444 "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2449 |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2450 |> Map.put(:fields, fields)
2453 def get_host(%User{ap_id: ap_id} = _user) do
2454 URI.parse(ap_id).host