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
18 alias Pleroma.FollowingRelationship
19 alias Pleroma.Formatter
23 alias Pleroma.Notification
25 alias Pleroma.Registration
27 alias Pleroma.RepoStreamer
29 alias Pleroma.UserRelationship
31 alias Pleroma.Web.ActivityPub.ActivityPub
32 alias Pleroma.Web.ActivityPub.Builder
33 alias Pleroma.Web.ActivityPub.ObjectValidators.Types
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 :: :active | :deactivated | :password_reset_pending | :confirmation_pending
46 @primary_key {:id, FlakeId.Ecto.CompatType, autogenerate: true}
48 # credo:disable-for-next-line Credo.Check.Readability.MaxLineLength
49 @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])?)*$/
51 @strict_local_nickname_regex ~r/^[a-zA-Z\d]+$/
52 @extended_local_nickname_regex ~r/^[a-zA-Z\d_-]+$/
54 # AP ID user relationships (blocks, mutes etc.)
55 # Format: [rel_type: [outgoing_rel: :outgoing_rel_target, incoming_rel: :incoming_rel_source]]
56 @user_relationships_config [
58 blocker_blocks: :blocked_users,
59 blockee_blocks: :blocker_users
62 muter_mutes: :muted_users,
63 mutee_mutes: :muter_users
66 reblog_muter_mutes: :reblog_muted_users,
67 reblog_mutee_mutes: :reblog_muter_users
70 notification_muter_mutes: :notification_muted_users,
71 notification_mutee_mutes: :notification_muter_users
73 # Note: `inverse_subscription` relationship is inverse: subscriber acts as relationship target
74 inverse_subscription: [
75 subscribee_subscriptions: :subscriber_users,
76 subscriber_subscriptions: :subscribee_users
82 field(:email, :string)
84 field(:nickname, :string)
85 field(:password_hash, :string)
86 field(:password, :string, virtual: true)
87 field(:password_confirmation, :string, virtual: true)
89 field(:public_key, :string)
90 field(:ap_id, :string)
92 field(:local, :boolean, default: true)
93 field(:follower_address, :string)
94 field(:following_address, :string)
95 field(:search_rank, :float, virtual: true)
96 field(:search_type, :integer, virtual: true)
97 field(:tags, {:array, :string}, default: [])
98 field(:last_refreshed_at, :naive_datetime_usec)
99 field(:last_digest_emailed_at, :naive_datetime)
100 field(:banner, :map, default: %{})
101 field(:background, :map, default: %{})
102 field(:note_count, :integer, default: 0)
103 field(:follower_count, :integer, default: 0)
104 field(:following_count, :integer, default: 0)
105 field(:locked, :boolean, default: false)
106 field(:confirmation_pending, :boolean, default: false)
107 field(:password_reset_pending, :boolean, default: false)
108 field(:confirmation_token, :string, default: nil)
109 field(:default_scope, :string, default: "public")
110 field(:domain_blocks, {:array, :string}, default: [])
111 field(:deactivated, :boolean, default: false)
112 field(:no_rich_text, :boolean, default: false)
113 field(:ap_enabled, :boolean, default: false)
114 field(:is_moderator, :boolean, default: false)
115 field(:is_admin, :boolean, default: false)
116 field(:show_role, :boolean, default: true)
117 field(:settings, :map, default: nil)
118 field(:uri, Types.Uri, default: nil)
119 field(:hide_followers_count, :boolean, default: false)
120 field(:hide_follows_count, :boolean, default: false)
121 field(:hide_followers, :boolean, default: false)
122 field(:hide_follows, :boolean, default: false)
123 field(:hide_favorites, :boolean, default: true)
124 field(:unread_conversation_count, :integer, default: 0)
125 field(:pinned_activities, {:array, :string}, default: [])
126 field(:email_notifications, :map, default: %{"digest" => false})
127 field(:mascot, :map, default: nil)
128 field(:emoji, :map, default: %{})
129 field(:pleroma_settings_store, :map, default: %{})
130 field(:fields, {:array, :map}, default: [])
131 field(:raw_fields, {:array, :map}, default: [])
132 field(:discoverable, :boolean, default: false)
133 field(:invisible, :boolean, default: false)
134 field(:allow_following_move, :boolean, default: true)
135 field(:skip_thread_containment, :boolean, default: false)
136 field(:actor_type, :string, default: "Person")
137 field(:also_known_as, {:array, :string}, default: [])
138 field(:inbox, :string)
139 field(:shared_inbox, :string)
142 :notification_settings,
143 Pleroma.User.NotificationSetting,
147 has_many(:notifications, Notification)
148 has_many(:registrations, Registration)
149 has_many(:deliveries, Delivery)
151 has_many(:outgoing_relationships, UserRelationship, foreign_key: :source_id)
152 has_many(:incoming_relationships, UserRelationship, foreign_key: :target_id)
154 for {relationship_type,
156 {outgoing_relation, outgoing_relation_target},
157 {incoming_relation, incoming_relation_source}
158 ]} <- @user_relationships_config do
159 # Definitions of `has_many` relations: :blocker_blocks, :muter_mutes, :reblog_muter_mutes,
160 # :notification_muter_mutes, :subscribee_subscriptions
161 has_many(outgoing_relation, UserRelationship,
162 foreign_key: :source_id,
163 where: [relationship_type: relationship_type]
166 # Definitions of `has_many` relations: :blockee_blocks, :mutee_mutes, :reblog_mutee_mutes,
167 # :notification_mutee_mutes, :subscriber_subscriptions
168 has_many(incoming_relation, UserRelationship,
169 foreign_key: :target_id,
170 where: [relationship_type: relationship_type]
173 # Definitions of `has_many` relations: :blocked_users, :muted_users, :reblog_muted_users,
174 # :notification_muted_users, :subscriber_users
175 has_many(outgoing_relation_target, through: [outgoing_relation, :target])
177 # Definitions of `has_many` relations: :blocker_users, :muter_users, :reblog_muter_users,
178 # :notification_muter_users, :subscribee_users
179 has_many(incoming_relation_source, through: [incoming_relation, :source])
182 # `:blocks` is deprecated (replaced with `blocked_users` relation)
183 field(:blocks, {:array, :string}, default: [])
184 # `:mutes` is deprecated (replaced with `muted_users` relation)
185 field(:mutes, {:array, :string}, default: [])
186 # `:muted_reblogs` is deprecated (replaced with `reblog_muted_users` relation)
187 field(:muted_reblogs, {:array, :string}, default: [])
188 # `:muted_notifications` is deprecated (replaced with `notification_muted_users` relation)
189 field(:muted_notifications, {:array, :string}, default: [])
190 # `:subscribers` is deprecated (replaced with `subscriber_users` relation)
191 field(:subscribers, {:array, :string}, default: [])
194 :multi_factor_authentication_settings,
202 for {_relationship_type, [{_outgoing_relation, outgoing_relation_target}, _]} <-
203 @user_relationships_config do
204 # `def blocked_users_relation/2`, `def muted_users_relation/2`,
205 # `def reblog_muted_users_relation/2`, `def notification_muted_users/2`,
206 # `def subscriber_users/2`
207 def unquote(:"#{outgoing_relation_target}_relation")(user, restrict_deactivated? \\ false) do
208 target_users_query = assoc(user, unquote(outgoing_relation_target))
210 if restrict_deactivated? do
211 restrict_deactivated(target_users_query)
217 # `def blocked_users/2`, `def muted_users/2`, `def reblog_muted_users/2`,
218 # `def notification_muted_users/2`, `def subscriber_users/2`
219 def unquote(outgoing_relation_target)(user, restrict_deactivated? \\ false) do
221 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
223 restrict_deactivated?
228 # `def blocked_users_ap_ids/2`, `def muted_users_ap_ids/2`, `def reblog_muted_users_ap_ids/2`,
229 # `def notification_muted_users_ap_ids/2`, `def subscriber_users_ap_ids/2`
230 def unquote(:"#{outgoing_relation_target}_ap_ids")(user, restrict_deactivated? \\ false) do
232 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
234 restrict_deactivated?
236 |> select([u], u.ap_id)
242 Dumps Flake Id to SQL-compatible format (16-byte UUID).
243 E.g. "9pQtDGXuq4p3VlcJEm" -> <<0, 0, 1, 110, 179, 218, 42, 92, 213, 41, 44, 227, 95, 213, 0, 0>>
245 def binary_id(source_id) when is_binary(source_id) do
246 with {:ok, dumped_id} <- FlakeId.Ecto.CompatType.dump(source_id) do
253 def binary_id(source_ids) when is_list(source_ids) do
254 Enum.map(source_ids, &binary_id/1)
257 def binary_id(%User{} = user), do: binary_id(user.id)
259 @doc "Returns status account"
260 @spec account_status(User.t()) :: account_status()
261 def account_status(%User{deactivated: true}), do: :deactivated
262 def account_status(%User{password_reset_pending: true}), do: :password_reset_pending
264 def account_status(%User{confirmation_pending: true}) do
265 if Config.get([:instance, :account_activation_required]) do
266 :confirmation_pending
272 def account_status(%User{}), do: :active
274 @spec visible_for(User.t(), User.t() | nil) ::
277 | :restricted_unauthenticated
279 | :confirmation_pending
280 def visible_for(user, for_user \\ nil)
282 def visible_for(%User{invisible: true}, _), do: :invisible
284 def visible_for(%User{id: user_id}, %User{id: user_id}), do: true
286 def visible_for(%User{} = user, nil) do
287 if restrict_unauthenticated?(user) do
288 :restrict_unauthenticated
290 visible_account_status(user)
294 def visible_for(%User{} = user, for_user) do
295 superuser?(for_user) || visible_account_status(user)
298 def visible_for(_, _), do: false
300 defp restrict_unauthenticated?(%User{local: local}) do
301 config_key = if local, do: :local, else: :remote
303 Config.get([:restrict_unauthenticated, :profiles, config_key], false)
306 defp visible_account_status(user) do
307 status = account_status(user)
308 status in [:active, :password_reset_pending] || status
311 @spec superuser?(User.t()) :: boolean()
312 def superuser?(%User{local: true, is_admin: true}), do: true
313 def superuser?(%User{local: true, is_moderator: true}), do: true
314 def superuser?(_), do: false
316 @spec invisible?(User.t()) :: boolean()
317 def invisible?(%User{invisible: true}), do: true
318 def invisible?(_), do: false
320 def avatar_url(user, options \\ []) do
322 %{"url" => [%{"href" => href} | _]} -> href
323 _ -> !options[:no_default] && "#{Web.base_url()}/images/avi.png"
327 def banner_url(user, options \\ []) do
329 %{"url" => [%{"href" => href} | _]} -> href
330 _ -> !options[:no_default] && "#{Web.base_url()}/images/banner.png"
334 # Should probably be renamed or removed
335 def ap_id(%User{nickname: nickname}), do: "#{Web.base_url()}/users/#{nickname}"
337 def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
338 def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"
340 @spec ap_following(User.t()) :: String.t()
341 def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
342 def ap_following(%User{} = user), do: "#{ap_id(user)}/following"
344 @spec restrict_deactivated(Ecto.Query.t()) :: Ecto.Query.t()
345 def restrict_deactivated(query) do
346 from(u in query, where: u.deactivated != ^true)
349 defdelegate following_count(user), to: FollowingRelationship
351 defp truncate_fields_param(params) do
352 if Map.has_key?(params, :fields) do
353 Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
359 defp truncate_if_exists(params, key, max_length) do
360 if Map.has_key?(params, key) and is_binary(params[key]) do
361 {value, _chopped} = String.split_at(params[key], max_length)
362 Map.put(params, key, value)
368 defp fix_follower_address(%{follower_address: _, following_address: _} = params), do: params
370 defp fix_follower_address(%{nickname: nickname} = params),
371 do: Map.put(params, :follower_address, ap_followers(%User{nickname: nickname}))
373 defp fix_follower_address(params), do: params
375 def remote_user_changeset(struct \\ %User{local: false}, params) do
376 bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
377 name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
380 case params[:name] do
381 name when is_binary(name) and byte_size(name) > 0 -> name
382 _ -> params[:nickname]
387 |> Map.put(:name, name)
388 |> Map.put_new(:last_refreshed_at, NaiveDateTime.utc_now())
389 |> truncate_if_exists(:name, name_limit)
390 |> truncate_if_exists(:bio, bio_limit)
391 |> truncate_fields_param()
392 |> fix_follower_address()
416 :hide_followers_count,
427 |> validate_required([:name, :ap_id])
428 |> unique_constraint(:nickname)
429 |> validate_format(:nickname, @email_regex)
430 |> validate_length(:bio, max: bio_limit)
431 |> validate_length(:name, max: name_limit)
432 |> validate_fields(true)
435 def update_changeset(struct, params \\ %{}) do
436 bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
437 name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
456 :hide_followers_count,
459 :allow_following_move,
462 :skip_thread_containment,
465 :pleroma_settings_store,
471 |> unique_constraint(:nickname)
472 |> validate_format(:nickname, local_nickname_regex())
473 |> validate_length(:bio, max: bio_limit)
474 |> validate_length(:name, min: 1, max: name_limit)
477 |> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
478 |> put_change_if_present(:avatar, &put_upload(&1, :avatar))
479 |> put_change_if_present(:banner, &put_upload(&1, :banner))
480 |> put_change_if_present(:background, &put_upload(&1, :background))
481 |> put_change_if_present(
482 :pleroma_settings_store,
483 &{:ok, Map.merge(struct.pleroma_settings_store, &1)}
485 |> validate_fields(false)
488 defp put_fields(changeset) do
489 if raw_fields = get_change(changeset, :raw_fields) do
492 |> Enum.filter(fn %{"name" => n} -> n != "" end)
496 |> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)
499 |> put_change(:raw_fields, raw_fields)
500 |> put_change(:fields, fields)
506 defp parse_fields(value) do
508 |> Formatter.linkify(mentions_format: :full)
512 defp put_emoji(changeset) do
513 bio = get_change(changeset, :bio)
514 name = get_change(changeset, :name)
517 emoji = Map.merge(Emoji.Formatter.get_emoji_map(bio), Emoji.Formatter.get_emoji_map(name))
518 put_change(changeset, :emoji, emoji)
524 defp put_change_if_present(changeset, map_field, value_function) do
525 if value = get_change(changeset, map_field) do
526 with {:ok, new_value} <- value_function.(value) do
527 put_change(changeset, map_field, new_value)
536 defp put_upload(value, type) do
537 with %Plug.Upload{} <- value,
538 {:ok, object} <- ActivityPub.upload(value, type: type) do
543 def update_as_admin_changeset(struct, params) do
545 |> update_changeset(params)
546 |> cast(params, [:email])
547 |> delete_change(:also_known_as)
548 |> unique_constraint(:email)
549 |> validate_format(:email, @email_regex)
552 @spec update_as_admin(%User{}, map) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
553 def update_as_admin(user, params) do
554 params = Map.put(params, "password_confirmation", params["password"])
555 changeset = update_as_admin_changeset(user, params)
557 if params["password"] do
558 reset_password(user, changeset, params)
560 User.update_and_set_cache(changeset)
564 def password_update_changeset(struct, params) do
566 |> cast(params, [:password, :password_confirmation])
567 |> validate_required([:password, :password_confirmation])
568 |> validate_confirmation(:password)
569 |> put_password_hash()
570 |> put_change(:password_reset_pending, false)
573 @spec reset_password(User.t(), map) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
574 def reset_password(%User{} = user, params) do
575 reset_password(user, user, params)
578 def reset_password(%User{id: user_id} = user, struct, params) do
581 |> Multi.update(:user, password_update_changeset(struct, params))
582 |> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
583 |> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))
585 case Repo.transaction(multi) do
586 {:ok, %{user: user} = _} -> set_cache(user)
587 {:error, _, changeset, _} -> {:error, changeset}
591 def update_password_reset_pending(user, value) do
594 |> put_change(:password_reset_pending, value)
595 |> update_and_set_cache()
598 def force_password_reset_async(user) do
599 BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
602 @spec force_password_reset(User.t()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
603 def force_password_reset(user), do: update_password_reset_pending(user, true)
605 def register_changeset(struct, params \\ %{}, opts \\ []) do
606 bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
607 name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
610 if is_nil(opts[:need_confirmation]) do
611 Pleroma.Config.get([:instance, :account_activation_required])
613 opts[:need_confirmation]
617 |> confirmation_changeset(need_confirmation: need_confirmation?)
618 |> cast(params, [:bio, :email, :name, :nickname, :password, :password_confirmation, :emoji])
619 |> validate_required([:name, :nickname, :password, :password_confirmation])
620 |> validate_confirmation(:password)
621 |> unique_constraint(:email)
622 |> unique_constraint(:nickname)
623 |> validate_exclusion(:nickname, Pleroma.Config.get([User, :restricted_nicknames]))
624 |> validate_format(:nickname, local_nickname_regex())
625 |> validate_format(:email, @email_regex)
626 |> validate_length(:bio, max: bio_limit)
627 |> validate_length(:name, min: 1, max: name_limit)
628 |> maybe_validate_required_email(opts[:external])
631 |> unique_constraint(:ap_id)
632 |> put_following_and_follower_address()
635 def maybe_validate_required_email(changeset, true), do: changeset
637 def maybe_validate_required_email(changeset, _) do
638 if Pleroma.Config.get([:instance, :account_activation_required]) do
639 validate_required(changeset, [:email])
645 defp put_ap_id(changeset) do
646 ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
647 put_change(changeset, :ap_id, ap_id)
650 defp put_following_and_follower_address(changeset) do
651 followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
654 |> put_change(:follower_address, followers)
657 defp autofollow_users(user) do
658 candidates = Pleroma.Config.get([:instance, :autofollowed_nicknames])
661 User.Query.build(%{nickname: candidates, local: true, deactivated: false})
664 follow_all(user, autofollowed_users)
667 @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
668 def register(%Ecto.Changeset{} = changeset) do
669 with {:ok, user} <- Repo.insert(changeset) do
670 post_register_action(user)
674 def post_register_action(%User{} = user) do
675 with {:ok, user} <- autofollow_users(user),
676 {:ok, user} <- set_cache(user),
677 {:ok, _} <- User.WelcomeMessage.post_welcome_message_to_user(user),
678 {:ok, _} <- try_send_confirmation_email(user) do
683 def try_send_confirmation_email(%User{} = user) do
684 if user.confirmation_pending &&
685 Pleroma.Config.get([:instance, :account_activation_required]) do
687 |> Pleroma.Emails.UserEmail.account_confirmation_email()
688 |> Pleroma.Emails.Mailer.deliver_async()
696 def try_send_confirmation_email(users) do
697 Enum.each(users, &try_send_confirmation_email/1)
700 def needs_update?(%User{local: true}), do: false
702 def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
704 def needs_update?(%User{local: false} = user) do
705 NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
708 def needs_update?(_), do: true
710 @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
712 # "Locked" (self-locked) users demand explicit authorization of follow requests
713 def maybe_direct_follow(%User{} = follower, %User{local: true, locked: true} = followed) do
714 follow(follower, followed, :follow_pending)
717 def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
718 follow(follower, followed)
721 def maybe_direct_follow(%User{} = follower, %User{} = followed) do
722 if not ap_enabled?(followed) do
723 follow(follower, followed)
729 @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
730 @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
731 def follow_all(follower, followeds) do
733 |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
734 |> Enum.each(&follow(follower, &1, :follow_accept))
739 defdelegate following(user), to: FollowingRelationship
741 def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
742 deny_follow_blocked = Pleroma.Config.get([:user, :deny_follow_blocked])
745 followed.deactivated ->
746 {:error, "Could not follow user: #{followed.nickname} is deactivated."}
748 deny_follow_blocked and blocks?(followed, follower) ->
749 {:error, "Could not follow user: #{followed.nickname} blocked you."}
752 FollowingRelationship.follow(follower, followed, state)
754 {:ok, _} = update_follower_count(followed)
757 |> update_following_count()
762 def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
763 {:error, "Not subscribed!"}
766 def unfollow(%User{} = follower, %User{} = followed) do
767 case get_follow_state(follower, followed) do
768 state when state in [:follow_pending, :follow_accept] ->
769 FollowingRelationship.unfollow(follower, followed)
770 {:ok, followed} = update_follower_count(followed)
774 |> update_following_count()
777 {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
780 {:error, "Not subscribed!"}
784 defdelegate following?(follower, followed), to: FollowingRelationship
786 @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
787 def get_follow_state(%User{} = follower, %User{} = following) do
788 following_relationship = FollowingRelationship.get(follower, following)
789 get_follow_state(follower, following, following_relationship)
792 def get_follow_state(
795 following_relationship
797 case {following_relationship, following.local} do
799 case Utils.fetch_latest_follow(follower, following) do
800 %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
801 FollowingRelationship.state_to_enum(state)
807 {%{state: state}, _} ->
815 def locked?(%User{} = user) do
820 Repo.get_by(User, id: id)
823 def get_by_ap_id(ap_id) do
824 Repo.get_by(User, ap_id: ap_id)
827 def get_all_by_ap_id(ap_ids) do
828 from(u in __MODULE__,
829 where: u.ap_id in ^ap_ids
834 def get_all_by_ids(ids) do
835 from(u in __MODULE__, where: u.id in ^ids)
839 # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
840 # of the ap_id and the domain and tries to get that user
841 def get_by_guessed_nickname(ap_id) do
842 domain = URI.parse(ap_id).host
843 name = List.last(String.split(ap_id, "/"))
844 nickname = "#{name}@#{domain}"
846 get_cached_by_nickname(nickname)
849 def set_cache({:ok, user}), do: set_cache(user)
850 def set_cache({:error, err}), do: {:error, err}
852 def set_cache(%User{} = user) do
853 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
854 Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
855 Cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
859 def update_and_set_cache(struct, params) do
861 |> update_changeset(params)
862 |> update_and_set_cache()
865 def update_and_set_cache(changeset) do
866 with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
871 def get_user_friends_ap_ids(user) do
872 from(u in User.get_friends_query(user), select: u.ap_id)
876 @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
877 def get_cached_user_friends_ap_ids(user) do
878 Cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
879 get_user_friends_ap_ids(user)
883 def invalidate_cache(user) do
884 Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
885 Cachex.del(:user_cache, "nickname:#{user.nickname}")
886 Cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
889 @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
890 def get_cached_by_ap_id(ap_id) do
891 key = "ap_id:#{ap_id}"
893 with {:ok, nil} <- Cachex.get(:user_cache, key),
894 user when not is_nil(user) <- get_by_ap_id(ap_id),
895 {:ok, true} <- Cachex.put(:user_cache, key, user) do
903 def get_cached_by_id(id) do
907 Cachex.fetch!(:user_cache, key, fn _ ->
911 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
912 {:commit, user.ap_id}
918 get_cached_by_ap_id(ap_id)
921 def get_cached_by_nickname(nickname) do
922 key = "nickname:#{nickname}"
924 Cachex.fetch!(:user_cache, key, fn ->
925 case get_or_fetch_by_nickname(nickname) do
926 {:ok, user} -> {:commit, user}
927 {:error, _error} -> {:ignore, nil}
932 def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
933 restrict_to_local = Pleroma.Config.get([:instance, :limit_to_local_content])
936 is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
937 get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
939 restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
940 get_cached_by_nickname(nickname_or_id)
942 restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
943 get_cached_by_nickname(nickname_or_id)
950 @spec get_by_nickname(String.t()) :: User.t() | nil
951 def get_by_nickname(nickname) do
952 Repo.get_by(User, nickname: nickname) ||
953 if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
954 Repo.get_by(User, nickname: local_nickname(nickname))
958 def get_by_email(email), do: Repo.get_by(User, email: email)
960 def get_by_nickname_or_email(nickname_or_email) do
961 get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
964 def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
966 def get_or_fetch_by_nickname(nickname) do
967 with %User{} = user <- get_by_nickname(nickname) do
971 with [_nick, _domain] <- String.split(nickname, "@"),
972 {:ok, user} <- fetch_by_nickname(nickname) do
975 _e -> {:error, "not found " <> nickname}
980 @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
981 def get_followers_query(%User{} = user, nil) do
982 User.Query.build(%{followers: user, deactivated: false})
985 def get_followers_query(user, page) do
987 |> get_followers_query(nil)
988 |> User.Query.paginate(page, 20)
991 @spec get_followers_query(User.t()) :: Ecto.Query.t()
992 def get_followers_query(user), do: get_followers_query(user, nil)
994 @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
995 def get_followers(user, page \\ nil) do
997 |> get_followers_query(page)
1001 @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1002 def get_external_followers(user, page \\ nil) do
1004 |> get_followers_query(page)
1005 |> User.Query.build(%{external: true})
1009 def get_followers_ids(user, page \\ nil) do
1011 |> get_followers_query(page)
1012 |> select([u], u.id)
1016 @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1017 def get_friends_query(%User{} = user, nil) do
1018 User.Query.build(%{friends: user, deactivated: false})
1021 def get_friends_query(user, page) do
1023 |> get_friends_query(nil)
1024 |> User.Query.paginate(page, 20)
1027 @spec get_friends_query(User.t()) :: Ecto.Query.t()
1028 def get_friends_query(user), do: get_friends_query(user, nil)
1030 def get_friends(user, page \\ nil) do
1032 |> get_friends_query(page)
1036 def get_friends_ap_ids(user) do
1038 |> get_friends_query(nil)
1039 |> select([u], u.ap_id)
1043 def get_friends_ids(user, page \\ nil) do
1045 |> get_friends_query(page)
1046 |> select([u], u.id)
1050 defdelegate get_follow_requests(user), to: FollowingRelationship
1052 def increase_note_count(%User{} = user) do
1054 |> where(id: ^user.id)
1055 |> update([u], inc: [note_count: 1])
1057 |> Repo.update_all([])
1059 {1, [user]} -> set_cache(user)
1064 def decrease_note_count(%User{} = user) do
1066 |> where(id: ^user.id)
1069 note_count: fragment("greatest(0, note_count - 1)")
1073 |> Repo.update_all([])
1075 {1, [user]} -> set_cache(user)
1080 def update_note_count(%User{} = user, note_count \\ nil) do
1085 where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1091 |> cast(%{note_count: note_count}, [:note_count])
1092 |> update_and_set_cache()
1095 @spec maybe_fetch_follow_information(User.t()) :: User.t()
1096 def maybe_fetch_follow_information(user) do
1097 with {:ok, user} <- fetch_follow_information(user) do
1101 Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1107 def fetch_follow_information(user) do
1108 with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1110 |> follow_information_changeset(info)
1111 |> update_and_set_cache()
1115 defp follow_information_changeset(user, params) do
1122 :hide_followers_count,
1127 def update_follower_count(%User{} = user) do
1128 if user.local or !Pleroma.Config.get([:instance, :external_user_synchronization]) do
1129 follower_count_query =
1130 User.Query.build(%{followers: user, deactivated: false})
1131 |> select([u], %{count: count(u.id)})
1134 |> where(id: ^user.id)
1135 |> join(:inner, [u], s in subquery(follower_count_query))
1137 set: [follower_count: s.count]
1140 |> Repo.update_all([])
1142 {1, [user]} -> set_cache(user)
1146 {:ok, maybe_fetch_follow_information(user)}
1150 @spec update_following_count(User.t()) :: User.t()
1151 def update_following_count(%User{local: false} = user) do
1152 if Pleroma.Config.get([:instance, :external_user_synchronization]) do
1153 maybe_fetch_follow_information(user)
1159 def update_following_count(%User{local: true} = user) do
1160 following_count = FollowingRelationship.following_count(user)
1163 |> follow_information_changeset(%{following_count: following_count})
1167 def set_unread_conversation_count(%User{local: true} = user) do
1168 unread_query = Participation.unread_conversation_count_for_user(user)
1171 |> join(:inner, [u], p in subquery(unread_query))
1173 set: [unread_conversation_count: p.count]
1175 |> where([u], u.id == ^user.id)
1177 |> Repo.update_all([])
1179 {1, [user]} -> set_cache(user)
1184 def set_unread_conversation_count(user), do: {:ok, user}
1186 def increment_unread_conversation_count(conversation, %User{local: true} = user) do
1188 Participation.unread_conversation_count_for_user(user)
1189 |> where([p], p.conversation_id == ^conversation.id)
1192 |> join(:inner, [u], p in subquery(unread_query))
1194 inc: [unread_conversation_count: 1]
1196 |> where([u], u.id == ^user.id)
1197 |> where([u, p], p.count == 0)
1199 |> Repo.update_all([])
1201 {1, [user]} -> set_cache(user)
1206 def increment_unread_conversation_count(_, user), do: {:ok, user}
1208 @spec get_users_from_set([String.t()], boolean()) :: [User.t()]
1209 def get_users_from_set(ap_ids, local_only \\ true) do
1210 criteria = %{ap_id: ap_ids, deactivated: false}
1211 criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1213 User.Query.build(criteria)
1217 @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1218 def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1221 User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
1225 @spec mute(User.t(), User.t(), boolean()) ::
1226 {:ok, list(UserRelationship.t())} | {:error, String.t()}
1227 def mute(%User{} = muter, %User{} = mutee, notifications? \\ true) do
1228 add_to_mutes(muter, mutee, notifications?)
1231 def unmute(%User{} = muter, %User{} = mutee) do
1232 remove_from_mutes(muter, mutee)
1235 def subscribe(%User{} = subscriber, %User{} = target) do
1236 deny_follow_blocked = Pleroma.Config.get([:user, :deny_follow_blocked])
1238 if blocks?(target, subscriber) and deny_follow_blocked do
1239 {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1241 # Note: the relationship is inverse: subscriber acts as relationship target
1242 UserRelationship.create_inverse_subscription(target, subscriber)
1246 def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1247 with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1248 subscribe(subscriber, subscribee)
1252 def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1253 # Note: the relationship is inverse: subscriber acts as relationship target
1254 UserRelationship.delete_inverse_subscription(target, unsubscriber)
1257 def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1258 with %User{} = user <- get_cached_by_ap_id(ap_id) do
1259 unsubscribe(unsubscriber, user)
1263 def block(%User{} = blocker, %User{} = blocked) do
1264 # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1266 if following?(blocker, blocked) do
1267 {:ok, blocker, _} = unfollow(blocker, blocked)
1273 # clear any requested follows as well
1275 case CommonAPI.reject_follow_request(blocked, blocker) do
1276 {:ok, %User{} = updated_blocked} -> updated_blocked
1280 unsubscribe(blocked, blocker)
1282 if following?(blocked, blocker), do: unfollow(blocked, blocker)
1284 {:ok, blocker} = update_follower_count(blocker)
1285 {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1286 add_to_block(blocker, blocked)
1289 # helper to handle the block given only an actor's AP id
1290 def block(%User{} = blocker, %{ap_id: ap_id}) do
1291 block(blocker, get_cached_by_ap_id(ap_id))
1294 def unblock(%User{} = blocker, %User{} = blocked) do
1295 remove_from_block(blocker, blocked)
1298 # helper to handle the block given only an actor's AP id
1299 def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1300 unblock(blocker, get_cached_by_ap_id(ap_id))
1303 def mutes?(nil, _), do: false
1304 def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1306 def mutes_user?(%User{} = user, %User{} = target) do
1307 UserRelationship.mute_exists?(user, target)
1310 @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1311 def muted_notifications?(nil, _), do: false
1313 def muted_notifications?(%User{} = user, %User{} = target),
1314 do: UserRelationship.notification_mute_exists?(user, target)
1316 def blocks?(nil, _), do: false
1318 def blocks?(%User{} = user, %User{} = target) do
1319 blocks_user?(user, target) ||
1320 (blocks_domain?(user, target) and not User.following?(user, target))
1323 def blocks_user?(%User{} = user, %User{} = target) do
1324 UserRelationship.block_exists?(user, target)
1327 def blocks_user?(_, _), do: false
1329 def blocks_domain?(%User{} = user, %User{} = target) do
1330 domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1331 %{host: host} = URI.parse(target.ap_id)
1332 Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1335 def blocks_domain?(_, _), do: false
1337 def subscribed_to?(%User{} = user, %User{} = target) do
1338 # Note: the relationship is inverse: subscriber acts as relationship target
1339 UserRelationship.inverse_subscription_exists?(target, user)
1342 def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1343 with %User{} = target <- get_cached_by_ap_id(ap_id) do
1344 subscribed_to?(user, target)
1349 Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1350 E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1352 @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1353 def outgoing_relationships_ap_ids(_user, []), do: %{}
1355 def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1357 def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1358 when is_list(relationship_types) do
1361 |> assoc(:outgoing_relationships)
1362 |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1363 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1364 |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1365 |> group_by([user_rel, u], user_rel.relationship_type)
1367 |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1372 fn rel_type -> {rel_type, db_result[rel_type] || []} end
1376 def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1378 def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1380 def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1382 def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1383 when is_list(relationship_types) do
1385 |> assoc(:incoming_relationships)
1386 |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1387 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1388 |> maybe_filter_on_ap_id(ap_ids)
1389 |> select([user_rel, u], u.ap_id)
1394 defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1395 where(query, [user_rel, u], u.ap_id in ^ap_ids)
1398 defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1400 def deactivate_async(user, status \\ true) do
1401 BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
1404 def deactivate(user, status \\ true)
1406 def deactivate(users, status) when is_list(users) do
1407 Repo.transaction(fn ->
1408 for user <- users, do: deactivate(user, status)
1412 def deactivate(%User{} = user, status) do
1413 with {:ok, user} <- set_activation_status(user, status) do
1416 |> Enum.filter(& &1.local)
1417 |> Enum.each(fn follower ->
1418 follower |> update_following_count() |> set_cache()
1421 # Only update local user counts, remote will be update during the next pull.
1424 |> Enum.filter(& &1.local)
1425 |> Enum.each(&update_follower_count/1)
1431 def update_notification_settings(%User{} = user, settings) do
1433 |> cast(%{notification_settings: settings}, [])
1434 |> cast_embed(:notification_settings)
1435 |> validate_required([:notification_settings])
1436 |> update_and_set_cache()
1439 def delete(users) when is_list(users) do
1440 for user <- users, do: delete(user)
1443 def delete(%User{} = user) do
1444 BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1447 def perform(:force_password_reset, user), do: force_password_reset(user)
1449 @spec perform(atom(), User.t()) :: {:ok, User.t()}
1450 def perform(:delete, %User{} = user) do
1451 # Remove all relationships
1454 |> Enum.each(fn follower ->
1455 ActivityPub.unfollow(follower, user)
1456 unfollow(follower, user)
1461 |> Enum.each(fn followed ->
1462 ActivityPub.unfollow(user, followed)
1463 unfollow(user, followed)
1466 delete_user_activities(user)
1470 |> change(%{deactivated: true, email: nil})
1471 |> update_and_set_cache()
1473 invalidate_cache(user)
1478 def perform(:deactivate_async, user, status), do: deactivate(user, status)
1480 @spec perform(atom(), User.t(), list()) :: list() | {:error, any()}
1481 def perform(:blocks_import, %User{} = blocker, blocked_identifiers)
1482 when is_list(blocked_identifiers) do
1484 blocked_identifiers,
1485 fn blocked_identifier ->
1486 with {:ok, %User{} = blocked} <- get_or_fetch(blocked_identifier),
1487 {:ok, _user_block} <- block(blocker, blocked),
1488 {:ok, _} <- ActivityPub.block(blocker, blocked) do
1492 Logger.debug("blocks_import failed for #{blocked_identifier} with: #{inspect(err)}")
1499 def perform(:follow_import, %User{} = follower, followed_identifiers)
1500 when is_list(followed_identifiers) do
1502 followed_identifiers,
1503 fn followed_identifier ->
1504 with {:ok, %User{} = followed} <- get_or_fetch(followed_identifier),
1505 {:ok, follower} <- maybe_direct_follow(follower, followed),
1506 {:ok, _} <- ActivityPub.follow(follower, followed) do
1510 Logger.debug("follow_import failed for #{followed_identifier} with: #{inspect(err)}")
1517 @spec external_users_query() :: Ecto.Query.t()
1518 def external_users_query do
1526 @spec external_users(keyword()) :: [User.t()]
1527 def external_users(opts \\ []) do
1529 external_users_query()
1530 |> select([u], struct(u, [:id, :ap_id]))
1534 do: where(query, [u], u.id > ^opts[:max_id]),
1539 do: limit(query, ^opts[:limit]),
1545 def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers) do
1546 BackgroundWorker.enqueue("blocks_import", %{
1547 "blocker_id" => blocker.id,
1548 "blocked_identifiers" => blocked_identifiers
1552 def follow_import(%User{} = follower, followed_identifiers)
1553 when is_list(followed_identifiers) do
1554 BackgroundWorker.enqueue("follow_import", %{
1555 "follower_id" => follower.id,
1556 "followed_identifiers" => followed_identifiers
1560 def delete_user_activities(%User{ap_id: ap_id} = user) do
1562 |> Activity.Queries.by_actor()
1563 |> RepoStreamer.chunk_stream(50)
1564 |> Stream.each(fn activities ->
1565 Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1570 defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1571 with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1572 {:ok, delete_data, _} <- Builder.delete(user, object) do
1573 Pipeline.common_pipeline(delete_data, local: user.local)
1575 {:find_object, nil} ->
1576 # We have the create activity, but not the object, it was probably pruned.
1577 # Insert a tombstone and try again
1578 with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1579 {:ok, _tombstone} <- Object.create(tombstone_data) do
1580 delete_activity(activity, user)
1584 Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1585 Logger.error("Error: #{inspect(e)}")
1589 defp delete_activity(%{data: %{"type" => type}} = activity, user)
1590 when type in ["Like", "Announce"] do
1591 {:ok, undo, _} = Builder.undo(user, activity)
1592 Pipeline.common_pipeline(undo, local: user.local)
1595 defp delete_activity(_activity, _user), do: "Doing nothing"
1597 def html_filter_policy(%User{no_rich_text: true}) do
1598 Pleroma.HTML.Scrubber.TwitterText
1601 def html_filter_policy(_), do: Pleroma.Config.get([:markup, :scrub_policy])
1603 def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1605 def get_or_fetch_by_ap_id(ap_id) do
1606 user = get_cached_by_ap_id(ap_id)
1608 if !is_nil(user) and !needs_update?(user) do
1611 fetch_by_ap_id(ap_id)
1616 Creates an internal service actor by URI if missing.
1617 Optionally takes nickname for addressing.
1619 @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1620 def get_or_create_service_actor_by_ap_id(uri, nickname) do
1622 case get_cached_by_ap_id(uri) do
1624 with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1625 Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1629 %User{invisible: false} = user ->
1639 @spec set_invisible(User.t()) :: {:ok, User.t()}
1640 defp set_invisible(user) do
1642 |> change(%{invisible: true})
1643 |> update_and_set_cache()
1646 @spec create_service_actor(String.t(), String.t()) ::
1647 {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1648 defp create_service_actor(uri, nickname) do
1654 follower_address: uri <> "/followers"
1657 |> unique_constraint(:nickname)
1662 def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1665 |> :public_key.pem_decode()
1667 |> :public_key.pem_entry_decode()
1672 def public_key(_), do: {:error, "key not found"}
1674 def get_public_key_for_ap_id(ap_id) do
1675 with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1676 {:ok, public_key} <- public_key(user) do
1683 def ap_enabled?(%User{local: true}), do: true
1684 def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1685 def ap_enabled?(_), do: false
1687 @doc "Gets or fetch a user by uri or nickname."
1688 @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1689 def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1690 def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1692 # wait a period of time and return newest version of the User structs
1693 # this is because we have synchronous follow APIs and need to simulate them
1694 # with an async handshake
1695 def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1696 with %User{} = a <- get_cached_by_id(a.id),
1697 %User{} = b <- get_cached_by_id(b.id) do
1704 def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1705 with :ok <- :timer.sleep(timeout),
1706 %User{} = a <- get_cached_by_id(a.id),
1707 %User{} = b <- get_cached_by_id(b.id) do
1714 def parse_bio(bio) when is_binary(bio) and bio != "" do
1716 |> CommonUtils.format_input("text/plain", mentions_format: :full)
1720 def parse_bio(_), do: ""
1722 def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1723 # TODO: get profile URLs other than user.ap_id
1724 profile_urls = [user.ap_id]
1727 |> CommonUtils.format_input("text/plain",
1728 mentions_format: :full,
1729 rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1734 def parse_bio(_, _), do: ""
1736 def tag(user_identifiers, tags) when is_list(user_identifiers) do
1737 Repo.transaction(fn ->
1738 for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1742 def tag(nickname, tags) when is_binary(nickname),
1743 do: tag(get_by_nickname(nickname), tags)
1745 def tag(%User{} = user, tags),
1746 do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1748 def untag(user_identifiers, tags) when is_list(user_identifiers) do
1749 Repo.transaction(fn ->
1750 for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1754 def untag(nickname, tags) when is_binary(nickname),
1755 do: untag(get_by_nickname(nickname), tags)
1757 def untag(%User{} = user, tags),
1758 do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1760 defp update_tags(%User{} = user, new_tags) do
1761 {:ok, updated_user} =
1763 |> change(%{tags: new_tags})
1764 |> update_and_set_cache()
1769 defp normalize_tags(tags) do
1772 |> Enum.map(&String.downcase/1)
1775 defp local_nickname_regex do
1776 if Pleroma.Config.get([:instance, :extended_nickname_format]) do
1777 @extended_local_nickname_regex
1779 @strict_local_nickname_regex
1783 def local_nickname(nickname_or_mention) do
1786 |> String.split("@")
1790 def full_nickname(nickname_or_mention),
1791 do: String.trim_leading(nickname_or_mention, "@")
1793 def error_user(ap_id) do
1797 nickname: "erroruser@example.com",
1798 inserted_at: NaiveDateTime.utc_now()
1802 @spec all_superusers() :: [User.t()]
1803 def all_superusers do
1804 User.Query.build(%{super_users: true, local: true, deactivated: false})
1808 def muting_reblogs?(%User{} = user, %User{} = target) do
1809 UserRelationship.reblog_mute_exists?(user, target)
1812 def showing_reblogs?(%User{} = user, %User{} = target) do
1813 not muting_reblogs?(user, target)
1817 The function returns a query to get users with no activity for given interval of days.
1818 Inactive users are those who didn't read any notification, or had any activity where
1819 the user is the activity's actor, during `inactivity_threshold` days.
1820 Deactivated users will not appear in this list.
1824 iex> Pleroma.User.list_inactive_users()
1827 @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
1828 def list_inactive_users_query(inactivity_threshold \\ 7) do
1829 negative_inactivity_threshold = -inactivity_threshold
1830 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
1831 # Subqueries are not supported in `where` clauses, join gets too complicated.
1832 has_read_notifications =
1833 from(n in Pleroma.Notification,
1834 where: n.seen == true,
1836 having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
1839 |> Pleroma.Repo.all()
1841 from(u in Pleroma.User,
1842 left_join: a in Pleroma.Activity,
1843 on: u.ap_id == a.actor,
1844 where: not is_nil(u.nickname),
1845 where: u.deactivated != ^true,
1846 where: u.id not in ^has_read_notifications,
1849 max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
1850 is_nil(max(a.inserted_at))
1855 Enable or disable email notifications for user
1859 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
1860 Pleroma.User{email_notifications: %{"digest" => true}}
1862 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
1863 Pleroma.User{email_notifications: %{"digest" => false}}
1865 @spec switch_email_notifications(t(), String.t(), boolean()) ::
1866 {:ok, t()} | {:error, Ecto.Changeset.t()}
1867 def switch_email_notifications(user, type, status) do
1868 User.update_email_notifications(user, %{type => status})
1872 Set `last_digest_emailed_at` value for the user to current time
1874 @spec touch_last_digest_emailed_at(t()) :: t()
1875 def touch_last_digest_emailed_at(user) do
1876 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
1878 {:ok, updated_user} =
1880 |> change(%{last_digest_emailed_at: now})
1881 |> update_and_set_cache()
1886 @spec toggle_confirmation(User.t()) :: {:ok, User.t()} | {:error, Changeset.t()}
1887 def toggle_confirmation(%User{} = user) do
1889 |> confirmation_changeset(need_confirmation: !user.confirmation_pending)
1890 |> update_and_set_cache()
1893 @spec toggle_confirmation([User.t()]) :: [{:ok, User.t()} | {:error, Changeset.t()}]
1894 def toggle_confirmation(users) do
1895 Enum.map(users, &toggle_confirmation/1)
1898 def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
1902 def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
1903 # use instance-default
1904 config = Pleroma.Config.get([:assets, :mascots])
1905 default_mascot = Pleroma.Config.get([:assets, :default_mascot])
1906 mascot = Keyword.get(config, default_mascot)
1909 "id" => "default-mascot",
1910 "url" => mascot[:url],
1911 "preview_url" => mascot[:url],
1913 "mime_type" => mascot[:mime_type]
1918 def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
1920 def ensure_keys_present(%User{} = user) do
1921 with {:ok, pem} <- Keys.generate_rsa_pem() do
1923 |> cast(%{keys: pem}, [:keys])
1924 |> validate_required([:keys])
1925 |> update_and_set_cache()
1929 def get_ap_ids_by_nicknames(nicknames) do
1931 where: u.nickname in ^nicknames,
1937 defdelegate search(query, opts \\ []), to: User.Search
1939 defp put_password_hash(
1940 %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
1942 change(changeset, password_hash: Pbkdf2.hash_pwd_salt(password))
1945 defp put_password_hash(changeset), do: changeset
1947 def is_internal_user?(%User{nickname: nil}), do: true
1948 def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
1949 def is_internal_user?(_), do: false
1951 # A hack because user delete activities have a fake id for whatever reason
1952 # TODO: Get rid of this
1953 def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
1955 def get_delivered_users_by_object_id(object_id) do
1957 inner_join: delivery in assoc(u, :deliveries),
1958 where: delivery.object_id == ^object_id
1963 def change_email(user, email) do
1965 |> cast(%{email: email}, [:email])
1966 |> validate_required([:email])
1967 |> unique_constraint(:email)
1968 |> validate_format(:email, @email_regex)
1969 |> update_and_set_cache()
1972 # Internal function; public one is `deactivate/2`
1973 defp set_activation_status(user, deactivated) do
1975 |> cast(%{deactivated: deactivated}, [:deactivated])
1976 |> update_and_set_cache()
1979 def update_banner(user, banner) do
1981 |> cast(%{banner: banner}, [:banner])
1982 |> update_and_set_cache()
1985 def update_background(user, background) do
1987 |> cast(%{background: background}, [:background])
1988 |> update_and_set_cache()
1991 def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
1994 moderator: is_moderator
1998 def validate_fields(changeset, remote? \\ false) do
1999 limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2000 limit = Pleroma.Config.get([:instance, limit_name], 0)
2003 |> validate_length(:fields, max: limit)
2004 |> validate_change(:fields, fn :fields, fields ->
2005 if Enum.all?(fields, &valid_field?/1) do
2013 defp valid_field?(%{"name" => name, "value" => value}) do
2014 name_limit = Pleroma.Config.get([:instance, :account_field_name_length], 255)
2015 value_limit = Pleroma.Config.get([:instance, :account_field_value_length], 255)
2017 is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2018 String.length(value) <= value_limit
2021 defp valid_field?(_), do: false
2023 defp truncate_field(%{"name" => name, "value" => value}) do
2025 String.split_at(name, Pleroma.Config.get([:instance, :account_field_name_length], 255))
2028 String.split_at(value, Pleroma.Config.get([:instance, :account_field_value_length], 255))
2030 %{"name" => name, "value" => value}
2033 def admin_api_update(user, params) do
2040 |> update_and_set_cache()
2043 @doc "Signs user out of all applications"
2044 def global_sign_out(user) do
2045 OAuth.Authorization.delete_user_authorizations(user)
2046 OAuth.Token.delete_user_tokens(user)
2049 def mascot_update(user, url) do
2051 |> cast(%{mascot: url}, [:mascot])
2052 |> validate_required([:mascot])
2053 |> update_and_set_cache()
2056 def mastodon_settings_update(user, settings) do
2058 |> cast(%{settings: settings}, [:settings])
2059 |> validate_required([:settings])
2060 |> update_and_set_cache()
2063 @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2064 def confirmation_changeset(user, need_confirmation: need_confirmation?) do
2066 if need_confirmation? do
2068 confirmation_pending: true,
2069 confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2073 confirmation_pending: false,
2074 confirmation_token: nil
2078 cast(user, params, [:confirmation_pending, :confirmation_token])
2081 def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2082 if id not in user.pinned_activities do
2083 max_pinned_statuses = Pleroma.Config.get([:instance, :max_pinned_statuses], 0)
2084 params = %{pinned_activities: user.pinned_activities ++ [id]}
2087 |> cast(params, [:pinned_activities])
2088 |> validate_length(:pinned_activities,
2089 max: max_pinned_statuses,
2090 message: "You have already pinned the maximum number of statuses"
2095 |> update_and_set_cache()
2098 def remove_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2099 params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2102 |> cast(params, [:pinned_activities])
2103 |> update_and_set_cache()
2106 def update_email_notifications(user, settings) do
2107 email_notifications =
2108 user.email_notifications
2109 |> Map.merge(settings)
2110 |> Map.take(["digest"])
2112 params = %{email_notifications: email_notifications}
2113 fields = [:email_notifications]
2116 |> cast(params, fields)
2117 |> validate_required(fields)
2118 |> update_and_set_cache()
2121 defp set_domain_blocks(user, domain_blocks) do
2122 params = %{domain_blocks: domain_blocks}
2125 |> cast(params, [:domain_blocks])
2126 |> validate_required([:domain_blocks])
2127 |> update_and_set_cache()
2130 def block_domain(user, domain_blocked) do
2131 set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2134 def unblock_domain(user, domain_blocked) do
2135 set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2138 @spec add_to_block(User.t(), User.t()) ::
2139 {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2140 defp add_to_block(%User{} = user, %User{} = blocked) do
2141 UserRelationship.create_block(user, blocked)
2144 @spec add_to_block(User.t(), User.t()) ::
2145 {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2146 defp remove_from_block(%User{} = user, %User{} = blocked) do
2147 UserRelationship.delete_block(user, blocked)
2150 defp add_to_mutes(%User{} = user, %User{} = muted_user, notifications?) do
2151 with {:ok, user_mute} <- UserRelationship.create_mute(user, muted_user),
2152 {:ok, user_notification_mute} <-
2153 (notifications? && UserRelationship.create_notification_mute(user, muted_user)) ||
2155 {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
2159 defp remove_from_mutes(user, %User{} = muted_user) do
2160 with {:ok, user_mute} <- UserRelationship.delete_mute(user, muted_user),
2161 {:ok, user_notification_mute} <-
2162 UserRelationship.delete_notification_mute(user, muted_user) do
2163 {:ok, [user_mute, user_notification_mute]}
2167 def set_invisible(user, invisible) do
2168 params = %{invisible: invisible}
2171 |> cast(params, [:invisible])
2172 |> validate_required([:invisible])
2173 |> update_and_set_cache()
2176 def sanitize_html(%User{} = user) do
2177 sanitize_html(user, nil)
2180 # User data that mastodon isn't filtering (treated as plaintext):
2183 def sanitize_html(%User{} = user, filter) do
2185 Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2188 "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2193 |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2194 |> Map.put(:fields, fields)