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
28 alias Pleroma.RepoStreamer
30 alias Pleroma.UserRelationship
32 alias Pleroma.Web.ActivityPub.ActivityPub
33 alias Pleroma.Web.ActivityPub.Builder
34 alias Pleroma.Web.ActivityPub.Pipeline
35 alias Pleroma.Web.ActivityPub.Utils
36 alias Pleroma.Web.CommonAPI
37 alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
38 alias Pleroma.Web.OAuth
39 alias Pleroma.Web.RelMe
40 alias Pleroma.Workers.BackgroundWorker
44 @type t :: %__MODULE__{}
45 @type account_status ::
48 | :password_reset_pending
49 | :confirmation_pending
51 @primary_key {:id, FlakeId.Ecto.CompatType, autogenerate: true}
53 # credo:disable-for-next-line Credo.Check.Readability.MaxLineLength
54 @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 # credo:disable-for-next-line Credo.Check.Readability.MaxLineLength
56 @url_regex ~r/https?:\/\/[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&\/=]*)/
58 @strict_local_nickname_regex ~r/^[a-zA-Z\d]+$/
59 @extended_local_nickname_regex ~r/^[a-zA-Z\d_-]+$/
61 # AP ID user relationships (blocks, mutes etc.)
62 # Format: [rel_type: [outgoing_rel: :outgoing_rel_target, incoming_rel: :incoming_rel_source]]
63 @user_relationships_config [
65 blocker_blocks: :blocked_users,
66 blockee_blocks: :blocker_users
69 muter_mutes: :muted_users,
70 mutee_mutes: :muter_users
73 reblog_muter_mutes: :reblog_muted_users,
74 reblog_mutee_mutes: :reblog_muter_users
77 notification_muter_mutes: :notification_muted_users,
78 notification_mutee_mutes: :notification_muter_users
80 # Note: `inverse_subscription` relationship is inverse: subscriber acts as relationship target
81 inverse_subscription: [
82 subscribee_subscriptions: :subscriber_users,
83 subscriber_subscriptions: :subscribee_users
89 field(:raw_bio, :string)
90 field(:email, :string)
92 field(:nickname, :string)
93 field(:password_hash, :string)
94 field(:password, :string, virtual: true)
95 field(:password_confirmation, :string, virtual: true)
97 field(:public_key, :string)
98 field(:ap_id, :string)
99 field(:avatar, :map, default: %{})
100 field(:local, :boolean, default: true)
101 field(:follower_address, :string)
102 field(:following_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(:locked, :boolean, default: false)
114 field(:confirmation_pending, :boolean, default: false)
115 field(:password_reset_pending, :boolean, default: false)
116 field(:approval_pending, :boolean, default: false)
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(:deactivated, :boolean, default: false)
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(:mastofe_settings, :map, default: nil)
128 field(:uri, ObjectValidators.Uri, default: nil)
129 field(:hide_followers_count, :boolean, default: false)
130 field(:hide_follows_count, :boolean, default: false)
131 field(:hide_followers, :boolean, default: false)
132 field(:hide_follows, :boolean, default: false)
133 field(:hide_favorites, :boolean, default: true)
134 field(:unread_conversation_count, :integer, default: 0)
135 field(:pinned_activities, {:array, :string}, default: [])
136 field(:email_notifications, :map, default: %{"digest" => false})
137 field(:mascot, :map, default: nil)
138 field(:emoji, :map, default: %{})
139 field(:pleroma_settings_store, :map, default: %{})
140 field(:fields, {:array, :map}, default: [])
141 field(:raw_fields, {:array, :map}, default: [])
142 field(:discoverable, :boolean, default: false)
143 field(:invisible, :boolean, default: false)
144 field(:allow_following_move, :boolean, default: true)
145 field(:skip_thread_containment, :boolean, default: false)
146 field(:actor_type, :string, default: "Person")
147 field(:also_known_as, {:array, :string}, default: [])
148 field(:inbox, :string)
149 field(:shared_inbox, :string)
150 field(:accepts_chat_messages, :boolean, default: nil)
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
222 restrict_deactivated(target_users_query)
228 # `def blocked_users/2`, `def muted_users/2`, `def reblog_muted_users/2`,
229 # `def notification_muted_users/2`, `def subscriber_users/2`
230 def unquote(outgoing_relation_target)(user, restrict_deactivated? \\ false) do
232 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
234 restrict_deactivated?
239 # `def blocked_users_ap_ids/2`, `def muted_users_ap_ids/2`, `def reblog_muted_users_ap_ids/2`,
240 # `def notification_muted_users_ap_ids/2`, `def subscriber_users_ap_ids/2`
241 def unquote(:"#{outgoing_relation_target}_ap_ids")(user, restrict_deactivated? \\ false) do
243 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
245 restrict_deactivated?
247 |> select([u], u.ap_id)
253 Dumps Flake Id to SQL-compatible format (16-byte UUID).
254 E.g. "9pQtDGXuq4p3VlcJEm" -> <<0, 0, 1, 110, 179, 218, 42, 92, 213, 41, 44, 227, 95, 213, 0, 0>>
256 def binary_id(source_id) when is_binary(source_id) do
257 with {:ok, dumped_id} <- FlakeId.Ecto.CompatType.dump(source_id) do
264 def binary_id(source_ids) when is_list(source_ids) do
265 Enum.map(source_ids, &binary_id/1)
268 def binary_id(%User{} = user), do: binary_id(user.id)
270 @doc "Returns status account"
271 @spec account_status(User.t()) :: account_status()
272 def account_status(%User{deactivated: true}), do: :deactivated
273 def account_status(%User{password_reset_pending: true}), do: :password_reset_pending
274 def account_status(%User{approval_pending: true}), do: :approval_pending
276 def account_status(%User{confirmation_pending: true}) do
277 if Config.get([:instance, :account_activation_required]) do
278 :confirmation_pending
284 def account_status(%User{}), do: :active
286 @spec visible_for(User.t(), User.t() | nil) ::
289 | :restricted_unauthenticated
291 | :confirmation_pending
292 def visible_for(user, for_user \\ nil)
294 def visible_for(%User{invisible: true}, _), do: :invisible
296 def visible_for(%User{id: user_id}, %User{id: user_id}), do: :visible
298 def visible_for(%User{} = user, nil) do
299 if restrict_unauthenticated?(user) do
300 :restrict_unauthenticated
302 visible_account_status(user)
306 def visible_for(%User{} = user, for_user) do
307 if superuser?(for_user) do
310 visible_account_status(user)
314 def visible_for(_, _), do: :invisible
316 defp restrict_unauthenticated?(%User{local: local}) do
317 config_key = if local, do: :local, else: :remote
319 Config.get([:restrict_unauthenticated, :profiles, config_key], false)
322 defp visible_account_status(user) do
323 status = account_status(user)
325 if status in [:active, :password_reset_pending] do
332 @spec superuser?(User.t()) :: boolean()
333 def superuser?(%User{local: true, is_admin: true}), do: true
334 def superuser?(%User{local: true, is_moderator: true}), do: true
335 def superuser?(_), do: false
337 @spec invisible?(User.t()) :: boolean()
338 def invisible?(%User{invisible: true}), do: true
339 def invisible?(_), do: false
341 def avatar_url(user, options \\ []) do
343 %{"url" => [%{"href" => href} | _]} ->
347 unless options[:no_default] do
348 Config.get([:assets, :default_user_avatar], "#{Web.base_url()}/images/avi.png")
353 def banner_url(user, options \\ []) do
355 %{"url" => [%{"href" => href} | _]} -> href
356 _ -> !options[:no_default] && "#{Web.base_url()}/images/banner.png"
360 # Should probably be renamed or removed
361 def ap_id(%User{nickname: nickname}), do: "#{Web.base_url()}/users/#{nickname}"
363 def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
364 def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"
366 @spec ap_following(User.t()) :: String.t()
367 def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
368 def ap_following(%User{} = user), do: "#{ap_id(user)}/following"
370 @spec restrict_deactivated(Ecto.Query.t()) :: Ecto.Query.t()
371 def restrict_deactivated(query) do
372 from(u in query, where: u.deactivated != ^true)
375 defdelegate following_count(user), to: FollowingRelationship
377 defp truncate_fields_param(params) do
378 if Map.has_key?(params, :fields) do
379 Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
385 defp truncate_if_exists(params, key, max_length) do
386 if Map.has_key?(params, key) and is_binary(params[key]) do
387 {value, _chopped} = String.split_at(params[key], max_length)
388 Map.put(params, key, value)
394 defp fix_follower_address(%{follower_address: _, following_address: _} = params), do: params
396 defp fix_follower_address(%{nickname: nickname} = params),
397 do: Map.put(params, :follower_address, ap_followers(%User{nickname: nickname}))
399 defp fix_follower_address(params), do: params
401 def remote_user_changeset(struct \\ %User{local: false}, params) do
402 bio_limit = Config.get([:instance, :user_bio_length], 5000)
403 name_limit = Config.get([:instance, :user_name_length], 100)
406 case params[:name] do
407 name when is_binary(name) and byte_size(name) > 0 -> name
408 _ -> params[:nickname]
413 |> Map.put(:name, name)
414 |> Map.put_new(:last_refreshed_at, NaiveDateTime.utc_now())
415 |> truncate_if_exists(:name, name_limit)
416 |> truncate_if_exists(:bio, bio_limit)
417 |> truncate_fields_param()
418 |> fix_follower_address()
442 :hide_followers_count,
451 :accepts_chat_messages
454 |> validate_required([:name, :ap_id])
455 |> unique_constraint(:nickname)
456 |> validate_format(:nickname, @email_regex)
457 |> validate_length(:bio, max: bio_limit)
458 |> validate_length(:name, max: name_limit)
459 |> validate_fields(true)
462 def update_changeset(struct, params \\ %{}) do
463 bio_limit = Config.get([:instance, :user_bio_length], 5000)
464 name_limit = Config.get([:instance, :user_name_length], 100)
484 :hide_followers_count,
487 :allow_following_move,
491 :skip_thread_containment,
494 :pleroma_settings_store,
497 :accepts_chat_messages
500 |> unique_constraint(:nickname)
501 |> validate_format(:nickname, local_nickname_regex())
502 |> validate_also_known_as()
503 |> validate_length(:bio, max: bio_limit)
504 |> validate_length(:name, min: 1, max: name_limit)
505 |> validate_inclusion(:actor_type, ["Person", "Service"])
508 |> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
509 |> put_change_if_present(:avatar, &put_upload(&1, :avatar))
510 |> put_change_if_present(:banner, &put_upload(&1, :banner))
511 |> put_change_if_present(:background, &put_upload(&1, :background))
512 |> put_change_if_present(
513 :pleroma_settings_store,
514 &{:ok, Map.merge(struct.pleroma_settings_store, &1)}
516 |> validate_fields(false)
519 defp put_fields(changeset) do
520 if raw_fields = get_change(changeset, :raw_fields) do
523 |> Enum.filter(fn %{"name" => n} -> n != "" end)
527 |> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)
530 |> put_change(:raw_fields, raw_fields)
531 |> put_change(:fields, fields)
537 defp parse_fields(value) do
539 |> Formatter.linkify(mentions_format: :full)
543 defp put_emoji(changeset) do
544 emojified_fields = [:bio, :name, :raw_fields]
546 if Enum.any?(changeset.changes, fn {k, _} -> k in emojified_fields end) do
547 bio = Emoji.Formatter.get_emoji_map(get_field(changeset, :bio))
548 name = Emoji.Formatter.get_emoji_map(get_field(changeset, :name))
550 emoji = Map.merge(bio, name)
554 |> get_field(:raw_fields)
555 |> Enum.reduce(emoji, fn x, acc ->
556 Map.merge(acc, Emoji.Formatter.get_emoji_map(x["name"] <> x["value"]))
559 put_change(changeset, :emoji, emoji)
565 defp put_change_if_present(changeset, map_field, value_function) do
566 with {:ok, value} <- fetch_change(changeset, map_field),
567 {:ok, new_value} <- value_function.(value) do
568 put_change(changeset, map_field, new_value)
574 defp put_upload(value, type) do
575 with %Plug.Upload{} <- value,
576 {:ok, object} <- ActivityPub.upload(value, type: type) do
581 def update_as_admin_changeset(struct, params) do
583 |> update_changeset(params)
584 |> cast(params, [:email])
585 |> delete_change(:also_known_as)
586 |> unique_constraint(:email)
587 |> validate_format(:email, @email_regex)
588 |> validate_inclusion(:actor_type, ["Person", "Service"])
591 @spec update_as_admin(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
592 def update_as_admin(user, params) do
593 params = Map.put(params, "password_confirmation", params["password"])
594 changeset = update_as_admin_changeset(user, params)
596 if params["password"] do
597 reset_password(user, changeset, params)
599 User.update_and_set_cache(changeset)
603 def password_update_changeset(struct, params) do
605 |> cast(params, [:password, :password_confirmation])
606 |> validate_required([:password, :password_confirmation])
607 |> validate_confirmation(:password)
608 |> put_password_hash()
609 |> put_change(:password_reset_pending, false)
612 @spec reset_password(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
613 def reset_password(%User{} = user, params) do
614 reset_password(user, user, params)
617 def reset_password(%User{id: user_id} = user, struct, params) do
620 |> Multi.update(:user, password_update_changeset(struct, params))
621 |> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
622 |> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))
624 case Repo.transaction(multi) do
625 {:ok, %{user: user} = _} -> set_cache(user)
626 {:error, _, changeset, _} -> {:error, changeset}
630 def update_password_reset_pending(user, value) do
633 |> put_change(:password_reset_pending, value)
634 |> update_and_set_cache()
637 def force_password_reset_async(user) do
638 BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
641 @spec force_password_reset(User.t()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
642 def force_password_reset(user), do: update_password_reset_pending(user, true)
644 # Used to auto-register LDAP accounts which won't have a password hash stored locally
645 def register_changeset_ldap(struct, params = %{password: password})
646 when is_nil(password) do
647 params = Map.put_new(params, :accepts_chat_messages, true)
650 if Map.has_key?(params, :email) do
651 Map.put_new(params, :email, params[:email])
661 :accepts_chat_messages
663 |> validate_required([:name, :nickname])
664 |> unique_constraint(:nickname)
665 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
666 |> validate_format(:nickname, local_nickname_regex())
668 |> unique_constraint(:ap_id)
669 |> put_following_and_follower_address()
672 def register_changeset(struct, params \\ %{}, opts \\ []) do
673 bio_limit = Config.get([:instance, :user_bio_length], 5000)
674 name_limit = Config.get([:instance, :user_name_length], 100)
675 reason_limit = Config.get([:instance, :registration_reason_length], 500)
676 params = Map.put_new(params, :accepts_chat_messages, true)
679 if is_nil(opts[:need_confirmation]) do
680 Config.get([:instance, :account_activation_required])
682 opts[:need_confirmation]
686 if is_nil(opts[:need_approval]) do
687 Config.get([:instance, :account_approval_required])
693 |> confirmation_changeset(need_confirmation: need_confirmation?)
694 |> approval_changeset(need_approval: need_approval?)
702 :password_confirmation,
704 :accepts_chat_messages,
707 |> validate_required([:name, :nickname, :password, :password_confirmation])
708 |> validate_confirmation(:password)
709 |> unique_constraint(:email)
710 |> validate_format(:email, @email_regex)
711 |> validate_change(:email, fn :email, email ->
713 Config.get([User, :email_blacklist])
714 |> Enum.all?(fn blacklisted_domain ->
715 !String.ends_with?(email, ["@" <> blacklisted_domain, "." <> blacklisted_domain])
718 if valid?, do: [], else: [email: "Invalid email"]
720 |> unique_constraint(:nickname)
721 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
722 |> validate_format(:nickname, local_nickname_regex())
723 |> validate_length(:bio, max: bio_limit)
724 |> validate_length(:name, min: 1, max: name_limit)
725 |> validate_length(:registration_reason, max: reason_limit)
726 |> maybe_validate_required_email(opts[:external])
729 |> unique_constraint(:ap_id)
730 |> put_following_and_follower_address()
733 def maybe_validate_required_email(changeset, true), do: changeset
735 def maybe_validate_required_email(changeset, _) do
736 if Config.get([:instance, :account_activation_required]) do
737 validate_required(changeset, [:email])
743 defp put_ap_id(changeset) do
744 ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
745 put_change(changeset, :ap_id, ap_id)
748 defp put_following_and_follower_address(changeset) do
749 followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
752 |> put_change(:follower_address, followers)
755 defp autofollow_users(user) do
756 candidates = Config.get([:instance, :autofollowed_nicknames])
759 User.Query.build(%{nickname: candidates, local: true, deactivated: false})
762 follow_all(user, autofollowed_users)
765 @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
766 def register(%Ecto.Changeset{} = changeset) do
767 with {:ok, user} <- Repo.insert(changeset) do
768 post_register_action(user)
772 def post_register_action(%User{} = user) do
773 with {:ok, user} <- autofollow_users(user),
774 {:ok, user} <- set_cache(user),
775 {:ok, _} <- send_welcome_email(user),
776 {:ok, _} <- send_welcome_message(user),
777 {:ok, _} <- send_welcome_chat_message(user),
778 {:ok, _} <- try_send_confirmation_email(user) do
783 def send_welcome_message(user) do
784 if User.WelcomeMessage.enabled?() do
785 User.WelcomeMessage.post_message(user)
792 def send_welcome_chat_message(user) do
793 if User.WelcomeChatMessage.enabled?() do
794 User.WelcomeChatMessage.post_message(user)
801 def send_welcome_email(%User{email: email} = user) when is_binary(email) do
802 if User.WelcomeEmail.enabled?() do
803 User.WelcomeEmail.send_email(user)
810 def send_welcome_email(_), do: {:ok, :noop}
812 @spec try_send_confirmation_email(User.t()) :: {:ok, :enqueued | :noop}
813 def try_send_confirmation_email(%User{confirmation_pending: true} = user) do
814 if Config.get([:instance, :account_activation_required]) do
815 send_confirmation_email(user)
822 def try_send_confirmation_email(_), do: {:ok, :noop}
824 @spec send_confirmation_email(Uset.t()) :: User.t()
825 def send_confirmation_email(%User{} = user) do
827 |> Pleroma.Emails.UserEmail.account_confirmation_email()
828 |> Pleroma.Emails.Mailer.deliver_async()
833 def needs_update?(%User{local: true}), do: false
835 def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
837 def needs_update?(%User{local: false} = user) do
838 NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
841 def needs_update?(_), do: true
843 @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
845 # "Locked" (self-locked) users demand explicit authorization of follow requests
846 def maybe_direct_follow(%User{} = follower, %User{local: true, locked: true} = followed) do
847 follow(follower, followed, :follow_pending)
850 def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
851 follow(follower, followed)
854 def maybe_direct_follow(%User{} = follower, %User{} = followed) do
855 if not ap_enabled?(followed) do
856 follow(follower, followed)
862 @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
863 @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
864 def follow_all(follower, followeds) do
866 |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
867 |> Enum.each(&follow(follower, &1, :follow_accept))
872 defdelegate following(user), to: FollowingRelationship
874 def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
875 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
878 followed.deactivated ->
879 {:error, "Could not follow user: #{followed.nickname} is deactivated."}
881 deny_follow_blocked and blocks?(followed, follower) ->
882 {:error, "Could not follow user: #{followed.nickname} blocked you."}
885 FollowingRelationship.follow(follower, followed, state)
887 {:ok, _} = update_follower_count(followed)
890 |> update_following_count()
894 def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
895 {:error, "Not subscribed!"}
898 @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
899 def unfollow(%User{} = follower, %User{} = followed) do
900 case do_unfollow(follower, followed) do
901 {:ok, follower, followed} ->
902 {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
909 @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
910 defp do_unfollow(%User{} = follower, %User{} = followed) do
911 case get_follow_state(follower, followed) do
912 state when state in [:follow_pending, :follow_accept] ->
913 FollowingRelationship.unfollow(follower, followed)
914 {:ok, followed} = update_follower_count(followed)
918 |> update_following_count()
920 {:ok, follower, followed}
923 {:error, "Not subscribed!"}
927 defdelegate following?(follower, followed), to: FollowingRelationship
929 @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
930 def get_follow_state(%User{} = follower, %User{} = following) do
931 following_relationship = FollowingRelationship.get(follower, following)
932 get_follow_state(follower, following, following_relationship)
935 def get_follow_state(
938 following_relationship
940 case {following_relationship, following.local} do
942 case Utils.fetch_latest_follow(follower, following) do
943 %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
944 FollowingRelationship.state_to_enum(state)
950 {%{state: state}, _} ->
958 def locked?(%User{} = user) do
963 Repo.get_by(User, id: id)
966 def get_by_ap_id(ap_id) do
967 Repo.get_by(User, ap_id: ap_id)
970 def get_all_by_ap_id(ap_ids) do
971 from(u in __MODULE__,
972 where: u.ap_id in ^ap_ids
977 def get_all_by_ids(ids) do
978 from(u in __MODULE__, where: u.id in ^ids)
982 # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
983 # of the ap_id and the domain and tries to get that user
984 def get_by_guessed_nickname(ap_id) do
985 domain = URI.parse(ap_id).host
986 name = List.last(String.split(ap_id, "/"))
987 nickname = "#{name}@#{domain}"
989 get_cached_by_nickname(nickname)
992 def set_cache({:ok, user}), do: set_cache(user)
993 def set_cache({:error, err}), do: {:error, err}
995 def set_cache(%User{} = user) do
996 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
997 Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
998 Cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
1002 def update_and_set_cache(struct, params) do
1004 |> update_changeset(params)
1005 |> update_and_set_cache()
1008 def update_and_set_cache(changeset) do
1009 with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
1014 def get_user_friends_ap_ids(user) do
1015 from(u in User.get_friends_query(user), select: u.ap_id)
1019 @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
1020 def get_cached_user_friends_ap_ids(user) do
1021 Cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
1022 get_user_friends_ap_ids(user)
1026 def invalidate_cache(user) do
1027 Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
1028 Cachex.del(:user_cache, "nickname:#{user.nickname}")
1029 Cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
1032 @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
1033 def get_cached_by_ap_id(ap_id) do
1034 key = "ap_id:#{ap_id}"
1036 with {:ok, nil} <- Cachex.get(:user_cache, key),
1037 user when not is_nil(user) <- get_by_ap_id(ap_id),
1038 {:ok, true} <- Cachex.put(:user_cache, key, user) do
1046 def get_cached_by_id(id) do
1050 Cachex.fetch!(:user_cache, key, fn _ ->
1051 user = get_by_id(id)
1054 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1055 {:commit, user.ap_id}
1061 get_cached_by_ap_id(ap_id)
1064 def get_cached_by_nickname(nickname) do
1065 key = "nickname:#{nickname}"
1067 Cachex.fetch!(:user_cache, key, fn ->
1068 case get_or_fetch_by_nickname(nickname) do
1069 {:ok, user} -> {:commit, user}
1070 {:error, _error} -> {:ignore, nil}
1075 def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
1076 restrict_to_local = Config.get([:instance, :limit_to_local_content])
1079 is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
1080 get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
1082 restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
1083 get_cached_by_nickname(nickname_or_id)
1085 restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
1086 get_cached_by_nickname(nickname_or_id)
1093 @spec get_by_nickname(String.t()) :: User.t() | nil
1094 def get_by_nickname(nickname) do
1095 Repo.get_by(User, nickname: nickname) ||
1096 if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
1097 Repo.get_by(User, nickname: local_nickname(nickname))
1101 def get_by_email(email), do: Repo.get_by(User, email: email)
1103 def get_by_nickname_or_email(nickname_or_email) do
1104 get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
1107 def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
1109 def get_or_fetch_by_nickname(nickname) do
1110 with %User{} = user <- get_by_nickname(nickname) do
1114 with [_nick, _domain] <- String.split(nickname, "@"),
1115 {:ok, user} <- fetch_by_nickname(nickname) do
1118 _e -> {:error, "not found " <> nickname}
1123 @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1124 def get_followers_query(%User{} = user, nil) do
1125 User.Query.build(%{followers: user, deactivated: false})
1128 def get_followers_query(user, page) do
1130 |> get_followers_query(nil)
1131 |> User.Query.paginate(page, 20)
1134 @spec get_followers_query(User.t()) :: Ecto.Query.t()
1135 def get_followers_query(user), do: get_followers_query(user, nil)
1137 @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1138 def get_followers(user, page \\ nil) do
1140 |> get_followers_query(page)
1144 @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1145 def get_external_followers(user, page \\ nil) do
1147 |> get_followers_query(page)
1148 |> User.Query.build(%{external: true})
1152 def get_followers_ids(user, page \\ nil) do
1154 |> get_followers_query(page)
1155 |> select([u], u.id)
1159 @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1160 def get_friends_query(%User{} = user, nil) do
1161 User.Query.build(%{friends: user, deactivated: false})
1164 def get_friends_query(user, page) do
1166 |> get_friends_query(nil)
1167 |> User.Query.paginate(page, 20)
1170 @spec get_friends_query(User.t()) :: Ecto.Query.t()
1171 def get_friends_query(user), do: get_friends_query(user, nil)
1173 def get_friends(user, page \\ nil) do
1175 |> get_friends_query(page)
1179 def get_friends_ap_ids(user) do
1181 |> get_friends_query(nil)
1182 |> select([u], u.ap_id)
1186 def get_friends_ids(user, page \\ nil) do
1188 |> get_friends_query(page)
1189 |> select([u], u.id)
1193 defdelegate get_follow_requests(user), to: FollowingRelationship
1195 def increase_note_count(%User{} = user) do
1197 |> where(id: ^user.id)
1198 |> update([u], inc: [note_count: 1])
1200 |> Repo.update_all([])
1202 {1, [user]} -> set_cache(user)
1207 def decrease_note_count(%User{} = user) do
1209 |> where(id: ^user.id)
1212 note_count: fragment("greatest(0, note_count - 1)")
1216 |> Repo.update_all([])
1218 {1, [user]} -> set_cache(user)
1223 def update_note_count(%User{} = user, note_count \\ nil) do
1228 where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1234 |> cast(%{note_count: note_count}, [:note_count])
1235 |> update_and_set_cache()
1238 @spec maybe_fetch_follow_information(User.t()) :: User.t()
1239 def maybe_fetch_follow_information(user) do
1240 with {:ok, user} <- fetch_follow_information(user) do
1244 Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1250 def fetch_follow_information(user) do
1251 with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1253 |> follow_information_changeset(info)
1254 |> update_and_set_cache()
1258 defp follow_information_changeset(user, params) do
1265 :hide_followers_count,
1270 @spec update_follower_count(User.t()) :: {:ok, User.t()}
1271 def update_follower_count(%User{} = user) do
1272 if user.local or !Config.get([:instance, :external_user_synchronization]) do
1273 follower_count = FollowingRelationship.follower_count(user)
1276 |> follow_information_changeset(%{follower_count: follower_count})
1277 |> update_and_set_cache
1279 {:ok, maybe_fetch_follow_information(user)}
1283 @spec update_following_count(User.t()) :: {:ok, User.t()}
1284 def update_following_count(%User{local: false} = user) do
1285 if Config.get([:instance, :external_user_synchronization]) do
1286 {:ok, maybe_fetch_follow_information(user)}
1292 def update_following_count(%User{local: true} = user) do
1293 following_count = FollowingRelationship.following_count(user)
1296 |> follow_information_changeset(%{following_count: following_count})
1297 |> update_and_set_cache()
1300 def set_unread_conversation_count(%User{local: true} = user) do
1301 unread_query = Participation.unread_conversation_count_for_user(user)
1304 |> join(:inner, [u], p in subquery(unread_query))
1306 set: [unread_conversation_count: p.count]
1308 |> where([u], u.id == ^user.id)
1310 |> Repo.update_all([])
1312 {1, [user]} -> set_cache(user)
1317 def set_unread_conversation_count(user), do: {:ok, user}
1319 def increment_unread_conversation_count(conversation, %User{local: true} = user) do
1321 Participation.unread_conversation_count_for_user(user)
1322 |> where([p], p.conversation_id == ^conversation.id)
1325 |> join(:inner, [u], p in subquery(unread_query))
1327 inc: [unread_conversation_count: 1]
1329 |> where([u], u.id == ^user.id)
1330 |> where([u, p], p.count == 0)
1332 |> Repo.update_all([])
1334 {1, [user]} -> set_cache(user)
1339 def increment_unread_conversation_count(_, user), do: {:ok, user}
1341 @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1342 def get_users_from_set(ap_ids, opts \\ []) do
1343 local_only = Keyword.get(opts, :local_only, true)
1344 criteria = %{ap_id: ap_ids, deactivated: false}
1345 criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1347 User.Query.build(criteria)
1351 @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1352 def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1355 query = User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
1361 @spec mute(User.t(), User.t(), boolean()) ::
1362 {:ok, list(UserRelationship.t())} | {:error, String.t()}
1363 def mute(%User{} = muter, %User{} = mutee, notifications? \\ true) do
1364 add_to_mutes(muter, mutee, notifications?)
1367 def unmute(%User{} = muter, %User{} = mutee) do
1368 remove_from_mutes(muter, mutee)
1371 def subscribe(%User{} = subscriber, %User{} = target) do
1372 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
1374 if blocks?(target, subscriber) and deny_follow_blocked do
1375 {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1377 # Note: the relationship is inverse: subscriber acts as relationship target
1378 UserRelationship.create_inverse_subscription(target, subscriber)
1382 def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1383 with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1384 subscribe(subscriber, subscribee)
1388 def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1389 # Note: the relationship is inverse: subscriber acts as relationship target
1390 UserRelationship.delete_inverse_subscription(target, unsubscriber)
1393 def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1394 with %User{} = user <- get_cached_by_ap_id(ap_id) do
1395 unsubscribe(unsubscriber, user)
1399 def block(%User{} = blocker, %User{} = blocked) do
1400 # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1402 if following?(blocker, blocked) do
1403 {:ok, blocker, _} = unfollow(blocker, blocked)
1409 # clear any requested follows as well
1411 case CommonAPI.reject_follow_request(blocked, blocker) do
1412 {:ok, %User{} = updated_blocked} -> updated_blocked
1416 unsubscribe(blocked, blocker)
1418 unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
1419 if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)
1421 {:ok, blocker} = update_follower_count(blocker)
1422 {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1423 add_to_block(blocker, blocked)
1426 # helper to handle the block given only an actor's AP id
1427 def block(%User{} = blocker, %{ap_id: ap_id}) do
1428 block(blocker, get_cached_by_ap_id(ap_id))
1431 def unblock(%User{} = blocker, %User{} = blocked) do
1432 remove_from_block(blocker, blocked)
1435 # helper to handle the block given only an actor's AP id
1436 def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1437 unblock(blocker, get_cached_by_ap_id(ap_id))
1440 def mutes?(nil, _), do: false
1441 def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1443 def mutes_user?(%User{} = user, %User{} = target) do
1444 UserRelationship.mute_exists?(user, target)
1447 @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1448 def muted_notifications?(nil, _), do: false
1450 def muted_notifications?(%User{} = user, %User{} = target),
1451 do: UserRelationship.notification_mute_exists?(user, target)
1453 def blocks?(nil, _), do: false
1455 def blocks?(%User{} = user, %User{} = target) do
1456 blocks_user?(user, target) ||
1457 (blocks_domain?(user, target) and not User.following?(user, target))
1460 def blocks_user?(%User{} = user, %User{} = target) do
1461 UserRelationship.block_exists?(user, target)
1464 def blocks_user?(_, _), do: false
1466 def blocks_domain?(%User{} = user, %User{} = target) do
1467 domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1468 %{host: host} = URI.parse(target.ap_id)
1469 Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1472 def blocks_domain?(_, _), do: false
1474 def subscribed_to?(%User{} = user, %User{} = target) do
1475 # Note: the relationship is inverse: subscriber acts as relationship target
1476 UserRelationship.inverse_subscription_exists?(target, user)
1479 def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1480 with %User{} = target <- get_cached_by_ap_id(ap_id) do
1481 subscribed_to?(user, target)
1486 Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1487 E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1489 @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1490 def outgoing_relationships_ap_ids(_user, []), do: %{}
1492 def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1494 def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1495 when is_list(relationship_types) do
1498 |> assoc(:outgoing_relationships)
1499 |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1500 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1501 |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1502 |> group_by([user_rel, u], user_rel.relationship_type)
1504 |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1509 fn rel_type -> {rel_type, db_result[rel_type] || []} end
1513 def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1515 def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1517 def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1519 def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1520 when is_list(relationship_types) do
1522 |> assoc(:incoming_relationships)
1523 |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1524 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1525 |> maybe_filter_on_ap_id(ap_ids)
1526 |> select([user_rel, u], u.ap_id)
1531 defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1532 where(query, [user_rel, u], u.ap_id in ^ap_ids)
1535 defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1537 def deactivate_async(user, status \\ true) do
1538 BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
1541 def deactivate(user, status \\ true)
1543 def deactivate(users, status) when is_list(users) do
1544 Repo.transaction(fn ->
1545 for user <- users, do: deactivate(user, status)
1549 def deactivate(%User{} = user, status) do
1550 with {:ok, user} <- set_activation_status(user, status) do
1553 |> Enum.filter(& &1.local)
1554 |> Enum.each(&set_cache(update_following_count(&1)))
1556 # Only update local user counts, remote will be update during the next pull.
1559 |> Enum.filter(& &1.local)
1560 |> Enum.each(&do_unfollow(user, &1))
1566 def approve(users) when is_list(users) do
1567 Repo.transaction(fn ->
1568 Enum.map(users, fn user ->
1569 with {:ok, user} <- approve(user), do: user
1574 def approve(%User{} = user) do
1575 change(user, approval_pending: false)
1576 |> update_and_set_cache()
1579 def update_notification_settings(%User{} = user, settings) do
1581 |> cast(%{notification_settings: settings}, [])
1582 |> cast_embed(:notification_settings)
1583 |> validate_required([:notification_settings])
1584 |> update_and_set_cache()
1587 def delete(users) when is_list(users) do
1588 for user <- users, do: delete(user)
1591 def delete(%User{} = user) do
1592 BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1595 defp delete_and_invalidate_cache(%User{} = user) do
1596 invalidate_cache(user)
1600 defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)
1602 defp delete_or_deactivate(%User{local: true} = user) do
1603 status = account_status(user)
1606 :confirmation_pending ->
1607 delete_and_invalidate_cache(user)
1609 :approval_pending ->
1610 delete_and_invalidate_cache(user)
1614 |> change(%{deactivated: true, email: nil})
1615 |> update_and_set_cache()
1619 def perform(:force_password_reset, user), do: force_password_reset(user)
1621 @spec perform(atom(), User.t()) :: {:ok, User.t()}
1622 def perform(:delete, %User{} = user) do
1623 # Remove all relationships
1626 |> Enum.each(fn follower ->
1627 ActivityPub.unfollow(follower, user)
1628 unfollow(follower, user)
1633 |> Enum.each(fn followed ->
1634 ActivityPub.unfollow(user, followed)
1635 unfollow(user, followed)
1638 delete_user_activities(user)
1639 delete_notifications_from_user_activities(user)
1641 delete_outgoing_pending_follow_requests(user)
1643 delete_or_deactivate(user)
1646 def perform(:deactivate_async, user, status), do: deactivate(user, status)
1648 @spec perform(atom(), User.t(), list()) :: list() | {:error, any()}
1649 def perform(:blocks_import, %User{} = blocker, blocked_identifiers)
1650 when is_list(blocked_identifiers) do
1652 blocked_identifiers,
1653 fn blocked_identifier ->
1654 with {:ok, %User{} = blocked} <- get_or_fetch(blocked_identifier),
1655 {:ok, _block} <- CommonAPI.block(blocker, blocked) do
1659 Logger.debug("blocks_import failed for #{blocked_identifier} with: #{inspect(err)}")
1666 def perform(:follow_import, %User{} = follower, followed_identifiers)
1667 when is_list(followed_identifiers) do
1669 followed_identifiers,
1670 fn followed_identifier ->
1671 with {:ok, %User{} = followed} <- get_or_fetch(followed_identifier),
1672 {:ok, follower} <- maybe_direct_follow(follower, followed),
1673 {:ok, _, _, _} <- CommonAPI.follow(follower, followed) do
1677 Logger.debug("follow_import failed for #{followed_identifier} with: #{inspect(err)}")
1684 @spec external_users_query() :: Ecto.Query.t()
1685 def external_users_query do
1693 @spec external_users(keyword()) :: [User.t()]
1694 def external_users(opts \\ []) do
1696 external_users_query()
1697 |> select([u], struct(u, [:id, :ap_id]))
1701 do: where(query, [u], u.id > ^opts[:max_id]),
1706 do: limit(query, ^opts[:limit]),
1712 def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers) do
1713 BackgroundWorker.enqueue("blocks_import", %{
1714 "blocker_id" => blocker.id,
1715 "blocked_identifiers" => blocked_identifiers
1719 def follow_import(%User{} = follower, followed_identifiers)
1720 when is_list(followed_identifiers) do
1721 BackgroundWorker.enqueue("follow_import", %{
1722 "follower_id" => follower.id,
1723 "followed_identifiers" => followed_identifiers
1727 def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1729 |> join(:inner, [n], activity in assoc(n, :activity))
1730 |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1731 |> Repo.delete_all()
1734 def delete_user_activities(%User{ap_id: ap_id} = user) do
1736 |> Activity.Queries.by_actor()
1737 |> RepoStreamer.chunk_stream(50)
1738 |> Stream.each(fn activities ->
1739 Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1744 defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1745 with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1746 {:ok, delete_data, _} <- Builder.delete(user, object) do
1747 Pipeline.common_pipeline(delete_data, local: user.local)
1749 {:find_object, nil} ->
1750 # We have the create activity, but not the object, it was probably pruned.
1751 # Insert a tombstone and try again
1752 with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1753 {:ok, _tombstone} <- Object.create(tombstone_data) do
1754 delete_activity(activity, user)
1758 Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1759 Logger.error("Error: #{inspect(e)}")
1763 defp delete_activity(%{data: %{"type" => type}} = activity, user)
1764 when type in ["Like", "Announce"] do
1765 {:ok, undo, _} = Builder.undo(user, activity)
1766 Pipeline.common_pipeline(undo, local: user.local)
1769 defp delete_activity(_activity, _user), do: "Doing nothing"
1771 defp delete_outgoing_pending_follow_requests(user) do
1773 |> FollowingRelationship.outgoing_pending_follow_requests_query()
1774 |> Repo.delete_all()
1777 def html_filter_policy(%User{no_rich_text: true}) do
1778 Pleroma.HTML.Scrubber.TwitterText
1781 def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])
1783 def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1785 def get_or_fetch_by_ap_id(ap_id) do
1786 cached_user = get_cached_by_ap_id(ap_id)
1788 maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)
1790 case {cached_user, maybe_fetched_user} do
1791 {_, {:ok, %User{} = user}} ->
1794 {%User{} = user, _} ->
1798 {:error, :not_found}
1803 Creates an internal service actor by URI if missing.
1804 Optionally takes nickname for addressing.
1806 @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1807 def get_or_create_service_actor_by_ap_id(uri, nickname) do
1809 case get_cached_by_ap_id(uri) do
1811 with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1812 Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1816 %User{invisible: false} = user ->
1826 @spec set_invisible(User.t()) :: {:ok, User.t()}
1827 defp set_invisible(user) do
1829 |> change(%{invisible: true})
1830 |> update_and_set_cache()
1833 @spec create_service_actor(String.t(), String.t()) ::
1834 {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1835 defp create_service_actor(uri, nickname) do
1841 follower_address: uri <> "/followers"
1844 |> unique_constraint(:nickname)
1849 def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1852 |> :public_key.pem_decode()
1854 |> :public_key.pem_entry_decode()
1859 def public_key(_), do: {:error, "key not found"}
1861 def get_public_key_for_ap_id(ap_id) do
1862 with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1863 {:ok, public_key} <- public_key(user) do
1870 def ap_enabled?(%User{local: true}), do: true
1871 def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1872 def ap_enabled?(_), do: false
1874 @doc "Gets or fetch a user by uri or nickname."
1875 @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1876 def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1877 def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1879 # wait a period of time and return newest version of the User structs
1880 # this is because we have synchronous follow APIs and need to simulate them
1881 # with an async handshake
1882 def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1883 with %User{} = a <- get_cached_by_id(a.id),
1884 %User{} = b <- get_cached_by_id(b.id) do
1891 def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1892 with :ok <- :timer.sleep(timeout),
1893 %User{} = a <- get_cached_by_id(a.id),
1894 %User{} = b <- get_cached_by_id(b.id) do
1901 def parse_bio(bio) when is_binary(bio) and bio != "" do
1903 |> CommonUtils.format_input("text/plain", mentions_format: :full)
1907 def parse_bio(_), do: ""
1909 def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1910 # TODO: get profile URLs other than user.ap_id
1911 profile_urls = [user.ap_id]
1914 |> CommonUtils.format_input("text/plain",
1915 mentions_format: :full,
1916 rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1921 def parse_bio(_, _), do: ""
1923 def tag(user_identifiers, tags) when is_list(user_identifiers) do
1924 Repo.transaction(fn ->
1925 for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1929 def tag(nickname, tags) when is_binary(nickname),
1930 do: tag(get_by_nickname(nickname), tags)
1932 def tag(%User{} = user, tags),
1933 do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1935 def untag(user_identifiers, tags) when is_list(user_identifiers) do
1936 Repo.transaction(fn ->
1937 for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1941 def untag(nickname, tags) when is_binary(nickname),
1942 do: untag(get_by_nickname(nickname), tags)
1944 def untag(%User{} = user, tags),
1945 do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1947 defp update_tags(%User{} = user, new_tags) do
1948 {:ok, updated_user} =
1950 |> change(%{tags: new_tags})
1951 |> update_and_set_cache()
1956 defp normalize_tags(tags) do
1959 |> Enum.map(&String.downcase/1)
1962 defp local_nickname_regex do
1963 if Config.get([:instance, :extended_nickname_format]) do
1964 @extended_local_nickname_regex
1966 @strict_local_nickname_regex
1970 def local_nickname(nickname_or_mention) do
1973 |> String.split("@")
1977 def full_nickname(nickname_or_mention),
1978 do: String.trim_leading(nickname_or_mention, "@")
1980 def error_user(ap_id) do
1984 nickname: "erroruser@example.com",
1985 inserted_at: NaiveDateTime.utc_now()
1989 @spec all_superusers() :: [User.t()]
1990 def all_superusers do
1991 User.Query.build(%{super_users: true, local: true, deactivated: false})
1995 def muting_reblogs?(%User{} = user, %User{} = target) do
1996 UserRelationship.reblog_mute_exists?(user, target)
1999 def showing_reblogs?(%User{} = user, %User{} = target) do
2000 not muting_reblogs?(user, target)
2004 The function returns a query to get users with no activity for given interval of days.
2005 Inactive users are those who didn't read any notification, or had any activity where
2006 the user is the activity's actor, during `inactivity_threshold` days.
2007 Deactivated users will not appear in this list.
2011 iex> Pleroma.User.list_inactive_users()
2014 @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
2015 def list_inactive_users_query(inactivity_threshold \\ 7) do
2016 negative_inactivity_threshold = -inactivity_threshold
2017 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2018 # Subqueries are not supported in `where` clauses, join gets too complicated.
2019 has_read_notifications =
2020 from(n in Pleroma.Notification,
2021 where: n.seen == true,
2023 having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
2026 |> Pleroma.Repo.all()
2028 from(u in Pleroma.User,
2029 left_join: a in Pleroma.Activity,
2030 on: u.ap_id == a.actor,
2031 where: not is_nil(u.nickname),
2032 where: u.deactivated != ^true,
2033 where: u.id not in ^has_read_notifications,
2036 max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
2037 is_nil(max(a.inserted_at))
2042 Enable or disable email notifications for user
2046 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
2047 Pleroma.User{email_notifications: %{"digest" => true}}
2049 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
2050 Pleroma.User{email_notifications: %{"digest" => false}}
2052 @spec switch_email_notifications(t(), String.t(), boolean()) ::
2053 {:ok, t()} | {:error, Ecto.Changeset.t()}
2054 def switch_email_notifications(user, type, status) do
2055 User.update_email_notifications(user, %{type => status})
2059 Set `last_digest_emailed_at` value for the user to current time
2061 @spec touch_last_digest_emailed_at(t()) :: t()
2062 def touch_last_digest_emailed_at(user) do
2063 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2065 {:ok, updated_user} =
2067 |> change(%{last_digest_emailed_at: now})
2068 |> update_and_set_cache()
2073 @spec toggle_confirmation(User.t()) :: {:ok, User.t()} | {:error, Changeset.t()}
2074 def toggle_confirmation(%User{} = user) do
2076 |> confirmation_changeset(need_confirmation: !user.confirmation_pending)
2077 |> update_and_set_cache()
2080 @spec toggle_confirmation([User.t()]) :: [{:ok, User.t()} | {:error, Changeset.t()}]
2081 def toggle_confirmation(users) do
2082 Enum.map(users, &toggle_confirmation/1)
2085 def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
2089 def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
2090 # use instance-default
2091 config = Config.get([:assets, :mascots])
2092 default_mascot = Config.get([:assets, :default_mascot])
2093 mascot = Keyword.get(config, default_mascot)
2096 "id" => "default-mascot",
2097 "url" => mascot[:url],
2098 "preview_url" => mascot[:url],
2100 "mime_type" => mascot[:mime_type]
2105 def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
2107 def ensure_keys_present(%User{} = user) do
2108 with {:ok, pem} <- Keys.generate_rsa_pem() do
2110 |> cast(%{keys: pem}, [:keys])
2111 |> validate_required([:keys])
2112 |> update_and_set_cache()
2116 def get_ap_ids_by_nicknames(nicknames) do
2118 where: u.nickname in ^nicknames,
2124 defdelegate search(query, opts \\ []), to: User.Search
2126 defp put_password_hash(
2127 %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2129 change(changeset, password_hash: Pbkdf2.hash_pwd_salt(password))
2132 defp put_password_hash(changeset), do: changeset
2134 def is_internal_user?(%User{nickname: nil}), do: true
2135 def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2136 def is_internal_user?(_), do: false
2138 # A hack because user delete activities have a fake id for whatever reason
2139 # TODO: Get rid of this
2140 def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2142 def get_delivered_users_by_object_id(object_id) do
2144 inner_join: delivery in assoc(u, :deliveries),
2145 where: delivery.object_id == ^object_id
2150 def change_email(user, email) do
2152 |> cast(%{email: email}, [:email])
2153 |> validate_required([:email])
2154 |> unique_constraint(:email)
2155 |> validate_format(:email, @email_regex)
2156 |> update_and_set_cache()
2159 # Internal function; public one is `deactivate/2`
2160 defp set_activation_status(user, deactivated) do
2162 |> cast(%{deactivated: deactivated}, [:deactivated])
2163 |> update_and_set_cache()
2166 def update_banner(user, banner) do
2168 |> cast(%{banner: banner}, [:banner])
2169 |> update_and_set_cache()
2172 def update_background(user, background) do
2174 |> cast(%{background: background}, [:background])
2175 |> update_and_set_cache()
2178 def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
2181 moderator: is_moderator
2185 def validate_fields(changeset, remote? \\ false) do
2186 limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2187 limit = Config.get([:instance, limit_name], 0)
2190 |> validate_length(:fields, max: limit)
2191 |> validate_change(:fields, fn :fields, fields ->
2192 if Enum.all?(fields, &valid_field?/1) do
2200 defp valid_field?(%{"name" => name, "value" => value}) do
2201 name_limit = Config.get([:instance, :account_field_name_length], 255)
2202 value_limit = Config.get([:instance, :account_field_value_length], 255)
2204 is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2205 String.length(value) <= value_limit
2208 defp valid_field?(_), do: false
2210 defp truncate_field(%{"name" => name, "value" => value}) do
2212 String.split_at(name, Config.get([:instance, :account_field_name_length], 255))
2215 String.split_at(value, Config.get([:instance, :account_field_value_length], 255))
2217 %{"name" => name, "value" => value}
2220 def admin_api_update(user, params) do
2227 |> update_and_set_cache()
2230 @doc "Signs user out of all applications"
2231 def global_sign_out(user) do
2232 OAuth.Authorization.delete_user_authorizations(user)
2233 OAuth.Token.delete_user_tokens(user)
2236 def mascot_update(user, url) do
2238 |> cast(%{mascot: url}, [:mascot])
2239 |> validate_required([:mascot])
2240 |> update_and_set_cache()
2243 def mastodon_settings_update(user, settings) do
2245 |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
2246 |> validate_required([:mastofe_settings])
2247 |> update_and_set_cache()
2250 @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2251 def confirmation_changeset(user, need_confirmation: need_confirmation?) do
2253 if need_confirmation? do
2255 confirmation_pending: true,
2256 confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2260 confirmation_pending: false,
2261 confirmation_token: nil
2265 cast(user, params, [:confirmation_pending, :confirmation_token])
2268 @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
2269 def approval_changeset(user, need_approval: need_approval?) do
2270 params = if need_approval?, do: %{approval_pending: true}, else: %{approval_pending: false}
2271 cast(user, params, [:approval_pending])
2274 def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2275 if id not in user.pinned_activities do
2276 max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2277 params = %{pinned_activities: user.pinned_activities ++ [id]}
2280 |> cast(params, [:pinned_activities])
2281 |> validate_length(:pinned_activities,
2282 max: max_pinned_statuses,
2283 message: "You have already pinned the maximum number of statuses"
2288 |> update_and_set_cache()
2291 def remove_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2292 params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2295 |> cast(params, [:pinned_activities])
2296 |> update_and_set_cache()
2299 def update_email_notifications(user, settings) do
2300 email_notifications =
2301 user.email_notifications
2302 |> Map.merge(settings)
2303 |> Map.take(["digest"])
2305 params = %{email_notifications: email_notifications}
2306 fields = [:email_notifications]
2309 |> cast(params, fields)
2310 |> validate_required(fields)
2311 |> update_and_set_cache()
2314 defp set_domain_blocks(user, domain_blocks) do
2315 params = %{domain_blocks: domain_blocks}
2318 |> cast(params, [:domain_blocks])
2319 |> validate_required([:domain_blocks])
2320 |> update_and_set_cache()
2323 def block_domain(user, domain_blocked) do
2324 set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2327 def unblock_domain(user, domain_blocked) do
2328 set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2331 @spec add_to_block(User.t(), User.t()) ::
2332 {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2333 defp add_to_block(%User{} = user, %User{} = blocked) do
2334 UserRelationship.create_block(user, blocked)
2337 @spec add_to_block(User.t(), User.t()) ::
2338 {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2339 defp remove_from_block(%User{} = user, %User{} = blocked) do
2340 UserRelationship.delete_block(user, blocked)
2343 defp add_to_mutes(%User{} = user, %User{} = muted_user, notifications?) do
2344 with {:ok, user_mute} <- UserRelationship.create_mute(user, muted_user),
2345 {:ok, user_notification_mute} <-
2346 (notifications? && UserRelationship.create_notification_mute(user, muted_user)) ||
2348 {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
2352 defp remove_from_mutes(user, %User{} = muted_user) do
2353 with {:ok, user_mute} <- UserRelationship.delete_mute(user, muted_user),
2354 {:ok, user_notification_mute} <-
2355 UserRelationship.delete_notification_mute(user, muted_user) do
2356 {:ok, [user_mute, user_notification_mute]}
2360 def set_invisible(user, invisible) do
2361 params = %{invisible: invisible}
2364 |> cast(params, [:invisible])
2365 |> validate_required([:invisible])
2366 |> update_and_set_cache()
2369 def sanitize_html(%User{} = user) do
2370 sanitize_html(user, nil)
2373 # User data that mastodon isn't filtering (treated as plaintext):
2376 def sanitize_html(%User{} = user, filter) do
2378 Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2381 "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2386 |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2387 |> Map.put(:fields, fields)
2390 defp validate_also_known_as(changeset) do
2391 validate_change(changeset, :also_known_as, fn :also_known_as, also_known_as ->
2392 case Enum.all?(also_known_as, fn a -> Regex.match?(@url_regex, a) end) do
2394 false -> [also_known_as: "Invalid ap_id format. Must be a URL."]