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)
478 def update_changeset(struct, params \\ %{}) do
479 bio_limit = Config.get([:instance, :user_bio_length], 5000)
480 name_limit = Config.get([:instance, :user_name_length], 100)
500 :hide_followers_count,
503 :allow_following_move,
506 :skip_thread_containment,
509 :pleroma_settings_store,
513 :accepts_chat_messages
516 |> unique_constraint(:nickname)
517 |> validate_format(:nickname, local_nickname_regex())
518 |> validate_length(:bio, max: bio_limit)
519 |> validate_length(:name, min: 1, max: name_limit)
520 |> validate_inclusion(:actor_type, ["Person", "Service"])
523 |> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
524 |> put_change_if_present(:avatar, &put_upload(&1, :avatar))
525 |> put_change_if_present(:banner, &put_upload(&1, :banner))
526 |> put_change_if_present(:background, &put_upload(&1, :background))
527 |> put_change_if_present(
528 :pleroma_settings_store,
529 &{:ok, Map.merge(struct.pleroma_settings_store, &1)}
531 |> validate_fields(false)
534 defp put_fields(changeset) do
535 if raw_fields = get_change(changeset, :raw_fields) do
538 |> Enum.filter(fn %{"name" => n} -> n != "" end)
542 |> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)
545 |> put_change(:raw_fields, raw_fields)
546 |> put_change(:fields, fields)
552 defp parse_fields(value) do
554 |> Formatter.linkify(mentions_format: :full)
558 defp put_emoji(changeset) do
559 emojified_fields = [:bio, :name, :raw_fields]
561 if Enum.any?(changeset.changes, fn {k, _} -> k in emojified_fields end) do
562 bio = Emoji.Formatter.get_emoji_map(get_field(changeset, :bio))
563 name = Emoji.Formatter.get_emoji_map(get_field(changeset, :name))
565 emoji = Map.merge(bio, name)
569 |> get_field(:raw_fields)
570 |> Enum.reduce(emoji, fn x, acc ->
571 Map.merge(acc, Emoji.Formatter.get_emoji_map(x["name"] <> x["value"]))
574 put_change(changeset, :emoji, emoji)
580 defp put_change_if_present(changeset, map_field, value_function) do
581 with {:ok, value} <- fetch_change(changeset, map_field),
582 {:ok, new_value} <- value_function.(value) do
583 put_change(changeset, map_field, new_value)
589 defp put_upload(value, type) do
590 with %Plug.Upload{} <- value,
591 {:ok, object} <- ActivityPub.upload(value, type: type) do
596 def update_as_admin_changeset(struct, params) do
598 |> update_changeset(params)
599 |> cast(params, [:email])
600 |> delete_change(:also_known_as)
601 |> unique_constraint(:email)
602 |> validate_format(:email, @email_regex)
603 |> validate_inclusion(:actor_type, ["Person", "Service"])
606 @spec update_as_admin(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
607 def update_as_admin(user, params) do
608 params = Map.put(params, "password_confirmation", params["password"])
609 changeset = update_as_admin_changeset(user, params)
611 if params["password"] do
612 reset_password(user, changeset, params)
614 User.update_and_set_cache(changeset)
618 def password_update_changeset(struct, params) do
620 |> cast(params, [:password, :password_confirmation])
621 |> validate_required([:password, :password_confirmation])
622 |> validate_confirmation(:password)
623 |> put_password_hash()
624 |> put_change(:password_reset_pending, false)
627 @spec reset_password(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
628 def reset_password(%User{} = user, params) do
629 reset_password(user, user, params)
632 def reset_password(%User{id: user_id} = user, struct, params) do
635 |> Multi.update(:user, password_update_changeset(struct, params))
636 |> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
637 |> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))
639 case Repo.transaction(multi) do
640 {:ok, %{user: user} = _} -> set_cache(user)
641 {:error, _, changeset, _} -> {:error, changeset}
645 def update_password_reset_pending(user, value) do
648 |> put_change(:password_reset_pending, value)
649 |> update_and_set_cache()
652 def force_password_reset_async(user) do
653 BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
656 @spec force_password_reset(User.t()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
657 def force_password_reset(user), do: update_password_reset_pending(user, true)
659 # Used to auto-register LDAP accounts which won't have a password hash stored locally
660 def register_changeset_ldap(struct, params = %{password: password})
661 when is_nil(password) do
662 params = Map.put_new(params, :accepts_chat_messages, true)
665 if Map.has_key?(params, :email) do
666 Map.put_new(params, :email, params[:email])
676 :accepts_chat_messages
678 |> validate_required([:name, :nickname])
679 |> unique_constraint(:nickname)
680 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
681 |> validate_format(:nickname, local_nickname_regex())
683 |> unique_constraint(:ap_id)
684 |> put_following_and_follower_address()
687 def register_changeset(struct, params \\ %{}, opts \\ []) do
688 bio_limit = Config.get([:instance, :user_bio_length], 5000)
689 name_limit = Config.get([:instance, :user_name_length], 100)
690 reason_limit = Config.get([:instance, :registration_reason_length], 500)
691 params = Map.put_new(params, :accepts_chat_messages, true)
694 if is_nil(opts[:need_confirmation]) do
695 Config.get([:instance, :account_activation_required])
697 opts[:need_confirmation]
701 if is_nil(opts[:need_approval]) do
702 Config.get([:instance, :account_approval_required])
708 |> confirmation_changeset(need_confirmation: need_confirmation?)
709 |> approval_changeset(need_approval: need_approval?)
717 :password_confirmation,
719 :accepts_chat_messages,
722 |> validate_required([:name, :nickname, :password, :password_confirmation])
723 |> validate_confirmation(:password)
724 |> unique_constraint(:email)
725 |> validate_format(:email, @email_regex)
726 |> validate_change(:email, fn :email, email ->
728 Config.get([User, :email_blacklist])
729 |> Enum.all?(fn blacklisted_domain ->
730 !String.ends_with?(email, ["@" <> blacklisted_domain, "." <> blacklisted_domain])
733 if valid?, do: [], else: [email: "Invalid email"]
735 |> unique_constraint(:nickname)
736 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
737 |> validate_format(:nickname, local_nickname_regex())
738 |> validate_length(:bio, max: bio_limit)
739 |> validate_length(:name, min: 1, max: name_limit)
740 |> validate_length(:registration_reason, max: reason_limit)
741 |> maybe_validate_required_email(opts[:external])
744 |> unique_constraint(:ap_id)
745 |> put_following_and_follower_address()
748 def maybe_validate_required_email(changeset, true), do: changeset
750 def maybe_validate_required_email(changeset, _) do
751 if Config.get([:instance, :account_activation_required]) do
752 validate_required(changeset, [:email])
758 defp put_ap_id(changeset) do
759 ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
760 put_change(changeset, :ap_id, ap_id)
763 defp put_following_and_follower_address(changeset) do
764 followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
767 |> put_change(:follower_address, followers)
770 defp autofollow_users(user) do
771 candidates = Config.get([:instance, :autofollowed_nicknames])
774 User.Query.build(%{nickname: candidates, local: true, deactivated: false})
777 follow_all(user, autofollowed_users)
780 defp autofollowing_users(user) do
781 candidates = Config.get([:instance, :autofollowing_nicknames])
783 User.Query.build(%{nickname: candidates, local: true, deactivated: false})
785 |> Enum.each(&follow(&1, user, :follow_accept))
790 @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
791 def register(%Ecto.Changeset{} = changeset) do
792 with {:ok, user} <- Repo.insert(changeset) do
793 post_register_action(user)
797 def post_register_action(%User{} = user) do
798 with {:ok, user} <- autofollow_users(user),
799 {:ok, _} <- autofollowing_users(user),
800 {:ok, user} <- set_cache(user),
801 {:ok, _} <- send_welcome_email(user),
802 {:ok, _} <- send_welcome_message(user),
803 {:ok, _} <- send_welcome_chat_message(user),
804 {:ok, _} <- try_send_confirmation_email(user) do
809 def send_welcome_message(user) do
810 if User.WelcomeMessage.enabled?() do
811 User.WelcomeMessage.post_message(user)
818 def send_welcome_chat_message(user) do
819 if User.WelcomeChatMessage.enabled?() do
820 User.WelcomeChatMessage.post_message(user)
827 def send_welcome_email(%User{email: email} = user) when is_binary(email) do
828 if User.WelcomeEmail.enabled?() do
829 User.WelcomeEmail.send_email(user)
836 def send_welcome_email(_), do: {:ok, :noop}
838 @spec try_send_confirmation_email(User.t()) :: {:ok, :enqueued | :noop}
839 def try_send_confirmation_email(%User{confirmation_pending: true, email: email} = user)
840 when is_binary(email) do
841 if Config.get([:instance, :account_activation_required]) do
842 send_confirmation_email(user)
849 def try_send_confirmation_email(_), do: {:ok, :noop}
851 @spec send_confirmation_email(Uset.t()) :: User.t()
852 def send_confirmation_email(%User{} = user) do
854 |> Pleroma.Emails.UserEmail.account_confirmation_email()
855 |> Pleroma.Emails.Mailer.deliver_async()
860 def needs_update?(%User{local: true}), do: false
862 def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
864 def needs_update?(%User{local: false} = user) do
865 NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
868 def needs_update?(_), do: true
870 @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
872 # "Locked" (self-locked) users demand explicit authorization of follow requests
873 def maybe_direct_follow(%User{} = follower, %User{local: true, is_locked: true} = followed) do
874 follow(follower, followed, :follow_pending)
877 def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
878 follow(follower, followed)
881 def maybe_direct_follow(%User{} = follower, %User{} = followed) do
882 if not ap_enabled?(followed) do
883 follow(follower, followed)
889 @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
890 @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
891 def follow_all(follower, followeds) do
893 |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
894 |> Enum.each(&follow(follower, &1, :follow_accept))
899 def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
900 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
903 followed.deactivated ->
904 {:error, "Could not follow user: #{followed.nickname} is deactivated."}
906 deny_follow_blocked and blocks?(followed, follower) ->
907 {:error, "Could not follow user: #{followed.nickname} blocked you."}
910 FollowingRelationship.follow(follower, followed, state)
912 {:ok, _} = update_follower_count(followed)
915 |> update_following_count()
919 def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
920 {:error, "Not subscribed!"}
923 @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
924 def unfollow(%User{} = follower, %User{} = followed) do
925 case do_unfollow(follower, followed) do
926 {:ok, follower, followed} ->
927 {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
934 @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
935 defp do_unfollow(%User{} = follower, %User{} = followed) do
936 case get_follow_state(follower, followed) do
937 state when state in [:follow_pending, :follow_accept] ->
938 FollowingRelationship.unfollow(follower, followed)
939 {:ok, followed} = update_follower_count(followed)
941 {:ok, follower} = update_following_count(follower)
943 {:ok, follower, followed}
946 {:error, "Not subscribed!"}
950 @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
951 def get_follow_state(%User{} = follower, %User{} = following) do
952 following_relationship = FollowingRelationship.get(follower, following)
953 get_follow_state(follower, following, following_relationship)
956 def get_follow_state(
959 following_relationship
961 case {following_relationship, following.local} do
963 case Utils.fetch_latest_follow(follower, following) do
964 %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
965 FollowingRelationship.state_to_enum(state)
971 {%{state: state}, _} ->
979 def locked?(%User{} = user) do
980 user.is_locked || false
984 Repo.get_by(User, id: id)
987 def get_by_ap_id(ap_id) do
988 Repo.get_by(User, ap_id: ap_id)
991 def get_all_by_ap_id(ap_ids) do
992 from(u in __MODULE__,
993 where: u.ap_id in ^ap_ids
998 def get_all_by_ids(ids) do
999 from(u in __MODULE__, where: u.id in ^ids)
1003 # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
1004 # of the ap_id and the domain and tries to get that user
1005 def get_by_guessed_nickname(ap_id) do
1006 domain = URI.parse(ap_id).host
1007 name = List.last(String.split(ap_id, "/"))
1008 nickname = "#{name}@#{domain}"
1010 get_cached_by_nickname(nickname)
1013 def set_cache({:ok, user}), do: set_cache(user)
1014 def set_cache({:error, err}), do: {:error, err}
1016 def set_cache(%User{} = user) do
1017 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1018 Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
1019 Cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
1023 def update_and_set_cache(struct, params) do
1025 |> update_changeset(params)
1026 |> update_and_set_cache()
1029 def update_and_set_cache(changeset) do
1030 with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
1035 def get_user_friends_ap_ids(user) do
1036 from(u in User.get_friends_query(user), select: u.ap_id)
1040 @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
1041 def get_cached_user_friends_ap_ids(user) do
1042 Cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
1043 get_user_friends_ap_ids(user)
1047 def invalidate_cache(user) do
1048 Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
1049 Cachex.del(:user_cache, "nickname:#{user.nickname}")
1050 Cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
1051 Cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
1052 Cachex.del(:user_cache, "muted_users_ap_ids:#{user.ap_id}")
1055 @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
1056 def get_cached_by_ap_id(ap_id) do
1057 key = "ap_id:#{ap_id}"
1059 with {:ok, nil} <- Cachex.get(:user_cache, key),
1060 user when not is_nil(user) <- get_by_ap_id(ap_id),
1061 {:ok, true} <- Cachex.put(:user_cache, key, user) do
1069 def get_cached_by_id(id) do
1073 Cachex.fetch!(:user_cache, key, fn _ ->
1074 user = get_by_id(id)
1077 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1078 {:commit, user.ap_id}
1084 get_cached_by_ap_id(ap_id)
1087 def get_cached_by_nickname(nickname) do
1088 key = "nickname:#{nickname}"
1090 Cachex.fetch!(:user_cache, key, fn ->
1091 case get_or_fetch_by_nickname(nickname) do
1092 {:ok, user} -> {:commit, user}
1093 {:error, _error} -> {:ignore, nil}
1098 def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
1099 restrict_to_local = Config.get([:instance, :limit_to_local_content])
1102 is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
1103 get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
1105 restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
1106 get_cached_by_nickname(nickname_or_id)
1108 restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
1109 get_cached_by_nickname(nickname_or_id)
1116 @spec get_by_nickname(String.t()) :: User.t() | nil
1117 def get_by_nickname(nickname) do
1118 Repo.get_by(User, nickname: nickname) ||
1119 if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
1120 Repo.get_by(User, nickname: local_nickname(nickname))
1124 def get_by_email(email), do: Repo.get_by(User, email: email)
1126 def get_by_nickname_or_email(nickname_or_email) do
1127 get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
1130 def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
1132 def get_or_fetch_by_nickname(nickname) do
1133 with %User{} = user <- get_by_nickname(nickname) do
1137 with [_nick, _domain] <- String.split(nickname, "@"),
1138 {:ok, user} <- fetch_by_nickname(nickname) do
1141 _e -> {:error, "not found " <> nickname}
1146 @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1147 def get_followers_query(%User{} = user, nil) do
1148 User.Query.build(%{followers: user, deactivated: false})
1151 def get_followers_query(%User{} = user, page) do
1153 |> get_followers_query(nil)
1154 |> User.Query.paginate(page, 20)
1157 @spec get_followers_query(User.t()) :: Ecto.Query.t()
1158 def get_followers_query(%User{} = user), do: get_followers_query(user, nil)
1160 @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1161 def get_followers(%User{} = user, page \\ nil) do
1163 |> get_followers_query(page)
1167 @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1168 def get_external_followers(%User{} = user, page \\ nil) do
1170 |> get_followers_query(page)
1171 |> User.Query.build(%{external: true})
1175 def get_followers_ids(%User{} = user, page \\ nil) do
1177 |> get_followers_query(page)
1178 |> select([u], u.id)
1182 @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1183 def get_friends_query(%User{} = user, nil) do
1184 User.Query.build(%{friends: user, deactivated: false})
1187 def get_friends_query(%User{} = user, page) do
1189 |> get_friends_query(nil)
1190 |> User.Query.paginate(page, 20)
1193 @spec get_friends_query(User.t()) :: Ecto.Query.t()
1194 def get_friends_query(%User{} = user), do: get_friends_query(user, nil)
1196 def get_friends(%User{} = user, page \\ nil) do
1198 |> get_friends_query(page)
1202 def get_friends_ap_ids(%User{} = user) do
1204 |> get_friends_query(nil)
1205 |> select([u], u.ap_id)
1209 def get_friends_ids(%User{} = user, page \\ nil) do
1211 |> get_friends_query(page)
1212 |> select([u], u.id)
1216 def increase_note_count(%User{} = user) do
1218 |> where(id: ^user.id)
1219 |> update([u], inc: [note_count: 1])
1221 |> Repo.update_all([])
1223 {1, [user]} -> set_cache(user)
1228 def decrease_note_count(%User{} = user) do
1230 |> where(id: ^user.id)
1233 note_count: fragment("greatest(0, note_count - 1)")
1237 |> Repo.update_all([])
1239 {1, [user]} -> set_cache(user)
1244 def update_note_count(%User{} = user, note_count \\ nil) do
1249 where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1255 |> cast(%{note_count: note_count}, [:note_count])
1256 |> update_and_set_cache()
1259 @spec maybe_fetch_follow_information(User.t()) :: User.t()
1260 def maybe_fetch_follow_information(user) do
1261 with {:ok, user} <- fetch_follow_information(user) do
1265 Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1271 def fetch_follow_information(user) do
1272 with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1274 |> follow_information_changeset(info)
1275 |> update_and_set_cache()
1279 defp follow_information_changeset(user, params) do
1286 :hide_followers_count,
1291 @spec update_follower_count(User.t()) :: {:ok, User.t()}
1292 def update_follower_count(%User{} = user) do
1293 if user.local or !Config.get([:instance, :external_user_synchronization]) do
1294 follower_count = FollowingRelationship.follower_count(user)
1297 |> follow_information_changeset(%{follower_count: follower_count})
1298 |> update_and_set_cache
1300 {:ok, maybe_fetch_follow_information(user)}
1304 @spec update_following_count(User.t()) :: {:ok, User.t()}
1305 def update_following_count(%User{local: false} = user) do
1306 if Config.get([:instance, :external_user_synchronization]) do
1307 {:ok, maybe_fetch_follow_information(user)}
1313 def update_following_count(%User{local: true} = user) do
1314 following_count = FollowingRelationship.following_count(user)
1317 |> follow_information_changeset(%{following_count: following_count})
1318 |> update_and_set_cache()
1321 @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1322 def get_users_from_set(ap_ids, opts \\ []) do
1323 local_only = Keyword.get(opts, :local_only, true)
1324 criteria = %{ap_id: ap_ids, deactivated: false}
1325 criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1327 User.Query.build(criteria)
1331 @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1332 def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1335 query = User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
1341 @spec mute(User.t(), User.t(), map()) ::
1342 {:ok, list(UserRelationship.t())} | {:error, String.t()}
1343 def mute(%User{} = muter, %User{} = mutee, params \\ %{}) do
1344 notifications? = Map.get(params, :notifications, true)
1345 expires_in = Map.get(params, :expires_in, 0)
1347 with {:ok, user_mute} <- UserRelationship.create_mute(muter, mutee),
1348 {:ok, user_notification_mute} <-
1349 (notifications? && UserRelationship.create_notification_mute(muter, mutee)) ||
1351 if expires_in > 0 do
1352 Pleroma.Workers.MuteExpireWorker.enqueue(
1354 %{"muter_id" => muter.id, "mutee_id" => mutee.id},
1355 schedule_in: expires_in
1359 Cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
1361 {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
1365 def unmute(%User{} = muter, %User{} = mutee) do
1366 with {:ok, user_mute} <- UserRelationship.delete_mute(muter, mutee),
1367 {:ok, user_notification_mute} <-
1368 UserRelationship.delete_notification_mute(muter, mutee) do
1369 Cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
1370 {:ok, [user_mute, user_notification_mute]}
1374 def unmute(muter_id, mutee_id) do
1375 with {:muter, %User{} = muter} <- {:muter, User.get_by_id(muter_id)},
1376 {:mutee, %User{} = mutee} <- {:mutee, User.get_by_id(mutee_id)} do
1377 unmute(muter, mutee)
1379 {who, result} = error ->
1381 "User.unmute/2 failed. #{who}: #{result}, muter_id: #{muter_id}, mutee_id: #{mutee_id}"
1388 def subscribe(%User{} = subscriber, %User{} = target) do
1389 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
1391 if blocks?(target, subscriber) and deny_follow_blocked do
1392 {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1394 # Note: the relationship is inverse: subscriber acts as relationship target
1395 UserRelationship.create_inverse_subscription(target, subscriber)
1399 def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1400 with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1401 subscribe(subscriber, subscribee)
1405 def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1406 # Note: the relationship is inverse: subscriber acts as relationship target
1407 UserRelationship.delete_inverse_subscription(target, unsubscriber)
1410 def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1411 with %User{} = user <- get_cached_by_ap_id(ap_id) do
1412 unsubscribe(unsubscriber, user)
1416 def block(%User{} = blocker, %User{} = blocked) do
1417 # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1419 if following?(blocker, blocked) do
1420 {:ok, blocker, _} = unfollow(blocker, blocked)
1426 # clear any requested follows as well
1428 case CommonAPI.reject_follow_request(blocked, blocker) do
1429 {:ok, %User{} = updated_blocked} -> updated_blocked
1433 unsubscribe(blocked, blocker)
1435 unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
1436 if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)
1438 {:ok, blocker} = update_follower_count(blocker)
1439 {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1440 add_to_block(blocker, blocked)
1443 # helper to handle the block given only an actor's AP id
1444 def block(%User{} = blocker, %{ap_id: ap_id}) do
1445 block(blocker, get_cached_by_ap_id(ap_id))
1448 def unblock(%User{} = blocker, %User{} = blocked) do
1449 remove_from_block(blocker, blocked)
1452 # helper to handle the block given only an actor's AP id
1453 def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1454 unblock(blocker, get_cached_by_ap_id(ap_id))
1457 def mutes?(nil, _), do: false
1458 def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1460 def mutes_user?(%User{} = user, %User{} = target) do
1461 UserRelationship.mute_exists?(user, target)
1464 @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1465 def muted_notifications?(nil, _), do: false
1467 def muted_notifications?(%User{} = user, %User{} = target),
1468 do: UserRelationship.notification_mute_exists?(user, target)
1470 def blocks?(nil, _), do: false
1472 def blocks?(%User{} = user, %User{} = target) do
1473 blocks_user?(user, target) ||
1474 (blocks_domain?(user, target) and not User.following?(user, target))
1477 def blocks_user?(%User{} = user, %User{} = target) do
1478 UserRelationship.block_exists?(user, target)
1481 def blocks_user?(_, _), do: false
1483 def blocks_domain?(%User{} = user, %User{} = target) do
1484 domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1485 %{host: host} = URI.parse(target.ap_id)
1486 Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1489 def blocks_domain?(_, _), do: false
1491 def subscribed_to?(%User{} = user, %User{} = target) do
1492 # Note: the relationship is inverse: subscriber acts as relationship target
1493 UserRelationship.inverse_subscription_exists?(target, user)
1496 def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1497 with %User{} = target <- get_cached_by_ap_id(ap_id) do
1498 subscribed_to?(user, target)
1503 Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1504 E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1506 @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1507 def outgoing_relationships_ap_ids(_user, []), do: %{}
1509 def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1511 def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1512 when is_list(relationship_types) do
1515 |> assoc(:outgoing_relationships)
1516 |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1517 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1518 |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1519 |> group_by([user_rel, u], user_rel.relationship_type)
1521 |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1526 fn rel_type -> {rel_type, db_result[rel_type] || []} end
1530 def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1532 def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1534 def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1536 def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1537 when is_list(relationship_types) do
1539 |> assoc(:incoming_relationships)
1540 |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1541 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1542 |> maybe_filter_on_ap_id(ap_ids)
1543 |> select([user_rel, u], u.ap_id)
1548 defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1549 where(query, [user_rel, u], u.ap_id in ^ap_ids)
1552 defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1554 def deactivate_async(user, status \\ true) do
1555 BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
1558 def deactivate(user, status \\ true)
1560 def deactivate(users, status) when is_list(users) do
1561 Repo.transaction(fn ->
1562 for user <- users, do: deactivate(user, status)
1566 def deactivate(%User{} = user, status) do
1567 with {:ok, user} <- set_activation_status(user, status) do
1570 |> Enum.filter(& &1.local)
1571 |> Enum.each(&set_cache(update_following_count(&1)))
1573 # Only update local user counts, remote will be update during the next pull.
1576 |> Enum.filter(& &1.local)
1577 |> Enum.each(&do_unfollow(user, &1))
1583 def approve(users) when is_list(users) do
1584 Repo.transaction(fn ->
1585 Enum.map(users, fn user ->
1586 with {:ok, user} <- approve(user), do: user
1591 def approve(%User{} = user) do
1592 change(user, approval_pending: false)
1593 |> update_and_set_cache()
1596 def update_notification_settings(%User{} = user, settings) do
1598 |> cast(%{notification_settings: settings}, [])
1599 |> cast_embed(:notification_settings)
1600 |> validate_required([:notification_settings])
1601 |> update_and_set_cache()
1604 @spec purge_user_changeset(User.t()) :: Changeset.t()
1605 def purge_user_changeset(user) do
1606 # "Right to be forgotten"
1607 # https://gdpr.eu/right-to-be-forgotten/
1618 last_refreshed_at: nil,
1619 last_digest_emailed_at: nil,
1626 confirmation_pending: false,
1627 password_reset_pending: false,
1628 approval_pending: false,
1629 registration_reason: nil,
1630 confirmation_token: nil,
1634 is_moderator: false,
1636 mastofe_settings: nil,
1639 pleroma_settings_store: %{},
1642 is_discoverable: false,
1647 def delete(users) when is_list(users) do
1648 for user <- users, do: delete(user)
1651 def delete(%User{} = user) do
1652 BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1655 defp delete_and_invalidate_cache(%User{} = user) do
1656 invalidate_cache(user)
1660 defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)
1662 defp delete_or_deactivate(%User{local: true} = user) do
1663 status = account_status(user)
1666 :confirmation_pending ->
1667 delete_and_invalidate_cache(user)
1669 :approval_pending ->
1670 delete_and_invalidate_cache(user)
1674 |> purge_user_changeset()
1675 |> update_and_set_cache()
1679 def perform(:force_password_reset, user), do: force_password_reset(user)
1681 @spec perform(atom(), User.t()) :: {:ok, User.t()}
1682 def perform(:delete, %User{} = user) do
1683 # Remove all relationships
1686 |> Enum.each(fn follower ->
1687 ActivityPub.unfollow(follower, user)
1688 unfollow(follower, user)
1693 |> Enum.each(fn followed ->
1694 ActivityPub.unfollow(user, followed)
1695 unfollow(user, followed)
1698 delete_user_activities(user)
1699 delete_notifications_from_user_activities(user)
1701 delete_outgoing_pending_follow_requests(user)
1703 delete_or_deactivate(user)
1706 def perform(:deactivate_async, user, status), do: deactivate(user, status)
1708 @spec external_users_query() :: Ecto.Query.t()
1709 def external_users_query do
1717 @spec external_users(keyword()) :: [User.t()]
1718 def external_users(opts \\ []) do
1720 external_users_query()
1721 |> select([u], struct(u, [:id, :ap_id]))
1725 do: where(query, [u], u.id > ^opts[:max_id]),
1730 do: limit(query, ^opts[:limit]),
1736 def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1738 |> join(:inner, [n], activity in assoc(n, :activity))
1739 |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1740 |> Repo.delete_all()
1743 def delete_user_activities(%User{ap_id: ap_id} = user) do
1745 |> Activity.Queries.by_actor()
1746 |> Repo.chunk_stream(50, :batches)
1747 |> Stream.each(fn activities ->
1748 Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1753 defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1754 with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1755 {:ok, delete_data, _} <- Builder.delete(user, object) do
1756 Pipeline.common_pipeline(delete_data, local: user.local)
1758 {:find_object, nil} ->
1759 # We have the create activity, but not the object, it was probably pruned.
1760 # Insert a tombstone and try again
1761 with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1762 {:ok, _tombstone} <- Object.create(tombstone_data) do
1763 delete_activity(activity, user)
1767 Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1768 Logger.error("Error: #{inspect(e)}")
1772 defp delete_activity(%{data: %{"type" => type}} = activity, user)
1773 when type in ["Like", "Announce"] do
1774 {:ok, undo, _} = Builder.undo(user, activity)
1775 Pipeline.common_pipeline(undo, local: user.local)
1778 defp delete_activity(_activity, _user), do: "Doing nothing"
1780 defp delete_outgoing_pending_follow_requests(user) do
1782 |> FollowingRelationship.outgoing_pending_follow_requests_query()
1783 |> Repo.delete_all()
1786 def html_filter_policy(%User{no_rich_text: true}) do
1787 Pleroma.HTML.Scrubber.TwitterText
1790 def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])
1792 def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1794 def get_or_fetch_by_ap_id(ap_id) do
1795 cached_user = get_cached_by_ap_id(ap_id)
1797 maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)
1799 case {cached_user, maybe_fetched_user} do
1800 {_, {:ok, %User{} = user}} ->
1803 {%User{} = user, _} ->
1807 {:error, :not_found}
1812 Creates an internal service actor by URI if missing.
1813 Optionally takes nickname for addressing.
1815 @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1816 def get_or_create_service_actor_by_ap_id(uri, nickname) do
1818 case get_cached_by_ap_id(uri) do
1820 with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1821 Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1825 %User{invisible: false} = user ->
1835 @spec set_invisible(User.t()) :: {:ok, User.t()}
1836 defp set_invisible(user) do
1838 |> change(%{invisible: true})
1839 |> update_and_set_cache()
1842 @spec create_service_actor(String.t(), String.t()) ::
1843 {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1844 defp create_service_actor(uri, nickname) do
1850 follower_address: uri <> "/followers"
1853 |> unique_constraint(:nickname)
1858 def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1861 |> :public_key.pem_decode()
1863 |> :public_key.pem_entry_decode()
1868 def public_key(_), do: {:error, "key not found"}
1870 def get_public_key_for_ap_id(ap_id) do
1871 with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1872 {:ok, public_key} <- public_key(user) do
1879 def ap_enabled?(%User{local: true}), do: true
1880 def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1881 def ap_enabled?(_), do: false
1883 @doc "Gets or fetch a user by uri or nickname."
1884 @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1885 def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1886 def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1888 # wait a period of time and return newest version of the User structs
1889 # this is because we have synchronous follow APIs and need to simulate them
1890 # with an async handshake
1891 def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1892 with %User{} = a <- get_cached_by_id(a.id),
1893 %User{} = b <- get_cached_by_id(b.id) do
1900 def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1901 with :ok <- :timer.sleep(timeout),
1902 %User{} = a <- get_cached_by_id(a.id),
1903 %User{} = b <- get_cached_by_id(b.id) do
1910 def parse_bio(bio) when is_binary(bio) and bio != "" do
1912 |> CommonUtils.format_input("text/plain", mentions_format: :full)
1916 def parse_bio(_), do: ""
1918 def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1919 # TODO: get profile URLs other than user.ap_id
1920 profile_urls = [user.ap_id]
1923 |> CommonUtils.format_input("text/plain",
1924 mentions_format: :full,
1925 rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1930 def parse_bio(_, _), do: ""
1932 def tag(user_identifiers, tags) when is_list(user_identifiers) do
1933 Repo.transaction(fn ->
1934 for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1938 def tag(nickname, tags) when is_binary(nickname),
1939 do: tag(get_by_nickname(nickname), tags)
1941 def tag(%User{} = user, tags),
1942 do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1944 def untag(user_identifiers, tags) when is_list(user_identifiers) do
1945 Repo.transaction(fn ->
1946 for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1950 def untag(nickname, tags) when is_binary(nickname),
1951 do: untag(get_by_nickname(nickname), tags)
1953 def untag(%User{} = user, tags),
1954 do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1956 defp update_tags(%User{} = user, new_tags) do
1957 {:ok, updated_user} =
1959 |> change(%{tags: new_tags})
1960 |> update_and_set_cache()
1965 defp normalize_tags(tags) do
1968 |> Enum.map(&String.downcase/1)
1971 defp local_nickname_regex do
1972 if Config.get([:instance, :extended_nickname_format]) do
1973 @extended_local_nickname_regex
1975 @strict_local_nickname_regex
1979 def local_nickname(nickname_or_mention) do
1982 |> String.split("@")
1986 def full_nickname(nickname_or_mention),
1987 do: String.trim_leading(nickname_or_mention, "@")
1989 def error_user(ap_id) do
1993 nickname: "erroruser@example.com",
1994 inserted_at: NaiveDateTime.utc_now()
1998 @spec all_superusers() :: [User.t()]
1999 def all_superusers do
2000 User.Query.build(%{super_users: true, local: true, deactivated: false})
2004 def muting_reblogs?(%User{} = user, %User{} = target) do
2005 UserRelationship.reblog_mute_exists?(user, target)
2008 def showing_reblogs?(%User{} = user, %User{} = target) do
2009 not muting_reblogs?(user, target)
2013 The function returns a query to get users with no activity for given interval of days.
2014 Inactive users are those who didn't read any notification, or had any activity where
2015 the user is the activity's actor, during `inactivity_threshold` days.
2016 Deactivated users will not appear in this list.
2020 iex> Pleroma.User.list_inactive_users()
2023 @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
2024 def list_inactive_users_query(inactivity_threshold \\ 7) do
2025 negative_inactivity_threshold = -inactivity_threshold
2026 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2027 # Subqueries are not supported in `where` clauses, join gets too complicated.
2028 has_read_notifications =
2029 from(n in Pleroma.Notification,
2030 where: n.seen == true,
2032 having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
2035 |> Pleroma.Repo.all()
2037 from(u in Pleroma.User,
2038 left_join: a in Pleroma.Activity,
2039 on: u.ap_id == a.actor,
2040 where: not is_nil(u.nickname),
2041 where: u.deactivated != ^true,
2042 where: u.id not in ^has_read_notifications,
2045 max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
2046 is_nil(max(a.inserted_at))
2051 Enable or disable email notifications for user
2055 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
2056 Pleroma.User{email_notifications: %{"digest" => true}}
2058 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
2059 Pleroma.User{email_notifications: %{"digest" => false}}
2061 @spec switch_email_notifications(t(), String.t(), boolean()) ::
2062 {:ok, t()} | {:error, Ecto.Changeset.t()}
2063 def switch_email_notifications(user, type, status) do
2064 User.update_email_notifications(user, %{type => status})
2068 Set `last_digest_emailed_at` value for the user to current time
2070 @spec touch_last_digest_emailed_at(t()) :: t()
2071 def touch_last_digest_emailed_at(user) do
2072 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2074 {:ok, updated_user} =
2076 |> change(%{last_digest_emailed_at: now})
2077 |> update_and_set_cache()
2082 @spec toggle_confirmation(User.t()) :: {:ok, User.t()} | {:error, Changeset.t()}
2083 def toggle_confirmation(%User{} = user) do
2085 |> confirmation_changeset(need_confirmation: !user.confirmation_pending)
2086 |> update_and_set_cache()
2089 @spec toggle_confirmation([User.t()]) :: [{:ok, User.t()} | {:error, Changeset.t()}]
2090 def toggle_confirmation(users) do
2091 Enum.map(users, &toggle_confirmation/1)
2094 @spec need_confirmation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
2095 def need_confirmation(%User{} = user, bool) do
2097 |> confirmation_changeset(need_confirmation: bool)
2098 |> update_and_set_cache()
2101 def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
2105 def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
2106 # use instance-default
2107 config = Config.get([:assets, :mascots])
2108 default_mascot = Config.get([:assets, :default_mascot])
2109 mascot = Keyword.get(config, default_mascot)
2112 "id" => "default-mascot",
2113 "url" => mascot[:url],
2114 "preview_url" => mascot[:url],
2116 "mime_type" => mascot[:mime_type]
2121 def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
2123 def ensure_keys_present(%User{} = user) do
2124 with {:ok, pem} <- Keys.generate_rsa_pem() do
2126 |> cast(%{keys: pem}, [:keys])
2127 |> validate_required([:keys])
2128 |> update_and_set_cache()
2132 def get_ap_ids_by_nicknames(nicknames) do
2134 where: u.nickname in ^nicknames,
2140 defp put_password_hash(
2141 %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2143 change(changeset, password_hash: Pbkdf2.hash_pwd_salt(password))
2146 defp put_password_hash(changeset), do: changeset
2148 def is_internal_user?(%User{nickname: nil}), do: true
2149 def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2150 def is_internal_user?(_), do: false
2152 # A hack because user delete activities have a fake id for whatever reason
2153 # TODO: Get rid of this
2154 def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2156 def get_delivered_users_by_object_id(object_id) do
2158 inner_join: delivery in assoc(u, :deliveries),
2159 where: delivery.object_id == ^object_id
2164 def change_email(user, email) do
2166 |> cast(%{email: email}, [:email])
2167 |> validate_required([:email])
2168 |> unique_constraint(:email)
2169 |> validate_format(:email, @email_regex)
2170 |> update_and_set_cache()
2173 # Internal function; public one is `deactivate/2`
2174 defp set_activation_status(user, deactivated) do
2176 |> cast(%{deactivated: deactivated}, [:deactivated])
2177 |> update_and_set_cache()
2180 def update_banner(user, banner) do
2182 |> cast(%{banner: banner}, [:banner])
2183 |> update_and_set_cache()
2186 def update_background(user, background) do
2188 |> cast(%{background: background}, [:background])
2189 |> update_and_set_cache()
2192 def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
2195 moderator: is_moderator
2199 def validate_fields(changeset, remote? \\ false) do
2200 limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2201 limit = Config.get([:instance, limit_name], 0)
2204 |> validate_length(:fields, max: limit)
2205 |> validate_change(:fields, fn :fields, fields ->
2206 if Enum.all?(fields, &valid_field?/1) do
2214 defp valid_field?(%{"name" => name, "value" => value}) do
2215 name_limit = Config.get([:instance, :account_field_name_length], 255)
2216 value_limit = Config.get([:instance, :account_field_value_length], 255)
2218 is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2219 String.length(value) <= value_limit
2222 defp valid_field?(_), do: false
2224 defp truncate_field(%{"name" => name, "value" => value}) do
2226 String.split_at(name, Config.get([:instance, :account_field_name_length], 255))
2229 String.split_at(value, Config.get([:instance, :account_field_value_length], 255))
2231 %{"name" => name, "value" => value}
2234 def admin_api_update(user, params) do
2241 |> update_and_set_cache()
2244 @doc "Signs user out of all applications"
2245 def global_sign_out(user) do
2246 OAuth.Authorization.delete_user_authorizations(user)
2247 OAuth.Token.delete_user_tokens(user)
2250 def mascot_update(user, url) do
2252 |> cast(%{mascot: url}, [:mascot])
2253 |> validate_required([:mascot])
2254 |> update_and_set_cache()
2257 def mastodon_settings_update(user, settings) do
2259 |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
2260 |> validate_required([:mastofe_settings])
2261 |> update_and_set_cache()
2264 @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2265 def confirmation_changeset(user, need_confirmation: need_confirmation?) do
2267 if need_confirmation? do
2269 confirmation_pending: true,
2270 confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2274 confirmation_pending: false,
2275 confirmation_token: nil
2279 cast(user, params, [:confirmation_pending, :confirmation_token])
2282 @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
2283 def approval_changeset(user, need_approval: need_approval?) do
2284 params = if need_approval?, do: %{approval_pending: true}, else: %{approval_pending: false}
2285 cast(user, params, [:approval_pending])
2288 def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2289 if id not in user.pinned_activities do
2290 max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2291 params = %{pinned_activities: user.pinned_activities ++ [id]}
2293 # if pinned activity was scheduled for deletion, we remove job
2294 if expiration = Pleroma.Workers.PurgeExpiredActivity.get_expiration(id) do
2295 Oban.cancel_job(expiration.id)
2299 |> cast(params, [:pinned_activities])
2300 |> validate_length(:pinned_activities,
2301 max: max_pinned_statuses,
2302 message: "You have already pinned the maximum number of statuses"
2307 |> update_and_set_cache()
2310 def remove_pinnned_activity(user, %Pleroma.Activity{id: id, data: data}) do
2311 params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2313 # if pinned activity was scheduled for deletion, we reschedule it for deletion
2314 if data["expires_at"] do
2315 # MRF.ActivityExpirationPolicy used UTC timestamps for expires_at in original implementation
2317 data["expires_at"] |> Pleroma.EctoType.ActivityPub.ObjectValidators.DateTime.cast()
2319 Pleroma.Workers.PurgeExpiredActivity.enqueue(%{
2321 expires_at: expires_at
2326 |> cast(params, [:pinned_activities])
2327 |> update_and_set_cache()
2330 def update_email_notifications(user, settings) do
2331 email_notifications =
2332 user.email_notifications
2333 |> Map.merge(settings)
2334 |> Map.take(["digest"])
2336 params = %{email_notifications: email_notifications}
2337 fields = [:email_notifications]
2340 |> cast(params, fields)
2341 |> validate_required(fields)
2342 |> update_and_set_cache()
2345 defp set_domain_blocks(user, domain_blocks) do
2346 params = %{domain_blocks: domain_blocks}
2349 |> cast(params, [:domain_blocks])
2350 |> validate_required([:domain_blocks])
2351 |> update_and_set_cache()
2354 def block_domain(user, domain_blocked) do
2355 set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2358 def unblock_domain(user, domain_blocked) do
2359 set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2362 @spec add_to_block(User.t(), User.t()) ::
2363 {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2364 defp add_to_block(%User{} = user, %User{} = blocked) do
2365 with {:ok, relationship} <- UserRelationship.create_block(user, blocked) do
2366 Cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
2371 @spec add_to_block(User.t(), User.t()) ::
2372 {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2373 defp remove_from_block(%User{} = user, %User{} = blocked) do
2374 with {:ok, relationship} <- UserRelationship.delete_block(user, blocked) do
2375 Cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
2380 def set_invisible(user, invisible) do
2381 params = %{invisible: invisible}
2384 |> cast(params, [:invisible])
2385 |> validate_required([:invisible])
2386 |> update_and_set_cache()
2389 def sanitize_html(%User{} = user) do
2390 sanitize_html(user, nil)
2393 # User data that mastodon isn't filtering (treated as plaintext):
2396 def sanitize_html(%User{} = user, filter) do
2398 Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2401 "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2406 |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2407 |> Map.put(:fields, fields)