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]
14 alias Pleroma.Activity
16 alias Pleroma.Conversation.Participation
17 alias Pleroma.Delivery
18 alias Pleroma.FollowingRelationship
21 alias Pleroma.Notification
23 alias Pleroma.Registration
25 alias Pleroma.RepoStreamer
27 alias Pleroma.UserRelationship
29 alias Pleroma.Web.ActivityPub.ActivityPub
30 alias Pleroma.Web.ActivityPub.Utils
31 alias Pleroma.Web.CommonAPI
32 alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
33 alias Pleroma.Web.OAuth
34 alias Pleroma.Web.RelMe
35 alias Pleroma.Workers.BackgroundWorker
39 @type t :: %__MODULE__{}
40 @type account_status :: :active | :deactivated | :password_reset_pending | :confirmation_pending
41 @primary_key {:id, FlakeId.Ecto.CompatType, autogenerate: true}
43 # credo:disable-for-next-line Credo.Check.Readability.MaxLineLength
44 @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])?)*$/
46 @strict_local_nickname_regex ~r/^[a-zA-Z\d]+$/
47 @extended_local_nickname_regex ~r/^[a-zA-Z\d_-]+$/
49 # AP ID user relationships (blocks, mutes etc.)
50 # Format: [rel_type: [outgoing_rel: :outgoing_rel_target, incoming_rel: :incoming_rel_source]]
51 @user_relationships_config [
53 blocker_blocks: :blocked_users,
54 blockee_blocks: :blocker_users
57 muter_mutes: :muted_users,
58 mutee_mutes: :muter_users
61 reblog_muter_mutes: :reblog_muted_users,
62 reblog_mutee_mutes: :reblog_muter_users
65 notification_muter_mutes: :notification_muted_users,
66 notification_mutee_mutes: :notification_muter_users
68 # Note: `inverse_subscription` relationship is inverse: subscriber acts as relationship target
69 inverse_subscription: [
70 subscribee_subscriptions: :subscriber_users,
71 subscriber_subscriptions: :subscribee_users
77 field(:email, :string)
79 field(:nickname, :string)
80 field(:password_hash, :string)
81 field(:password, :string, virtual: true)
82 field(:password_confirmation, :string, virtual: true)
84 field(:ap_id, :string)
86 field(:local, :boolean, default: true)
87 field(:follower_address, :string)
88 field(:following_address, :string)
89 field(:search_rank, :float, virtual: true)
90 field(:search_type, :integer, virtual: true)
91 field(:tags, {:array, :string}, default: [])
92 field(:last_refreshed_at, :naive_datetime_usec)
93 field(:last_digest_emailed_at, :naive_datetime)
94 field(:banner, :map, default: %{})
95 field(:background, :map, default: %{})
96 field(:source_data, :map, default: %{})
97 field(:note_count, :integer, default: 0)
98 field(:follower_count, :integer, default: 0)
99 field(:following_count, :integer, default: 0)
100 field(:locked, :boolean, default: false)
101 field(:confirmation_pending, :boolean, default: false)
102 field(:password_reset_pending, :boolean, default: false)
103 field(:confirmation_token, :string, default: nil)
104 field(:default_scope, :string, default: "public")
105 field(:domain_blocks, {:array, :string}, default: [])
106 field(:deactivated, :boolean, default: false)
107 field(:no_rich_text, :boolean, default: false)
108 field(:ap_enabled, :boolean, default: false)
109 field(:is_moderator, :boolean, default: false)
110 field(:is_admin, :boolean, default: false)
111 field(:show_role, :boolean, default: true)
112 field(:settings, :map, default: nil)
113 field(:magic_key, :string, default: nil)
114 field(:uri, :string, default: nil)
115 field(:hide_followers_count, :boolean, default: false)
116 field(:hide_follows_count, :boolean, default: false)
117 field(:hide_followers, :boolean, default: false)
118 field(:hide_follows, :boolean, default: false)
119 field(:hide_favorites, :boolean, default: true)
120 field(:unread_conversation_count, :integer, default: 0)
121 field(:pinned_activities, {:array, :string}, default: [])
122 field(:email_notifications, :map, default: %{"digest" => false})
123 field(:mascot, :map, default: nil)
124 field(:emoji, {:array, :map}, default: [])
125 field(:pleroma_settings_store, :map, default: %{})
126 field(:fields, {:array, :map}, default: [])
127 field(:raw_fields, {:array, :map}, default: [])
128 field(:discoverable, :boolean, default: false)
129 field(:invisible, :boolean, default: false)
130 field(:allow_following_move, :boolean, default: true)
131 field(:skip_thread_containment, :boolean, default: false)
132 field(:actor_type, :string, default: "Person")
133 field(:also_known_as, {:array, :string}, default: [])
136 :notification_settings,
137 Pleroma.User.NotificationSetting,
141 has_many(:notifications, Notification)
142 has_many(:registrations, Registration)
143 has_many(:deliveries, Delivery)
145 has_many(:outgoing_relationships, UserRelationship, foreign_key: :source_id)
146 has_many(:incoming_relationships, UserRelationship, foreign_key: :target_id)
148 for {relationship_type,
150 {outgoing_relation, outgoing_relation_target},
151 {incoming_relation, incoming_relation_source}
152 ]} <- @user_relationships_config do
153 # Definitions of `has_many` relations: :blocker_blocks, :muter_mutes, :reblog_muter_mutes,
154 # :notification_muter_mutes, :subscribee_subscriptions
155 has_many(outgoing_relation, UserRelationship,
156 foreign_key: :source_id,
157 where: [relationship_type: relationship_type]
160 # Definitions of `has_many` relations: :blockee_blocks, :mutee_mutes, :reblog_mutee_mutes,
161 # :notification_mutee_mutes, :subscriber_subscriptions
162 has_many(incoming_relation, UserRelationship,
163 foreign_key: :target_id,
164 where: [relationship_type: relationship_type]
167 # Definitions of `has_many` relations: :blocked_users, :muted_users, :reblog_muted_users,
168 # :notification_muted_users, :subscriber_users
169 has_many(outgoing_relation_target, through: [outgoing_relation, :target])
171 # Definitions of `has_many` relations: :blocker_users, :muter_users, :reblog_muter_users,
172 # :notification_muter_users, :subscribee_users
173 has_many(incoming_relation_source, through: [incoming_relation, :source])
176 # `:blocks` is deprecated (replaced with `blocked_users` relation)
177 field(:blocks, {:array, :string}, default: [])
178 # `:mutes` is deprecated (replaced with `muted_users` relation)
179 field(:mutes, {:array, :string}, default: [])
180 # `:muted_reblogs` is deprecated (replaced with `reblog_muted_users` relation)
181 field(:muted_reblogs, {:array, :string}, default: [])
182 # `:muted_notifications` is deprecated (replaced with `notification_muted_users` relation)
183 field(:muted_notifications, {:array, :string}, default: [])
184 # `:subscribers` is deprecated (replaced with `subscriber_users` relation)
185 field(:subscribers, {:array, :string}, default: [])
190 for {_relationship_type, [{_outgoing_relation, outgoing_relation_target}, _]} <-
191 @user_relationships_config do
192 # `def blocked_users_relation/2`, `def muted_users_relation/2`,
193 # `def reblog_muted_users_relation/2`, `def notification_muted_users/2`,
194 # `def subscriber_users/2`
195 def unquote(:"#{outgoing_relation_target}_relation")(user, restrict_deactivated? \\ false) do
196 target_users_query = assoc(user, unquote(outgoing_relation_target))
198 if restrict_deactivated? do
199 restrict_deactivated(target_users_query)
205 # `def blocked_users/2`, `def muted_users/2`, `def reblog_muted_users/2`,
206 # `def notification_muted_users/2`, `def subscriber_users/2`
207 def unquote(outgoing_relation_target)(user, restrict_deactivated? \\ false) do
209 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
211 restrict_deactivated?
216 # `def blocked_users_ap_ids/2`, `def muted_users_ap_ids/2`, `def reblog_muted_users_ap_ids/2`,
217 # `def notification_muted_users_ap_ids/2`, `def subscriber_users_ap_ids/2`
218 def unquote(:"#{outgoing_relation_target}_ap_ids")(user, restrict_deactivated? \\ false) do
220 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
222 restrict_deactivated?
224 |> select([u], u.ap_id)
229 @doc "Returns status account"
230 @spec account_status(User.t()) :: account_status()
231 def account_status(%User{deactivated: true}), do: :deactivated
232 def account_status(%User{password_reset_pending: true}), do: :password_reset_pending
234 def account_status(%User{confirmation_pending: true}) do
235 case Config.get([:instance, :account_activation_required]) do
236 true -> :confirmation_pending
241 def account_status(%User{}), do: :active
243 @spec visible_for?(User.t(), User.t() | nil) :: boolean()
244 def visible_for?(user, for_user \\ nil)
246 def visible_for?(%User{invisible: true}, _), do: false
248 def visible_for?(%User{id: user_id}, %User{id: for_id}) when user_id == for_id, do: true
250 def visible_for?(%User{} = user, for_user) do
251 account_status(user) == :active || superuser?(for_user)
254 def visible_for?(_, _), do: false
256 @spec superuser?(User.t()) :: boolean()
257 def superuser?(%User{local: true, is_admin: true}), do: true
258 def superuser?(%User{local: true, is_moderator: true}), do: true
259 def superuser?(_), do: false
261 @spec invisible?(User.t()) :: boolean()
262 def invisible?(%User{invisible: true}), do: true
263 def invisible?(_), do: false
265 def avatar_url(user, options \\ []) do
267 %{"url" => [%{"href" => href} | _]} -> href
268 _ -> !options[:no_default] && "#{Web.base_url()}/images/avi.png"
272 def banner_url(user, options \\ []) do
274 %{"url" => [%{"href" => href} | _]} -> href
275 _ -> !options[:no_default] && "#{Web.base_url()}/images/banner.png"
279 def profile_url(%User{source_data: %{"url" => url}}), do: url
280 def profile_url(%User{ap_id: ap_id}), do: ap_id
281 def profile_url(_), do: nil
283 def ap_id(%User{nickname: nickname}), do: "#{Web.base_url()}/users/#{nickname}"
285 def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
286 def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"
288 @spec ap_following(User.t()) :: Sring.t()
289 def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
290 def ap_following(%User{} = user), do: "#{ap_id(user)}/following"
292 def follow_state(%User{} = user, %User{} = target) do
293 case Utils.fetch_latest_follow(user, target) do
294 %{data: %{"state" => state}} -> state
295 # Ideally this would be nil, but then Cachex does not commit the value
300 def get_cached_follow_state(user, target) do
301 key = "follow_state:#{user.ap_id}|#{target.ap_id}"
302 Cachex.fetch!(:user_cache, key, fn _ -> {:commit, follow_state(user, target)} end)
305 @spec set_follow_state_cache(String.t(), String.t(), String.t()) :: {:ok | :error, boolean()}
306 def set_follow_state_cache(user_ap_id, target_ap_id, state) do
307 Cachex.put(:user_cache, "follow_state:#{user_ap_id}|#{target_ap_id}", state)
310 @spec restrict_deactivated(Ecto.Query.t()) :: Ecto.Query.t()
311 def restrict_deactivated(query) do
312 from(u in query, where: u.deactivated != ^true)
315 defdelegate following_count(user), to: FollowingRelationship
317 defp truncate_fields_param(params) do
318 if Map.has_key?(params, :fields) do
319 Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
325 defp truncate_if_exists(params, key, max_length) do
326 if Map.has_key?(params, key) and is_binary(params[key]) do
327 {value, _chopped} = String.split_at(params[key], max_length)
328 Map.put(params, key, value)
334 def remote_user_creation(params) do
335 bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
336 name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
340 |> truncate_if_exists(:name, name_limit)
341 |> truncate_if_exists(:bio, bio_limit)
342 |> truncate_fields_param()
362 :hide_followers_count,
373 |> validate_required([:name, :ap_id])
374 |> unique_constraint(:nickname)
375 |> validate_format(:nickname, @email_regex)
376 |> validate_length(:bio, max: bio_limit)
377 |> validate_length(:name, max: name_limit)
378 |> validate_fields(true)
380 case params[:source_data] do
381 %{"followers" => followers, "following" => following} ->
383 |> put_change(:follower_address, followers)
384 |> put_change(:following_address, following)
387 followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
388 put_change(changeset, :follower_address, followers)
392 def update_changeset(struct, params \\ %{}) do
393 bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
394 name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
409 :hide_followers_count,
412 :allow_following_move,
415 :skip_thread_containment,
418 :pleroma_settings_store,
424 |> unique_constraint(:nickname)
425 |> validate_format(:nickname, local_nickname_regex())
426 |> validate_length(:bio, max: bio_limit)
427 |> validate_length(:name, min: 1, max: name_limit)
429 |> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
430 |> put_change_if_present(:avatar, &put_upload(&1, :avatar))
431 |> put_change_if_present(:banner, &put_upload(&1, :banner))
432 |> put_change_if_present(:background, &put_upload(&1, :background))
433 |> put_change_if_present(
434 :pleroma_settings_store,
435 &{:ok, Map.merge(struct.pleroma_settings_store, &1)}
437 |> validate_fields(false)
440 defp put_fields(changeset) do
441 if raw_fields = get_change(changeset, :raw_fields) do
444 |> Enum.filter(fn %{"name" => n} -> n != "" end)
448 |> Enum.map(fn f -> Map.update!(f, "value", &AutoLinker.link(&1)) end)
451 |> put_change(:raw_fields, raw_fields)
452 |> put_change(:fields, fields)
458 defp put_change_if_present(changeset, map_field, value_function) do
459 if value = get_change(changeset, map_field) do
460 with {:ok, new_value} <- value_function.(value) do
461 put_change(changeset, map_field, new_value)
470 defp put_upload(value, type) do
471 with %Plug.Upload{} <- value,
472 {:ok, object} <- ActivityPub.upload(value, type: type) do
477 def upgrade_changeset(struct, params \\ %{}, remote? \\ false) do
478 bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
479 name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
481 params = Map.put(params, :last_refreshed_at, NaiveDateTime.utc_now())
483 params = if remote?, do: truncate_fields_param(params), else: params
505 :allow_following_move,
507 :hide_followers_count,
513 |> unique_constraint(:nickname)
514 |> validate_format(:nickname, local_nickname_regex())
515 |> validate_length(:bio, max: bio_limit)
516 |> validate_length(:name, max: name_limit)
517 |> validate_fields(remote?)
520 def update_as_admin_changeset(struct, params) do
522 |> update_changeset(params)
523 |> cast(params, [:email])
524 |> delete_change(:also_known_as)
525 |> unique_constraint(:email)
526 |> validate_format(:email, @email_regex)
529 @spec update_as_admin(%User{}, map) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
530 def update_as_admin(user, params) do
531 params = Map.put(params, "password_confirmation", params["password"])
532 changeset = update_as_admin_changeset(user, params)
534 if params["password"] do
535 reset_password(user, changeset, params)
537 User.update_and_set_cache(changeset)
541 def password_update_changeset(struct, params) do
543 |> cast(params, [:password, :password_confirmation])
544 |> validate_required([:password, :password_confirmation])
545 |> validate_confirmation(:password)
546 |> put_password_hash()
547 |> put_change(:password_reset_pending, false)
550 @spec reset_password(User.t(), map) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
551 def reset_password(%User{} = user, params) do
552 reset_password(user, user, params)
555 def reset_password(%User{id: user_id} = user, struct, params) do
558 |> Multi.update(:user, password_update_changeset(struct, params))
559 |> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
560 |> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))
562 case Repo.transaction(multi) do
563 {:ok, %{user: user} = _} -> set_cache(user)
564 {:error, _, changeset, _} -> {:error, changeset}
568 def update_password_reset_pending(user, value) do
571 |> put_change(:password_reset_pending, value)
572 |> update_and_set_cache()
575 def force_password_reset_async(user) do
576 BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
579 @spec force_password_reset(User.t()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
580 def force_password_reset(user), do: update_password_reset_pending(user, true)
582 def register_changeset(struct, params \\ %{}, opts \\ []) do
583 bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
584 name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
587 if is_nil(opts[:need_confirmation]) do
588 Pleroma.Config.get([:instance, :account_activation_required])
590 opts[:need_confirmation]
594 |> confirmation_changeset(need_confirmation: need_confirmation?)
595 |> cast(params, [:bio, :email, :name, :nickname, :password, :password_confirmation])
596 |> validate_required([:name, :nickname, :password, :password_confirmation])
597 |> validate_confirmation(:password)
598 |> unique_constraint(:email)
599 |> unique_constraint(:nickname)
600 |> validate_exclusion(:nickname, Pleroma.Config.get([User, :restricted_nicknames]))
601 |> validate_format(:nickname, local_nickname_regex())
602 |> validate_format(:email, @email_regex)
603 |> validate_length(:bio, max: bio_limit)
604 |> validate_length(:name, min: 1, max: name_limit)
605 |> maybe_validate_required_email(opts[:external])
608 |> unique_constraint(:ap_id)
609 |> put_following_and_follower_address()
612 def maybe_validate_required_email(changeset, true), do: changeset
614 def maybe_validate_required_email(changeset, _) do
615 if Pleroma.Config.get([:instance, :account_activation_required]) do
616 validate_required(changeset, [:email])
622 defp put_ap_id(changeset) do
623 ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
624 put_change(changeset, :ap_id, ap_id)
627 defp put_following_and_follower_address(changeset) do
628 followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
631 |> put_change(:follower_address, followers)
634 defp autofollow_users(user) do
635 candidates = Pleroma.Config.get([:instance, :autofollowed_nicknames])
638 User.Query.build(%{nickname: candidates, local: true, deactivated: false})
641 follow_all(user, autofollowed_users)
644 @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
645 def register(%Ecto.Changeset{} = changeset) do
646 with {:ok, user} <- Repo.insert(changeset) do
647 post_register_action(user)
651 def post_register_action(%User{} = user) do
652 with {:ok, user} <- autofollow_users(user),
653 {:ok, user} <- set_cache(user),
654 {:ok, _} <- User.WelcomeMessage.post_welcome_message_to_user(user),
655 {:ok, _} <- try_send_confirmation_email(user) do
660 def try_send_confirmation_email(%User{} = user) do
661 if user.confirmation_pending &&
662 Pleroma.Config.get([:instance, :account_activation_required]) do
664 |> Pleroma.Emails.UserEmail.account_confirmation_email()
665 |> Pleroma.Emails.Mailer.deliver_async()
673 def try_send_confirmation_email(users) do
674 Enum.each(users, &try_send_confirmation_email/1)
677 def needs_update?(%User{local: true}), do: false
679 def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
681 def needs_update?(%User{local: false} = user) do
682 NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
685 def needs_update?(_), do: true
687 @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
688 def maybe_direct_follow(%User{} = follower, %User{local: true, locked: true} = followed) do
689 follow(follower, followed, "pending")
692 def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
693 follow(follower, followed)
696 def maybe_direct_follow(%User{} = follower, %User{} = followed) do
697 if not ap_enabled?(followed) do
698 follow(follower, followed)
704 @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
705 @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
706 def follow_all(follower, followeds) do
708 |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
709 |> Enum.each(&follow(follower, &1, "accept"))
714 defdelegate following(user), to: FollowingRelationship
716 def follow(%User{} = follower, %User{} = followed, state \\ "accept") do
717 deny_follow_blocked = Pleroma.Config.get([:user, :deny_follow_blocked])
720 followed.deactivated ->
721 {:error, "Could not follow user: #{followed.nickname} is deactivated."}
723 deny_follow_blocked and blocks?(followed, follower) ->
724 {:error, "Could not follow user: #{followed.nickname} blocked you."}
727 FollowingRelationship.follow(follower, followed, state)
729 {:ok, _} = update_follower_count(followed)
732 |> update_following_count()
737 def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
738 {:error, "Not subscribed!"}
741 def unfollow(%User{} = follower, %User{} = followed) do
742 case get_follow_state(follower, followed) do
743 state when state in ["accept", "pending"] ->
744 FollowingRelationship.unfollow(follower, followed)
745 {:ok, followed} = update_follower_count(followed)
749 |> update_following_count()
752 {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
755 {:error, "Not subscribed!"}
759 defdelegate following?(follower, followed), to: FollowingRelationship
761 def get_follow_state(%User{} = follower, %User{} = following) do
762 following_relationship = FollowingRelationship.get(follower, following)
764 case {following_relationship, following.local} do
766 case Utils.fetch_latest_follow(follower, following) do
767 %{data: %{"state" => state}} when state in ["pending", "accept"] -> state
771 {%{state: state}, _} ->
779 def locked?(%User{} = user) do
784 Repo.get_by(User, id: id)
787 def get_by_ap_id(ap_id) do
788 Repo.get_by(User, ap_id: ap_id)
791 def get_all_by_ap_id(ap_ids) do
792 from(u in __MODULE__,
793 where: u.ap_id in ^ap_ids
798 def get_all_by_ids(ids) do
799 from(u in __MODULE__, where: u.id in ^ids)
803 # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
804 # of the ap_id and the domain and tries to get that user
805 def get_by_guessed_nickname(ap_id) do
806 domain = URI.parse(ap_id).host
807 name = List.last(String.split(ap_id, "/"))
808 nickname = "#{name}@#{domain}"
810 get_cached_by_nickname(nickname)
813 def set_cache({:ok, user}), do: set_cache(user)
814 def set_cache({:error, err}), do: {:error, err}
816 def set_cache(%User{} = user) do
817 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
818 Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
822 def update_and_set_cache(struct, params) do
824 |> update_changeset(params)
825 |> update_and_set_cache()
828 def update_and_set_cache(changeset) do
829 with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
834 def invalidate_cache(user) do
835 Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
836 Cachex.del(:user_cache, "nickname:#{user.nickname}")
839 @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
840 def get_cached_by_ap_id(ap_id) do
841 key = "ap_id:#{ap_id}"
843 with {:ok, nil} <- Cachex.get(:user_cache, key),
844 user when not is_nil(user) <- get_by_ap_id(ap_id),
845 {:ok, true} <- Cachex.put(:user_cache, key, user) do
853 def get_cached_by_id(id) do
857 Cachex.fetch!(:user_cache, key, fn _ ->
861 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
862 {:commit, user.ap_id}
868 get_cached_by_ap_id(ap_id)
871 def get_cached_by_nickname(nickname) do
872 key = "nickname:#{nickname}"
874 Cachex.fetch!(:user_cache, key, fn ->
875 case get_or_fetch_by_nickname(nickname) do
876 {:ok, user} -> {:commit, user}
877 {:error, _error} -> {:ignore, nil}
882 def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
883 restrict_to_local = Pleroma.Config.get([:instance, :limit_to_local_content])
886 is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
887 get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
889 restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
890 get_cached_by_nickname(nickname_or_id)
892 restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
893 get_cached_by_nickname(nickname_or_id)
900 def get_by_nickname(nickname) do
901 Repo.get_by(User, nickname: nickname) ||
902 if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
903 Repo.get_by(User, nickname: local_nickname(nickname))
907 def get_by_email(email), do: Repo.get_by(User, email: email)
909 def get_by_nickname_or_email(nickname_or_email) do
910 get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
913 def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
915 def get_or_fetch_by_nickname(nickname) do
916 with %User{} = user <- get_by_nickname(nickname) do
920 with [_nick, _domain] <- String.split(nickname, "@"),
921 {:ok, user} <- fetch_by_nickname(nickname) do
924 _e -> {:error, "not found " <> nickname}
929 @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
930 def get_followers_query(%User{} = user, nil) do
931 User.Query.build(%{followers: user, deactivated: false})
934 def get_followers_query(user, page) do
936 |> get_followers_query(nil)
937 |> User.Query.paginate(page, 20)
940 @spec get_followers_query(User.t()) :: Ecto.Query.t()
941 def get_followers_query(user), do: get_followers_query(user, nil)
943 @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
944 def get_followers(user, page \\ nil) do
946 |> get_followers_query(page)
950 @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
951 def get_external_followers(user, page \\ nil) do
953 |> get_followers_query(page)
954 |> User.Query.build(%{external: true})
958 def get_followers_ids(user, page \\ nil) do
960 |> get_followers_query(page)
965 @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
966 def get_friends_query(%User{} = user, nil) do
967 User.Query.build(%{friends: user, deactivated: false})
970 def get_friends_query(user, page) do
972 |> get_friends_query(nil)
973 |> User.Query.paginate(page, 20)
976 @spec get_friends_query(User.t()) :: Ecto.Query.t()
977 def get_friends_query(user), do: get_friends_query(user, nil)
979 def get_friends(user, page \\ nil) do
981 |> get_friends_query(page)
985 def get_friends_ap_ids(user) do
987 |> get_friends_query(nil)
988 |> select([u], u.ap_id)
992 def get_friends_ids(user, page \\ nil) do
994 |> get_friends_query(page)
999 defdelegate get_follow_requests(user), to: FollowingRelationship
1001 def increase_note_count(%User{} = user) do
1003 |> where(id: ^user.id)
1004 |> update([u], inc: [note_count: 1])
1006 |> Repo.update_all([])
1008 {1, [user]} -> set_cache(user)
1013 def decrease_note_count(%User{} = user) do
1015 |> where(id: ^user.id)
1018 note_count: fragment("greatest(0, note_count - 1)")
1022 |> Repo.update_all([])
1024 {1, [user]} -> set_cache(user)
1029 def update_note_count(%User{} = user, note_count \\ nil) do
1034 where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1040 |> cast(%{note_count: note_count}, [:note_count])
1041 |> update_and_set_cache()
1044 @spec maybe_fetch_follow_information(User.t()) :: User.t()
1045 def maybe_fetch_follow_information(user) do
1046 with {:ok, user} <- fetch_follow_information(user) do
1050 Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1056 def fetch_follow_information(user) do
1057 with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1059 |> follow_information_changeset(info)
1060 |> update_and_set_cache()
1064 defp follow_information_changeset(user, params) do
1071 :hide_followers_count,
1076 def update_follower_count(%User{} = user) do
1077 if user.local or !Pleroma.Config.get([:instance, :external_user_synchronization]) do
1078 follower_count_query =
1079 User.Query.build(%{followers: user, deactivated: false})
1080 |> select([u], %{count: count(u.id)})
1083 |> where(id: ^user.id)
1084 |> join(:inner, [u], s in subquery(follower_count_query))
1086 set: [follower_count: s.count]
1089 |> Repo.update_all([])
1091 {1, [user]} -> set_cache(user)
1095 {:ok, maybe_fetch_follow_information(user)}
1099 @spec update_following_count(User.t()) :: User.t()
1100 def update_following_count(%User{local: false} = user) do
1101 if Pleroma.Config.get([:instance, :external_user_synchronization]) do
1102 maybe_fetch_follow_information(user)
1108 def update_following_count(%User{local: true} = user) do
1109 following_count = FollowingRelationship.following_count(user)
1112 |> follow_information_changeset(%{following_count: following_count})
1116 def set_unread_conversation_count(%User{local: true} = user) do
1117 unread_query = Participation.unread_conversation_count_for_user(user)
1120 |> join(:inner, [u], p in subquery(unread_query))
1122 set: [unread_conversation_count: p.count]
1124 |> where([u], u.id == ^user.id)
1126 |> Repo.update_all([])
1128 {1, [user]} -> set_cache(user)
1133 def set_unread_conversation_count(user), do: {:ok, user}
1135 def increment_unread_conversation_count(conversation, %User{local: true} = user) do
1137 Participation.unread_conversation_count_for_user(user)
1138 |> where([p], p.conversation_id == ^conversation.id)
1141 |> join(:inner, [u], p in subquery(unread_query))
1143 inc: [unread_conversation_count: 1]
1145 |> where([u], u.id == ^user.id)
1146 |> where([u, p], p.count == 0)
1148 |> Repo.update_all([])
1150 {1, [user]} -> set_cache(user)
1155 def increment_unread_conversation_count(_, user), do: {:ok, user}
1157 @spec get_users_from_set([String.t()], boolean()) :: [User.t()]
1158 def get_users_from_set(ap_ids, local_only \\ true) do
1159 criteria = %{ap_id: ap_ids, deactivated: false}
1160 criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1162 User.Query.build(criteria)
1166 @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1167 def get_recipients_from_activity(%Activity{recipients: to}) do
1168 User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
1172 @spec mute(User.t(), User.t(), boolean()) ::
1173 {:ok, list(UserRelationship.t())} | {:error, String.t()}
1174 def mute(%User{} = muter, %User{} = mutee, notifications? \\ true) do
1175 add_to_mutes(muter, mutee, notifications?)
1178 def unmute(%User{} = muter, %User{} = mutee) do
1179 remove_from_mutes(muter, mutee)
1182 def subscribe(%User{} = subscriber, %User{} = target) do
1183 deny_follow_blocked = Pleroma.Config.get([:user, :deny_follow_blocked])
1185 if blocks?(target, subscriber) and deny_follow_blocked do
1186 {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1188 # Note: the relationship is inverse: subscriber acts as relationship target
1189 UserRelationship.create_inverse_subscription(target, subscriber)
1193 def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1194 with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1195 subscribe(subscriber, subscribee)
1199 def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1200 # Note: the relationship is inverse: subscriber acts as relationship target
1201 UserRelationship.delete_inverse_subscription(target, unsubscriber)
1204 def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1205 with %User{} = user <- get_cached_by_ap_id(ap_id) do
1206 unsubscribe(unsubscriber, user)
1210 def block(%User{} = blocker, %User{} = blocked) do
1211 # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1213 if following?(blocker, blocked) do
1214 {:ok, blocker, _} = unfollow(blocker, blocked)
1220 # clear any requested follows as well
1222 case CommonAPI.reject_follow_request(blocked, blocker) do
1223 {:ok, %User{} = updated_blocked} -> updated_blocked
1227 unsubscribe(blocked, blocker)
1229 if following?(blocked, blocker), do: unfollow(blocked, blocker)
1231 {:ok, blocker} = update_follower_count(blocker)
1232 {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1233 add_to_block(blocker, blocked)
1236 # helper to handle the block given only an actor's AP id
1237 def block(%User{} = blocker, %{ap_id: ap_id}) do
1238 block(blocker, get_cached_by_ap_id(ap_id))
1241 def unblock(%User{} = blocker, %User{} = blocked) do
1242 remove_from_block(blocker, blocked)
1245 # helper to handle the block given only an actor's AP id
1246 def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1247 unblock(blocker, get_cached_by_ap_id(ap_id))
1250 def mutes?(nil, _), do: false
1251 def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1253 def mutes_user?(%User{} = user, %User{} = target) do
1254 UserRelationship.mute_exists?(user, target)
1257 @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1258 def muted_notifications?(nil, _), do: false
1260 def muted_notifications?(%User{} = user, %User{} = target),
1261 do: UserRelationship.notification_mute_exists?(user, target)
1263 def blocks?(nil, _), do: false
1265 def blocks?(%User{} = user, %User{} = target) do
1266 blocks_user?(user, target) ||
1267 (!User.following?(user, target) && blocks_domain?(user, target))
1270 def blocks_user?(%User{} = user, %User{} = target) do
1271 UserRelationship.block_exists?(user, target)
1274 def blocks_user?(_, _), do: false
1276 def blocks_domain?(%User{} = user, %User{} = target) do
1277 domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1278 %{host: host} = URI.parse(target.ap_id)
1279 Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1282 def blocks_domain?(_, _), do: false
1284 def subscribed_to?(%User{} = user, %User{} = target) do
1285 # Note: the relationship is inverse: subscriber acts as relationship target
1286 UserRelationship.inverse_subscription_exists?(target, user)
1289 def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1290 with %User{} = target <- get_cached_by_ap_id(ap_id) do
1291 subscribed_to?(user, target)
1296 Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1297 E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1299 @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1300 def outgoing_relationships_ap_ids(_user, []), do: %{}
1302 def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1304 def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1305 when is_list(relationship_types) do
1308 |> assoc(:outgoing_relationships)
1309 |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1310 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1311 |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1312 |> group_by([user_rel, u], user_rel.relationship_type)
1314 |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1319 fn rel_type -> {rel_type, db_result[rel_type] || []} end
1323 def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1325 def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1327 def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1329 def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1330 when is_list(relationship_types) do
1332 |> assoc(:incoming_relationships)
1333 |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1334 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1335 |> maybe_filter_on_ap_id(ap_ids)
1336 |> select([user_rel, u], u.ap_id)
1341 defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1342 where(query, [user_rel, u], u.ap_id in ^ap_ids)
1345 defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1347 def deactivate_async(user, status \\ true) do
1348 BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
1351 def deactivate(user, status \\ true)
1353 def deactivate(users, status) when is_list(users) do
1354 Repo.transaction(fn ->
1355 for user <- users, do: deactivate(user, status)
1359 def deactivate(%User{} = user, status) do
1360 with {:ok, user} <- set_activation_status(user, status) do
1363 |> Enum.filter(& &1.local)
1364 |> Enum.each(fn follower ->
1365 follower |> update_following_count() |> set_cache()
1368 # Only update local user counts, remote will be update during the next pull.
1371 |> Enum.filter(& &1.local)
1372 |> Enum.each(&update_follower_count/1)
1378 def update_notification_settings(%User{} = user, settings) do
1380 |> cast(%{notification_settings: settings}, [])
1381 |> cast_embed(:notification_settings)
1382 |> validate_required([:notification_settings])
1383 |> update_and_set_cache()
1386 def delete(users) when is_list(users) do
1387 for user <- users, do: delete(user)
1390 def delete(%User{} = user) do
1391 BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1394 def perform(:force_password_reset, user), do: force_password_reset(user)
1396 @spec perform(atom(), User.t()) :: {:ok, User.t()}
1397 def perform(:delete, %User{} = user) do
1398 {:ok, _user} = ActivityPub.delete(user)
1400 # Remove all relationships
1403 |> Enum.each(fn follower ->
1404 ActivityPub.unfollow(follower, user)
1405 unfollow(follower, user)
1410 |> Enum.each(fn followed ->
1411 ActivityPub.unfollow(user, followed)
1412 unfollow(user, followed)
1415 delete_user_activities(user)
1416 invalidate_cache(user)
1420 def perform(:deactivate_async, user, status), do: deactivate(user, status)
1422 @spec perform(atom(), User.t(), list()) :: list() | {:error, any()}
1423 def perform(:blocks_import, %User{} = blocker, blocked_identifiers)
1424 when is_list(blocked_identifiers) do
1426 blocked_identifiers,
1427 fn blocked_identifier ->
1428 with {:ok, %User{} = blocked} <- get_or_fetch(blocked_identifier),
1429 {:ok, _user_block} <- block(blocker, blocked),
1430 {:ok, _} <- ActivityPub.block(blocker, blocked) do
1434 Logger.debug("blocks_import failed for #{blocked_identifier} with: #{inspect(err)}")
1441 def perform(:follow_import, %User{} = follower, followed_identifiers)
1442 when is_list(followed_identifiers) do
1444 followed_identifiers,
1445 fn followed_identifier ->
1446 with {:ok, %User{} = followed} <- get_or_fetch(followed_identifier),
1447 {:ok, follower} <- maybe_direct_follow(follower, followed),
1448 {:ok, _} <- ActivityPub.follow(follower, followed) do
1452 Logger.debug("follow_import failed for #{followed_identifier} with: #{inspect(err)}")
1459 @spec external_users_query() :: Ecto.Query.t()
1460 def external_users_query do
1468 @spec external_users(keyword()) :: [User.t()]
1469 def external_users(opts \\ []) do
1471 external_users_query()
1472 |> select([u], struct(u, [:id, :ap_id]))
1476 do: where(query, [u], u.id > ^opts[:max_id]),
1481 do: limit(query, ^opts[:limit]),
1487 def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers) do
1488 BackgroundWorker.enqueue("blocks_import", %{
1489 "blocker_id" => blocker.id,
1490 "blocked_identifiers" => blocked_identifiers
1494 def follow_import(%User{} = follower, followed_identifiers)
1495 when is_list(followed_identifiers) do
1496 BackgroundWorker.enqueue("follow_import", %{
1497 "follower_id" => follower.id,
1498 "followed_identifiers" => followed_identifiers
1502 def delete_user_activities(%User{ap_id: ap_id}) do
1504 |> Activity.Queries.by_actor()
1505 |> RepoStreamer.chunk_stream(50)
1506 |> Stream.each(fn activities -> Enum.each(activities, &delete_activity/1) end)
1510 defp delete_activity(%{data: %{"type" => "Create"}} = activity) do
1512 |> Object.normalize()
1513 |> ActivityPub.delete()
1516 defp delete_activity(%{data: %{"type" => "Like"}} = activity) do
1517 object = Object.normalize(activity)
1520 |> get_cached_by_ap_id()
1521 |> ActivityPub.unlike(object)
1524 defp delete_activity(%{data: %{"type" => "Announce"}} = activity) do
1525 object = Object.normalize(activity)
1528 |> get_cached_by_ap_id()
1529 |> ActivityPub.unannounce(object)
1532 defp delete_activity(_activity), do: "Doing nothing"
1534 def html_filter_policy(%User{no_rich_text: true}) do
1535 Pleroma.HTML.Scrubber.TwitterText
1538 def html_filter_policy(_), do: Pleroma.Config.get([:markup, :scrub_policy])
1540 def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1542 def get_or_fetch_by_ap_id(ap_id) do
1543 user = get_cached_by_ap_id(ap_id)
1545 if !is_nil(user) and !needs_update?(user) do
1548 fetch_by_ap_id(ap_id)
1553 Creates an internal service actor by URI if missing.
1554 Optionally takes nickname for addressing.
1556 @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1557 def get_or_create_service_actor_by_ap_id(uri, nickname) do
1559 case get_cached_by_ap_id(uri) do
1561 with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1562 Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1566 %User{invisible: false} = user ->
1576 @spec set_invisible(User.t()) :: {:ok, User.t()}
1577 defp set_invisible(user) do
1579 |> change(%{invisible: true})
1580 |> update_and_set_cache()
1583 @spec create_service_actor(String.t(), String.t()) ::
1584 {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1585 defp create_service_actor(uri, nickname) do
1591 follower_address: uri <> "/followers"
1594 |> unique_constraint(:nickname)
1600 def public_key(%{source_data: %{"publicKey" => %{"publicKeyPem" => public_key_pem}}}) do
1603 |> :public_key.pem_decode()
1605 |> :public_key.pem_entry_decode()
1610 def public_key(_), do: {:error, "not found key"}
1612 def get_public_key_for_ap_id(ap_id) do
1613 with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1614 {:ok, public_key} <- public_key(user) do
1621 defp blank?(""), do: nil
1622 defp blank?(n), do: n
1624 def insert_or_update_user(data) do
1626 |> Map.put(:name, blank?(data[:name]) || data[:nickname])
1627 |> remote_user_creation()
1628 |> Repo.insert(on_conflict: {:replace_all_except, [:id]}, conflict_target: :nickname)
1632 def ap_enabled?(%User{local: true}), do: true
1633 def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1634 def ap_enabled?(_), do: false
1636 @doc "Gets or fetch a user by uri or nickname."
1637 @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1638 def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1639 def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1641 # wait a period of time and return newest version of the User structs
1642 # this is because we have synchronous follow APIs and need to simulate them
1643 # with an async handshake
1644 def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1645 with %User{} = a <- get_cached_by_id(a.id),
1646 %User{} = b <- get_cached_by_id(b.id) do
1653 def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1654 with :ok <- :timer.sleep(timeout),
1655 %User{} = a <- get_cached_by_id(a.id),
1656 %User{} = b <- get_cached_by_id(b.id) do
1663 def parse_bio(bio) when is_binary(bio) and bio != "" do
1665 |> CommonUtils.format_input("text/plain", mentions_format: :full)
1669 def parse_bio(_), do: ""
1671 def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1672 # TODO: get profile URLs other than user.ap_id
1673 profile_urls = [user.ap_id]
1676 |> CommonUtils.format_input("text/plain",
1677 mentions_format: :full,
1678 rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1683 def parse_bio(_, _), do: ""
1685 def tag(user_identifiers, tags) when is_list(user_identifiers) do
1686 Repo.transaction(fn ->
1687 for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1691 def tag(nickname, tags) when is_binary(nickname),
1692 do: tag(get_by_nickname(nickname), tags)
1694 def tag(%User{} = user, tags),
1695 do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1697 def untag(user_identifiers, tags) when is_list(user_identifiers) do
1698 Repo.transaction(fn ->
1699 for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1703 def untag(nickname, tags) when is_binary(nickname),
1704 do: untag(get_by_nickname(nickname), tags)
1706 def untag(%User{} = user, tags),
1707 do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1709 defp update_tags(%User{} = user, new_tags) do
1710 {:ok, updated_user} =
1712 |> change(%{tags: new_tags})
1713 |> update_and_set_cache()
1718 defp normalize_tags(tags) do
1721 |> Enum.map(&String.downcase/1)
1724 defp local_nickname_regex do
1725 if Pleroma.Config.get([:instance, :extended_nickname_format]) do
1726 @extended_local_nickname_regex
1728 @strict_local_nickname_regex
1732 def local_nickname(nickname_or_mention) do
1735 |> String.split("@")
1739 def full_nickname(nickname_or_mention),
1740 do: String.trim_leading(nickname_or_mention, "@")
1742 def error_user(ap_id) do
1746 nickname: "erroruser@example.com",
1747 inserted_at: NaiveDateTime.utc_now()
1751 @spec all_superusers() :: [User.t()]
1752 def all_superusers do
1753 User.Query.build(%{super_users: true, local: true, deactivated: false})
1757 def showing_reblogs?(%User{} = user, %User{} = target) do
1758 not UserRelationship.reblog_mute_exists?(user, target)
1762 The function returns a query to get users with no activity for given interval of days.
1763 Inactive users are those who didn't read any notification, or had any activity where
1764 the user is the activity's actor, during `inactivity_threshold` days.
1765 Deactivated users will not appear in this list.
1769 iex> Pleroma.User.list_inactive_users()
1772 @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
1773 def list_inactive_users_query(inactivity_threshold \\ 7) do
1774 negative_inactivity_threshold = -inactivity_threshold
1775 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
1776 # Subqueries are not supported in `where` clauses, join gets too complicated.
1777 has_read_notifications =
1778 from(n in Pleroma.Notification,
1779 where: n.seen == true,
1781 having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
1784 |> Pleroma.Repo.all()
1786 from(u in Pleroma.User,
1787 left_join: a in Pleroma.Activity,
1788 on: u.ap_id == a.actor,
1789 where: not is_nil(u.nickname),
1790 where: u.deactivated != ^true,
1791 where: u.id not in ^has_read_notifications,
1794 max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
1795 is_nil(max(a.inserted_at))
1800 Enable or disable email notifications for user
1804 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
1805 Pleroma.User{email_notifications: %{"digest" => true}}
1807 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
1808 Pleroma.User{email_notifications: %{"digest" => false}}
1810 @spec switch_email_notifications(t(), String.t(), boolean()) ::
1811 {:ok, t()} | {:error, Ecto.Changeset.t()}
1812 def switch_email_notifications(user, type, status) do
1813 User.update_email_notifications(user, %{type => status})
1817 Set `last_digest_emailed_at` value for the user to current time
1819 @spec touch_last_digest_emailed_at(t()) :: t()
1820 def touch_last_digest_emailed_at(user) do
1821 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
1823 {:ok, updated_user} =
1825 |> change(%{last_digest_emailed_at: now})
1826 |> update_and_set_cache()
1831 @spec toggle_confirmation(User.t()) :: {:ok, User.t()} | {:error, Changeset.t()}
1832 def toggle_confirmation(%User{} = user) do
1834 |> confirmation_changeset(need_confirmation: !user.confirmation_pending)
1835 |> update_and_set_cache()
1838 @spec toggle_confirmation([User.t()]) :: [{:ok, User.t()} | {:error, Changeset.t()}]
1839 def toggle_confirmation(users) do
1840 Enum.map(users, &toggle_confirmation/1)
1843 def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
1847 def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
1848 # use instance-default
1849 config = Pleroma.Config.get([:assets, :mascots])
1850 default_mascot = Pleroma.Config.get([:assets, :default_mascot])
1851 mascot = Keyword.get(config, default_mascot)
1854 "id" => "default-mascot",
1855 "url" => mascot[:url],
1856 "preview_url" => mascot[:url],
1858 "mime_type" => mascot[:mime_type]
1863 def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
1865 def ensure_keys_present(%User{} = user) do
1866 with {:ok, pem} <- Keys.generate_rsa_pem() do
1868 |> cast(%{keys: pem}, [:keys])
1869 |> validate_required([:keys])
1870 |> update_and_set_cache()
1874 def get_ap_ids_by_nicknames(nicknames) do
1876 where: u.nickname in ^nicknames,
1882 defdelegate search(query, opts \\ []), to: User.Search
1884 defp put_password_hash(
1885 %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
1887 change(changeset, password_hash: Pbkdf2.hashpwsalt(password))
1890 defp put_password_hash(changeset), do: changeset
1892 def is_internal_user?(%User{nickname: nil}), do: true
1893 def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
1894 def is_internal_user?(_), do: false
1896 # A hack because user delete activities have a fake id for whatever reason
1897 # TODO: Get rid of this
1898 def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
1900 def get_delivered_users_by_object_id(object_id) do
1902 inner_join: delivery in assoc(u, :deliveries),
1903 where: delivery.object_id == ^object_id
1908 def change_email(user, email) do
1910 |> cast(%{email: email}, [:email])
1911 |> validate_required([:email])
1912 |> unique_constraint(:email)
1913 |> validate_format(:email, @email_regex)
1914 |> update_and_set_cache()
1917 # Internal function; public one is `deactivate/2`
1918 defp set_activation_status(user, deactivated) do
1920 |> cast(%{deactivated: deactivated}, [:deactivated])
1921 |> update_and_set_cache()
1924 def update_banner(user, banner) do
1926 |> cast(%{banner: banner}, [:banner])
1927 |> update_and_set_cache()
1930 def update_background(user, background) do
1932 |> cast(%{background: background}, [:background])
1933 |> update_and_set_cache()
1936 def update_source_data(user, source_data) do
1938 |> cast(%{source_data: source_data}, [:source_data])
1939 |> update_and_set_cache()
1942 def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
1945 moderator: is_moderator
1949 # ``fields`` is an array of mastodon profile field, containing ``{"name": "…", "value": "…"}``.
1950 # For example: [{"name": "Pronoun", "value": "she/her"}, …]
1951 def fields(%{fields: nil, source_data: %{"attachment" => attachment}}) do
1952 limit = Pleroma.Config.get([:instance, :max_remote_account_fields], 0)
1955 |> Enum.filter(fn %{"type" => t} -> t == "PropertyValue" end)
1956 |> Enum.map(fn fields -> Map.take(fields, ["name", "value"]) end)
1960 def fields(%{fields: nil}), do: []
1962 def fields(%{fields: fields}), do: fields
1964 def sanitized_fields(%User{} = user) do
1967 |> Enum.map(fn %{"name" => name, "value" => value} ->
1970 "value" => Pleroma.HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
1975 def validate_fields(changeset, remote? \\ false) do
1976 limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
1977 limit = Pleroma.Config.get([:instance, limit_name], 0)
1980 |> validate_length(:fields, max: limit)
1981 |> validate_change(:fields, fn :fields, fields ->
1982 if Enum.all?(fields, &valid_field?/1) do
1990 defp valid_field?(%{"name" => name, "value" => value}) do
1991 name_limit = Pleroma.Config.get([:instance, :account_field_name_length], 255)
1992 value_limit = Pleroma.Config.get([:instance, :account_field_value_length], 255)
1994 is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
1995 String.length(value) <= value_limit
1998 defp valid_field?(_), do: false
2000 defp truncate_field(%{"name" => name, "value" => value}) do
2002 String.split_at(name, Pleroma.Config.get([:instance, :account_field_name_length], 255))
2005 String.split_at(value, Pleroma.Config.get([:instance, :account_field_value_length], 255))
2007 %{"name" => name, "value" => value}
2010 def admin_api_update(user, params) do
2017 |> update_and_set_cache()
2020 @doc "Signs user out of all applications"
2021 def global_sign_out(user) do
2022 OAuth.Authorization.delete_user_authorizations(user)
2023 OAuth.Token.delete_user_tokens(user)
2026 def mascot_update(user, url) do
2028 |> cast(%{mascot: url}, [:mascot])
2029 |> validate_required([:mascot])
2030 |> update_and_set_cache()
2033 def mastodon_settings_update(user, settings) do
2035 |> cast(%{settings: settings}, [:settings])
2036 |> validate_required([:settings])
2037 |> update_and_set_cache()
2040 @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2041 def confirmation_changeset(user, need_confirmation: need_confirmation?) do
2043 if need_confirmation? do
2045 confirmation_pending: true,
2046 confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2050 confirmation_pending: false,
2051 confirmation_token: nil
2055 cast(user, params, [:confirmation_pending, :confirmation_token])
2058 def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2059 if id not in user.pinned_activities do
2060 max_pinned_statuses = Pleroma.Config.get([:instance, :max_pinned_statuses], 0)
2061 params = %{pinned_activities: user.pinned_activities ++ [id]}
2064 |> cast(params, [:pinned_activities])
2065 |> validate_length(:pinned_activities,
2066 max: max_pinned_statuses,
2067 message: "You have already pinned the maximum number of statuses"
2072 |> update_and_set_cache()
2075 def remove_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2076 params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2079 |> cast(params, [:pinned_activities])
2080 |> update_and_set_cache()
2083 def update_email_notifications(user, settings) do
2084 email_notifications =
2085 user.email_notifications
2086 |> Map.merge(settings)
2087 |> Map.take(["digest"])
2089 params = %{email_notifications: email_notifications}
2090 fields = [:email_notifications]
2093 |> cast(params, fields)
2094 |> validate_required(fields)
2095 |> update_and_set_cache()
2098 defp set_domain_blocks(user, domain_blocks) do
2099 params = %{domain_blocks: domain_blocks}
2102 |> cast(params, [:domain_blocks])
2103 |> validate_required([:domain_blocks])
2104 |> update_and_set_cache()
2107 def block_domain(user, domain_blocked) do
2108 set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2111 def unblock_domain(user, domain_blocked) do
2112 set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2115 @spec add_to_block(User.t(), User.t()) ::
2116 {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2117 defp add_to_block(%User{} = user, %User{} = blocked) do
2118 UserRelationship.create_block(user, blocked)
2121 @spec add_to_block(User.t(), User.t()) ::
2122 {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2123 defp remove_from_block(%User{} = user, %User{} = blocked) do
2124 UserRelationship.delete_block(user, blocked)
2127 defp add_to_mutes(%User{} = user, %User{} = muted_user, notifications?) do
2128 with {:ok, user_mute} <- UserRelationship.create_mute(user, muted_user),
2129 {:ok, user_notification_mute} <-
2130 (notifications? && UserRelationship.create_notification_mute(user, muted_user)) ||
2132 {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
2136 defp remove_from_mutes(user, %User{} = muted_user) do
2137 with {:ok, user_mute} <- UserRelationship.delete_mute(user, muted_user),
2138 {:ok, user_notification_mute} <-
2139 UserRelationship.delete_notification_mute(user, muted_user) do
2140 {:ok, [user_mute, user_notification_mute]}
2144 def set_invisible(user, invisible) do
2145 params = %{invisible: invisible}
2148 |> cast(params, [:invisible])
2149 |> validate_required([:invisible])
2150 |> update_and_set_cache()
2153 def sanitize_html(%User{} = user) do
2154 sanitize_html(user, nil)
2157 # User data that mastodon isn't filtering (treated as plaintext):
2160 def sanitize_html(%User{} = user, filter) do
2164 |> Enum.map(fn %{"name" => name, "value" => value} ->
2167 "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2172 |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2173 |> Map.put(:fields, fields)