1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.User do
10 import Ecto, only: [assoc: 2]
13 alias Pleroma.Activity
15 alias Pleroma.Conversation.Participation
16 alias Pleroma.Delivery
17 alias Pleroma.EctoType.ActivityPub.ObjectValidators
19 alias Pleroma.FollowingRelationship
20 alias Pleroma.Formatter
24 alias Pleroma.Notification
26 alias Pleroma.Registration
29 alias Pleroma.UserRelationship
31 alias Pleroma.Web.ActivityPub.ActivityPub
32 alias Pleroma.Web.ActivityPub.Builder
33 alias Pleroma.Web.ActivityPub.Pipeline
34 alias Pleroma.Web.ActivityPub.Utils
35 alias Pleroma.Web.CommonAPI
36 alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
37 alias Pleroma.Web.OAuth
38 alias Pleroma.Web.RelMe
39 alias Pleroma.Workers.BackgroundWorker
43 @type t :: %__MODULE__{}
44 @type account_status ::
47 | :password_reset_pending
48 | :confirmation_pending
50 @primary_key {:id, FlakeId.Ecto.CompatType, autogenerate: true}
52 # credo:disable-for-next-line Credo.Check.Readability.MaxLineLength
53 @email_regex ~r/^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/
55 @strict_local_nickname_regex ~r/^[a-zA-Z\d]+$/
56 @extended_local_nickname_regex ~r/^[a-zA-Z\d_-]+$/
58 # AP ID user relationships (blocks, mutes etc.)
59 # Format: [rel_type: [outgoing_rel: :outgoing_rel_target, incoming_rel: :incoming_rel_source]]
60 @user_relationships_config [
62 blocker_blocks: :blocked_users,
63 blockee_blocks: :blocker_users
66 muter_mutes: :muted_users,
67 mutee_mutes: :muter_users
70 reblog_muter_mutes: :reblog_muted_users,
71 reblog_mutee_mutes: :reblog_muter_users
74 notification_muter_mutes: :notification_muted_users,
75 notification_mutee_mutes: :notification_muter_users
77 # Note: `inverse_subscription` relationship is inverse: subscriber acts as relationship target
78 inverse_subscription: [
79 subscribee_subscriptions: :subscriber_users,
80 subscriber_subscriptions: :subscribee_users
85 field(:bio, :string, default: "")
86 field(:raw_bio, :string)
87 field(:email, :string)
89 field(:nickname, :string)
90 field(:password_hash, :string)
91 field(:password, :string, virtual: true)
92 field(:password_confirmation, :string, virtual: true)
94 field(:public_key, :string)
95 field(:ap_id, :string)
96 field(:avatar, :map, default: %{})
97 field(:local, :boolean, default: true)
98 field(:follower_address, :string)
99 field(:following_address, :string)
100 field(:search_rank, :float, virtual: true)
101 field(:search_type, :integer, virtual: true)
102 field(:tags, {:array, :string}, default: [])
103 field(:last_refreshed_at, :naive_datetime_usec)
104 field(:last_digest_emailed_at, :naive_datetime)
105 field(:banner, :map, default: %{})
106 field(:background, :map, default: %{})
107 field(:note_count, :integer, default: 0)
108 field(:follower_count, :integer, default: 0)
109 field(:following_count, :integer, default: 0)
110 field(:is_locked, :boolean, default: false)
111 field(:confirmation_pending, :boolean, default: false)
112 field(:password_reset_pending, :boolean, default: false)
113 field(:approval_pending, :boolean, default: false)
114 field(:registration_reason, :string, default: nil)
115 field(:confirmation_token, :string, default: nil)
116 field(:default_scope, :string, default: "public")
117 field(:domain_blocks, {:array, :string}, default: [])
118 field(:deactivated, :boolean, default: false)
119 field(:no_rich_text, :boolean, default: false)
120 field(:ap_enabled, :boolean, default: false)
121 field(:is_moderator, :boolean, default: false)
122 field(:is_admin, :boolean, default: false)
123 field(:show_role, :boolean, default: true)
124 field(:mastofe_settings, :map, default: nil)
125 field(:uri, ObjectValidators.Uri, default: nil)
126 field(:hide_followers_count, :boolean, default: false)
127 field(:hide_follows_count, :boolean, default: false)
128 field(:hide_followers, :boolean, default: false)
129 field(:hide_follows, :boolean, default: false)
130 field(:hide_favorites, :boolean, default: true)
131 field(:pinned_activities, {:array, :string}, default: [])
132 field(:email_notifications, :map, default: %{"digest" => false})
133 field(:mascot, :map, default: nil)
134 field(:emoji, :map, default: %{})
135 field(:pleroma_settings_store, :map, default: %{})
136 field(:fields, {:array, :map}, default: [])
137 field(:raw_fields, {:array, :map}, default: [])
138 field(:is_discoverable, :boolean, default: false)
139 field(:invisible, :boolean, default: false)
140 field(:allow_following_move, :boolean, default: true)
141 field(:skip_thread_containment, :boolean, default: false)
142 field(:actor_type, :string, default: "Person")
143 field(:also_known_as, {:array, :string}, default: [])
144 field(:inbox, :string)
145 field(:shared_inbox, :string)
146 field(:accepts_chat_messages, :boolean, default: nil)
149 :notification_settings,
150 Pleroma.User.NotificationSetting,
154 has_many(:notifications, Notification)
155 has_many(:registrations, Registration)
156 has_many(:deliveries, Delivery)
158 has_many(:outgoing_relationships, UserRelationship, foreign_key: :source_id)
159 has_many(:incoming_relationships, UserRelationship, foreign_key: :target_id)
161 for {relationship_type,
163 {outgoing_relation, outgoing_relation_target},
164 {incoming_relation, incoming_relation_source}
165 ]} <- @user_relationships_config do
166 # Definitions of `has_many` relations: :blocker_blocks, :muter_mutes, :reblog_muter_mutes,
167 # :notification_muter_mutes, :subscribee_subscriptions
168 has_many(outgoing_relation, UserRelationship,
169 foreign_key: :source_id,
170 where: [relationship_type: relationship_type]
173 # Definitions of `has_many` relations: :blockee_blocks, :mutee_mutes, :reblog_mutee_mutes,
174 # :notification_mutee_mutes, :subscriber_subscriptions
175 has_many(incoming_relation, UserRelationship,
176 foreign_key: :target_id,
177 where: [relationship_type: relationship_type]
180 # Definitions of `has_many` relations: :blocked_users, :muted_users, :reblog_muted_users,
181 # :notification_muted_users, :subscriber_users
182 has_many(outgoing_relation_target, through: [outgoing_relation, :target])
184 # Definitions of `has_many` relations: :blocker_users, :muter_users, :reblog_muter_users,
185 # :notification_muter_users, :subscribee_users
186 has_many(incoming_relation_source, through: [incoming_relation, :source])
189 # `:blocks` is deprecated (replaced with `blocked_users` relation)
190 field(:blocks, {:array, :string}, default: [])
191 # `:mutes` is deprecated (replaced with `muted_users` relation)
192 field(:mutes, {:array, :string}, default: [])
193 # `:muted_reblogs` is deprecated (replaced with `reblog_muted_users` relation)
194 field(:muted_reblogs, {:array, :string}, default: [])
195 # `:muted_notifications` is deprecated (replaced with `notification_muted_users` relation)
196 field(:muted_notifications, {:array, :string}, default: [])
197 # `:subscribers` is deprecated (replaced with `subscriber_users` relation)
198 field(:subscribers, {:array, :string}, default: [])
201 :multi_factor_authentication_settings,
209 for {_relationship_type, [{_outgoing_relation, outgoing_relation_target}, _]} <-
210 @user_relationships_config do
211 # `def blocked_users_relation/2`, `def muted_users_relation/2`,
212 # `def reblog_muted_users_relation/2`, `def notification_muted_users/2`,
213 # `def subscriber_users/2`
214 def unquote(:"#{outgoing_relation_target}_relation")(user, restrict_deactivated? \\ false) do
215 target_users_query = assoc(user, unquote(outgoing_relation_target))
217 if restrict_deactivated? do
218 restrict_deactivated(target_users_query)
224 # `def blocked_users/2`, `def muted_users/2`, `def reblog_muted_users/2`,
225 # `def notification_muted_users/2`, `def subscriber_users/2`
226 def unquote(outgoing_relation_target)(user, restrict_deactivated? \\ false) do
228 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
230 restrict_deactivated?
235 # `def blocked_users_ap_ids/2`, `def muted_users_ap_ids/2`, `def reblog_muted_users_ap_ids/2`,
236 # `def notification_muted_users_ap_ids/2`, `def subscriber_users_ap_ids/2`
237 def unquote(:"#{outgoing_relation_target}_ap_ids")(user, restrict_deactivated? \\ false) do
239 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
241 restrict_deactivated?
243 |> select([u], u.ap_id)
248 defdelegate following_count(user), to: FollowingRelationship
249 defdelegate following(user), to: FollowingRelationship
250 defdelegate following?(follower, followed), to: FollowingRelationship
251 defdelegate following_ap_ids(user), to: FollowingRelationship
252 defdelegate get_follow_requests(user), to: FollowingRelationship
253 defdelegate search(query, opts \\ []), to: User.Search
256 Dumps Flake Id to SQL-compatible format (16-byte UUID).
257 E.g. "9pQtDGXuq4p3VlcJEm" -> <<0, 0, 1, 110, 179, 218, 42, 92, 213, 41, 44, 227, 95, 213, 0, 0>>
259 def binary_id(source_id) when is_binary(source_id) do
260 with {:ok, dumped_id} <- FlakeId.Ecto.CompatType.dump(source_id) do
267 def binary_id(source_ids) when is_list(source_ids) do
268 Enum.map(source_ids, &binary_id/1)
271 def binary_id(%User{} = user), do: binary_id(user.id)
273 @doc "Returns status account"
274 @spec account_status(User.t()) :: account_status()
275 def account_status(%User{deactivated: true}), do: :deactivated
276 def account_status(%User{password_reset_pending: true}), do: :password_reset_pending
277 def account_status(%User{local: true, approval_pending: true}), do: :approval_pending
279 def account_status(%User{local: true, confirmation_pending: true}) do
280 if Config.get([:instance, :account_activation_required]) do
281 :confirmation_pending
287 def account_status(%User{}), do: :active
289 @spec visible_for(User.t(), User.t() | nil) ::
292 | :restricted_unauthenticated
294 | :confirmation_pending
295 def visible_for(user, for_user \\ nil)
297 def visible_for(%User{invisible: true}, _), do: :invisible
299 def visible_for(%User{id: user_id}, %User{id: user_id}), do: :visible
301 def visible_for(%User{} = user, nil) do
302 if restrict_unauthenticated?(user) do
303 :restrict_unauthenticated
305 visible_account_status(user)
309 def visible_for(%User{} = user, for_user) do
310 if superuser?(for_user) do
313 visible_account_status(user)
317 def visible_for(_, _), do: :invisible
319 defp restrict_unauthenticated?(%User{local: true}) do
320 Config.restrict_unauthenticated_access?(:profiles, :local)
323 defp restrict_unauthenticated?(%User{local: _}) do
324 Config.restrict_unauthenticated_access?(:profiles, :remote)
327 defp visible_account_status(user) do
328 status = account_status(user)
330 if status in [:active, :password_reset_pending] do
337 @spec superuser?(User.t()) :: boolean()
338 def superuser?(%User{local: true, is_admin: true}), do: true
339 def superuser?(%User{local: true, is_moderator: true}), do: true
340 def superuser?(_), do: false
342 @spec invisible?(User.t()) :: boolean()
343 def invisible?(%User{invisible: true}), do: true
344 def invisible?(_), do: false
346 def avatar_url(user, options \\ []) do
348 %{"url" => [%{"href" => href} | _]} ->
352 unless options[:no_default] do
353 Config.get([:assets, :default_user_avatar], "#{Web.base_url()}/images/avi.png")
358 def banner_url(user, options \\ []) do
360 %{"url" => [%{"href" => href} | _]} -> href
361 _ -> !options[:no_default] && "#{Web.base_url()}/images/banner.png"
365 # Should probably be renamed or removed
366 def ap_id(%User{nickname: nickname}), do: "#{Web.base_url()}/users/#{nickname}"
368 def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
369 def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"
371 @spec ap_following(User.t()) :: String.t()
372 def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
373 def ap_following(%User{} = user), do: "#{ap_id(user)}/following"
375 @spec restrict_deactivated(Ecto.Query.t()) :: Ecto.Query.t()
376 def restrict_deactivated(query) do
377 from(u in query, where: u.deactivated != ^true)
380 defp truncate_fields_param(params) do
381 if Map.has_key?(params, :fields) do
382 Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
388 defp truncate_if_exists(params, key, max_length) do
389 if Map.has_key?(params, key) and is_binary(params[key]) do
390 {value, _chopped} = String.split_at(params[key], max_length)
391 Map.put(params, key, value)
397 defp fix_follower_address(%{follower_address: _, following_address: _} = params), do: params
399 defp fix_follower_address(%{nickname: nickname} = params),
400 do: Map.put(params, :follower_address, ap_followers(%User{nickname: nickname}))
402 defp fix_follower_address(params), do: params
404 def remote_user_changeset(struct \\ %User{local: false}, params) do
405 bio_limit = Config.get([:instance, :user_bio_length], 5000)
406 name_limit = Config.get([:instance, :user_name_length], 100)
409 case params[:name] do
410 name when is_binary(name) and byte_size(name) > 0 -> name
411 _ -> params[:nickname]
416 |> Map.put(:name, name)
417 |> Map.put_new(:last_refreshed_at, NaiveDateTime.utc_now())
418 |> truncate_if_exists(:name, name_limit)
419 |> truncate_if_exists(:bio, bio_limit)
420 |> truncate_fields_param()
421 |> fix_follower_address()
444 :hide_followers_count,
453 :accepts_chat_messages
456 |> cast(params, [:name], empty_values: [])
457 |> validate_required([:ap_id])
458 |> validate_required([:name], trim: false)
459 |> unique_constraint(:nickname)
460 |> validate_format(:nickname, @email_regex)
461 |> validate_length(:bio, max: bio_limit)
462 |> validate_length(:name, max: name_limit)
463 |> validate_fields(true)
466 def update_changeset(struct, params \\ %{}) do
467 bio_limit = Config.get([:instance, :user_bio_length], 5000)
468 name_limit = Config.get([:instance, :user_name_length], 100)
488 :hide_followers_count,
491 :allow_following_move,
494 :skip_thread_containment,
497 :pleroma_settings_store,
501 :accepts_chat_messages
504 |> unique_constraint(:nickname)
505 |> validate_format(:nickname, local_nickname_regex())
506 |> validate_length(:bio, max: bio_limit)
507 |> validate_length(:name, min: 1, max: name_limit)
508 |> validate_inclusion(:actor_type, ["Person", "Service"])
511 |> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
512 |> put_change_if_present(:avatar, &put_upload(&1, :avatar))
513 |> put_change_if_present(:banner, &put_upload(&1, :banner))
514 |> put_change_if_present(:background, &put_upload(&1, :background))
515 |> put_change_if_present(
516 :pleroma_settings_store,
517 &{:ok, Map.merge(struct.pleroma_settings_store, &1)}
519 |> validate_fields(false)
522 defp put_fields(changeset) do
523 if raw_fields = get_change(changeset, :raw_fields) do
526 |> Enum.filter(fn %{"name" => n} -> n != "" end)
530 |> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)
533 |> put_change(:raw_fields, raw_fields)
534 |> put_change(:fields, fields)
540 defp parse_fields(value) do
542 |> Formatter.linkify(mentions_format: :full)
546 defp put_emoji(changeset) do
547 emojified_fields = [:bio, :name, :raw_fields]
549 if Enum.any?(changeset.changes, fn {k, _} -> k in emojified_fields end) do
550 bio = Emoji.Formatter.get_emoji_map(get_field(changeset, :bio))
551 name = Emoji.Formatter.get_emoji_map(get_field(changeset, :name))
553 emoji = Map.merge(bio, name)
557 |> get_field(:raw_fields)
558 |> Enum.reduce(emoji, fn x, acc ->
559 Map.merge(acc, Emoji.Formatter.get_emoji_map(x["name"] <> x["value"]))
562 put_change(changeset, :emoji, emoji)
568 defp put_change_if_present(changeset, map_field, value_function) do
569 with {:ok, value} <- fetch_change(changeset, map_field),
570 {:ok, new_value} <- value_function.(value) do
571 put_change(changeset, map_field, new_value)
577 defp put_upload(value, type) do
578 with %Plug.Upload{} <- value,
579 {:ok, object} <- ActivityPub.upload(value, type: type) do
584 def update_as_admin_changeset(struct, params) do
586 |> update_changeset(params)
587 |> cast(params, [:email])
588 |> delete_change(:also_known_as)
589 |> unique_constraint(:email)
590 |> validate_format(:email, @email_regex)
591 |> validate_inclusion(:actor_type, ["Person", "Service"])
594 @spec update_as_admin(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
595 def update_as_admin(user, params) do
596 params = Map.put(params, "password_confirmation", params["password"])
597 changeset = update_as_admin_changeset(user, params)
599 if params["password"] do
600 reset_password(user, changeset, params)
602 User.update_and_set_cache(changeset)
606 def password_update_changeset(struct, params) do
608 |> cast(params, [:password, :password_confirmation])
609 |> validate_required([:password, :password_confirmation])
610 |> validate_confirmation(:password)
611 |> put_password_hash()
612 |> put_change(:password_reset_pending, false)
615 @spec reset_password(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
616 def reset_password(%User{} = user, params) do
617 reset_password(user, user, params)
620 def reset_password(%User{id: user_id} = user, struct, params) do
623 |> Multi.update(:user, password_update_changeset(struct, params))
624 |> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
625 |> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))
627 case Repo.transaction(multi) do
628 {:ok, %{user: user} = _} -> set_cache(user)
629 {:error, _, changeset, _} -> {:error, changeset}
633 def update_password_reset_pending(user, value) do
636 |> put_change(:password_reset_pending, value)
637 |> update_and_set_cache()
640 def force_password_reset_async(user) do
641 BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
644 @spec force_password_reset(User.t()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
645 def force_password_reset(user), do: update_password_reset_pending(user, true)
647 # Used to auto-register LDAP accounts which won't have a password hash stored locally
648 def register_changeset_ldap(struct, params = %{password: password})
649 when is_nil(password) do
650 params = Map.put_new(params, :accepts_chat_messages, true)
653 if Map.has_key?(params, :email) do
654 Map.put_new(params, :email, params[:email])
664 :accepts_chat_messages
666 |> validate_required([:name, :nickname])
667 |> unique_constraint(:nickname)
668 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
669 |> validate_format(:nickname, local_nickname_regex())
671 |> unique_constraint(:ap_id)
672 |> put_following_and_follower_address()
675 def register_changeset(struct, params \\ %{}, opts \\ []) do
676 bio_limit = Config.get([:instance, :user_bio_length], 5000)
677 name_limit = Config.get([:instance, :user_name_length], 100)
678 reason_limit = Config.get([:instance, :registration_reason_length], 500)
679 params = Map.put_new(params, :accepts_chat_messages, true)
682 if is_nil(opts[:need_confirmation]) do
683 Config.get([:instance, :account_activation_required])
685 opts[:need_confirmation]
689 if is_nil(opts[:need_approval]) do
690 Config.get([:instance, :account_approval_required])
696 |> confirmation_changeset(need_confirmation: need_confirmation?)
697 |> approval_changeset(need_approval: need_approval?)
705 :password_confirmation,
707 :accepts_chat_messages,
710 |> validate_required([:name, :nickname, :password, :password_confirmation])
711 |> validate_confirmation(:password)
712 |> unique_constraint(:email)
713 |> validate_format(:email, @email_regex)
714 |> validate_change(:email, fn :email, email ->
716 Config.get([User, :email_blacklist])
717 |> Enum.all?(fn blacklisted_domain ->
718 !String.ends_with?(email, ["@" <> blacklisted_domain, "." <> blacklisted_domain])
721 if valid?, do: [], else: [email: "Invalid email"]
723 |> unique_constraint(:nickname)
724 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
725 |> validate_format(:nickname, local_nickname_regex())
726 |> validate_length(:bio, max: bio_limit)
727 |> validate_length(:name, min: 1, max: name_limit)
728 |> validate_length(:registration_reason, max: reason_limit)
729 |> maybe_validate_required_email(opts[:external])
732 |> unique_constraint(:ap_id)
733 |> put_following_and_follower_address()
736 def maybe_validate_required_email(changeset, true), do: changeset
738 def maybe_validate_required_email(changeset, _) do
739 if Config.get([:instance, :account_activation_required]) do
740 validate_required(changeset, [:email])
746 defp put_ap_id(changeset) do
747 ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
748 put_change(changeset, :ap_id, ap_id)
751 defp put_following_and_follower_address(changeset) do
752 followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
755 |> put_change(:follower_address, followers)
758 defp autofollow_users(user) do
759 candidates = Config.get([:instance, :autofollowed_nicknames])
762 User.Query.build(%{nickname: candidates, local: true, deactivated: false})
765 follow_all(user, autofollowed_users)
768 defp autofollowing_users(user) do
769 candidates = Config.get([:instance, :autofollowing_nicknames])
771 User.Query.build(%{nickname: candidates, local: true, deactivated: false})
773 |> Enum.each(&follow(&1, user, :follow_accept))
778 @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
779 def register(%Ecto.Changeset{} = changeset) do
780 with {:ok, user} <- Repo.insert(changeset) do
781 post_register_action(user)
785 def post_register_action(%User{} = user) do
786 with {:ok, user} <- autofollow_users(user),
787 {:ok, _} <- autofollowing_users(user),
788 {:ok, user} <- set_cache(user),
789 {:ok, _} <- send_welcome_email(user),
790 {:ok, _} <- send_welcome_message(user),
791 {:ok, _} <- send_welcome_chat_message(user),
792 {:ok, _} <- try_send_confirmation_email(user) do
797 def send_welcome_message(user) do
798 if User.WelcomeMessage.enabled?() do
799 User.WelcomeMessage.post_message(user)
806 def send_welcome_chat_message(user) do
807 if User.WelcomeChatMessage.enabled?() do
808 User.WelcomeChatMessage.post_message(user)
815 def send_welcome_email(%User{email: email} = user) when is_binary(email) do
816 if User.WelcomeEmail.enabled?() do
817 User.WelcomeEmail.send_email(user)
824 def send_welcome_email(_), do: {:ok, :noop}
826 @spec try_send_confirmation_email(User.t()) :: {:ok, :enqueued | :noop}
827 def try_send_confirmation_email(%User{confirmation_pending: true, email: email} = user)
828 when is_binary(email) do
829 if Config.get([:instance, :account_activation_required]) do
830 send_confirmation_email(user)
837 def try_send_confirmation_email(_), do: {:ok, :noop}
839 @spec send_confirmation_email(Uset.t()) :: User.t()
840 def send_confirmation_email(%User{} = user) do
842 |> Pleroma.Emails.UserEmail.account_confirmation_email()
843 |> Pleroma.Emails.Mailer.deliver_async()
848 def needs_update?(%User{local: true}), do: false
850 def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
852 def needs_update?(%User{local: false} = user) do
853 NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
856 def needs_update?(_), do: true
858 @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
860 # "Locked" (self-locked) users demand explicit authorization of follow requests
861 def maybe_direct_follow(%User{} = follower, %User{local: true, is_locked: true} = followed) do
862 follow(follower, followed, :follow_pending)
865 def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
866 follow(follower, followed)
869 def maybe_direct_follow(%User{} = follower, %User{} = followed) do
870 if not ap_enabled?(followed) do
871 follow(follower, followed)
877 @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
878 @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
879 def follow_all(follower, followeds) do
881 |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
882 |> Enum.each(&follow(follower, &1, :follow_accept))
887 def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
888 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
891 followed.deactivated ->
892 {:error, "Could not follow user: #{followed.nickname} is deactivated."}
894 deny_follow_blocked and blocks?(followed, follower) ->
895 {:error, "Could not follow user: #{followed.nickname} blocked you."}
898 FollowingRelationship.follow(follower, followed, state)
900 {:ok, _} = update_follower_count(followed)
903 |> update_following_count()
907 def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
908 {:error, "Not subscribed!"}
911 @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
912 def unfollow(%User{} = follower, %User{} = followed) do
913 case do_unfollow(follower, followed) do
914 {:ok, follower, followed} ->
915 {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
922 @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
923 defp do_unfollow(%User{} = follower, %User{} = followed) do
924 case get_follow_state(follower, followed) do
925 state when state in [:follow_pending, :follow_accept] ->
926 FollowingRelationship.unfollow(follower, followed)
927 {:ok, followed} = update_follower_count(followed)
929 {:ok, follower} = update_following_count(follower)
931 {:ok, follower, followed}
934 {:error, "Not subscribed!"}
938 @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
939 def get_follow_state(%User{} = follower, %User{} = following) do
940 following_relationship = FollowingRelationship.get(follower, following)
941 get_follow_state(follower, following, following_relationship)
944 def get_follow_state(
947 following_relationship
949 case {following_relationship, following.local} do
951 case Utils.fetch_latest_follow(follower, following) do
952 %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
953 FollowingRelationship.state_to_enum(state)
959 {%{state: state}, _} ->
967 def locked?(%User{} = user) do
968 user.is_locked || false
972 Repo.get_by(User, id: id)
975 def get_by_ap_id(ap_id) do
976 Repo.get_by(User, ap_id: ap_id)
979 def get_all_by_ap_id(ap_ids) do
980 from(u in __MODULE__,
981 where: u.ap_id in ^ap_ids
986 def get_all_by_ids(ids) do
987 from(u in __MODULE__, where: u.id in ^ids)
991 # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
992 # of the ap_id and the domain and tries to get that user
993 def get_by_guessed_nickname(ap_id) do
994 domain = URI.parse(ap_id).host
995 name = List.last(String.split(ap_id, "/"))
996 nickname = "#{name}@#{domain}"
998 get_cached_by_nickname(nickname)
1001 def set_cache({:ok, user}), do: set_cache(user)
1002 def set_cache({:error, err}), do: {:error, err}
1004 def set_cache(%User{} = user) do
1005 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1006 Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
1007 Cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
1011 def update_and_set_cache(struct, params) do
1013 |> update_changeset(params)
1014 |> update_and_set_cache()
1017 def update_and_set_cache(changeset) do
1018 with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
1023 def get_user_friends_ap_ids(user) do
1024 from(u in User.get_friends_query(user), select: u.ap_id)
1028 @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
1029 def get_cached_user_friends_ap_ids(user) do
1030 Cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
1031 get_user_friends_ap_ids(user)
1035 def invalidate_cache(user) do
1036 Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
1037 Cachex.del(:user_cache, "nickname:#{user.nickname}")
1038 Cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
1041 @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
1042 def get_cached_by_ap_id(ap_id) do
1043 key = "ap_id:#{ap_id}"
1045 with {:ok, nil} <- Cachex.get(:user_cache, key),
1046 user when not is_nil(user) <- get_by_ap_id(ap_id),
1047 {:ok, true} <- Cachex.put(:user_cache, key, user) do
1055 def get_cached_by_id(id) do
1059 Cachex.fetch!(:user_cache, key, fn _ ->
1060 user = get_by_id(id)
1063 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1064 {:commit, user.ap_id}
1070 get_cached_by_ap_id(ap_id)
1073 def get_cached_by_nickname(nickname) do
1074 key = "nickname:#{nickname}"
1076 Cachex.fetch!(:user_cache, key, fn ->
1077 case get_or_fetch_by_nickname(nickname) do
1078 {:ok, user} -> {:commit, user}
1079 {:error, _error} -> {:ignore, nil}
1084 def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
1085 restrict_to_local = Config.get([:instance, :limit_to_local_content])
1088 is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
1089 get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
1091 restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
1092 get_cached_by_nickname(nickname_or_id)
1094 restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
1095 get_cached_by_nickname(nickname_or_id)
1102 @spec get_by_nickname(String.t()) :: User.t() | nil
1103 def get_by_nickname(nickname) do
1104 Repo.get_by(User, nickname: nickname) ||
1105 if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
1106 Repo.get_by(User, nickname: local_nickname(nickname))
1110 def get_by_email(email), do: Repo.get_by(User, email: email)
1112 def get_by_nickname_or_email(nickname_or_email) do
1113 get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
1116 def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
1118 def get_or_fetch_by_nickname(nickname) do
1119 with %User{} = user <- get_by_nickname(nickname) do
1123 with [_nick, _domain] <- String.split(nickname, "@"),
1124 {:ok, user} <- fetch_by_nickname(nickname) do
1127 _e -> {:error, "not found " <> nickname}
1132 @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1133 def get_followers_query(%User{} = user, nil) do
1134 User.Query.build(%{followers: user, deactivated: false})
1137 def get_followers_query(%User{} = user, page) do
1139 |> get_followers_query(nil)
1140 |> User.Query.paginate(page, 20)
1143 @spec get_followers_query(User.t()) :: Ecto.Query.t()
1144 def get_followers_query(%User{} = user), do: get_followers_query(user, nil)
1146 @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1147 def get_followers(%User{} = user, page \\ nil) do
1149 |> get_followers_query(page)
1153 @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1154 def get_external_followers(%User{} = user, page \\ nil) do
1156 |> get_followers_query(page)
1157 |> User.Query.build(%{external: true})
1161 def get_followers_ids(%User{} = user, page \\ nil) do
1163 |> get_followers_query(page)
1164 |> select([u], u.id)
1168 @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1169 def get_friends_query(%User{} = user, nil) do
1170 User.Query.build(%{friends: user, deactivated: false})
1173 def get_friends_query(%User{} = user, page) do
1175 |> get_friends_query(nil)
1176 |> User.Query.paginate(page, 20)
1179 @spec get_friends_query(User.t()) :: Ecto.Query.t()
1180 def get_friends_query(%User{} = user), do: get_friends_query(user, nil)
1182 def get_friends(%User{} = user, page \\ nil) do
1184 |> get_friends_query(page)
1188 def get_friends_ap_ids(%User{} = user) do
1190 |> get_friends_query(nil)
1191 |> select([u], u.ap_id)
1195 def get_friends_ids(%User{} = user, page \\ nil) do
1197 |> get_friends_query(page)
1198 |> select([u], u.id)
1202 def increase_note_count(%User{} = user) do
1204 |> where(id: ^user.id)
1205 |> update([u], inc: [note_count: 1])
1207 |> Repo.update_all([])
1209 {1, [user]} -> set_cache(user)
1214 def decrease_note_count(%User{} = user) do
1216 |> where(id: ^user.id)
1219 note_count: fragment("greatest(0, note_count - 1)")
1223 |> Repo.update_all([])
1225 {1, [user]} -> set_cache(user)
1230 def update_note_count(%User{} = user, note_count \\ nil) do
1235 where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1241 |> cast(%{note_count: note_count}, [:note_count])
1242 |> update_and_set_cache()
1245 @spec maybe_fetch_follow_information(User.t()) :: User.t()
1246 def maybe_fetch_follow_information(user) do
1247 with {:ok, user} <- fetch_follow_information(user) do
1251 Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1257 def fetch_follow_information(user) do
1258 with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1260 |> follow_information_changeset(info)
1261 |> update_and_set_cache()
1265 defp follow_information_changeset(user, params) do
1272 :hide_followers_count,
1277 @spec update_follower_count(User.t()) :: {:ok, User.t()}
1278 def update_follower_count(%User{} = user) do
1279 if user.local or !Config.get([:instance, :external_user_synchronization]) do
1280 follower_count = FollowingRelationship.follower_count(user)
1283 |> follow_information_changeset(%{follower_count: follower_count})
1284 |> update_and_set_cache
1286 {:ok, maybe_fetch_follow_information(user)}
1290 @spec update_following_count(User.t()) :: {:ok, User.t()}
1291 def update_following_count(%User{local: false} = user) do
1292 if Config.get([:instance, :external_user_synchronization]) do
1293 {:ok, maybe_fetch_follow_information(user)}
1299 def update_following_count(%User{local: true} = user) do
1300 following_count = FollowingRelationship.following_count(user)
1303 |> follow_information_changeset(%{following_count: following_count})
1304 |> update_and_set_cache()
1307 @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1308 def get_users_from_set(ap_ids, opts \\ []) do
1309 local_only = Keyword.get(opts, :local_only, true)
1310 criteria = %{ap_id: ap_ids, deactivated: false}
1311 criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1313 User.Query.build(criteria)
1317 @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1318 def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1321 query = User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
1327 @spec mute(User.t(), User.t(), boolean()) ::
1328 {:ok, list(UserRelationship.t())} | {:error, String.t()}
1329 def mute(%User{} = muter, %User{} = mutee, notifications? \\ true) do
1330 add_to_mutes(muter, mutee, notifications?)
1333 def unmute(%User{} = muter, %User{} = mutee) do
1334 remove_from_mutes(muter, mutee)
1337 def subscribe(%User{} = subscriber, %User{} = target) do
1338 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
1340 if blocks?(target, subscriber) and deny_follow_blocked do
1341 {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1343 # Note: the relationship is inverse: subscriber acts as relationship target
1344 UserRelationship.create_inverse_subscription(target, subscriber)
1348 def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1349 with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1350 subscribe(subscriber, subscribee)
1354 def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1355 # Note: the relationship is inverse: subscriber acts as relationship target
1356 UserRelationship.delete_inverse_subscription(target, unsubscriber)
1359 def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1360 with %User{} = user <- get_cached_by_ap_id(ap_id) do
1361 unsubscribe(unsubscriber, user)
1365 def block(%User{} = blocker, %User{} = blocked) do
1366 # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1368 if following?(blocker, blocked) do
1369 {:ok, blocker, _} = unfollow(blocker, blocked)
1375 # clear any requested follows as well
1377 case CommonAPI.reject_follow_request(blocked, blocker) do
1378 {:ok, %User{} = updated_blocked} -> updated_blocked
1382 unsubscribe(blocked, blocker)
1384 unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
1385 if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)
1387 {:ok, blocker} = update_follower_count(blocker)
1388 {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1389 add_to_block(blocker, blocked)
1392 # helper to handle the block given only an actor's AP id
1393 def block(%User{} = blocker, %{ap_id: ap_id}) do
1394 block(blocker, get_cached_by_ap_id(ap_id))
1397 def unblock(%User{} = blocker, %User{} = blocked) do
1398 remove_from_block(blocker, blocked)
1401 # helper to handle the block given only an actor's AP id
1402 def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1403 unblock(blocker, get_cached_by_ap_id(ap_id))
1406 def mutes?(nil, _), do: false
1407 def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1409 def mutes_user?(%User{} = user, %User{} = target) do
1410 UserRelationship.mute_exists?(user, target)
1413 @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1414 def muted_notifications?(nil, _), do: false
1416 def muted_notifications?(%User{} = user, %User{} = target),
1417 do: UserRelationship.notification_mute_exists?(user, target)
1419 def blocks?(nil, _), do: false
1421 def blocks?(%User{} = user, %User{} = target) do
1422 blocks_user?(user, target) ||
1423 (blocks_domain?(user, target) and not User.following?(user, target))
1426 def blocks_user?(%User{} = user, %User{} = target) do
1427 UserRelationship.block_exists?(user, target)
1430 def blocks_user?(_, _), do: false
1432 def blocks_domain?(%User{} = user, %User{} = target) do
1433 domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1434 %{host: host} = URI.parse(target.ap_id)
1435 Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1438 def blocks_domain?(_, _), do: false
1440 def subscribed_to?(%User{} = user, %User{} = target) do
1441 # Note: the relationship is inverse: subscriber acts as relationship target
1442 UserRelationship.inverse_subscription_exists?(target, user)
1445 def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1446 with %User{} = target <- get_cached_by_ap_id(ap_id) do
1447 subscribed_to?(user, target)
1452 Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1453 E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1455 @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1456 def outgoing_relationships_ap_ids(_user, []), do: %{}
1458 def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1460 def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1461 when is_list(relationship_types) do
1464 |> assoc(:outgoing_relationships)
1465 |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1466 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1467 |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1468 |> group_by([user_rel, u], user_rel.relationship_type)
1470 |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1475 fn rel_type -> {rel_type, db_result[rel_type] || []} end
1479 def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1481 def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1483 def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1485 def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1486 when is_list(relationship_types) do
1488 |> assoc(:incoming_relationships)
1489 |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1490 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1491 |> maybe_filter_on_ap_id(ap_ids)
1492 |> select([user_rel, u], u.ap_id)
1497 defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1498 where(query, [user_rel, u], u.ap_id in ^ap_ids)
1501 defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1503 def deactivate_async(user, status \\ true) do
1504 BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
1507 def deactivate(user, status \\ true)
1509 def deactivate(users, status) when is_list(users) do
1510 Repo.transaction(fn ->
1511 for user <- users, do: deactivate(user, status)
1515 def deactivate(%User{} = user, status) do
1516 with {:ok, user} <- set_activation_status(user, status) do
1519 |> Enum.filter(& &1.local)
1520 |> Enum.each(&set_cache(update_following_count(&1)))
1522 # Only update local user counts, remote will be update during the next pull.
1525 |> Enum.filter(& &1.local)
1526 |> Enum.each(&do_unfollow(user, &1))
1532 def approve(users) when is_list(users) do
1533 Repo.transaction(fn ->
1534 Enum.map(users, fn user ->
1535 with {:ok, user} <- approve(user), do: user
1540 def approve(%User{} = user) do
1541 change(user, approval_pending: false)
1542 |> update_and_set_cache()
1545 def update_notification_settings(%User{} = user, settings) do
1547 |> cast(%{notification_settings: settings}, [])
1548 |> cast_embed(:notification_settings)
1549 |> validate_required([:notification_settings])
1550 |> update_and_set_cache()
1553 @spec purge_user_changeset(User.t()) :: Changeset.t()
1554 def purge_user_changeset(user) do
1555 # "Right to be forgotten"
1556 # https://gdpr.eu/right-to-be-forgotten/
1567 last_refreshed_at: nil,
1568 last_digest_emailed_at: nil,
1575 confirmation_pending: false,
1576 password_reset_pending: false,
1577 approval_pending: false,
1578 registration_reason: nil,
1579 confirmation_token: nil,
1583 is_moderator: false,
1585 mastofe_settings: nil,
1588 pleroma_settings_store: %{},
1591 is_discoverable: false,
1596 def delete(users) when is_list(users) do
1597 for user <- users, do: delete(user)
1600 def delete(%User{} = user) do
1601 BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1604 defp delete_and_invalidate_cache(%User{} = user) do
1605 invalidate_cache(user)
1609 defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)
1611 defp delete_or_deactivate(%User{local: true} = user) do
1612 status = account_status(user)
1615 :confirmation_pending ->
1616 delete_and_invalidate_cache(user)
1618 :approval_pending ->
1619 delete_and_invalidate_cache(user)
1623 |> purge_user_changeset()
1624 |> update_and_set_cache()
1628 def perform(:force_password_reset, user), do: force_password_reset(user)
1630 @spec perform(atom(), User.t()) :: {:ok, User.t()}
1631 def perform(:delete, %User{} = user) do
1632 # Remove all relationships
1635 |> Enum.each(fn follower ->
1636 ActivityPub.unfollow(follower, user)
1637 unfollow(follower, user)
1642 |> Enum.each(fn followed ->
1643 ActivityPub.unfollow(user, followed)
1644 unfollow(user, followed)
1647 delete_user_activities(user)
1648 delete_notifications_from_user_activities(user)
1650 delete_outgoing_pending_follow_requests(user)
1652 delete_or_deactivate(user)
1655 def perform(:deactivate_async, user, status), do: deactivate(user, status)
1657 @spec external_users_query() :: Ecto.Query.t()
1658 def external_users_query do
1666 @spec external_users(keyword()) :: [User.t()]
1667 def external_users(opts \\ []) do
1669 external_users_query()
1670 |> select([u], struct(u, [:id, :ap_id]))
1674 do: where(query, [u], u.id > ^opts[:max_id]),
1679 do: limit(query, ^opts[:limit]),
1685 def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1687 |> join(:inner, [n], activity in assoc(n, :activity))
1688 |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1689 |> Repo.delete_all()
1692 def delete_user_activities(%User{ap_id: ap_id} = user) do
1694 |> Activity.Queries.by_actor()
1695 |> Repo.chunk_stream(50, :batches)
1696 |> Stream.each(fn activities ->
1697 Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1702 defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1703 with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1704 {:ok, delete_data, _} <- Builder.delete(user, object) do
1705 Pipeline.common_pipeline(delete_data, local: user.local)
1707 {:find_object, nil} ->
1708 # We have the create activity, but not the object, it was probably pruned.
1709 # Insert a tombstone and try again
1710 with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1711 {:ok, _tombstone} <- Object.create(tombstone_data) do
1712 delete_activity(activity, user)
1716 Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1717 Logger.error("Error: #{inspect(e)}")
1721 defp delete_activity(%{data: %{"type" => type}} = activity, user)
1722 when type in ["Like", "Announce"] do
1723 {:ok, undo, _} = Builder.undo(user, activity)
1724 Pipeline.common_pipeline(undo, local: user.local)
1727 defp delete_activity(_activity, _user), do: "Doing nothing"
1729 defp delete_outgoing_pending_follow_requests(user) do
1731 |> FollowingRelationship.outgoing_pending_follow_requests_query()
1732 |> Repo.delete_all()
1735 def html_filter_policy(%User{no_rich_text: true}) do
1736 Pleroma.HTML.Scrubber.TwitterText
1739 def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])
1741 def fetch_by_ap_id(ap_id, opts \\ []), do: ActivityPub.make_user_from_ap_id(ap_id, opts)
1743 def get_or_fetch_by_ap_id(ap_id, opts \\ []) do
1744 cached_user = get_cached_by_ap_id(ap_id)
1746 maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id, opts)
1748 case {cached_user, maybe_fetched_user} do
1749 {_, {:ok, %User{} = user}} ->
1752 {%User{} = user, _} ->
1756 {:error, :not_found}
1761 Creates an internal service actor by URI if missing.
1762 Optionally takes nickname for addressing.
1764 @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1765 def get_or_create_service_actor_by_ap_id(uri, nickname) do
1767 case get_cached_by_ap_id(uri) do
1769 with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1770 Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1774 %User{invisible: false} = user ->
1784 @spec set_invisible(User.t()) :: {:ok, User.t()}
1785 defp set_invisible(user) do
1787 |> change(%{invisible: true})
1788 |> update_and_set_cache()
1791 @spec create_service_actor(String.t(), String.t()) ::
1792 {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1793 defp create_service_actor(uri, nickname) do
1799 follower_address: uri <> "/followers"
1802 |> unique_constraint(:nickname)
1807 def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1810 |> :public_key.pem_decode()
1812 |> :public_key.pem_entry_decode()
1817 def public_key(_), do: {:error, "key not found"}
1819 def get_public_key_for_ap_id(ap_id, opts \\ []) do
1820 with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id, opts),
1821 {:ok, public_key} <- public_key(user) do
1828 def ap_enabled?(%User{local: true}), do: true
1829 def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1830 def ap_enabled?(_), do: false
1832 @doc "Gets or fetch a user by uri or nickname."
1833 @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1834 def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1835 def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1837 # wait a period of time and return newest version of the User structs
1838 # this is because we have synchronous follow APIs and need to simulate them
1839 # with an async handshake
1840 def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1841 with %User{} = a <- get_cached_by_id(a.id),
1842 %User{} = b <- get_cached_by_id(b.id) do
1849 def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1850 with :ok <- :timer.sleep(timeout),
1851 %User{} = a <- get_cached_by_id(a.id),
1852 %User{} = b <- get_cached_by_id(b.id) do
1859 def parse_bio(bio) when is_binary(bio) and bio != "" do
1861 |> CommonUtils.format_input("text/plain", mentions_format: :full)
1865 def parse_bio(_), do: ""
1867 def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1868 # TODO: get profile URLs other than user.ap_id
1869 profile_urls = [user.ap_id]
1872 |> CommonUtils.format_input("text/plain",
1873 mentions_format: :full,
1874 rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1879 def parse_bio(_, _), do: ""
1881 def tag(user_identifiers, tags) when is_list(user_identifiers) do
1882 Repo.transaction(fn ->
1883 for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1887 def tag(nickname, tags) when is_binary(nickname),
1888 do: tag(get_by_nickname(nickname), tags)
1890 def tag(%User{} = user, tags),
1891 do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1893 def untag(user_identifiers, tags) when is_list(user_identifiers) do
1894 Repo.transaction(fn ->
1895 for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1899 def untag(nickname, tags) when is_binary(nickname),
1900 do: untag(get_by_nickname(nickname), tags)
1902 def untag(%User{} = user, tags),
1903 do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1905 defp update_tags(%User{} = user, new_tags) do
1906 {:ok, updated_user} =
1908 |> change(%{tags: new_tags})
1909 |> update_and_set_cache()
1914 defp normalize_tags(tags) do
1917 |> Enum.map(&String.downcase/1)
1920 defp local_nickname_regex do
1921 if Config.get([:instance, :extended_nickname_format]) do
1922 @extended_local_nickname_regex
1924 @strict_local_nickname_regex
1928 def local_nickname(nickname_or_mention) do
1931 |> String.split("@")
1935 def full_nickname(nickname_or_mention),
1936 do: String.trim_leading(nickname_or_mention, "@")
1938 def error_user(ap_id) do
1942 nickname: "erroruser@example.com",
1943 inserted_at: NaiveDateTime.utc_now()
1947 @spec all_superusers() :: [User.t()]
1948 def all_superusers do
1949 User.Query.build(%{super_users: true, local: true, deactivated: false})
1953 def muting_reblogs?(%User{} = user, %User{} = target) do
1954 UserRelationship.reblog_mute_exists?(user, target)
1957 def showing_reblogs?(%User{} = user, %User{} = target) do
1958 not muting_reblogs?(user, target)
1962 The function returns a query to get users with no activity for given interval of days.
1963 Inactive users are those who didn't read any notification, or had any activity where
1964 the user is the activity's actor, during `inactivity_threshold` days.
1965 Deactivated users will not appear in this list.
1969 iex> Pleroma.User.list_inactive_users()
1972 @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
1973 def list_inactive_users_query(inactivity_threshold \\ 7) do
1974 negative_inactivity_threshold = -inactivity_threshold
1975 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
1976 # Subqueries are not supported in `where` clauses, join gets too complicated.
1977 has_read_notifications =
1978 from(n in Pleroma.Notification,
1979 where: n.seen == true,
1981 having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
1984 |> Pleroma.Repo.all()
1986 from(u in Pleroma.User,
1987 left_join: a in Pleroma.Activity,
1988 on: u.ap_id == a.actor,
1989 where: not is_nil(u.nickname),
1990 where: u.deactivated != ^true,
1991 where: u.id not in ^has_read_notifications,
1994 max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
1995 is_nil(max(a.inserted_at))
2000 Enable or disable email notifications for user
2004 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
2005 Pleroma.User{email_notifications: %{"digest" => true}}
2007 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
2008 Pleroma.User{email_notifications: %{"digest" => false}}
2010 @spec switch_email_notifications(t(), String.t(), boolean()) ::
2011 {:ok, t()} | {:error, Ecto.Changeset.t()}
2012 def switch_email_notifications(user, type, status) do
2013 User.update_email_notifications(user, %{type => status})
2017 Set `last_digest_emailed_at` value for the user to current time
2019 @spec touch_last_digest_emailed_at(t()) :: t()
2020 def touch_last_digest_emailed_at(user) do
2021 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2023 {:ok, updated_user} =
2025 |> change(%{last_digest_emailed_at: now})
2026 |> update_and_set_cache()
2031 @spec toggle_confirmation(User.t()) :: {:ok, User.t()} | {:error, Changeset.t()}
2032 def toggle_confirmation(%User{} = user) do
2034 |> confirmation_changeset(need_confirmation: !user.confirmation_pending)
2035 |> update_and_set_cache()
2038 @spec toggle_confirmation([User.t()]) :: [{:ok, User.t()} | {:error, Changeset.t()}]
2039 def toggle_confirmation(users) do
2040 Enum.map(users, &toggle_confirmation/1)
2043 @spec need_confirmation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
2044 def need_confirmation(%User{} = user, bool) do
2046 |> confirmation_changeset(need_confirmation: bool)
2047 |> update_and_set_cache()
2050 def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
2054 def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
2055 # use instance-default
2056 config = Config.get([:assets, :mascots])
2057 default_mascot = Config.get([:assets, :default_mascot])
2058 mascot = Keyword.get(config, default_mascot)
2061 "id" => "default-mascot",
2062 "url" => mascot[:url],
2063 "preview_url" => mascot[:url],
2065 "mime_type" => mascot[:mime_type]
2070 def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
2072 def ensure_keys_present(%User{} = user) do
2073 with {:ok, pem} <- Keys.generate_rsa_pem() do
2075 |> cast(%{keys: pem}, [:keys])
2076 |> validate_required([:keys])
2077 |> update_and_set_cache()
2081 def get_ap_ids_by_nicknames(nicknames) do
2083 where: u.nickname in ^nicknames,
2089 defp put_password_hash(
2090 %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2092 change(changeset, password_hash: Pbkdf2.hash_pwd_salt(password))
2095 defp put_password_hash(changeset), do: changeset
2097 def is_internal_user?(%User{nickname: nil}), do: true
2098 def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2099 def is_internal_user?(_), do: false
2101 # A hack because user delete activities have a fake id for whatever reason
2102 # TODO: Get rid of this
2103 def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2105 def get_delivered_users_by_object_id(object_id) do
2107 inner_join: delivery in assoc(u, :deliveries),
2108 where: delivery.object_id == ^object_id
2113 def change_email(user, email) do
2115 |> cast(%{email: email}, [:email])
2116 |> validate_required([:email])
2117 |> unique_constraint(:email)
2118 |> validate_format(:email, @email_regex)
2119 |> update_and_set_cache()
2122 # Internal function; public one is `deactivate/2`
2123 defp set_activation_status(user, deactivated) do
2125 |> cast(%{deactivated: deactivated}, [:deactivated])
2126 |> update_and_set_cache()
2129 def update_banner(user, banner) do
2131 |> cast(%{banner: banner}, [:banner])
2132 |> update_and_set_cache()
2135 def update_background(user, background) do
2137 |> cast(%{background: background}, [:background])
2138 |> update_and_set_cache()
2141 def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
2144 moderator: is_moderator
2148 def validate_fields(changeset, remote? \\ false) do
2149 limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2150 limit = Config.get([:instance, limit_name], 0)
2153 |> validate_length(:fields, max: limit)
2154 |> validate_change(:fields, fn :fields, fields ->
2155 if Enum.all?(fields, &valid_field?/1) do
2163 defp valid_field?(%{"name" => name, "value" => value}) do
2164 name_limit = Config.get([:instance, :account_field_name_length], 255)
2165 value_limit = Config.get([:instance, :account_field_value_length], 255)
2167 is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2168 String.length(value) <= value_limit
2171 defp valid_field?(_), do: false
2173 defp truncate_field(%{"name" => name, "value" => value}) do
2175 String.split_at(name, Config.get([:instance, :account_field_name_length], 255))
2178 String.split_at(value, Config.get([:instance, :account_field_value_length], 255))
2180 %{"name" => name, "value" => value}
2183 def admin_api_update(user, params) do
2190 |> update_and_set_cache()
2193 @doc "Signs user out of all applications"
2194 def global_sign_out(user) do
2195 OAuth.Authorization.delete_user_authorizations(user)
2196 OAuth.Token.delete_user_tokens(user)
2199 def mascot_update(user, url) do
2201 |> cast(%{mascot: url}, [:mascot])
2202 |> validate_required([:mascot])
2203 |> update_and_set_cache()
2206 def mastodon_settings_update(user, settings) do
2208 |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
2209 |> validate_required([:mastofe_settings])
2210 |> update_and_set_cache()
2213 @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2214 def confirmation_changeset(user, need_confirmation: need_confirmation?) do
2216 if need_confirmation? do
2218 confirmation_pending: true,
2219 confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2223 confirmation_pending: false,
2224 confirmation_token: nil
2228 cast(user, params, [:confirmation_pending, :confirmation_token])
2231 @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
2232 def approval_changeset(user, need_approval: need_approval?) do
2233 params = if need_approval?, do: %{approval_pending: true}, else: %{approval_pending: false}
2234 cast(user, params, [:approval_pending])
2237 def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2238 if id not in user.pinned_activities do
2239 max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2240 params = %{pinned_activities: user.pinned_activities ++ [id]}
2242 # if pinned activity was scheduled for deletion, we remove job
2243 if expiration = Pleroma.Workers.PurgeExpiredActivity.get_expiration(id) do
2244 Oban.cancel_job(expiration.id)
2248 |> cast(params, [:pinned_activities])
2249 |> validate_length(:pinned_activities,
2250 max: max_pinned_statuses,
2251 message: "You have already pinned the maximum number of statuses"
2256 |> update_and_set_cache()
2259 def remove_pinnned_activity(user, %Pleroma.Activity{id: id, data: data}) do
2260 params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2262 # if pinned activity was scheduled for deletion, we reschedule it for deletion
2263 if data["expires_at"] do
2264 # MRF.ActivityExpirationPolicy used UTC timestamps for expires_at in original implementation
2266 data["expires_at"] |> Pleroma.EctoType.ActivityPub.ObjectValidators.DateTime.cast()
2268 Pleroma.Workers.PurgeExpiredActivity.enqueue(%{
2270 expires_at: expires_at
2275 |> cast(params, [:pinned_activities])
2276 |> update_and_set_cache()
2279 def update_email_notifications(user, settings) do
2280 email_notifications =
2281 user.email_notifications
2282 |> Map.merge(settings)
2283 |> Map.take(["digest"])
2285 params = %{email_notifications: email_notifications}
2286 fields = [:email_notifications]
2289 |> cast(params, fields)
2290 |> validate_required(fields)
2291 |> update_and_set_cache()
2294 defp set_domain_blocks(user, domain_blocks) do
2295 params = %{domain_blocks: domain_blocks}
2298 |> cast(params, [:domain_blocks])
2299 |> validate_required([:domain_blocks])
2300 |> update_and_set_cache()
2303 def block_domain(user, domain_blocked) do
2304 set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2307 def unblock_domain(user, domain_blocked) do
2308 set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2311 @spec add_to_block(User.t(), User.t()) ::
2312 {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2313 defp add_to_block(%User{} = user, %User{} = blocked) do
2314 UserRelationship.create_block(user, blocked)
2317 @spec add_to_block(User.t(), User.t()) ::
2318 {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2319 defp remove_from_block(%User{} = user, %User{} = blocked) do
2320 UserRelationship.delete_block(user, blocked)
2323 defp add_to_mutes(%User{} = user, %User{} = muted_user, notifications?) do
2324 with {:ok, user_mute} <- UserRelationship.create_mute(user, muted_user),
2325 {:ok, user_notification_mute} <-
2326 (notifications? && UserRelationship.create_notification_mute(user, muted_user)) ||
2328 {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
2332 defp remove_from_mutes(user, %User{} = muted_user) do
2333 with {:ok, user_mute} <- UserRelationship.delete_mute(user, muted_user),
2334 {:ok, user_notification_mute} <-
2335 UserRelationship.delete_notification_mute(user, muted_user) do
2336 {:ok, [user_mute, user_notification_mute]}
2340 def set_invisible(user, invisible) do
2341 params = %{invisible: invisible}
2344 |> cast(params, [:invisible])
2345 |> validate_required([:invisible])
2346 |> update_and_set_cache()
2349 def sanitize_html(%User{} = user) do
2350 sanitize_html(user, nil)
2353 # User data that mastodon isn't filtering (treated as plaintext):
2356 def sanitize_html(%User{} = user, filter) do
2358 Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2361 "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2366 |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2367 |> Map.put(:fields, fields)