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 case Config.get([:instance, :account_activation_required]) do
266 true -> :confirmation_pending
271 def account_status(%User{}), do: :active
273 @spec visible_for?(User.t(), User.t() | nil) :: boolean()
274 def visible_for?(user, for_user \\ nil)
276 def visible_for?(%User{invisible: true}, _), do: false
278 def visible_for?(%User{id: user_id}, %User{id: user_id}), do: true
280 def visible_for?(%User{local: local} = user, nil) do
286 if Config.get([:restrict_unauthenticated, :profiles, cfg_key]),
288 else: account_status(user) == :active
291 def visible_for?(%User{} = user, for_user) do
292 account_status(user) == :active || superuser?(for_user)
295 def visible_for?(_, _), do: false
297 @spec superuser?(User.t()) :: boolean()
298 def superuser?(%User{local: true, is_admin: true}), do: true
299 def superuser?(%User{local: true, is_moderator: true}), do: true
300 def superuser?(_), do: false
302 @spec invisible?(User.t()) :: boolean()
303 def invisible?(%User{invisible: true}), do: true
304 def invisible?(_), do: false
306 def avatar_url(user, options \\ []) do
308 %{"url" => [%{"href" => href} | _]} -> href
309 _ -> !options[:no_default] && "#{Web.base_url()}/images/avi.png"
313 def banner_url(user, options \\ []) do
315 %{"url" => [%{"href" => href} | _]} -> href
316 _ -> !options[:no_default] && "#{Web.base_url()}/images/banner.png"
320 # Should probably be renamed or removed
321 def ap_id(%User{nickname: nickname}), do: "#{Web.base_url()}/users/#{nickname}"
323 def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
324 def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"
326 @spec ap_following(User.t()) :: String.t()
327 def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
328 def ap_following(%User{} = user), do: "#{ap_id(user)}/following"
330 @spec restrict_deactivated(Ecto.Query.t()) :: Ecto.Query.t()
331 def restrict_deactivated(query) do
332 from(u in query, where: u.deactivated != ^true)
335 defdelegate following_count(user), to: FollowingRelationship
337 defp truncate_fields_param(params) do
338 if Map.has_key?(params, :fields) do
339 Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
345 defp truncate_if_exists(params, key, max_length) do
346 if Map.has_key?(params, key) and is_binary(params[key]) do
347 {value, _chopped} = String.split_at(params[key], max_length)
348 Map.put(params, key, value)
354 defp fix_follower_address(%{follower_address: _, following_address: _} = params), do: params
356 defp fix_follower_address(%{nickname: nickname} = params),
357 do: Map.put(params, :follower_address, ap_followers(%User{nickname: nickname}))
359 defp fix_follower_address(params), do: params
361 def remote_user_changeset(struct \\ %User{local: false}, params) do
362 bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
363 name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
366 case params[:name] do
367 name when is_binary(name) and byte_size(name) > 0 -> name
368 _ -> params[:nickname]
373 |> Map.put(:name, name)
374 |> Map.put_new(:last_refreshed_at, NaiveDateTime.utc_now())
375 |> truncate_if_exists(:name, name_limit)
376 |> truncate_if_exists(:bio, bio_limit)
377 |> truncate_fields_param()
378 |> fix_follower_address()
402 :hide_followers_count,
413 |> validate_required([:name, :ap_id])
414 |> unique_constraint(:nickname)
415 |> validate_format(:nickname, @email_regex)
416 |> validate_length(:bio, max: bio_limit)
417 |> validate_length(:name, max: name_limit)
418 |> validate_fields(true)
421 def update_changeset(struct, params \\ %{}) do
422 bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
423 name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
442 :hide_followers_count,
445 :allow_following_move,
448 :skip_thread_containment,
451 :pleroma_settings_store,
457 |> unique_constraint(:nickname)
458 |> validate_format(:nickname, local_nickname_regex())
459 |> validate_length(:bio, max: bio_limit)
460 |> validate_length(:name, min: 1, max: name_limit)
463 |> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
464 |> put_change_if_present(:avatar, &put_upload(&1, :avatar))
465 |> put_change_if_present(:banner, &put_upload(&1, :banner))
466 |> put_change_if_present(:background, &put_upload(&1, :background))
467 |> put_change_if_present(
468 :pleroma_settings_store,
469 &{:ok, Map.merge(struct.pleroma_settings_store, &1)}
471 |> validate_fields(false)
474 defp put_fields(changeset) do
475 if raw_fields = get_change(changeset, :raw_fields) do
478 |> Enum.filter(fn %{"name" => n} -> n != "" end)
482 |> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)
485 |> put_change(:raw_fields, raw_fields)
486 |> put_change(:fields, fields)
492 defp parse_fields(value) do
494 |> Formatter.linkify(mentions_format: :full)
498 defp put_emoji(changeset) do
499 bio = get_change(changeset, :bio)
500 name = get_change(changeset, :name)
503 emoji = Map.merge(Emoji.Formatter.get_emoji_map(bio), Emoji.Formatter.get_emoji_map(name))
504 put_change(changeset, :emoji, emoji)
510 defp put_change_if_present(changeset, map_field, value_function) do
511 if value = get_change(changeset, map_field) do
512 with {:ok, new_value} <- value_function.(value) do
513 put_change(changeset, map_field, new_value)
522 defp put_upload(value, type) do
523 with %Plug.Upload{} <- value,
524 {:ok, object} <- ActivityPub.upload(value, type: type) do
529 def update_as_admin_changeset(struct, params) do
531 |> update_changeset(params)
532 |> cast(params, [:email])
533 |> delete_change(:also_known_as)
534 |> unique_constraint(:email)
535 |> validate_format(:email, @email_regex)
538 @spec update_as_admin(%User{}, map) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
539 def update_as_admin(user, params) do
540 params = Map.put(params, "password_confirmation", params["password"])
541 changeset = update_as_admin_changeset(user, params)
543 if params["password"] do
544 reset_password(user, changeset, params)
546 User.update_and_set_cache(changeset)
550 def password_update_changeset(struct, params) do
552 |> cast(params, [:password, :password_confirmation])
553 |> validate_required([:password, :password_confirmation])
554 |> validate_confirmation(:password)
555 |> put_password_hash()
556 |> put_change(:password_reset_pending, false)
559 @spec reset_password(User.t(), map) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
560 def reset_password(%User{} = user, params) do
561 reset_password(user, user, params)
564 def reset_password(%User{id: user_id} = user, struct, params) do
567 |> Multi.update(:user, password_update_changeset(struct, params))
568 |> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
569 |> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))
571 case Repo.transaction(multi) do
572 {:ok, %{user: user} = _} -> set_cache(user)
573 {:error, _, changeset, _} -> {:error, changeset}
577 def update_password_reset_pending(user, value) do
580 |> put_change(:password_reset_pending, value)
581 |> update_and_set_cache()
584 def force_password_reset_async(user) do
585 BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
588 @spec force_password_reset(User.t()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
589 def force_password_reset(user), do: update_password_reset_pending(user, true)
591 def register_changeset(struct, params \\ %{}, opts \\ []) do
592 bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
593 name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
596 if is_nil(opts[:need_confirmation]) do
597 Pleroma.Config.get([:instance, :account_activation_required])
599 opts[:need_confirmation]
603 |> confirmation_changeset(need_confirmation: need_confirmation?)
604 |> cast(params, [:bio, :email, :name, :nickname, :password, :password_confirmation, :emoji])
605 |> validate_required([:name, :nickname, :password, :password_confirmation])
606 |> validate_confirmation(:password)
607 |> unique_constraint(:email)
608 |> unique_constraint(:nickname)
609 |> validate_exclusion(:nickname, Pleroma.Config.get([User, :restricted_nicknames]))
610 |> validate_format(:nickname, local_nickname_regex())
611 |> validate_format(:email, @email_regex)
612 |> validate_length(:bio, max: bio_limit)
613 |> validate_length(:name, min: 1, max: name_limit)
614 |> maybe_validate_required_email(opts[:external])
617 |> unique_constraint(:ap_id)
618 |> put_following_and_follower_address()
621 def maybe_validate_required_email(changeset, true), do: changeset
623 def maybe_validate_required_email(changeset, _) do
624 if Pleroma.Config.get([:instance, :account_activation_required]) do
625 validate_required(changeset, [:email])
631 defp put_ap_id(changeset) do
632 ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
633 put_change(changeset, :ap_id, ap_id)
636 defp put_following_and_follower_address(changeset) do
637 followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
640 |> put_change(:follower_address, followers)
643 defp autofollow_users(user) do
644 candidates = Pleroma.Config.get([:instance, :autofollowed_nicknames])
647 User.Query.build(%{nickname: candidates, local: true, deactivated: false})
650 follow_all(user, autofollowed_users)
653 @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
654 def register(%Ecto.Changeset{} = changeset) do
655 with {:ok, user} <- Repo.insert(changeset) do
656 post_register_action(user)
660 def post_register_action(%User{} = user) do
661 with {:ok, user} <- autofollow_users(user),
662 {:ok, user} <- set_cache(user),
663 {:ok, _} <- User.WelcomeMessage.post_welcome_message_to_user(user),
664 {:ok, _} <- try_send_confirmation_email(user) do
669 def try_send_confirmation_email(%User{} = user) do
670 if user.confirmation_pending &&
671 Pleroma.Config.get([:instance, :account_activation_required]) do
673 |> Pleroma.Emails.UserEmail.account_confirmation_email()
674 |> Pleroma.Emails.Mailer.deliver_async()
682 def try_send_confirmation_email(users) do
683 Enum.each(users, &try_send_confirmation_email/1)
686 def needs_update?(%User{local: true}), do: false
688 def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
690 def needs_update?(%User{local: false} = user) do
691 NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
694 def needs_update?(_), do: true
696 @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
698 # "Locked" (self-locked) users demand explicit authorization of follow requests
699 def maybe_direct_follow(%User{} = follower, %User{local: true, locked: true} = followed) do
700 follow(follower, followed, :follow_pending)
703 def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
704 follow(follower, followed)
707 def maybe_direct_follow(%User{} = follower, %User{} = followed) do
708 if not ap_enabled?(followed) do
709 follow(follower, followed)
715 @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
716 @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
717 def follow_all(follower, followeds) do
719 |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
720 |> Enum.each(&follow(follower, &1, :follow_accept))
725 defdelegate following(user), to: FollowingRelationship
727 def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
728 deny_follow_blocked = Pleroma.Config.get([:user, :deny_follow_blocked])
731 followed.deactivated ->
732 {:error, "Could not follow user: #{followed.nickname} is deactivated."}
734 deny_follow_blocked and blocks?(followed, follower) ->
735 {:error, "Could not follow user: #{followed.nickname} blocked you."}
738 FollowingRelationship.follow(follower, followed, state)
740 {:ok, _} = update_follower_count(followed)
743 |> update_following_count()
748 def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
749 {:error, "Not subscribed!"}
752 def unfollow(%User{} = follower, %User{} = followed) do
753 case get_follow_state(follower, followed) do
754 state when state in [:follow_pending, :follow_accept] ->
755 FollowingRelationship.unfollow(follower, followed)
756 {:ok, followed} = update_follower_count(followed)
760 |> update_following_count()
763 {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
766 {:error, "Not subscribed!"}
770 defdelegate following?(follower, followed), to: FollowingRelationship
772 @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
773 def get_follow_state(%User{} = follower, %User{} = following) do
774 following_relationship = FollowingRelationship.get(follower, following)
775 get_follow_state(follower, following, following_relationship)
778 def get_follow_state(
781 following_relationship
783 case {following_relationship, following.local} do
785 case Utils.fetch_latest_follow(follower, following) do
786 %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
787 FollowingRelationship.state_to_enum(state)
793 {%{state: state}, _} ->
801 def locked?(%User{} = user) do
806 Repo.get_by(User, id: id)
809 def get_by_ap_id(ap_id) do
810 Repo.get_by(User, ap_id: ap_id)
813 def get_all_by_ap_id(ap_ids) do
814 from(u in __MODULE__,
815 where: u.ap_id in ^ap_ids
820 def get_all_by_ids(ids) do
821 from(u in __MODULE__, where: u.id in ^ids)
825 # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
826 # of the ap_id and the domain and tries to get that user
827 def get_by_guessed_nickname(ap_id) do
828 domain = URI.parse(ap_id).host
829 name = List.last(String.split(ap_id, "/"))
830 nickname = "#{name}@#{domain}"
832 get_cached_by_nickname(nickname)
835 def set_cache({:ok, user}), do: set_cache(user)
836 def set_cache({:error, err}), do: {:error, err}
838 def set_cache(%User{} = user) do
839 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
840 Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
841 Cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
845 def update_and_set_cache(struct, params) do
847 |> update_changeset(params)
848 |> update_and_set_cache()
851 def update_and_set_cache(changeset) do
852 with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
857 def get_user_friends_ap_ids(user) do
858 from(u in User.get_friends_query(user), select: u.ap_id)
862 @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
863 def get_cached_user_friends_ap_ids(user) do
864 Cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
865 get_user_friends_ap_ids(user)
869 def invalidate_cache(user) do
870 Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
871 Cachex.del(:user_cache, "nickname:#{user.nickname}")
872 Cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
875 @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
876 def get_cached_by_ap_id(ap_id) do
877 key = "ap_id:#{ap_id}"
879 with {:ok, nil} <- Cachex.get(:user_cache, key),
880 user when not is_nil(user) <- get_by_ap_id(ap_id),
881 {:ok, true} <- Cachex.put(:user_cache, key, user) do
889 def get_cached_by_id(id) do
893 Cachex.fetch!(:user_cache, key, fn _ ->
897 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
898 {:commit, user.ap_id}
904 get_cached_by_ap_id(ap_id)
907 def get_cached_by_nickname(nickname) do
908 key = "nickname:#{nickname}"
910 Cachex.fetch!(:user_cache, key, fn ->
911 case get_or_fetch_by_nickname(nickname) do
912 {:ok, user} -> {:commit, user}
913 {:error, _error} -> {:ignore, nil}
918 def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
919 restrict_to_local = Pleroma.Config.get([:instance, :limit_to_local_content])
922 is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
923 get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
925 restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
926 get_cached_by_nickname(nickname_or_id)
928 restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
929 get_cached_by_nickname(nickname_or_id)
936 @spec get_by_nickname(String.t()) :: User.t() | nil
937 def get_by_nickname(nickname) do
938 Repo.get_by(User, nickname: nickname) ||
939 if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
940 Repo.get_by(User, nickname: local_nickname(nickname))
944 def get_by_email(email), do: Repo.get_by(User, email: email)
946 def get_by_nickname_or_email(nickname_or_email) do
947 get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
950 def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
952 def get_or_fetch_by_nickname(nickname) do
953 with %User{} = user <- get_by_nickname(nickname) do
957 with [_nick, _domain] <- String.split(nickname, "@"),
958 {:ok, user} <- fetch_by_nickname(nickname) do
961 _e -> {:error, "not found " <> nickname}
966 @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
967 def get_followers_query(%User{} = user, nil) do
968 User.Query.build(%{followers: user, deactivated: false})
971 def get_followers_query(user, page) do
973 |> get_followers_query(nil)
974 |> User.Query.paginate(page, 20)
977 @spec get_followers_query(User.t()) :: Ecto.Query.t()
978 def get_followers_query(user), do: get_followers_query(user, nil)
980 @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
981 def get_followers(user, page \\ nil) do
983 |> get_followers_query(page)
987 @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
988 def get_external_followers(user, page \\ nil) do
990 |> get_followers_query(page)
991 |> User.Query.build(%{external: true})
995 def get_followers_ids(user, page \\ nil) do
997 |> get_followers_query(page)
1002 @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1003 def get_friends_query(%User{} = user, nil) do
1004 User.Query.build(%{friends: user, deactivated: false})
1007 def get_friends_query(user, page) do
1009 |> get_friends_query(nil)
1010 |> User.Query.paginate(page, 20)
1013 @spec get_friends_query(User.t()) :: Ecto.Query.t()
1014 def get_friends_query(user), do: get_friends_query(user, nil)
1016 def get_friends(user, page \\ nil) do
1018 |> get_friends_query(page)
1022 def get_friends_ap_ids(user) do
1024 |> get_friends_query(nil)
1025 |> select([u], u.ap_id)
1029 def get_friends_ids(user, page \\ nil) do
1031 |> get_friends_query(page)
1032 |> select([u], u.id)
1036 defdelegate get_follow_requests(user), to: FollowingRelationship
1038 def increase_note_count(%User{} = user) do
1040 |> where(id: ^user.id)
1041 |> update([u], inc: [note_count: 1])
1043 |> Repo.update_all([])
1045 {1, [user]} -> set_cache(user)
1050 def decrease_note_count(%User{} = user) do
1052 |> where(id: ^user.id)
1055 note_count: fragment("greatest(0, note_count - 1)")
1059 |> Repo.update_all([])
1061 {1, [user]} -> set_cache(user)
1066 def update_note_count(%User{} = user, note_count \\ nil) do
1071 where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1077 |> cast(%{note_count: note_count}, [:note_count])
1078 |> update_and_set_cache()
1081 @spec maybe_fetch_follow_information(User.t()) :: User.t()
1082 def maybe_fetch_follow_information(user) do
1083 with {:ok, user} <- fetch_follow_information(user) do
1087 Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1093 def fetch_follow_information(user) do
1094 with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1096 |> follow_information_changeset(info)
1097 |> update_and_set_cache()
1101 defp follow_information_changeset(user, params) do
1108 :hide_followers_count,
1113 def update_follower_count(%User{} = user) do
1114 if user.local or !Pleroma.Config.get([:instance, :external_user_synchronization]) do
1115 follower_count_query =
1116 User.Query.build(%{followers: user, deactivated: false})
1117 |> select([u], %{count: count(u.id)})
1120 |> where(id: ^user.id)
1121 |> join(:inner, [u], s in subquery(follower_count_query))
1123 set: [follower_count: s.count]
1126 |> Repo.update_all([])
1128 {1, [user]} -> set_cache(user)
1132 {:ok, maybe_fetch_follow_information(user)}
1136 @spec update_following_count(User.t()) :: User.t()
1137 def update_following_count(%User{local: false} = user) do
1138 if Pleroma.Config.get([:instance, :external_user_synchronization]) do
1139 maybe_fetch_follow_information(user)
1145 def update_following_count(%User{local: true} = user) do
1146 following_count = FollowingRelationship.following_count(user)
1149 |> follow_information_changeset(%{following_count: following_count})
1153 def set_unread_conversation_count(%User{local: true} = user) do
1154 unread_query = Participation.unread_conversation_count_for_user(user)
1157 |> join(:inner, [u], p in subquery(unread_query))
1159 set: [unread_conversation_count: p.count]
1161 |> where([u], u.id == ^user.id)
1163 |> Repo.update_all([])
1165 {1, [user]} -> set_cache(user)
1170 def set_unread_conversation_count(user), do: {:ok, user}
1172 def increment_unread_conversation_count(conversation, %User{local: true} = user) do
1174 Participation.unread_conversation_count_for_user(user)
1175 |> where([p], p.conversation_id == ^conversation.id)
1178 |> join(:inner, [u], p in subquery(unread_query))
1180 inc: [unread_conversation_count: 1]
1182 |> where([u], u.id == ^user.id)
1183 |> where([u, p], p.count == 0)
1185 |> Repo.update_all([])
1187 {1, [user]} -> set_cache(user)
1192 def increment_unread_conversation_count(_, user), do: {:ok, user}
1194 @spec get_users_from_set([String.t()], boolean()) :: [User.t()]
1195 def get_users_from_set(ap_ids, local_only \\ true) do
1196 criteria = %{ap_id: ap_ids, deactivated: false}
1197 criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1199 User.Query.build(criteria)
1203 @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1204 def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1207 query = User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
1213 @spec mute(User.t(), User.t(), boolean()) ::
1214 {:ok, list(UserRelationship.t())} | {:error, String.t()}
1215 def mute(%User{} = muter, %User{} = mutee, notifications? \\ true) do
1216 add_to_mutes(muter, mutee, notifications?)
1219 def unmute(%User{} = muter, %User{} = mutee) do
1220 remove_from_mutes(muter, mutee)
1223 def subscribe(%User{} = subscriber, %User{} = target) do
1224 deny_follow_blocked = Pleroma.Config.get([:user, :deny_follow_blocked])
1226 if blocks?(target, subscriber) and deny_follow_blocked do
1227 {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1229 # Note: the relationship is inverse: subscriber acts as relationship target
1230 UserRelationship.create_inverse_subscription(target, subscriber)
1234 def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1235 with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1236 subscribe(subscriber, subscribee)
1240 def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1241 # Note: the relationship is inverse: subscriber acts as relationship target
1242 UserRelationship.delete_inverse_subscription(target, unsubscriber)
1245 def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1246 with %User{} = user <- get_cached_by_ap_id(ap_id) do
1247 unsubscribe(unsubscriber, user)
1251 def block(%User{} = blocker, %User{} = blocked) do
1252 # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1254 if following?(blocker, blocked) do
1255 {:ok, blocker, _} = unfollow(blocker, blocked)
1261 # clear any requested follows as well
1263 case CommonAPI.reject_follow_request(blocked, blocker) do
1264 {:ok, %User{} = updated_blocked} -> updated_blocked
1268 unsubscribe(blocked, blocker)
1270 if following?(blocked, blocker), do: unfollow(blocked, blocker)
1272 {:ok, blocker} = update_follower_count(blocker)
1273 {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1274 add_to_block(blocker, blocked)
1277 # helper to handle the block given only an actor's AP id
1278 def block(%User{} = blocker, %{ap_id: ap_id}) do
1279 block(blocker, get_cached_by_ap_id(ap_id))
1282 def unblock(%User{} = blocker, %User{} = blocked) do
1283 remove_from_block(blocker, blocked)
1286 # helper to handle the block given only an actor's AP id
1287 def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1288 unblock(blocker, get_cached_by_ap_id(ap_id))
1291 def mutes?(nil, _), do: false
1292 def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1294 def mutes_user?(%User{} = user, %User{} = target) do
1295 UserRelationship.mute_exists?(user, target)
1298 @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1299 def muted_notifications?(nil, _), do: false
1301 def muted_notifications?(%User{} = user, %User{} = target),
1302 do: UserRelationship.notification_mute_exists?(user, target)
1304 def blocks?(nil, _), do: false
1306 def blocks?(%User{} = user, %User{} = target) do
1307 blocks_user?(user, target) ||
1308 (blocks_domain?(user, target) and not User.following?(user, target))
1311 def blocks_user?(%User{} = user, %User{} = target) do
1312 UserRelationship.block_exists?(user, target)
1315 def blocks_user?(_, _), do: false
1317 def blocks_domain?(%User{} = user, %User{} = target) do
1318 domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1319 %{host: host} = URI.parse(target.ap_id)
1320 Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1323 def blocks_domain?(_, _), do: false
1325 def subscribed_to?(%User{} = user, %User{} = target) do
1326 # Note: the relationship is inverse: subscriber acts as relationship target
1327 UserRelationship.inverse_subscription_exists?(target, user)
1330 def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1331 with %User{} = target <- get_cached_by_ap_id(ap_id) do
1332 subscribed_to?(user, target)
1337 Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1338 E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1340 @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1341 def outgoing_relationships_ap_ids(_user, []), do: %{}
1343 def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1345 def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1346 when is_list(relationship_types) do
1349 |> assoc(:outgoing_relationships)
1350 |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1351 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1352 |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1353 |> group_by([user_rel, u], user_rel.relationship_type)
1355 |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1360 fn rel_type -> {rel_type, db_result[rel_type] || []} end
1364 def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1366 def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1368 def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1370 def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1371 when is_list(relationship_types) do
1373 |> assoc(:incoming_relationships)
1374 |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1375 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1376 |> maybe_filter_on_ap_id(ap_ids)
1377 |> select([user_rel, u], u.ap_id)
1382 defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1383 where(query, [user_rel, u], u.ap_id in ^ap_ids)
1386 defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1388 def deactivate_async(user, status \\ true) do
1389 BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
1392 def deactivate(user, status \\ true)
1394 def deactivate(users, status) when is_list(users) do
1395 Repo.transaction(fn ->
1396 for user <- users, do: deactivate(user, status)
1400 def deactivate(%User{} = user, status) do
1401 with {:ok, user} <- set_activation_status(user, status) do
1404 |> Enum.filter(& &1.local)
1405 |> Enum.each(fn follower ->
1406 follower |> update_following_count() |> set_cache()
1409 # Only update local user counts, remote will be update during the next pull.
1412 |> Enum.filter(& &1.local)
1413 |> Enum.each(&update_follower_count/1)
1419 def update_notification_settings(%User{} = user, settings) do
1421 |> cast(%{notification_settings: settings}, [])
1422 |> cast_embed(:notification_settings)
1423 |> validate_required([:notification_settings])
1424 |> update_and_set_cache()
1427 def delete(users) when is_list(users) do
1428 for user <- users, do: delete(user)
1431 def delete(%User{} = user) do
1432 BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1435 def perform(:force_password_reset, user), do: force_password_reset(user)
1437 @spec perform(atom(), User.t()) :: {:ok, User.t()}
1438 def perform(:delete, %User{} = user) do
1439 # Remove all relationships
1442 |> Enum.each(fn follower ->
1443 ActivityPub.unfollow(follower, user)
1444 unfollow(follower, user)
1449 |> Enum.each(fn followed ->
1450 ActivityPub.unfollow(user, followed)
1451 unfollow(user, followed)
1454 delete_user_activities(user)
1458 |> change(%{deactivated: true, email: nil})
1459 |> update_and_set_cache()
1461 invalidate_cache(user)
1466 def perform(:deactivate_async, user, status), do: deactivate(user, status)
1468 @spec perform(atom(), User.t(), list()) :: list() | {:error, any()}
1469 def perform(:blocks_import, %User{} = blocker, blocked_identifiers)
1470 when is_list(blocked_identifiers) do
1472 blocked_identifiers,
1473 fn blocked_identifier ->
1474 with {:ok, %User{} = blocked} <- get_or_fetch(blocked_identifier),
1475 {:ok, _user_block} <- block(blocker, blocked),
1476 {:ok, _} <- ActivityPub.block(blocker, blocked) do
1480 Logger.debug("blocks_import failed for #{blocked_identifier} with: #{inspect(err)}")
1487 def perform(:follow_import, %User{} = follower, followed_identifiers)
1488 when is_list(followed_identifiers) do
1490 followed_identifiers,
1491 fn followed_identifier ->
1492 with {:ok, %User{} = followed} <- get_or_fetch(followed_identifier),
1493 {:ok, follower} <- maybe_direct_follow(follower, followed),
1494 {:ok, _} <- ActivityPub.follow(follower, followed) do
1498 Logger.debug("follow_import failed for #{followed_identifier} with: #{inspect(err)}")
1505 @spec external_users_query() :: Ecto.Query.t()
1506 def external_users_query do
1514 @spec external_users(keyword()) :: [User.t()]
1515 def external_users(opts \\ []) do
1517 external_users_query()
1518 |> select([u], struct(u, [:id, :ap_id]))
1522 do: where(query, [u], u.id > ^opts[:max_id]),
1527 do: limit(query, ^opts[:limit]),
1533 def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers) do
1534 BackgroundWorker.enqueue("blocks_import", %{
1535 "blocker_id" => blocker.id,
1536 "blocked_identifiers" => blocked_identifiers
1540 def follow_import(%User{} = follower, followed_identifiers)
1541 when is_list(followed_identifiers) do
1542 BackgroundWorker.enqueue("follow_import", %{
1543 "follower_id" => follower.id,
1544 "followed_identifiers" => followed_identifiers
1548 def delete_user_activities(%User{ap_id: ap_id} = user) do
1550 |> Activity.Queries.by_actor()
1551 |> RepoStreamer.chunk_stream(50)
1552 |> Stream.each(fn activities ->
1553 Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1558 defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1559 with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1560 {:ok, delete_data, _} <- Builder.delete(user, object) do
1561 Pipeline.common_pipeline(delete_data, local: user.local)
1563 {:find_object, nil} ->
1564 # We have the create activity, but not the object, it was probably pruned.
1565 # Insert a tombstone and try again
1566 with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1567 {:ok, _tombstone} <- Object.create(tombstone_data) do
1568 delete_activity(activity, user)
1572 Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1573 Logger.error("Error: #{inspect(e)}")
1577 defp delete_activity(%{data: %{"type" => type}} = activity, user)
1578 when type in ["Like", "Announce"] do
1579 {:ok, undo, _} = Builder.undo(user, activity)
1580 Pipeline.common_pipeline(undo, local: user.local)
1583 defp delete_activity(_activity, _user), do: "Doing nothing"
1585 def html_filter_policy(%User{no_rich_text: true}) do
1586 Pleroma.HTML.Scrubber.TwitterText
1589 def html_filter_policy(_), do: Pleroma.Config.get([:markup, :scrub_policy])
1591 def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1593 def get_or_fetch_by_ap_id(ap_id) do
1594 user = get_cached_by_ap_id(ap_id)
1596 if !is_nil(user) and !needs_update?(user) do
1599 fetch_by_ap_id(ap_id)
1604 Creates an internal service actor by URI if missing.
1605 Optionally takes nickname for addressing.
1607 @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1608 def get_or_create_service_actor_by_ap_id(uri, nickname) do
1610 case get_cached_by_ap_id(uri) do
1612 with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1613 Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1617 %User{invisible: false} = user ->
1627 @spec set_invisible(User.t()) :: {:ok, User.t()}
1628 defp set_invisible(user) do
1630 |> change(%{invisible: true})
1631 |> update_and_set_cache()
1634 @spec create_service_actor(String.t(), String.t()) ::
1635 {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1636 defp create_service_actor(uri, nickname) do
1642 follower_address: uri <> "/followers"
1645 |> unique_constraint(:nickname)
1650 def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1653 |> :public_key.pem_decode()
1655 |> :public_key.pem_entry_decode()
1660 def public_key(_), do: {:error, "key not found"}
1662 def get_public_key_for_ap_id(ap_id) do
1663 with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1664 {:ok, public_key} <- public_key(user) do
1671 def ap_enabled?(%User{local: true}), do: true
1672 def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1673 def ap_enabled?(_), do: false
1675 @doc "Gets or fetch a user by uri or nickname."
1676 @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1677 def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1678 def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1680 # wait a period of time and return newest version of the User structs
1681 # this is because we have synchronous follow APIs and need to simulate them
1682 # with an async handshake
1683 def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1684 with %User{} = a <- get_cached_by_id(a.id),
1685 %User{} = b <- get_cached_by_id(b.id) do
1692 def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1693 with :ok <- :timer.sleep(timeout),
1694 %User{} = a <- get_cached_by_id(a.id),
1695 %User{} = b <- get_cached_by_id(b.id) do
1702 def parse_bio(bio) when is_binary(bio) and bio != "" do
1704 |> CommonUtils.format_input("text/plain", mentions_format: :full)
1708 def parse_bio(_), do: ""
1710 def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1711 # TODO: get profile URLs other than user.ap_id
1712 profile_urls = [user.ap_id]
1715 |> CommonUtils.format_input("text/plain",
1716 mentions_format: :full,
1717 rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1722 def parse_bio(_, _), do: ""
1724 def tag(user_identifiers, tags) when is_list(user_identifiers) do
1725 Repo.transaction(fn ->
1726 for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1730 def tag(nickname, tags) when is_binary(nickname),
1731 do: tag(get_by_nickname(nickname), tags)
1733 def tag(%User{} = user, tags),
1734 do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1736 def untag(user_identifiers, tags) when is_list(user_identifiers) do
1737 Repo.transaction(fn ->
1738 for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1742 def untag(nickname, tags) when is_binary(nickname),
1743 do: untag(get_by_nickname(nickname), tags)
1745 def untag(%User{} = user, tags),
1746 do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1748 defp update_tags(%User{} = user, new_tags) do
1749 {:ok, updated_user} =
1751 |> change(%{tags: new_tags})
1752 |> update_and_set_cache()
1757 defp normalize_tags(tags) do
1760 |> Enum.map(&String.downcase/1)
1763 defp local_nickname_regex do
1764 if Pleroma.Config.get([:instance, :extended_nickname_format]) do
1765 @extended_local_nickname_regex
1767 @strict_local_nickname_regex
1771 def local_nickname(nickname_or_mention) do
1774 |> String.split("@")
1778 def full_nickname(nickname_or_mention),
1779 do: String.trim_leading(nickname_or_mention, "@")
1781 def error_user(ap_id) do
1785 nickname: "erroruser@example.com",
1786 inserted_at: NaiveDateTime.utc_now()
1790 @spec all_superusers() :: [User.t()]
1791 def all_superusers do
1792 User.Query.build(%{super_users: true, local: true, deactivated: false})
1796 def muting_reblogs?(%User{} = user, %User{} = target) do
1797 UserRelationship.reblog_mute_exists?(user, target)
1800 def showing_reblogs?(%User{} = user, %User{} = target) do
1801 not muting_reblogs?(user, target)
1805 The function returns a query to get users with no activity for given interval of days.
1806 Inactive users are those who didn't read any notification, or had any activity where
1807 the user is the activity's actor, during `inactivity_threshold` days.
1808 Deactivated users will not appear in this list.
1812 iex> Pleroma.User.list_inactive_users()
1815 @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
1816 def list_inactive_users_query(inactivity_threshold \\ 7) do
1817 negative_inactivity_threshold = -inactivity_threshold
1818 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
1819 # Subqueries are not supported in `where` clauses, join gets too complicated.
1820 has_read_notifications =
1821 from(n in Pleroma.Notification,
1822 where: n.seen == true,
1824 having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
1827 |> Pleroma.Repo.all()
1829 from(u in Pleroma.User,
1830 left_join: a in Pleroma.Activity,
1831 on: u.ap_id == a.actor,
1832 where: not is_nil(u.nickname),
1833 where: u.deactivated != ^true,
1834 where: u.id not in ^has_read_notifications,
1837 max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
1838 is_nil(max(a.inserted_at))
1843 Enable or disable email notifications for user
1847 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
1848 Pleroma.User{email_notifications: %{"digest" => true}}
1850 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
1851 Pleroma.User{email_notifications: %{"digest" => false}}
1853 @spec switch_email_notifications(t(), String.t(), boolean()) ::
1854 {:ok, t()} | {:error, Ecto.Changeset.t()}
1855 def switch_email_notifications(user, type, status) do
1856 User.update_email_notifications(user, %{type => status})
1860 Set `last_digest_emailed_at` value for the user to current time
1862 @spec touch_last_digest_emailed_at(t()) :: t()
1863 def touch_last_digest_emailed_at(user) do
1864 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
1866 {:ok, updated_user} =
1868 |> change(%{last_digest_emailed_at: now})
1869 |> update_and_set_cache()
1874 @spec toggle_confirmation(User.t()) :: {:ok, User.t()} | {:error, Changeset.t()}
1875 def toggle_confirmation(%User{} = user) do
1877 |> confirmation_changeset(need_confirmation: !user.confirmation_pending)
1878 |> update_and_set_cache()
1881 @spec toggle_confirmation([User.t()]) :: [{:ok, User.t()} | {:error, Changeset.t()}]
1882 def toggle_confirmation(users) do
1883 Enum.map(users, &toggle_confirmation/1)
1886 def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
1890 def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
1891 # use instance-default
1892 config = Pleroma.Config.get([:assets, :mascots])
1893 default_mascot = Pleroma.Config.get([:assets, :default_mascot])
1894 mascot = Keyword.get(config, default_mascot)
1897 "id" => "default-mascot",
1898 "url" => mascot[:url],
1899 "preview_url" => mascot[:url],
1901 "mime_type" => mascot[:mime_type]
1906 def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
1908 def ensure_keys_present(%User{} = user) do
1909 with {:ok, pem} <- Keys.generate_rsa_pem() do
1911 |> cast(%{keys: pem}, [:keys])
1912 |> validate_required([:keys])
1913 |> update_and_set_cache()
1917 def get_ap_ids_by_nicknames(nicknames) do
1919 where: u.nickname in ^nicknames,
1925 defdelegate search(query, opts \\ []), to: User.Search
1927 defp put_password_hash(
1928 %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
1930 change(changeset, password_hash: Pbkdf2.hash_pwd_salt(password))
1933 defp put_password_hash(changeset), do: changeset
1935 def is_internal_user?(%User{nickname: nil}), do: true
1936 def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
1937 def is_internal_user?(_), do: false
1939 # A hack because user delete activities have a fake id for whatever reason
1940 # TODO: Get rid of this
1941 def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
1943 def get_delivered_users_by_object_id(object_id) do
1945 inner_join: delivery in assoc(u, :deliveries),
1946 where: delivery.object_id == ^object_id
1951 def change_email(user, email) do
1953 |> cast(%{email: email}, [:email])
1954 |> validate_required([:email])
1955 |> unique_constraint(:email)
1956 |> validate_format(:email, @email_regex)
1957 |> update_and_set_cache()
1960 # Internal function; public one is `deactivate/2`
1961 defp set_activation_status(user, deactivated) do
1963 |> cast(%{deactivated: deactivated}, [:deactivated])
1964 |> update_and_set_cache()
1967 def update_banner(user, banner) do
1969 |> cast(%{banner: banner}, [:banner])
1970 |> update_and_set_cache()
1973 def update_background(user, background) do
1975 |> cast(%{background: background}, [:background])
1976 |> update_and_set_cache()
1979 def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
1982 moderator: is_moderator
1986 def validate_fields(changeset, remote? \\ false) do
1987 limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
1988 limit = Pleroma.Config.get([:instance, limit_name], 0)
1991 |> validate_length(:fields, max: limit)
1992 |> validate_change(:fields, fn :fields, fields ->
1993 if Enum.all?(fields, &valid_field?/1) do
2001 defp valid_field?(%{"name" => name, "value" => value}) do
2002 name_limit = Pleroma.Config.get([:instance, :account_field_name_length], 255)
2003 value_limit = Pleroma.Config.get([:instance, :account_field_value_length], 255)
2005 is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2006 String.length(value) <= value_limit
2009 defp valid_field?(_), do: false
2011 defp truncate_field(%{"name" => name, "value" => value}) do
2013 String.split_at(name, Pleroma.Config.get([:instance, :account_field_name_length], 255))
2016 String.split_at(value, Pleroma.Config.get([:instance, :account_field_value_length], 255))
2018 %{"name" => name, "value" => value}
2021 def admin_api_update(user, params) do
2028 |> update_and_set_cache()
2031 @doc "Signs user out of all applications"
2032 def global_sign_out(user) do
2033 OAuth.Authorization.delete_user_authorizations(user)
2034 OAuth.Token.delete_user_tokens(user)
2037 def mascot_update(user, url) do
2039 |> cast(%{mascot: url}, [:mascot])
2040 |> validate_required([:mascot])
2041 |> update_and_set_cache()
2044 def mastodon_settings_update(user, settings) do
2046 |> cast(%{settings: settings}, [:settings])
2047 |> validate_required([:settings])
2048 |> update_and_set_cache()
2051 @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2052 def confirmation_changeset(user, need_confirmation: need_confirmation?) do
2054 if need_confirmation? do
2056 confirmation_pending: true,
2057 confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2061 confirmation_pending: false,
2062 confirmation_token: nil
2066 cast(user, params, [:confirmation_pending, :confirmation_token])
2069 def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2070 if id not in user.pinned_activities do
2071 max_pinned_statuses = Pleroma.Config.get([:instance, :max_pinned_statuses], 0)
2072 params = %{pinned_activities: user.pinned_activities ++ [id]}
2075 |> cast(params, [:pinned_activities])
2076 |> validate_length(:pinned_activities,
2077 max: max_pinned_statuses,
2078 message: "You have already pinned the maximum number of statuses"
2083 |> update_and_set_cache()
2086 def remove_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2087 params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2090 |> cast(params, [:pinned_activities])
2091 |> update_and_set_cache()
2094 def update_email_notifications(user, settings) do
2095 email_notifications =
2096 user.email_notifications
2097 |> Map.merge(settings)
2098 |> Map.take(["digest"])
2100 params = %{email_notifications: email_notifications}
2101 fields = [:email_notifications]
2104 |> cast(params, fields)
2105 |> validate_required(fields)
2106 |> update_and_set_cache()
2109 defp set_domain_blocks(user, domain_blocks) do
2110 params = %{domain_blocks: domain_blocks}
2113 |> cast(params, [:domain_blocks])
2114 |> validate_required([:domain_blocks])
2115 |> update_and_set_cache()
2118 def block_domain(user, domain_blocked) do
2119 set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2122 def unblock_domain(user, domain_blocked) do
2123 set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2126 @spec add_to_block(User.t(), User.t()) ::
2127 {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2128 defp add_to_block(%User{} = user, %User{} = blocked) do
2129 UserRelationship.create_block(user, blocked)
2132 @spec add_to_block(User.t(), User.t()) ::
2133 {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2134 defp remove_from_block(%User{} = user, %User{} = blocked) do
2135 UserRelationship.delete_block(user, blocked)
2138 defp add_to_mutes(%User{} = user, %User{} = muted_user, notifications?) do
2139 with {:ok, user_mute} <- UserRelationship.create_mute(user, muted_user),
2140 {:ok, user_notification_mute} <-
2141 (notifications? && UserRelationship.create_notification_mute(user, muted_user)) ||
2143 {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
2147 defp remove_from_mutes(user, %User{} = muted_user) do
2148 with {:ok, user_mute} <- UserRelationship.delete_mute(user, muted_user),
2149 {:ok, user_notification_mute} <-
2150 UserRelationship.delete_notification_mute(user, muted_user) do
2151 {:ok, [user_mute, user_notification_mute]}
2155 def set_invisible(user, invisible) do
2156 params = %{invisible: invisible}
2159 |> cast(params, [:invisible])
2160 |> validate_required([:invisible])
2161 |> update_and_set_cache()
2164 def sanitize_html(%User{} = user) do
2165 sanitize_html(user, nil)
2168 # User data that mastodon isn't filtering (treated as plaintext):
2171 def sanitize_html(%User{} = user, filter) do
2173 Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2176 "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2181 |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2182 |> Map.put(:fields, fields)