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])?)*$/
56 @strict_local_nickname_regex ~r/^[a-zA-Z\d]+$/
57 @extended_local_nickname_regex ~r/^[a-zA-Z\d_-]+$/
59 # AP ID user relationships (blocks, mutes etc.)
60 # Format: [rel_type: [outgoing_rel: :outgoing_rel_target, incoming_rel: :incoming_rel_source]]
61 @user_relationships_config [
63 blocker_blocks: :blocked_users,
64 blockee_blocks: :blocker_users
67 muter_mutes: :muted_users,
68 mutee_mutes: :muter_users
71 reblog_muter_mutes: :reblog_muted_users,
72 reblog_mutee_mutes: :reblog_muter_users
75 notification_muter_mutes: :notification_muted_users,
76 notification_mutee_mutes: :notification_muter_users
78 # Note: `inverse_subscription` relationship is inverse: subscriber acts as relationship target
79 inverse_subscription: [
80 subscribee_subscriptions: :subscriber_users,
81 subscriber_subscriptions: :subscribee_users
87 field(:raw_bio, :string)
88 field(:email, :string)
90 field(:nickname, :string)
91 field(:password_hash, :string)
92 field(:password, :string, virtual: true)
93 field(:password_confirmation, :string, virtual: true)
95 field(:public_key, :string)
96 field(:ap_id, :string)
97 field(:avatar, :map, default: %{})
98 field(:local, :boolean, default: true)
99 field(:follower_address, :string)
100 field(:following_address, :string)
101 field(:search_rank, :float, virtual: true)
102 field(:search_type, :integer, virtual: true)
103 field(:tags, {:array, :string}, default: [])
104 field(:last_refreshed_at, :naive_datetime_usec)
105 field(:last_digest_emailed_at, :naive_datetime)
106 field(:banner, :map, default: %{})
107 field(:background, :map, default: %{})
108 field(:note_count, :integer, default: 0)
109 field(:follower_count, :integer, default: 0)
110 field(:following_count, :integer, default: 0)
111 field(:locked, :boolean, default: false)
112 field(:confirmation_pending, :boolean, default: false)
113 field(:password_reset_pending, :boolean, default: false)
114 field(:approval_pending, :boolean, default: false)
115 field(:registration_reason, :string, default: nil)
116 field(:confirmation_token, :string, default: nil)
117 field(:default_scope, :string, default: "public")
118 field(:domain_blocks, {:array, :string}, default: [])
119 field(:deactivated, :boolean, default: false)
120 field(:no_rich_text, :boolean, default: false)
121 field(:ap_enabled, :boolean, default: false)
122 field(:is_moderator, :boolean, default: false)
123 field(:is_admin, :boolean, default: false)
124 field(:show_role, :boolean, default: true)
125 field(:mastofe_settings, :map, default: nil)
126 field(:uri, ObjectValidators.Uri, default: nil)
127 field(:hide_followers_count, :boolean, default: false)
128 field(:hide_follows_count, :boolean, default: false)
129 field(:hide_followers, :boolean, default: false)
130 field(:hide_follows, :boolean, default: false)
131 field(:hide_favorites, :boolean, default: true)
132 field(:unread_conversation_count, :integer, default: 0)
133 field(:pinned_activities, {:array, :string}, default: [])
134 field(:email_notifications, :map, default: %{"digest" => false})
135 field(:mascot, :map, default: nil)
136 field(:emoji, :map, default: %{})
137 field(:pleroma_settings_store, :map, default: %{})
138 field(:fields, {:array, :map}, default: [])
139 field(:raw_fields, {:array, :map}, default: [])
140 field(:discoverable, :boolean, default: false)
141 field(:invisible, :boolean, default: false)
142 field(:allow_following_move, :boolean, default: true)
143 field(:skip_thread_containment, :boolean, default: false)
144 field(:actor_type, :string, default: "Person")
145 field(:also_known_as, {:array, :string}, default: [])
146 field(:inbox, :string)
147 field(:shared_inbox, :string)
148 field(:accepts_chat_messages, :boolean, default: nil)
151 :notification_settings,
152 Pleroma.User.NotificationSetting,
156 has_many(:notifications, Notification)
157 has_many(:registrations, Registration)
158 has_many(:deliveries, Delivery)
160 has_many(:outgoing_relationships, UserRelationship, foreign_key: :source_id)
161 has_many(:incoming_relationships, UserRelationship, foreign_key: :target_id)
163 for {relationship_type,
165 {outgoing_relation, outgoing_relation_target},
166 {incoming_relation, incoming_relation_source}
167 ]} <- @user_relationships_config do
168 # Definitions of `has_many` relations: :blocker_blocks, :muter_mutes, :reblog_muter_mutes,
169 # :notification_muter_mutes, :subscribee_subscriptions
170 has_many(outgoing_relation, UserRelationship,
171 foreign_key: :source_id,
172 where: [relationship_type: relationship_type]
175 # Definitions of `has_many` relations: :blockee_blocks, :mutee_mutes, :reblog_mutee_mutes,
176 # :notification_mutee_mutes, :subscriber_subscriptions
177 has_many(incoming_relation, UserRelationship,
178 foreign_key: :target_id,
179 where: [relationship_type: relationship_type]
182 # Definitions of `has_many` relations: :blocked_users, :muted_users, :reblog_muted_users,
183 # :notification_muted_users, :subscriber_users
184 has_many(outgoing_relation_target, through: [outgoing_relation, :target])
186 # Definitions of `has_many` relations: :blocker_users, :muter_users, :reblog_muter_users,
187 # :notification_muter_users, :subscribee_users
188 has_many(incoming_relation_source, through: [incoming_relation, :source])
191 # `:blocks` is deprecated (replaced with `blocked_users` relation)
192 field(:blocks, {:array, :string}, default: [])
193 # `:mutes` is deprecated (replaced with `muted_users` relation)
194 field(:mutes, {:array, :string}, default: [])
195 # `:muted_reblogs` is deprecated (replaced with `reblog_muted_users` relation)
196 field(:muted_reblogs, {:array, :string}, default: [])
197 # `:muted_notifications` is deprecated (replaced with `notification_muted_users` relation)
198 field(:muted_notifications, {:array, :string}, default: [])
199 # `:subscribers` is deprecated (replaced with `subscriber_users` relation)
200 field(:subscribers, {:array, :string}, default: [])
203 :multi_factor_authentication_settings,
211 for {_relationship_type, [{_outgoing_relation, outgoing_relation_target}, _]} <-
212 @user_relationships_config do
213 # `def blocked_users_relation/2`, `def muted_users_relation/2`,
214 # `def reblog_muted_users_relation/2`, `def notification_muted_users/2`,
215 # `def subscriber_users/2`
216 def unquote(:"#{outgoing_relation_target}_relation")(user, restrict_deactivated? \\ false) do
217 target_users_query = assoc(user, unquote(outgoing_relation_target))
219 if restrict_deactivated? do
220 restrict_deactivated(target_users_query)
226 # `def blocked_users/2`, `def muted_users/2`, `def reblog_muted_users/2`,
227 # `def notification_muted_users/2`, `def subscriber_users/2`
228 def unquote(outgoing_relation_target)(user, restrict_deactivated? \\ false) do
230 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
232 restrict_deactivated?
237 # `def blocked_users_ap_ids/2`, `def muted_users_ap_ids/2`, `def reblog_muted_users_ap_ids/2`,
238 # `def notification_muted_users_ap_ids/2`, `def subscriber_users_ap_ids/2`
239 def unquote(:"#{outgoing_relation_target}_ap_ids")(user, restrict_deactivated? \\ false) do
241 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
243 restrict_deactivated?
245 |> select([u], u.ap_id)
251 Dumps Flake Id to SQL-compatible format (16-byte UUID).
252 E.g. "9pQtDGXuq4p3VlcJEm" -> <<0, 0, 1, 110, 179, 218, 42, 92, 213, 41, 44, 227, 95, 213, 0, 0>>
254 def binary_id(source_id) when is_binary(source_id) do
255 with {:ok, dumped_id} <- FlakeId.Ecto.CompatType.dump(source_id) do
262 def binary_id(source_ids) when is_list(source_ids) do
263 Enum.map(source_ids, &binary_id/1)
266 def binary_id(%User{} = user), do: binary_id(user.id)
268 @doc "Returns status account"
269 @spec account_status(User.t()) :: account_status()
270 def account_status(%User{deactivated: true}), do: :deactivated
271 def account_status(%User{password_reset_pending: true}), do: :password_reset_pending
272 def account_status(%User{approval_pending: true}), do: :approval_pending
274 def account_status(%User{confirmation_pending: true}) do
275 if Config.get([:instance, :account_activation_required]) do
276 :confirmation_pending
282 def account_status(%User{}), do: :active
284 @spec visible_for(User.t(), User.t() | nil) ::
287 | :restricted_unauthenticated
289 | :confirmation_pending
290 def visible_for(user, for_user \\ nil)
292 def visible_for(%User{invisible: true}, _), do: :invisible
294 def visible_for(%User{id: user_id}, %User{id: user_id}), do: :visible
296 def visible_for(%User{} = user, nil) do
297 if restrict_unauthenticated?(user) do
298 :restrict_unauthenticated
300 visible_account_status(user)
304 def visible_for(%User{} = user, for_user) do
305 if superuser?(for_user) do
308 visible_account_status(user)
312 def visible_for(_, _), do: :invisible
314 defp restrict_unauthenticated?(%User{local: true}) do
315 Config.restrict_unauthenticated_access?(:profiles, :local)
318 defp restrict_unauthenticated?(%User{local: _}) do
319 Config.restrict_unauthenticated_access?(:profiles, :remote)
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,
490 :skip_thread_containment,
493 :pleroma_settings_store,
497 :accepts_chat_messages
500 |> unique_constraint(:nickname)
501 |> validate_format(:nickname, local_nickname_regex())
502 |> validate_length(:bio, max: bio_limit)
503 |> validate_length(:name, min: 1, max: name_limit)
504 |> validate_inclusion(:actor_type, ["Person", "Service"])
507 |> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
508 |> put_change_if_present(:avatar, &put_upload(&1, :avatar))
509 |> put_change_if_present(:banner, &put_upload(&1, :banner))
510 |> put_change_if_present(:background, &put_upload(&1, :background))
511 |> put_change_if_present(
512 :pleroma_settings_store,
513 &{:ok, Map.merge(struct.pleroma_settings_store, &1)}
515 |> validate_fields(false)
518 defp put_fields(changeset) do
519 if raw_fields = get_change(changeset, :raw_fields) do
522 |> Enum.filter(fn %{"name" => n} -> n != "" end)
526 |> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)
529 |> put_change(:raw_fields, raw_fields)
530 |> put_change(:fields, fields)
536 defp parse_fields(value) do
538 |> Formatter.linkify(mentions_format: :full)
542 defp put_emoji(changeset) do
543 emojified_fields = [:bio, :name, :raw_fields]
545 if Enum.any?(changeset.changes, fn {k, _} -> k in emojified_fields end) do
546 bio = Emoji.Formatter.get_emoji_map(get_field(changeset, :bio))
547 name = Emoji.Formatter.get_emoji_map(get_field(changeset, :name))
549 emoji = Map.merge(bio, name)
553 |> get_field(:raw_fields)
554 |> Enum.reduce(emoji, fn x, acc ->
555 Map.merge(acc, Emoji.Formatter.get_emoji_map(x["name"] <> x["value"]))
558 put_change(changeset, :emoji, emoji)
564 defp put_change_if_present(changeset, map_field, value_function) do
565 with {:ok, value} <- fetch_change(changeset, map_field),
566 {:ok, new_value} <- value_function.(value) do
567 put_change(changeset, map_field, new_value)
573 defp put_upload(value, type) do
574 with %Plug.Upload{} <- value,
575 {:ok, object} <- ActivityPub.upload(value, type: type) do
580 def update_as_admin_changeset(struct, params) do
582 |> update_changeset(params)
583 |> cast(params, [:email])
584 |> delete_change(:also_known_as)
585 |> unique_constraint(:email)
586 |> validate_format(:email, @email_regex)
587 |> validate_inclusion(:actor_type, ["Person", "Service"])
590 @spec update_as_admin(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
591 def update_as_admin(user, params) do
592 params = Map.put(params, "password_confirmation", params["password"])
593 changeset = update_as_admin_changeset(user, params)
595 if params["password"] do
596 reset_password(user, changeset, params)
598 User.update_and_set_cache(changeset)
602 def password_update_changeset(struct, params) do
604 |> cast(params, [:password, :password_confirmation])
605 |> validate_required([:password, :password_confirmation])
606 |> validate_confirmation(:password)
607 |> put_password_hash()
608 |> put_change(:password_reset_pending, false)
611 @spec reset_password(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
612 def reset_password(%User{} = user, params) do
613 reset_password(user, user, params)
616 def reset_password(%User{id: user_id} = user, struct, params) do
619 |> Multi.update(:user, password_update_changeset(struct, params))
620 |> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
621 |> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))
623 case Repo.transaction(multi) do
624 {:ok, %{user: user} = _} -> set_cache(user)
625 {:error, _, changeset, _} -> {:error, changeset}
629 def update_password_reset_pending(user, value) do
632 |> put_change(:password_reset_pending, value)
633 |> update_and_set_cache()
636 def force_password_reset_async(user) do
637 BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
640 @spec force_password_reset(User.t()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
641 def force_password_reset(user), do: update_password_reset_pending(user, true)
643 # Used to auto-register LDAP accounts which won't have a password hash stored locally
644 def register_changeset_ldap(struct, params = %{password: password})
645 when is_nil(password) do
646 params = Map.put_new(params, :accepts_chat_messages, true)
649 if Map.has_key?(params, :email) do
650 Map.put_new(params, :email, params[:email])
660 :accepts_chat_messages
662 |> validate_required([:name, :nickname])
663 |> unique_constraint(:nickname)
664 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
665 |> validate_format(:nickname, local_nickname_regex())
667 |> unique_constraint(:ap_id)
668 |> put_following_and_follower_address()
671 def register_changeset(struct, params \\ %{}, opts \\ []) do
672 bio_limit = Config.get([:instance, :user_bio_length], 5000)
673 name_limit = Config.get([:instance, :user_name_length], 100)
674 reason_limit = Config.get([:instance, :registration_reason_length], 500)
675 params = Map.put_new(params, :accepts_chat_messages, true)
678 if is_nil(opts[:need_confirmation]) do
679 Config.get([:instance, :account_activation_required])
681 opts[:need_confirmation]
685 if is_nil(opts[:need_approval]) do
686 Config.get([:instance, :account_approval_required])
692 |> confirmation_changeset(need_confirmation: need_confirmation?)
693 |> approval_changeset(need_approval: need_approval?)
701 :password_confirmation,
703 :accepts_chat_messages,
706 |> validate_required([:name, :nickname, :password, :password_confirmation])
707 |> validate_confirmation(:password)
708 |> unique_constraint(:email)
709 |> validate_format(:email, @email_regex)
710 |> validate_change(:email, fn :email, email ->
712 Config.get([User, :email_blacklist])
713 |> Enum.all?(fn blacklisted_domain ->
714 !String.ends_with?(email, ["@" <> blacklisted_domain, "." <> blacklisted_domain])
717 if valid?, do: [], else: [email: "Invalid email"]
719 |> unique_constraint(:nickname)
720 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
721 |> validate_format(:nickname, local_nickname_regex())
722 |> validate_length(:bio, max: bio_limit)
723 |> validate_length(:name, min: 1, max: name_limit)
724 |> validate_length(:registration_reason, max: reason_limit)
725 |> maybe_validate_required_email(opts[:external])
728 |> unique_constraint(:ap_id)
729 |> put_following_and_follower_address()
732 def maybe_validate_required_email(changeset, true), do: changeset
734 def maybe_validate_required_email(changeset, _) do
735 if Config.get([:instance, :account_activation_required]) do
736 validate_required(changeset, [:email])
742 defp put_ap_id(changeset) do
743 ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
744 put_change(changeset, :ap_id, ap_id)
747 defp put_following_and_follower_address(changeset) do
748 followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
751 |> put_change(:follower_address, followers)
754 defp autofollow_users(user) do
755 candidates = Config.get([:instance, :autofollowed_nicknames])
758 User.Query.build(%{nickname: candidates, local: true, deactivated: false})
761 follow_all(user, autofollowed_users)
764 @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
765 def register(%Ecto.Changeset{} = changeset) do
766 with {:ok, user} <- Repo.insert(changeset) do
767 post_register_action(user)
771 def post_register_action(%User{} = user) do
772 with {:ok, user} <- autofollow_users(user),
773 {:ok, user} <- set_cache(user),
774 {:ok, _} <- send_welcome_email(user),
775 {:ok, _} <- send_welcome_message(user),
776 {:ok, _} <- send_welcome_chat_message(user),
777 {:ok, _} <- try_send_confirmation_email(user) do
782 def send_welcome_message(user) do
783 if User.WelcomeMessage.enabled?() do
784 User.WelcomeMessage.post_message(user)
791 def send_welcome_chat_message(user) do
792 if User.WelcomeChatMessage.enabled?() do
793 User.WelcomeChatMessage.post_message(user)
800 def send_welcome_email(%User{email: email} = user) when is_binary(email) do
801 if User.WelcomeEmail.enabled?() do
802 User.WelcomeEmail.send_email(user)
809 def send_welcome_email(_), do: {:ok, :noop}
811 @spec try_send_confirmation_email(User.t()) :: {:ok, :enqueued | :noop}
812 def try_send_confirmation_email(%User{confirmation_pending: true} = user) do
813 if Config.get([:instance, :account_activation_required]) do
814 send_confirmation_email(user)
821 def try_send_confirmation_email(_), do: {:ok, :noop}
823 @spec send_confirmation_email(Uset.t()) :: User.t()
824 def send_confirmation_email(%User{} = user) do
826 |> Pleroma.Emails.UserEmail.account_confirmation_email()
827 |> Pleroma.Emails.Mailer.deliver_async()
832 def needs_update?(%User{local: true}), do: false
834 def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
836 def needs_update?(%User{local: false} = user) do
837 NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
840 def needs_update?(_), do: true
842 @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
844 # "Locked" (self-locked) users demand explicit authorization of follow requests
845 def maybe_direct_follow(%User{} = follower, %User{local: true, locked: true} = followed) do
846 follow(follower, followed, :follow_pending)
849 def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
850 follow(follower, followed)
853 def maybe_direct_follow(%User{} = follower, %User{} = followed) do
854 if not ap_enabled?(followed) do
855 follow(follower, followed)
861 @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
862 @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
863 def follow_all(follower, followeds) do
865 |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
866 |> Enum.each(&follow(follower, &1, :follow_accept))
871 defdelegate following(user), to: FollowingRelationship
873 def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
874 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
877 followed.deactivated ->
878 {:error, "Could not follow user: #{followed.nickname} is deactivated."}
880 deny_follow_blocked and blocks?(followed, follower) ->
881 {:error, "Could not follow user: #{followed.nickname} blocked you."}
884 FollowingRelationship.follow(follower, followed, state)
886 {:ok, _} = update_follower_count(followed)
889 |> update_following_count()
893 def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
894 {:error, "Not subscribed!"}
897 @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
898 def unfollow(%User{} = follower, %User{} = followed) do
899 case do_unfollow(follower, followed) do
900 {:ok, follower, followed} ->
901 {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
908 @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
909 defp do_unfollow(%User{} = follower, %User{} = followed) do
910 case get_follow_state(follower, followed) do
911 state when state in [:follow_pending, :follow_accept] ->
912 FollowingRelationship.unfollow(follower, followed)
913 {:ok, followed} = update_follower_count(followed)
917 |> update_following_count()
919 {:ok, follower, followed}
922 {:error, "Not subscribed!"}
926 defdelegate following?(follower, followed), to: FollowingRelationship
928 @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
929 def get_follow_state(%User{} = follower, %User{} = following) do
930 following_relationship = FollowingRelationship.get(follower, following)
931 get_follow_state(follower, following, following_relationship)
934 def get_follow_state(
937 following_relationship
939 case {following_relationship, following.local} do
941 case Utils.fetch_latest_follow(follower, following) do
942 %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
943 FollowingRelationship.state_to_enum(state)
949 {%{state: state}, _} ->
957 def locked?(%User{} = user) do
962 Repo.get_by(User, id: id)
965 def get_by_ap_id(ap_id) do
966 Repo.get_by(User, ap_id: ap_id)
969 def get_all_by_ap_id(ap_ids) do
970 from(u in __MODULE__,
971 where: u.ap_id in ^ap_ids
976 def get_all_by_ids(ids) do
977 from(u in __MODULE__, where: u.id in ^ids)
981 # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
982 # of the ap_id and the domain and tries to get that user
983 def get_by_guessed_nickname(ap_id) do
984 domain = URI.parse(ap_id).host
985 name = List.last(String.split(ap_id, "/"))
986 nickname = "#{name}@#{domain}"
988 get_cached_by_nickname(nickname)
991 def set_cache({:ok, user}), do: set_cache(user)
992 def set_cache({:error, err}), do: {:error, err}
994 def set_cache(%User{} = user) do
995 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
996 Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
997 Cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
1001 def update_and_set_cache(struct, params) do
1003 |> update_changeset(params)
1004 |> update_and_set_cache()
1007 def update_and_set_cache(changeset) do
1008 with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
1013 def get_user_friends_ap_ids(user) do
1014 from(u in User.get_friends_query(user), select: u.ap_id)
1018 @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
1019 def get_cached_user_friends_ap_ids(user) do
1020 Cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
1021 get_user_friends_ap_ids(user)
1025 def invalidate_cache(user) do
1026 Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
1027 Cachex.del(:user_cache, "nickname:#{user.nickname}")
1028 Cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
1031 @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
1032 def get_cached_by_ap_id(ap_id) do
1033 key = "ap_id:#{ap_id}"
1035 with {:ok, nil} <- Cachex.get(:user_cache, key),
1036 user when not is_nil(user) <- get_by_ap_id(ap_id),
1037 {:ok, true} <- Cachex.put(:user_cache, key, user) do
1045 def get_cached_by_id(id) do
1049 Cachex.fetch!(:user_cache, key, fn _ ->
1050 user = get_by_id(id)
1053 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1054 {:commit, user.ap_id}
1060 get_cached_by_ap_id(ap_id)
1063 def get_cached_by_nickname(nickname) do
1064 key = "nickname:#{nickname}"
1066 Cachex.fetch!(:user_cache, key, fn ->
1067 case get_or_fetch_by_nickname(nickname) do
1068 {:ok, user} -> {:commit, user}
1069 {:error, _error} -> {:ignore, nil}
1074 def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
1075 restrict_to_local = Config.get([:instance, :limit_to_local_content])
1078 is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
1079 get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
1081 restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
1082 get_cached_by_nickname(nickname_or_id)
1084 restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
1085 get_cached_by_nickname(nickname_or_id)
1092 @spec get_by_nickname(String.t()) :: User.t() | nil
1093 def get_by_nickname(nickname) do
1094 Repo.get_by(User, nickname: nickname) ||
1095 if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
1096 Repo.get_by(User, nickname: local_nickname(nickname))
1100 def get_by_email(email), do: Repo.get_by(User, email: email)
1102 def get_by_nickname_or_email(nickname_or_email) do
1103 get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
1106 def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
1108 def get_or_fetch_by_nickname(nickname) do
1109 with %User{} = user <- get_by_nickname(nickname) do
1113 with [_nick, _domain] <- String.split(nickname, "@"),
1114 {:ok, user} <- fetch_by_nickname(nickname) do
1117 _e -> {:error, "not found " <> nickname}
1122 @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1123 def get_followers_query(%User{} = user, nil) do
1124 User.Query.build(%{followers: user, deactivated: false})
1127 def get_followers_query(user, page) do
1129 |> get_followers_query(nil)
1130 |> User.Query.paginate(page, 20)
1133 @spec get_followers_query(User.t()) :: Ecto.Query.t()
1134 def get_followers_query(user), do: get_followers_query(user, nil)
1136 @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1137 def get_followers(user, page \\ nil) do
1139 |> get_followers_query(page)
1143 @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1144 def get_external_followers(user, page \\ nil) do
1146 |> get_followers_query(page)
1147 |> User.Query.build(%{external: true})
1151 def get_followers_ids(user, page \\ nil) do
1153 |> get_followers_query(page)
1154 |> select([u], u.id)
1158 @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1159 def get_friends_query(%User{} = user, nil) do
1160 User.Query.build(%{friends: user, deactivated: false})
1163 def get_friends_query(user, page) do
1165 |> get_friends_query(nil)
1166 |> User.Query.paginate(page, 20)
1169 @spec get_friends_query(User.t()) :: Ecto.Query.t()
1170 def get_friends_query(user), do: get_friends_query(user, nil)
1172 def get_friends(user, page \\ nil) do
1174 |> get_friends_query(page)
1178 def get_friends_ap_ids(user) do
1180 |> get_friends_query(nil)
1181 |> select([u], u.ap_id)
1185 def get_friends_ids(user, page \\ nil) do
1187 |> get_friends_query(page)
1188 |> select([u], u.id)
1192 defdelegate get_follow_requests(user), to: FollowingRelationship
1194 def increase_note_count(%User{} = user) do
1196 |> where(id: ^user.id)
1197 |> update([u], inc: [note_count: 1])
1199 |> Repo.update_all([])
1201 {1, [user]} -> set_cache(user)
1206 def decrease_note_count(%User{} = user) do
1208 |> where(id: ^user.id)
1211 note_count: fragment("greatest(0, note_count - 1)")
1215 |> Repo.update_all([])
1217 {1, [user]} -> set_cache(user)
1222 def update_note_count(%User{} = user, note_count \\ nil) do
1227 where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1233 |> cast(%{note_count: note_count}, [:note_count])
1234 |> update_and_set_cache()
1237 @spec maybe_fetch_follow_information(User.t()) :: User.t()
1238 def maybe_fetch_follow_information(user) do
1239 with {:ok, user} <- fetch_follow_information(user) do
1243 Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1249 def fetch_follow_information(user) do
1250 with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1252 |> follow_information_changeset(info)
1253 |> update_and_set_cache()
1257 defp follow_information_changeset(user, params) do
1264 :hide_followers_count,
1269 @spec update_follower_count(User.t()) :: {:ok, User.t()}
1270 def update_follower_count(%User{} = user) do
1271 if user.local or !Config.get([:instance, :external_user_synchronization]) do
1272 follower_count = FollowingRelationship.follower_count(user)
1275 |> follow_information_changeset(%{follower_count: follower_count})
1276 |> update_and_set_cache
1278 {:ok, maybe_fetch_follow_information(user)}
1282 @spec update_following_count(User.t()) :: {:ok, User.t()}
1283 def update_following_count(%User{local: false} = user) do
1284 if Config.get([:instance, :external_user_synchronization]) do
1285 {:ok, maybe_fetch_follow_information(user)}
1291 def update_following_count(%User{local: true} = user) do
1292 following_count = FollowingRelationship.following_count(user)
1295 |> follow_information_changeset(%{following_count: following_count})
1296 |> update_and_set_cache()
1299 def set_unread_conversation_count(%User{local: true} = user) do
1300 unread_query = Participation.unread_conversation_count_for_user(user)
1303 |> join(:inner, [u], p in subquery(unread_query))
1305 set: [unread_conversation_count: p.count]
1307 |> where([u], u.id == ^user.id)
1309 |> Repo.update_all([])
1311 {1, [user]} -> set_cache(user)
1316 def set_unread_conversation_count(user), do: {:ok, user}
1318 def increment_unread_conversation_count(conversation, %User{local: true} = user) do
1320 Participation.unread_conversation_count_for_user(user)
1321 |> where([p], p.conversation_id == ^conversation.id)
1324 |> join(:inner, [u], p in subquery(unread_query))
1326 inc: [unread_conversation_count: 1]
1328 |> where([u], u.id == ^user.id)
1329 |> where([u, p], p.count == 0)
1331 |> Repo.update_all([])
1333 {1, [user]} -> set_cache(user)
1338 def increment_unread_conversation_count(_, user), do: {:ok, user}
1340 @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1341 def get_users_from_set(ap_ids, opts \\ []) do
1342 local_only = Keyword.get(opts, :local_only, true)
1343 criteria = %{ap_id: ap_ids, deactivated: false}
1344 criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1346 User.Query.build(criteria)
1350 @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1351 def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1354 query = User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
1360 @spec mute(User.t(), User.t(), boolean()) ::
1361 {:ok, list(UserRelationship.t())} | {:error, String.t()}
1362 def mute(%User{} = muter, %User{} = mutee, notifications? \\ true) do
1363 add_to_mutes(muter, mutee, notifications?)
1366 def unmute(%User{} = muter, %User{} = mutee) do
1367 remove_from_mutes(muter, mutee)
1370 def subscribe(%User{} = subscriber, %User{} = target) do
1371 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
1373 if blocks?(target, subscriber) and deny_follow_blocked do
1374 {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1376 # Note: the relationship is inverse: subscriber acts as relationship target
1377 UserRelationship.create_inverse_subscription(target, subscriber)
1381 def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1382 with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1383 subscribe(subscriber, subscribee)
1387 def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1388 # Note: the relationship is inverse: subscriber acts as relationship target
1389 UserRelationship.delete_inverse_subscription(target, unsubscriber)
1392 def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1393 with %User{} = user <- get_cached_by_ap_id(ap_id) do
1394 unsubscribe(unsubscriber, user)
1398 def block(%User{} = blocker, %User{} = blocked) do
1399 # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1401 if following?(blocker, blocked) do
1402 {:ok, blocker, _} = unfollow(blocker, blocked)
1408 # clear any requested follows as well
1410 case CommonAPI.reject_follow_request(blocked, blocker) do
1411 {:ok, %User{} = updated_blocked} -> updated_blocked
1415 unsubscribe(blocked, blocker)
1417 unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
1418 if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)
1420 {:ok, blocker} = update_follower_count(blocker)
1421 {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1422 add_to_block(blocker, blocked)
1425 # helper to handle the block given only an actor's AP id
1426 def block(%User{} = blocker, %{ap_id: ap_id}) do
1427 block(blocker, get_cached_by_ap_id(ap_id))
1430 def unblock(%User{} = blocker, %User{} = blocked) do
1431 remove_from_block(blocker, blocked)
1434 # helper to handle the block given only an actor's AP id
1435 def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1436 unblock(blocker, get_cached_by_ap_id(ap_id))
1439 def mutes?(nil, _), do: false
1440 def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1442 def mutes_user?(%User{} = user, %User{} = target) do
1443 UserRelationship.mute_exists?(user, target)
1446 @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1447 def muted_notifications?(nil, _), do: false
1449 def muted_notifications?(%User{} = user, %User{} = target),
1450 do: UserRelationship.notification_mute_exists?(user, target)
1452 def blocks?(nil, _), do: false
1454 def blocks?(%User{} = user, %User{} = target) do
1455 blocks_user?(user, target) ||
1456 (blocks_domain?(user, target) and not User.following?(user, target))
1459 def blocks_user?(%User{} = user, %User{} = target) do
1460 UserRelationship.block_exists?(user, target)
1463 def blocks_user?(_, _), do: false
1465 def blocks_domain?(%User{} = user, %User{} = target) do
1466 domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1467 %{host: host} = URI.parse(target.ap_id)
1468 Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1471 def blocks_domain?(_, _), do: false
1473 def subscribed_to?(%User{} = user, %User{} = target) do
1474 # Note: the relationship is inverse: subscriber acts as relationship target
1475 UserRelationship.inverse_subscription_exists?(target, user)
1478 def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1479 with %User{} = target <- get_cached_by_ap_id(ap_id) do
1480 subscribed_to?(user, target)
1485 Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1486 E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1488 @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1489 def outgoing_relationships_ap_ids(_user, []), do: %{}
1491 def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1493 def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1494 when is_list(relationship_types) do
1497 |> assoc(:outgoing_relationships)
1498 |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1499 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1500 |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1501 |> group_by([user_rel, u], user_rel.relationship_type)
1503 |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1508 fn rel_type -> {rel_type, db_result[rel_type] || []} end
1512 def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1514 def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1516 def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1518 def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1519 when is_list(relationship_types) do
1521 |> assoc(:incoming_relationships)
1522 |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1523 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1524 |> maybe_filter_on_ap_id(ap_ids)
1525 |> select([user_rel, u], u.ap_id)
1530 defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1531 where(query, [user_rel, u], u.ap_id in ^ap_ids)
1534 defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1536 def deactivate_async(user, status \\ true) do
1537 BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
1540 def deactivate(user, status \\ true)
1542 def deactivate(users, status) when is_list(users) do
1543 Repo.transaction(fn ->
1544 for user <- users, do: deactivate(user, status)
1548 def deactivate(%User{} = user, status) do
1549 with {:ok, user} <- set_activation_status(user, status) do
1552 |> Enum.filter(& &1.local)
1553 |> Enum.each(&set_cache(update_following_count(&1)))
1555 # Only update local user counts, remote will be update during the next pull.
1558 |> Enum.filter(& &1.local)
1559 |> Enum.each(&do_unfollow(user, &1))
1565 def approve(users) when is_list(users) do
1566 Repo.transaction(fn ->
1567 Enum.map(users, fn user ->
1568 with {:ok, user} <- approve(user), do: user
1573 def approve(%User{} = user) do
1574 change(user, approval_pending: false)
1575 |> update_and_set_cache()
1578 def update_notification_settings(%User{} = user, settings) do
1580 |> cast(%{notification_settings: settings}, [])
1581 |> cast_embed(:notification_settings)
1582 |> validate_required([:notification_settings])
1583 |> update_and_set_cache()
1586 @spec purge_user_changeset(User.t()) :: Changeset.t()
1587 def purge_user_changeset(user) do
1588 # "Right to be forgotten"
1589 # https://gdpr.eu/right-to-be-forgotten/
1600 last_refreshed_at: nil,
1601 last_digest_emailed_at: nil,
1608 confirmation_pending: false,
1609 password_reset_pending: false,
1610 approval_pending: false,
1611 registration_reason: nil,
1612 confirmation_token: nil,
1616 is_moderator: false,
1618 mastofe_settings: nil,
1621 pleroma_settings_store: %{},
1624 discoverable: false,
1629 def delete(users) when is_list(users) do
1630 for user <- users, do: delete(user)
1633 def delete(%User{} = user) do
1634 BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1637 defp delete_and_invalidate_cache(%User{} = user) do
1638 invalidate_cache(user)
1642 defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)
1644 defp delete_or_deactivate(%User{local: true} = user) do
1645 status = account_status(user)
1648 :confirmation_pending ->
1649 delete_and_invalidate_cache(user)
1651 :approval_pending ->
1652 delete_and_invalidate_cache(user)
1656 |> purge_user_changeset()
1657 |> update_and_set_cache()
1661 def perform(:force_password_reset, user), do: force_password_reset(user)
1663 @spec perform(atom(), User.t()) :: {:ok, User.t()}
1664 def perform(:delete, %User{} = user) do
1665 # Remove all relationships
1668 |> Enum.each(fn follower ->
1669 ActivityPub.unfollow(follower, user)
1670 unfollow(follower, user)
1675 |> Enum.each(fn followed ->
1676 ActivityPub.unfollow(user, followed)
1677 unfollow(user, followed)
1680 delete_user_activities(user)
1681 delete_notifications_from_user_activities(user)
1683 delete_outgoing_pending_follow_requests(user)
1685 delete_or_deactivate(user)
1688 def perform(:deactivate_async, user, status), do: deactivate(user, status)
1690 @spec perform(atom(), User.t(), list()) :: list() | {:error, any()}
1691 def perform(:blocks_import, %User{} = blocker, blocked_identifiers)
1692 when is_list(blocked_identifiers) do
1694 blocked_identifiers,
1695 fn blocked_identifier ->
1696 with {:ok, %User{} = blocked} <- get_or_fetch(blocked_identifier),
1697 {:ok, _block} <- CommonAPI.block(blocker, blocked) do
1701 Logger.debug("blocks_import failed for #{blocked_identifier} with: #{inspect(err)}")
1708 def perform(:follow_import, %User{} = follower, followed_identifiers)
1709 when is_list(followed_identifiers) do
1711 followed_identifiers,
1712 fn followed_identifier ->
1713 with {:ok, %User{} = followed} <- get_or_fetch(followed_identifier),
1714 {:ok, follower} <- maybe_direct_follow(follower, followed),
1715 {:ok, _, _, _} <- CommonAPI.follow(follower, followed) do
1719 Logger.debug("follow_import failed for #{followed_identifier} with: #{inspect(err)}")
1726 @spec external_users_query() :: Ecto.Query.t()
1727 def external_users_query do
1735 @spec external_users(keyword()) :: [User.t()]
1736 def external_users(opts \\ []) do
1738 external_users_query()
1739 |> select([u], struct(u, [:id, :ap_id]))
1743 do: where(query, [u], u.id > ^opts[:max_id]),
1748 do: limit(query, ^opts[:limit]),
1754 def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers) do
1755 BackgroundWorker.enqueue("blocks_import", %{
1756 "blocker_id" => blocker.id,
1757 "blocked_identifiers" => blocked_identifiers
1761 def follow_import(%User{} = follower, followed_identifiers)
1762 when is_list(followed_identifiers) do
1763 BackgroundWorker.enqueue("follow_import", %{
1764 "follower_id" => follower.id,
1765 "followed_identifiers" => followed_identifiers
1769 def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1771 |> join(:inner, [n], activity in assoc(n, :activity))
1772 |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1773 |> Repo.delete_all()
1776 def delete_user_activities(%User{ap_id: ap_id} = user) do
1778 |> Activity.Queries.by_actor()
1779 |> RepoStreamer.chunk_stream(50)
1780 |> Stream.each(fn activities ->
1781 Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1786 defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1787 with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1788 {:ok, delete_data, _} <- Builder.delete(user, object) do
1789 Pipeline.common_pipeline(delete_data, local: user.local)
1791 {:find_object, nil} ->
1792 # We have the create activity, but not the object, it was probably pruned.
1793 # Insert a tombstone and try again
1794 with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1795 {:ok, _tombstone} <- Object.create(tombstone_data) do
1796 delete_activity(activity, user)
1800 Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1801 Logger.error("Error: #{inspect(e)}")
1805 defp delete_activity(%{data: %{"type" => type}} = activity, user)
1806 when type in ["Like", "Announce"] do
1807 {:ok, undo, _} = Builder.undo(user, activity)
1808 Pipeline.common_pipeline(undo, local: user.local)
1811 defp delete_activity(_activity, _user), do: "Doing nothing"
1813 defp delete_outgoing_pending_follow_requests(user) do
1815 |> FollowingRelationship.outgoing_pending_follow_requests_query()
1816 |> Repo.delete_all()
1819 def html_filter_policy(%User{no_rich_text: true}) do
1820 Pleroma.HTML.Scrubber.TwitterText
1823 def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])
1825 def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1827 def get_or_fetch_by_ap_id(ap_id) do
1828 cached_user = get_cached_by_ap_id(ap_id)
1830 maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)
1832 case {cached_user, maybe_fetched_user} do
1833 {_, {:ok, %User{} = user}} ->
1836 {%User{} = user, _} ->
1840 {:error, :not_found}
1845 Creates an internal service actor by URI if missing.
1846 Optionally takes nickname for addressing.
1848 @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1849 def get_or_create_service_actor_by_ap_id(uri, nickname) do
1851 case get_cached_by_ap_id(uri) do
1853 with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1854 Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1858 %User{invisible: false} = user ->
1868 @spec set_invisible(User.t()) :: {:ok, User.t()}
1869 defp set_invisible(user) do
1871 |> change(%{invisible: true})
1872 |> update_and_set_cache()
1875 @spec create_service_actor(String.t(), String.t()) ::
1876 {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1877 defp create_service_actor(uri, nickname) do
1883 follower_address: uri <> "/followers"
1886 |> unique_constraint(:nickname)
1891 def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1894 |> :public_key.pem_decode()
1896 |> :public_key.pem_entry_decode()
1901 def public_key(_), do: {:error, "key not found"}
1903 def get_public_key_for_ap_id(ap_id) do
1904 with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1905 {:ok, public_key} <- public_key(user) do
1912 def ap_enabled?(%User{local: true}), do: true
1913 def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1914 def ap_enabled?(_), do: false
1916 @doc "Gets or fetch a user by uri or nickname."
1917 @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1918 def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1919 def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1921 # wait a period of time and return newest version of the User structs
1922 # this is because we have synchronous follow APIs and need to simulate them
1923 # with an async handshake
1924 def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1925 with %User{} = a <- get_cached_by_id(a.id),
1926 %User{} = b <- get_cached_by_id(b.id) do
1933 def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1934 with :ok <- :timer.sleep(timeout),
1935 %User{} = a <- get_cached_by_id(a.id),
1936 %User{} = b <- get_cached_by_id(b.id) do
1943 def parse_bio(bio) when is_binary(bio) and bio != "" do
1945 |> CommonUtils.format_input("text/plain", mentions_format: :full)
1949 def parse_bio(_), do: ""
1951 def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1952 # TODO: get profile URLs other than user.ap_id
1953 profile_urls = [user.ap_id]
1956 |> CommonUtils.format_input("text/plain",
1957 mentions_format: :full,
1958 rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1963 def parse_bio(_, _), do: ""
1965 def tag(user_identifiers, tags) when is_list(user_identifiers) do
1966 Repo.transaction(fn ->
1967 for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1971 def tag(nickname, tags) when is_binary(nickname),
1972 do: tag(get_by_nickname(nickname), tags)
1974 def tag(%User{} = user, tags),
1975 do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1977 def untag(user_identifiers, tags) when is_list(user_identifiers) do
1978 Repo.transaction(fn ->
1979 for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1983 def untag(nickname, tags) when is_binary(nickname),
1984 do: untag(get_by_nickname(nickname), tags)
1986 def untag(%User{} = user, tags),
1987 do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1989 defp update_tags(%User{} = user, new_tags) do
1990 {:ok, updated_user} =
1992 |> change(%{tags: new_tags})
1993 |> update_and_set_cache()
1998 defp normalize_tags(tags) do
2001 |> Enum.map(&String.downcase/1)
2004 defp local_nickname_regex do
2005 if Config.get([:instance, :extended_nickname_format]) do
2006 @extended_local_nickname_regex
2008 @strict_local_nickname_regex
2012 def local_nickname(nickname_or_mention) do
2015 |> String.split("@")
2019 def full_nickname(nickname_or_mention),
2020 do: String.trim_leading(nickname_or_mention, "@")
2022 def error_user(ap_id) do
2026 nickname: "erroruser@example.com",
2027 inserted_at: NaiveDateTime.utc_now()
2031 @spec all_superusers() :: [User.t()]
2032 def all_superusers do
2033 User.Query.build(%{super_users: true, local: true, deactivated: false})
2037 def muting_reblogs?(%User{} = user, %User{} = target) do
2038 UserRelationship.reblog_mute_exists?(user, target)
2041 def showing_reblogs?(%User{} = user, %User{} = target) do
2042 not muting_reblogs?(user, target)
2046 The function returns a query to get users with no activity for given interval of days.
2047 Inactive users are those who didn't read any notification, or had any activity where
2048 the user is the activity's actor, during `inactivity_threshold` days.
2049 Deactivated users will not appear in this list.
2053 iex> Pleroma.User.list_inactive_users()
2056 @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
2057 def list_inactive_users_query(inactivity_threshold \\ 7) do
2058 negative_inactivity_threshold = -inactivity_threshold
2059 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2060 # Subqueries are not supported in `where` clauses, join gets too complicated.
2061 has_read_notifications =
2062 from(n in Pleroma.Notification,
2063 where: n.seen == true,
2065 having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
2068 |> Pleroma.Repo.all()
2070 from(u in Pleroma.User,
2071 left_join: a in Pleroma.Activity,
2072 on: u.ap_id == a.actor,
2073 where: not is_nil(u.nickname),
2074 where: u.deactivated != ^true,
2075 where: u.id not in ^has_read_notifications,
2078 max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
2079 is_nil(max(a.inserted_at))
2084 Enable or disable email notifications for user
2088 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
2089 Pleroma.User{email_notifications: %{"digest" => true}}
2091 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
2092 Pleroma.User{email_notifications: %{"digest" => false}}
2094 @spec switch_email_notifications(t(), String.t(), boolean()) ::
2095 {:ok, t()} | {:error, Ecto.Changeset.t()}
2096 def switch_email_notifications(user, type, status) do
2097 User.update_email_notifications(user, %{type => status})
2101 Set `last_digest_emailed_at` value for the user to current time
2103 @spec touch_last_digest_emailed_at(t()) :: t()
2104 def touch_last_digest_emailed_at(user) do
2105 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2107 {:ok, updated_user} =
2109 |> change(%{last_digest_emailed_at: now})
2110 |> update_and_set_cache()
2115 @spec toggle_confirmation(User.t()) :: {:ok, User.t()} | {:error, Changeset.t()}
2116 def toggle_confirmation(%User{} = user) do
2118 |> confirmation_changeset(need_confirmation: !user.confirmation_pending)
2119 |> update_and_set_cache()
2122 @spec toggle_confirmation([User.t()]) :: [{:ok, User.t()} | {:error, Changeset.t()}]
2123 def toggle_confirmation(users) do
2124 Enum.map(users, &toggle_confirmation/1)
2127 def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
2131 def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
2132 # use instance-default
2133 config = Config.get([:assets, :mascots])
2134 default_mascot = Config.get([:assets, :default_mascot])
2135 mascot = Keyword.get(config, default_mascot)
2138 "id" => "default-mascot",
2139 "url" => mascot[:url],
2140 "preview_url" => mascot[:url],
2142 "mime_type" => mascot[:mime_type]
2147 def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
2149 def ensure_keys_present(%User{} = user) do
2150 with {:ok, pem} <- Keys.generate_rsa_pem() do
2152 |> cast(%{keys: pem}, [:keys])
2153 |> validate_required([:keys])
2154 |> update_and_set_cache()
2158 def get_ap_ids_by_nicknames(nicknames) do
2160 where: u.nickname in ^nicknames,
2166 defdelegate search(query, opts \\ []), to: User.Search
2168 defp put_password_hash(
2169 %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2171 change(changeset, password_hash: Pbkdf2.hash_pwd_salt(password))
2174 defp put_password_hash(changeset), do: changeset
2176 def is_internal_user?(%User{nickname: nil}), do: true
2177 def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2178 def is_internal_user?(_), do: false
2180 # A hack because user delete activities have a fake id for whatever reason
2181 # TODO: Get rid of this
2182 def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2184 def get_delivered_users_by_object_id(object_id) do
2186 inner_join: delivery in assoc(u, :deliveries),
2187 where: delivery.object_id == ^object_id
2192 def change_email(user, email) do
2194 |> cast(%{email: email}, [:email])
2195 |> validate_required([:email])
2196 |> unique_constraint(:email)
2197 |> validate_format(:email, @email_regex)
2198 |> update_and_set_cache()
2201 # Internal function; public one is `deactivate/2`
2202 defp set_activation_status(user, deactivated) do
2204 |> cast(%{deactivated: deactivated}, [:deactivated])
2205 |> update_and_set_cache()
2208 def update_banner(user, banner) do
2210 |> cast(%{banner: banner}, [:banner])
2211 |> update_and_set_cache()
2214 def update_background(user, background) do
2216 |> cast(%{background: background}, [:background])
2217 |> update_and_set_cache()
2220 def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
2223 moderator: is_moderator
2227 def validate_fields(changeset, remote? \\ false) do
2228 limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2229 limit = Config.get([:instance, limit_name], 0)
2232 |> validate_length(:fields, max: limit)
2233 |> validate_change(:fields, fn :fields, fields ->
2234 if Enum.all?(fields, &valid_field?/1) do
2242 defp valid_field?(%{"name" => name, "value" => value}) do
2243 name_limit = Config.get([:instance, :account_field_name_length], 255)
2244 value_limit = Config.get([:instance, :account_field_value_length], 255)
2246 is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2247 String.length(value) <= value_limit
2250 defp valid_field?(_), do: false
2252 defp truncate_field(%{"name" => name, "value" => value}) do
2254 String.split_at(name, Config.get([:instance, :account_field_name_length], 255))
2257 String.split_at(value, Config.get([:instance, :account_field_value_length], 255))
2259 %{"name" => name, "value" => value}
2262 def admin_api_update(user, params) do
2269 |> update_and_set_cache()
2272 @doc "Signs user out of all applications"
2273 def global_sign_out(user) do
2274 OAuth.Authorization.delete_user_authorizations(user)
2275 OAuth.Token.delete_user_tokens(user)
2278 def mascot_update(user, url) do
2280 |> cast(%{mascot: url}, [:mascot])
2281 |> validate_required([:mascot])
2282 |> update_and_set_cache()
2285 def mastodon_settings_update(user, settings) do
2287 |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
2288 |> validate_required([:mastofe_settings])
2289 |> update_and_set_cache()
2292 @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2293 def confirmation_changeset(user, need_confirmation: need_confirmation?) do
2295 if need_confirmation? do
2297 confirmation_pending: true,
2298 confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2302 confirmation_pending: false,
2303 confirmation_token: nil
2307 cast(user, params, [:confirmation_pending, :confirmation_token])
2310 @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
2311 def approval_changeset(user, need_approval: need_approval?) do
2312 params = if need_approval?, do: %{approval_pending: true}, else: %{approval_pending: false}
2313 cast(user, params, [:approval_pending])
2316 def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2317 if id not in user.pinned_activities do
2318 max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2319 params = %{pinned_activities: user.pinned_activities ++ [id]}
2322 |> cast(params, [:pinned_activities])
2323 |> validate_length(:pinned_activities,
2324 max: max_pinned_statuses,
2325 message: "You have already pinned the maximum number of statuses"
2330 |> update_and_set_cache()
2333 def remove_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2334 params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2337 |> cast(params, [:pinned_activities])
2338 |> update_and_set_cache()
2341 def update_email_notifications(user, settings) do
2342 email_notifications =
2343 user.email_notifications
2344 |> Map.merge(settings)
2345 |> Map.take(["digest"])
2347 params = %{email_notifications: email_notifications}
2348 fields = [:email_notifications]
2351 |> cast(params, fields)
2352 |> validate_required(fields)
2353 |> update_and_set_cache()
2356 defp set_domain_blocks(user, domain_blocks) do
2357 params = %{domain_blocks: domain_blocks}
2360 |> cast(params, [:domain_blocks])
2361 |> validate_required([:domain_blocks])
2362 |> update_and_set_cache()
2365 def block_domain(user, domain_blocked) do
2366 set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2369 def unblock_domain(user, domain_blocked) do
2370 set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2373 @spec add_to_block(User.t(), User.t()) ::
2374 {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2375 defp add_to_block(%User{} = user, %User{} = blocked) do
2376 UserRelationship.create_block(user, blocked)
2379 @spec add_to_block(User.t(), User.t()) ::
2380 {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2381 defp remove_from_block(%User{} = user, %User{} = blocked) do
2382 UserRelationship.delete_block(user, blocked)
2385 defp add_to_mutes(%User{} = user, %User{} = muted_user, notifications?) do
2386 with {:ok, user_mute} <- UserRelationship.create_mute(user, muted_user),
2387 {:ok, user_notification_mute} <-
2388 (notifications? && UserRelationship.create_notification_mute(user, muted_user)) ||
2390 {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
2394 defp remove_from_mutes(user, %User{} = muted_user) do
2395 with {:ok, user_mute} <- UserRelationship.delete_mute(user, muted_user),
2396 {:ok, user_notification_mute} <-
2397 UserRelationship.delete_notification_mute(user, muted_user) do
2398 {:ok, [user_mute, user_notification_mute]}
2402 def set_invisible(user, invisible) do
2403 params = %{invisible: invisible}
2406 |> cast(params, [:invisible])
2407 |> validate_required([:invisible])
2408 |> update_and_set_cache()
2411 def sanitize_html(%User{} = user) do
2412 sanitize_html(user, nil)
2415 # User data that mastodon isn't filtering (treated as plaintext):
2418 def sanitize_html(%User{} = user, filter) do
2420 Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2423 "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2428 |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2429 |> Map.put(:fields, fields)