1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.User do
10 import Ecto, only: [assoc: 2]
13 alias Pleroma.Activity
15 alias Pleroma.Conversation.Participation
16 alias Pleroma.Delivery
17 alias Pleroma.EctoType.ActivityPub.ObjectValidators
19 alias Pleroma.FollowingRelationship
20 alias Pleroma.Formatter
24 alias Pleroma.Notification
26 alias Pleroma.Registration
28 alias Pleroma.RepoStreamer
30 alias Pleroma.UserRelationship
32 alias Pleroma.Web.ActivityPub.ActivityPub
33 alias Pleroma.Web.ActivityPub.Builder
34 alias Pleroma.Web.ActivityPub.Pipeline
35 alias Pleroma.Web.ActivityPub.Utils
36 alias Pleroma.Web.CommonAPI
37 alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
38 alias Pleroma.Web.OAuth
39 alias Pleroma.Web.RelMe
40 alias Pleroma.Workers.BackgroundWorker
44 @type t :: %__MODULE__{}
45 @type account_status :: :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(:raw_bio, :string)
83 field(:email, :string)
85 field(:nickname, :string)
86 field(:password_hash, :string)
87 field(:password, :string, virtual: true)
88 field(:password_confirmation, :string, virtual: true)
90 field(:public_key, :string)
91 field(:ap_id, :string)
93 field(:local, :boolean, default: true)
94 field(:follower_address, :string)
95 field(:following_address, :string)
96 field(:search_rank, :float, virtual: true)
97 field(:search_type, :integer, virtual: true)
98 field(:tags, {:array, :string}, default: [])
99 field(:last_refreshed_at, :naive_datetime_usec)
100 field(:last_digest_emailed_at, :naive_datetime)
101 field(:banner, :map, default: %{})
102 field(:background, :map, default: %{})
103 field(:note_count, :integer, default: 0)
104 field(:follower_count, :integer, default: 0)
105 field(:following_count, :integer, default: 0)
106 field(:locked, :boolean, default: false)
107 field(:confirmation_pending, :boolean, default: false)
108 field(:password_reset_pending, :boolean, default: false)
109 field(:confirmation_token, :string, default: nil)
110 field(:default_scope, :string, default: "public")
111 field(:domain_blocks, {:array, :string}, default: [])
112 field(:deactivated, :boolean, default: false)
113 field(:no_rich_text, :boolean, default: false)
114 field(:ap_enabled, :boolean, default: false)
115 field(:is_moderator, :boolean, default: false)
116 field(:is_admin, :boolean, default: false)
117 field(:show_role, :boolean, default: true)
118 field(:mastofe_settings, :map, default: nil)
119 field(:uri, ObjectValidators.Uri, default: nil)
120 field(:hide_followers_count, :boolean, default: false)
121 field(:hide_follows_count, :boolean, default: false)
122 field(:hide_followers, :boolean, default: false)
123 field(:hide_follows, :boolean, default: false)
124 field(:hide_favorites, :boolean, default: true)
125 field(:unread_conversation_count, :integer, default: 0)
126 field(:pinned_activities, {:array, :string}, default: [])
127 field(:email_notifications, :map, default: %{"digest" => false})
128 field(:mascot, :map, default: nil)
129 field(:emoji, :map, default: %{})
130 field(:pleroma_settings_store, :map, default: %{})
131 field(:fields, {:array, :map}, default: [])
132 field(:raw_fields, {:array, :map}, default: [])
133 field(:discoverable, :boolean, default: false)
134 field(:invisible, :boolean, default: false)
135 field(:allow_following_move, :boolean, default: true)
136 field(:skip_thread_containment, :boolean, default: false)
137 field(:actor_type, :string, default: "Person")
138 field(:also_known_as, {:array, :string}, default: [])
139 field(:inbox, :string)
140 field(:shared_inbox, :string)
141 field(:accepts_chat_messages, :boolean, default: nil)
144 :notification_settings,
145 Pleroma.User.NotificationSetting,
149 has_many(:notifications, Notification)
150 has_many(:registrations, Registration)
151 has_many(:deliveries, Delivery)
153 has_many(:outgoing_relationships, UserRelationship, foreign_key: :source_id)
154 has_many(:incoming_relationships, UserRelationship, foreign_key: :target_id)
156 for {relationship_type,
158 {outgoing_relation, outgoing_relation_target},
159 {incoming_relation, incoming_relation_source}
160 ]} <- @user_relationships_config do
161 # Definitions of `has_many` relations: :blocker_blocks, :muter_mutes, :reblog_muter_mutes,
162 # :notification_muter_mutes, :subscribee_subscriptions
163 has_many(outgoing_relation, UserRelationship,
164 foreign_key: :source_id,
165 where: [relationship_type: relationship_type]
168 # Definitions of `has_many` relations: :blockee_blocks, :mutee_mutes, :reblog_mutee_mutes,
169 # :notification_mutee_mutes, :subscriber_subscriptions
170 has_many(incoming_relation, UserRelationship,
171 foreign_key: :target_id,
172 where: [relationship_type: relationship_type]
175 # Definitions of `has_many` relations: :blocked_users, :muted_users, :reblog_muted_users,
176 # :notification_muted_users, :subscriber_users
177 has_many(outgoing_relation_target, through: [outgoing_relation, :target])
179 # Definitions of `has_many` relations: :blocker_users, :muter_users, :reblog_muter_users,
180 # :notification_muter_users, :subscribee_users
181 has_many(incoming_relation_source, through: [incoming_relation, :source])
184 # `:blocks` is deprecated (replaced with `blocked_users` relation)
185 field(:blocks, {:array, :string}, default: [])
186 # `:mutes` is deprecated (replaced with `muted_users` relation)
187 field(:mutes, {:array, :string}, default: [])
188 # `:muted_reblogs` is deprecated (replaced with `reblog_muted_users` relation)
189 field(:muted_reblogs, {:array, :string}, default: [])
190 # `:muted_notifications` is deprecated (replaced with `notification_muted_users` relation)
191 field(:muted_notifications, {:array, :string}, default: [])
192 # `:subscribers` is deprecated (replaced with `subscriber_users` relation)
193 field(:subscribers, {:array, :string}, default: [])
196 :multi_factor_authentication_settings,
204 for {_relationship_type, [{_outgoing_relation, outgoing_relation_target}, _]} <-
205 @user_relationships_config do
206 # `def blocked_users_relation/2`, `def muted_users_relation/2`,
207 # `def reblog_muted_users_relation/2`, `def notification_muted_users/2`,
208 # `def subscriber_users/2`
209 def unquote(:"#{outgoing_relation_target}_relation")(user, restrict_deactivated? \\ false) do
210 target_users_query = assoc(user, unquote(outgoing_relation_target))
212 if restrict_deactivated? do
213 restrict_deactivated(target_users_query)
219 # `def blocked_users/2`, `def muted_users/2`, `def reblog_muted_users/2`,
220 # `def notification_muted_users/2`, `def subscriber_users/2`
221 def unquote(outgoing_relation_target)(user, restrict_deactivated? \\ false) do
223 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
225 restrict_deactivated?
230 # `def blocked_users_ap_ids/2`, `def muted_users_ap_ids/2`, `def reblog_muted_users_ap_ids/2`,
231 # `def notification_muted_users_ap_ids/2`, `def subscriber_users_ap_ids/2`
232 def unquote(:"#{outgoing_relation_target}_ap_ids")(user, restrict_deactivated? \\ false) do
234 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
236 restrict_deactivated?
238 |> select([u], u.ap_id)
244 Dumps Flake Id to SQL-compatible format (16-byte UUID).
245 E.g. "9pQtDGXuq4p3VlcJEm" -> <<0, 0, 1, 110, 179, 218, 42, 92, 213, 41, 44, 227, 95, 213, 0, 0>>
247 def binary_id(source_id) when is_binary(source_id) do
248 with {:ok, dumped_id} <- FlakeId.Ecto.CompatType.dump(source_id) do
255 def binary_id(source_ids) when is_list(source_ids) do
256 Enum.map(source_ids, &binary_id/1)
259 def binary_id(%User{} = user), do: binary_id(user.id)
261 @doc "Returns status account"
262 @spec account_status(User.t()) :: account_status()
263 def account_status(%User{deactivated: true}), do: :deactivated
264 def account_status(%User{password_reset_pending: true}), do: :password_reset_pending
266 def account_status(%User{confirmation_pending: true}) do
267 if Config.get([:instance, :account_activation_required]) do
268 :confirmation_pending
274 def account_status(%User{}), do: :active
276 @spec visible_for(User.t(), User.t() | nil) ::
279 | :restricted_unauthenticated
281 | :confirmation_pending
282 def visible_for(user, for_user \\ nil)
284 def visible_for(%User{invisible: true}, _), do: :invisible
286 def visible_for(%User{id: user_id}, %User{id: user_id}), do: :visible
288 def visible_for(%User{} = user, nil) do
289 if restrict_unauthenticated?(user) do
290 :restrict_unauthenticated
292 visible_account_status(user)
296 def visible_for(%User{} = user, for_user) do
297 if superuser?(for_user) do
300 visible_account_status(user)
304 def visible_for(_, _), do: :invisible
306 defp restrict_unauthenticated?(%User{local: local}) do
307 config_key = if local, do: :local, else: :remote
309 Config.get([:restrict_unauthenticated, :profiles, config_key], false)
312 defp visible_account_status(user) do
313 status = account_status(user)
315 if status in [:active, :password_reset_pending] do
322 @spec superuser?(User.t()) :: boolean()
323 def superuser?(%User{local: true, is_admin: true}), do: true
324 def superuser?(%User{local: true, is_moderator: true}), do: true
325 def superuser?(_), do: false
327 @spec invisible?(User.t()) :: boolean()
328 def invisible?(%User{invisible: true}), do: true
329 def invisible?(_), do: false
331 def avatar_url(user, options \\ []) do
333 %{"url" => [%{"href" => href} | _]} ->
337 unless options[:no_default] do
338 Config.get([:assets, :default_user_avatar], "#{Web.base_url()}/images/avi.png")
343 def banner_url(user, options \\ []) do
345 %{"url" => [%{"href" => href} | _]} -> href
346 _ -> !options[:no_default] && "#{Web.base_url()}/images/banner.png"
350 # Should probably be renamed or removed
351 def ap_id(%User{nickname: nickname}), do: "#{Web.base_url()}/users/#{nickname}"
353 def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
354 def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"
356 @spec ap_following(User.t()) :: String.t()
357 def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
358 def ap_following(%User{} = user), do: "#{ap_id(user)}/following"
360 @spec restrict_deactivated(Ecto.Query.t()) :: Ecto.Query.t()
361 def restrict_deactivated(query) do
362 from(u in query, where: u.deactivated != ^true)
365 defdelegate following_count(user), to: FollowingRelationship
367 defp truncate_fields_param(params) do
368 if Map.has_key?(params, :fields) do
369 Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
375 defp truncate_if_exists(params, key, max_length) do
376 if Map.has_key?(params, key) and is_binary(params[key]) do
377 {value, _chopped} = String.split_at(params[key], max_length)
378 Map.put(params, key, value)
384 defp fix_follower_address(%{follower_address: _, following_address: _} = params), do: params
386 defp fix_follower_address(%{nickname: nickname} = params),
387 do: Map.put(params, :follower_address, ap_followers(%User{nickname: nickname}))
389 defp fix_follower_address(params), do: params
391 def remote_user_changeset(struct \\ %User{local: false}, params) do
392 bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
393 name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
396 case params[:name] do
397 name when is_binary(name) and byte_size(name) > 0 -> name
398 _ -> params[:nickname]
403 |> Map.put(:name, name)
404 |> Map.put_new(:last_refreshed_at, NaiveDateTime.utc_now())
405 |> truncate_if_exists(:name, name_limit)
406 |> truncate_if_exists(:bio, bio_limit)
407 |> truncate_fields_param()
408 |> fix_follower_address()
432 :hide_followers_count,
441 :accepts_chat_messages
444 |> validate_required([:name, :ap_id])
445 |> unique_constraint(:nickname)
446 |> validate_format(:nickname, @email_regex)
447 |> validate_length(:bio, max: bio_limit)
448 |> validate_length(:name, max: name_limit)
449 |> validate_fields(true)
452 def update_changeset(struct, params \\ %{}) do
453 bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
454 name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
474 :hide_followers_count,
477 :allow_following_move,
480 :skip_thread_containment,
483 :pleroma_settings_store,
489 |> unique_constraint(:nickname)
490 |> validate_format(:nickname, local_nickname_regex())
491 |> validate_length(:bio, max: bio_limit)
492 |> validate_length(:name, min: 1, max: name_limit)
493 |> validate_inclusion(:actor_type, ["Person", "Service"])
496 |> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
497 |> put_change_if_present(:avatar, &put_upload(&1, :avatar))
498 |> put_change_if_present(:banner, &put_upload(&1, :banner))
499 |> put_change_if_present(:background, &put_upload(&1, :background))
500 |> put_change_if_present(
501 :pleroma_settings_store,
502 &{:ok, Map.merge(struct.pleroma_settings_store, &1)}
504 |> validate_fields(false)
507 defp put_fields(changeset) do
508 if raw_fields = get_change(changeset, :raw_fields) do
511 |> Enum.filter(fn %{"name" => n} -> n != "" end)
515 |> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)
518 |> put_change(:raw_fields, raw_fields)
519 |> put_change(:fields, fields)
525 defp parse_fields(value) do
527 |> Formatter.linkify(mentions_format: :full)
531 defp put_emoji(changeset) do
532 bio = get_change(changeset, :bio)
533 name = get_change(changeset, :name)
536 emoji = Map.merge(Emoji.Formatter.get_emoji_map(bio), Emoji.Formatter.get_emoji_map(name))
537 put_change(changeset, :emoji, emoji)
543 defp put_change_if_present(changeset, map_field, value_function) do
544 if value = get_change(changeset, map_field) do
545 with {:ok, new_value} <- value_function.(value) do
546 put_change(changeset, map_field, new_value)
555 defp put_upload(value, type) do
556 with %Plug.Upload{} <- value,
557 {:ok, object} <- ActivityPub.upload(value, type: type) do
562 def update_as_admin_changeset(struct, params) do
564 |> update_changeset(params)
565 |> cast(params, [:email])
566 |> delete_change(:also_known_as)
567 |> unique_constraint(:email)
568 |> validate_format(:email, @email_regex)
569 |> validate_inclusion(:actor_type, ["Person", "Service"])
572 @spec update_as_admin(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
573 def update_as_admin(user, params) do
574 params = Map.put(params, "password_confirmation", params["password"])
575 changeset = update_as_admin_changeset(user, params)
577 if params["password"] do
578 reset_password(user, changeset, params)
580 User.update_and_set_cache(changeset)
584 def password_update_changeset(struct, params) do
586 |> cast(params, [:password, :password_confirmation])
587 |> validate_required([:password, :password_confirmation])
588 |> validate_confirmation(:password)
589 |> put_password_hash()
590 |> put_change(:password_reset_pending, false)
593 @spec reset_password(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
594 def reset_password(%User{} = user, params) do
595 reset_password(user, user, params)
598 def reset_password(%User{id: user_id} = user, struct, params) do
601 |> Multi.update(:user, password_update_changeset(struct, params))
602 |> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
603 |> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))
605 case Repo.transaction(multi) do
606 {:ok, %{user: user} = _} -> set_cache(user)
607 {:error, _, changeset, _} -> {:error, changeset}
611 def update_password_reset_pending(user, value) do
614 |> put_change(:password_reset_pending, value)
615 |> update_and_set_cache()
618 def force_password_reset_async(user) do
619 BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
622 @spec force_password_reset(User.t()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
623 def force_password_reset(user), do: update_password_reset_pending(user, true)
625 def register_changeset(struct, params \\ %{}, opts \\ []) do
626 bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
627 name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
628 params = Map.put_new(params, :accepts_chat_messages, true)
631 if is_nil(opts[:need_confirmation]) do
632 Pleroma.Config.get([:instance, :account_activation_required])
634 opts[:need_confirmation]
638 |> confirmation_changeset(need_confirmation: need_confirmation?)
646 :password_confirmation,
648 :accepts_chat_messages
650 |> validate_required([:name, :nickname, :password, :password_confirmation])
651 |> validate_confirmation(:password)
652 |> unique_constraint(:email)
653 |> unique_constraint(:nickname)
654 |> validate_exclusion(:nickname, Pleroma.Config.get([User, :restricted_nicknames]))
655 |> validate_format(:nickname, local_nickname_regex())
656 |> validate_format(:email, @email_regex)
657 |> validate_length(:bio, max: bio_limit)
658 |> validate_length(:name, min: 1, max: name_limit)
659 |> maybe_validate_required_email(opts[:external])
662 |> unique_constraint(:ap_id)
663 |> put_following_and_follower_address()
666 def maybe_validate_required_email(changeset, true), do: changeset
668 def maybe_validate_required_email(changeset, _) do
669 if Pleroma.Config.get([:instance, :account_activation_required]) do
670 validate_required(changeset, [:email])
676 defp put_ap_id(changeset) do
677 ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
678 put_change(changeset, :ap_id, ap_id)
681 defp put_following_and_follower_address(changeset) do
682 followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
685 |> put_change(:follower_address, followers)
688 defp autofollow_users(user) do
689 candidates = Pleroma.Config.get([:instance, :autofollowed_nicknames])
692 User.Query.build(%{nickname: candidates, local: true, deactivated: false})
695 follow_all(user, autofollowed_users)
698 @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
699 def register(%Ecto.Changeset{} = changeset) do
700 with {:ok, user} <- Repo.insert(changeset) do
701 post_register_action(user)
705 def post_register_action(%User{} = user) do
706 with {:ok, user} <- autofollow_users(user),
707 {:ok, user} <- set_cache(user),
708 {:ok, _} <- User.WelcomeMessage.post_welcome_message_to_user(user),
709 {:ok, _} <- try_send_confirmation_email(user) do
714 def try_send_confirmation_email(%User{} = user) do
715 if user.confirmation_pending &&
716 Pleroma.Config.get([:instance, :account_activation_required]) do
718 |> Pleroma.Emails.UserEmail.account_confirmation_email()
719 |> Pleroma.Emails.Mailer.deliver_async()
727 def try_send_confirmation_email(users) do
728 Enum.each(users, &try_send_confirmation_email/1)
731 def needs_update?(%User{local: true}), do: false
733 def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
735 def needs_update?(%User{local: false} = user) do
736 NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
739 def needs_update?(_), do: true
741 @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
743 # "Locked" (self-locked) users demand explicit authorization of follow requests
744 def maybe_direct_follow(%User{} = follower, %User{local: true, locked: true} = followed) do
745 follow(follower, followed, :follow_pending)
748 def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
749 follow(follower, followed)
752 def maybe_direct_follow(%User{} = follower, %User{} = followed) do
753 if not ap_enabled?(followed) do
754 follow(follower, followed)
760 @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
761 @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
762 def follow_all(follower, followeds) do
764 |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
765 |> Enum.each(&follow(follower, &1, :follow_accept))
770 defdelegate following(user), to: FollowingRelationship
772 def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
773 deny_follow_blocked = Pleroma.Config.get([:user, :deny_follow_blocked])
776 followed.deactivated ->
777 {:error, "Could not follow user: #{followed.nickname} is deactivated."}
779 deny_follow_blocked and blocks?(followed, follower) ->
780 {:error, "Could not follow user: #{followed.nickname} blocked you."}
783 FollowingRelationship.follow(follower, followed, state)
785 {:ok, _} = update_follower_count(followed)
788 |> update_following_count()
792 def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
793 {:error, "Not subscribed!"}
796 @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
797 def unfollow(%User{} = follower, %User{} = followed) do
798 case do_unfollow(follower, followed) do
799 {:ok, follower, followed} ->
800 {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
807 @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
808 defp do_unfollow(%User{} = follower, %User{} = followed) do
809 case get_follow_state(follower, followed) do
810 state when state in [:follow_pending, :follow_accept] ->
811 FollowingRelationship.unfollow(follower, followed)
812 {:ok, followed} = update_follower_count(followed)
816 |> update_following_count()
818 {:ok, follower, followed}
821 {:error, "Not subscribed!"}
825 defdelegate following?(follower, followed), to: FollowingRelationship
827 @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
828 def get_follow_state(%User{} = follower, %User{} = following) do
829 following_relationship = FollowingRelationship.get(follower, following)
830 get_follow_state(follower, following, following_relationship)
833 def get_follow_state(
836 following_relationship
838 case {following_relationship, following.local} do
840 case Utils.fetch_latest_follow(follower, following) do
841 %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
842 FollowingRelationship.state_to_enum(state)
848 {%{state: state}, _} ->
856 def locked?(%User{} = user) do
861 Repo.get_by(User, id: id)
864 def get_by_ap_id(ap_id) do
865 Repo.get_by(User, ap_id: ap_id)
868 def get_all_by_ap_id(ap_ids) do
869 from(u in __MODULE__,
870 where: u.ap_id in ^ap_ids
875 def get_all_by_ids(ids) do
876 from(u in __MODULE__, where: u.id in ^ids)
880 # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
881 # of the ap_id and the domain and tries to get that user
882 def get_by_guessed_nickname(ap_id) do
883 domain = URI.parse(ap_id).host
884 name = List.last(String.split(ap_id, "/"))
885 nickname = "#{name}@#{domain}"
887 get_cached_by_nickname(nickname)
890 def set_cache({:ok, user}), do: set_cache(user)
891 def set_cache({:error, err}), do: {:error, err}
893 def set_cache(%User{} = user) do
894 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
895 Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
896 Cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
900 def update_and_set_cache(struct, params) do
902 |> update_changeset(params)
903 |> update_and_set_cache()
906 def update_and_set_cache(changeset) do
907 with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
912 def get_user_friends_ap_ids(user) do
913 from(u in User.get_friends_query(user), select: u.ap_id)
917 @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
918 def get_cached_user_friends_ap_ids(user) do
919 Cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
920 get_user_friends_ap_ids(user)
924 def invalidate_cache(user) do
925 Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
926 Cachex.del(:user_cache, "nickname:#{user.nickname}")
927 Cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
930 @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
931 def get_cached_by_ap_id(ap_id) do
932 key = "ap_id:#{ap_id}"
934 with {:ok, nil} <- Cachex.get(:user_cache, key),
935 user when not is_nil(user) <- get_by_ap_id(ap_id),
936 {:ok, true} <- Cachex.put(:user_cache, key, user) do
944 def get_cached_by_id(id) do
948 Cachex.fetch!(:user_cache, key, fn _ ->
952 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
953 {:commit, user.ap_id}
959 get_cached_by_ap_id(ap_id)
962 def get_cached_by_nickname(nickname) do
963 key = "nickname:#{nickname}"
965 Cachex.fetch!(:user_cache, key, fn ->
966 case get_or_fetch_by_nickname(nickname) do
967 {:ok, user} -> {:commit, user}
968 {:error, _error} -> {:ignore, nil}
973 def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
974 restrict_to_local = Pleroma.Config.get([:instance, :limit_to_local_content])
977 is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
978 get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
980 restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
981 get_cached_by_nickname(nickname_or_id)
983 restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
984 get_cached_by_nickname(nickname_or_id)
991 @spec get_by_nickname(String.t()) :: User.t() | nil
992 def get_by_nickname(nickname) do
993 Repo.get_by(User, nickname: nickname) ||
994 if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
995 Repo.get_by(User, nickname: local_nickname(nickname))
999 def get_by_email(email), do: Repo.get_by(User, email: email)
1001 def get_by_nickname_or_email(nickname_or_email) do
1002 get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
1005 def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
1007 def get_or_fetch_by_nickname(nickname) do
1008 with %User{} = user <- get_by_nickname(nickname) do
1012 with [_nick, _domain] <- String.split(nickname, "@"),
1013 {:ok, user} <- fetch_by_nickname(nickname) do
1016 _e -> {:error, "not found " <> nickname}
1021 @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1022 def get_followers_query(%User{} = user, nil) do
1023 User.Query.build(%{followers: user, deactivated: false})
1026 def get_followers_query(user, page) do
1028 |> get_followers_query(nil)
1029 |> User.Query.paginate(page, 20)
1032 @spec get_followers_query(User.t()) :: Ecto.Query.t()
1033 def get_followers_query(user), do: get_followers_query(user, nil)
1035 @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1036 def get_followers(user, page \\ nil) do
1038 |> get_followers_query(page)
1042 @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1043 def get_external_followers(user, page \\ nil) do
1045 |> get_followers_query(page)
1046 |> User.Query.build(%{external: true})
1050 def get_followers_ids(user, page \\ nil) do
1052 |> get_followers_query(page)
1053 |> select([u], u.id)
1057 @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1058 def get_friends_query(%User{} = user, nil) do
1059 User.Query.build(%{friends: user, deactivated: false})
1062 def get_friends_query(user, page) do
1064 |> get_friends_query(nil)
1065 |> User.Query.paginate(page, 20)
1068 @spec get_friends_query(User.t()) :: Ecto.Query.t()
1069 def get_friends_query(user), do: get_friends_query(user, nil)
1071 def get_friends(user, page \\ nil) do
1073 |> get_friends_query(page)
1077 def get_friends_ap_ids(user) do
1079 |> get_friends_query(nil)
1080 |> select([u], u.ap_id)
1084 def get_friends_ids(user, page \\ nil) do
1086 |> get_friends_query(page)
1087 |> select([u], u.id)
1091 defdelegate get_follow_requests(user), to: FollowingRelationship
1093 def increase_note_count(%User{} = user) do
1095 |> where(id: ^user.id)
1096 |> update([u], inc: [note_count: 1])
1098 |> Repo.update_all([])
1100 {1, [user]} -> set_cache(user)
1105 def decrease_note_count(%User{} = user) do
1107 |> where(id: ^user.id)
1110 note_count: fragment("greatest(0, note_count - 1)")
1114 |> Repo.update_all([])
1116 {1, [user]} -> set_cache(user)
1121 def update_note_count(%User{} = user, note_count \\ nil) do
1126 where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1132 |> cast(%{note_count: note_count}, [:note_count])
1133 |> update_and_set_cache()
1136 @spec maybe_fetch_follow_information(User.t()) :: User.t()
1137 def maybe_fetch_follow_information(user) do
1138 with {:ok, user} <- fetch_follow_information(user) do
1142 Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1148 def fetch_follow_information(user) do
1149 with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1151 |> follow_information_changeset(info)
1152 |> update_and_set_cache()
1156 defp follow_information_changeset(user, params) do
1163 :hide_followers_count,
1168 @spec update_follower_count(User.t()) :: {:ok, User.t()}
1169 def update_follower_count(%User{} = user) do
1170 if user.local or !Pleroma.Config.get([:instance, :external_user_synchronization]) do
1171 follower_count = FollowingRelationship.follower_count(user)
1174 |> follow_information_changeset(%{follower_count: follower_count})
1175 |> update_and_set_cache
1177 {:ok, maybe_fetch_follow_information(user)}
1181 @spec update_following_count(User.t()) :: {:ok, User.t()}
1182 def update_following_count(%User{local: false} = user) do
1183 if Pleroma.Config.get([:instance, :external_user_synchronization]) do
1184 {:ok, maybe_fetch_follow_information(user)}
1190 def update_following_count(%User{local: true} = user) do
1191 following_count = FollowingRelationship.following_count(user)
1194 |> follow_information_changeset(%{following_count: following_count})
1195 |> update_and_set_cache()
1198 def set_unread_conversation_count(%User{local: true} = user) do
1199 unread_query = Participation.unread_conversation_count_for_user(user)
1202 |> join(:inner, [u], p in subquery(unread_query))
1204 set: [unread_conversation_count: p.count]
1206 |> where([u], u.id == ^user.id)
1208 |> Repo.update_all([])
1210 {1, [user]} -> set_cache(user)
1215 def set_unread_conversation_count(user), do: {:ok, user}
1217 def increment_unread_conversation_count(conversation, %User{local: true} = user) do
1219 Participation.unread_conversation_count_for_user(user)
1220 |> where([p], p.conversation_id == ^conversation.id)
1223 |> join(:inner, [u], p in subquery(unread_query))
1225 inc: [unread_conversation_count: 1]
1227 |> where([u], u.id == ^user.id)
1228 |> where([u, p], p.count == 0)
1230 |> Repo.update_all([])
1232 {1, [user]} -> set_cache(user)
1237 def increment_unread_conversation_count(_, user), do: {:ok, user}
1239 @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1240 def get_users_from_set(ap_ids, opts \\ []) do
1241 local_only = Keyword.get(opts, :local_only, true)
1242 criteria = %{ap_id: ap_ids, deactivated: false}
1243 criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1245 User.Query.build(criteria)
1249 @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1250 def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1253 query = User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
1259 @spec mute(User.t(), User.t(), boolean()) ::
1260 {:ok, list(UserRelationship.t())} | {:error, String.t()}
1261 def mute(%User{} = muter, %User{} = mutee, notifications? \\ true) do
1262 add_to_mutes(muter, mutee, notifications?)
1265 def unmute(%User{} = muter, %User{} = mutee) do
1266 remove_from_mutes(muter, mutee)
1269 def subscribe(%User{} = subscriber, %User{} = target) do
1270 deny_follow_blocked = Pleroma.Config.get([:user, :deny_follow_blocked])
1272 if blocks?(target, subscriber) and deny_follow_blocked do
1273 {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1275 # Note: the relationship is inverse: subscriber acts as relationship target
1276 UserRelationship.create_inverse_subscription(target, subscriber)
1280 def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1281 with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1282 subscribe(subscriber, subscribee)
1286 def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1287 # Note: the relationship is inverse: subscriber acts as relationship target
1288 UserRelationship.delete_inverse_subscription(target, unsubscriber)
1291 def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1292 with %User{} = user <- get_cached_by_ap_id(ap_id) do
1293 unsubscribe(unsubscriber, user)
1297 def block(%User{} = blocker, %User{} = blocked) do
1298 # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1300 if following?(blocker, blocked) do
1301 {:ok, blocker, _} = unfollow(blocker, blocked)
1307 # clear any requested follows as well
1309 case CommonAPI.reject_follow_request(blocked, blocker) do
1310 {:ok, %User{} = updated_blocked} -> updated_blocked
1314 unsubscribe(blocked, blocker)
1316 unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
1317 if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)
1319 {:ok, blocker} = update_follower_count(blocker)
1320 {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1321 add_to_block(blocker, blocked)
1324 # helper to handle the block given only an actor's AP id
1325 def block(%User{} = blocker, %{ap_id: ap_id}) do
1326 block(blocker, get_cached_by_ap_id(ap_id))
1329 def unblock(%User{} = blocker, %User{} = blocked) do
1330 remove_from_block(blocker, blocked)
1333 # helper to handle the block given only an actor's AP id
1334 def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1335 unblock(blocker, get_cached_by_ap_id(ap_id))
1338 def mutes?(nil, _), do: false
1339 def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1341 def mutes_user?(%User{} = user, %User{} = target) do
1342 UserRelationship.mute_exists?(user, target)
1345 @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1346 def muted_notifications?(nil, _), do: false
1348 def muted_notifications?(%User{} = user, %User{} = target),
1349 do: UserRelationship.notification_mute_exists?(user, target)
1351 def blocks?(nil, _), do: false
1353 def blocks?(%User{} = user, %User{} = target) do
1354 blocks_user?(user, target) ||
1355 (blocks_domain?(user, target) and not User.following?(user, target))
1358 def blocks_user?(%User{} = user, %User{} = target) do
1359 UserRelationship.block_exists?(user, target)
1362 def blocks_user?(_, _), do: false
1364 def blocks_domain?(%User{} = user, %User{} = target) do
1365 domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1366 %{host: host} = URI.parse(target.ap_id)
1367 Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1370 def blocks_domain?(_, _), do: false
1372 def subscribed_to?(%User{} = user, %User{} = target) do
1373 # Note: the relationship is inverse: subscriber acts as relationship target
1374 UserRelationship.inverse_subscription_exists?(target, user)
1377 def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1378 with %User{} = target <- get_cached_by_ap_id(ap_id) do
1379 subscribed_to?(user, target)
1384 Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1385 E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1387 @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1388 def outgoing_relationships_ap_ids(_user, []), do: %{}
1390 def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1392 def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1393 when is_list(relationship_types) do
1396 |> assoc(:outgoing_relationships)
1397 |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1398 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1399 |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1400 |> group_by([user_rel, u], user_rel.relationship_type)
1402 |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1407 fn rel_type -> {rel_type, db_result[rel_type] || []} end
1411 def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1413 def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1415 def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1417 def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1418 when is_list(relationship_types) do
1420 |> assoc(:incoming_relationships)
1421 |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1422 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1423 |> maybe_filter_on_ap_id(ap_ids)
1424 |> select([user_rel, u], u.ap_id)
1429 defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1430 where(query, [user_rel, u], u.ap_id in ^ap_ids)
1433 defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1435 def deactivate_async(user, status \\ true) do
1436 BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
1439 def deactivate(user, status \\ true)
1441 def deactivate(users, status) when is_list(users) do
1442 Repo.transaction(fn ->
1443 for user <- users, do: deactivate(user, status)
1447 def deactivate(%User{} = user, status) do
1448 with {:ok, user} <- set_activation_status(user, status) do
1451 |> Enum.filter(& &1.local)
1452 |> Enum.each(&set_cache(update_following_count(&1)))
1454 # Only update local user counts, remote will be update during the next pull.
1457 |> Enum.filter(& &1.local)
1458 |> Enum.each(&do_unfollow(user, &1))
1464 def update_notification_settings(%User{} = user, settings) do
1466 |> cast(%{notification_settings: settings}, [])
1467 |> cast_embed(:notification_settings)
1468 |> validate_required([:notification_settings])
1469 |> update_and_set_cache()
1472 def delete(users) when is_list(users) do
1473 for user <- users, do: delete(user)
1476 def delete(%User{} = user) do
1477 BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1480 defp delete_and_invalidate_cache(%User{} = user) do
1481 invalidate_cache(user)
1485 defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)
1487 defp delete_or_deactivate(%User{local: true} = user) do
1488 status = account_status(user)
1490 if status == :confirmation_pending do
1491 delete_and_invalidate_cache(user)
1494 |> change(%{deactivated: true, email: nil})
1495 |> update_and_set_cache()
1499 def perform(:force_password_reset, user), do: force_password_reset(user)
1501 @spec perform(atom(), User.t()) :: {:ok, User.t()}
1502 def perform(:delete, %User{} = user) do
1503 # Remove all relationships
1506 |> Enum.each(fn follower ->
1507 ActivityPub.unfollow(follower, user)
1508 unfollow(follower, user)
1513 |> Enum.each(fn followed ->
1514 ActivityPub.unfollow(user, followed)
1515 unfollow(user, followed)
1518 delete_user_activities(user)
1519 delete_notifications_from_user_activities(user)
1521 delete_outgoing_pending_follow_requests(user)
1523 delete_or_deactivate(user)
1526 def perform(:deactivate_async, user, status), do: deactivate(user, status)
1528 @spec perform(atom(), User.t(), list()) :: list() | {:error, any()}
1529 def perform(:blocks_import, %User{} = blocker, blocked_identifiers)
1530 when is_list(blocked_identifiers) do
1532 blocked_identifiers,
1533 fn blocked_identifier ->
1534 with {:ok, %User{} = blocked} <- get_or_fetch(blocked_identifier),
1535 {:ok, _block} <- CommonAPI.block(blocker, blocked) do
1539 Logger.debug("blocks_import failed for #{blocked_identifier} with: #{inspect(err)}")
1546 def perform(:follow_import, %User{} = follower, followed_identifiers)
1547 when is_list(followed_identifiers) do
1549 followed_identifiers,
1550 fn followed_identifier ->
1551 with {:ok, %User{} = followed} <- get_or_fetch(followed_identifier),
1552 {:ok, follower} <- maybe_direct_follow(follower, followed),
1553 {:ok, _} <- ActivityPub.follow(follower, followed) do
1557 Logger.debug("follow_import failed for #{followed_identifier} with: #{inspect(err)}")
1564 @spec external_users_query() :: Ecto.Query.t()
1565 def external_users_query do
1573 @spec external_users(keyword()) :: [User.t()]
1574 def external_users(opts \\ []) do
1576 external_users_query()
1577 |> select([u], struct(u, [:id, :ap_id]))
1581 do: where(query, [u], u.id > ^opts[:max_id]),
1586 do: limit(query, ^opts[:limit]),
1592 def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers) do
1593 BackgroundWorker.enqueue("blocks_import", %{
1594 "blocker_id" => blocker.id,
1595 "blocked_identifiers" => blocked_identifiers
1599 def follow_import(%User{} = follower, followed_identifiers)
1600 when is_list(followed_identifiers) do
1601 BackgroundWorker.enqueue("follow_import", %{
1602 "follower_id" => follower.id,
1603 "followed_identifiers" => followed_identifiers
1607 def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1609 |> join(:inner, [n], activity in assoc(n, :activity))
1610 |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1611 |> Repo.delete_all()
1614 def delete_user_activities(%User{ap_id: ap_id} = user) do
1616 |> Activity.Queries.by_actor()
1617 |> RepoStreamer.chunk_stream(50)
1618 |> Stream.each(fn activities ->
1619 Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1624 defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1625 with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1626 {:ok, delete_data, _} <- Builder.delete(user, object) do
1627 Pipeline.common_pipeline(delete_data, local: user.local)
1629 {:find_object, nil} ->
1630 # We have the create activity, but not the object, it was probably pruned.
1631 # Insert a tombstone and try again
1632 with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1633 {:ok, _tombstone} <- Object.create(tombstone_data) do
1634 delete_activity(activity, user)
1638 Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1639 Logger.error("Error: #{inspect(e)}")
1643 defp delete_activity(%{data: %{"type" => type}} = activity, user)
1644 when type in ["Like", "Announce"] do
1645 {:ok, undo, _} = Builder.undo(user, activity)
1646 Pipeline.common_pipeline(undo, local: user.local)
1649 defp delete_activity(_activity, _user), do: "Doing nothing"
1651 defp delete_outgoing_pending_follow_requests(user) do
1653 |> FollowingRelationship.outgoing_pending_follow_requests_query()
1654 |> Repo.delete_all()
1657 def html_filter_policy(%User{no_rich_text: true}) do
1658 Pleroma.HTML.Scrubber.TwitterText
1661 def html_filter_policy(_), do: Pleroma.Config.get([:markup, :scrub_policy])
1663 def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1665 def get_or_fetch_by_ap_id(ap_id) do
1666 cached_user = get_cached_by_ap_id(ap_id)
1668 maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)
1670 case {cached_user, maybe_fetched_user} do
1671 {_, {:ok, %User{} = user}} ->
1674 {%User{} = user, _} ->
1678 {:error, :not_found}
1683 Creates an internal service actor by URI if missing.
1684 Optionally takes nickname for addressing.
1686 @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1687 def get_or_create_service_actor_by_ap_id(uri, nickname) do
1689 case get_cached_by_ap_id(uri) do
1691 with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1692 Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1696 %User{invisible: false} = user ->
1706 @spec set_invisible(User.t()) :: {:ok, User.t()}
1707 defp set_invisible(user) do
1709 |> change(%{invisible: true})
1710 |> update_and_set_cache()
1713 @spec create_service_actor(String.t(), String.t()) ::
1714 {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1715 defp create_service_actor(uri, nickname) do
1721 follower_address: uri <> "/followers"
1724 |> unique_constraint(:nickname)
1729 def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1732 |> :public_key.pem_decode()
1734 |> :public_key.pem_entry_decode()
1739 def public_key(_), do: {:error, "key not found"}
1741 def get_public_key_for_ap_id(ap_id) do
1742 with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1743 {:ok, public_key} <- public_key(user) do
1750 def ap_enabled?(%User{local: true}), do: true
1751 def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1752 def ap_enabled?(_), do: false
1754 @doc "Gets or fetch a user by uri or nickname."
1755 @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1756 def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1757 def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1759 # wait a period of time and return newest version of the User structs
1760 # this is because we have synchronous follow APIs and need to simulate them
1761 # with an async handshake
1762 def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1763 with %User{} = a <- get_cached_by_id(a.id),
1764 %User{} = b <- get_cached_by_id(b.id) do
1771 def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1772 with :ok <- :timer.sleep(timeout),
1773 %User{} = a <- get_cached_by_id(a.id),
1774 %User{} = b <- get_cached_by_id(b.id) do
1781 def parse_bio(bio) when is_binary(bio) and bio != "" do
1783 |> CommonUtils.format_input("text/plain", mentions_format: :full)
1787 def parse_bio(_), do: ""
1789 def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1790 # TODO: get profile URLs other than user.ap_id
1791 profile_urls = [user.ap_id]
1794 |> CommonUtils.format_input("text/plain",
1795 mentions_format: :full,
1796 rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1801 def parse_bio(_, _), do: ""
1803 def tag(user_identifiers, tags) when is_list(user_identifiers) do
1804 Repo.transaction(fn ->
1805 for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1809 def tag(nickname, tags) when is_binary(nickname),
1810 do: tag(get_by_nickname(nickname), tags)
1812 def tag(%User{} = user, tags),
1813 do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1815 def untag(user_identifiers, tags) when is_list(user_identifiers) do
1816 Repo.transaction(fn ->
1817 for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1821 def untag(nickname, tags) when is_binary(nickname),
1822 do: untag(get_by_nickname(nickname), tags)
1824 def untag(%User{} = user, tags),
1825 do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1827 defp update_tags(%User{} = user, new_tags) do
1828 {:ok, updated_user} =
1830 |> change(%{tags: new_tags})
1831 |> update_and_set_cache()
1836 defp normalize_tags(tags) do
1839 |> Enum.map(&String.downcase/1)
1842 defp local_nickname_regex do
1843 if Pleroma.Config.get([:instance, :extended_nickname_format]) do
1844 @extended_local_nickname_regex
1846 @strict_local_nickname_regex
1850 def local_nickname(nickname_or_mention) do
1853 |> String.split("@")
1857 def full_nickname(nickname_or_mention),
1858 do: String.trim_leading(nickname_or_mention, "@")
1860 def error_user(ap_id) do
1864 nickname: "erroruser@example.com",
1865 inserted_at: NaiveDateTime.utc_now()
1869 @spec all_superusers() :: [User.t()]
1870 def all_superusers do
1871 User.Query.build(%{super_users: true, local: true, deactivated: false})
1875 def muting_reblogs?(%User{} = user, %User{} = target) do
1876 UserRelationship.reblog_mute_exists?(user, target)
1879 def showing_reblogs?(%User{} = user, %User{} = target) do
1880 not muting_reblogs?(user, target)
1884 The function returns a query to get users with no activity for given interval of days.
1885 Inactive users are those who didn't read any notification, or had any activity where
1886 the user is the activity's actor, during `inactivity_threshold` days.
1887 Deactivated users will not appear in this list.
1891 iex> Pleroma.User.list_inactive_users()
1894 @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
1895 def list_inactive_users_query(inactivity_threshold \\ 7) do
1896 negative_inactivity_threshold = -inactivity_threshold
1897 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
1898 # Subqueries are not supported in `where` clauses, join gets too complicated.
1899 has_read_notifications =
1900 from(n in Pleroma.Notification,
1901 where: n.seen == true,
1903 having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
1906 |> Pleroma.Repo.all()
1908 from(u in Pleroma.User,
1909 left_join: a in Pleroma.Activity,
1910 on: u.ap_id == a.actor,
1911 where: not is_nil(u.nickname),
1912 where: u.deactivated != ^true,
1913 where: u.id not in ^has_read_notifications,
1916 max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
1917 is_nil(max(a.inserted_at))
1922 Enable or disable email notifications for user
1926 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
1927 Pleroma.User{email_notifications: %{"digest" => true}}
1929 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
1930 Pleroma.User{email_notifications: %{"digest" => false}}
1932 @spec switch_email_notifications(t(), String.t(), boolean()) ::
1933 {:ok, t()} | {:error, Ecto.Changeset.t()}
1934 def switch_email_notifications(user, type, status) do
1935 User.update_email_notifications(user, %{type => status})
1939 Set `last_digest_emailed_at` value for the user to current time
1941 @spec touch_last_digest_emailed_at(t()) :: t()
1942 def touch_last_digest_emailed_at(user) do
1943 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
1945 {:ok, updated_user} =
1947 |> change(%{last_digest_emailed_at: now})
1948 |> update_and_set_cache()
1953 @spec toggle_confirmation(User.t()) :: {:ok, User.t()} | {:error, Changeset.t()}
1954 def toggle_confirmation(%User{} = user) do
1956 |> confirmation_changeset(need_confirmation: !user.confirmation_pending)
1957 |> update_and_set_cache()
1960 @spec toggle_confirmation([User.t()]) :: [{:ok, User.t()} | {:error, Changeset.t()}]
1961 def toggle_confirmation(users) do
1962 Enum.map(users, &toggle_confirmation/1)
1965 def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
1969 def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
1970 # use instance-default
1971 config = Pleroma.Config.get([:assets, :mascots])
1972 default_mascot = Pleroma.Config.get([:assets, :default_mascot])
1973 mascot = Keyword.get(config, default_mascot)
1976 "id" => "default-mascot",
1977 "url" => mascot[:url],
1978 "preview_url" => mascot[:url],
1980 "mime_type" => mascot[:mime_type]
1985 def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
1987 def ensure_keys_present(%User{} = user) do
1988 with {:ok, pem} <- Keys.generate_rsa_pem() do
1990 |> cast(%{keys: pem}, [:keys])
1991 |> validate_required([:keys])
1992 |> update_and_set_cache()
1996 def get_ap_ids_by_nicknames(nicknames) do
1998 where: u.nickname in ^nicknames,
2004 defdelegate search(query, opts \\ []), to: User.Search
2006 defp put_password_hash(
2007 %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2009 change(changeset, password_hash: Pbkdf2.hash_pwd_salt(password))
2012 defp put_password_hash(changeset), do: changeset
2014 def is_internal_user?(%User{nickname: nil}), do: true
2015 def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2016 def is_internal_user?(_), do: false
2018 # A hack because user delete activities have a fake id for whatever reason
2019 # TODO: Get rid of this
2020 def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2022 def get_delivered_users_by_object_id(object_id) do
2024 inner_join: delivery in assoc(u, :deliveries),
2025 where: delivery.object_id == ^object_id
2030 def change_email(user, email) do
2032 |> cast(%{email: email}, [:email])
2033 |> validate_required([:email])
2034 |> unique_constraint(:email)
2035 |> validate_format(:email, @email_regex)
2036 |> update_and_set_cache()
2039 # Internal function; public one is `deactivate/2`
2040 defp set_activation_status(user, deactivated) do
2042 |> cast(%{deactivated: deactivated}, [:deactivated])
2043 |> update_and_set_cache()
2046 def update_banner(user, banner) do
2048 |> cast(%{banner: banner}, [:banner])
2049 |> update_and_set_cache()
2052 def update_background(user, background) do
2054 |> cast(%{background: background}, [:background])
2055 |> update_and_set_cache()
2058 def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
2061 moderator: is_moderator
2065 def validate_fields(changeset, remote? \\ false) do
2066 limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2067 limit = Pleroma.Config.get([:instance, limit_name], 0)
2070 |> validate_length(:fields, max: limit)
2071 |> validate_change(:fields, fn :fields, fields ->
2072 if Enum.all?(fields, &valid_field?/1) do
2080 defp valid_field?(%{"name" => name, "value" => value}) do
2081 name_limit = Pleroma.Config.get([:instance, :account_field_name_length], 255)
2082 value_limit = Pleroma.Config.get([:instance, :account_field_value_length], 255)
2084 is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2085 String.length(value) <= value_limit
2088 defp valid_field?(_), do: false
2090 defp truncate_field(%{"name" => name, "value" => value}) do
2092 String.split_at(name, Pleroma.Config.get([:instance, :account_field_name_length], 255))
2095 String.split_at(value, Pleroma.Config.get([:instance, :account_field_value_length], 255))
2097 %{"name" => name, "value" => value}
2100 def admin_api_update(user, params) do
2107 |> update_and_set_cache()
2110 @doc "Signs user out of all applications"
2111 def global_sign_out(user) do
2112 OAuth.Authorization.delete_user_authorizations(user)
2113 OAuth.Token.delete_user_tokens(user)
2116 def mascot_update(user, url) do
2118 |> cast(%{mascot: url}, [:mascot])
2119 |> validate_required([:mascot])
2120 |> update_and_set_cache()
2123 def mastodon_settings_update(user, settings) do
2125 |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
2126 |> validate_required([:mastofe_settings])
2127 |> update_and_set_cache()
2130 @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2131 def confirmation_changeset(user, need_confirmation: need_confirmation?) do
2133 if need_confirmation? do
2135 confirmation_pending: true,
2136 confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2140 confirmation_pending: false,
2141 confirmation_token: nil
2145 cast(user, params, [:confirmation_pending, :confirmation_token])
2148 def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2149 if id not in user.pinned_activities do
2150 max_pinned_statuses = Pleroma.Config.get([:instance, :max_pinned_statuses], 0)
2151 params = %{pinned_activities: user.pinned_activities ++ [id]}
2154 |> cast(params, [:pinned_activities])
2155 |> validate_length(:pinned_activities,
2156 max: max_pinned_statuses,
2157 message: "You have already pinned the maximum number of statuses"
2162 |> update_and_set_cache()
2165 def remove_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2166 params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2169 |> cast(params, [:pinned_activities])
2170 |> update_and_set_cache()
2173 def update_email_notifications(user, settings) do
2174 email_notifications =
2175 user.email_notifications
2176 |> Map.merge(settings)
2177 |> Map.take(["digest"])
2179 params = %{email_notifications: email_notifications}
2180 fields = [:email_notifications]
2183 |> cast(params, fields)
2184 |> validate_required(fields)
2185 |> update_and_set_cache()
2188 defp set_domain_blocks(user, domain_blocks) do
2189 params = %{domain_blocks: domain_blocks}
2192 |> cast(params, [:domain_blocks])
2193 |> validate_required([:domain_blocks])
2194 |> update_and_set_cache()
2197 def block_domain(user, domain_blocked) do
2198 set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2201 def unblock_domain(user, domain_blocked) do
2202 set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2205 @spec add_to_block(User.t(), User.t()) ::
2206 {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2207 defp add_to_block(%User{} = user, %User{} = blocked) do
2208 UserRelationship.create_block(user, blocked)
2211 @spec add_to_block(User.t(), User.t()) ::
2212 {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2213 defp remove_from_block(%User{} = user, %User{} = blocked) do
2214 UserRelationship.delete_block(user, blocked)
2217 defp add_to_mutes(%User{} = user, %User{} = muted_user, notifications?) do
2218 with {:ok, user_mute} <- UserRelationship.create_mute(user, muted_user),
2219 {:ok, user_notification_mute} <-
2220 (notifications? && UserRelationship.create_notification_mute(user, muted_user)) ||
2222 {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
2226 defp remove_from_mutes(user, %User{} = muted_user) do
2227 with {:ok, user_mute} <- UserRelationship.delete_mute(user, muted_user),
2228 {:ok, user_notification_mute} <-
2229 UserRelationship.delete_notification_mute(user, muted_user) do
2230 {:ok, [user_mute, user_notification_mute]}
2234 def set_invisible(user, invisible) do
2235 params = %{invisible: invisible}
2238 |> cast(params, [:invisible])
2239 |> validate_required([:invisible])
2240 |> update_and_set_cache()
2243 def sanitize_html(%User{} = user) do
2244 sanitize_html(user, nil)
2247 # User data that mastodon isn't filtering (treated as plaintext):
2250 def sanitize_html(%User{} = user, filter) do
2252 Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2255 "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2260 |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2261 |> Map.put(:fields, fields)