1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.User do
10 import Ecto, only: [assoc: 2]
13 alias Pleroma.Activity
15 alias Pleroma.Conversation.Participation
16 alias Pleroma.Delivery
17 alias Pleroma.EctoType.ActivityPub.ObjectValidators
19 alias Pleroma.FollowingRelationship
20 alias Pleroma.Formatter
24 alias Pleroma.Notification
26 alias Pleroma.Registration
29 alias Pleroma.UserRelationship
31 alias Pleroma.Web.ActivityPub.ActivityPub
32 alias Pleroma.Web.ActivityPub.Builder
33 alias Pleroma.Web.ActivityPub.Pipeline
34 alias Pleroma.Web.ActivityPub.Utils
35 alias Pleroma.Web.CommonAPI
36 alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
37 alias Pleroma.Web.OAuth
38 alias Pleroma.Web.RelMe
39 alias Pleroma.Workers.BackgroundWorker
43 @type t :: %__MODULE__{}
44 @type account_status ::
47 | :password_reset_pending
48 | :confirmation_pending
50 @primary_key {:id, FlakeId.Ecto.CompatType, autogenerate: true}
52 # credo:disable-for-next-line Credo.Check.Readability.MaxLineLength
53 @email_regex ~r/^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/
55 @strict_local_nickname_regex ~r/^[a-zA-Z\d]+$/
56 @extended_local_nickname_regex ~r/^[a-zA-Z\d_-]+$/
58 # AP ID user relationships (blocks, mutes etc.)
59 # Format: [rel_type: [outgoing_rel: :outgoing_rel_target, incoming_rel: :incoming_rel_source]]
60 @user_relationships_config [
62 blocker_blocks: :blocked_users,
63 blockee_blocks: :blocker_users
66 muter_mutes: :muted_users,
67 mutee_mutes: :muter_users
70 reblog_muter_mutes: :reblog_muted_users,
71 reblog_mutee_mutes: :reblog_muter_users
74 notification_muter_mutes: :notification_muted_users,
75 notification_mutee_mutes: :notification_muter_users
77 # Note: `inverse_subscription` relationship is inverse: subscriber acts as relationship target
78 inverse_subscription: [
79 subscribee_subscriptions: :subscriber_users,
80 subscriber_subscriptions: :subscribee_users
85 field(:bio, :string, default: "")
86 field(:raw_bio, :string)
87 field(:email, :string)
89 field(:nickname, :string)
90 field(:password_hash, :string)
91 field(:password, :string, virtual: true)
92 field(:password_confirmation, :string, virtual: true)
94 field(:public_key, :string)
95 field(:ap_id, :string)
96 field(:avatar, :map, default: %{})
97 field(:local, :boolean, default: true)
98 field(:follower_address, :string)
99 field(:following_address, :string)
100 field(:search_rank, :float, virtual: true)
101 field(:search_type, :integer, virtual: true)
102 field(:tags, {:array, :string}, default: [])
103 field(:last_refreshed_at, :naive_datetime_usec)
104 field(:last_digest_emailed_at, :naive_datetime)
105 field(:banner, :map, default: %{})
106 field(:background, :map, default: %{})
107 field(:note_count, :integer, default: 0)
108 field(:follower_count, :integer, default: 0)
109 field(:following_count, :integer, default: 0)
110 field(:is_locked, :boolean, default: false)
111 field(:confirmation_pending, :boolean, default: false)
112 field(:password_reset_pending, :boolean, default: false)
113 field(:approval_pending, :boolean, default: false)
114 field(:registration_reason, :string, default: nil)
115 field(:confirmation_token, :string, default: nil)
116 field(:default_scope, :string, default: "public")
117 field(:domain_blocks, {:array, :string}, default: [])
118 field(:deactivated, :boolean, default: false)
119 field(:no_rich_text, :boolean, default: false)
120 field(:ap_enabled, :boolean, default: false)
121 field(:is_moderator, :boolean, default: false)
122 field(:is_admin, :boolean, default: false)
123 field(:show_role, :boolean, default: true)
124 field(:mastofe_settings, :map, default: nil)
125 field(:uri, ObjectValidators.Uri, default: nil)
126 field(:hide_followers_count, :boolean, default: false)
127 field(:hide_follows_count, :boolean, default: false)
128 field(:hide_followers, :boolean, default: false)
129 field(:hide_follows, :boolean, default: false)
130 field(:hide_favorites, :boolean, default: true)
131 field(:pinned_activities, {:array, :string}, default: [])
132 field(:email_notifications, :map, default: %{"digest" => false})
133 field(:mascot, :map, default: nil)
134 field(:emoji, :map, default: %{})
135 field(:pleroma_settings_store, :map, default: %{})
136 field(:fields, {:array, :map}, default: [])
137 field(:raw_fields, {:array, :map}, default: [])
138 field(:is_discoverable, :boolean, default: false)
139 field(:invisible, :boolean, default: false)
140 field(:allow_following_move, :boolean, default: true)
141 field(:skip_thread_containment, :boolean, default: false)
142 field(:actor_type, :string, default: "Person")
143 field(:also_known_as, {:array, :string}, default: [])
144 field(:inbox, :string)
145 field(:shared_inbox, :string)
146 field(:accepts_chat_messages, :boolean, default: nil)
149 :notification_settings,
150 Pleroma.User.NotificationSetting,
154 has_many(:notifications, Notification)
155 has_many(:registrations, Registration)
156 has_many(:deliveries, Delivery)
158 has_many(:outgoing_relationships, UserRelationship, foreign_key: :source_id)
159 has_many(:incoming_relationships, UserRelationship, foreign_key: :target_id)
161 for {relationship_type,
163 {outgoing_relation, outgoing_relation_target},
164 {incoming_relation, incoming_relation_source}
165 ]} <- @user_relationships_config do
166 # Definitions of `has_many` relations: :blocker_blocks, :muter_mutes, :reblog_muter_mutes,
167 # :notification_muter_mutes, :subscribee_subscriptions
168 has_many(outgoing_relation, UserRelationship,
169 foreign_key: :source_id,
170 where: [relationship_type: relationship_type]
173 # Definitions of `has_many` relations: :blockee_blocks, :mutee_mutes, :reblog_mutee_mutes,
174 # :notification_mutee_mutes, :subscriber_subscriptions
175 has_many(incoming_relation, UserRelationship,
176 foreign_key: :target_id,
177 where: [relationship_type: relationship_type]
180 # Definitions of `has_many` relations: :blocked_users, :muted_users, :reblog_muted_users,
181 # :notification_muted_users, :subscriber_users
182 has_many(outgoing_relation_target, through: [outgoing_relation, :target])
184 # Definitions of `has_many` relations: :blocker_users, :muter_users, :reblog_muter_users,
185 # :notification_muter_users, :subscribee_users
186 has_many(incoming_relation_source, through: [incoming_relation, :source])
189 # `:blocks` is deprecated (replaced with `blocked_users` relation)
190 field(:blocks, {:array, :string}, default: [])
191 # `:mutes` is deprecated (replaced with `muted_users` relation)
192 field(:mutes, {:array, :string}, default: [])
193 # `:muted_reblogs` is deprecated (replaced with `reblog_muted_users` relation)
194 field(:muted_reblogs, {:array, :string}, default: [])
195 # `:muted_notifications` is deprecated (replaced with `notification_muted_users` relation)
196 field(:muted_notifications, {:array, :string}, default: [])
197 # `:subscribers` is deprecated (replaced with `subscriber_users` relation)
198 field(:subscribers, {:array, :string}, default: [])
201 :multi_factor_authentication_settings,
209 for {_relationship_type, [{_outgoing_relation, outgoing_relation_target}, _]} <-
210 @user_relationships_config do
211 # `def blocked_users_relation/2`, `def muted_users_relation/2`,
212 # `def reblog_muted_users_relation/2`, `def notification_muted_users/2`,
213 # `def subscriber_users/2`
214 def unquote(:"#{outgoing_relation_target}_relation")(user, restrict_deactivated? \\ false) do
215 target_users_query = assoc(user, unquote(outgoing_relation_target))
217 if restrict_deactivated? do
218 restrict_deactivated(target_users_query)
224 # `def blocked_users/2`, `def muted_users/2`, `def reblog_muted_users/2`,
225 # `def notification_muted_users/2`, `def subscriber_users/2`
226 def unquote(outgoing_relation_target)(user, restrict_deactivated? \\ false) do
228 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
230 restrict_deactivated?
235 # `def blocked_users_ap_ids/2`, `def muted_users_ap_ids/2`, `def reblog_muted_users_ap_ids/2`,
236 # `def notification_muted_users_ap_ids/2`, `def subscriber_users_ap_ids/2`
237 def unquote(:"#{outgoing_relation_target}_ap_ids")(user, restrict_deactivated? \\ false) do
239 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
241 restrict_deactivated?
243 |> select([u], u.ap_id)
248 def cached_blocked_users_ap_ids(user) do
249 Cachex.fetch!(:user_cache, "blocked_users_ap_ids:#{user.ap_id}", fn _ ->
250 blocked_users_ap_ids(user)
254 def cached_muted_users_ap_ids(user) do
255 Cachex.fetch!(:user_cache, "muted_users_ap_ids:#{user.ap_id}", fn _ ->
256 muted_users_ap_ids(user)
260 defdelegate following_count(user), to: FollowingRelationship
261 defdelegate following(user), to: FollowingRelationship
262 defdelegate following?(follower, followed), to: FollowingRelationship
263 defdelegate following_ap_ids(user), to: FollowingRelationship
264 defdelegate get_follow_requests(user), to: FollowingRelationship
265 defdelegate search(query, opts \\ []), to: User.Search
268 Dumps Flake Id to SQL-compatible format (16-byte UUID).
269 E.g. "9pQtDGXuq4p3VlcJEm" -> <<0, 0, 1, 110, 179, 218, 42, 92, 213, 41, 44, 227, 95, 213, 0, 0>>
271 def binary_id(source_id) when is_binary(source_id) do
272 with {:ok, dumped_id} <- FlakeId.Ecto.CompatType.dump(source_id) do
279 def binary_id(source_ids) when is_list(source_ids) do
280 Enum.map(source_ids, &binary_id/1)
283 def binary_id(%User{} = user), do: binary_id(user.id)
285 @doc "Returns status account"
286 @spec account_status(User.t()) :: account_status()
287 def account_status(%User{deactivated: true}), do: :deactivated
288 def account_status(%User{password_reset_pending: true}), do: :password_reset_pending
289 def account_status(%User{local: true, approval_pending: true}), do: :approval_pending
291 def account_status(%User{local: true, confirmation_pending: true}) do
292 if Config.get([:instance, :account_activation_required]) do
293 :confirmation_pending
299 def account_status(%User{}), do: :active
301 @spec visible_for(User.t(), User.t() | nil) ::
304 | :restricted_unauthenticated
306 | :confirmation_pending
307 def visible_for(user, for_user \\ nil)
309 def visible_for(%User{invisible: true}, _), do: :invisible
311 def visible_for(%User{id: user_id}, %User{id: user_id}), do: :visible
313 def visible_for(%User{} = user, nil) do
314 if restrict_unauthenticated?(user) do
315 :restrict_unauthenticated
317 visible_account_status(user)
321 def visible_for(%User{} = user, for_user) do
322 if superuser?(for_user) do
325 visible_account_status(user)
329 def visible_for(_, _), do: :invisible
331 defp restrict_unauthenticated?(%User{local: true}) do
332 Config.restrict_unauthenticated_access?(:profiles, :local)
335 defp restrict_unauthenticated?(%User{local: _}) do
336 Config.restrict_unauthenticated_access?(:profiles, :remote)
339 defp visible_account_status(user) do
340 status = account_status(user)
342 if status in [:active, :password_reset_pending] do
349 @spec superuser?(User.t()) :: boolean()
350 def superuser?(%User{local: true, is_admin: true}), do: true
351 def superuser?(%User{local: true, is_moderator: true}), do: true
352 def superuser?(_), do: false
354 @spec invisible?(User.t()) :: boolean()
355 def invisible?(%User{invisible: true}), do: true
356 def invisible?(_), do: false
358 def avatar_url(user, options \\ []) do
360 %{"url" => [%{"href" => href} | _]} ->
364 unless options[:no_default] do
365 Config.get([:assets, :default_user_avatar], "#{Web.base_url()}/images/avi.png")
370 def banner_url(user, options \\ []) do
372 %{"url" => [%{"href" => href} | _]} -> href
373 _ -> !options[:no_default] && "#{Web.base_url()}/images/banner.png"
377 # Should probably be renamed or removed
378 def ap_id(%User{nickname: nickname}), do: "#{Web.base_url()}/users/#{nickname}"
380 def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
381 def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"
383 @spec ap_following(User.t()) :: String.t()
384 def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
385 def ap_following(%User{} = user), do: "#{ap_id(user)}/following"
387 @spec restrict_deactivated(Ecto.Query.t()) :: Ecto.Query.t()
388 def restrict_deactivated(query) do
389 from(u in query, where: u.deactivated != ^true)
392 defp truncate_fields_param(params) do
393 if Map.has_key?(params, :fields) do
394 Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
400 defp truncate_if_exists(params, key, max_length) do
401 if Map.has_key?(params, key) and is_binary(params[key]) do
402 {value, _chopped} = String.split_at(params[key], max_length)
403 Map.put(params, key, value)
409 defp fix_follower_address(%{follower_address: _, following_address: _} = params), do: params
411 defp fix_follower_address(%{nickname: nickname} = params),
412 do: Map.put(params, :follower_address, ap_followers(%User{nickname: nickname}))
414 defp fix_follower_address(params), do: params
416 def remote_user_changeset(struct \\ %User{local: false}, params) do
417 bio_limit = Config.get([:instance, :user_bio_length], 5000)
418 name_limit = Config.get([:instance, :user_name_length], 100)
421 case params[:name] do
422 name when is_binary(name) and byte_size(name) > 0 -> name
423 _ -> params[:nickname]
428 |> Map.put(:name, name)
429 |> Map.put_new(:last_refreshed_at, NaiveDateTime.utc_now())
430 |> truncate_if_exists(:name, name_limit)
431 |> truncate_if_exists(:bio, bio_limit)
432 |> truncate_fields_param()
433 |> fix_follower_address()
456 :hide_followers_count,
465 :accepts_chat_messages
468 |> cast(params, [:name], empty_values: [])
469 |> validate_required([:ap_id])
470 |> validate_required([:name], trim: false)
471 |> unique_constraint(:nickname)
472 |> validate_format(:nickname, @email_regex)
473 |> validate_length(:bio, max: bio_limit)
474 |> validate_length(:name, max: name_limit)
475 |> validate_fields(true)
476 |> validate_non_local()
479 defp validate_non_local(cng) do
480 local? = get_field(cng, :local)
484 |> add_error(:local, "User is local, can't update with this changeset.")
490 def update_changeset(struct, params \\ %{}) do
491 bio_limit = Config.get([:instance, :user_bio_length], 5000)
492 name_limit = Config.get([:instance, :user_name_length], 100)
512 :hide_followers_count,
515 :allow_following_move,
518 :skip_thread_containment,
521 :pleroma_settings_store,
525 :accepts_chat_messages
528 |> unique_constraint(:nickname)
529 |> validate_format(:nickname, local_nickname_regex())
530 |> validate_length(:bio, max: bio_limit)
531 |> validate_length(:name, min: 1, max: name_limit)
532 |> validate_inclusion(:actor_type, ["Person", "Service"])
535 |> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
536 |> put_change_if_present(:avatar, &put_upload(&1, :avatar))
537 |> put_change_if_present(:banner, &put_upload(&1, :banner))
538 |> put_change_if_present(:background, &put_upload(&1, :background))
539 |> put_change_if_present(
540 :pleroma_settings_store,
541 &{:ok, Map.merge(struct.pleroma_settings_store, &1)}
543 |> validate_fields(false)
546 defp put_fields(changeset) do
547 if raw_fields = get_change(changeset, :raw_fields) do
550 |> Enum.filter(fn %{"name" => n} -> n != "" end)
554 |> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)
557 |> put_change(:raw_fields, raw_fields)
558 |> put_change(:fields, fields)
564 defp parse_fields(value) do
566 |> Formatter.linkify(mentions_format: :full)
570 defp put_emoji(changeset) do
571 emojified_fields = [:bio, :name, :raw_fields]
573 if Enum.any?(changeset.changes, fn {k, _} -> k in emojified_fields end) do
574 bio = Emoji.Formatter.get_emoji_map(get_field(changeset, :bio))
575 name = Emoji.Formatter.get_emoji_map(get_field(changeset, :name))
577 emoji = Map.merge(bio, name)
581 |> get_field(:raw_fields)
582 |> Enum.reduce(emoji, fn x, acc ->
583 Map.merge(acc, Emoji.Formatter.get_emoji_map(x["name"] <> x["value"]))
586 put_change(changeset, :emoji, emoji)
592 defp put_change_if_present(changeset, map_field, value_function) do
593 with {:ok, value} <- fetch_change(changeset, map_field),
594 {:ok, new_value} <- value_function.(value) do
595 put_change(changeset, map_field, new_value)
601 defp put_upload(value, type) do
602 with %Plug.Upload{} <- value,
603 {:ok, object} <- ActivityPub.upload(value, type: type) do
608 def update_as_admin_changeset(struct, params) do
610 |> update_changeset(params)
611 |> cast(params, [:email])
612 |> delete_change(:also_known_as)
613 |> unique_constraint(:email)
614 |> validate_format(:email, @email_regex)
615 |> validate_inclusion(:actor_type, ["Person", "Service"])
618 @spec update_as_admin(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
619 def update_as_admin(user, params) do
620 params = Map.put(params, "password_confirmation", params["password"])
621 changeset = update_as_admin_changeset(user, params)
623 if params["password"] do
624 reset_password(user, changeset, params)
626 User.update_and_set_cache(changeset)
630 def password_update_changeset(struct, params) do
632 |> cast(params, [:password, :password_confirmation])
633 |> validate_required([:password, :password_confirmation])
634 |> validate_confirmation(:password)
635 |> put_password_hash()
636 |> put_change(:password_reset_pending, false)
639 @spec reset_password(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
640 def reset_password(%User{} = user, params) do
641 reset_password(user, user, params)
644 def reset_password(%User{id: user_id} = user, struct, params) do
647 |> Multi.update(:user, password_update_changeset(struct, params))
648 |> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
649 |> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))
651 case Repo.transaction(multi) do
652 {:ok, %{user: user} = _} -> set_cache(user)
653 {:error, _, changeset, _} -> {:error, changeset}
657 def update_password_reset_pending(user, value) do
660 |> put_change(:password_reset_pending, value)
661 |> update_and_set_cache()
664 def force_password_reset_async(user) do
665 BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
668 @spec force_password_reset(User.t()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
669 def force_password_reset(user), do: update_password_reset_pending(user, true)
671 # Used to auto-register LDAP accounts which won't have a password hash stored locally
672 def register_changeset_ldap(struct, params = %{password: password})
673 when is_nil(password) do
674 params = Map.put_new(params, :accepts_chat_messages, true)
677 if Map.has_key?(params, :email) do
678 Map.put_new(params, :email, params[:email])
688 :accepts_chat_messages
690 |> validate_required([:name, :nickname])
691 |> unique_constraint(:nickname)
692 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
693 |> validate_format(:nickname, local_nickname_regex())
695 |> unique_constraint(:ap_id)
696 |> put_following_and_follower_address()
699 def register_changeset(struct, params \\ %{}, opts \\ []) do
700 bio_limit = Config.get([:instance, :user_bio_length], 5000)
701 name_limit = Config.get([:instance, :user_name_length], 100)
702 reason_limit = Config.get([:instance, :registration_reason_length], 500)
703 params = Map.put_new(params, :accepts_chat_messages, true)
706 if is_nil(opts[:need_confirmation]) do
707 Config.get([:instance, :account_activation_required])
709 opts[:need_confirmation]
713 if is_nil(opts[:need_approval]) do
714 Config.get([:instance, :account_approval_required])
720 |> confirmation_changeset(need_confirmation: need_confirmation?)
721 |> approval_changeset(need_approval: need_approval?)
729 :password_confirmation,
731 :accepts_chat_messages,
734 |> validate_required([:name, :nickname, :password, :password_confirmation])
735 |> validate_confirmation(:password)
736 |> unique_constraint(:email)
737 |> validate_format(:email, @email_regex)
738 |> validate_change(:email, fn :email, email ->
740 Config.get([User, :email_blacklist])
741 |> Enum.all?(fn blacklisted_domain ->
742 !String.ends_with?(email, ["@" <> blacklisted_domain, "." <> blacklisted_domain])
745 if valid?, do: [], else: [email: "Invalid email"]
747 |> unique_constraint(:nickname)
748 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
749 |> validate_format(:nickname, local_nickname_regex())
750 |> validate_length(:bio, max: bio_limit)
751 |> validate_length(:name, min: 1, max: name_limit)
752 |> validate_length(:registration_reason, max: reason_limit)
753 |> maybe_validate_required_email(opts[:external])
756 |> unique_constraint(:ap_id)
757 |> put_following_and_follower_address()
760 def maybe_validate_required_email(changeset, true), do: changeset
762 def maybe_validate_required_email(changeset, _) do
763 if Config.get([:instance, :account_activation_required]) do
764 validate_required(changeset, [:email])
770 defp put_ap_id(changeset) do
771 ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
772 put_change(changeset, :ap_id, ap_id)
775 defp put_following_and_follower_address(changeset) do
776 followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
779 |> put_change(:follower_address, followers)
782 defp autofollow_users(user) do
783 candidates = Config.get([:instance, :autofollowed_nicknames])
786 User.Query.build(%{nickname: candidates, local: true, deactivated: false})
789 follow_all(user, autofollowed_users)
792 defp autofollowing_users(user) do
793 candidates = Config.get([:instance, :autofollowing_nicknames])
795 User.Query.build(%{nickname: candidates, local: true, deactivated: false})
797 |> Enum.each(&follow(&1, user, :follow_accept))
802 @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
803 def register(%Ecto.Changeset{} = changeset) do
804 with {:ok, user} <- Repo.insert(changeset) do
805 post_register_action(user)
809 def post_register_action(%User{confirmation_pending: true} = user) do
810 with {:ok, _} <- try_send_confirmation_email(user) do
815 def post_register_action(%User{approval_pending: true} = user) do
816 with {:ok, _} <- send_user_approval_email(user),
817 {:ok, _} <- send_admin_approval_emails(user) do
822 def post_register_action(%User{approval_pending: false, confirmation_pending: false} = user) do
823 with {:ok, user} <- autofollow_users(user),
824 {:ok, _} <- autofollowing_users(user),
825 {:ok, user} <- set_cache(user),
826 {:ok, _} <- send_welcome_email(user),
827 {:ok, _} <- send_welcome_message(user),
828 {:ok, _} <- send_welcome_chat_message(user) do
833 defp send_user_approval_email(user) do
835 |> Pleroma.Emails.UserEmail.approval_pending_email()
836 |> Pleroma.Emails.Mailer.deliver_async()
841 defp send_admin_approval_emails(user) do
843 |> Enum.filter(fn user -> not is_nil(user.email) end)
844 |> Enum.each(fn superuser ->
846 |> Pleroma.Emails.AdminEmail.new_unapproved_registration(user)
847 |> Pleroma.Emails.Mailer.deliver_async()
853 def send_welcome_message(user) do
854 if User.WelcomeMessage.enabled?() do
855 User.WelcomeMessage.post_message(user)
862 def send_welcome_chat_message(user) do
863 if User.WelcomeChatMessage.enabled?() do
864 User.WelcomeChatMessage.post_message(user)
871 def send_welcome_email(%User{email: email} = user) when is_binary(email) do
872 if User.WelcomeEmail.enabled?() do
873 User.WelcomeEmail.send_email(user)
880 def send_welcome_email(_), do: {:ok, :noop}
882 @spec try_send_confirmation_email(User.t()) :: {:ok, :enqueued | :noop}
883 def try_send_confirmation_email(%User{confirmation_pending: true, email: email} = user)
884 when is_binary(email) do
885 if Config.get([:instance, :account_activation_required]) do
886 send_confirmation_email(user)
893 def try_send_confirmation_email(_), do: {:ok, :noop}
895 @spec send_confirmation_email(Uset.t()) :: User.t()
896 def send_confirmation_email(%User{} = user) do
898 |> Pleroma.Emails.UserEmail.account_confirmation_email()
899 |> Pleroma.Emails.Mailer.deliver_async()
904 def needs_update?(%User{local: true}), do: false
906 def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
908 def needs_update?(%User{local: false} = user) do
909 NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
912 def needs_update?(_), do: true
914 @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
916 # "Locked" (self-locked) users demand explicit authorization of follow requests
917 def maybe_direct_follow(%User{} = follower, %User{local: true, is_locked: true} = followed) do
918 follow(follower, followed, :follow_pending)
921 def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
922 follow(follower, followed)
925 def maybe_direct_follow(%User{} = follower, %User{} = followed) do
926 if not ap_enabled?(followed) do
927 follow(follower, followed)
929 {:ok, follower, followed}
933 @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
934 @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
935 def follow_all(follower, followeds) do
937 |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
938 |> Enum.each(&follow(follower, &1, :follow_accept))
943 def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
944 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
947 followed.deactivated ->
948 {:error, "Could not follow user: #{followed.nickname} is deactivated."}
950 deny_follow_blocked and blocks?(followed, follower) ->
951 {:error, "Could not follow user: #{followed.nickname} blocked you."}
954 FollowingRelationship.follow(follower, followed, state)
958 def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
959 {:error, "Not subscribed!"}
962 @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
963 def unfollow(%User{} = follower, %User{} = followed) do
964 case do_unfollow(follower, followed) do
965 {:ok, follower, followed} ->
966 {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
973 @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
974 defp do_unfollow(%User{} = follower, %User{} = followed) do
975 case get_follow_state(follower, followed) do
976 state when state in [:follow_pending, :follow_accept] ->
977 FollowingRelationship.unfollow(follower, followed)
980 {:error, "Not subscribed!"}
984 @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
985 def get_follow_state(%User{} = follower, %User{} = following) do
986 following_relationship = FollowingRelationship.get(follower, following)
987 get_follow_state(follower, following, following_relationship)
990 def get_follow_state(
993 following_relationship
995 case {following_relationship, following.local} do
997 case Utils.fetch_latest_follow(follower, following) do
998 %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
999 FollowingRelationship.state_to_enum(state)
1005 {%{state: state}, _} ->
1013 def locked?(%User{} = user) do
1014 user.is_locked || false
1017 def get_by_id(id) do
1018 Repo.get_by(User, id: id)
1021 def get_by_ap_id(ap_id) do
1022 Repo.get_by(User, ap_id: ap_id)
1025 def get_all_by_ap_id(ap_ids) do
1026 from(u in __MODULE__,
1027 where: u.ap_id in ^ap_ids
1032 def get_all_by_ids(ids) do
1033 from(u in __MODULE__, where: u.id in ^ids)
1037 # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
1038 # of the ap_id and the domain and tries to get that user
1039 def get_by_guessed_nickname(ap_id) do
1040 domain = URI.parse(ap_id).host
1041 name = List.last(String.split(ap_id, "/"))
1042 nickname = "#{name}@#{domain}"
1044 get_cached_by_nickname(nickname)
1047 def set_cache({:ok, user}), do: set_cache(user)
1048 def set_cache({:error, err}), do: {:error, err}
1050 def set_cache(%User{} = user) do
1051 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1052 Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
1053 Cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
1057 def update_and_set_cache(struct, params) do
1059 |> update_changeset(params)
1060 |> update_and_set_cache()
1063 def update_and_set_cache(changeset) do
1064 with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
1069 def get_user_friends_ap_ids(user) do
1070 from(u in User.get_friends_query(user), select: u.ap_id)
1074 @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
1075 def get_cached_user_friends_ap_ids(user) do
1076 Cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
1077 get_user_friends_ap_ids(user)
1081 def invalidate_cache(user) do
1082 Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
1083 Cachex.del(:user_cache, "nickname:#{user.nickname}")
1084 Cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
1085 Cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
1086 Cachex.del(:user_cache, "muted_users_ap_ids:#{user.ap_id}")
1089 @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
1090 def get_cached_by_ap_id(ap_id) do
1091 key = "ap_id:#{ap_id}"
1093 with {:ok, nil} <- Cachex.get(:user_cache, key),
1094 user when not is_nil(user) <- get_by_ap_id(ap_id),
1095 {:ok, true} <- Cachex.put(:user_cache, key, user) do
1103 def get_cached_by_id(id) do
1107 Cachex.fetch!(:user_cache, key, fn _ ->
1108 user = get_by_id(id)
1111 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1112 {:commit, user.ap_id}
1118 get_cached_by_ap_id(ap_id)
1121 def get_cached_by_nickname(nickname) do
1122 key = "nickname:#{nickname}"
1124 Cachex.fetch!(:user_cache, key, fn ->
1125 case get_or_fetch_by_nickname(nickname) do
1126 {:ok, user} -> {:commit, user}
1127 {:error, _error} -> {:ignore, nil}
1132 def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
1133 restrict_to_local = Config.get([:instance, :limit_to_local_content])
1136 is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
1137 get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
1139 restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
1140 get_cached_by_nickname(nickname_or_id)
1142 restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
1143 get_cached_by_nickname(nickname_or_id)
1150 @spec get_by_nickname(String.t()) :: User.t() | nil
1151 def get_by_nickname(nickname) do
1152 Repo.get_by(User, nickname: nickname) ||
1153 if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
1154 Repo.get_by(User, nickname: local_nickname(nickname))
1158 def get_by_email(email), do: Repo.get_by(User, email: email)
1160 def get_by_nickname_or_email(nickname_or_email) do
1161 get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
1164 def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
1166 def get_or_fetch_by_nickname(nickname) do
1167 with %User{} = user <- get_by_nickname(nickname) do
1171 with [_nick, _domain] <- String.split(nickname, "@"),
1172 {:ok, user} <- fetch_by_nickname(nickname) do
1175 _e -> {:error, "not found " <> nickname}
1180 @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1181 def get_followers_query(%User{} = user, nil) do
1182 User.Query.build(%{followers: user, deactivated: false})
1185 def get_followers_query(%User{} = user, page) do
1187 |> get_followers_query(nil)
1188 |> User.Query.paginate(page, 20)
1191 @spec get_followers_query(User.t()) :: Ecto.Query.t()
1192 def get_followers_query(%User{} = user), do: get_followers_query(user, nil)
1194 @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1195 def get_followers(%User{} = user, page \\ nil) do
1197 |> get_followers_query(page)
1201 @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1202 def get_external_followers(%User{} = user, page \\ nil) do
1204 |> get_followers_query(page)
1205 |> User.Query.build(%{external: true})
1209 def get_followers_ids(%User{} = user, page \\ nil) do
1211 |> get_followers_query(page)
1212 |> select([u], u.id)
1216 @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1217 def get_friends_query(%User{} = user, nil) do
1218 User.Query.build(%{friends: user, deactivated: false})
1221 def get_friends_query(%User{} = user, page) do
1223 |> get_friends_query(nil)
1224 |> User.Query.paginate(page, 20)
1227 @spec get_friends_query(User.t()) :: Ecto.Query.t()
1228 def get_friends_query(%User{} = user), do: get_friends_query(user, nil)
1230 def get_friends(%User{} = user, page \\ nil) do
1232 |> get_friends_query(page)
1236 def get_friends_ap_ids(%User{} = user) do
1238 |> get_friends_query(nil)
1239 |> select([u], u.ap_id)
1243 def get_friends_ids(%User{} = user, page \\ nil) do
1245 |> get_friends_query(page)
1246 |> select([u], u.id)
1250 def increase_note_count(%User{} = user) do
1252 |> where(id: ^user.id)
1253 |> update([u], inc: [note_count: 1])
1255 |> Repo.update_all([])
1257 {1, [user]} -> set_cache(user)
1262 def decrease_note_count(%User{} = user) do
1264 |> where(id: ^user.id)
1267 note_count: fragment("greatest(0, note_count - 1)")
1271 |> Repo.update_all([])
1273 {1, [user]} -> set_cache(user)
1278 def update_note_count(%User{} = user, note_count \\ nil) do
1283 where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1289 |> cast(%{note_count: note_count}, [:note_count])
1290 |> update_and_set_cache()
1293 @spec maybe_fetch_follow_information(User.t()) :: User.t()
1294 def maybe_fetch_follow_information(user) do
1295 with {:ok, user} <- fetch_follow_information(user) do
1299 Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1305 def fetch_follow_information(user) do
1306 with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1308 |> follow_information_changeset(info)
1309 |> update_and_set_cache()
1313 defp follow_information_changeset(user, params) do
1320 :hide_followers_count,
1325 @spec update_follower_count(User.t()) :: {:ok, User.t()}
1326 def update_follower_count(%User{} = user) do
1327 if user.local or !Config.get([:instance, :external_user_synchronization]) do
1328 follower_count = FollowingRelationship.follower_count(user)
1331 |> follow_information_changeset(%{follower_count: follower_count})
1332 |> update_and_set_cache
1334 {:ok, maybe_fetch_follow_information(user)}
1338 @spec update_following_count(User.t()) :: {:ok, User.t()}
1339 def update_following_count(%User{local: false} = user) do
1340 if Config.get([:instance, :external_user_synchronization]) do
1341 {:ok, maybe_fetch_follow_information(user)}
1347 def update_following_count(%User{local: true} = user) do
1348 following_count = FollowingRelationship.following_count(user)
1351 |> follow_information_changeset(%{following_count: following_count})
1352 |> update_and_set_cache()
1355 @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1356 def get_users_from_set(ap_ids, opts \\ []) do
1357 local_only = Keyword.get(opts, :local_only, true)
1358 criteria = %{ap_id: ap_ids, deactivated: false}
1359 criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1361 User.Query.build(criteria)
1365 @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1366 def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1369 query = User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
1375 @spec mute(User.t(), User.t(), map()) ::
1376 {:ok, list(UserRelationship.t())} | {:error, String.t()}
1377 def mute(%User{} = muter, %User{} = mutee, params \\ %{}) do
1378 notifications? = Map.get(params, :notifications, true)
1379 expires_in = Map.get(params, :expires_in, 0)
1381 with {:ok, user_mute} <- UserRelationship.create_mute(muter, mutee),
1382 {:ok, user_notification_mute} <-
1383 (notifications? && UserRelationship.create_notification_mute(muter, mutee)) ||
1385 if expires_in > 0 do
1386 Pleroma.Workers.MuteExpireWorker.enqueue(
1388 %{"muter_id" => muter.id, "mutee_id" => mutee.id},
1389 schedule_in: expires_in
1393 Cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
1395 {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
1399 def unmute(%User{} = muter, %User{} = mutee) do
1400 with {:ok, user_mute} <- UserRelationship.delete_mute(muter, mutee),
1401 {:ok, user_notification_mute} <-
1402 UserRelationship.delete_notification_mute(muter, mutee) do
1403 Cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
1404 {:ok, [user_mute, user_notification_mute]}
1408 def unmute(muter_id, mutee_id) do
1409 with {:muter, %User{} = muter} <- {:muter, User.get_by_id(muter_id)},
1410 {:mutee, %User{} = mutee} <- {:mutee, User.get_by_id(mutee_id)} do
1411 unmute(muter, mutee)
1413 {who, result} = error ->
1415 "User.unmute/2 failed. #{who}: #{result}, muter_id: #{muter_id}, mutee_id: #{mutee_id}"
1422 def subscribe(%User{} = subscriber, %User{} = target) do
1423 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
1425 if blocks?(target, subscriber) and deny_follow_blocked do
1426 {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1428 # Note: the relationship is inverse: subscriber acts as relationship target
1429 UserRelationship.create_inverse_subscription(target, subscriber)
1433 def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1434 with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1435 subscribe(subscriber, subscribee)
1439 def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1440 # Note: the relationship is inverse: subscriber acts as relationship target
1441 UserRelationship.delete_inverse_subscription(target, unsubscriber)
1444 def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1445 with %User{} = user <- get_cached_by_ap_id(ap_id) do
1446 unsubscribe(unsubscriber, user)
1450 def block(%User{} = blocker, %User{} = blocked) do
1451 # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1453 if following?(blocker, blocked) do
1454 {:ok, blocker, _} = unfollow(blocker, blocked)
1460 # clear any requested follows as well
1462 case CommonAPI.reject_follow_request(blocked, blocker) do
1463 {:ok, %User{} = updated_blocked} -> updated_blocked
1467 unsubscribe(blocked, blocker)
1469 unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
1470 if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)
1472 {:ok, blocker} = update_follower_count(blocker)
1473 {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1474 add_to_block(blocker, blocked)
1477 # helper to handle the block given only an actor's AP id
1478 def block(%User{} = blocker, %{ap_id: ap_id}) do
1479 block(blocker, get_cached_by_ap_id(ap_id))
1482 def unblock(%User{} = blocker, %User{} = blocked) do
1483 remove_from_block(blocker, blocked)
1486 # helper to handle the block given only an actor's AP id
1487 def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1488 unblock(blocker, get_cached_by_ap_id(ap_id))
1491 def mutes?(nil, _), do: false
1492 def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1494 def mutes_user?(%User{} = user, %User{} = target) do
1495 UserRelationship.mute_exists?(user, target)
1498 @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1499 def muted_notifications?(nil, _), do: false
1501 def muted_notifications?(%User{} = user, %User{} = target),
1502 do: UserRelationship.notification_mute_exists?(user, target)
1504 def blocks?(nil, _), do: false
1506 def blocks?(%User{} = user, %User{} = target) do
1507 blocks_user?(user, target) ||
1508 (blocks_domain?(user, target) and not User.following?(user, target))
1511 def blocks_user?(%User{} = user, %User{} = target) do
1512 UserRelationship.block_exists?(user, target)
1515 def blocks_user?(_, _), do: false
1517 def blocks_domain?(%User{} = user, %User{} = target) do
1518 domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1519 %{host: host} = URI.parse(target.ap_id)
1520 Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1523 def blocks_domain?(_, _), do: false
1525 def subscribed_to?(%User{} = user, %User{} = target) do
1526 # Note: the relationship is inverse: subscriber acts as relationship target
1527 UserRelationship.inverse_subscription_exists?(target, user)
1530 def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1531 with %User{} = target <- get_cached_by_ap_id(ap_id) do
1532 subscribed_to?(user, target)
1537 Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1538 E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1540 @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1541 def outgoing_relationships_ap_ids(_user, []), do: %{}
1543 def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1545 def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1546 when is_list(relationship_types) do
1549 |> assoc(:outgoing_relationships)
1550 |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1551 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1552 |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1553 |> group_by([user_rel, u], user_rel.relationship_type)
1555 |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1560 fn rel_type -> {rel_type, db_result[rel_type] || []} end
1564 def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1566 def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1568 def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1570 def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1571 when is_list(relationship_types) do
1573 |> assoc(:incoming_relationships)
1574 |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1575 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1576 |> maybe_filter_on_ap_id(ap_ids)
1577 |> select([user_rel, u], u.ap_id)
1582 defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1583 where(query, [user_rel, u], u.ap_id in ^ap_ids)
1586 defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1588 def deactivate_async(user, status \\ true) do
1589 BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
1592 def deactivate(user, status \\ true)
1594 def deactivate(users, status) when is_list(users) do
1595 Repo.transaction(fn ->
1596 for user <- users, do: deactivate(user, status)
1600 def deactivate(%User{} = user, status) do
1601 with {:ok, user} <- set_activation_status(user, status) do
1604 |> Enum.filter(& &1.local)
1605 |> Enum.each(&set_cache(update_following_count(&1)))
1607 # Only update local user counts, remote will be update during the next pull.
1610 |> Enum.filter(& &1.local)
1611 |> Enum.each(&do_unfollow(user, &1))
1617 def approve(users) when is_list(users) do
1618 Repo.transaction(fn ->
1619 Enum.map(users, fn user ->
1620 with {:ok, user} <- approve(user), do: user
1625 def approve(%User{approval_pending: true} = user) do
1626 with chg <- change(user, approval_pending: false),
1627 {:ok, user} <- update_and_set_cache(chg) do
1628 post_register_action(user)
1633 def approve(%User{} = user), do: {:ok, user}
1635 def confirm(users) when is_list(users) do
1636 Repo.transaction(fn ->
1637 Enum.map(users, fn user ->
1638 with {:ok, user} <- confirm(user), do: user
1643 def confirm(%User{confirmation_pending: true} = user) do
1644 with chg <- confirmation_changeset(user, need_confirmation: false),
1645 {:ok, user} <- update_and_set_cache(chg) do
1646 post_register_action(user)
1651 def confirm(%User{} = user), do: {:ok, user}
1653 def update_notification_settings(%User{} = user, settings) do
1655 |> cast(%{notification_settings: settings}, [])
1656 |> cast_embed(:notification_settings)
1657 |> validate_required([:notification_settings])
1658 |> update_and_set_cache()
1661 @spec purge_user_changeset(User.t()) :: Changeset.t()
1662 def purge_user_changeset(user) do
1663 # "Right to be forgotten"
1664 # https://gdpr.eu/right-to-be-forgotten/
1675 last_refreshed_at: nil,
1676 last_digest_emailed_at: nil,
1683 confirmation_pending: false,
1684 password_reset_pending: false,
1685 approval_pending: false,
1686 registration_reason: nil,
1687 confirmation_token: nil,
1691 is_moderator: false,
1693 mastofe_settings: nil,
1696 pleroma_settings_store: %{},
1699 is_discoverable: false,
1704 def delete(users) when is_list(users) do
1705 for user <- users, do: delete(user)
1708 def delete(%User{} = user) do
1709 BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1712 defp delete_and_invalidate_cache(%User{} = user) do
1713 invalidate_cache(user)
1717 defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)
1719 defp delete_or_deactivate(%User{local: true} = user) do
1720 status = account_status(user)
1723 :confirmation_pending ->
1724 delete_and_invalidate_cache(user)
1726 :approval_pending ->
1727 delete_and_invalidate_cache(user)
1731 |> purge_user_changeset()
1732 |> update_and_set_cache()
1736 def perform(:force_password_reset, user), do: force_password_reset(user)
1738 @spec perform(atom(), User.t()) :: {:ok, User.t()}
1739 def perform(:delete, %User{} = user) do
1740 # Remove all relationships
1743 |> Enum.each(fn follower ->
1744 ActivityPub.unfollow(follower, user)
1745 unfollow(follower, user)
1750 |> Enum.each(fn followed ->
1751 ActivityPub.unfollow(user, followed)
1752 unfollow(user, followed)
1755 delete_user_activities(user)
1756 delete_notifications_from_user_activities(user)
1758 delete_outgoing_pending_follow_requests(user)
1760 delete_or_deactivate(user)
1763 def perform(:deactivate_async, user, status), do: deactivate(user, status)
1765 @spec external_users_query() :: Ecto.Query.t()
1766 def external_users_query do
1774 @spec external_users(keyword()) :: [User.t()]
1775 def external_users(opts \\ []) do
1777 external_users_query()
1778 |> select([u], struct(u, [:id, :ap_id]))
1782 do: where(query, [u], u.id > ^opts[:max_id]),
1787 do: limit(query, ^opts[:limit]),
1793 def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1795 |> join(:inner, [n], activity in assoc(n, :activity))
1796 |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1797 |> Repo.delete_all()
1800 def delete_user_activities(%User{ap_id: ap_id} = user) do
1802 |> Activity.Queries.by_actor()
1803 |> Repo.chunk_stream(50, :batches)
1804 |> Stream.each(fn activities ->
1805 Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1810 defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1811 with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1812 {:ok, delete_data, _} <- Builder.delete(user, object) do
1813 Pipeline.common_pipeline(delete_data, local: user.local)
1815 {:find_object, nil} ->
1816 # We have the create activity, but not the object, it was probably pruned.
1817 # Insert a tombstone and try again
1818 with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1819 {:ok, _tombstone} <- Object.create(tombstone_data) do
1820 delete_activity(activity, user)
1824 Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1825 Logger.error("Error: #{inspect(e)}")
1829 defp delete_activity(%{data: %{"type" => type}} = activity, user)
1830 when type in ["Like", "Announce"] do
1831 {:ok, undo, _} = Builder.undo(user, activity)
1832 Pipeline.common_pipeline(undo, local: user.local)
1835 defp delete_activity(_activity, _user), do: "Doing nothing"
1837 defp delete_outgoing_pending_follow_requests(user) do
1839 |> FollowingRelationship.outgoing_pending_follow_requests_query()
1840 |> Repo.delete_all()
1843 def html_filter_policy(%User{no_rich_text: true}) do
1844 Pleroma.HTML.Scrubber.TwitterText
1847 def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])
1849 def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1851 def get_or_fetch_by_ap_id(ap_id) do
1852 cached_user = get_cached_by_ap_id(ap_id)
1854 maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)
1856 case {cached_user, maybe_fetched_user} do
1857 {_, {:ok, %User{} = user}} ->
1860 {%User{} = user, _} ->
1864 {:error, :not_found}
1869 Creates an internal service actor by URI if missing.
1870 Optionally takes nickname for addressing.
1872 @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1873 def get_or_create_service_actor_by_ap_id(uri, nickname) do
1875 case get_cached_by_ap_id(uri) do
1877 with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1878 Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1882 %User{invisible: false} = user ->
1892 @spec set_invisible(User.t()) :: {:ok, User.t()}
1893 defp set_invisible(user) do
1895 |> change(%{invisible: true})
1896 |> update_and_set_cache()
1899 @spec create_service_actor(String.t(), String.t()) ::
1900 {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1901 defp create_service_actor(uri, nickname) do
1907 follower_address: uri <> "/followers"
1910 |> unique_constraint(:nickname)
1915 def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1918 |> :public_key.pem_decode()
1920 |> :public_key.pem_entry_decode()
1925 def public_key(_), do: {:error, "key not found"}
1927 def get_public_key_for_ap_id(ap_id) do
1928 with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1929 {:ok, public_key} <- public_key(user) do
1936 def ap_enabled?(%User{local: true}), do: true
1937 def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1938 def ap_enabled?(_), do: false
1940 @doc "Gets or fetch a user by uri or nickname."
1941 @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1942 def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1943 def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1945 # wait a period of time and return newest version of the User structs
1946 # this is because we have synchronous follow APIs and need to simulate them
1947 # with an async handshake
1948 def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1949 with %User{} = a <- get_cached_by_id(a.id),
1950 %User{} = b <- get_cached_by_id(b.id) do
1957 def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1958 with :ok <- :timer.sleep(timeout),
1959 %User{} = a <- get_cached_by_id(a.id),
1960 %User{} = b <- get_cached_by_id(b.id) do
1967 def parse_bio(bio) when is_binary(bio) and bio != "" do
1969 |> CommonUtils.format_input("text/plain", mentions_format: :full)
1973 def parse_bio(_), do: ""
1975 def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1976 # TODO: get profile URLs other than user.ap_id
1977 profile_urls = [user.ap_id]
1980 |> CommonUtils.format_input("text/plain",
1981 mentions_format: :full,
1982 rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1987 def parse_bio(_, _), do: ""
1989 def tag(user_identifiers, tags) when is_list(user_identifiers) do
1990 Repo.transaction(fn ->
1991 for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1995 def tag(nickname, tags) when is_binary(nickname),
1996 do: tag(get_by_nickname(nickname), tags)
1998 def tag(%User{} = user, tags),
1999 do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
2001 def untag(user_identifiers, tags) when is_list(user_identifiers) do
2002 Repo.transaction(fn ->
2003 for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
2007 def untag(nickname, tags) when is_binary(nickname),
2008 do: untag(get_by_nickname(nickname), tags)
2010 def untag(%User{} = user, tags),
2011 do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
2013 defp update_tags(%User{} = user, new_tags) do
2014 {:ok, updated_user} =
2016 |> change(%{tags: new_tags})
2017 |> update_and_set_cache()
2022 defp normalize_tags(tags) do
2025 |> Enum.map(&String.downcase/1)
2028 defp local_nickname_regex do
2029 if Config.get([:instance, :extended_nickname_format]) do
2030 @extended_local_nickname_regex
2032 @strict_local_nickname_regex
2036 def local_nickname(nickname_or_mention) do
2039 |> String.split("@")
2043 def full_nickname(nickname_or_mention),
2044 do: String.trim_leading(nickname_or_mention, "@")
2046 def error_user(ap_id) do
2050 nickname: "erroruser@example.com",
2051 inserted_at: NaiveDateTime.utc_now()
2055 @spec all_superusers() :: [User.t()]
2056 def all_superusers do
2057 User.Query.build(%{super_users: true, local: true, deactivated: false})
2061 def muting_reblogs?(%User{} = user, %User{} = target) do
2062 UserRelationship.reblog_mute_exists?(user, target)
2065 def showing_reblogs?(%User{} = user, %User{} = target) do
2066 not muting_reblogs?(user, target)
2070 The function returns a query to get users with no activity for given interval of days.
2071 Inactive users are those who didn't read any notification, or had any activity where
2072 the user is the activity's actor, during `inactivity_threshold` days.
2073 Deactivated users will not appear in this list.
2077 iex> Pleroma.User.list_inactive_users()
2080 @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
2081 def list_inactive_users_query(inactivity_threshold \\ 7) do
2082 negative_inactivity_threshold = -inactivity_threshold
2083 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2084 # Subqueries are not supported in `where` clauses, join gets too complicated.
2085 has_read_notifications =
2086 from(n in Pleroma.Notification,
2087 where: n.seen == true,
2089 having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
2092 |> Pleroma.Repo.all()
2094 from(u in Pleroma.User,
2095 left_join: a in Pleroma.Activity,
2096 on: u.ap_id == a.actor,
2097 where: not is_nil(u.nickname),
2098 where: u.deactivated != ^true,
2099 where: u.id not in ^has_read_notifications,
2102 max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
2103 is_nil(max(a.inserted_at))
2108 Enable or disable email notifications for user
2112 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
2113 Pleroma.User{email_notifications: %{"digest" => true}}
2115 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
2116 Pleroma.User{email_notifications: %{"digest" => false}}
2118 @spec switch_email_notifications(t(), String.t(), boolean()) ::
2119 {:ok, t()} | {:error, Ecto.Changeset.t()}
2120 def switch_email_notifications(user, type, status) do
2121 User.update_email_notifications(user, %{type => status})
2125 Set `last_digest_emailed_at` value for the user to current time
2127 @spec touch_last_digest_emailed_at(t()) :: t()
2128 def touch_last_digest_emailed_at(user) do
2129 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2131 {:ok, updated_user} =
2133 |> change(%{last_digest_emailed_at: now})
2134 |> update_and_set_cache()
2139 @spec need_confirmation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
2140 def need_confirmation(%User{} = user, bool) do
2142 |> confirmation_changeset(need_confirmation: bool)
2143 |> update_and_set_cache()
2146 def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
2150 def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
2151 # use instance-default
2152 config = Config.get([:assets, :mascots])
2153 default_mascot = Config.get([:assets, :default_mascot])
2154 mascot = Keyword.get(config, default_mascot)
2157 "id" => "default-mascot",
2158 "url" => mascot[:url],
2159 "preview_url" => mascot[:url],
2161 "mime_type" => mascot[:mime_type]
2166 def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
2168 def ensure_keys_present(%User{} = user) do
2169 with {:ok, pem} <- Keys.generate_rsa_pem() do
2171 |> cast(%{keys: pem}, [:keys])
2172 |> validate_required([:keys])
2173 |> update_and_set_cache()
2177 def get_ap_ids_by_nicknames(nicknames) do
2179 where: u.nickname in ^nicknames,
2185 defp put_password_hash(
2186 %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2188 change(changeset, password_hash: Pbkdf2.hash_pwd_salt(password))
2191 defp put_password_hash(changeset), do: changeset
2193 def is_internal_user?(%User{nickname: nil}), do: true
2194 def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2195 def is_internal_user?(_), do: false
2197 # A hack because user delete activities have a fake id for whatever reason
2198 # TODO: Get rid of this
2199 def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2201 def get_delivered_users_by_object_id(object_id) do
2203 inner_join: delivery in assoc(u, :deliveries),
2204 where: delivery.object_id == ^object_id
2209 def change_email(user, email) do
2211 |> cast(%{email: email}, [:email])
2212 |> validate_required([:email])
2213 |> unique_constraint(:email)
2214 |> validate_format(:email, @email_regex)
2215 |> update_and_set_cache()
2218 # Internal function; public one is `deactivate/2`
2219 defp set_activation_status(user, deactivated) do
2221 |> cast(%{deactivated: deactivated}, [:deactivated])
2222 |> update_and_set_cache()
2225 def update_banner(user, banner) do
2227 |> cast(%{banner: banner}, [:banner])
2228 |> update_and_set_cache()
2231 def update_background(user, background) do
2233 |> cast(%{background: background}, [:background])
2234 |> update_and_set_cache()
2237 def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
2240 moderator: is_moderator
2244 def validate_fields(changeset, remote? \\ false) do
2245 limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2246 limit = Config.get([:instance, limit_name], 0)
2249 |> validate_length(:fields, max: limit)
2250 |> validate_change(:fields, fn :fields, fields ->
2251 if Enum.all?(fields, &valid_field?/1) do
2259 defp valid_field?(%{"name" => name, "value" => value}) do
2260 name_limit = Config.get([:instance, :account_field_name_length], 255)
2261 value_limit = Config.get([:instance, :account_field_value_length], 255)
2263 is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2264 String.length(value) <= value_limit
2267 defp valid_field?(_), do: false
2269 defp truncate_field(%{"name" => name, "value" => value}) do
2271 String.split_at(name, Config.get([:instance, :account_field_name_length], 255))
2274 String.split_at(value, Config.get([:instance, :account_field_value_length], 255))
2276 %{"name" => name, "value" => value}
2279 def admin_api_update(user, params) do
2286 |> update_and_set_cache()
2289 @doc "Signs user out of all applications"
2290 def global_sign_out(user) do
2291 OAuth.Authorization.delete_user_authorizations(user)
2292 OAuth.Token.delete_user_tokens(user)
2295 def mascot_update(user, url) do
2297 |> cast(%{mascot: url}, [:mascot])
2298 |> validate_required([:mascot])
2299 |> update_and_set_cache()
2302 def mastodon_settings_update(user, settings) do
2304 |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
2305 |> validate_required([:mastofe_settings])
2306 |> update_and_set_cache()
2309 @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2310 def confirmation_changeset(user, need_confirmation: need_confirmation?) do
2312 if need_confirmation? do
2314 confirmation_pending: true,
2315 confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2319 confirmation_pending: false,
2320 confirmation_token: nil
2324 cast(user, params, [:confirmation_pending, :confirmation_token])
2327 @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
2328 def approval_changeset(user, need_approval: need_approval?) do
2329 params = if need_approval?, do: %{approval_pending: true}, else: %{approval_pending: false}
2330 cast(user, params, [:approval_pending])
2333 def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2334 if id not in user.pinned_activities do
2335 max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2336 params = %{pinned_activities: user.pinned_activities ++ [id]}
2338 # if pinned activity was scheduled for deletion, we remove job
2339 if expiration = Pleroma.Workers.PurgeExpiredActivity.get_expiration(id) do
2340 Oban.cancel_job(expiration.id)
2344 |> cast(params, [:pinned_activities])
2345 |> validate_length(:pinned_activities,
2346 max: max_pinned_statuses,
2347 message: "You have already pinned the maximum number of statuses"
2352 |> update_and_set_cache()
2355 def remove_pinnned_activity(user, %Pleroma.Activity{id: id, data: data}) do
2356 params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2358 # if pinned activity was scheduled for deletion, we reschedule it for deletion
2359 if data["expires_at"] do
2360 # MRF.ActivityExpirationPolicy used UTC timestamps for expires_at in original implementation
2362 data["expires_at"] |> Pleroma.EctoType.ActivityPub.ObjectValidators.DateTime.cast()
2364 Pleroma.Workers.PurgeExpiredActivity.enqueue(%{
2366 expires_at: expires_at
2371 |> cast(params, [:pinned_activities])
2372 |> update_and_set_cache()
2375 def update_email_notifications(user, settings) do
2376 email_notifications =
2377 user.email_notifications
2378 |> Map.merge(settings)
2379 |> Map.take(["digest"])
2381 params = %{email_notifications: email_notifications}
2382 fields = [:email_notifications]
2385 |> cast(params, fields)
2386 |> validate_required(fields)
2387 |> update_and_set_cache()
2390 defp set_domain_blocks(user, domain_blocks) do
2391 params = %{domain_blocks: domain_blocks}
2394 |> cast(params, [:domain_blocks])
2395 |> validate_required([:domain_blocks])
2396 |> update_and_set_cache()
2399 def block_domain(user, domain_blocked) do
2400 set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2403 def unblock_domain(user, domain_blocked) do
2404 set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2407 @spec add_to_block(User.t(), User.t()) ::
2408 {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2409 defp add_to_block(%User{} = user, %User{} = blocked) do
2410 with {:ok, relationship} <- UserRelationship.create_block(user, blocked) do
2411 Cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
2416 @spec add_to_block(User.t(), User.t()) ::
2417 {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2418 defp remove_from_block(%User{} = user, %User{} = blocked) do
2419 with {:ok, relationship} <- UserRelationship.delete_block(user, blocked) do
2420 Cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
2425 def set_invisible(user, invisible) do
2426 params = %{invisible: invisible}
2429 |> cast(params, [:invisible])
2430 |> validate_required([:invisible])
2431 |> update_and_set_cache()
2434 def sanitize_html(%User{} = user) do
2435 sanitize_html(user, nil)
2438 # User data that mastodon isn't filtering (treated as plaintext):
2441 def sanitize_html(%User{} = user, filter) do
2443 Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2446 "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2451 |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2452 |> Map.put(:fields, fields)
2455 def get_host(%User{ap_id: ap_id} = _user) do
2456 URI.parse(ap_id).host