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(: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)
143 :notification_settings,
144 Pleroma.User.NotificationSetting,
148 has_many(:notifications, Notification)
149 has_many(:registrations, Registration)
150 has_many(:deliveries, Delivery)
152 has_many(:outgoing_relationships, UserRelationship, foreign_key: :source_id)
153 has_many(:incoming_relationships, UserRelationship, foreign_key: :target_id)
155 for {relationship_type,
157 {outgoing_relation, outgoing_relation_target},
158 {incoming_relation, incoming_relation_source}
159 ]} <- @user_relationships_config do
160 # Definitions of `has_many` relations: :blocker_blocks, :muter_mutes, :reblog_muter_mutes,
161 # :notification_muter_mutes, :subscribee_subscriptions
162 has_many(outgoing_relation, UserRelationship,
163 foreign_key: :source_id,
164 where: [relationship_type: relationship_type]
167 # Definitions of `has_many` relations: :blockee_blocks, :mutee_mutes, :reblog_mutee_mutes,
168 # :notification_mutee_mutes, :subscriber_subscriptions
169 has_many(incoming_relation, UserRelationship,
170 foreign_key: :target_id,
171 where: [relationship_type: relationship_type]
174 # Definitions of `has_many` relations: :blocked_users, :muted_users, :reblog_muted_users,
175 # :notification_muted_users, :subscriber_users
176 has_many(outgoing_relation_target, through: [outgoing_relation, :target])
178 # Definitions of `has_many` relations: :blocker_users, :muter_users, :reblog_muter_users,
179 # :notification_muter_users, :subscribee_users
180 has_many(incoming_relation_source, through: [incoming_relation, :source])
183 # `:blocks` is deprecated (replaced with `blocked_users` relation)
184 field(:blocks, {:array, :string}, default: [])
185 # `:mutes` is deprecated (replaced with `muted_users` relation)
186 field(:mutes, {:array, :string}, default: [])
187 # `:muted_reblogs` is deprecated (replaced with `reblog_muted_users` relation)
188 field(:muted_reblogs, {:array, :string}, default: [])
189 # `:muted_notifications` is deprecated (replaced with `notification_muted_users` relation)
190 field(:muted_notifications, {:array, :string}, default: [])
191 # `:subscribers` is deprecated (replaced with `subscriber_users` relation)
192 field(:subscribers, {:array, :string}, default: [])
195 :multi_factor_authentication_settings,
203 for {_relationship_type, [{_outgoing_relation, outgoing_relation_target}, _]} <-
204 @user_relationships_config do
205 # `def blocked_users_relation/2`, `def muted_users_relation/2`,
206 # `def reblog_muted_users_relation/2`, `def notification_muted_users/2`,
207 # `def subscriber_users/2`
208 def unquote(:"#{outgoing_relation_target}_relation")(user, restrict_deactivated? \\ false) do
209 target_users_query = assoc(user, unquote(outgoing_relation_target))
211 if restrict_deactivated? do
212 restrict_deactivated(target_users_query)
218 # `def blocked_users/2`, `def muted_users/2`, `def reblog_muted_users/2`,
219 # `def notification_muted_users/2`, `def subscriber_users/2`
220 def unquote(outgoing_relation_target)(user, restrict_deactivated? \\ false) do
222 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
224 restrict_deactivated?
229 # `def blocked_users_ap_ids/2`, `def muted_users_ap_ids/2`, `def reblog_muted_users_ap_ids/2`,
230 # `def notification_muted_users_ap_ids/2`, `def subscriber_users_ap_ids/2`
231 def unquote(:"#{outgoing_relation_target}_ap_ids")(user, restrict_deactivated? \\ false) do
233 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
235 restrict_deactivated?
237 |> select([u], u.ap_id)
243 Dumps Flake Id to SQL-compatible format (16-byte UUID).
244 E.g. "9pQtDGXuq4p3VlcJEm" -> <<0, 0, 1, 110, 179, 218, 42, 92, 213, 41, 44, 227, 95, 213, 0, 0>>
246 def binary_id(source_id) when is_binary(source_id) do
247 with {:ok, dumped_id} <- FlakeId.Ecto.CompatType.dump(source_id) do
254 def binary_id(source_ids) when is_list(source_ids) do
255 Enum.map(source_ids, &binary_id/1)
258 def binary_id(%User{} = user), do: binary_id(user.id)
260 @doc "Returns status account"
261 @spec account_status(User.t()) :: account_status()
262 def account_status(%User{deactivated: true}), do: :deactivated
263 def account_status(%User{password_reset_pending: true}), do: :password_reset_pending
265 def account_status(%User{confirmation_pending: true}) do
266 if Config.get([:instance, :account_activation_required]) do
267 :confirmation_pending
273 def account_status(%User{}), do: :active
275 @spec visible_for(User.t(), User.t() | nil) ::
278 | :restricted_unauthenticated
280 | :confirmation_pending
281 def visible_for(user, for_user \\ nil)
283 def visible_for(%User{invisible: true}, _), do: :invisible
285 def visible_for(%User{id: user_id}, %User{id: user_id}), do: :visible
287 def visible_for(%User{} = user, nil) do
288 if restrict_unauthenticated?(user) do
289 :restrict_unauthenticated
291 visible_account_status(user)
295 def visible_for(%User{} = user, for_user) do
296 if superuser?(for_user) do
299 visible_account_status(user)
303 def visible_for(_, _), do: :invisible
305 defp restrict_unauthenticated?(%User{local: local}) do
306 config_key = if local, do: :local, else: :remote
308 Config.get([:restrict_unauthenticated, :profiles, config_key], false)
311 defp visible_account_status(user) do
312 status = account_status(user)
314 if status in [:active, :password_reset_pending] do
321 @spec superuser?(User.t()) :: boolean()
322 def superuser?(%User{local: true, is_admin: true}), do: true
323 def superuser?(%User{local: true, is_moderator: true}), do: true
324 def superuser?(_), do: false
326 @spec invisible?(User.t()) :: boolean()
327 def invisible?(%User{invisible: true}), do: true
328 def invisible?(_), do: false
330 def avatar_url(user, options \\ []) do
332 %{"url" => [%{"href" => href} | _]} ->
336 unless options[:no_default] do
337 Config.get([:assets, :default_user_avatar], "#{Web.base_url()}/images/avi.png")
342 def banner_url(user, options \\ []) do
344 %{"url" => [%{"href" => href} | _]} -> href
345 _ -> !options[:no_default] && "#{Web.base_url()}/images/banner.png"
349 # Should probably be renamed or removed
350 def ap_id(%User{nickname: nickname}), do: "#{Web.base_url()}/users/#{nickname}"
352 def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
353 def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"
355 @spec ap_following(User.t()) :: String.t()
356 def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
357 def ap_following(%User{} = user), do: "#{ap_id(user)}/following"
359 @spec restrict_deactivated(Ecto.Query.t()) :: Ecto.Query.t()
360 def restrict_deactivated(query) do
361 from(u in query, where: u.deactivated != ^true)
364 defdelegate following_count(user), to: FollowingRelationship
366 defp truncate_fields_param(params) do
367 if Map.has_key?(params, :fields) do
368 Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
374 defp truncate_if_exists(params, key, max_length) do
375 if Map.has_key?(params, key) and is_binary(params[key]) do
376 {value, _chopped} = String.split_at(params[key], max_length)
377 Map.put(params, key, value)
383 defp fix_follower_address(%{follower_address: _, following_address: _} = params), do: params
385 defp fix_follower_address(%{nickname: nickname} = params),
386 do: Map.put(params, :follower_address, ap_followers(%User{nickname: nickname}))
388 defp fix_follower_address(params), do: params
390 def remote_user_changeset(struct \\ %User{local: false}, params) do
391 bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
392 name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
395 case params[:name] do
396 name when is_binary(name) and byte_size(name) > 0 -> name
397 _ -> params[:nickname]
402 |> Map.put(:name, name)
403 |> Map.put_new(:last_refreshed_at, NaiveDateTime.utc_now())
404 |> truncate_if_exists(:name, name_limit)
405 |> truncate_if_exists(:bio, bio_limit)
406 |> truncate_fields_param()
407 |> fix_follower_address()
431 :hide_followers_count,
442 |> validate_required([:name, :ap_id])
443 |> unique_constraint(:nickname)
444 |> validate_format(:nickname, @email_regex)
445 |> validate_length(:bio, max: bio_limit)
446 |> validate_length(:name, max: name_limit)
447 |> validate_fields(true)
450 def update_changeset(struct, params \\ %{}) do
451 bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
452 name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
472 :hide_followers_count,
475 :allow_following_move,
478 :skip_thread_containment,
481 :pleroma_settings_store,
487 |> unique_constraint(:nickname)
488 |> validate_format(:nickname, local_nickname_regex())
489 |> validate_length(:bio, max: bio_limit)
490 |> validate_length(:name, min: 1, max: name_limit)
491 |> validate_inclusion(:actor_type, ["Person", "Service"])
494 |> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
495 |> put_change_if_present(:avatar, &put_upload(&1, :avatar))
496 |> put_change_if_present(:banner, &put_upload(&1, :banner))
497 |> put_change_if_present(:background, &put_upload(&1, :background))
498 |> put_change_if_present(
499 :pleroma_settings_store,
500 &{:ok, Map.merge(struct.pleroma_settings_store, &1)}
502 |> validate_fields(false)
505 defp put_fields(changeset) do
506 if raw_fields = get_change(changeset, :raw_fields) do
509 |> Enum.filter(fn %{"name" => n} -> n != "" end)
513 |> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)
516 |> put_change(:raw_fields, raw_fields)
517 |> put_change(:fields, fields)
523 defp parse_fields(value) do
525 |> Formatter.linkify(mentions_format: :full)
529 defp put_emoji(changeset) do
530 bio = get_change(changeset, :bio)
531 name = get_change(changeset, :name)
534 emoji = Map.merge(Emoji.Formatter.get_emoji_map(bio), Emoji.Formatter.get_emoji_map(name))
535 put_change(changeset, :emoji, emoji)
541 defp put_change_if_present(changeset, map_field, value_function) do
542 if value = get_change(changeset, map_field) do
543 with {:ok, new_value} <- value_function.(value) do
544 put_change(changeset, map_field, new_value)
553 defp put_upload(value, type) do
554 with %Plug.Upload{} <- value,
555 {:ok, object} <- ActivityPub.upload(value, type: type) do
560 def update_as_admin_changeset(struct, params) do
562 |> update_changeset(params)
563 |> cast(params, [:email])
564 |> delete_change(:also_known_as)
565 |> unique_constraint(:email)
566 |> validate_format(:email, @email_regex)
567 |> validate_inclusion(:actor_type, ["Person", "Service"])
570 @spec update_as_admin(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
571 def update_as_admin(user, params) do
572 params = Map.put(params, "password_confirmation", params["password"])
573 changeset = update_as_admin_changeset(user, params)
575 if params["password"] do
576 reset_password(user, changeset, params)
578 User.update_and_set_cache(changeset)
582 def password_update_changeset(struct, params) do
584 |> cast(params, [:password, :password_confirmation])
585 |> validate_required([:password, :password_confirmation])
586 |> validate_confirmation(:password)
587 |> put_password_hash()
588 |> put_change(:password_reset_pending, false)
591 @spec reset_password(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
592 def reset_password(%User{} = user, params) do
593 reset_password(user, user, params)
596 def reset_password(%User{id: user_id} = user, struct, params) do
599 |> Multi.update(:user, password_update_changeset(struct, params))
600 |> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
601 |> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))
603 case Repo.transaction(multi) do
604 {:ok, %{user: user} = _} -> set_cache(user)
605 {:error, _, changeset, _} -> {:error, changeset}
609 def update_password_reset_pending(user, value) do
612 |> put_change(:password_reset_pending, value)
613 |> update_and_set_cache()
616 def force_password_reset_async(user) do
617 BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
620 @spec force_password_reset(User.t()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
621 def force_password_reset(user), do: update_password_reset_pending(user, true)
623 def register_changeset(struct, params \\ %{}, opts \\ []) do
624 bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
625 name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
628 if is_nil(opts[:need_confirmation]) do
629 Pleroma.Config.get([:instance, :account_activation_required])
631 opts[:need_confirmation]
635 |> confirmation_changeset(need_confirmation: need_confirmation?)
643 :password_confirmation,
646 |> validate_required([:name, :nickname, :password, :password_confirmation])
647 |> validate_confirmation(:password)
648 |> unique_constraint(:email)
649 |> unique_constraint(:nickname)
650 |> validate_exclusion(:nickname, Pleroma.Config.get([User, :restricted_nicknames]))
651 |> validate_format(:nickname, local_nickname_regex())
652 |> validate_format(:email, @email_regex)
653 |> validate_length(:bio, max: bio_limit)
654 |> validate_length(:name, min: 1, max: name_limit)
655 |> maybe_validate_required_email(opts[:external])
658 |> unique_constraint(:ap_id)
659 |> put_following_and_follower_address()
662 def maybe_validate_required_email(changeset, true), do: changeset
664 def maybe_validate_required_email(changeset, _) do
665 if Pleroma.Config.get([:instance, :account_activation_required]) do
666 validate_required(changeset, [:email])
672 defp put_ap_id(changeset) do
673 ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
674 put_change(changeset, :ap_id, ap_id)
677 defp put_following_and_follower_address(changeset) do
678 followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
681 |> put_change(:follower_address, followers)
684 defp autofollow_users(user) do
685 candidates = Pleroma.Config.get([:instance, :autofollowed_nicknames])
688 User.Query.build(%{nickname: candidates, local: true, deactivated: false})
691 follow_all(user, autofollowed_users)
694 @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
695 def register(%Ecto.Changeset{} = changeset) do
696 with {:ok, user} <- Repo.insert(changeset) do
697 post_register_action(user)
701 def post_register_action(%User{} = user) do
702 with {:ok, user} <- autofollow_users(user),
703 {:ok, user} <- set_cache(user),
704 {:ok, _} <- User.WelcomeMessage.post_welcome_message_to_user(user),
705 {:ok, _} <- try_send_confirmation_email(user) do
710 def try_send_confirmation_email(%User{} = user) do
711 if user.confirmation_pending &&
712 Pleroma.Config.get([:instance, :account_activation_required]) do
714 |> Pleroma.Emails.UserEmail.account_confirmation_email()
715 |> Pleroma.Emails.Mailer.deliver_async()
723 def try_send_confirmation_email(users) do
724 Enum.each(users, &try_send_confirmation_email/1)
727 def needs_update?(%User{local: true}), do: false
729 def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
731 def needs_update?(%User{local: false} = user) do
732 NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
735 def needs_update?(_), do: true
737 @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
739 # "Locked" (self-locked) users demand explicit authorization of follow requests
740 def maybe_direct_follow(%User{} = follower, %User{local: true, locked: true} = followed) do
741 follow(follower, followed, :follow_pending)
744 def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
745 follow(follower, followed)
748 def maybe_direct_follow(%User{} = follower, %User{} = followed) do
749 if not ap_enabled?(followed) do
750 follow(follower, followed)
756 @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
757 @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
758 def follow_all(follower, followeds) do
760 |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
761 |> Enum.each(&follow(follower, &1, :follow_accept))
766 defdelegate following(user), to: FollowingRelationship
768 def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
769 deny_follow_blocked = Pleroma.Config.get([:user, :deny_follow_blocked])
772 followed.deactivated ->
773 {:error, "Could not follow user: #{followed.nickname} is deactivated."}
775 deny_follow_blocked and blocks?(followed, follower) ->
776 {:error, "Could not follow user: #{followed.nickname} blocked you."}
779 FollowingRelationship.follow(follower, followed, state)
781 {:ok, _} = update_follower_count(followed)
784 |> update_following_count()
788 def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
789 {:error, "Not subscribed!"}
792 @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
793 def unfollow(%User{} = follower, %User{} = followed) do
794 case do_unfollow(follower, followed) do
795 {:ok, follower, followed} ->
796 {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
803 @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
804 defp do_unfollow(%User{} = follower, %User{} = followed) do
805 case get_follow_state(follower, followed) do
806 state when state in [:follow_pending, :follow_accept] ->
807 FollowingRelationship.unfollow(follower, followed)
808 {:ok, followed} = update_follower_count(followed)
812 |> update_following_count()
814 {:ok, follower, followed}
817 {:error, "Not subscribed!"}
821 defdelegate following?(follower, followed), to: FollowingRelationship
823 @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
824 def get_follow_state(%User{} = follower, %User{} = following) do
825 following_relationship = FollowingRelationship.get(follower, following)
826 get_follow_state(follower, following, following_relationship)
829 def get_follow_state(
832 following_relationship
834 case {following_relationship, following.local} do
836 case Utils.fetch_latest_follow(follower, following) do
837 %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
838 FollowingRelationship.state_to_enum(state)
844 {%{state: state}, _} ->
852 def locked?(%User{} = user) do
857 Repo.get_by(User, id: id)
860 def get_by_ap_id(ap_id) do
861 Repo.get_by(User, ap_id: ap_id)
864 def get_all_by_ap_id(ap_ids) do
865 from(u in __MODULE__,
866 where: u.ap_id in ^ap_ids
871 def get_all_by_ids(ids) do
872 from(u in __MODULE__, where: u.id in ^ids)
876 # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
877 # of the ap_id and the domain and tries to get that user
878 def get_by_guessed_nickname(ap_id) do
879 domain = URI.parse(ap_id).host
880 name = List.last(String.split(ap_id, "/"))
881 nickname = "#{name}@#{domain}"
883 get_cached_by_nickname(nickname)
886 def set_cache({:ok, user}), do: set_cache(user)
887 def set_cache({:error, err}), do: {:error, err}
889 def set_cache(%User{} = user) do
890 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
891 Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
892 Cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
896 def update_and_set_cache(struct, params) do
898 |> update_changeset(params)
899 |> update_and_set_cache()
902 def update_and_set_cache(changeset) do
903 with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
908 def get_user_friends_ap_ids(user) do
909 from(u in User.get_friends_query(user), select: u.ap_id)
913 @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
914 def get_cached_user_friends_ap_ids(user) do
915 Cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
916 get_user_friends_ap_ids(user)
920 def invalidate_cache(user) do
921 Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
922 Cachex.del(:user_cache, "nickname:#{user.nickname}")
923 Cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
926 @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
927 def get_cached_by_ap_id(ap_id) do
928 key = "ap_id:#{ap_id}"
930 with {:ok, nil} <- Cachex.get(:user_cache, key),
931 user when not is_nil(user) <- get_by_ap_id(ap_id),
932 {:ok, true} <- Cachex.put(:user_cache, key, user) do
940 def get_cached_by_id(id) do
944 Cachex.fetch!(:user_cache, key, fn _ ->
948 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
949 {:commit, user.ap_id}
955 get_cached_by_ap_id(ap_id)
958 def get_cached_by_nickname(nickname) do
959 key = "nickname:#{nickname}"
961 Cachex.fetch!(:user_cache, key, fn ->
962 case get_or_fetch_by_nickname(nickname) do
963 {:ok, user} -> {:commit, user}
964 {:error, _error} -> {:ignore, nil}
969 def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
970 restrict_to_local = Pleroma.Config.get([:instance, :limit_to_local_content])
973 is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
974 get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
976 restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
977 get_cached_by_nickname(nickname_or_id)
979 restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
980 get_cached_by_nickname(nickname_or_id)
987 @spec get_by_nickname(String.t()) :: User.t() | nil
988 def get_by_nickname(nickname) do
989 Repo.get_by(User, nickname: nickname) ||
990 if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
991 Repo.get_by(User, nickname: local_nickname(nickname))
995 def get_by_email(email), do: Repo.get_by(User, email: email)
997 def get_by_nickname_or_email(nickname_or_email) do
998 get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
1001 def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
1003 def get_or_fetch_by_nickname(nickname) do
1004 with %User{} = user <- get_by_nickname(nickname) do
1008 with [_nick, _domain] <- String.split(nickname, "@"),
1009 {:ok, user} <- fetch_by_nickname(nickname) do
1012 _e -> {:error, "not found " <> nickname}
1017 @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1018 def get_followers_query(%User{} = user, nil) do
1019 User.Query.build(%{followers: user, deactivated: false})
1022 def get_followers_query(user, page) do
1024 |> get_followers_query(nil)
1025 |> User.Query.paginate(page, 20)
1028 @spec get_followers_query(User.t()) :: Ecto.Query.t()
1029 def get_followers_query(user), do: get_followers_query(user, nil)
1031 @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1032 def get_followers(user, page \\ nil) do
1034 |> get_followers_query(page)
1038 @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1039 def get_external_followers(user, page \\ nil) do
1041 |> get_followers_query(page)
1042 |> User.Query.build(%{external: true})
1046 def get_followers_ids(user, page \\ nil) do
1048 |> get_followers_query(page)
1049 |> select([u], u.id)
1053 @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1054 def get_friends_query(%User{} = user, nil) do
1055 User.Query.build(%{friends: user, deactivated: false})
1058 def get_friends_query(user, page) do
1060 |> get_friends_query(nil)
1061 |> User.Query.paginate(page, 20)
1064 @spec get_friends_query(User.t()) :: Ecto.Query.t()
1065 def get_friends_query(user), do: get_friends_query(user, nil)
1067 def get_friends(user, page \\ nil) do
1069 |> get_friends_query(page)
1073 def get_friends_ap_ids(user) do
1075 |> get_friends_query(nil)
1076 |> select([u], u.ap_id)
1080 def get_friends_ids(user, page \\ nil) do
1082 |> get_friends_query(page)
1083 |> select([u], u.id)
1087 defdelegate get_follow_requests(user), to: FollowingRelationship
1089 def increase_note_count(%User{} = user) do
1091 |> where(id: ^user.id)
1092 |> update([u], inc: [note_count: 1])
1094 |> Repo.update_all([])
1096 {1, [user]} -> set_cache(user)
1101 def decrease_note_count(%User{} = user) do
1103 |> where(id: ^user.id)
1106 note_count: fragment("greatest(0, note_count - 1)")
1110 |> Repo.update_all([])
1112 {1, [user]} -> set_cache(user)
1117 def update_note_count(%User{} = user, note_count \\ nil) do
1122 where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1128 |> cast(%{note_count: note_count}, [:note_count])
1129 |> update_and_set_cache()
1132 @spec maybe_fetch_follow_information(User.t()) :: User.t()
1133 def maybe_fetch_follow_information(user) do
1134 with {:ok, user} <- fetch_follow_information(user) do
1138 Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1144 def fetch_follow_information(user) do
1145 with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1147 |> follow_information_changeset(info)
1148 |> update_and_set_cache()
1152 defp follow_information_changeset(user, params) do
1159 :hide_followers_count,
1164 @spec update_follower_count(User.t()) :: {:ok, User.t()}
1165 def update_follower_count(%User{} = user) do
1166 if user.local or !Pleroma.Config.get([:instance, :external_user_synchronization]) do
1167 follower_count = FollowingRelationship.follower_count(user)
1170 |> follow_information_changeset(%{follower_count: follower_count})
1171 |> update_and_set_cache
1173 {:ok, maybe_fetch_follow_information(user)}
1177 @spec update_following_count(User.t()) :: {:ok, User.t()}
1178 def update_following_count(%User{local: false} = user) do
1179 if Pleroma.Config.get([:instance, :external_user_synchronization]) do
1180 {:ok, maybe_fetch_follow_information(user)}
1186 def update_following_count(%User{local: true} = user) do
1187 following_count = FollowingRelationship.following_count(user)
1190 |> follow_information_changeset(%{following_count: following_count})
1191 |> update_and_set_cache()
1194 def set_unread_conversation_count(%User{local: true} = user) do
1195 unread_query = Participation.unread_conversation_count_for_user(user)
1198 |> join(:inner, [u], p in subquery(unread_query))
1200 set: [unread_conversation_count: p.count]
1202 |> where([u], u.id == ^user.id)
1204 |> Repo.update_all([])
1206 {1, [user]} -> set_cache(user)
1211 def set_unread_conversation_count(user), do: {:ok, user}
1213 def increment_unread_conversation_count(conversation, %User{local: true} = user) do
1215 Participation.unread_conversation_count_for_user(user)
1216 |> where([p], p.conversation_id == ^conversation.id)
1219 |> join(:inner, [u], p in subquery(unread_query))
1221 inc: [unread_conversation_count: 1]
1223 |> where([u], u.id == ^user.id)
1224 |> where([u, p], p.count == 0)
1226 |> Repo.update_all([])
1228 {1, [user]} -> set_cache(user)
1233 def increment_unread_conversation_count(_, user), do: {:ok, user}
1235 @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1236 def get_users_from_set(ap_ids, opts \\ []) do
1237 local_only = Keyword.get(opts, :local_only, true)
1238 criteria = %{ap_id: ap_ids, deactivated: false}
1239 criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1241 User.Query.build(criteria)
1245 @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1246 def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1249 query = User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
1255 @spec mute(User.t(), User.t(), boolean()) ::
1256 {:ok, list(UserRelationship.t())} | {:error, String.t()}
1257 def mute(%User{} = muter, %User{} = mutee, notifications? \\ true) do
1258 add_to_mutes(muter, mutee, notifications?)
1261 def unmute(%User{} = muter, %User{} = mutee) do
1262 remove_from_mutes(muter, mutee)
1265 def subscribe(%User{} = subscriber, %User{} = target) do
1266 deny_follow_blocked = Pleroma.Config.get([:user, :deny_follow_blocked])
1268 if blocks?(target, subscriber) and deny_follow_blocked do
1269 {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1271 # Note: the relationship is inverse: subscriber acts as relationship target
1272 UserRelationship.create_inverse_subscription(target, subscriber)
1276 def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1277 with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1278 subscribe(subscriber, subscribee)
1282 def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1283 # Note: the relationship is inverse: subscriber acts as relationship target
1284 UserRelationship.delete_inverse_subscription(target, unsubscriber)
1287 def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1288 with %User{} = user <- get_cached_by_ap_id(ap_id) do
1289 unsubscribe(unsubscriber, user)
1293 def block(%User{} = blocker, %User{} = blocked) do
1294 # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1296 if following?(blocker, blocked) do
1297 {:ok, blocker, _} = unfollow(blocker, blocked)
1303 # clear any requested follows as well
1305 case CommonAPI.reject_follow_request(blocked, blocker) do
1306 {:ok, %User{} = updated_blocked} -> updated_blocked
1310 unsubscribe(blocked, blocker)
1312 unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
1313 if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)
1315 {:ok, blocker} = update_follower_count(blocker)
1316 {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1317 add_to_block(blocker, blocked)
1320 # helper to handle the block given only an actor's AP id
1321 def block(%User{} = blocker, %{ap_id: ap_id}) do
1322 block(blocker, get_cached_by_ap_id(ap_id))
1325 def unblock(%User{} = blocker, %User{} = blocked) do
1326 remove_from_block(blocker, blocked)
1329 # helper to handle the block given only an actor's AP id
1330 def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1331 unblock(blocker, get_cached_by_ap_id(ap_id))
1334 def mutes?(nil, _), do: false
1335 def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1337 def mutes_user?(%User{} = user, %User{} = target) do
1338 UserRelationship.mute_exists?(user, target)
1341 @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1342 def muted_notifications?(nil, _), do: false
1344 def muted_notifications?(%User{} = user, %User{} = target),
1345 do: UserRelationship.notification_mute_exists?(user, target)
1347 def blocks?(nil, _), do: false
1349 def blocks?(%User{} = user, %User{} = target) do
1350 blocks_user?(user, target) ||
1351 (blocks_domain?(user, target) and not User.following?(user, target))
1354 def blocks_user?(%User{} = user, %User{} = target) do
1355 UserRelationship.block_exists?(user, target)
1358 def blocks_user?(_, _), do: false
1360 def blocks_domain?(%User{} = user, %User{} = target) do
1361 domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1362 %{host: host} = URI.parse(target.ap_id)
1363 Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1366 def blocks_domain?(_, _), do: false
1368 def subscribed_to?(%User{} = user, %User{} = target) do
1369 # Note: the relationship is inverse: subscriber acts as relationship target
1370 UserRelationship.inverse_subscription_exists?(target, user)
1373 def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1374 with %User{} = target <- get_cached_by_ap_id(ap_id) do
1375 subscribed_to?(user, target)
1380 Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1381 E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1383 @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1384 def outgoing_relationships_ap_ids(_user, []), do: %{}
1386 def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1388 def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1389 when is_list(relationship_types) do
1392 |> assoc(:outgoing_relationships)
1393 |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1394 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1395 |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1396 |> group_by([user_rel, u], user_rel.relationship_type)
1398 |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1403 fn rel_type -> {rel_type, db_result[rel_type] || []} end
1407 def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1409 def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1411 def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1413 def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1414 when is_list(relationship_types) do
1416 |> assoc(:incoming_relationships)
1417 |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1418 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1419 |> maybe_filter_on_ap_id(ap_ids)
1420 |> select([user_rel, u], u.ap_id)
1425 defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1426 where(query, [user_rel, u], u.ap_id in ^ap_ids)
1429 defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1431 def deactivate_async(user, status \\ true) do
1432 BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
1435 def deactivate(user, status \\ true)
1437 def deactivate(users, status) when is_list(users) do
1438 Repo.transaction(fn ->
1439 for user <- users, do: deactivate(user, status)
1443 def deactivate(%User{} = user, status) do
1444 with {:ok, user} <- set_activation_status(user, status) do
1447 |> Enum.filter(& &1.local)
1448 |> Enum.each(&set_cache(update_following_count(&1)))
1450 # Only update local user counts, remote will be update during the next pull.
1453 |> Enum.filter(& &1.local)
1454 |> Enum.each(&do_unfollow(user, &1))
1460 def update_notification_settings(%User{} = user, settings) do
1462 |> cast(%{notification_settings: settings}, [])
1463 |> cast_embed(:notification_settings)
1464 |> validate_required([:notification_settings])
1465 |> update_and_set_cache()
1468 def delete(users) when is_list(users) do
1469 for user <- users, do: delete(user)
1472 def delete(%User{} = user) do
1473 BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1476 defp delete_and_invalidate_cache(%User{} = user) do
1477 invalidate_cache(user)
1481 defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)
1483 defp delete_or_deactivate(%User{local: true} = user) do
1484 status = account_status(user)
1486 if status == :confirmation_pending do
1487 delete_and_invalidate_cache(user)
1490 |> change(%{deactivated: true, email: nil})
1491 |> update_and_set_cache()
1495 def perform(:force_password_reset, user), do: force_password_reset(user)
1497 @spec perform(atom(), User.t()) :: {:ok, User.t()}
1498 def perform(:delete, %User{} = user) do
1499 # Remove all relationships
1502 |> Enum.each(fn follower ->
1503 ActivityPub.unfollow(follower, user)
1504 unfollow(follower, user)
1509 |> Enum.each(fn followed ->
1510 ActivityPub.unfollow(user, followed)
1511 unfollow(user, followed)
1514 delete_user_activities(user)
1515 delete_notifications_from_user_activities(user)
1517 delete_outgoing_pending_follow_requests(user)
1519 delete_or_deactivate(user)
1522 def perform(:deactivate_async, user, status), do: deactivate(user, status)
1524 @spec perform(atom(), User.t(), list()) :: list() | {:error, any()}
1525 def perform(:blocks_import, %User{} = blocker, blocked_identifiers)
1526 when is_list(blocked_identifiers) do
1528 blocked_identifiers,
1529 fn blocked_identifier ->
1530 with {:ok, %User{} = blocked} <- get_or_fetch(blocked_identifier),
1531 {:ok, _block} <- CommonAPI.block(blocker, blocked) do
1535 Logger.debug("blocks_import failed for #{blocked_identifier} with: #{inspect(err)}")
1542 def perform(:follow_import, %User{} = follower, followed_identifiers)
1543 when is_list(followed_identifiers) do
1545 followed_identifiers,
1546 fn followed_identifier ->
1547 with {:ok, %User{} = followed} <- get_or_fetch(followed_identifier),
1548 {:ok, follower} <- maybe_direct_follow(follower, followed),
1549 {:ok, _} <- ActivityPub.follow(follower, followed) do
1553 Logger.debug("follow_import failed for #{followed_identifier} with: #{inspect(err)}")
1560 @spec external_users_query() :: Ecto.Query.t()
1561 def external_users_query do
1569 @spec external_users(keyword()) :: [User.t()]
1570 def external_users(opts \\ []) do
1572 external_users_query()
1573 |> select([u], struct(u, [:id, :ap_id]))
1577 do: where(query, [u], u.id > ^opts[:max_id]),
1582 do: limit(query, ^opts[:limit]),
1588 def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers) do
1589 BackgroundWorker.enqueue("blocks_import", %{
1590 "blocker_id" => blocker.id,
1591 "blocked_identifiers" => blocked_identifiers
1595 def follow_import(%User{} = follower, followed_identifiers)
1596 when is_list(followed_identifiers) do
1597 BackgroundWorker.enqueue("follow_import", %{
1598 "follower_id" => follower.id,
1599 "followed_identifiers" => followed_identifiers
1603 def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1605 |> join(:inner, [n], activity in assoc(n, :activity))
1606 |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1607 |> Repo.delete_all()
1610 def delete_user_activities(%User{ap_id: ap_id} = user) do
1612 |> Activity.Queries.by_actor()
1613 |> RepoStreamer.chunk_stream(50)
1614 |> Stream.each(fn activities ->
1615 Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1620 defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1621 with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1622 {:ok, delete_data, _} <- Builder.delete(user, object) do
1623 Pipeline.common_pipeline(delete_data, local: user.local)
1625 {:find_object, nil} ->
1626 # We have the create activity, but not the object, it was probably pruned.
1627 # Insert a tombstone and try again
1628 with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1629 {:ok, _tombstone} <- Object.create(tombstone_data) do
1630 delete_activity(activity, user)
1634 Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1635 Logger.error("Error: #{inspect(e)}")
1639 defp delete_activity(%{data: %{"type" => type}} = activity, user)
1640 when type in ["Like", "Announce"] do
1641 {:ok, undo, _} = Builder.undo(user, activity)
1642 Pipeline.common_pipeline(undo, local: user.local)
1645 defp delete_activity(_activity, _user), do: "Doing nothing"
1647 defp delete_outgoing_pending_follow_requests(user) do
1649 |> FollowingRelationship.outgoing_pending_follow_requests_query()
1650 |> Repo.delete_all()
1653 def html_filter_policy(%User{no_rich_text: true}) do
1654 Pleroma.HTML.Scrubber.TwitterText
1657 def html_filter_policy(_), do: Pleroma.Config.get([:markup, :scrub_policy])
1659 def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1661 def get_or_fetch_by_ap_id(ap_id) do
1662 cached_user = get_cached_by_ap_id(ap_id)
1664 maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)
1666 case {cached_user, maybe_fetched_user} do
1667 {_, {:ok, %User{} = user}} ->
1670 {%User{} = user, _} ->
1674 {:error, :not_found}
1679 Creates an internal service actor by URI if missing.
1680 Optionally takes nickname for addressing.
1682 @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1683 def get_or_create_service_actor_by_ap_id(uri, nickname) do
1685 case get_cached_by_ap_id(uri) do
1687 with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1688 Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1692 %User{invisible: false} = user ->
1702 @spec set_invisible(User.t()) :: {:ok, User.t()}
1703 defp set_invisible(user) do
1705 |> change(%{invisible: true})
1706 |> update_and_set_cache()
1709 @spec create_service_actor(String.t(), String.t()) ::
1710 {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1711 defp create_service_actor(uri, nickname) do
1717 follower_address: uri <> "/followers"
1720 |> unique_constraint(:nickname)
1725 def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1728 |> :public_key.pem_decode()
1730 |> :public_key.pem_entry_decode()
1735 def public_key(_), do: {:error, "key not found"}
1737 def get_public_key_for_ap_id(ap_id) do
1738 with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1739 {:ok, public_key} <- public_key(user) do
1746 def ap_enabled?(%User{local: true}), do: true
1747 def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1748 def ap_enabled?(_), do: false
1750 @doc "Gets or fetch a user by uri or nickname."
1751 @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1752 def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1753 def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1755 # wait a period of time and return newest version of the User structs
1756 # this is because we have synchronous follow APIs and need to simulate them
1757 # with an async handshake
1758 def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1759 with %User{} = a <- get_cached_by_id(a.id),
1760 %User{} = b <- get_cached_by_id(b.id) do
1767 def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1768 with :ok <- :timer.sleep(timeout),
1769 %User{} = a <- get_cached_by_id(a.id),
1770 %User{} = b <- get_cached_by_id(b.id) do
1777 def parse_bio(bio) when is_binary(bio) and bio != "" do
1779 |> CommonUtils.format_input("text/plain", mentions_format: :full)
1783 def parse_bio(_), do: ""
1785 def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1786 # TODO: get profile URLs other than user.ap_id
1787 profile_urls = [user.ap_id]
1790 |> CommonUtils.format_input("text/plain",
1791 mentions_format: :full,
1792 rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1797 def parse_bio(_, _), do: ""
1799 def tag(user_identifiers, tags) when is_list(user_identifiers) do
1800 Repo.transaction(fn ->
1801 for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1805 def tag(nickname, tags) when is_binary(nickname),
1806 do: tag(get_by_nickname(nickname), tags)
1808 def tag(%User{} = user, tags),
1809 do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1811 def untag(user_identifiers, tags) when is_list(user_identifiers) do
1812 Repo.transaction(fn ->
1813 for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1817 def untag(nickname, tags) when is_binary(nickname),
1818 do: untag(get_by_nickname(nickname), tags)
1820 def untag(%User{} = user, tags),
1821 do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1823 defp update_tags(%User{} = user, new_tags) do
1824 {:ok, updated_user} =
1826 |> change(%{tags: new_tags})
1827 |> update_and_set_cache()
1832 defp normalize_tags(tags) do
1835 |> Enum.map(&String.downcase/1)
1838 defp local_nickname_regex do
1839 if Pleroma.Config.get([:instance, :extended_nickname_format]) do
1840 @extended_local_nickname_regex
1842 @strict_local_nickname_regex
1846 def local_nickname(nickname_or_mention) do
1849 |> String.split("@")
1853 def full_nickname(nickname_or_mention),
1854 do: String.trim_leading(nickname_or_mention, "@")
1856 def error_user(ap_id) do
1860 nickname: "erroruser@example.com",
1861 inserted_at: NaiveDateTime.utc_now()
1865 @spec all_superusers() :: [User.t()]
1866 def all_superusers do
1867 User.Query.build(%{super_users: true, local: true, deactivated: false})
1871 def muting_reblogs?(%User{} = user, %User{} = target) do
1872 UserRelationship.reblog_mute_exists?(user, target)
1875 def showing_reblogs?(%User{} = user, %User{} = target) do
1876 not muting_reblogs?(user, target)
1880 The function returns a query to get users with no activity for given interval of days.
1881 Inactive users are those who didn't read any notification, or had any activity where
1882 the user is the activity's actor, during `inactivity_threshold` days.
1883 Deactivated users will not appear in this list.
1887 iex> Pleroma.User.list_inactive_users()
1890 @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
1891 def list_inactive_users_query(inactivity_threshold \\ 7) do
1892 negative_inactivity_threshold = -inactivity_threshold
1893 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
1894 # Subqueries are not supported in `where` clauses, join gets too complicated.
1895 has_read_notifications =
1896 from(n in Pleroma.Notification,
1897 where: n.seen == true,
1899 having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
1902 |> Pleroma.Repo.all()
1904 from(u in Pleroma.User,
1905 left_join: a in Pleroma.Activity,
1906 on: u.ap_id == a.actor,
1907 where: not is_nil(u.nickname),
1908 where: u.deactivated != ^true,
1909 where: u.id not in ^has_read_notifications,
1912 max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
1913 is_nil(max(a.inserted_at))
1918 Enable or disable email notifications for user
1922 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
1923 Pleroma.User{email_notifications: %{"digest" => true}}
1925 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
1926 Pleroma.User{email_notifications: %{"digest" => false}}
1928 @spec switch_email_notifications(t(), String.t(), boolean()) ::
1929 {:ok, t()} | {:error, Ecto.Changeset.t()}
1930 def switch_email_notifications(user, type, status) do
1931 User.update_email_notifications(user, %{type => status})
1935 Set `last_digest_emailed_at` value for the user to current time
1937 @spec touch_last_digest_emailed_at(t()) :: t()
1938 def touch_last_digest_emailed_at(user) do
1939 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
1941 {:ok, updated_user} =
1943 |> change(%{last_digest_emailed_at: now})
1944 |> update_and_set_cache()
1949 @spec toggle_confirmation(User.t()) :: {:ok, User.t()} | {:error, Changeset.t()}
1950 def toggle_confirmation(%User{} = user) do
1952 |> confirmation_changeset(need_confirmation: !user.confirmation_pending)
1953 |> update_and_set_cache()
1956 @spec toggle_confirmation([User.t()]) :: [{:ok, User.t()} | {:error, Changeset.t()}]
1957 def toggle_confirmation(users) do
1958 Enum.map(users, &toggle_confirmation/1)
1961 def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
1965 def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
1966 # use instance-default
1967 config = Pleroma.Config.get([:assets, :mascots])
1968 default_mascot = Pleroma.Config.get([:assets, :default_mascot])
1969 mascot = Keyword.get(config, default_mascot)
1972 "id" => "default-mascot",
1973 "url" => mascot[:url],
1974 "preview_url" => mascot[:url],
1976 "mime_type" => mascot[:mime_type]
1981 def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
1983 def ensure_keys_present(%User{} = user) do
1984 with {:ok, pem} <- Keys.generate_rsa_pem() do
1986 |> cast(%{keys: pem}, [:keys])
1987 |> validate_required([:keys])
1988 |> update_and_set_cache()
1992 def get_ap_ids_by_nicknames(nicknames) do
1994 where: u.nickname in ^nicknames,
2000 defdelegate search(query, opts \\ []), to: User.Search
2002 defp put_password_hash(
2003 %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2005 change(changeset, password_hash: Pbkdf2.hash_pwd_salt(password))
2008 defp put_password_hash(changeset), do: changeset
2010 def is_internal_user?(%User{nickname: nil}), do: true
2011 def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2012 def is_internal_user?(_), do: false
2014 # A hack because user delete activities have a fake id for whatever reason
2015 # TODO: Get rid of this
2016 def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2018 def get_delivered_users_by_object_id(object_id) do
2020 inner_join: delivery in assoc(u, :deliveries),
2021 where: delivery.object_id == ^object_id
2026 def change_email(user, email) do
2028 |> cast(%{email: email}, [:email])
2029 |> validate_required([:email])
2030 |> unique_constraint(:email)
2031 |> validate_format(:email, @email_regex)
2032 |> update_and_set_cache()
2035 # Internal function; public one is `deactivate/2`
2036 defp set_activation_status(user, deactivated) do
2038 |> cast(%{deactivated: deactivated}, [:deactivated])
2039 |> update_and_set_cache()
2042 def update_banner(user, banner) do
2044 |> cast(%{banner: banner}, [:banner])
2045 |> update_and_set_cache()
2048 def update_background(user, background) do
2050 |> cast(%{background: background}, [:background])
2051 |> update_and_set_cache()
2054 def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
2057 moderator: is_moderator
2061 def validate_fields(changeset, remote? \\ false) do
2062 limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2063 limit = Pleroma.Config.get([:instance, limit_name], 0)
2066 |> validate_length(:fields, max: limit)
2067 |> validate_change(:fields, fn :fields, fields ->
2068 if Enum.all?(fields, &valid_field?/1) do
2076 defp valid_field?(%{"name" => name, "value" => value}) do
2077 name_limit = Pleroma.Config.get([:instance, :account_field_name_length], 255)
2078 value_limit = Pleroma.Config.get([:instance, :account_field_value_length], 255)
2080 is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2081 String.length(value) <= value_limit
2084 defp valid_field?(_), do: false
2086 defp truncate_field(%{"name" => name, "value" => value}) do
2088 String.split_at(name, Pleroma.Config.get([:instance, :account_field_name_length], 255))
2091 String.split_at(value, Pleroma.Config.get([:instance, :account_field_value_length], 255))
2093 %{"name" => name, "value" => value}
2096 def admin_api_update(user, params) do
2103 |> update_and_set_cache()
2106 @doc "Signs user out of all applications"
2107 def global_sign_out(user) do
2108 OAuth.Authorization.delete_user_authorizations(user)
2109 OAuth.Token.delete_user_tokens(user)
2112 def mascot_update(user, url) do
2114 |> cast(%{mascot: url}, [:mascot])
2115 |> validate_required([:mascot])
2116 |> update_and_set_cache()
2119 def mastodon_settings_update(user, settings) do
2121 |> cast(%{settings: settings}, [:settings])
2122 |> validate_required([:settings])
2123 |> update_and_set_cache()
2126 @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2127 def confirmation_changeset(user, need_confirmation: need_confirmation?) do
2129 if need_confirmation? do
2131 confirmation_pending: true,
2132 confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2136 confirmation_pending: false,
2137 confirmation_token: nil
2141 cast(user, params, [:confirmation_pending, :confirmation_token])
2144 def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2145 if id not in user.pinned_activities do
2146 max_pinned_statuses = Pleroma.Config.get([:instance, :max_pinned_statuses], 0)
2147 params = %{pinned_activities: user.pinned_activities ++ [id]}
2150 |> cast(params, [:pinned_activities])
2151 |> validate_length(:pinned_activities,
2152 max: max_pinned_statuses,
2153 message: "You have already pinned the maximum number of statuses"
2158 |> update_and_set_cache()
2161 def remove_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2162 params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2165 |> cast(params, [:pinned_activities])
2166 |> update_and_set_cache()
2169 def update_email_notifications(user, settings) do
2170 email_notifications =
2171 user.email_notifications
2172 |> Map.merge(settings)
2173 |> Map.take(["digest"])
2175 params = %{email_notifications: email_notifications}
2176 fields = [:email_notifications]
2179 |> cast(params, fields)
2180 |> validate_required(fields)
2181 |> update_and_set_cache()
2184 defp set_domain_blocks(user, domain_blocks) do
2185 params = %{domain_blocks: domain_blocks}
2188 |> cast(params, [:domain_blocks])
2189 |> validate_required([:domain_blocks])
2190 |> update_and_set_cache()
2193 def block_domain(user, domain_blocked) do
2194 set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2197 def unblock_domain(user, domain_blocked) do
2198 set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2201 @spec add_to_block(User.t(), User.t()) ::
2202 {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2203 defp add_to_block(%User{} = user, %User{} = blocked) do
2204 UserRelationship.create_block(user, blocked)
2207 @spec add_to_block(User.t(), User.t()) ::
2208 {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2209 defp remove_from_block(%User{} = user, %User{} = blocked) do
2210 UserRelationship.delete_block(user, blocked)
2213 defp add_to_mutes(%User{} = user, %User{} = muted_user, notifications?) do
2214 with {:ok, user_mute} <- UserRelationship.create_mute(user, muted_user),
2215 {:ok, user_notification_mute} <-
2216 (notifications? && UserRelationship.create_notification_mute(user, muted_user)) ||
2218 {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
2222 defp remove_from_mutes(user, %User{} = muted_user) do
2223 with {:ok, user_mute} <- UserRelationship.delete_mute(user, muted_user),
2224 {:ok, user_notification_mute} <-
2225 UserRelationship.delete_notification_mute(user, muted_user) do
2226 {:ok, [user_mute, user_notification_mute]}
2230 def set_invisible(user, invisible) do
2231 params = %{invisible: invisible}
2234 |> cast(params, [:invisible])
2235 |> validate_required([:invisible])
2236 |> update_and_set_cache()
2239 def sanitize_html(%User{} = user) do
2240 sanitize_html(user, nil)
2243 # User data that mastodon isn't filtering (treated as plaintext):
2246 def sanitize_html(%User{} = user, filter) do
2248 Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2251 "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2256 |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2257 |> Map.put(:fields, fields)