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{} = user) do
810 with {:ok, user} <- autofollow_users(user),
811 {:ok, _} <- autofollowing_users(user),
812 {:ok, user} <- set_cache(user),
813 {:ok, _} <- send_welcome_email(user),
814 {:ok, _} <- send_welcome_message(user),
815 {:ok, _} <- send_welcome_chat_message(user),
816 {:ok, _} <- try_send_confirmation_email(user) do
821 def send_welcome_message(user) do
822 if User.WelcomeMessage.enabled?() do
823 User.WelcomeMessage.post_message(user)
830 def send_welcome_chat_message(user) do
831 if User.WelcomeChatMessage.enabled?() do
832 User.WelcomeChatMessage.post_message(user)
839 def send_welcome_email(%User{email: email} = user) when is_binary(email) do
840 if User.WelcomeEmail.enabled?() do
841 User.WelcomeEmail.send_email(user)
848 def send_welcome_email(_), do: {:ok, :noop}
850 @spec try_send_confirmation_email(User.t()) :: {:ok, :enqueued | :noop}
851 def try_send_confirmation_email(%User{confirmation_pending: true, email: email} = user)
852 when is_binary(email) do
853 if Config.get([:instance, :account_activation_required]) do
854 send_confirmation_email(user)
861 def try_send_confirmation_email(_), do: {:ok, :noop}
863 @spec send_confirmation_email(Uset.t()) :: User.t()
864 def send_confirmation_email(%User{} = user) do
866 |> Pleroma.Emails.UserEmail.account_confirmation_email()
867 |> Pleroma.Emails.Mailer.deliver_async()
872 def needs_update?(%User{local: true}), do: false
874 def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
876 def needs_update?(%User{local: false} = user) do
877 NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
880 def needs_update?(_), do: true
882 @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
884 # "Locked" (self-locked) users demand explicit authorization of follow requests
885 def maybe_direct_follow(%User{} = follower, %User{local: true, is_locked: true} = followed) do
886 follow(follower, followed, :follow_pending)
889 def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
890 follow(follower, followed)
893 def maybe_direct_follow(%User{} = follower, %User{} = followed) do
894 if not ap_enabled?(followed) do
895 follow(follower, followed)
901 @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
902 @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
903 def follow_all(follower, followeds) do
905 |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
906 |> Enum.each(&follow(follower, &1, :follow_accept))
911 def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
912 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
915 followed.deactivated ->
916 {:error, "Could not follow user: #{followed.nickname} is deactivated."}
918 deny_follow_blocked and blocks?(followed, follower) ->
919 {:error, "Could not follow user: #{followed.nickname} blocked you."}
922 FollowingRelationship.follow(follower, followed, state)
924 {:ok, _} = update_follower_count(followed)
927 |> update_following_count()
931 def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
932 {:error, "Not subscribed!"}
935 @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
936 def unfollow(%User{} = follower, %User{} = followed) do
937 case do_unfollow(follower, followed) do
938 {:ok, follower, followed} ->
939 {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
946 @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
947 defp do_unfollow(%User{} = follower, %User{} = followed) do
948 case get_follow_state(follower, followed) do
949 state when state in [:follow_pending, :follow_accept] ->
950 FollowingRelationship.unfollow(follower, followed)
951 {:ok, followed} = update_follower_count(followed)
953 {:ok, follower} = update_following_count(follower)
955 {:ok, follower, followed}
958 {:error, "Not subscribed!"}
962 @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
963 def get_follow_state(%User{} = follower, %User{} = following) do
964 following_relationship = FollowingRelationship.get(follower, following)
965 get_follow_state(follower, following, following_relationship)
968 def get_follow_state(
971 following_relationship
973 case {following_relationship, following.local} do
975 case Utils.fetch_latest_follow(follower, following) do
976 %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
977 FollowingRelationship.state_to_enum(state)
983 {%{state: state}, _} ->
991 def locked?(%User{} = user) do
992 user.is_locked || false
996 Repo.get_by(User, id: id)
999 def get_by_ap_id(ap_id) do
1000 Repo.get_by(User, ap_id: ap_id)
1003 def get_all_by_ap_id(ap_ids) do
1004 from(u in __MODULE__,
1005 where: u.ap_id in ^ap_ids
1010 def get_all_by_ids(ids) do
1011 from(u in __MODULE__, where: u.id in ^ids)
1015 # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
1016 # of the ap_id and the domain and tries to get that user
1017 def get_by_guessed_nickname(ap_id) do
1018 domain = URI.parse(ap_id).host
1019 name = List.last(String.split(ap_id, "/"))
1020 nickname = "#{name}@#{domain}"
1022 get_cached_by_nickname(nickname)
1025 def set_cache({:ok, user}), do: set_cache(user)
1026 def set_cache({:error, err}), do: {:error, err}
1028 def set_cache(%User{} = user) do
1029 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1030 Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
1031 Cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
1035 def update_and_set_cache(struct, params) do
1037 |> update_changeset(params)
1038 |> update_and_set_cache()
1041 def update_and_set_cache(changeset) do
1042 with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
1047 def get_user_friends_ap_ids(user) do
1048 from(u in User.get_friends_query(user), select: u.ap_id)
1052 @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
1053 def get_cached_user_friends_ap_ids(user) do
1054 Cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
1055 get_user_friends_ap_ids(user)
1059 def invalidate_cache(user) do
1060 Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
1061 Cachex.del(:user_cache, "nickname:#{user.nickname}")
1062 Cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
1063 Cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
1064 Cachex.del(:user_cache, "muted_users_ap_ids:#{user.ap_id}")
1067 @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
1068 def get_cached_by_ap_id(ap_id) do
1069 key = "ap_id:#{ap_id}"
1071 with {:ok, nil} <- Cachex.get(:user_cache, key),
1072 user when not is_nil(user) <- get_by_ap_id(ap_id),
1073 {:ok, true} <- Cachex.put(:user_cache, key, user) do
1081 def get_cached_by_id(id) do
1085 Cachex.fetch!(:user_cache, key, fn _ ->
1086 user = get_by_id(id)
1089 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1090 {:commit, user.ap_id}
1096 get_cached_by_ap_id(ap_id)
1099 def get_cached_by_nickname(nickname) do
1100 key = "nickname:#{nickname}"
1102 Cachex.fetch!(:user_cache, key, fn ->
1103 case get_or_fetch_by_nickname(nickname) do
1104 {:ok, user} -> {:commit, user}
1105 {:error, _error} -> {:ignore, nil}
1110 def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
1111 restrict_to_local = Config.get([:instance, :limit_to_local_content])
1114 is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
1115 get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
1117 restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
1118 get_cached_by_nickname(nickname_or_id)
1120 restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
1121 get_cached_by_nickname(nickname_or_id)
1128 @spec get_by_nickname(String.t()) :: User.t() | nil
1129 def get_by_nickname(nickname) do
1130 Repo.get_by(User, nickname: nickname) ||
1131 if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
1132 Repo.get_by(User, nickname: local_nickname(nickname))
1136 def get_by_email(email), do: Repo.get_by(User, email: email)
1138 def get_by_nickname_or_email(nickname_or_email) do
1139 get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
1142 def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
1144 def get_or_fetch_by_nickname(nickname) do
1145 with %User{} = user <- get_by_nickname(nickname) do
1149 with [_nick, _domain] <- String.split(nickname, "@"),
1150 {:ok, user} <- fetch_by_nickname(nickname) do
1153 _e -> {:error, "not found " <> nickname}
1158 @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1159 def get_followers_query(%User{} = user, nil) do
1160 User.Query.build(%{followers: user, deactivated: false})
1163 def get_followers_query(%User{} = user, page) do
1165 |> get_followers_query(nil)
1166 |> User.Query.paginate(page, 20)
1169 @spec get_followers_query(User.t()) :: Ecto.Query.t()
1170 def get_followers_query(%User{} = user), do: get_followers_query(user, nil)
1172 @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1173 def get_followers(%User{} = user, page \\ nil) do
1175 |> get_followers_query(page)
1179 @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1180 def get_external_followers(%User{} = user, page \\ nil) do
1182 |> get_followers_query(page)
1183 |> User.Query.build(%{external: true})
1187 def get_followers_ids(%User{} = user, page \\ nil) do
1189 |> get_followers_query(page)
1190 |> select([u], u.id)
1194 @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1195 def get_friends_query(%User{} = user, nil) do
1196 User.Query.build(%{friends: user, deactivated: false})
1199 def get_friends_query(%User{} = user, page) do
1201 |> get_friends_query(nil)
1202 |> User.Query.paginate(page, 20)
1205 @spec get_friends_query(User.t()) :: Ecto.Query.t()
1206 def get_friends_query(%User{} = user), do: get_friends_query(user, nil)
1208 def get_friends(%User{} = user, page \\ nil) do
1210 |> get_friends_query(page)
1214 def get_friends_ap_ids(%User{} = user) do
1216 |> get_friends_query(nil)
1217 |> select([u], u.ap_id)
1221 def get_friends_ids(%User{} = user, page \\ nil) do
1223 |> get_friends_query(page)
1224 |> select([u], u.id)
1228 def increase_note_count(%User{} = user) do
1230 |> where(id: ^user.id)
1231 |> update([u], inc: [note_count: 1])
1233 |> Repo.update_all([])
1235 {1, [user]} -> set_cache(user)
1240 def decrease_note_count(%User{} = user) do
1242 |> where(id: ^user.id)
1245 note_count: fragment("greatest(0, note_count - 1)")
1249 |> Repo.update_all([])
1251 {1, [user]} -> set_cache(user)
1256 def update_note_count(%User{} = user, note_count \\ nil) do
1261 where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1267 |> cast(%{note_count: note_count}, [:note_count])
1268 |> update_and_set_cache()
1271 @spec maybe_fetch_follow_information(User.t()) :: User.t()
1272 def maybe_fetch_follow_information(user) do
1273 with {:ok, user} <- fetch_follow_information(user) do
1277 Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1283 def fetch_follow_information(user) do
1284 with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1286 |> follow_information_changeset(info)
1287 |> update_and_set_cache()
1291 defp follow_information_changeset(user, params) do
1298 :hide_followers_count,
1303 @spec update_follower_count(User.t()) :: {:ok, User.t()}
1304 def update_follower_count(%User{} = user) do
1305 if user.local or !Config.get([:instance, :external_user_synchronization]) do
1306 follower_count = FollowingRelationship.follower_count(user)
1309 |> follow_information_changeset(%{follower_count: follower_count})
1310 |> update_and_set_cache
1312 {:ok, maybe_fetch_follow_information(user)}
1316 @spec update_following_count(User.t()) :: {:ok, User.t()}
1317 def update_following_count(%User{local: false} = user) do
1318 if Config.get([:instance, :external_user_synchronization]) do
1319 {:ok, maybe_fetch_follow_information(user)}
1325 def update_following_count(%User{local: true} = user) do
1326 following_count = FollowingRelationship.following_count(user)
1329 |> follow_information_changeset(%{following_count: following_count})
1330 |> update_and_set_cache()
1333 @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1334 def get_users_from_set(ap_ids, opts \\ []) do
1335 local_only = Keyword.get(opts, :local_only, true)
1336 criteria = %{ap_id: ap_ids, deactivated: false}
1337 criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1339 User.Query.build(criteria)
1343 @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1344 def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1347 query = User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
1353 @spec mute(User.t(), User.t(), map()) ::
1354 {:ok, list(UserRelationship.t())} | {:error, String.t()}
1355 def mute(%User{} = muter, %User{} = mutee, params \\ %{}) do
1356 notifications? = Map.get(params, :notifications, true)
1357 expires_in = Map.get(params, :expires_in, 0)
1359 with {:ok, user_mute} <- UserRelationship.create_mute(muter, mutee),
1360 {:ok, user_notification_mute} <-
1361 (notifications? && UserRelationship.create_notification_mute(muter, mutee)) ||
1363 if expires_in > 0 do
1364 Pleroma.Workers.MuteExpireWorker.enqueue(
1366 %{"muter_id" => muter.id, "mutee_id" => mutee.id},
1367 schedule_in: expires_in
1371 Cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
1373 {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
1377 def unmute(%User{} = muter, %User{} = mutee) do
1378 with {:ok, user_mute} <- UserRelationship.delete_mute(muter, mutee),
1379 {:ok, user_notification_mute} <-
1380 UserRelationship.delete_notification_mute(muter, mutee) do
1381 Cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
1382 {:ok, [user_mute, user_notification_mute]}
1386 def unmute(muter_id, mutee_id) do
1387 with {:muter, %User{} = muter} <- {:muter, User.get_by_id(muter_id)},
1388 {:mutee, %User{} = mutee} <- {:mutee, User.get_by_id(mutee_id)} do
1389 unmute(muter, mutee)
1391 {who, result} = error ->
1393 "User.unmute/2 failed. #{who}: #{result}, muter_id: #{muter_id}, mutee_id: #{mutee_id}"
1400 def subscribe(%User{} = subscriber, %User{} = target) do
1401 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
1403 if blocks?(target, subscriber) and deny_follow_blocked do
1404 {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1406 # Note: the relationship is inverse: subscriber acts as relationship target
1407 UserRelationship.create_inverse_subscription(target, subscriber)
1411 def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1412 with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1413 subscribe(subscriber, subscribee)
1417 def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1418 # Note: the relationship is inverse: subscriber acts as relationship target
1419 UserRelationship.delete_inverse_subscription(target, unsubscriber)
1422 def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1423 with %User{} = user <- get_cached_by_ap_id(ap_id) do
1424 unsubscribe(unsubscriber, user)
1428 def block(%User{} = blocker, %User{} = blocked) do
1429 # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1431 if following?(blocker, blocked) do
1432 {:ok, blocker, _} = unfollow(blocker, blocked)
1438 # clear any requested follows as well
1440 case CommonAPI.reject_follow_request(blocked, blocker) do
1441 {:ok, %User{} = updated_blocked} -> updated_blocked
1445 unsubscribe(blocked, blocker)
1447 unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
1448 if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)
1450 {:ok, blocker} = update_follower_count(blocker)
1451 {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1452 add_to_block(blocker, blocked)
1455 # helper to handle the block given only an actor's AP id
1456 def block(%User{} = blocker, %{ap_id: ap_id}) do
1457 block(blocker, get_cached_by_ap_id(ap_id))
1460 def unblock(%User{} = blocker, %User{} = blocked) do
1461 remove_from_block(blocker, blocked)
1464 # helper to handle the block given only an actor's AP id
1465 def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1466 unblock(blocker, get_cached_by_ap_id(ap_id))
1469 def mutes?(nil, _), do: false
1470 def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1472 def mutes_user?(%User{} = user, %User{} = target) do
1473 UserRelationship.mute_exists?(user, target)
1476 @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1477 def muted_notifications?(nil, _), do: false
1479 def muted_notifications?(%User{} = user, %User{} = target),
1480 do: UserRelationship.notification_mute_exists?(user, target)
1482 def blocks?(nil, _), do: false
1484 def blocks?(%User{} = user, %User{} = target) do
1485 blocks_user?(user, target) ||
1486 (blocks_domain?(user, target) and not User.following?(user, target))
1489 def blocks_user?(%User{} = user, %User{} = target) do
1490 UserRelationship.block_exists?(user, target)
1493 def blocks_user?(_, _), do: false
1495 def blocks_domain?(%User{} = user, %User{} = target) do
1496 domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1497 %{host: host} = URI.parse(target.ap_id)
1498 Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1501 def blocks_domain?(_, _), do: false
1503 def subscribed_to?(%User{} = user, %User{} = target) do
1504 # Note: the relationship is inverse: subscriber acts as relationship target
1505 UserRelationship.inverse_subscription_exists?(target, user)
1508 def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1509 with %User{} = target <- get_cached_by_ap_id(ap_id) do
1510 subscribed_to?(user, target)
1515 Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1516 E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1518 @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1519 def outgoing_relationships_ap_ids(_user, []), do: %{}
1521 def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1523 def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1524 when is_list(relationship_types) do
1527 |> assoc(:outgoing_relationships)
1528 |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1529 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1530 |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1531 |> group_by([user_rel, u], user_rel.relationship_type)
1533 |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1538 fn rel_type -> {rel_type, db_result[rel_type] || []} end
1542 def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1544 def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1546 def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1548 def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1549 when is_list(relationship_types) do
1551 |> assoc(:incoming_relationships)
1552 |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1553 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1554 |> maybe_filter_on_ap_id(ap_ids)
1555 |> select([user_rel, u], u.ap_id)
1560 defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1561 where(query, [user_rel, u], u.ap_id in ^ap_ids)
1564 defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1566 def deactivate_async(user, status \\ true) do
1567 BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
1570 def deactivate(user, status \\ true)
1572 def deactivate(users, status) when is_list(users) do
1573 Repo.transaction(fn ->
1574 for user <- users, do: deactivate(user, status)
1578 def deactivate(%User{} = user, status) do
1579 with {:ok, user} <- set_activation_status(user, status) do
1582 |> Enum.filter(& &1.local)
1583 |> Enum.each(&set_cache(update_following_count(&1)))
1585 # Only update local user counts, remote will be update during the next pull.
1588 |> Enum.filter(& &1.local)
1589 |> Enum.each(&do_unfollow(user, &1))
1595 def approve(users) when is_list(users) do
1596 Repo.transaction(fn ->
1597 Enum.map(users, fn user ->
1598 with {:ok, user} <- approve(user), do: user
1603 def approve(%User{} = user) do
1604 change(user, approval_pending: false)
1605 |> update_and_set_cache()
1608 def update_notification_settings(%User{} = user, settings) do
1610 |> cast(%{notification_settings: settings}, [])
1611 |> cast_embed(:notification_settings)
1612 |> validate_required([:notification_settings])
1613 |> update_and_set_cache()
1616 @spec purge_user_changeset(User.t()) :: Changeset.t()
1617 def purge_user_changeset(user) do
1618 # "Right to be forgotten"
1619 # https://gdpr.eu/right-to-be-forgotten/
1630 last_refreshed_at: nil,
1631 last_digest_emailed_at: nil,
1638 confirmation_pending: false,
1639 password_reset_pending: false,
1640 approval_pending: false,
1641 registration_reason: nil,
1642 confirmation_token: nil,
1646 is_moderator: false,
1648 mastofe_settings: nil,
1651 pleroma_settings_store: %{},
1654 is_discoverable: false,
1659 def delete(users) when is_list(users) do
1660 for user <- users, do: delete(user)
1663 def delete(%User{} = user) do
1664 BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1667 defp delete_and_invalidate_cache(%User{} = user) do
1668 invalidate_cache(user)
1672 defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)
1674 defp delete_or_deactivate(%User{local: true} = user) do
1675 status = account_status(user)
1678 :confirmation_pending ->
1679 delete_and_invalidate_cache(user)
1681 :approval_pending ->
1682 delete_and_invalidate_cache(user)
1686 |> purge_user_changeset()
1687 |> update_and_set_cache()
1691 def perform(:force_password_reset, user), do: force_password_reset(user)
1693 @spec perform(atom(), User.t()) :: {:ok, User.t()}
1694 def perform(:delete, %User{} = user) do
1695 # Remove all relationships
1698 |> Enum.each(fn follower ->
1699 ActivityPub.unfollow(follower, user)
1700 unfollow(follower, user)
1705 |> Enum.each(fn followed ->
1706 ActivityPub.unfollow(user, followed)
1707 unfollow(user, followed)
1710 delete_user_activities(user)
1711 delete_notifications_from_user_activities(user)
1713 delete_outgoing_pending_follow_requests(user)
1715 delete_or_deactivate(user)
1718 def perform(:deactivate_async, user, status), do: deactivate(user, status)
1720 @spec external_users_query() :: Ecto.Query.t()
1721 def external_users_query do
1729 @spec external_users(keyword()) :: [User.t()]
1730 def external_users(opts \\ []) do
1732 external_users_query()
1733 |> select([u], struct(u, [:id, :ap_id]))
1737 do: where(query, [u], u.id > ^opts[:max_id]),
1742 do: limit(query, ^opts[:limit]),
1748 def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1750 |> join(:inner, [n], activity in assoc(n, :activity))
1751 |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1752 |> Repo.delete_all()
1755 def delete_user_activities(%User{ap_id: ap_id} = user) do
1757 |> Activity.Queries.by_actor()
1758 |> Repo.chunk_stream(50, :batches)
1759 |> Stream.each(fn activities ->
1760 Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1765 defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1766 with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1767 {:ok, delete_data, _} <- Builder.delete(user, object) do
1768 Pipeline.common_pipeline(delete_data, local: user.local)
1770 {:find_object, nil} ->
1771 # We have the create activity, but not the object, it was probably pruned.
1772 # Insert a tombstone and try again
1773 with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1774 {:ok, _tombstone} <- Object.create(tombstone_data) do
1775 delete_activity(activity, user)
1779 Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1780 Logger.error("Error: #{inspect(e)}")
1784 defp delete_activity(%{data: %{"type" => type}} = activity, user)
1785 when type in ["Like", "Announce"] do
1786 {:ok, undo, _} = Builder.undo(user, activity)
1787 Pipeline.common_pipeline(undo, local: user.local)
1790 defp delete_activity(_activity, _user), do: "Doing nothing"
1792 defp delete_outgoing_pending_follow_requests(user) do
1794 |> FollowingRelationship.outgoing_pending_follow_requests_query()
1795 |> Repo.delete_all()
1798 def html_filter_policy(%User{no_rich_text: true}) do
1799 Pleroma.HTML.Scrubber.TwitterText
1802 def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])
1804 def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1806 def get_or_fetch_by_ap_id(ap_id) do
1807 cached_user = get_cached_by_ap_id(ap_id)
1809 maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)
1811 case {cached_user, maybe_fetched_user} do
1812 {_, {:ok, %User{} = user}} ->
1815 {%User{} = user, _} ->
1819 {:error, :not_found}
1824 Creates an internal service actor by URI if missing.
1825 Optionally takes nickname for addressing.
1827 @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1828 def get_or_create_service_actor_by_ap_id(uri, nickname) do
1830 case get_cached_by_ap_id(uri) do
1832 with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1833 Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1837 %User{invisible: false} = user ->
1847 @spec set_invisible(User.t()) :: {:ok, User.t()}
1848 defp set_invisible(user) do
1850 |> change(%{invisible: true})
1851 |> update_and_set_cache()
1854 @spec create_service_actor(String.t(), String.t()) ::
1855 {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1856 defp create_service_actor(uri, nickname) do
1862 follower_address: uri <> "/followers"
1865 |> unique_constraint(:nickname)
1870 def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1873 |> :public_key.pem_decode()
1875 |> :public_key.pem_entry_decode()
1880 def public_key(_), do: {:error, "key not found"}
1882 def get_public_key_for_ap_id(ap_id) do
1883 with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1884 {:ok, public_key} <- public_key(user) do
1891 def ap_enabled?(%User{local: true}), do: true
1892 def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1893 def ap_enabled?(_), do: false
1895 @doc "Gets or fetch a user by uri or nickname."
1896 @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1897 def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1898 def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1900 # wait a period of time and return newest version of the User structs
1901 # this is because we have synchronous follow APIs and need to simulate them
1902 # with an async handshake
1903 def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1904 with %User{} = a <- get_cached_by_id(a.id),
1905 %User{} = b <- get_cached_by_id(b.id) do
1912 def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1913 with :ok <- :timer.sleep(timeout),
1914 %User{} = a <- get_cached_by_id(a.id),
1915 %User{} = b <- get_cached_by_id(b.id) do
1922 def parse_bio(bio) when is_binary(bio) and bio != "" do
1924 |> CommonUtils.format_input("text/plain", mentions_format: :full)
1928 def parse_bio(_), do: ""
1930 def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1931 # TODO: get profile URLs other than user.ap_id
1932 profile_urls = [user.ap_id]
1935 |> CommonUtils.format_input("text/plain",
1936 mentions_format: :full,
1937 rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1942 def parse_bio(_, _), do: ""
1944 def tag(user_identifiers, tags) when is_list(user_identifiers) do
1945 Repo.transaction(fn ->
1946 for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1950 def tag(nickname, tags) when is_binary(nickname),
1951 do: tag(get_by_nickname(nickname), tags)
1953 def tag(%User{} = user, tags),
1954 do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1956 def untag(user_identifiers, tags) when is_list(user_identifiers) do
1957 Repo.transaction(fn ->
1958 for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1962 def untag(nickname, tags) when is_binary(nickname),
1963 do: untag(get_by_nickname(nickname), tags)
1965 def untag(%User{} = user, tags),
1966 do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1968 defp update_tags(%User{} = user, new_tags) do
1969 {:ok, updated_user} =
1971 |> change(%{tags: new_tags})
1972 |> update_and_set_cache()
1977 defp normalize_tags(tags) do
1980 |> Enum.map(&String.downcase/1)
1983 defp local_nickname_regex do
1984 if Config.get([:instance, :extended_nickname_format]) do
1985 @extended_local_nickname_regex
1987 @strict_local_nickname_regex
1991 def local_nickname(nickname_or_mention) do
1994 |> String.split("@")
1998 def full_nickname(nickname_or_mention),
1999 do: String.trim_leading(nickname_or_mention, "@")
2001 def error_user(ap_id) do
2005 nickname: "erroruser@example.com",
2006 inserted_at: NaiveDateTime.utc_now()
2010 @spec all_superusers() :: [User.t()]
2011 def all_superusers do
2012 User.Query.build(%{super_users: true, local: true, deactivated: false})
2016 def muting_reblogs?(%User{} = user, %User{} = target) do
2017 UserRelationship.reblog_mute_exists?(user, target)
2020 def showing_reblogs?(%User{} = user, %User{} = target) do
2021 not muting_reblogs?(user, target)
2025 The function returns a query to get users with no activity for given interval of days.
2026 Inactive users are those who didn't read any notification, or had any activity where
2027 the user is the activity's actor, during `inactivity_threshold` days.
2028 Deactivated users will not appear in this list.
2032 iex> Pleroma.User.list_inactive_users()
2035 @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
2036 def list_inactive_users_query(inactivity_threshold \\ 7) do
2037 negative_inactivity_threshold = -inactivity_threshold
2038 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2039 # Subqueries are not supported in `where` clauses, join gets too complicated.
2040 has_read_notifications =
2041 from(n in Pleroma.Notification,
2042 where: n.seen == true,
2044 having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
2047 |> Pleroma.Repo.all()
2049 from(u in Pleroma.User,
2050 left_join: a in Pleroma.Activity,
2051 on: u.ap_id == a.actor,
2052 where: not is_nil(u.nickname),
2053 where: u.deactivated != ^true,
2054 where: u.id not in ^has_read_notifications,
2057 max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
2058 is_nil(max(a.inserted_at))
2063 Enable or disable email notifications for user
2067 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
2068 Pleroma.User{email_notifications: %{"digest" => true}}
2070 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
2071 Pleroma.User{email_notifications: %{"digest" => false}}
2073 @spec switch_email_notifications(t(), String.t(), boolean()) ::
2074 {:ok, t()} | {:error, Ecto.Changeset.t()}
2075 def switch_email_notifications(user, type, status) do
2076 User.update_email_notifications(user, %{type => status})
2080 Set `last_digest_emailed_at` value for the user to current time
2082 @spec touch_last_digest_emailed_at(t()) :: t()
2083 def touch_last_digest_emailed_at(user) do
2084 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2086 {:ok, updated_user} =
2088 |> change(%{last_digest_emailed_at: now})
2089 |> update_and_set_cache()
2094 @spec toggle_confirmation(User.t()) :: {:ok, User.t()} | {:error, Changeset.t()}
2095 def toggle_confirmation(%User{} = user) do
2097 |> confirmation_changeset(need_confirmation: !user.confirmation_pending)
2098 |> update_and_set_cache()
2101 @spec toggle_confirmation([User.t()]) :: [{:ok, User.t()} | {:error, Changeset.t()}]
2102 def toggle_confirmation(users) do
2103 Enum.map(users, &toggle_confirmation/1)
2106 @spec need_confirmation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
2107 def need_confirmation(%User{} = user, bool) do
2109 |> confirmation_changeset(need_confirmation: bool)
2110 |> update_and_set_cache()
2113 def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
2117 def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
2118 # use instance-default
2119 config = Config.get([:assets, :mascots])
2120 default_mascot = Config.get([:assets, :default_mascot])
2121 mascot = Keyword.get(config, default_mascot)
2124 "id" => "default-mascot",
2125 "url" => mascot[:url],
2126 "preview_url" => mascot[:url],
2128 "mime_type" => mascot[:mime_type]
2133 def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
2135 def ensure_keys_present(%User{} = user) do
2136 with {:ok, pem} <- Keys.generate_rsa_pem() do
2138 |> cast(%{keys: pem}, [:keys])
2139 |> validate_required([:keys])
2140 |> update_and_set_cache()
2144 def get_ap_ids_by_nicknames(nicknames) do
2146 where: u.nickname in ^nicknames,
2152 defp put_password_hash(
2153 %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2155 change(changeset, password_hash: Pbkdf2.hash_pwd_salt(password))
2158 defp put_password_hash(changeset), do: changeset
2160 def is_internal_user?(%User{nickname: nil}), do: true
2161 def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2162 def is_internal_user?(_), do: false
2164 # A hack because user delete activities have a fake id for whatever reason
2165 # TODO: Get rid of this
2166 def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2168 def get_delivered_users_by_object_id(object_id) do
2170 inner_join: delivery in assoc(u, :deliveries),
2171 where: delivery.object_id == ^object_id
2176 def change_email(user, email) do
2178 |> cast(%{email: email}, [:email])
2179 |> validate_required([:email])
2180 |> unique_constraint(:email)
2181 |> validate_format(:email, @email_regex)
2182 |> update_and_set_cache()
2185 # Internal function; public one is `deactivate/2`
2186 defp set_activation_status(user, deactivated) do
2188 |> cast(%{deactivated: deactivated}, [:deactivated])
2189 |> update_and_set_cache()
2192 def update_banner(user, banner) do
2194 |> cast(%{banner: banner}, [:banner])
2195 |> update_and_set_cache()
2198 def update_background(user, background) do
2200 |> cast(%{background: background}, [:background])
2201 |> update_and_set_cache()
2204 def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
2207 moderator: is_moderator
2211 def validate_fields(changeset, remote? \\ false) do
2212 limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2213 limit = Config.get([:instance, limit_name], 0)
2216 |> validate_length(:fields, max: limit)
2217 |> validate_change(:fields, fn :fields, fields ->
2218 if Enum.all?(fields, &valid_field?/1) do
2226 defp valid_field?(%{"name" => name, "value" => value}) do
2227 name_limit = Config.get([:instance, :account_field_name_length], 255)
2228 value_limit = Config.get([:instance, :account_field_value_length], 255)
2230 is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2231 String.length(value) <= value_limit
2234 defp valid_field?(_), do: false
2236 defp truncate_field(%{"name" => name, "value" => value}) do
2238 String.split_at(name, Config.get([:instance, :account_field_name_length], 255))
2241 String.split_at(value, Config.get([:instance, :account_field_value_length], 255))
2243 %{"name" => name, "value" => value}
2246 def admin_api_update(user, params) do
2253 |> update_and_set_cache()
2256 @doc "Signs user out of all applications"
2257 def global_sign_out(user) do
2258 OAuth.Authorization.delete_user_authorizations(user)
2259 OAuth.Token.delete_user_tokens(user)
2262 def mascot_update(user, url) do
2264 |> cast(%{mascot: url}, [:mascot])
2265 |> validate_required([:mascot])
2266 |> update_and_set_cache()
2269 def mastodon_settings_update(user, settings) do
2271 |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
2272 |> validate_required([:mastofe_settings])
2273 |> update_and_set_cache()
2276 @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2277 def confirmation_changeset(user, need_confirmation: need_confirmation?) do
2279 if need_confirmation? do
2281 confirmation_pending: true,
2282 confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2286 confirmation_pending: false,
2287 confirmation_token: nil
2291 cast(user, params, [:confirmation_pending, :confirmation_token])
2294 @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
2295 def approval_changeset(user, need_approval: need_approval?) do
2296 params = if need_approval?, do: %{approval_pending: true}, else: %{approval_pending: false}
2297 cast(user, params, [:approval_pending])
2300 def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2301 if id not in user.pinned_activities do
2302 max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2303 params = %{pinned_activities: user.pinned_activities ++ [id]}
2305 # if pinned activity was scheduled for deletion, we remove job
2306 if expiration = Pleroma.Workers.PurgeExpiredActivity.get_expiration(id) do
2307 Oban.cancel_job(expiration.id)
2311 |> cast(params, [:pinned_activities])
2312 |> validate_length(:pinned_activities,
2313 max: max_pinned_statuses,
2314 message: "You have already pinned the maximum number of statuses"
2319 |> update_and_set_cache()
2322 def remove_pinnned_activity(user, %Pleroma.Activity{id: id, data: data}) do
2323 params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2325 # if pinned activity was scheduled for deletion, we reschedule it for deletion
2326 if data["expires_at"] do
2327 # MRF.ActivityExpirationPolicy used UTC timestamps for expires_at in original implementation
2329 data["expires_at"] |> Pleroma.EctoType.ActivityPub.ObjectValidators.DateTime.cast()
2331 Pleroma.Workers.PurgeExpiredActivity.enqueue(%{
2333 expires_at: expires_at
2338 |> cast(params, [:pinned_activities])
2339 |> update_and_set_cache()
2342 def update_email_notifications(user, settings) do
2343 email_notifications =
2344 user.email_notifications
2345 |> Map.merge(settings)
2346 |> Map.take(["digest"])
2348 params = %{email_notifications: email_notifications}
2349 fields = [:email_notifications]
2352 |> cast(params, fields)
2353 |> validate_required(fields)
2354 |> update_and_set_cache()
2357 defp set_domain_blocks(user, domain_blocks) do
2358 params = %{domain_blocks: domain_blocks}
2361 |> cast(params, [:domain_blocks])
2362 |> validate_required([:domain_blocks])
2363 |> update_and_set_cache()
2366 def block_domain(user, domain_blocked) do
2367 set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2370 def unblock_domain(user, domain_blocked) do
2371 set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2374 @spec add_to_block(User.t(), User.t()) ::
2375 {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2376 defp add_to_block(%User{} = user, %User{} = blocked) do
2377 with {:ok, relationship} <- UserRelationship.create_block(user, blocked) do
2378 Cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
2383 @spec add_to_block(User.t(), User.t()) ::
2384 {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2385 defp remove_from_block(%User{} = user, %User{} = blocked) do
2386 with {:ok, relationship} <- UserRelationship.delete_block(user, blocked) do
2387 Cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
2392 def set_invisible(user, invisible) do
2393 params = %{invisible: invisible}
2396 |> cast(params, [:invisible])
2397 |> validate_required([:invisible])
2398 |> update_and_set_cache()
2401 def sanitize_html(%User{} = user) do
2402 sanitize_html(user, nil)
2405 # User data that mastodon isn't filtering (treated as plaintext):
2408 def sanitize_html(%User{} = user, filter) do
2410 Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2413 "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2418 |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2419 |> Map.put(:fields, fields)