1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.User do
10 import Ecto, only: [assoc: 2]
13 alias Pleroma.Activity
15 alias Pleroma.Conversation.Participation
16 alias Pleroma.Delivery
17 alias Pleroma.EctoType.ActivityPub.ObjectValidators
19 alias Pleroma.FollowingRelationship
20 alias Pleroma.Formatter
24 alias Pleroma.Notification
26 alias Pleroma.Registration
29 alias Pleroma.UserRelationship
30 alias Pleroma.Web.ActivityPub.ActivityPub
31 alias Pleroma.Web.ActivityPub.Builder
32 alias Pleroma.Web.ActivityPub.Pipeline
33 alias Pleroma.Web.ActivityPub.Utils
34 alias Pleroma.Web.CommonAPI
35 alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
36 alias Pleroma.Web.Endpoint
37 alias Pleroma.Web.OAuth
38 alias Pleroma.Web.RelMe
39 alias Pleroma.Workers.BackgroundWorker
43 @type t :: %__MODULE__{}
44 @type account_status ::
47 | :password_reset_pending
48 | :confirmation_pending
50 @primary_key {:id, FlakeId.Ecto.CompatType, autogenerate: true}
52 # credo:disable-for-next-line Credo.Check.Readability.MaxLineLength
53 @email_regex ~r/^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/
55 @strict_local_nickname_regex ~r/^[a-zA-Z\d]+$/
56 @extended_local_nickname_regex ~r/^[a-zA-Z\d_-]+$/
58 # AP ID user relationships (blocks, mutes etc.)
59 # Format: [rel_type: [outgoing_rel: :outgoing_rel_target, incoming_rel: :incoming_rel_source]]
60 @user_relationships_config [
62 blocker_blocks: :blocked_users,
63 blockee_blocks: :blocker_users
66 muter_mutes: :muted_users,
67 mutee_mutes: :muter_users
70 reblog_muter_mutes: :reblog_muted_users,
71 reblog_mutee_mutes: :reblog_muter_users
74 notification_muter_mutes: :notification_muted_users,
75 notification_mutee_mutes: :notification_muter_users
77 # Note: `inverse_subscription` relationship is inverse: subscriber acts as relationship target
78 inverse_subscription: [
79 subscribee_subscriptions: :subscriber_users,
80 subscriber_subscriptions: :subscribee_users
84 @cachex Pleroma.Config.get([:cachex, :provider], Cachex)
87 field(:bio, :string, default: "")
88 field(:raw_bio, :string)
89 field(:email, :string)
91 field(:nickname, :string)
92 field(:password_hash, :string)
93 field(:password, :string, virtual: true)
94 field(:password_confirmation, :string, virtual: true)
96 field(:public_key, :string)
97 field(:ap_id, :string)
98 field(:avatar, :map, default: %{})
99 field(:local, :boolean, default: true)
100 field(:follower_address, :string)
101 field(:following_address, :string)
102 field(:featured_address, :string)
103 field(:search_rank, :float, virtual: true)
104 field(:search_type, :integer, virtual: true)
105 field(:tags, {:array, :string}, default: [])
106 field(:last_refreshed_at, :naive_datetime_usec)
107 field(:last_digest_emailed_at, :naive_datetime)
108 field(:banner, :map, default: %{})
109 field(:background, :map, default: %{})
110 field(:note_count, :integer, default: 0)
111 field(:follower_count, :integer, default: 0)
112 field(:following_count, :integer, default: 0)
113 field(:is_locked, :boolean, default: false)
114 field(:is_confirmed, :boolean, default: true)
115 field(:password_reset_pending, :boolean, default: false)
116 field(:is_approved, :boolean, default: true)
117 field(:registration_reason, :string, default: nil)
118 field(:confirmation_token, :string, default: nil)
119 field(:default_scope, :string, default: "public")
120 field(:domain_blocks, {:array, :string}, default: [])
121 field(:is_active, :boolean, default: true)
122 field(:no_rich_text, :boolean, default: false)
123 field(:ap_enabled, :boolean, default: false)
124 field(:is_moderator, :boolean, default: false)
125 field(:is_admin, :boolean, default: false)
126 field(:show_role, :boolean, default: true)
127 field(:uri, ObjectValidators.Uri, default: nil)
128 field(:hide_followers_count, :boolean, default: false)
129 field(:hide_follows_count, :boolean, default: false)
130 field(:hide_followers, :boolean, default: false)
131 field(:hide_follows, :boolean, default: false)
132 field(:hide_favorites, :boolean, default: true)
133 field(: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, ObjectValidators.ObjectID}, default: [])
145 field(:inbox, :string)
146 field(:shared_inbox, :string)
147 field(:accepts_chat_messages, :boolean, default: nil)
148 field(:last_active_at, :naive_datetime)
149 field(:disclose_client, :boolean, default: true)
150 field(:pinned_objects, :map, default: %{})
153 :notification_settings,
154 Pleroma.User.NotificationSetting,
158 has_many(:notifications, Notification)
159 has_many(:registrations, Registration)
160 has_many(:deliveries, Delivery)
162 has_many(:outgoing_relationships, UserRelationship, foreign_key: :source_id)
163 has_many(:incoming_relationships, UserRelationship, foreign_key: :target_id)
165 for {relationship_type,
167 {outgoing_relation, outgoing_relation_target},
168 {incoming_relation, incoming_relation_source}
169 ]} <- @user_relationships_config do
170 # Definitions of `has_many` relations: :blocker_blocks, :muter_mutes, :reblog_muter_mutes,
171 # :notification_muter_mutes, :subscribee_subscriptions
172 has_many(outgoing_relation, UserRelationship,
173 foreign_key: :source_id,
174 where: [relationship_type: relationship_type]
177 # Definitions of `has_many` relations: :blockee_blocks, :mutee_mutes, :reblog_mutee_mutes,
178 # :notification_mutee_mutes, :subscriber_subscriptions
179 has_many(incoming_relation, UserRelationship,
180 foreign_key: :target_id,
181 where: [relationship_type: relationship_type]
184 # Definitions of `has_many` relations: :blocked_users, :muted_users, :reblog_muted_users,
185 # :notification_muted_users, :subscriber_users
186 has_many(outgoing_relation_target, through: [outgoing_relation, :target])
188 # Definitions of `has_many` relations: :blocker_users, :muter_users, :reblog_muter_users,
189 # :notification_muter_users, :subscribee_users
190 has_many(incoming_relation_source, through: [incoming_relation, :source])
193 # `:blocks` is deprecated (replaced with `blocked_users` relation)
194 field(:blocks, {:array, :string}, default: [])
195 # `:mutes` is deprecated (replaced with `muted_users` relation)
196 field(:mutes, {:array, :string}, default: [])
197 # `:muted_reblogs` is deprecated (replaced with `reblog_muted_users` relation)
198 field(:muted_reblogs, {:array, :string}, default: [])
199 # `:muted_notifications` is deprecated (replaced with `notification_muted_users` relation)
200 field(:muted_notifications, {:array, :string}, default: [])
201 # `:subscribers` is deprecated (replaced with `subscriber_users` relation)
202 field(:subscribers, {:array, :string}, default: [])
205 :multi_factor_authentication_settings,
213 for {_relationship_type, [{_outgoing_relation, outgoing_relation_target}, _]} <-
214 @user_relationships_config do
215 # `def blocked_users_relation/2`, `def muted_users_relation/2`,
216 # `def reblog_muted_users_relation/2`, `def notification_muted_users/2`,
217 # `def subscriber_users/2`
218 def unquote(:"#{outgoing_relation_target}_relation")(user, restrict_deactivated? \\ false) do
219 target_users_query = assoc(user, unquote(outgoing_relation_target))
221 if restrict_deactivated? do
223 |> User.Query.build(%{deactivated: false})
229 # `def blocked_users/2`, `def muted_users/2`, `def reblog_muted_users/2`,
230 # `def notification_muted_users/2`, `def subscriber_users/2`
231 def unquote(outgoing_relation_target)(user, restrict_deactivated? \\ false) do
233 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
235 restrict_deactivated?
240 # `def blocked_users_ap_ids/2`, `def muted_users_ap_ids/2`, `def reblog_muted_users_ap_ids/2`,
241 # `def notification_muted_users_ap_ids/2`, `def subscriber_users_ap_ids/2`
242 def unquote(:"#{outgoing_relation_target}_ap_ids")(user, restrict_deactivated? \\ false) do
244 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
246 restrict_deactivated?
248 |> select([u], u.ap_id)
253 def cached_blocked_users_ap_ids(user) do
254 @cachex.fetch!(:user_cache, "blocked_users_ap_ids:#{user.ap_id}", fn _ ->
255 blocked_users_ap_ids(user)
259 def cached_muted_users_ap_ids(user) do
260 @cachex.fetch!(:user_cache, "muted_users_ap_ids:#{user.ap_id}", fn _ ->
261 muted_users_ap_ids(user)
265 defdelegate following_count(user), to: FollowingRelationship
266 defdelegate following(user), to: FollowingRelationship
267 defdelegate following?(follower, followed), to: FollowingRelationship
268 defdelegate following_ap_ids(user), to: FollowingRelationship
269 defdelegate get_follow_requests(user), to: FollowingRelationship
270 defdelegate search(query, opts \\ []), to: User.Search
273 Dumps Flake Id to SQL-compatible format (16-byte UUID).
274 E.g. "9pQtDGXuq4p3VlcJEm" -> <<0, 0, 1, 110, 179, 218, 42, 92, 213, 41, 44, 227, 95, 213, 0, 0>>
276 def binary_id(source_id) when is_binary(source_id) do
277 with {:ok, dumped_id} <- FlakeId.Ecto.CompatType.dump(source_id) do
284 def binary_id(source_ids) when is_list(source_ids) do
285 Enum.map(source_ids, &binary_id/1)
288 def binary_id(%User{} = user), do: binary_id(user.id)
290 @doc "Returns status account"
291 @spec account_status(User.t()) :: account_status()
292 def account_status(%User{is_active: false}), do: :deactivated
293 def account_status(%User{password_reset_pending: true}), do: :password_reset_pending
294 def account_status(%User{local: true, is_approved: false}), do: :approval_pending
295 def account_status(%User{local: true, is_confirmed: false}), do: :confirmation_pending
296 def account_status(%User{}), do: :active
298 @spec visible_for(User.t(), User.t() | nil) ::
301 | :restricted_unauthenticated
303 | :confirmation_pending
304 def visible_for(user, for_user \\ nil)
306 def visible_for(%User{invisible: true}, _), do: :invisible
308 def visible_for(%User{id: user_id}, %User{id: user_id}), do: :visible
310 def visible_for(%User{} = user, nil) do
311 if restrict_unauthenticated?(user) do
312 :restrict_unauthenticated
314 visible_account_status(user)
318 def visible_for(%User{} = user, for_user) do
319 if superuser?(for_user) do
322 visible_account_status(user)
326 def visible_for(_, _), do: :invisible
328 defp restrict_unauthenticated?(%User{local: true}) do
329 Config.restrict_unauthenticated_access?(:profiles, :local)
332 defp restrict_unauthenticated?(%User{local: _}) do
333 Config.restrict_unauthenticated_access?(:profiles, :remote)
336 defp visible_account_status(user) do
337 status = account_status(user)
339 if status in [:active, :password_reset_pending] do
346 @spec superuser?(User.t()) :: boolean()
347 def superuser?(%User{local: true, is_admin: true}), do: true
348 def superuser?(%User{local: true, is_moderator: true}), do: true
349 def superuser?(_), do: false
351 @spec invisible?(User.t()) :: boolean()
352 def invisible?(%User{invisible: true}), do: true
353 def invisible?(_), do: false
355 def avatar_url(user, options \\ []) do
357 %{"url" => [%{"href" => href} | _]} ->
361 unless options[:no_default] do
362 Config.get([:assets, :default_user_avatar], "#{Endpoint.url()}/images/avi.png")
367 def banner_url(user, options \\ []) do
369 %{"url" => [%{"href" => href} | _]} -> href
370 _ -> !options[:no_default] && "#{Endpoint.url()}/images/banner.png"
374 # Should probably be renamed or removed
375 @spec ap_id(User.t()) :: String.t()
376 def ap_id(%User{nickname: nickname}), do: "#{Endpoint.url()}/users/#{nickname}"
378 @spec ap_followers(User.t()) :: String.t()
379 def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
380 def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"
382 @spec ap_following(User.t()) :: String.t()
383 def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
384 def ap_following(%User{} = user), do: "#{ap_id(user)}/following"
386 @spec ap_featured_collection(User.t()) :: String.t()
387 def ap_featured_collection(%User{featured_address: fa}) when is_binary(fa), do: fa
389 def ap_featured_collection(%User{} = user), do: "#{ap_id(user)}/collections/featured"
391 defp truncate_fields_param(params) do
392 if Map.has_key?(params, :fields) do
393 Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
399 defp truncate_if_exists(params, key, max_length) do
400 if Map.has_key?(params, key) and is_binary(params[key]) do
401 {value, _chopped} = String.split_at(params[key], max_length)
402 Map.put(params, key, value)
408 defp fix_follower_address(%{follower_address: _, following_address: _} = params), do: params
410 defp fix_follower_address(%{nickname: nickname} = params),
411 do: Map.put(params, :follower_address, ap_followers(%User{nickname: nickname}))
413 defp fix_follower_address(params), do: params
415 def remote_user_changeset(struct \\ %User{local: false}, params) do
416 bio_limit = Config.get([:instance, :user_bio_length], 5000)
417 name_limit = Config.get([:instance, :user_name_length], 100)
420 case params[:name] do
421 name when is_binary(name) and byte_size(name) > 0 -> name
422 _ -> params[:nickname]
427 |> Map.put(:name, name)
428 |> Map.put_new(:last_refreshed_at, NaiveDateTime.utc_now())
429 |> truncate_if_exists(:name, name_limit)
430 |> truncate_if_exists(:bio, bio_limit)
431 |> truncate_fields_param()
432 |> fix_follower_address()
456 :hide_followers_count,
465 :accepts_chat_messages,
469 |> cast(params, [:name], empty_values: [])
470 |> validate_required([:ap_id])
471 |> validate_required([:name], trim: false)
472 |> unique_constraint(:nickname)
473 |> validate_format(:nickname, @email_regex)
474 |> validate_length(:bio, max: bio_limit)
475 |> validate_length(:name, max: name_limit)
476 |> validate_fields(true)
477 |> validate_non_local()
480 defp validate_non_local(cng) do
481 local? = get_field(cng, :local)
485 |> add_error(:local, "User is local, can't update with this changeset.")
491 def update_changeset(struct, params \\ %{}) do
492 bio_limit = Config.get([:instance, :user_bio_length], 5000)
493 name_limit = Config.get([:instance, :user_name_length], 100)
513 :hide_followers_count,
516 :allow_following_move,
520 :skip_thread_containment,
523 :pleroma_settings_store,
526 :accepts_chat_messages,
530 |> unique_constraint(:nickname)
531 |> validate_format(:nickname, local_nickname_regex())
532 |> validate_length(:bio, max: bio_limit)
533 |> validate_length(:name, min: 1, max: name_limit)
534 |> validate_inclusion(:actor_type, ["Person", "Service"])
537 |> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
538 |> put_change_if_present(:avatar, &put_upload(&1, :avatar))
539 |> put_change_if_present(:banner, &put_upload(&1, :banner))
540 |> put_change_if_present(:background, &put_upload(&1, :background))
541 |> put_change_if_present(
542 :pleroma_settings_store,
543 &{:ok, Map.merge(struct.pleroma_settings_store, &1)}
545 |> validate_fields(false)
548 defp put_fields(changeset) do
549 if raw_fields = get_change(changeset, :raw_fields) do
552 |> Enum.filter(fn %{"name" => n} -> n != "" end)
556 |> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)
559 |> put_change(:raw_fields, raw_fields)
560 |> put_change(:fields, fields)
566 defp parse_fields(value) do
568 |> Formatter.linkify(mentions_format: :full)
572 defp put_emoji(changeset) do
573 emojified_fields = [:bio, :name, :raw_fields]
575 if Enum.any?(changeset.changes, fn {k, _} -> k in emojified_fields end) do
576 bio = Emoji.Formatter.get_emoji_map(get_field(changeset, :bio))
577 name = Emoji.Formatter.get_emoji_map(get_field(changeset, :name))
579 emoji = Map.merge(bio, name)
583 |> get_field(:raw_fields)
584 |> Enum.reduce(emoji, fn x, acc ->
585 Map.merge(acc, Emoji.Formatter.get_emoji_map(x["name"] <> x["value"]))
588 put_change(changeset, :emoji, emoji)
594 defp put_change_if_present(changeset, map_field, value_function) do
595 with {:ok, value} <- fetch_change(changeset, map_field),
596 {:ok, new_value} <- value_function.(value) do
597 put_change(changeset, map_field, new_value)
603 defp put_upload(value, type) do
604 with %Plug.Upload{} <- value,
605 {:ok, object} <- ActivityPub.upload(value, type: type) do
610 def update_as_admin_changeset(struct, params) do
612 |> update_changeset(params)
613 |> cast(params, [:email])
614 |> delete_change(:also_known_as)
615 |> unique_constraint(:email)
616 |> validate_format(:email, @email_regex)
617 |> validate_inclusion(:actor_type, ["Person", "Service"])
620 @spec update_as_admin(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
621 def update_as_admin(user, params) do
622 params = Map.put(params, "password_confirmation", params["password"])
623 changeset = update_as_admin_changeset(user, params)
625 if params["password"] do
626 reset_password(user, changeset, params)
628 User.update_and_set_cache(changeset)
632 def password_update_changeset(struct, params) do
634 |> cast(params, [:password, :password_confirmation])
635 |> validate_required([:password, :password_confirmation])
636 |> validate_confirmation(:password)
637 |> put_password_hash()
638 |> put_change(:password_reset_pending, false)
641 @spec reset_password(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
642 def reset_password(%User{} = user, params) do
643 reset_password(user, user, params)
646 def reset_password(%User{id: user_id} = user, struct, params) do
649 |> Multi.update(:user, password_update_changeset(struct, params))
650 |> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
651 |> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))
653 case Repo.transaction(multi) do
654 {:ok, %{user: user} = _} -> set_cache(user)
655 {:error, _, changeset, _} -> {:error, changeset}
659 def update_password_reset_pending(user, value) do
662 |> put_change(:password_reset_pending, value)
663 |> update_and_set_cache()
666 def force_password_reset_async(user) do
667 BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
670 @spec force_password_reset(User.t()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
671 def force_password_reset(user), do: update_password_reset_pending(user, true)
673 # Used to auto-register LDAP accounts which won't have a password hash stored locally
674 def register_changeset_ldap(struct, params = %{password: password})
675 when is_nil(password) do
676 params = Map.put_new(params, :accepts_chat_messages, true)
679 if Map.has_key?(params, :email) do
680 Map.put_new(params, :email, params[:email])
690 :accepts_chat_messages
692 |> validate_required([:name, :nickname])
693 |> unique_constraint(:nickname)
694 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
695 |> validate_format(:nickname, local_nickname_regex())
697 |> unique_constraint(:ap_id)
698 |> put_following_and_follower_and_featured_address()
701 def register_changeset(struct, params \\ %{}, opts \\ []) do
702 bio_limit = Config.get([:instance, :user_bio_length], 5000)
703 name_limit = Config.get([:instance, :user_name_length], 100)
704 reason_limit = Config.get([:instance, :registration_reason_length], 500)
705 params = Map.put_new(params, :accepts_chat_messages, true)
708 if is_nil(opts[:confirmed]) do
709 !Config.get([:instance, :account_activation_required])
715 if is_nil(opts[:approved]) do
716 !Config.get([:instance, :account_approval_required])
722 |> confirmation_changeset(set_confirmation: confirmed?)
723 |> approval_changeset(set_approval: approved?)
731 :password_confirmation,
733 :accepts_chat_messages,
736 |> validate_required([:name, :nickname, :password, :password_confirmation])
737 |> validate_confirmation(:password)
738 |> unique_constraint(:email)
739 |> validate_format(:email, @email_regex)
740 |> validate_change(:email, fn :email, email ->
742 Config.get([User, :email_blacklist])
743 |> Enum.all?(fn blacklisted_domain ->
744 !String.ends_with?(email, ["@" <> blacklisted_domain, "." <> blacklisted_domain])
747 if valid?, do: [], else: [email: "Invalid email"]
749 |> unique_constraint(:nickname)
750 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
751 |> validate_format(:nickname, local_nickname_regex())
752 |> validate_length(:bio, max: bio_limit)
753 |> validate_length(:name, min: 1, max: name_limit)
754 |> validate_length(:registration_reason, max: reason_limit)
755 |> maybe_validate_required_email(opts[:external])
758 |> unique_constraint(:ap_id)
759 |> put_following_and_follower_and_featured_address()
762 def maybe_validate_required_email(changeset, true), do: changeset
764 def maybe_validate_required_email(changeset, _) do
765 if Config.get([:instance, :account_activation_required]) do
766 validate_required(changeset, [:email])
772 defp put_ap_id(changeset) do
773 ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
774 put_change(changeset, :ap_id, ap_id)
777 defp put_following_and_follower_and_featured_address(changeset) do
778 user = %User{nickname: get_field(changeset, :nickname)}
779 followers = ap_followers(user)
780 following = ap_following(user)
781 featured = ap_featured_collection(user)
784 |> put_change(:follower_address, followers)
785 |> put_change(:following_address, following)
786 |> put_change(:featured_address, featured)
789 defp autofollow_users(user) do
790 candidates = Config.get([:instance, :autofollowed_nicknames])
793 User.Query.build(%{nickname: candidates, local: true, is_active: true})
796 follow_all(user, autofollowed_users)
799 defp autofollowing_users(user) do
800 candidates = Config.get([:instance, :autofollowing_nicknames])
802 User.Query.build(%{nickname: candidates, local: true, deactivated: false})
804 |> Enum.each(&follow(&1, user, :follow_accept))
809 @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
810 def register(%Ecto.Changeset{} = changeset) do
811 with {:ok, user} <- Repo.insert(changeset) do
812 post_register_action(user)
816 def post_register_action(%User{is_confirmed: false} = user) do
817 with {:ok, _} <- maybe_send_confirmation_email(user) do
822 def post_register_action(%User{is_approved: false} = user) do
823 with {:ok, _} <- send_user_approval_email(user),
824 {:ok, _} <- send_admin_approval_emails(user) do
829 def post_register_action(%User{is_approved: true, is_confirmed: true} = user) do
830 with {:ok, user} <- autofollow_users(user),
831 {:ok, _} <- autofollowing_users(user),
832 {:ok, user} <- set_cache(user),
833 {:ok, _} <- maybe_send_registration_email(user),
834 {:ok, _} <- maybe_send_welcome_email(user),
835 {:ok, _} <- maybe_send_welcome_message(user),
836 {:ok, _} <- maybe_send_welcome_chat_message(user) do
841 defp send_user_approval_email(user) do
843 |> Pleroma.Emails.UserEmail.approval_pending_email()
844 |> Pleroma.Emails.Mailer.deliver_async()
849 defp send_admin_approval_emails(user) do
851 |> Enum.filter(fn user -> not is_nil(user.email) end)
852 |> Enum.each(fn superuser ->
854 |> Pleroma.Emails.AdminEmail.new_unapproved_registration(user)
855 |> Pleroma.Emails.Mailer.deliver_async()
861 defp maybe_send_welcome_message(user) do
862 if User.WelcomeMessage.enabled?() do
863 User.WelcomeMessage.post_message(user)
870 defp maybe_send_welcome_chat_message(user) do
871 if User.WelcomeChatMessage.enabled?() do
872 User.WelcomeChatMessage.post_message(user)
879 defp maybe_send_welcome_email(%User{email: email} = user) when is_binary(email) do
880 if User.WelcomeEmail.enabled?() do
881 User.WelcomeEmail.send_email(user)
888 defp maybe_send_welcome_email(_), do: {:ok, :noop}
890 @spec maybe_send_confirmation_email(User.t()) :: {:ok, :enqueued | :noop}
891 def maybe_send_confirmation_email(%User{is_confirmed: false, email: email} = user)
892 when is_binary(email) do
893 if Config.get([:instance, :account_activation_required]) do
894 send_confirmation_email(user)
901 def maybe_send_confirmation_email(_), do: {:ok, :noop}
903 @spec send_confirmation_email(Uset.t()) :: User.t()
904 def send_confirmation_email(%User{} = user) do
906 |> Pleroma.Emails.UserEmail.account_confirmation_email()
907 |> Pleroma.Emails.Mailer.deliver_async()
912 @spec maybe_send_registration_email(User.t()) :: {:ok, :enqueued | :noop}
913 defp maybe_send_registration_email(%User{email: email} = user) when is_binary(email) do
914 with false <- User.WelcomeEmail.enabled?(),
915 false <- Config.get([:instance, :account_activation_required], false),
916 false <- Config.get([:instance, :account_approval_required], false) do
918 |> Pleroma.Emails.UserEmail.successful_registration_email()
919 |> Pleroma.Emails.Mailer.deliver_async()
928 defp maybe_send_registration_email(_), do: {:ok, :noop}
930 def needs_update?(%User{local: true}), do: false
932 def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
934 def needs_update?(%User{local: false} = user) do
935 NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
938 def needs_update?(_), do: true
940 @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
942 # "Locked" (self-locked) users demand explicit authorization of follow requests
943 def maybe_direct_follow(%User{} = follower, %User{local: true, is_locked: true} = followed) do
944 follow(follower, followed, :follow_pending)
947 def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
948 follow(follower, followed)
951 def maybe_direct_follow(%User{} = follower, %User{} = followed) do
952 if not ap_enabled?(followed) do
953 follow(follower, followed)
955 {:ok, follower, followed}
959 @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
960 @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
961 def follow_all(follower, followeds) do
963 |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
964 |> Enum.each(&follow(follower, &1, :follow_accept))
969 def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
970 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
973 not followed.is_active ->
974 {:error, "Could not follow user: #{followed.nickname} is deactivated."}
976 deny_follow_blocked and blocks?(followed, follower) ->
977 {:error, "Could not follow user: #{followed.nickname} blocked you."}
980 FollowingRelationship.follow(follower, followed, state)
984 def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
985 {:error, "Not subscribed!"}
988 @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
989 def unfollow(%User{} = follower, %User{} = followed) do
990 case do_unfollow(follower, followed) do
991 {:ok, follower, followed} ->
992 {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
999 @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
1000 defp do_unfollow(%User{} = follower, %User{} = followed) do
1001 case get_follow_state(follower, followed) do
1002 state when state in [:follow_pending, :follow_accept] ->
1003 FollowingRelationship.unfollow(follower, followed)
1006 {:error, "Not subscribed!"}
1010 @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
1011 def get_follow_state(%User{} = follower, %User{} = following) do
1012 following_relationship = FollowingRelationship.get(follower, following)
1013 get_follow_state(follower, following, following_relationship)
1016 def get_follow_state(
1018 %User{} = following,
1019 following_relationship
1021 case {following_relationship, following.local} do
1023 case Utils.fetch_latest_follow(follower, following) do
1024 %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
1025 FollowingRelationship.state_to_enum(state)
1031 {%{state: state}, _} ->
1039 def locked?(%User{} = user) do
1040 user.is_locked || false
1043 def get_by_id(id) do
1044 Repo.get_by(User, id: id)
1047 def get_by_ap_id(ap_id) do
1048 Repo.get_by(User, ap_id: ap_id)
1051 def get_all_by_ap_id(ap_ids) do
1052 from(u in __MODULE__,
1053 where: u.ap_id in ^ap_ids
1058 def get_all_by_ids(ids) do
1059 from(u in __MODULE__, where: u.id in ^ids)
1063 # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
1064 # of the ap_id and the domain and tries to get that user
1065 def get_by_guessed_nickname(ap_id) do
1066 domain = URI.parse(ap_id).host
1067 name = List.last(String.split(ap_id, "/"))
1068 nickname = "#{name}@#{domain}"
1070 get_cached_by_nickname(nickname)
1073 def set_cache({:ok, user}), do: set_cache(user)
1074 def set_cache({:error, err}), do: {:error, err}
1076 def set_cache(%User{} = user) do
1077 @cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1078 @cachex.put(:user_cache, "nickname:#{user.nickname}", user)
1079 @cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
1083 def update_and_set_cache(struct, params) do
1085 |> update_changeset(params)
1086 |> update_and_set_cache()
1089 def update_and_set_cache(changeset) do
1090 with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
1091 Pleroma.Elasticsearch.maybe_put_into_elasticsearch(user)
1096 def get_user_friends_ap_ids(user) do
1097 from(u in User.get_friends_query(user), select: u.ap_id)
1101 @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
1102 def get_cached_user_friends_ap_ids(user) do
1103 @cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
1104 get_user_friends_ap_ids(user)
1108 def invalidate_cache(user) do
1109 @cachex.del(:user_cache, "ap_id:#{user.ap_id}")
1110 @cachex.del(:user_cache, "nickname:#{user.nickname}")
1111 @cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
1112 @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
1113 @cachex.del(:user_cache, "muted_users_ap_ids:#{user.ap_id}")
1116 @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
1117 def get_cached_by_ap_id(ap_id) do
1118 key = "ap_id:#{ap_id}"
1120 with {:ok, nil} <- @cachex.get(:user_cache, key),
1121 user when not is_nil(user) <- get_by_ap_id(ap_id),
1122 {:ok, true} <- @cachex.put(:user_cache, key, user) do
1130 def get_cached_by_id(id) do
1134 @cachex.fetch!(:user_cache, key, fn _ ->
1135 user = get_by_id(id)
1138 @cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1139 {:commit, user.ap_id}
1145 get_cached_by_ap_id(ap_id)
1148 def get_cached_by_nickname(nickname) do
1149 key = "nickname:#{nickname}"
1151 @cachex.fetch!(:user_cache, key, fn _ ->
1152 case get_or_fetch_by_nickname(nickname) do
1153 {:ok, user} -> {:commit, user}
1154 {:error, _error} -> {:ignore, nil}
1159 def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
1160 restrict_to_local = Config.get([:instance, :limit_to_local_content])
1163 is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
1164 get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
1166 restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
1167 get_cached_by_nickname(nickname_or_id)
1169 restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
1170 get_cached_by_nickname(nickname_or_id)
1177 @spec get_by_nickname(String.t()) :: User.t() | nil
1178 def get_by_nickname(nickname) do
1179 Repo.get_by(User, nickname: nickname) ||
1180 if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
1181 Repo.get_by(User, nickname: local_nickname(nickname))
1185 def get_by_email(email), do: Repo.get_by(User, email: email)
1187 def get_by_nickname_or_email(nickname_or_email) do
1188 get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
1191 def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
1193 def get_or_fetch_by_nickname(nickname) do
1194 with %User{} = user <- get_by_nickname(nickname) do
1198 with [_nick, _domain] <- String.split(nickname, "@"),
1199 {:ok, user} <- fetch_by_nickname(nickname) do
1202 _e -> {:error, "not found " <> nickname}
1207 @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1208 def get_followers_query(%User{} = user, nil) do
1209 User.Query.build(%{followers: user, is_active: true})
1212 def get_followers_query(%User{} = user, page) do
1214 |> get_followers_query(nil)
1215 |> User.Query.paginate(page, 20)
1218 @spec get_followers_query(User.t()) :: Ecto.Query.t()
1219 def get_followers_query(%User{} = user), do: get_followers_query(user, nil)
1221 @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1222 def get_followers(%User{} = user, page \\ nil) do
1224 |> get_followers_query(page)
1228 @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1229 def get_external_followers(%User{} = user, page \\ nil) do
1231 |> get_followers_query(page)
1232 |> User.Query.build(%{external: true})
1236 def get_followers_ids(%User{} = user, page \\ nil) do
1238 |> get_followers_query(page)
1239 |> select([u], u.id)
1243 @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1244 def get_friends_query(%User{} = user, nil) do
1245 User.Query.build(%{friends: user, deactivated: false})
1248 def get_friends_query(%User{} = user, page) do
1250 |> get_friends_query(nil)
1251 |> User.Query.paginate(page, 20)
1254 @spec get_friends_query(User.t()) :: Ecto.Query.t()
1255 def get_friends_query(%User{} = user), do: get_friends_query(user, nil)
1257 def get_friends(%User{} = user, page \\ nil) do
1259 |> get_friends_query(page)
1263 def get_friends_ap_ids(%User{} = user) do
1265 |> get_friends_query(nil)
1266 |> select([u], u.ap_id)
1270 def get_friends_ids(%User{} = user, page \\ nil) do
1272 |> get_friends_query(page)
1273 |> select([u], u.id)
1277 def increase_note_count(%User{} = user) do
1279 |> where(id: ^user.id)
1280 |> update([u], inc: [note_count: 1])
1282 |> Repo.update_all([])
1284 {1, [user]} -> set_cache(user)
1289 def decrease_note_count(%User{} = user) do
1291 |> where(id: ^user.id)
1294 note_count: fragment("greatest(0, note_count - 1)")
1298 |> Repo.update_all([])
1300 {1, [user]} -> set_cache(user)
1305 def update_note_count(%User{} = user, note_count \\ nil) do
1310 where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1316 |> cast(%{note_count: note_count}, [:note_count])
1317 |> update_and_set_cache()
1320 @spec maybe_fetch_follow_information(User.t()) :: User.t()
1321 def maybe_fetch_follow_information(user) do
1322 with {:ok, user} <- fetch_follow_information(user) do
1326 Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1332 def fetch_follow_information(user) do
1333 with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1335 |> follow_information_changeset(info)
1336 |> update_and_set_cache()
1340 defp follow_information_changeset(user, params) do
1347 :hide_followers_count,
1352 @spec update_follower_count(User.t()) :: {:ok, User.t()}
1353 def update_follower_count(%User{} = user) do
1354 if user.local or !Config.get([:instance, :external_user_synchronization]) do
1355 follower_count = FollowingRelationship.follower_count(user)
1358 |> follow_information_changeset(%{follower_count: follower_count})
1359 |> update_and_set_cache
1361 {:ok, maybe_fetch_follow_information(user)}
1365 @spec update_following_count(User.t()) :: {:ok, User.t()}
1366 def update_following_count(%User{local: false} = user) do
1367 if Config.get([:instance, :external_user_synchronization]) do
1368 {:ok, maybe_fetch_follow_information(user)}
1374 def update_following_count(%User{local: true} = user) do
1375 following_count = FollowingRelationship.following_count(user)
1378 |> follow_information_changeset(%{following_count: following_count})
1379 |> update_and_set_cache()
1382 @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1383 def get_users_from_set(ap_ids, opts \\ []) do
1384 local_only = Keyword.get(opts, :local_only, true)
1385 criteria = %{ap_id: ap_ids, is_active: true}
1386 criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1388 User.Query.build(criteria)
1392 @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1393 def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1396 query = User.Query.build(%{recipients_from_activity: to, local: true, is_active: true})
1402 @spec mute(User.t(), User.t(), map()) ::
1403 {:ok, list(UserRelationship.t())} | {:error, String.t()}
1404 def mute(%User{} = muter, %User{} = mutee, params \\ %{}) do
1405 notifications? = Map.get(params, :notifications, true)
1406 expires_in = Map.get(params, :expires_in, 0)
1408 with {:ok, user_mute} <- UserRelationship.create_mute(muter, mutee),
1409 {:ok, user_notification_mute} <-
1410 (notifications? && UserRelationship.create_notification_mute(muter, mutee)) ||
1412 if expires_in > 0 do
1413 Pleroma.Workers.MuteExpireWorker.enqueue(
1415 %{"muter_id" => muter.id, "mutee_id" => mutee.id},
1416 schedule_in: expires_in
1420 @cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
1422 {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
1426 def unmute(%User{} = muter, %User{} = mutee) do
1427 with {:ok, user_mute} <- UserRelationship.delete_mute(muter, mutee),
1428 {:ok, user_notification_mute} <-
1429 UserRelationship.delete_notification_mute(muter, mutee) do
1430 @cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
1431 {:ok, [user_mute, user_notification_mute]}
1435 def unmute(muter_id, mutee_id) do
1436 with {:muter, %User{} = muter} <- {:muter, User.get_by_id(muter_id)},
1437 {:mutee, %User{} = mutee} <- {:mutee, User.get_by_id(mutee_id)} do
1438 unmute(muter, mutee)
1440 {who, result} = error ->
1442 "User.unmute/2 failed. #{who}: #{result}, muter_id: #{muter_id}, mutee_id: #{mutee_id}"
1449 def subscribe(%User{} = subscriber, %User{} = target) do
1450 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
1452 if blocks?(target, subscriber) and deny_follow_blocked do
1453 {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1455 # Note: the relationship is inverse: subscriber acts as relationship target
1456 UserRelationship.create_inverse_subscription(target, subscriber)
1460 def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1461 with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1462 subscribe(subscriber, subscribee)
1466 def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1467 # Note: the relationship is inverse: subscriber acts as relationship target
1468 UserRelationship.delete_inverse_subscription(target, unsubscriber)
1471 def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1472 with %User{} = user <- get_cached_by_ap_id(ap_id) do
1473 unsubscribe(unsubscriber, user)
1477 def block(%User{} = blocker, %User{} = blocked) do
1478 # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1480 if following?(blocker, blocked) do
1481 {:ok, blocker, _} = unfollow(blocker, blocked)
1487 # clear any requested follows as well
1489 case CommonAPI.reject_follow_request(blocked, blocker) do
1490 {:ok, %User{} = updated_blocked} -> updated_blocked
1494 unsubscribe(blocked, blocker)
1496 unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
1497 if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)
1499 {:ok, blocker} = update_follower_count(blocker)
1500 {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1501 add_to_block(blocker, blocked)
1504 # helper to handle the block given only an actor's AP id
1505 def block(%User{} = blocker, %{ap_id: ap_id}) do
1506 block(blocker, get_cached_by_ap_id(ap_id))
1509 def unblock(%User{} = blocker, %User{} = blocked) do
1510 remove_from_block(blocker, blocked)
1513 # helper to handle the block given only an actor's AP id
1514 def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1515 unblock(blocker, get_cached_by_ap_id(ap_id))
1518 def mutes?(nil, _), do: false
1519 def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1521 def mutes_user?(%User{} = user, %User{} = target) do
1522 UserRelationship.mute_exists?(user, target)
1525 @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1526 def muted_notifications?(nil, _), do: false
1528 def muted_notifications?(%User{} = user, %User{} = target),
1529 do: UserRelationship.notification_mute_exists?(user, target)
1531 def blocks?(nil, _), do: false
1533 def blocks?(%User{} = user, %User{} = target) do
1534 blocks_user?(user, target) ||
1535 (blocks_domain?(user, target) and not User.following?(user, target))
1538 def blocks_user?(%User{} = user, %User{} = target) do
1539 UserRelationship.block_exists?(user, target)
1542 def blocks_user?(_, _), do: false
1544 def blocks_domain?(%User{} = user, %User{} = target) do
1545 domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1546 %{host: host} = URI.parse(target.ap_id)
1547 Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1550 def blocks_domain?(_, _), do: false
1552 def subscribed_to?(%User{} = user, %User{} = target) do
1553 # Note: the relationship is inverse: subscriber acts as relationship target
1554 UserRelationship.inverse_subscription_exists?(target, user)
1557 def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1558 with %User{} = target <- get_cached_by_ap_id(ap_id) do
1559 subscribed_to?(user, target)
1564 Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1565 E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1567 @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1568 def outgoing_relationships_ap_ids(_user, []), do: %{}
1570 def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1572 def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1573 when is_list(relationship_types) do
1576 |> assoc(:outgoing_relationships)
1577 |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1578 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1579 |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1580 |> group_by([user_rel, u], user_rel.relationship_type)
1582 |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1587 fn rel_type -> {rel_type, db_result[rel_type] || []} end
1591 def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1593 def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1595 def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1597 def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1598 when is_list(relationship_types) do
1600 |> assoc(:incoming_relationships)
1601 |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1602 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1603 |> maybe_filter_on_ap_id(ap_ids)
1604 |> select([user_rel, u], u.ap_id)
1609 defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1610 where(query, [user_rel, u], u.ap_id in ^ap_ids)
1613 defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1615 def set_activation_async(user, status \\ true) do
1616 BackgroundWorker.enqueue("user_activation", %{"user_id" => user.id, "status" => status})
1619 @spec set_activation([User.t()], boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
1620 def set_activation(users, status) when is_list(users) do
1621 Repo.transaction(fn ->
1622 for user <- users, do: set_activation(user, status)
1626 @spec set_activation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
1627 def set_activation(%User{} = user, status) do
1628 with {:ok, user} <- set_activation_status(user, status) do
1631 |> Enum.filter(& &1.local)
1632 |> Enum.each(&set_cache(update_following_count(&1)))
1634 # Only update local user counts, remote will be update during the next pull.
1637 |> Enum.filter(& &1.local)
1638 |> Enum.each(&do_unfollow(user, &1))
1644 def approve(users) when is_list(users) do
1645 Repo.transaction(fn ->
1646 Enum.map(users, fn user ->
1647 with {:ok, user} <- approve(user), do: user
1652 def approve(%User{is_approved: false} = user) do
1653 with chg <- change(user, is_approved: true),
1654 {:ok, user} <- update_and_set_cache(chg) do
1655 post_register_action(user)
1660 def approve(%User{} = user), do: {:ok, user}
1662 def confirm(users) when is_list(users) do
1663 Repo.transaction(fn ->
1664 Enum.map(users, fn user ->
1665 with {:ok, user} <- confirm(user), do: user
1670 def confirm(%User{is_confirmed: false} = user) do
1671 with chg <- confirmation_changeset(user, set_confirmation: true),
1672 {:ok, user} <- update_and_set_cache(chg) do
1673 post_register_action(user)
1678 def confirm(%User{} = user), do: {:ok, user}
1680 def update_notification_settings(%User{} = user, settings) do
1682 |> cast(%{notification_settings: settings}, [])
1683 |> cast_embed(:notification_settings)
1684 |> validate_required([:notification_settings])
1685 |> update_and_set_cache()
1688 @spec purge_user_changeset(User.t()) :: Changeset.t()
1689 def purge_user_changeset(user) do
1690 # "Right to be forgotten"
1691 # https://gdpr.eu/right-to-be-forgotten/
1700 last_refreshed_at: nil,
1701 last_digest_emailed_at: nil,
1708 password_reset_pending: false,
1709 registration_reason: nil,
1710 confirmation_token: nil,
1714 is_moderator: false,
1718 pleroma_settings_store: %{},
1721 is_discoverable: false,
1725 # nickname: preserved
1729 # Purge doesn't delete the user from the database.
1730 # It just nulls all its fields and deactivates it.
1731 # See `User.purge_user_changeset/1` above.
1732 defp purge(%User{} = user) do
1734 |> purge_user_changeset()
1735 |> update_and_set_cache()
1738 def delete(users) when is_list(users) do
1739 for user <- users, do: delete(user)
1742 def delete(%User{} = user) do
1743 # Purge the user immediately
1745 BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1748 # *Actually* delete the user from the DB
1749 defp delete_from_db(%User{} = user) do
1750 invalidate_cache(user)
1754 # If the user never finalized their account, it's safe to delete them.
1755 defp maybe_delete_from_db(%User{local: true, is_confirmed: false} = user),
1756 do: delete_from_db(user)
1758 defp maybe_delete_from_db(%User{local: true, is_approved: false} = user),
1759 do: delete_from_db(user)
1761 defp maybe_delete_from_db(user), do: {:ok, user}
1763 def perform(:force_password_reset, user), do: force_password_reset(user)
1765 @spec perform(atom(), User.t()) :: {:ok, User.t()}
1766 def perform(:delete, %User{} = user) do
1767 # Purge the user again, in case perform/2 is called directly
1770 # Remove all relationships
1773 |> Enum.each(fn follower ->
1774 ActivityPub.unfollow(follower, user)
1775 unfollow(follower, user)
1780 |> Enum.each(fn followed ->
1781 ActivityPub.unfollow(user, followed)
1782 unfollow(user, followed)
1785 delete_user_activities(user)
1786 delete_notifications_from_user_activities(user)
1787 delete_outgoing_pending_follow_requests(user)
1789 maybe_delete_from_db(user)
1792 def perform(:set_activation_async, user, status), do: set_activation(user, status)
1794 @spec external_users_query() :: Ecto.Query.t()
1795 def external_users_query do
1803 @spec external_users(keyword()) :: [User.t()]
1804 def external_users(opts \\ []) do
1806 external_users_query()
1807 |> select([u], struct(u, [:id, :ap_id]))
1811 do: where(query, [u], u.id > ^opts[:max_id]),
1816 do: limit(query, ^opts[:limit]),
1822 def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1824 |> join(:inner, [n], activity in assoc(n, :activity))
1825 |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1826 |> Repo.delete_all()
1829 def delete_user_activities(%User{ap_id: ap_id} = user) do
1831 |> Activity.Queries.by_actor()
1832 |> Repo.chunk_stream(50, :batches)
1833 |> Stream.each(fn activities ->
1834 Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1839 defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1840 with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1841 {:ok, delete_data, _} <- Builder.delete(user, object) do
1842 Pipeline.common_pipeline(delete_data, local: user.local)
1844 {:find_object, nil} ->
1845 # We have the create activity, but not the object, it was probably pruned.
1846 # Insert a tombstone and try again
1847 with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1848 {:ok, _tombstone} <- Object.create(tombstone_data) do
1849 delete_activity(activity, user)
1853 Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1854 Logger.error("Error: #{inspect(e)}")
1858 defp delete_activity(%{data: %{"type" => type}} = activity, user)
1859 when type in ["Like", "Announce"] do
1860 {:ok, undo, _} = Builder.undo(user, activity)
1861 Pipeline.common_pipeline(undo, local: user.local)
1864 defp delete_activity(_activity, _user), do: "Doing nothing"
1866 defp delete_outgoing_pending_follow_requests(user) do
1868 |> FollowingRelationship.outgoing_pending_follow_requests_query()
1869 |> Repo.delete_all()
1872 def html_filter_policy(%User{no_rich_text: true}) do
1873 Pleroma.HTML.Scrubber.TwitterText
1876 def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])
1878 def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1880 def get_or_fetch_by_ap_id(ap_id) do
1881 cached_user = get_cached_by_ap_id(ap_id)
1883 maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)
1885 case {cached_user, maybe_fetched_user} do
1886 {_, {:ok, %User{} = user}} ->
1889 {%User{} = user, _} ->
1893 {:error, :not_found}
1898 Creates an internal service actor by URI if missing.
1899 Optionally takes nickname for addressing.
1901 @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1902 def get_or_create_service_actor_by_ap_id(uri, nickname) do
1904 case get_cached_by_ap_id(uri) do
1906 with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1907 Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1911 %User{invisible: false} = user ->
1921 @spec set_invisible(User.t()) :: {:ok, User.t()}
1922 defp set_invisible(user) do
1924 |> change(%{invisible: true})
1925 |> update_and_set_cache()
1928 @spec create_service_actor(String.t(), String.t()) ::
1929 {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1930 defp create_service_actor(uri, nickname) do
1936 follower_address: uri <> "/followers"
1939 |> unique_constraint(:nickname)
1944 def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1947 |> :public_key.pem_decode()
1949 |> :public_key.pem_entry_decode()
1954 def public_key(_), do: {:error, "key not found"}
1956 def get_public_key_for_ap_id(ap_id) do
1957 with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1958 {:ok, public_key} <- public_key(user) do
1965 def ap_enabled?(%User{local: true}), do: true
1966 def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1967 def ap_enabled?(_), do: false
1969 @doc "Gets or fetch a user by uri or nickname."
1970 @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1971 def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1972 def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1974 # wait a period of time and return newest version of the User structs
1975 # this is because we have synchronous follow APIs and need to simulate them
1976 # with an async handshake
1977 def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1978 with %User{} = a <- get_cached_by_id(a.id),
1979 %User{} = b <- get_cached_by_id(b.id) do
1986 def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1987 with :ok <- :timer.sleep(timeout),
1988 %User{} = a <- get_cached_by_id(a.id),
1989 %User{} = b <- get_cached_by_id(b.id) do
1996 def parse_bio(bio) when is_binary(bio) and bio != "" do
1998 |> CommonUtils.format_input("text/plain", mentions_format: :full)
2002 def parse_bio(_), do: ""
2004 def parse_bio(bio, user) when is_binary(bio) and bio != "" do
2005 # TODO: get profile URLs other than user.ap_id
2006 profile_urls = [user.ap_id]
2009 |> CommonUtils.format_input("text/plain",
2010 mentions_format: :full,
2011 rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
2016 def parse_bio(_, _), do: ""
2018 def tag(user_identifiers, tags) when is_list(user_identifiers) do
2019 Repo.transaction(fn ->
2020 for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
2024 def tag(nickname, tags) when is_binary(nickname),
2025 do: tag(get_by_nickname(nickname), tags)
2027 def tag(%User{} = user, tags),
2028 do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
2030 def untag(user_identifiers, tags) when is_list(user_identifiers) do
2031 Repo.transaction(fn ->
2032 for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
2036 def untag(nickname, tags) when is_binary(nickname),
2037 do: untag(get_by_nickname(nickname), tags)
2039 def untag(%User{} = user, tags),
2040 do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
2042 defp update_tags(%User{} = user, new_tags) do
2043 {:ok, updated_user} =
2045 |> change(%{tags: new_tags})
2046 |> update_and_set_cache()
2051 defp normalize_tags(tags) do
2054 |> Enum.map(&String.downcase/1)
2057 defp local_nickname_regex do
2058 if Config.get([:instance, :extended_nickname_format]) do
2059 @extended_local_nickname_regex
2061 @strict_local_nickname_regex
2065 def local_nickname(nickname_or_mention) do
2068 |> String.split("@")
2072 def full_nickname(%User{} = user) do
2073 if String.contains?(user.nickname, "@") do
2076 %{host: host} = URI.parse(user.ap_id)
2077 user.nickname <> "@" <> host
2081 def full_nickname(nickname_or_mention),
2082 do: String.trim_leading(nickname_or_mention, "@")
2084 def error_user(ap_id) do
2088 nickname: "erroruser@example.com",
2089 inserted_at: NaiveDateTime.utc_now()
2093 @spec all_superusers() :: [User.t()]
2094 def all_superusers do
2095 User.Query.build(%{super_users: true, local: true, is_active: true})
2099 def muting_reblogs?(%User{} = user, %User{} = target) do
2100 UserRelationship.reblog_mute_exists?(user, target)
2103 def showing_reblogs?(%User{} = user, %User{} = target) do
2104 not muting_reblogs?(user, target)
2108 The function returns a query to get users with no activity for given interval of days.
2109 Inactive users are those who didn't read any notification, or had any activity where
2110 the user is the activity's actor, during `inactivity_threshold` days.
2111 Deactivated users will not appear in this list.
2115 iex> Pleroma.User.list_inactive_users()
2118 @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
2119 def list_inactive_users_query(inactivity_threshold \\ 7) do
2120 negative_inactivity_threshold = -inactivity_threshold
2121 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2122 # Subqueries are not supported in `where` clauses, join gets too complicated.
2123 has_read_notifications =
2124 from(n in Pleroma.Notification,
2125 where: n.seen == true,
2127 having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
2130 |> Pleroma.Repo.all()
2132 from(u in Pleroma.User,
2133 left_join: a in Pleroma.Activity,
2134 on: u.ap_id == a.actor,
2135 where: not is_nil(u.nickname),
2136 where: u.is_active == ^true,
2137 where: u.id not in ^has_read_notifications,
2140 max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
2141 is_nil(max(a.inserted_at))
2146 Enable or disable email notifications for user
2150 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
2151 Pleroma.User{email_notifications: %{"digest" => true}}
2153 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
2154 Pleroma.User{email_notifications: %{"digest" => false}}
2156 @spec switch_email_notifications(t(), String.t(), boolean()) ::
2157 {:ok, t()} | {:error, Ecto.Changeset.t()}
2158 def switch_email_notifications(user, type, status) do
2159 User.update_email_notifications(user, %{type => status})
2163 Set `last_digest_emailed_at` value for the user to current time
2165 @spec touch_last_digest_emailed_at(t()) :: t()
2166 def touch_last_digest_emailed_at(user) do
2167 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2169 {:ok, updated_user} =
2171 |> change(%{last_digest_emailed_at: now})
2172 |> update_and_set_cache()
2177 @spec set_confirmation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
2178 def set_confirmation(%User{} = user, bool) do
2180 |> confirmation_changeset(set_confirmation: bool)
2181 |> update_and_set_cache()
2184 def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
2188 def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
2189 # use instance-default
2190 config = Config.get([:assets, :mascots])
2191 default_mascot = Config.get([:assets, :default_mascot])
2192 mascot = Keyword.get(config, default_mascot)
2195 "id" => "default-mascot",
2196 "url" => mascot[:url],
2197 "preview_url" => mascot[:url],
2199 "mime_type" => mascot[:mime_type]
2204 def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
2206 def ensure_keys_present(%User{} = user) do
2207 with {:ok, pem} <- Keys.generate_rsa_pem() do
2209 |> cast(%{keys: pem}, [:keys])
2210 |> validate_required([:keys])
2211 |> update_and_set_cache()
2215 def get_ap_ids_by_nicknames(nicknames) do
2217 where: u.nickname in ^nicknames,
2223 defp put_password_hash(
2224 %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2226 change(changeset, password_hash: Pleroma.Password.Pbkdf2.hash_pwd_salt(password))
2229 defp put_password_hash(changeset), do: changeset
2231 def is_internal_user?(%User{nickname: nil}), do: true
2232 def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2233 def is_internal_user?(_), do: false
2235 # A hack because user delete activities have a fake id for whatever reason
2236 # TODO: Get rid of this
2237 def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2239 def get_delivered_users_by_object_id(object_id) do
2241 inner_join: delivery in assoc(u, :deliveries),
2242 where: delivery.object_id == ^object_id
2247 def change_email(user, email) do
2249 |> cast(%{email: email}, [:email])
2250 |> maybe_validate_required_email(false)
2251 |> unique_constraint(:email)
2252 |> validate_format(:email, @email_regex)
2253 |> update_and_set_cache()
2256 # Internal function; public one is `deactivate/2`
2257 defp set_activation_status(user, status) do
2259 |> cast(%{is_active: status}, [:is_active])
2260 |> update_and_set_cache()
2263 def update_banner(user, banner) do
2265 |> cast(%{banner: banner}, [:banner])
2266 |> update_and_set_cache()
2269 def update_background(user, background) do
2271 |> cast(%{background: background}, [:background])
2272 |> update_and_set_cache()
2275 def validate_fields(changeset, remote? \\ false) do
2276 limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2277 limit = Config.get([:instance, limit_name], 0)
2280 |> validate_length(:fields, max: limit)
2281 |> validate_change(:fields, fn :fields, fields ->
2282 if Enum.all?(fields, &valid_field?/1) do
2290 defp valid_field?(%{"name" => name, "value" => value}) do
2291 name_limit = Config.get([:instance, :account_field_name_length], 255)
2292 value_limit = Config.get([:instance, :account_field_value_length], 255)
2294 is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2295 String.length(value) <= value_limit
2298 defp valid_field?(_), do: false
2300 defp truncate_field(%{"name" => name, "value" => value}) do
2302 String.split_at(name, Config.get([:instance, :account_field_name_length], 255))
2305 String.split_at(value, Config.get([:instance, :account_field_value_length], 255))
2307 %{"name" => name, "value" => value}
2310 def admin_api_update(user, params) do
2317 |> update_and_set_cache()
2320 @doc "Signs user out of all applications"
2321 def global_sign_out(user) do
2322 OAuth.Authorization.delete_user_authorizations(user)
2323 OAuth.Token.delete_user_tokens(user)
2326 def mascot_update(user, url) do
2328 |> cast(%{mascot: url}, [:mascot])
2329 |> validate_required([:mascot])
2330 |> update_and_set_cache()
2333 @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2334 def confirmation_changeset(user, set_confirmation: confirmed?) do
2339 confirmation_token: nil
2343 is_confirmed: false,
2344 confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2348 cast(user, params, [:is_confirmed, :confirmation_token])
2351 @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
2352 def approval_changeset(user, set_approval: approved?) do
2353 cast(user, %{is_approved: approved?}, [:is_approved])
2356 @spec add_pinned_object_id(User.t(), String.t()) :: {:ok, User.t()} | {:error, term()}
2357 def add_pinned_object_id(%User{} = user, object_id) do
2358 if !user.pinned_objects[object_id] do
2359 params = %{pinned_objects: Map.put(user.pinned_objects, object_id, NaiveDateTime.utc_now())}
2362 |> cast(params, [:pinned_objects])
2363 |> validate_change(:pinned_objects, fn :pinned_objects, pinned_objects ->
2364 max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2366 if Enum.count(pinned_objects) <= max_pinned_statuses do
2369 [pinned_objects: "You have already pinned the maximum number of statuses"]
2375 |> update_and_set_cache()
2378 @spec remove_pinned_object_id(User.t(), String.t()) :: {:ok, t()} | {:error, term()}
2379 def remove_pinned_object_id(%User{} = user, object_id) do
2382 %{pinned_objects: Map.delete(user.pinned_objects, object_id)},
2385 |> update_and_set_cache()
2388 def update_email_notifications(user, settings) do
2389 email_notifications =
2390 user.email_notifications
2391 |> Map.merge(settings)
2392 |> Map.take(["digest"])
2394 params = %{email_notifications: email_notifications}
2395 fields = [:email_notifications]
2398 |> cast(params, fields)
2399 |> validate_required(fields)
2400 |> update_and_set_cache()
2403 defp set_domain_blocks(user, domain_blocks) do
2404 params = %{domain_blocks: domain_blocks}
2407 |> cast(params, [:domain_blocks])
2408 |> validate_required([:domain_blocks])
2409 |> update_and_set_cache()
2412 def block_domain(user, domain_blocked) do
2413 set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2416 def unblock_domain(user, domain_blocked) do
2417 set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2420 @spec add_to_block(User.t(), User.t()) ::
2421 {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2422 defp add_to_block(%User{} = user, %User{} = blocked) do
2423 with {:ok, relationship} <- UserRelationship.create_block(user, blocked) do
2424 @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
2429 @spec add_to_block(User.t(), User.t()) ::
2430 {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2431 defp remove_from_block(%User{} = user, %User{} = blocked) do
2432 with {:ok, relationship} <- UserRelationship.delete_block(user, blocked) do
2433 @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
2438 def set_invisible(user, invisible) do
2439 params = %{invisible: invisible}
2442 |> cast(params, [:invisible])
2443 |> validate_required([:invisible])
2444 |> update_and_set_cache()
2447 def sanitize_html(%User{} = user) do
2448 sanitize_html(user, nil)
2451 # User data that mastodon isn't filtering (treated as plaintext):
2454 def sanitize_html(%User{} = user, filter) do
2456 Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2459 "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2464 |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2465 |> Map.put(:fields, fields)
2468 def get_host(%User{ap_id: ap_id} = _user) do
2469 URI.parse(ap_id).host
2472 def update_last_active_at(%__MODULE__{local: true} = user) do
2474 |> cast(%{last_active_at: NaiveDateTime.utc_now()}, [:last_active_at])
2475 |> update_and_set_cache()
2478 def active_user_count(days \\ 30) do
2479 active_after = Timex.shift(NaiveDateTime.utc_now(), days: -days)
2482 |> where([u], u.last_active_at >= ^active_after)
2483 |> where([u], u.local == true)
2484 |> Repo.aggregate(:count)