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(:unread_conversation_count, :integer, default: 0)
132 field(:pinned_activities, {:array, :string}, default: [])
133 field(:email_notifications, :map, default: %{"digest" => false})
134 field(:mascot, :map, default: nil)
135 field(:emoji, :map, default: %{})
136 field(:pleroma_settings_store, :map, default: %{})
137 field(:fields, {:array, :map}, default: [])
138 field(:raw_fields, {:array, :map}, default: [])
139 field(:is_discoverable, :boolean, default: false)
140 field(:invisible, :boolean, default: false)
141 field(:allow_following_move, :boolean, default: true)
142 field(:skip_thread_containment, :boolean, default: false)
143 field(:actor_type, :string, default: "Person")
144 field(:also_known_as, {:array, :string}, default: [])
145 field(:inbox, :string)
146 field(:shared_inbox, :string)
147 field(:accepts_chat_messages, :boolean, default: nil)
150 :notification_settings,
151 Pleroma.User.NotificationSetting,
155 has_many(:notifications, Notification)
156 has_many(:registrations, Registration)
157 has_many(:deliveries, Delivery)
159 has_many(:outgoing_relationships, UserRelationship, foreign_key: :source_id)
160 has_many(:incoming_relationships, UserRelationship, foreign_key: :target_id)
162 for {relationship_type,
164 {outgoing_relation, outgoing_relation_target},
165 {incoming_relation, incoming_relation_source}
166 ]} <- @user_relationships_config do
167 # Definitions of `has_many` relations: :blocker_blocks, :muter_mutes, :reblog_muter_mutes,
168 # :notification_muter_mutes, :subscribee_subscriptions
169 has_many(outgoing_relation, UserRelationship,
170 foreign_key: :source_id,
171 where: [relationship_type: relationship_type]
174 # Definitions of `has_many` relations: :blockee_blocks, :mutee_mutes, :reblog_mutee_mutes,
175 # :notification_mutee_mutes, :subscriber_subscriptions
176 has_many(incoming_relation, UserRelationship,
177 foreign_key: :target_id,
178 where: [relationship_type: relationship_type]
181 # Definitions of `has_many` relations: :blocked_users, :muted_users, :reblog_muted_users,
182 # :notification_muted_users, :subscriber_users
183 has_many(outgoing_relation_target, through: [outgoing_relation, :target])
185 # Definitions of `has_many` relations: :blocker_users, :muter_users, :reblog_muter_users,
186 # :notification_muter_users, :subscribee_users
187 has_many(incoming_relation_source, through: [incoming_relation, :source])
190 # `:blocks` is deprecated (replaced with `blocked_users` relation)
191 field(:blocks, {:array, :string}, default: [])
192 # `:mutes` is deprecated (replaced with `muted_users` relation)
193 field(:mutes, {:array, :string}, default: [])
194 # `:muted_reblogs` is deprecated (replaced with `reblog_muted_users` relation)
195 field(:muted_reblogs, {:array, :string}, default: [])
196 # `:muted_notifications` is deprecated (replaced with `notification_muted_users` relation)
197 field(:muted_notifications, {:array, :string}, default: [])
198 # `:subscribers` is deprecated (replaced with `subscriber_users` relation)
199 field(:subscribers, {:array, :string}, default: [])
202 :multi_factor_authentication_settings,
210 for {_relationship_type, [{_outgoing_relation, outgoing_relation_target}, _]} <-
211 @user_relationships_config do
212 # `def blocked_users_relation/2`, `def muted_users_relation/2`,
213 # `def reblog_muted_users_relation/2`, `def notification_muted_users/2`,
214 # `def subscriber_users/2`
215 def unquote(:"#{outgoing_relation_target}_relation")(user, restrict_deactivated? \\ false) do
216 target_users_query = assoc(user, unquote(outgoing_relation_target))
218 if restrict_deactivated? do
219 restrict_deactivated(target_users_query)
225 # `def blocked_users/2`, `def muted_users/2`, `def reblog_muted_users/2`,
226 # `def notification_muted_users/2`, `def subscriber_users/2`
227 def unquote(outgoing_relation_target)(user, restrict_deactivated? \\ false) do
229 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
231 restrict_deactivated?
236 # `def blocked_users_ap_ids/2`, `def muted_users_ap_ids/2`, `def reblog_muted_users_ap_ids/2`,
237 # `def notification_muted_users_ap_ids/2`, `def subscriber_users_ap_ids/2`
238 def unquote(:"#{outgoing_relation_target}_ap_ids")(user, restrict_deactivated? \\ false) do
240 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
242 restrict_deactivated?
244 |> select([u], u.ap_id)
249 defdelegate following_count(user), to: FollowingRelationship
250 defdelegate following(user), to: FollowingRelationship
251 defdelegate following?(follower, followed), to: FollowingRelationship
252 defdelegate following_ap_ids(user), to: FollowingRelationship
253 defdelegate get_follow_requests(user), to: FollowingRelationship
254 defdelegate search(query, opts \\ []), to: User.Search
257 Dumps Flake Id to SQL-compatible format (16-byte UUID).
258 E.g. "9pQtDGXuq4p3VlcJEm" -> <<0, 0, 1, 110, 179, 218, 42, 92, 213, 41, 44, 227, 95, 213, 0, 0>>
260 def binary_id(source_id) when is_binary(source_id) do
261 with {:ok, dumped_id} <- FlakeId.Ecto.CompatType.dump(source_id) do
268 def binary_id(source_ids) when is_list(source_ids) do
269 Enum.map(source_ids, &binary_id/1)
272 def binary_id(%User{} = user), do: binary_id(user.id)
274 @doc "Returns status account"
275 @spec account_status(User.t()) :: account_status()
276 def account_status(%User{deactivated: true}), do: :deactivated
277 def account_status(%User{password_reset_pending: true}), do: :password_reset_pending
278 def account_status(%User{local: true, approval_pending: true}), do: :approval_pending
280 def account_status(%User{local: true, confirmation_pending: true}) do
281 if Config.get([:instance, :account_activation_required]) do
282 :confirmation_pending
288 def account_status(%User{}), do: :active
290 @spec visible_for(User.t(), User.t() | nil) ::
293 | :restricted_unauthenticated
295 | :confirmation_pending
296 def visible_for(user, for_user \\ nil)
298 def visible_for(%User{invisible: true}, _), do: :invisible
300 def visible_for(%User{id: user_id}, %User{id: user_id}), do: :visible
302 def visible_for(%User{} = user, nil) do
303 if restrict_unauthenticated?(user) do
304 :restrict_unauthenticated
306 visible_account_status(user)
310 def visible_for(%User{} = user, for_user) do
311 if superuser?(for_user) do
314 visible_account_status(user)
318 def visible_for(_, _), do: :invisible
320 defp restrict_unauthenticated?(%User{local: true}) do
321 Config.restrict_unauthenticated_access?(:profiles, :local)
324 defp restrict_unauthenticated?(%User{local: _}) do
325 Config.restrict_unauthenticated_access?(:profiles, :remote)
328 defp visible_account_status(user) do
329 status = account_status(user)
331 if status in [:active, :password_reset_pending] do
338 @spec superuser?(User.t()) :: boolean()
339 def superuser?(%User{local: true, is_admin: true}), do: true
340 def superuser?(%User{local: true, is_moderator: true}), do: true
341 def superuser?(_), do: false
343 @spec invisible?(User.t()) :: boolean()
344 def invisible?(%User{invisible: true}), do: true
345 def invisible?(_), do: false
347 def avatar_url(user, options \\ []) do
349 %{"url" => [%{"href" => href} | _]} ->
353 unless options[:no_default] do
354 Config.get([:assets, :default_user_avatar], "#{Web.base_url()}/images/avi.png")
359 def banner_url(user, options \\ []) do
361 %{"url" => [%{"href" => href} | _]} -> href
362 _ -> !options[:no_default] && "#{Web.base_url()}/images/banner.png"
366 # Should probably be renamed or removed
367 def ap_id(%User{nickname: nickname}), do: "#{Web.base_url()}/users/#{nickname}"
369 def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
370 def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"
372 @spec ap_following(User.t()) :: String.t()
373 def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
374 def ap_following(%User{} = user), do: "#{ap_id(user)}/following"
376 @spec restrict_deactivated(Ecto.Query.t()) :: Ecto.Query.t()
377 def restrict_deactivated(query) do
378 from(u in query, where: u.deactivated != ^true)
381 defp truncate_fields_param(params) do
382 if Map.has_key?(params, :fields) do
383 Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
389 defp truncate_if_exists(params, key, max_length) do
390 if Map.has_key?(params, key) and is_binary(params[key]) do
391 {value, _chopped} = String.split_at(params[key], max_length)
392 Map.put(params, key, value)
398 defp fix_follower_address(%{follower_address: _, following_address: _} = params), do: params
400 defp fix_follower_address(%{nickname: nickname} = params),
401 do: Map.put(params, :follower_address, ap_followers(%User{nickname: nickname}))
403 defp fix_follower_address(params), do: params
405 def remote_user_changeset(struct \\ %User{local: false}, params) do
406 bio_limit = Config.get([:instance, :user_bio_length], 5000)
407 name_limit = Config.get([:instance, :user_name_length], 100)
410 case params[:name] do
411 name when is_binary(name) and byte_size(name) > 0 -> name
412 _ -> params[:nickname]
417 |> Map.put(:name, name)
418 |> Map.put_new(:last_refreshed_at, NaiveDateTime.utc_now())
419 |> truncate_if_exists(:name, name_limit)
420 |> truncate_if_exists(:bio, bio_limit)
421 |> truncate_fields_param()
422 |> fix_follower_address()
445 :hide_followers_count,
454 :accepts_chat_messages
457 |> cast(params, [:name], empty_values: [])
458 |> validate_required([:ap_id])
459 |> validate_required([:name], trim: false)
460 |> unique_constraint(:nickname)
461 |> validate_format(:nickname, @email_regex)
462 |> validate_length(:bio, max: bio_limit)
463 |> validate_length(:name, max: name_limit)
464 |> validate_fields(true)
467 def update_changeset(struct, params \\ %{}) do
468 bio_limit = Config.get([:instance, :user_bio_length], 5000)
469 name_limit = Config.get([:instance, :user_name_length], 100)
489 :hide_followers_count,
492 :allow_following_move,
495 :skip_thread_containment,
498 :pleroma_settings_store,
502 :accepts_chat_messages
505 |> unique_constraint(:nickname)
506 |> validate_format(:nickname, local_nickname_regex())
507 |> validate_length(:bio, max: bio_limit)
508 |> validate_length(:name, min: 1, max: name_limit)
509 |> validate_inclusion(:actor_type, ["Person", "Service"])
512 |> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
513 |> put_change_if_present(:avatar, &put_upload(&1, :avatar))
514 |> put_change_if_present(:banner, &put_upload(&1, :banner))
515 |> put_change_if_present(:background, &put_upload(&1, :background))
516 |> put_change_if_present(
517 :pleroma_settings_store,
518 &{:ok, Map.merge(struct.pleroma_settings_store, &1)}
520 |> validate_fields(false)
523 defp put_fields(changeset) do
524 if raw_fields = get_change(changeset, :raw_fields) do
527 |> Enum.filter(fn %{"name" => n} -> n != "" end)
531 |> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)
534 |> put_change(:raw_fields, raw_fields)
535 |> put_change(:fields, fields)
541 defp parse_fields(value) do
543 |> Formatter.linkify(mentions_format: :full)
547 defp put_emoji(changeset) do
548 emojified_fields = [:bio, :name, :raw_fields]
550 if Enum.any?(changeset.changes, fn {k, _} -> k in emojified_fields end) do
551 bio = Emoji.Formatter.get_emoji_map(get_field(changeset, :bio))
552 name = Emoji.Formatter.get_emoji_map(get_field(changeset, :name))
554 emoji = Map.merge(bio, name)
558 |> get_field(:raw_fields)
559 |> Enum.reduce(emoji, fn x, acc ->
560 Map.merge(acc, Emoji.Formatter.get_emoji_map(x["name"] <> x["value"]))
563 put_change(changeset, :emoji, emoji)
569 defp put_change_if_present(changeset, map_field, value_function) do
570 with {:ok, value} <- fetch_change(changeset, map_field),
571 {:ok, new_value} <- value_function.(value) do
572 put_change(changeset, map_field, new_value)
578 defp put_upload(value, type) do
579 with %Plug.Upload{} <- value,
580 {:ok, object} <- ActivityPub.upload(value, type: type) do
585 def update_as_admin_changeset(struct, params) do
587 |> update_changeset(params)
588 |> cast(params, [:email])
589 |> delete_change(:also_known_as)
590 |> unique_constraint(:email)
591 |> validate_format(:email, @email_regex)
592 |> validate_inclusion(:actor_type, ["Person", "Service"])
595 @spec update_as_admin(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
596 def update_as_admin(user, params) do
597 params = Map.put(params, "password_confirmation", params["password"])
598 changeset = update_as_admin_changeset(user, params)
600 if params["password"] do
601 reset_password(user, changeset, params)
603 User.update_and_set_cache(changeset)
607 def password_update_changeset(struct, params) do
609 |> cast(params, [:password, :password_confirmation])
610 |> validate_required([:password, :password_confirmation])
611 |> validate_confirmation(:password)
612 |> put_password_hash()
613 |> put_change(:password_reset_pending, false)
616 @spec reset_password(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
617 def reset_password(%User{} = user, params) do
618 reset_password(user, user, params)
621 def reset_password(%User{id: user_id} = user, struct, params) do
624 |> Multi.update(:user, password_update_changeset(struct, params))
625 |> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
626 |> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))
628 case Repo.transaction(multi) do
629 {:ok, %{user: user} = _} -> set_cache(user)
630 {:error, _, changeset, _} -> {:error, changeset}
634 def update_password_reset_pending(user, value) do
637 |> put_change(:password_reset_pending, value)
638 |> update_and_set_cache()
641 def force_password_reset_async(user) do
642 BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
645 @spec force_password_reset(User.t()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
646 def force_password_reset(user), do: update_password_reset_pending(user, true)
648 # Used to auto-register LDAP accounts which won't have a password hash stored locally
649 def register_changeset_ldap(struct, params = %{password: password})
650 when is_nil(password) do
651 params = Map.put_new(params, :accepts_chat_messages, true)
654 if Map.has_key?(params, :email) do
655 Map.put_new(params, :email, params[:email])
665 :accepts_chat_messages
667 |> validate_required([:name, :nickname])
668 |> unique_constraint(:nickname)
669 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
670 |> validate_format(:nickname, local_nickname_regex())
672 |> unique_constraint(:ap_id)
673 |> put_following_and_follower_address()
676 def register_changeset(struct, params \\ %{}, opts \\ []) do
677 bio_limit = Config.get([:instance, :user_bio_length], 5000)
678 name_limit = Config.get([:instance, :user_name_length], 100)
679 reason_limit = Config.get([:instance, :registration_reason_length], 500)
680 params = Map.put_new(params, :accepts_chat_messages, true)
683 if is_nil(opts[:need_confirmation]) do
684 Config.get([:instance, :account_activation_required])
686 opts[:need_confirmation]
690 if is_nil(opts[:need_approval]) do
691 Config.get([:instance, :account_approval_required])
697 |> confirmation_changeset(need_confirmation: need_confirmation?)
698 |> approval_changeset(need_approval: need_approval?)
706 :password_confirmation,
708 :accepts_chat_messages,
711 |> validate_required([:name, :nickname, :password, :password_confirmation])
712 |> validate_confirmation(:password)
713 |> unique_constraint(:email)
714 |> validate_format(:email, @email_regex)
715 |> validate_change(:email, fn :email, email ->
717 Config.get([User, :email_blacklist])
718 |> Enum.all?(fn blacklisted_domain ->
719 !String.ends_with?(email, ["@" <> blacklisted_domain, "." <> blacklisted_domain])
722 if valid?, do: [], else: [email: "Invalid email"]
724 |> unique_constraint(:nickname)
725 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
726 |> validate_format(:nickname, local_nickname_regex())
727 |> validate_length(:bio, max: bio_limit)
728 |> validate_length(:name, min: 1, max: name_limit)
729 |> validate_length(:registration_reason, max: reason_limit)
730 |> maybe_validate_required_email(opts[:external])
733 |> unique_constraint(:ap_id)
734 |> put_following_and_follower_address()
737 def maybe_validate_required_email(changeset, true), do: changeset
739 def maybe_validate_required_email(changeset, _) do
740 if Config.get([:instance, :account_activation_required]) do
741 validate_required(changeset, [:email])
747 defp put_ap_id(changeset) do
748 ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
749 put_change(changeset, :ap_id, ap_id)
752 defp put_following_and_follower_address(changeset) do
753 followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
756 |> put_change(:follower_address, followers)
759 defp autofollow_users(user) do
760 candidates = Config.get([:instance, :autofollowed_nicknames])
763 User.Query.build(%{nickname: candidates, local: true, deactivated: false})
766 follow_all(user, autofollowed_users)
769 defp autofollowing_users(user) do
770 candidates = Config.get([:instance, :autofollowing_nicknames])
772 User.Query.build(%{nickname: candidates, local: true, deactivated: false})
774 |> Enum.each(&follow(&1, user, :follow_accept))
779 @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
780 def register(%Ecto.Changeset{} = changeset) do
781 with {:ok, user} <- Repo.insert(changeset) do
782 post_register_action(user)
786 def post_register_action(%User{} = user) do
787 with {:ok, user} <- autofollow_users(user),
788 {:ok, _} <- autofollowing_users(user),
789 {:ok, user} <- set_cache(user),
790 {:ok, _} <- send_welcome_email(user),
791 {:ok, _} <- send_welcome_message(user),
792 {:ok, _} <- send_welcome_chat_message(user),
793 {:ok, _} <- try_send_confirmation_email(user) do
798 def send_welcome_message(user) do
799 if User.WelcomeMessage.enabled?() do
800 User.WelcomeMessage.post_message(user)
807 def send_welcome_chat_message(user) do
808 if User.WelcomeChatMessage.enabled?() do
809 User.WelcomeChatMessage.post_message(user)
816 def send_welcome_email(%User{email: email} = user) when is_binary(email) do
817 if User.WelcomeEmail.enabled?() do
818 User.WelcomeEmail.send_email(user)
825 def send_welcome_email(_), do: {:ok, :noop}
827 @spec try_send_confirmation_email(User.t()) :: {:ok, :enqueued | :noop}
828 def try_send_confirmation_email(%User{confirmation_pending: true, email: email} = user)
829 when is_binary(email) do
830 if Config.get([:instance, :account_activation_required]) do
831 send_confirmation_email(user)
838 def try_send_confirmation_email(_), do: {:ok, :noop}
840 @spec send_confirmation_email(Uset.t()) :: User.t()
841 def send_confirmation_email(%User{} = user) do
843 |> Pleroma.Emails.UserEmail.account_confirmation_email()
844 |> Pleroma.Emails.Mailer.deliver_async()
849 def needs_update?(%User{local: true}), do: false
851 def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
853 def needs_update?(%User{local: false} = user) do
854 NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
857 def needs_update?(_), do: true
859 @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
861 # "Locked" (self-locked) users demand explicit authorization of follow requests
862 def maybe_direct_follow(%User{} = follower, %User{local: true, is_locked: true} = followed) do
863 follow(follower, followed, :follow_pending)
866 def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
867 follow(follower, followed)
870 def maybe_direct_follow(%User{} = follower, %User{} = followed) do
871 if not ap_enabled?(followed) do
872 follow(follower, followed)
878 @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
879 @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
880 def follow_all(follower, followeds) do
882 |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
883 |> Enum.each(&follow(follower, &1, :follow_accept))
888 def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
889 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
892 followed.deactivated ->
893 {:error, "Could not follow user: #{followed.nickname} is deactivated."}
895 deny_follow_blocked and blocks?(followed, follower) ->
896 {:error, "Could not follow user: #{followed.nickname} blocked you."}
899 FollowingRelationship.follow(follower, followed, state)
901 {:ok, _} = update_follower_count(followed)
904 |> update_following_count()
908 def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
909 {:error, "Not subscribed!"}
912 @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
913 def unfollow(%User{} = follower, %User{} = followed) do
914 case do_unfollow(follower, followed) do
915 {:ok, follower, followed} ->
916 {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
923 @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
924 defp do_unfollow(%User{} = follower, %User{} = followed) do
925 case get_follow_state(follower, followed) do
926 state when state in [:follow_pending, :follow_accept] ->
927 FollowingRelationship.unfollow(follower, followed)
928 {:ok, followed} = update_follower_count(followed)
930 {:ok, follower} = update_following_count(follower)
932 {:ok, follower, followed}
935 {:error, "Not subscribed!"}
939 @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
940 def get_follow_state(%User{} = follower, %User{} = following) do
941 following_relationship = FollowingRelationship.get(follower, following)
942 get_follow_state(follower, following, following_relationship)
945 def get_follow_state(
948 following_relationship
950 case {following_relationship, following.local} do
952 case Utils.fetch_latest_follow(follower, following) do
953 %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
954 FollowingRelationship.state_to_enum(state)
960 {%{state: state}, _} ->
968 def locked?(%User{} = user) do
969 user.is_locked || false
973 Repo.get_by(User, id: id)
976 def get_by_ap_id(ap_id) do
977 Repo.get_by(User, ap_id: ap_id)
980 def get_all_by_ap_id(ap_ids) do
981 from(u in __MODULE__,
982 where: u.ap_id in ^ap_ids
987 def get_all_by_ids(ids) do
988 from(u in __MODULE__, where: u.id in ^ids)
992 # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
993 # of the ap_id and the domain and tries to get that user
994 def get_by_guessed_nickname(ap_id) do
995 domain = URI.parse(ap_id).host
996 name = List.last(String.split(ap_id, "/"))
997 nickname = "#{name}@#{domain}"
999 get_cached_by_nickname(nickname)
1002 def set_cache({:ok, user}), do: set_cache(user)
1003 def set_cache({:error, err}), do: {:error, err}
1005 def set_cache(%User{} = user) do
1006 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1007 Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
1008 Cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
1012 def update_and_set_cache(struct, params) do
1014 |> update_changeset(params)
1015 |> update_and_set_cache()
1018 def update_and_set_cache(changeset) do
1019 with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
1024 def get_user_friends_ap_ids(user) do
1025 from(u in User.get_friends_query(user), select: u.ap_id)
1029 @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
1030 def get_cached_user_friends_ap_ids(user) do
1031 Cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
1032 get_user_friends_ap_ids(user)
1036 def invalidate_cache(user) do
1037 Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
1038 Cachex.del(:user_cache, "nickname:#{user.nickname}")
1039 Cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
1042 @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
1043 def get_cached_by_ap_id(ap_id) do
1044 key = "ap_id:#{ap_id}"
1046 with {:ok, nil} <- Cachex.get(:user_cache, key),
1047 user when not is_nil(user) <- get_by_ap_id(ap_id),
1048 {:ok, true} <- Cachex.put(:user_cache, key, user) do
1056 def get_cached_by_id(id) do
1060 Cachex.fetch!(:user_cache, key, fn _ ->
1061 user = get_by_id(id)
1064 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1065 {:commit, user.ap_id}
1071 get_cached_by_ap_id(ap_id)
1074 def get_cached_by_nickname(nickname) do
1075 key = "nickname:#{nickname}"
1077 Cachex.fetch!(:user_cache, key, fn ->
1078 case get_or_fetch_by_nickname(nickname) do
1079 {:ok, user} -> {:commit, user}
1080 {:error, _error} -> {:ignore, nil}
1085 def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
1086 restrict_to_local = Config.get([:instance, :limit_to_local_content])
1089 is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
1090 get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
1092 restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
1093 get_cached_by_nickname(nickname_or_id)
1095 restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
1096 get_cached_by_nickname(nickname_or_id)
1103 @spec get_by_nickname(String.t()) :: User.t() | nil
1104 def get_by_nickname(nickname) do
1105 Repo.get_by(User, nickname: nickname) ||
1106 if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
1107 Repo.get_by(User, nickname: local_nickname(nickname))
1111 def get_by_email(email), do: Repo.get_by(User, email: email)
1113 def get_by_nickname_or_email(nickname_or_email) do
1114 get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
1117 def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
1119 def get_or_fetch_by_nickname(nickname) do
1120 with %User{} = user <- get_by_nickname(nickname) do
1124 with [_nick, _domain] <- String.split(nickname, "@"),
1125 {:ok, user} <- fetch_by_nickname(nickname) do
1128 _e -> {:error, "not found " <> nickname}
1133 @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1134 def get_followers_query(%User{} = user, nil) do
1135 User.Query.build(%{followers: user, deactivated: false})
1138 def get_followers_query(%User{} = user, page) do
1140 |> get_followers_query(nil)
1141 |> User.Query.paginate(page, 20)
1144 @spec get_followers_query(User.t()) :: Ecto.Query.t()
1145 def get_followers_query(%User{} = user), do: get_followers_query(user, nil)
1147 @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1148 def get_followers(%User{} = user, page \\ nil) do
1150 |> get_followers_query(page)
1154 @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1155 def get_external_followers(%User{} = user, page \\ nil) do
1157 |> get_followers_query(page)
1158 |> User.Query.build(%{external: true})
1162 def get_followers_ids(%User{} = user, page \\ nil) do
1164 |> get_followers_query(page)
1165 |> select([u], u.id)
1169 @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1170 def get_friends_query(%User{} = user, nil) do
1171 User.Query.build(%{friends: user, deactivated: false})
1174 def get_friends_query(%User{} = user, page) do
1176 |> get_friends_query(nil)
1177 |> User.Query.paginate(page, 20)
1180 @spec get_friends_query(User.t()) :: Ecto.Query.t()
1181 def get_friends_query(%User{} = user), do: get_friends_query(user, nil)
1183 def get_friends(%User{} = user, page \\ nil) do
1185 |> get_friends_query(page)
1189 def get_friends_ap_ids(%User{} = user) do
1191 |> get_friends_query(nil)
1192 |> select([u], u.ap_id)
1196 def get_friends_ids(%User{} = user, page \\ nil) do
1198 |> get_friends_query(page)
1199 |> select([u], u.id)
1203 def increase_note_count(%User{} = user) do
1205 |> where(id: ^user.id)
1206 |> update([u], inc: [note_count: 1])
1208 |> Repo.update_all([])
1210 {1, [user]} -> set_cache(user)
1215 def decrease_note_count(%User{} = user) do
1217 |> where(id: ^user.id)
1220 note_count: fragment("greatest(0, note_count - 1)")
1224 |> Repo.update_all([])
1226 {1, [user]} -> set_cache(user)
1231 def update_note_count(%User{} = user, note_count \\ nil) do
1236 where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1242 |> cast(%{note_count: note_count}, [:note_count])
1243 |> update_and_set_cache()
1246 @spec maybe_fetch_follow_information(User.t()) :: User.t()
1247 def maybe_fetch_follow_information(user) do
1248 with {:ok, user} <- fetch_follow_information(user) do
1252 Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1258 def fetch_follow_information(user) do
1259 with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1261 |> follow_information_changeset(info)
1262 |> update_and_set_cache()
1266 defp follow_information_changeset(user, params) do
1273 :hide_followers_count,
1278 @spec update_follower_count(User.t()) :: {:ok, User.t()}
1279 def update_follower_count(%User{} = user) do
1280 if user.local or !Config.get([:instance, :external_user_synchronization]) do
1281 follower_count = FollowingRelationship.follower_count(user)
1284 |> follow_information_changeset(%{follower_count: follower_count})
1285 |> update_and_set_cache
1287 {:ok, maybe_fetch_follow_information(user)}
1291 @spec update_following_count(User.t()) :: {:ok, User.t()}
1292 def update_following_count(%User{local: false} = user) do
1293 if Config.get([:instance, :external_user_synchronization]) do
1294 {:ok, maybe_fetch_follow_information(user)}
1300 def update_following_count(%User{local: true} = user) do
1301 following_count = FollowingRelationship.following_count(user)
1304 |> follow_information_changeset(%{following_count: following_count})
1305 |> update_and_set_cache()
1308 def set_unread_conversation_count(%User{local: true} = user) do
1309 unread_query = Participation.unread_conversation_count_for_user(user)
1312 |> join(:inner, [u], p in subquery(unread_query))
1314 set: [unread_conversation_count: p.count]
1316 |> where([u], u.id == ^user.id)
1318 |> Repo.update_all([])
1320 {1, [user]} -> set_cache(user)
1325 def set_unread_conversation_count(user), do: {:ok, user}
1327 def increment_unread_conversation_count(conversation, %User{local: true} = user) do
1329 Participation.unread_conversation_count_for_user(user)
1330 |> where([p], p.conversation_id == ^conversation.id)
1333 |> join(:inner, [u], p in subquery(unread_query))
1335 inc: [unread_conversation_count: 1]
1337 |> where([u], u.id == ^user.id)
1338 |> where([u, p], p.count == 0)
1340 |> Repo.update_all([])
1342 {1, [user]} -> set_cache(user)
1347 def increment_unread_conversation_count(_, user), do: {:ok, user}
1349 @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1350 def get_users_from_set(ap_ids, opts \\ []) do
1351 local_only = Keyword.get(opts, :local_only, true)
1352 criteria = %{ap_id: ap_ids, deactivated: false}
1353 criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1355 User.Query.build(criteria)
1359 @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1360 def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1363 query = User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
1369 @spec mute(User.t(), User.t(), boolean()) ::
1370 {:ok, list(UserRelationship.t())} | {:error, String.t()}
1371 def mute(%User{} = muter, %User{} = mutee, notifications? \\ true) do
1372 add_to_mutes(muter, mutee, notifications?)
1375 def unmute(%User{} = muter, %User{} = mutee) do
1376 remove_from_mutes(muter, mutee)
1379 def subscribe(%User{} = subscriber, %User{} = target) do
1380 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
1382 if blocks?(target, subscriber) and deny_follow_blocked do
1383 {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1385 # Note: the relationship is inverse: subscriber acts as relationship target
1386 UserRelationship.create_inverse_subscription(target, subscriber)
1390 def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1391 with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1392 subscribe(subscriber, subscribee)
1396 def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1397 # Note: the relationship is inverse: subscriber acts as relationship target
1398 UserRelationship.delete_inverse_subscription(target, unsubscriber)
1401 def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1402 with %User{} = user <- get_cached_by_ap_id(ap_id) do
1403 unsubscribe(unsubscriber, user)
1407 def block(%User{} = blocker, %User{} = blocked) do
1408 # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1410 if following?(blocker, blocked) do
1411 {:ok, blocker, _} = unfollow(blocker, blocked)
1417 # clear any requested follows as well
1419 case CommonAPI.reject_follow_request(blocked, blocker) do
1420 {:ok, %User{} = updated_blocked} -> updated_blocked
1424 unsubscribe(blocked, blocker)
1426 unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
1427 if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)
1429 {:ok, blocker} = update_follower_count(blocker)
1430 {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1431 add_to_block(blocker, blocked)
1434 # helper to handle the block given only an actor's AP id
1435 def block(%User{} = blocker, %{ap_id: ap_id}) do
1436 block(blocker, get_cached_by_ap_id(ap_id))
1439 def unblock(%User{} = blocker, %User{} = blocked) do
1440 remove_from_block(blocker, blocked)
1443 # helper to handle the block given only an actor's AP id
1444 def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1445 unblock(blocker, get_cached_by_ap_id(ap_id))
1448 def mutes?(nil, _), do: false
1449 def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1451 def mutes_user?(%User{} = user, %User{} = target) do
1452 UserRelationship.mute_exists?(user, target)
1455 @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1456 def muted_notifications?(nil, _), do: false
1458 def muted_notifications?(%User{} = user, %User{} = target),
1459 do: UserRelationship.notification_mute_exists?(user, target)
1461 def blocks?(nil, _), do: false
1463 def blocks?(%User{} = user, %User{} = target) do
1464 blocks_user?(user, target) ||
1465 (blocks_domain?(user, target) and not User.following?(user, target))
1468 def blocks_user?(%User{} = user, %User{} = target) do
1469 UserRelationship.block_exists?(user, target)
1472 def blocks_user?(_, _), do: false
1474 def blocks_domain?(%User{} = user, %User{} = target) do
1475 domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1476 %{host: host} = URI.parse(target.ap_id)
1477 Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1480 def blocks_domain?(_, _), do: false
1482 def subscribed_to?(%User{} = user, %User{} = target) do
1483 # Note: the relationship is inverse: subscriber acts as relationship target
1484 UserRelationship.inverse_subscription_exists?(target, user)
1487 def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1488 with %User{} = target <- get_cached_by_ap_id(ap_id) do
1489 subscribed_to?(user, target)
1494 Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1495 E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1497 @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1498 def outgoing_relationships_ap_ids(_user, []), do: %{}
1500 def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1502 def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1503 when is_list(relationship_types) do
1506 |> assoc(:outgoing_relationships)
1507 |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1508 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1509 |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1510 |> group_by([user_rel, u], user_rel.relationship_type)
1512 |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1517 fn rel_type -> {rel_type, db_result[rel_type] || []} end
1521 def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1523 def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1525 def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1527 def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1528 when is_list(relationship_types) do
1530 |> assoc(:incoming_relationships)
1531 |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1532 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1533 |> maybe_filter_on_ap_id(ap_ids)
1534 |> select([user_rel, u], u.ap_id)
1539 defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1540 where(query, [user_rel, u], u.ap_id in ^ap_ids)
1543 defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1545 def deactivate_async(user, status \\ true) do
1546 BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
1549 def deactivate(user, status \\ true)
1551 def deactivate(users, status) when is_list(users) do
1552 Repo.transaction(fn ->
1553 for user <- users, do: deactivate(user, status)
1557 def deactivate(%User{} = user, status) do
1558 with {:ok, user} <- set_activation_status(user, status) do
1561 |> Enum.filter(& &1.local)
1562 |> Enum.each(&set_cache(update_following_count(&1)))
1564 # Only update local user counts, remote will be update during the next pull.
1567 |> Enum.filter(& &1.local)
1568 |> Enum.each(&do_unfollow(user, &1))
1574 def approve(users) when is_list(users) do
1575 Repo.transaction(fn ->
1576 Enum.map(users, fn user ->
1577 with {:ok, user} <- approve(user), do: user
1582 def approve(%User{} = user) do
1583 change(user, approval_pending: false)
1584 |> update_and_set_cache()
1587 def update_notification_settings(%User{} = user, settings) do
1589 |> cast(%{notification_settings: settings}, [])
1590 |> cast_embed(:notification_settings)
1591 |> validate_required([:notification_settings])
1592 |> update_and_set_cache()
1595 @spec purge_user_changeset(User.t()) :: Changeset.t()
1596 def purge_user_changeset(user) do
1597 # "Right to be forgotten"
1598 # https://gdpr.eu/right-to-be-forgotten/
1609 last_refreshed_at: nil,
1610 last_digest_emailed_at: nil,
1617 confirmation_pending: false,
1618 password_reset_pending: false,
1619 approval_pending: false,
1620 registration_reason: nil,
1621 confirmation_token: nil,
1625 is_moderator: false,
1627 mastofe_settings: nil,
1630 pleroma_settings_store: %{},
1633 is_discoverable: false,
1638 def delete(users) when is_list(users) do
1639 for user <- users, do: delete(user)
1642 def delete(%User{} = user) do
1643 BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1646 defp delete_and_invalidate_cache(%User{} = user) do
1647 invalidate_cache(user)
1651 defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)
1653 defp delete_or_deactivate(%User{local: true} = user) do
1654 status = account_status(user)
1657 :confirmation_pending ->
1658 delete_and_invalidate_cache(user)
1660 :approval_pending ->
1661 delete_and_invalidate_cache(user)
1665 |> purge_user_changeset()
1666 |> update_and_set_cache()
1670 def perform(:force_password_reset, user), do: force_password_reset(user)
1672 @spec perform(atom(), User.t()) :: {:ok, User.t()}
1673 def perform(:delete, %User{} = user) do
1674 # Remove all relationships
1677 |> Enum.each(fn follower ->
1678 ActivityPub.unfollow(follower, user)
1679 unfollow(follower, user)
1684 |> Enum.each(fn followed ->
1685 ActivityPub.unfollow(user, followed)
1686 unfollow(user, followed)
1689 delete_user_activities(user)
1690 delete_notifications_from_user_activities(user)
1692 delete_outgoing_pending_follow_requests(user)
1694 delete_or_deactivate(user)
1697 def perform(:deactivate_async, user, status), do: deactivate(user, status)
1699 @spec external_users_query() :: Ecto.Query.t()
1700 def external_users_query do
1708 @spec external_users(keyword()) :: [User.t()]
1709 def external_users(opts \\ []) do
1711 external_users_query()
1712 |> select([u], struct(u, [:id, :ap_id]))
1716 do: where(query, [u], u.id > ^opts[:max_id]),
1721 do: limit(query, ^opts[:limit]),
1727 def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1729 |> join(:inner, [n], activity in assoc(n, :activity))
1730 |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1731 |> Repo.delete_all()
1734 def delete_user_activities(%User{ap_id: ap_id} = user) do
1736 |> Activity.Queries.by_actor()
1737 |> Repo.chunk_stream(50, :batches)
1738 |> Stream.each(fn activities ->
1739 Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1744 defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1745 with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1746 {:ok, delete_data, _} <- Builder.delete(user, object) do
1747 Pipeline.common_pipeline(delete_data, local: user.local)
1749 {:find_object, nil} ->
1750 # We have the create activity, but not the object, it was probably pruned.
1751 # Insert a tombstone and try again
1752 with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1753 {:ok, _tombstone} <- Object.create(tombstone_data) do
1754 delete_activity(activity, user)
1758 Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1759 Logger.error("Error: #{inspect(e)}")
1763 defp delete_activity(%{data: %{"type" => type}} = activity, user)
1764 when type in ["Like", "Announce"] do
1765 {:ok, undo, _} = Builder.undo(user, activity)
1766 Pipeline.common_pipeline(undo, local: user.local)
1769 defp delete_activity(_activity, _user), do: "Doing nothing"
1771 defp delete_outgoing_pending_follow_requests(user) do
1773 |> FollowingRelationship.outgoing_pending_follow_requests_query()
1774 |> Repo.delete_all()
1777 def html_filter_policy(%User{no_rich_text: true}) do
1778 Pleroma.HTML.Scrubber.TwitterText
1781 def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])
1783 def fetch_by_ap_id(ap_id, opts \\ []), do: ActivityPub.make_user_from_ap_id(ap_id, opts)
1785 def get_or_fetch_by_ap_id(ap_id, opts \\ []) do
1786 cached_user = get_cached_by_ap_id(ap_id)
1788 maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id, opts)
1790 case {cached_user, maybe_fetched_user} do
1791 {_, {:ok, %User{} = user}} ->
1794 {%User{} = user, _} ->
1798 {:error, :not_found}
1803 Creates an internal service actor by URI if missing.
1804 Optionally takes nickname for addressing.
1806 @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1807 def get_or_create_service_actor_by_ap_id(uri, nickname) do
1809 case get_cached_by_ap_id(uri) do
1811 with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1812 Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1816 %User{invisible: false} = user ->
1826 @spec set_invisible(User.t()) :: {:ok, User.t()}
1827 defp set_invisible(user) do
1829 |> change(%{invisible: true})
1830 |> update_and_set_cache()
1833 @spec create_service_actor(String.t(), String.t()) ::
1834 {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1835 defp create_service_actor(uri, nickname) do
1841 follower_address: uri <> "/followers"
1844 |> unique_constraint(:nickname)
1849 def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1852 |> :public_key.pem_decode()
1854 |> :public_key.pem_entry_decode()
1859 def public_key(_), do: {:error, "key not found"}
1861 def get_public_key_for_ap_id(ap_id, opts \\ []) do
1862 with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id, opts),
1863 {:ok, public_key} <- public_key(user) do
1870 def ap_enabled?(%User{local: true}), do: true
1871 def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1872 def ap_enabled?(_), do: false
1874 @doc "Gets or fetch a user by uri or nickname."
1875 @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1876 def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1877 def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1879 # wait a period of time and return newest version of the User structs
1880 # this is because we have synchronous follow APIs and need to simulate them
1881 # with an async handshake
1882 def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1883 with %User{} = a <- get_cached_by_id(a.id),
1884 %User{} = b <- get_cached_by_id(b.id) do
1891 def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1892 with :ok <- :timer.sleep(timeout),
1893 %User{} = a <- get_cached_by_id(a.id),
1894 %User{} = b <- get_cached_by_id(b.id) do
1901 def parse_bio(bio) when is_binary(bio) and bio != "" do
1903 |> CommonUtils.format_input("text/plain", mentions_format: :full)
1907 def parse_bio(_), do: ""
1909 def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1910 # TODO: get profile URLs other than user.ap_id
1911 profile_urls = [user.ap_id]
1914 |> CommonUtils.format_input("text/plain",
1915 mentions_format: :full,
1916 rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1921 def parse_bio(_, _), do: ""
1923 def tag(user_identifiers, tags) when is_list(user_identifiers) do
1924 Repo.transaction(fn ->
1925 for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1929 def tag(nickname, tags) when is_binary(nickname),
1930 do: tag(get_by_nickname(nickname), tags)
1932 def tag(%User{} = user, tags),
1933 do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1935 def untag(user_identifiers, tags) when is_list(user_identifiers) do
1936 Repo.transaction(fn ->
1937 for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1941 def untag(nickname, tags) when is_binary(nickname),
1942 do: untag(get_by_nickname(nickname), tags)
1944 def untag(%User{} = user, tags),
1945 do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1947 defp update_tags(%User{} = user, new_tags) do
1948 {:ok, updated_user} =
1950 |> change(%{tags: new_tags})
1951 |> update_and_set_cache()
1956 defp normalize_tags(tags) do
1959 |> Enum.map(&String.downcase/1)
1962 defp local_nickname_regex do
1963 if Config.get([:instance, :extended_nickname_format]) do
1964 @extended_local_nickname_regex
1966 @strict_local_nickname_regex
1970 def local_nickname(nickname_or_mention) do
1973 |> String.split("@")
1977 def full_nickname(nickname_or_mention),
1978 do: String.trim_leading(nickname_or_mention, "@")
1980 def error_user(ap_id) do
1984 nickname: "erroruser@example.com",
1985 inserted_at: NaiveDateTime.utc_now()
1989 @spec all_superusers() :: [User.t()]
1990 def all_superusers do
1991 User.Query.build(%{super_users: true, local: true, deactivated: false})
1995 def muting_reblogs?(%User{} = user, %User{} = target) do
1996 UserRelationship.reblog_mute_exists?(user, target)
1999 def showing_reblogs?(%User{} = user, %User{} = target) do
2000 not muting_reblogs?(user, target)
2004 The function returns a query to get users with no activity for given interval of days.
2005 Inactive users are those who didn't read any notification, or had any activity where
2006 the user is the activity's actor, during `inactivity_threshold` days.
2007 Deactivated users will not appear in this list.
2011 iex> Pleroma.User.list_inactive_users()
2014 @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
2015 def list_inactive_users_query(inactivity_threshold \\ 7) do
2016 negative_inactivity_threshold = -inactivity_threshold
2017 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2018 # Subqueries are not supported in `where` clauses, join gets too complicated.
2019 has_read_notifications =
2020 from(n in Pleroma.Notification,
2021 where: n.seen == true,
2023 having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
2026 |> Pleroma.Repo.all()
2028 from(u in Pleroma.User,
2029 left_join: a in Pleroma.Activity,
2030 on: u.ap_id == a.actor,
2031 where: not is_nil(u.nickname),
2032 where: u.deactivated != ^true,
2033 where: u.id not in ^has_read_notifications,
2036 max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
2037 is_nil(max(a.inserted_at))
2042 Enable or disable email notifications for user
2046 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
2047 Pleroma.User{email_notifications: %{"digest" => true}}
2049 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
2050 Pleroma.User{email_notifications: %{"digest" => false}}
2052 @spec switch_email_notifications(t(), String.t(), boolean()) ::
2053 {:ok, t()} | {:error, Ecto.Changeset.t()}
2054 def switch_email_notifications(user, type, status) do
2055 User.update_email_notifications(user, %{type => status})
2059 Set `last_digest_emailed_at` value for the user to current time
2061 @spec touch_last_digest_emailed_at(t()) :: t()
2062 def touch_last_digest_emailed_at(user) do
2063 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2065 {:ok, updated_user} =
2067 |> change(%{last_digest_emailed_at: now})
2068 |> update_and_set_cache()
2073 @spec toggle_confirmation(User.t()) :: {:ok, User.t()} | {:error, Changeset.t()}
2074 def toggle_confirmation(%User{} = user) do
2076 |> confirmation_changeset(need_confirmation: !user.confirmation_pending)
2077 |> update_and_set_cache()
2080 @spec toggle_confirmation([User.t()]) :: [{:ok, User.t()} | {:error, Changeset.t()}]
2081 def toggle_confirmation(users) do
2082 Enum.map(users, &toggle_confirmation/1)
2085 @spec need_confirmation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
2086 def need_confirmation(%User{} = user, bool) do
2088 |> confirmation_changeset(need_confirmation: bool)
2089 |> update_and_set_cache()
2092 def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
2096 def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
2097 # use instance-default
2098 config = Config.get([:assets, :mascots])
2099 default_mascot = Config.get([:assets, :default_mascot])
2100 mascot = Keyword.get(config, default_mascot)
2103 "id" => "default-mascot",
2104 "url" => mascot[:url],
2105 "preview_url" => mascot[:url],
2107 "mime_type" => mascot[:mime_type]
2112 def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
2114 def ensure_keys_present(%User{} = user) do
2115 with {:ok, pem} <- Keys.generate_rsa_pem() do
2117 |> cast(%{keys: pem}, [:keys])
2118 |> validate_required([:keys])
2119 |> update_and_set_cache()
2123 def get_ap_ids_by_nicknames(nicknames) do
2125 where: u.nickname in ^nicknames,
2131 defp put_password_hash(
2132 %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2134 change(changeset, password_hash: Pbkdf2.hash_pwd_salt(password))
2137 defp put_password_hash(changeset), do: changeset
2139 def is_internal_user?(%User{nickname: nil}), do: true
2140 def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2141 def is_internal_user?(_), do: false
2143 # A hack because user delete activities have a fake id for whatever reason
2144 # TODO: Get rid of this
2145 def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2147 def get_delivered_users_by_object_id(object_id) do
2149 inner_join: delivery in assoc(u, :deliveries),
2150 where: delivery.object_id == ^object_id
2155 def change_email(user, email) do
2157 |> cast(%{email: email}, [:email])
2158 |> validate_required([:email])
2159 |> unique_constraint(:email)
2160 |> validate_format(:email, @email_regex)
2161 |> update_and_set_cache()
2164 # Internal function; public one is `deactivate/2`
2165 defp set_activation_status(user, deactivated) do
2167 |> cast(%{deactivated: deactivated}, [:deactivated])
2168 |> update_and_set_cache()
2171 def update_banner(user, banner) do
2173 |> cast(%{banner: banner}, [:banner])
2174 |> update_and_set_cache()
2177 def update_background(user, background) do
2179 |> cast(%{background: background}, [:background])
2180 |> update_and_set_cache()
2183 def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
2186 moderator: is_moderator
2190 def validate_fields(changeset, remote? \\ false) do
2191 limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2192 limit = Config.get([:instance, limit_name], 0)
2195 |> validate_length(:fields, max: limit)
2196 |> validate_change(:fields, fn :fields, fields ->
2197 if Enum.all?(fields, &valid_field?/1) do
2205 defp valid_field?(%{"name" => name, "value" => value}) do
2206 name_limit = Config.get([:instance, :account_field_name_length], 255)
2207 value_limit = Config.get([:instance, :account_field_value_length], 255)
2209 is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2210 String.length(value) <= value_limit
2213 defp valid_field?(_), do: false
2215 defp truncate_field(%{"name" => name, "value" => value}) do
2217 String.split_at(name, Config.get([:instance, :account_field_name_length], 255))
2220 String.split_at(value, Config.get([:instance, :account_field_value_length], 255))
2222 %{"name" => name, "value" => value}
2225 def admin_api_update(user, params) do
2232 |> update_and_set_cache()
2235 @doc "Signs user out of all applications"
2236 def global_sign_out(user) do
2237 OAuth.Authorization.delete_user_authorizations(user)
2238 OAuth.Token.delete_user_tokens(user)
2241 def mascot_update(user, url) do
2243 |> cast(%{mascot: url}, [:mascot])
2244 |> validate_required([:mascot])
2245 |> update_and_set_cache()
2248 def mastodon_settings_update(user, settings) do
2250 |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
2251 |> validate_required([:mastofe_settings])
2252 |> update_and_set_cache()
2255 @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2256 def confirmation_changeset(user, need_confirmation: need_confirmation?) do
2258 if need_confirmation? do
2260 confirmation_pending: true,
2261 confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2265 confirmation_pending: false,
2266 confirmation_token: nil
2270 cast(user, params, [:confirmation_pending, :confirmation_token])
2273 @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
2274 def approval_changeset(user, need_approval: need_approval?) do
2275 params = if need_approval?, do: %{approval_pending: true}, else: %{approval_pending: false}
2276 cast(user, params, [:approval_pending])
2279 def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2280 if id not in user.pinned_activities do
2281 max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2282 params = %{pinned_activities: user.pinned_activities ++ [id]}
2284 # if pinned activity was scheduled for deletion, we remove job
2285 if expiration = Pleroma.Workers.PurgeExpiredActivity.get_expiration(id) do
2286 Oban.cancel_job(expiration.id)
2290 |> cast(params, [:pinned_activities])
2291 |> validate_length(:pinned_activities,
2292 max: max_pinned_statuses,
2293 message: "You have already pinned the maximum number of statuses"
2298 |> update_and_set_cache()
2301 def remove_pinnned_activity(user, %Pleroma.Activity{id: id, data: data}) do
2302 params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2304 # if pinned activity was scheduled for deletion, we reschedule it for deletion
2305 if data["expires_at"] do
2306 # MRF.ActivityExpirationPolicy used UTC timestamps for expires_at in original implementation
2308 data["expires_at"] |> Pleroma.EctoType.ActivityPub.ObjectValidators.DateTime.cast()
2310 Pleroma.Workers.PurgeExpiredActivity.enqueue(%{
2312 expires_at: expires_at
2317 |> cast(params, [:pinned_activities])
2318 |> update_and_set_cache()
2321 def update_email_notifications(user, settings) do
2322 email_notifications =
2323 user.email_notifications
2324 |> Map.merge(settings)
2325 |> Map.take(["digest"])
2327 params = %{email_notifications: email_notifications}
2328 fields = [:email_notifications]
2331 |> cast(params, fields)
2332 |> validate_required(fields)
2333 |> update_and_set_cache()
2336 defp set_domain_blocks(user, domain_blocks) do
2337 params = %{domain_blocks: domain_blocks}
2340 |> cast(params, [:domain_blocks])
2341 |> validate_required([:domain_blocks])
2342 |> update_and_set_cache()
2345 def block_domain(user, domain_blocked) do
2346 set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2349 def unblock_domain(user, domain_blocked) do
2350 set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2353 @spec add_to_block(User.t(), User.t()) ::
2354 {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2355 defp add_to_block(%User{} = user, %User{} = blocked) do
2356 UserRelationship.create_block(user, blocked)
2359 @spec add_to_block(User.t(), User.t()) ::
2360 {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2361 defp remove_from_block(%User{} = user, %User{} = blocked) do
2362 UserRelationship.delete_block(user, blocked)
2365 defp add_to_mutes(%User{} = user, %User{} = muted_user, notifications?) do
2366 with {:ok, user_mute} <- UserRelationship.create_mute(user, muted_user),
2367 {:ok, user_notification_mute} <-
2368 (notifications? && UserRelationship.create_notification_mute(user, muted_user)) ||
2370 {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
2374 defp remove_from_mutes(user, %User{} = muted_user) do
2375 with {:ok, user_mute} <- UserRelationship.delete_mute(user, muted_user),
2376 {:ok, user_notification_mute} <-
2377 UserRelationship.delete_notification_mute(user, muted_user) do
2378 {:ok, [user_mute, user_notification_mute]}
2382 def set_invisible(user, invisible) do
2383 params = %{invisible: invisible}
2386 |> cast(params, [:invisible])
2387 |> validate_required([:invisible])
2388 |> update_and_set_cache()
2391 def sanitize_html(%User{} = user) do
2392 sanitize_html(user, nil)
2395 # User data that mastodon isn't filtering (treated as plaintext):
2398 def sanitize_html(%User{} = user, filter) do
2400 Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2403 "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2408 |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2409 |> Map.put(:fields, fields)