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} | _]} ->
312 unless options[:no_default] do
313 Config.get([:assets, :default_user_avatar], "#{Web.base_url()}/images/avi.png")
318 def banner_url(user, options \\ []) do
320 %{"url" => [%{"href" => href} | _]} -> href
321 _ -> !options[:no_default] && "#{Web.base_url()}/images/banner.png"
325 # Should probably be renamed or removed
326 def ap_id(%User{nickname: nickname}), do: "#{Web.base_url()}/users/#{nickname}"
328 def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
329 def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"
331 @spec ap_following(User.t()) :: String.t()
332 def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
333 def ap_following(%User{} = user), do: "#{ap_id(user)}/following"
335 @spec restrict_deactivated(Ecto.Query.t()) :: Ecto.Query.t()
336 def restrict_deactivated(query) do
337 from(u in query, where: u.deactivated != ^true)
340 defdelegate following_count(user), to: FollowingRelationship
342 defp truncate_fields_param(params) do
343 if Map.has_key?(params, :fields) do
344 Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
350 defp truncate_if_exists(params, key, max_length) do
351 if Map.has_key?(params, key) and is_binary(params[key]) do
352 {value, _chopped} = String.split_at(params[key], max_length)
353 Map.put(params, key, value)
359 defp fix_follower_address(%{follower_address: _, following_address: _} = params), do: params
361 defp fix_follower_address(%{nickname: nickname} = params),
362 do: Map.put(params, :follower_address, ap_followers(%User{nickname: nickname}))
364 defp fix_follower_address(params), do: params
366 def remote_user_changeset(struct \\ %User{local: false}, params) do
367 bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
368 name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
371 case params[:name] do
372 name when is_binary(name) and byte_size(name) > 0 -> name
373 _ -> params[:nickname]
378 |> Map.put(:name, name)
379 |> Map.put_new(:last_refreshed_at, NaiveDateTime.utc_now())
380 |> truncate_if_exists(:name, name_limit)
381 |> truncate_if_exists(:bio, bio_limit)
382 |> truncate_fields_param()
383 |> fix_follower_address()
407 :hide_followers_count,
418 |> validate_required([:name, :ap_id])
419 |> unique_constraint(:nickname)
420 |> validate_format(:nickname, @email_regex)
421 |> validate_length(:bio, max: bio_limit)
422 |> validate_length(:name, max: name_limit)
423 |> validate_fields(true)
426 def update_changeset(struct, params \\ %{}) do
427 bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
428 name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
447 :hide_followers_count,
450 :allow_following_move,
453 :skip_thread_containment,
456 :pleroma_settings_store,
462 |> unique_constraint(:nickname)
463 |> validate_format(:nickname, local_nickname_regex())
464 |> validate_length(:bio, max: bio_limit)
465 |> validate_length(:name, min: 1, max: name_limit)
468 |> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
469 |> put_change_if_present(:avatar, &put_upload(&1, :avatar))
470 |> put_change_if_present(:banner, &put_upload(&1, :banner))
471 |> put_change_if_present(:background, &put_upload(&1, :background))
472 |> put_change_if_present(
473 :pleroma_settings_store,
474 &{:ok, Map.merge(struct.pleroma_settings_store, &1)}
476 |> validate_fields(false)
479 defp put_fields(changeset) do
480 if raw_fields = get_change(changeset, :raw_fields) do
483 |> Enum.filter(fn %{"name" => n} -> n != "" end)
487 |> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)
490 |> put_change(:raw_fields, raw_fields)
491 |> put_change(:fields, fields)
497 defp parse_fields(value) do
499 |> Formatter.linkify(mentions_format: :full)
503 defp put_emoji(changeset) do
504 bio = get_change(changeset, :bio)
505 name = get_change(changeset, :name)
508 emoji = Map.merge(Emoji.Formatter.get_emoji_map(bio), Emoji.Formatter.get_emoji_map(name))
509 put_change(changeset, :emoji, emoji)
515 defp put_change_if_present(changeset, map_field, value_function) do
516 if value = get_change(changeset, map_field) do
517 with {:ok, new_value} <- value_function.(value) do
518 put_change(changeset, map_field, new_value)
527 defp put_upload(value, type) do
528 with %Plug.Upload{} <- value,
529 {:ok, object} <- ActivityPub.upload(value, type: type) do
534 def update_as_admin_changeset(struct, params) do
536 |> update_changeset(params)
537 |> cast(params, [:email])
538 |> delete_change(:also_known_as)
539 |> unique_constraint(:email)
540 |> validate_format(:email, @email_regex)
543 @spec update_as_admin(%User{}, map) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
544 def update_as_admin(user, params) do
545 params = Map.put(params, "password_confirmation", params["password"])
546 changeset = update_as_admin_changeset(user, params)
548 if params["password"] do
549 reset_password(user, changeset, params)
551 User.update_and_set_cache(changeset)
555 def password_update_changeset(struct, params) do
557 |> cast(params, [:password, :password_confirmation])
558 |> validate_required([:password, :password_confirmation])
559 |> validate_confirmation(:password)
560 |> put_password_hash()
561 |> put_change(:password_reset_pending, false)
564 @spec reset_password(User.t(), map) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
565 def reset_password(%User{} = user, params) do
566 reset_password(user, user, params)
569 def reset_password(%User{id: user_id} = user, struct, params) do
572 |> Multi.update(:user, password_update_changeset(struct, params))
573 |> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
574 |> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))
576 case Repo.transaction(multi) do
577 {:ok, %{user: user} = _} -> set_cache(user)
578 {:error, _, changeset, _} -> {:error, changeset}
582 def update_password_reset_pending(user, value) do
585 |> put_change(:password_reset_pending, value)
586 |> update_and_set_cache()
589 def force_password_reset_async(user) do
590 BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
593 @spec force_password_reset(User.t()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
594 def force_password_reset(user), do: update_password_reset_pending(user, true)
596 def register_changeset(struct, params \\ %{}, opts \\ []) do
597 bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
598 name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
601 if is_nil(opts[:need_confirmation]) do
602 Pleroma.Config.get([:instance, :account_activation_required])
604 opts[:need_confirmation]
608 |> confirmation_changeset(need_confirmation: need_confirmation?)
609 |> cast(params, [:bio, :email, :name, :nickname, :password, :password_confirmation, :emoji])
610 |> validate_required([:name, :nickname, :password, :password_confirmation])
611 |> validate_confirmation(:password)
612 |> unique_constraint(:email)
613 |> unique_constraint(:nickname)
614 |> validate_exclusion(:nickname, Pleroma.Config.get([User, :restricted_nicknames]))
615 |> validate_format(:nickname, local_nickname_regex())
616 |> validate_format(:email, @email_regex)
617 |> validate_length(:bio, max: bio_limit)
618 |> validate_length(:name, min: 1, max: name_limit)
619 |> maybe_validate_required_email(opts[:external])
622 |> unique_constraint(:ap_id)
623 |> put_following_and_follower_address()
626 def maybe_validate_required_email(changeset, true), do: changeset
628 def maybe_validate_required_email(changeset, _) do
629 if Pleroma.Config.get([:instance, :account_activation_required]) do
630 validate_required(changeset, [:email])
636 defp put_ap_id(changeset) do
637 ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
638 put_change(changeset, :ap_id, ap_id)
641 defp put_following_and_follower_address(changeset) do
642 followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
645 |> put_change(:follower_address, followers)
648 defp autofollow_users(user) do
649 candidates = Pleroma.Config.get([:instance, :autofollowed_nicknames])
652 User.Query.build(%{nickname: candidates, local: true, deactivated: false})
655 follow_all(user, autofollowed_users)
658 @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
659 def register(%Ecto.Changeset{} = changeset) do
660 with {:ok, user} <- Repo.insert(changeset) do
661 post_register_action(user)
665 def post_register_action(%User{} = user) do
666 with {:ok, user} <- autofollow_users(user),
667 {:ok, user} <- set_cache(user),
668 {:ok, _} <- User.WelcomeMessage.post_welcome_message_to_user(user),
669 {:ok, _} <- try_send_confirmation_email(user) do
674 def try_send_confirmation_email(%User{} = user) do
675 if user.confirmation_pending &&
676 Pleroma.Config.get([:instance, :account_activation_required]) do
678 |> Pleroma.Emails.UserEmail.account_confirmation_email()
679 |> Pleroma.Emails.Mailer.deliver_async()
687 def try_send_confirmation_email(users) do
688 Enum.each(users, &try_send_confirmation_email/1)
691 def needs_update?(%User{local: true}), do: false
693 def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
695 def needs_update?(%User{local: false} = user) do
696 NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
699 def needs_update?(_), do: true
701 @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
703 # "Locked" (self-locked) users demand explicit authorization of follow requests
704 def maybe_direct_follow(%User{} = follower, %User{local: true, locked: true} = followed) do
705 follow(follower, followed, :follow_pending)
708 def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
709 follow(follower, followed)
712 def maybe_direct_follow(%User{} = follower, %User{} = followed) do
713 if not ap_enabled?(followed) do
714 follow(follower, followed)
720 @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
721 @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
722 def follow_all(follower, followeds) do
724 |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
725 |> Enum.each(&follow(follower, &1, :follow_accept))
730 defdelegate following(user), to: FollowingRelationship
732 def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
733 deny_follow_blocked = Pleroma.Config.get([:user, :deny_follow_blocked])
736 followed.deactivated ->
737 {:error, "Could not follow user: #{followed.nickname} is deactivated."}
739 deny_follow_blocked and blocks?(followed, follower) ->
740 {:error, "Could not follow user: #{followed.nickname} blocked you."}
743 FollowingRelationship.follow(follower, followed, state)
745 {:ok, _} = update_follower_count(followed)
748 |> update_following_count()
753 def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
754 {:error, "Not subscribed!"}
757 @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
758 def unfollow(%User{} = follower, %User{} = followed) do
759 case do_unfollow(follower, followed) do
760 {:ok, follower, followed} ->
761 {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
768 @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
769 defp do_unfollow(%User{} = follower, %User{} = followed) do
770 case get_follow_state(follower, followed) do
771 state when state in [:follow_pending, :follow_accept] ->
772 FollowingRelationship.unfollow(follower, followed)
773 {:ok, followed} = update_follower_count(followed)
777 |> update_following_count()
780 {:ok, follower, followed}
783 {:error, "Not subscribed!"}
787 defdelegate following?(follower, followed), to: FollowingRelationship
789 @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
790 def get_follow_state(%User{} = follower, %User{} = following) do
791 following_relationship = FollowingRelationship.get(follower, following)
792 get_follow_state(follower, following, following_relationship)
795 def get_follow_state(
798 following_relationship
800 case {following_relationship, following.local} do
802 case Utils.fetch_latest_follow(follower, following) do
803 %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
804 FollowingRelationship.state_to_enum(state)
810 {%{state: state}, _} ->
818 def locked?(%User{} = user) do
823 Repo.get_by(User, id: id)
826 def get_by_ap_id(ap_id) do
827 Repo.get_by(User, ap_id: ap_id)
830 def get_all_by_ap_id(ap_ids) do
831 from(u in __MODULE__,
832 where: u.ap_id in ^ap_ids
837 def get_all_by_ids(ids) do
838 from(u in __MODULE__, where: u.id in ^ids)
842 # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
843 # of the ap_id and the domain and tries to get that user
844 def get_by_guessed_nickname(ap_id) do
845 domain = URI.parse(ap_id).host
846 name = List.last(String.split(ap_id, "/"))
847 nickname = "#{name}@#{domain}"
849 get_cached_by_nickname(nickname)
852 def set_cache({:ok, user}), do: set_cache(user)
853 def set_cache({:error, err}), do: {:error, err}
855 def set_cache(%User{} = user) do
856 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
857 Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
858 Cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
862 def update_and_set_cache(struct, params) do
864 |> update_changeset(params)
865 |> update_and_set_cache()
868 def update_and_set_cache(changeset) do
869 with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
874 def get_user_friends_ap_ids(user) do
875 from(u in User.get_friends_query(user), select: u.ap_id)
879 @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
880 def get_cached_user_friends_ap_ids(user) do
881 Cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
882 get_user_friends_ap_ids(user)
886 def invalidate_cache(user) do
887 Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
888 Cachex.del(:user_cache, "nickname:#{user.nickname}")
889 Cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
892 @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
893 def get_cached_by_ap_id(ap_id) do
894 key = "ap_id:#{ap_id}"
896 with {:ok, nil} <- Cachex.get(:user_cache, key),
897 user when not is_nil(user) <- get_by_ap_id(ap_id),
898 {:ok, true} <- Cachex.put(:user_cache, key, user) do
906 def get_cached_by_id(id) do
910 Cachex.fetch!(:user_cache, key, fn _ ->
914 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
915 {:commit, user.ap_id}
921 get_cached_by_ap_id(ap_id)
924 def get_cached_by_nickname(nickname) do
925 key = "nickname:#{nickname}"
927 Cachex.fetch!(:user_cache, key, fn ->
928 case get_or_fetch_by_nickname(nickname) do
929 {:ok, user} -> {:commit, user}
930 {:error, _error} -> {:ignore, nil}
935 def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
936 restrict_to_local = Pleroma.Config.get([:instance, :limit_to_local_content])
939 is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
940 get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
942 restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
943 get_cached_by_nickname(nickname_or_id)
945 restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
946 get_cached_by_nickname(nickname_or_id)
953 @spec get_by_nickname(String.t()) :: User.t() | nil
954 def get_by_nickname(nickname) do
955 Repo.get_by(User, nickname: nickname) ||
956 if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
957 Repo.get_by(User, nickname: local_nickname(nickname))
961 def get_by_email(email), do: Repo.get_by(User, email: email)
963 def get_by_nickname_or_email(nickname_or_email) do
964 get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
967 def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
969 def get_or_fetch_by_nickname(nickname) do
970 with %User{} = user <- get_by_nickname(nickname) do
974 with [_nick, _domain] <- String.split(nickname, "@"),
975 {:ok, user} <- fetch_by_nickname(nickname) do
978 _e -> {:error, "not found " <> nickname}
983 @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
984 def get_followers_query(%User{} = user, nil) do
985 User.Query.build(%{followers: user, deactivated: false})
988 def get_followers_query(user, page) do
990 |> get_followers_query(nil)
991 |> User.Query.paginate(page, 20)
994 @spec get_followers_query(User.t()) :: Ecto.Query.t()
995 def get_followers_query(user), do: get_followers_query(user, nil)
997 @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
998 def get_followers(user, page \\ nil) do
1000 |> get_followers_query(page)
1004 @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1005 def get_external_followers(user, page \\ nil) do
1007 |> get_followers_query(page)
1008 |> User.Query.build(%{external: true})
1012 def get_followers_ids(user, page \\ nil) do
1014 |> get_followers_query(page)
1015 |> select([u], u.id)
1019 @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1020 def get_friends_query(%User{} = user, nil) do
1021 User.Query.build(%{friends: user, deactivated: false})
1024 def get_friends_query(user, page) do
1026 |> get_friends_query(nil)
1027 |> User.Query.paginate(page, 20)
1030 @spec get_friends_query(User.t()) :: Ecto.Query.t()
1031 def get_friends_query(user), do: get_friends_query(user, nil)
1033 def get_friends(user, page \\ nil) do
1035 |> get_friends_query(page)
1039 def get_friends_ap_ids(user) do
1041 |> get_friends_query(nil)
1042 |> select([u], u.ap_id)
1046 def get_friends_ids(user, page \\ nil) do
1048 |> get_friends_query(page)
1049 |> select([u], u.id)
1053 defdelegate get_follow_requests(user), to: FollowingRelationship
1055 def increase_note_count(%User{} = user) do
1057 |> where(id: ^user.id)
1058 |> update([u], inc: [note_count: 1])
1060 |> Repo.update_all([])
1062 {1, [user]} -> set_cache(user)
1067 def decrease_note_count(%User{} = user) do
1069 |> where(id: ^user.id)
1072 note_count: fragment("greatest(0, note_count - 1)")
1076 |> Repo.update_all([])
1078 {1, [user]} -> set_cache(user)
1083 def update_note_count(%User{} = user, note_count \\ nil) do
1088 where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1094 |> cast(%{note_count: note_count}, [:note_count])
1095 |> update_and_set_cache()
1098 @spec maybe_fetch_follow_information(User.t()) :: User.t()
1099 def maybe_fetch_follow_information(user) do
1100 with {:ok, user} <- fetch_follow_information(user) do
1104 Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1110 def fetch_follow_information(user) do
1111 with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1113 |> follow_information_changeset(info)
1114 |> update_and_set_cache()
1118 defp follow_information_changeset(user, params) do
1125 :hide_followers_count,
1130 def update_follower_count(%User{} = user) do
1131 if user.local or !Pleroma.Config.get([:instance, :external_user_synchronization]) do
1132 follower_count_query =
1133 User.Query.build(%{followers: user, deactivated: false})
1134 |> select([u], %{count: count(u.id)})
1137 |> where(id: ^user.id)
1138 |> join(:inner, [u], s in subquery(follower_count_query))
1140 set: [follower_count: s.count]
1143 |> Repo.update_all([])
1145 {1, [user]} -> set_cache(user)
1149 {:ok, maybe_fetch_follow_information(user)}
1153 @spec update_following_count(User.t()) :: User.t()
1154 def update_following_count(%User{local: false} = user) do
1155 if Pleroma.Config.get([:instance, :external_user_synchronization]) do
1156 maybe_fetch_follow_information(user)
1162 def update_following_count(%User{local: true} = user) do
1163 following_count = FollowingRelationship.following_count(user)
1166 |> follow_information_changeset(%{following_count: following_count})
1170 def set_unread_conversation_count(%User{local: true} = user) do
1171 unread_query = Participation.unread_conversation_count_for_user(user)
1174 |> join(:inner, [u], p in subquery(unread_query))
1176 set: [unread_conversation_count: p.count]
1178 |> where([u], u.id == ^user.id)
1180 |> Repo.update_all([])
1182 {1, [user]} -> set_cache(user)
1187 def set_unread_conversation_count(user), do: {:ok, user}
1189 def increment_unread_conversation_count(conversation, %User{local: true} = user) do
1191 Participation.unread_conversation_count_for_user(user)
1192 |> where([p], p.conversation_id == ^conversation.id)
1195 |> join(:inner, [u], p in subquery(unread_query))
1197 inc: [unread_conversation_count: 1]
1199 |> where([u], u.id == ^user.id)
1200 |> where([u, p], p.count == 0)
1202 |> Repo.update_all([])
1204 {1, [user]} -> set_cache(user)
1209 def increment_unread_conversation_count(_, user), do: {:ok, user}
1211 @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1212 def get_users_from_set(ap_ids, opts \\ []) do
1213 local_only = Keyword.get(opts, :local_only, true)
1214 criteria = %{ap_id: ap_ids, deactivated: false}
1215 criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1217 User.Query.build(criteria)
1221 @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1222 def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1225 query = User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
1231 @spec mute(User.t(), User.t(), boolean()) ::
1232 {:ok, list(UserRelationship.t())} | {:error, String.t()}
1233 def mute(%User{} = muter, %User{} = mutee, notifications? \\ true) do
1234 add_to_mutes(muter, mutee, notifications?)
1237 def unmute(%User{} = muter, %User{} = mutee) do
1238 remove_from_mutes(muter, mutee)
1241 def subscribe(%User{} = subscriber, %User{} = target) do
1242 deny_follow_blocked = Pleroma.Config.get([:user, :deny_follow_blocked])
1244 if blocks?(target, subscriber) and deny_follow_blocked do
1245 {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1247 # Note: the relationship is inverse: subscriber acts as relationship target
1248 UserRelationship.create_inverse_subscription(target, subscriber)
1252 def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1253 with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1254 subscribe(subscriber, subscribee)
1258 def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1259 # Note: the relationship is inverse: subscriber acts as relationship target
1260 UserRelationship.delete_inverse_subscription(target, unsubscriber)
1263 def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1264 with %User{} = user <- get_cached_by_ap_id(ap_id) do
1265 unsubscribe(unsubscriber, user)
1269 def block(%User{} = blocker, %User{} = blocked) do
1270 # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1272 if following?(blocker, blocked) do
1273 {:ok, blocker, _} = unfollow(blocker, blocked)
1279 # clear any requested follows as well
1281 case CommonAPI.reject_follow_request(blocked, blocker) do
1282 {:ok, %User{} = updated_blocked} -> updated_blocked
1286 unsubscribe(blocked, blocker)
1288 if following?(blocked, blocker), do: unfollow(blocked, blocker)
1290 {:ok, blocker} = update_follower_count(blocker)
1291 {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1292 add_to_block(blocker, blocked)
1295 # helper to handle the block given only an actor's AP id
1296 def block(%User{} = blocker, %{ap_id: ap_id}) do
1297 block(blocker, get_cached_by_ap_id(ap_id))
1300 def unblock(%User{} = blocker, %User{} = blocked) do
1301 remove_from_block(blocker, blocked)
1304 # helper to handle the block given only an actor's AP id
1305 def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1306 unblock(blocker, get_cached_by_ap_id(ap_id))
1309 def mutes?(nil, _), do: false
1310 def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1312 def mutes_user?(%User{} = user, %User{} = target) do
1313 UserRelationship.mute_exists?(user, target)
1316 @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1317 def muted_notifications?(nil, _), do: false
1319 def muted_notifications?(%User{} = user, %User{} = target),
1320 do: UserRelationship.notification_mute_exists?(user, target)
1322 def blocks?(nil, _), do: false
1324 def blocks?(%User{} = user, %User{} = target) do
1325 blocks_user?(user, target) ||
1326 (blocks_domain?(user, target) and not User.following?(user, target))
1329 def blocks_user?(%User{} = user, %User{} = target) do
1330 UserRelationship.block_exists?(user, target)
1333 def blocks_user?(_, _), do: false
1335 def blocks_domain?(%User{} = user, %User{} = target) do
1336 domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1337 %{host: host} = URI.parse(target.ap_id)
1338 Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1341 def blocks_domain?(_, _), do: false
1343 def subscribed_to?(%User{} = user, %User{} = target) do
1344 # Note: the relationship is inverse: subscriber acts as relationship target
1345 UserRelationship.inverse_subscription_exists?(target, user)
1348 def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1349 with %User{} = target <- get_cached_by_ap_id(ap_id) do
1350 subscribed_to?(user, target)
1355 Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1356 E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1358 @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1359 def outgoing_relationships_ap_ids(_user, []), do: %{}
1361 def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1363 def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1364 when is_list(relationship_types) do
1367 |> assoc(:outgoing_relationships)
1368 |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1369 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1370 |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1371 |> group_by([user_rel, u], user_rel.relationship_type)
1373 |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1378 fn rel_type -> {rel_type, db_result[rel_type] || []} end
1382 def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1384 def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1386 def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1388 def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1389 when is_list(relationship_types) do
1391 |> assoc(:incoming_relationships)
1392 |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1393 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1394 |> maybe_filter_on_ap_id(ap_ids)
1395 |> select([user_rel, u], u.ap_id)
1400 defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1401 where(query, [user_rel, u], u.ap_id in ^ap_ids)
1404 defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1406 def deactivate_async(user, status \\ true) do
1407 BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
1410 def deactivate(user, status \\ true)
1412 def deactivate(users, status) when is_list(users) do
1413 Repo.transaction(fn ->
1414 for user <- users, do: deactivate(user, status)
1418 def deactivate(%User{} = user, status) do
1419 with {:ok, user} <- set_activation_status(user, status) do
1422 |> Enum.filter(& &1.local)
1423 |> Enum.each(&set_cache(update_following_count(&1)))
1425 # Only update local user counts, remote will be update during the next pull.
1428 |> Enum.filter(& &1.local)
1429 |> Enum.each(&do_unfollow(user, &1))
1435 def update_notification_settings(%User{} = user, settings) do
1437 |> cast(%{notification_settings: settings}, [])
1438 |> cast_embed(:notification_settings)
1439 |> validate_required([:notification_settings])
1440 |> update_and_set_cache()
1443 def delete(users) when is_list(users) do
1444 for user <- users, do: delete(user)
1447 def delete(%User{} = user) do
1448 BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1451 defp delete_and_invalidate_cache(%User{} = user) do
1452 invalidate_cache(user)
1456 defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)
1458 defp delete_or_deactivate(%User{local: true} = user) do
1459 status = account_status(user)
1461 if status == :confirmation_pending do
1462 delete_and_invalidate_cache(user)
1465 |> change(%{deactivated: true, email: nil})
1466 |> update_and_set_cache()
1470 def perform(:force_password_reset, user), do: force_password_reset(user)
1472 @spec perform(atom(), User.t()) :: {:ok, User.t()}
1473 def perform(:delete, %User{} = user) do
1474 # Remove all relationships
1477 |> Enum.each(fn follower ->
1478 ActivityPub.unfollow(follower, user)
1479 unfollow(follower, user)
1484 |> Enum.each(fn followed ->
1485 ActivityPub.unfollow(user, followed)
1486 unfollow(user, followed)
1489 delete_user_activities(user)
1491 delete_or_deactivate(user)
1494 def perform(:deactivate_async, user, status), do: deactivate(user, status)
1496 @spec perform(atom(), User.t(), list()) :: list() | {:error, any()}
1497 def perform(:blocks_import, %User{} = blocker, blocked_identifiers)
1498 when is_list(blocked_identifiers) do
1500 blocked_identifiers,
1501 fn blocked_identifier ->
1502 with {:ok, %User{} = blocked} <- get_or_fetch(blocked_identifier),
1503 {:ok, _user_block} <- block(blocker, blocked),
1504 {:ok, _} <- ActivityPub.block(blocker, blocked) do
1508 Logger.debug("blocks_import failed for #{blocked_identifier} with: #{inspect(err)}")
1515 def perform(:follow_import, %User{} = follower, followed_identifiers)
1516 when is_list(followed_identifiers) do
1518 followed_identifiers,
1519 fn followed_identifier ->
1520 with {:ok, %User{} = followed} <- get_or_fetch(followed_identifier),
1521 {:ok, follower} <- maybe_direct_follow(follower, followed),
1522 {:ok, _} <- ActivityPub.follow(follower, followed) do
1526 Logger.debug("follow_import failed for #{followed_identifier} with: #{inspect(err)}")
1533 @spec external_users_query() :: Ecto.Query.t()
1534 def external_users_query do
1542 @spec external_users(keyword()) :: [User.t()]
1543 def external_users(opts \\ []) do
1545 external_users_query()
1546 |> select([u], struct(u, [:id, :ap_id]))
1550 do: where(query, [u], u.id > ^opts[:max_id]),
1555 do: limit(query, ^opts[:limit]),
1561 def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers) do
1562 BackgroundWorker.enqueue("blocks_import", %{
1563 "blocker_id" => blocker.id,
1564 "blocked_identifiers" => blocked_identifiers
1568 def follow_import(%User{} = follower, followed_identifiers)
1569 when is_list(followed_identifiers) do
1570 BackgroundWorker.enqueue("follow_import", %{
1571 "follower_id" => follower.id,
1572 "followed_identifiers" => followed_identifiers
1576 def delete_user_activities(%User{ap_id: ap_id} = user) do
1578 |> Activity.Queries.by_actor()
1579 |> RepoStreamer.chunk_stream(50)
1580 |> Stream.each(fn activities ->
1581 Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1586 defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1587 with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1588 {:ok, delete_data, _} <- Builder.delete(user, object) do
1589 Pipeline.common_pipeline(delete_data, local: user.local)
1591 {:find_object, nil} ->
1592 # We have the create activity, but not the object, it was probably pruned.
1593 # Insert a tombstone and try again
1594 with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1595 {:ok, _tombstone} <- Object.create(tombstone_data) do
1596 delete_activity(activity, user)
1600 Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1601 Logger.error("Error: #{inspect(e)}")
1605 defp delete_activity(%{data: %{"type" => type}} = activity, user)
1606 when type in ["Like", "Announce"] do
1607 {:ok, undo, _} = Builder.undo(user, activity)
1608 Pipeline.common_pipeline(undo, local: user.local)
1611 defp delete_activity(_activity, _user), do: "Doing nothing"
1613 def html_filter_policy(%User{no_rich_text: true}) do
1614 Pleroma.HTML.Scrubber.TwitterText
1617 def html_filter_policy(_), do: Pleroma.Config.get([:markup, :scrub_policy])
1619 def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1621 def get_or_fetch_by_ap_id(ap_id) do
1622 cached_user = get_cached_by_ap_id(ap_id)
1624 maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)
1626 case {cached_user, maybe_fetched_user} do
1627 {_, {:ok, %User{} = user}} ->
1630 {%User{} = user, _} ->
1634 {:error, :not_found}
1639 Creates an internal service actor by URI if missing.
1640 Optionally takes nickname for addressing.
1642 @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1643 def get_or_create_service_actor_by_ap_id(uri, nickname) do
1645 case get_cached_by_ap_id(uri) do
1647 with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1648 Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1652 %User{invisible: false} = user ->
1662 @spec set_invisible(User.t()) :: {:ok, User.t()}
1663 defp set_invisible(user) do
1665 |> change(%{invisible: true})
1666 |> update_and_set_cache()
1669 @spec create_service_actor(String.t(), String.t()) ::
1670 {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1671 defp create_service_actor(uri, nickname) do
1677 follower_address: uri <> "/followers"
1680 |> unique_constraint(:nickname)
1685 def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1688 |> :public_key.pem_decode()
1690 |> :public_key.pem_entry_decode()
1695 def public_key(_), do: {:error, "key not found"}
1697 def get_public_key_for_ap_id(ap_id) do
1698 with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1699 {:ok, public_key} <- public_key(user) do
1706 def ap_enabled?(%User{local: true}), do: true
1707 def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1708 def ap_enabled?(_), do: false
1710 @doc "Gets or fetch a user by uri or nickname."
1711 @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1712 def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1713 def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1715 # wait a period of time and return newest version of the User structs
1716 # this is because we have synchronous follow APIs and need to simulate them
1717 # with an async handshake
1718 def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1719 with %User{} = a <- get_cached_by_id(a.id),
1720 %User{} = b <- get_cached_by_id(b.id) do
1727 def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1728 with :ok <- :timer.sleep(timeout),
1729 %User{} = a <- get_cached_by_id(a.id),
1730 %User{} = b <- get_cached_by_id(b.id) do
1737 def parse_bio(bio) when is_binary(bio) and bio != "" do
1739 |> CommonUtils.format_input("text/plain", mentions_format: :full)
1743 def parse_bio(_), do: ""
1745 def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1746 # TODO: get profile URLs other than user.ap_id
1747 profile_urls = [user.ap_id]
1750 |> CommonUtils.format_input("text/plain",
1751 mentions_format: :full,
1752 rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1757 def parse_bio(_, _), do: ""
1759 def tag(user_identifiers, tags) when is_list(user_identifiers) do
1760 Repo.transaction(fn ->
1761 for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1765 def tag(nickname, tags) when is_binary(nickname),
1766 do: tag(get_by_nickname(nickname), tags)
1768 def tag(%User{} = user, tags),
1769 do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1771 def untag(user_identifiers, tags) when is_list(user_identifiers) do
1772 Repo.transaction(fn ->
1773 for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1777 def untag(nickname, tags) when is_binary(nickname),
1778 do: untag(get_by_nickname(nickname), tags)
1780 def untag(%User{} = user, tags),
1781 do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1783 defp update_tags(%User{} = user, new_tags) do
1784 {:ok, updated_user} =
1786 |> change(%{tags: new_tags})
1787 |> update_and_set_cache()
1792 defp normalize_tags(tags) do
1795 |> Enum.map(&String.downcase/1)
1798 defp local_nickname_regex do
1799 if Pleroma.Config.get([:instance, :extended_nickname_format]) do
1800 @extended_local_nickname_regex
1802 @strict_local_nickname_regex
1806 def local_nickname(nickname_or_mention) do
1809 |> String.split("@")
1813 def full_nickname(nickname_or_mention),
1814 do: String.trim_leading(nickname_or_mention, "@")
1816 def error_user(ap_id) do
1820 nickname: "erroruser@example.com",
1821 inserted_at: NaiveDateTime.utc_now()
1825 @spec all_superusers() :: [User.t()]
1826 def all_superusers do
1827 User.Query.build(%{super_users: true, local: true, deactivated: false})
1831 def muting_reblogs?(%User{} = user, %User{} = target) do
1832 UserRelationship.reblog_mute_exists?(user, target)
1835 def showing_reblogs?(%User{} = user, %User{} = target) do
1836 not muting_reblogs?(user, target)
1840 The function returns a query to get users with no activity for given interval of days.
1841 Inactive users are those who didn't read any notification, or had any activity where
1842 the user is the activity's actor, during `inactivity_threshold` days.
1843 Deactivated users will not appear in this list.
1847 iex> Pleroma.User.list_inactive_users()
1850 @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
1851 def list_inactive_users_query(inactivity_threshold \\ 7) do
1852 negative_inactivity_threshold = -inactivity_threshold
1853 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
1854 # Subqueries are not supported in `where` clauses, join gets too complicated.
1855 has_read_notifications =
1856 from(n in Pleroma.Notification,
1857 where: n.seen == true,
1859 having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
1862 |> Pleroma.Repo.all()
1864 from(u in Pleroma.User,
1865 left_join: a in Pleroma.Activity,
1866 on: u.ap_id == a.actor,
1867 where: not is_nil(u.nickname),
1868 where: u.deactivated != ^true,
1869 where: u.id not in ^has_read_notifications,
1872 max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
1873 is_nil(max(a.inserted_at))
1878 Enable or disable email notifications for user
1882 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
1883 Pleroma.User{email_notifications: %{"digest" => true}}
1885 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
1886 Pleroma.User{email_notifications: %{"digest" => false}}
1888 @spec switch_email_notifications(t(), String.t(), boolean()) ::
1889 {:ok, t()} | {:error, Ecto.Changeset.t()}
1890 def switch_email_notifications(user, type, status) do
1891 User.update_email_notifications(user, %{type => status})
1895 Set `last_digest_emailed_at` value for the user to current time
1897 @spec touch_last_digest_emailed_at(t()) :: t()
1898 def touch_last_digest_emailed_at(user) do
1899 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
1901 {:ok, updated_user} =
1903 |> change(%{last_digest_emailed_at: now})
1904 |> update_and_set_cache()
1909 @spec toggle_confirmation(User.t()) :: {:ok, User.t()} | {:error, Changeset.t()}
1910 def toggle_confirmation(%User{} = user) do
1912 |> confirmation_changeset(need_confirmation: !user.confirmation_pending)
1913 |> update_and_set_cache()
1916 @spec toggle_confirmation([User.t()]) :: [{:ok, User.t()} | {:error, Changeset.t()}]
1917 def toggle_confirmation(users) do
1918 Enum.map(users, &toggle_confirmation/1)
1921 def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
1925 def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
1926 # use instance-default
1927 config = Pleroma.Config.get([:assets, :mascots])
1928 default_mascot = Pleroma.Config.get([:assets, :default_mascot])
1929 mascot = Keyword.get(config, default_mascot)
1932 "id" => "default-mascot",
1933 "url" => mascot[:url],
1934 "preview_url" => mascot[:url],
1936 "mime_type" => mascot[:mime_type]
1941 def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
1943 def ensure_keys_present(%User{} = user) do
1944 with {:ok, pem} <- Keys.generate_rsa_pem() do
1946 |> cast(%{keys: pem}, [:keys])
1947 |> validate_required([:keys])
1948 |> update_and_set_cache()
1952 def get_ap_ids_by_nicknames(nicknames) do
1954 where: u.nickname in ^nicknames,
1960 defdelegate search(query, opts \\ []), to: User.Search
1962 defp put_password_hash(
1963 %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
1965 change(changeset, password_hash: Pbkdf2.hash_pwd_salt(password))
1968 defp put_password_hash(changeset), do: changeset
1970 def is_internal_user?(%User{nickname: nil}), do: true
1971 def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
1972 def is_internal_user?(_), do: false
1974 # A hack because user delete activities have a fake id for whatever reason
1975 # TODO: Get rid of this
1976 def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
1978 def get_delivered_users_by_object_id(object_id) do
1980 inner_join: delivery in assoc(u, :deliveries),
1981 where: delivery.object_id == ^object_id
1986 def change_email(user, email) do
1988 |> cast(%{email: email}, [:email])
1989 |> validate_required([:email])
1990 |> unique_constraint(:email)
1991 |> validate_format(:email, @email_regex)
1992 |> update_and_set_cache()
1995 # Internal function; public one is `deactivate/2`
1996 defp set_activation_status(user, deactivated) do
1998 |> cast(%{deactivated: deactivated}, [:deactivated])
1999 |> update_and_set_cache()
2002 def update_banner(user, banner) do
2004 |> cast(%{banner: banner}, [:banner])
2005 |> update_and_set_cache()
2008 def update_background(user, background) do
2010 |> cast(%{background: background}, [:background])
2011 |> update_and_set_cache()
2014 def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
2017 moderator: is_moderator
2021 def validate_fields(changeset, remote? \\ false) do
2022 limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2023 limit = Pleroma.Config.get([:instance, limit_name], 0)
2026 |> validate_length(:fields, max: limit)
2027 |> validate_change(:fields, fn :fields, fields ->
2028 if Enum.all?(fields, &valid_field?/1) do
2036 defp valid_field?(%{"name" => name, "value" => value}) do
2037 name_limit = Pleroma.Config.get([:instance, :account_field_name_length], 255)
2038 value_limit = Pleroma.Config.get([:instance, :account_field_value_length], 255)
2040 is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2041 String.length(value) <= value_limit
2044 defp valid_field?(_), do: false
2046 defp truncate_field(%{"name" => name, "value" => value}) do
2048 String.split_at(name, Pleroma.Config.get([:instance, :account_field_name_length], 255))
2051 String.split_at(value, Pleroma.Config.get([:instance, :account_field_value_length], 255))
2053 %{"name" => name, "value" => value}
2056 def admin_api_update(user, params) do
2063 |> update_and_set_cache()
2066 @doc "Signs user out of all applications"
2067 def global_sign_out(user) do
2068 OAuth.Authorization.delete_user_authorizations(user)
2069 OAuth.Token.delete_user_tokens(user)
2072 def mascot_update(user, url) do
2074 |> cast(%{mascot: url}, [:mascot])
2075 |> validate_required([:mascot])
2076 |> update_and_set_cache()
2079 def mastodon_settings_update(user, settings) do
2081 |> cast(%{settings: settings}, [:settings])
2082 |> validate_required([:settings])
2083 |> update_and_set_cache()
2086 @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2087 def confirmation_changeset(user, need_confirmation: need_confirmation?) do
2089 if need_confirmation? do
2091 confirmation_pending: true,
2092 confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2096 confirmation_pending: false,
2097 confirmation_token: nil
2101 cast(user, params, [:confirmation_pending, :confirmation_token])
2104 def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2105 if id not in user.pinned_activities do
2106 max_pinned_statuses = Pleroma.Config.get([:instance, :max_pinned_statuses], 0)
2107 params = %{pinned_activities: user.pinned_activities ++ [id]}
2110 |> cast(params, [:pinned_activities])
2111 |> validate_length(:pinned_activities,
2112 max: max_pinned_statuses,
2113 message: "You have already pinned the maximum number of statuses"
2118 |> update_and_set_cache()
2121 def remove_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2122 params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2125 |> cast(params, [:pinned_activities])
2126 |> update_and_set_cache()
2129 def update_email_notifications(user, settings) do
2130 email_notifications =
2131 user.email_notifications
2132 |> Map.merge(settings)
2133 |> Map.take(["digest"])
2135 params = %{email_notifications: email_notifications}
2136 fields = [:email_notifications]
2139 |> cast(params, fields)
2140 |> validate_required(fields)
2141 |> update_and_set_cache()
2144 defp set_domain_blocks(user, domain_blocks) do
2145 params = %{domain_blocks: domain_blocks}
2148 |> cast(params, [:domain_blocks])
2149 |> validate_required([:domain_blocks])
2150 |> update_and_set_cache()
2153 def block_domain(user, domain_blocked) do
2154 set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2157 def unblock_domain(user, domain_blocked) do
2158 set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2161 @spec add_to_block(User.t(), User.t()) ::
2162 {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2163 defp add_to_block(%User{} = user, %User{} = blocked) do
2164 UserRelationship.create_block(user, blocked)
2167 @spec add_to_block(User.t(), User.t()) ::
2168 {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2169 defp remove_from_block(%User{} = user, %User{} = blocked) do
2170 UserRelationship.delete_block(user, blocked)
2173 defp add_to_mutes(%User{} = user, %User{} = muted_user, notifications?) do
2174 with {:ok, user_mute} <- UserRelationship.create_mute(user, muted_user),
2175 {:ok, user_notification_mute} <-
2176 (notifications? && UserRelationship.create_notification_mute(user, muted_user)) ||
2178 {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
2182 defp remove_from_mutes(user, %User{} = muted_user) do
2183 with {:ok, user_mute} <- UserRelationship.delete_mute(user, muted_user),
2184 {:ok, user_notification_mute} <-
2185 UserRelationship.delete_notification_mute(user, muted_user) do
2186 {:ok, [user_mute, user_notification_mute]}
2190 def set_invisible(user, invisible) do
2191 params = %{invisible: invisible}
2194 |> cast(params, [:invisible])
2195 |> validate_required([:invisible])
2196 |> update_and_set_cache()
2199 def sanitize_html(%User{} = user) do
2200 sanitize_html(user, nil)
2203 # User data that mastodon isn't filtering (treated as plaintext):
2206 def sanitize_html(%User{} = user, filter) do
2208 Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2211 "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2216 |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2217 |> Map.put(:fields, fields)