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
19 alias Pleroma.Formatter
22 alias Pleroma.Notification
24 alias Pleroma.Registration
26 alias Pleroma.RepoStreamer
28 alias Pleroma.UserRelationship
30 alias Pleroma.Web.ActivityPub.ActivityPub
31 alias Pleroma.Web.ActivityPub.Utils
32 alias Pleroma.Web.CommonAPI
33 alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
34 alias Pleroma.Web.OAuth
35 alias Pleroma.Web.RelMe
36 alias Pleroma.Workers.BackgroundWorker
40 @type t :: %__MODULE__{}
41 @type account_status :: :active | :deactivated | :password_reset_pending | :confirmation_pending
42 @primary_key {:id, FlakeId.Ecto.CompatType, autogenerate: true}
44 # credo:disable-for-next-line Credo.Check.Readability.MaxLineLength
45 @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])?)*$/
47 @strict_local_nickname_regex ~r/^[a-zA-Z\d]+$/
48 @extended_local_nickname_regex ~r/^[a-zA-Z\d_-]+$/
50 # AP ID user relationships (blocks, mutes etc.)
51 # Format: [rel_type: [outgoing_rel: :outgoing_rel_target, incoming_rel: :incoming_rel_source]]
52 @user_relationships_config [
54 blocker_blocks: :blocked_users,
55 blockee_blocks: :blocker_users
58 muter_mutes: :muted_users,
59 mutee_mutes: :muter_users
62 reblog_muter_mutes: :reblog_muted_users,
63 reblog_mutee_mutes: :reblog_muter_users
66 notification_muter_mutes: :notification_muted_users,
67 notification_mutee_mutes: :notification_muter_users
69 # Note: `inverse_subscription` relationship is inverse: subscriber acts as relationship target
70 inverse_subscription: [
71 subscribee_subscriptions: :subscriber_users,
72 subscriber_subscriptions: :subscribee_users
78 field(:email, :string)
80 field(:nickname, :string)
81 field(:password_hash, :string)
82 field(:password, :string, virtual: true)
83 field(:password_confirmation, :string, virtual: true)
85 field(:ap_id, :string)
87 field(:local, :boolean, default: true)
88 field(:follower_address, :string)
89 field(:following_address, :string)
90 field(:search_rank, :float, virtual: true)
91 field(:search_type, :integer, virtual: true)
92 field(:tags, {:array, :string}, default: [])
93 field(:last_refreshed_at, :naive_datetime_usec)
94 field(:last_digest_emailed_at, :naive_datetime)
95 field(:banner, :map, default: %{})
96 field(:background, :map, default: %{})
97 field(:source_data, :map, default: %{})
98 field(:note_count, :integer, default: 0)
99 field(:follower_count, :integer, default: 0)
100 field(:following_count, :integer, default: 0)
101 field(:locked, :boolean, default: false)
102 field(:confirmation_pending, :boolean, default: false)
103 field(:password_reset_pending, :boolean, default: false)
104 field(:confirmation_token, :string, default: nil)
105 field(:default_scope, :string, default: "public")
106 field(:domain_blocks, {:array, :string}, default: [])
107 field(:deactivated, :boolean, default: false)
108 field(:no_rich_text, :boolean, default: false)
109 field(:ap_enabled, :boolean, default: false)
110 field(:is_moderator, :boolean, default: false)
111 field(:is_admin, :boolean, default: false)
112 field(:show_role, :boolean, default: true)
113 field(:settings, :map, default: nil)
114 field(:magic_key, :string, default: nil)
115 field(:uri, :string, default: nil)
116 field(:hide_followers_count, :boolean, default: false)
117 field(:hide_follows_count, :boolean, default: false)
118 field(:hide_followers, :boolean, default: false)
119 field(:hide_follows, :boolean, default: false)
120 field(:hide_favorites, :boolean, default: true)
121 field(:unread_conversation_count, :integer, default: 0)
122 field(:pinned_activities, {:array, :string}, default: [])
123 field(:email_notifications, :map, default: %{"digest" => false})
124 field(:mascot, :map, default: nil)
125 field(:emoji, {:array, :map}, default: [])
126 field(:pleroma_settings_store, :map, default: %{})
127 field(:fields, {:array, :map}, default: [])
128 field(:raw_fields, {:array, :map}, default: [])
129 field(:discoverable, :boolean, default: false)
130 field(:invisible, :boolean, default: false)
131 field(:allow_following_move, :boolean, default: true)
132 field(:skip_thread_containment, :boolean, default: false)
133 field(:actor_type, :string, default: "Person")
134 field(:also_known_as, {:array, :string}, default: [])
137 :notification_settings,
138 Pleroma.User.NotificationSetting,
142 has_many(:notifications, Notification)
143 has_many(:registrations, Registration)
144 has_many(:deliveries, Delivery)
146 has_many(:outgoing_relationships, UserRelationship, foreign_key: :source_id)
147 has_many(:incoming_relationships, UserRelationship, foreign_key: :target_id)
149 for {relationship_type,
151 {outgoing_relation, outgoing_relation_target},
152 {incoming_relation, incoming_relation_source}
153 ]} <- @user_relationships_config do
154 # Definitions of `has_many` relations: :blocker_blocks, :muter_mutes, :reblog_muter_mutes,
155 # :notification_muter_mutes, :subscribee_subscriptions
156 has_many(outgoing_relation, UserRelationship,
157 foreign_key: :source_id,
158 where: [relationship_type: relationship_type]
161 # Definitions of `has_many` relations: :blockee_blocks, :mutee_mutes, :reblog_mutee_mutes,
162 # :notification_mutee_mutes, :subscriber_subscriptions
163 has_many(incoming_relation, UserRelationship,
164 foreign_key: :target_id,
165 where: [relationship_type: relationship_type]
168 # Definitions of `has_many` relations: :blocked_users, :muted_users, :reblog_muted_users,
169 # :notification_muted_users, :subscriber_users
170 has_many(outgoing_relation_target, through: [outgoing_relation, :target])
172 # Definitions of `has_many` relations: :blocker_users, :muter_users, :reblog_muter_users,
173 # :notification_muter_users, :subscribee_users
174 has_many(incoming_relation_source, through: [incoming_relation, :source])
177 # `:blocks` is deprecated (replaced with `blocked_users` relation)
178 field(:blocks, {:array, :string}, default: [])
179 # `:mutes` is deprecated (replaced with `muted_users` relation)
180 field(:mutes, {:array, :string}, default: [])
181 # `:muted_reblogs` is deprecated (replaced with `reblog_muted_users` relation)
182 field(:muted_reblogs, {:array, :string}, default: [])
183 # `:muted_notifications` is deprecated (replaced with `notification_muted_users` relation)
184 field(:muted_notifications, {:array, :string}, default: [])
185 # `:subscribers` is deprecated (replaced with `subscriber_users` relation)
186 field(:subscribers, {:array, :string}, default: [])
191 for {_relationship_type, [{_outgoing_relation, outgoing_relation_target}, _]} <-
192 @user_relationships_config do
193 # `def blocked_users_relation/2`, `def muted_users_relation/2`,
194 # `def reblog_muted_users_relation/2`, `def notification_muted_users/2`,
195 # `def subscriber_users/2`
196 def unquote(:"#{outgoing_relation_target}_relation")(user, restrict_deactivated? \\ false) do
197 target_users_query = assoc(user, unquote(outgoing_relation_target))
199 if restrict_deactivated? do
200 restrict_deactivated(target_users_query)
206 # `def blocked_users/2`, `def muted_users/2`, `def reblog_muted_users/2`,
207 # `def notification_muted_users/2`, `def subscriber_users/2`
208 def unquote(outgoing_relation_target)(user, restrict_deactivated? \\ false) do
210 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
212 restrict_deactivated?
217 # `def blocked_users_ap_ids/2`, `def muted_users_ap_ids/2`, `def reblog_muted_users_ap_ids/2`,
218 # `def notification_muted_users_ap_ids/2`, `def subscriber_users_ap_ids/2`
219 def unquote(:"#{outgoing_relation_target}_ap_ids")(user, restrict_deactivated? \\ false) do
221 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
223 restrict_deactivated?
225 |> select([u], u.ap_id)
231 Dumps Flake Id to SQL-compatible format (16-byte UUID).
232 E.g. "9pQtDGXuq4p3VlcJEm" -> <<0, 0, 1, 110, 179, 218, 42, 92, 213, 41, 44, 227, 95, 213, 0, 0>>
234 def binary_id(source_id) when is_binary(source_id) do
235 with {:ok, dumped_id} <- FlakeId.Ecto.CompatType.dump(source_id) do
242 def binary_id(source_ids) when is_list(source_ids) do
243 Enum.map(source_ids, &binary_id/1)
246 def binary_id(%User{} = user), do: binary_id(user.id)
248 @doc "Returns status account"
249 @spec account_status(User.t()) :: account_status()
250 def account_status(%User{deactivated: true}), do: :deactivated
251 def account_status(%User{password_reset_pending: true}), do: :password_reset_pending
253 def account_status(%User{confirmation_pending: true}) do
254 case Config.get([:instance, :account_activation_required]) do
255 true -> :confirmation_pending
260 def account_status(%User{}), do: :active
262 @spec visible_for?(User.t(), User.t() | nil) :: boolean()
263 def visible_for?(user, for_user \\ nil)
265 def visible_for?(%User{invisible: true}, _), do: false
267 def visible_for?(%User{id: user_id}, %User{id: for_id}) when user_id == for_id, do: true
269 def visible_for?(%User{} = user, for_user) do
270 account_status(user) == :active || superuser?(for_user)
273 def visible_for?(_, _), do: false
275 @spec superuser?(User.t()) :: boolean()
276 def superuser?(%User{local: true, is_admin: true}), do: true
277 def superuser?(%User{local: true, is_moderator: true}), do: true
278 def superuser?(_), do: false
280 @spec invisible?(User.t()) :: boolean()
281 def invisible?(%User{invisible: true}), do: true
282 def invisible?(_), do: false
284 def avatar_url(user, options \\ []) do
286 %{"url" => [%{"href" => href} | _]} -> href
287 _ -> !options[:no_default] && "#{Web.base_url()}/images/avi.png"
291 def banner_url(user, options \\ []) do
293 %{"url" => [%{"href" => href} | _]} -> href
294 _ -> !options[:no_default] && "#{Web.base_url()}/images/banner.png"
298 def ap_id(%User{nickname: nickname}), do: "#{Web.base_url()}/users/#{nickname}"
300 def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
301 def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"
303 @spec ap_following(User.t()) :: String.t()
304 def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
305 def ap_following(%User{} = user), do: "#{ap_id(user)}/following"
307 def follow_state(%User{} = user, %User{} = target) do
308 case Utils.fetch_latest_follow(user, target) do
309 %{data: %{"state" => state}} -> state
310 # Ideally this would be nil, but then Cachex does not commit the value
315 def get_cached_follow_state(user, target) do
316 key = "follow_state:#{user.ap_id}|#{target.ap_id}"
317 Cachex.fetch!(:user_cache, key, fn _ -> {:commit, follow_state(user, target)} end)
320 @spec set_follow_state_cache(String.t(), String.t(), String.t()) :: {:ok | :error, boolean()}
321 def set_follow_state_cache(user_ap_id, target_ap_id, state) do
322 Cachex.put(:user_cache, "follow_state:#{user_ap_id}|#{target_ap_id}", state)
325 @spec restrict_deactivated(Ecto.Query.t()) :: Ecto.Query.t()
326 def restrict_deactivated(query) do
327 from(u in query, where: u.deactivated != ^true)
330 defdelegate following_count(user), to: FollowingRelationship
332 defp truncate_fields_param(params) do
333 if Map.has_key?(params, :fields) do
334 Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
340 defp truncate_if_exists(params, key, max_length) do
341 if Map.has_key?(params, key) and is_binary(params[key]) do
342 {value, _chopped} = String.split_at(params[key], max_length)
343 Map.put(params, key, value)
349 def remote_user_creation(params) do
350 bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
351 name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
355 |> truncate_if_exists(:name, name_limit)
356 |> truncate_if_exists(:bio, bio_limit)
357 |> truncate_fields_param()
377 :hide_followers_count,
388 |> validate_required([:name, :ap_id])
389 |> unique_constraint(:nickname)
390 |> validate_format(:nickname, @email_regex)
391 |> validate_length(:bio, max: bio_limit)
392 |> validate_length(:name, max: name_limit)
393 |> validate_fields(true)
395 case params[:source_data] do
396 %{"followers" => followers, "following" => following} ->
398 |> put_change(:follower_address, followers)
399 |> put_change(:following_address, following)
402 followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
403 put_change(changeset, :follower_address, followers)
407 def update_changeset(struct, params \\ %{}) do
408 bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
409 name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
424 :hide_followers_count,
427 :allow_following_move,
430 :skip_thread_containment,
433 :pleroma_settings_store,
439 |> unique_constraint(:nickname)
440 |> validate_format(:nickname, local_nickname_regex())
441 |> validate_length(:bio, max: bio_limit)
442 |> validate_length(:name, min: 1, max: name_limit)
444 |> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
445 |> put_change_if_present(:avatar, &put_upload(&1, :avatar))
446 |> put_change_if_present(:banner, &put_upload(&1, :banner))
447 |> put_change_if_present(:background, &put_upload(&1, :background))
448 |> put_change_if_present(
449 :pleroma_settings_store,
450 &{:ok, Map.merge(struct.pleroma_settings_store, &1)}
452 |> validate_fields(false)
455 defp put_fields(changeset) do
456 if raw_fields = get_change(changeset, :raw_fields) do
459 |> Enum.filter(fn %{"name" => n} -> n != "" end)
463 |> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)
466 |> put_change(:raw_fields, raw_fields)
467 |> put_change(:fields, fields)
473 defp parse_fields(value) do
475 |> Formatter.linkify(mentions_format: :full)
479 defp put_change_if_present(changeset, map_field, value_function) do
480 if value = get_change(changeset, map_field) do
481 with {:ok, new_value} <- value_function.(value) do
482 put_change(changeset, map_field, new_value)
491 defp put_upload(value, type) do
492 with %Plug.Upload{} <- value,
493 {:ok, object} <- ActivityPub.upload(value, type: type) do
498 def upgrade_changeset(struct, params \\ %{}, remote? \\ false) do
499 bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
500 name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
502 params = Map.put(params, :last_refreshed_at, NaiveDateTime.utc_now())
504 params = if remote?, do: truncate_fields_param(params), else: params
526 :allow_following_move,
528 :hide_followers_count,
534 |> unique_constraint(:nickname)
535 |> validate_format(:nickname, local_nickname_regex())
536 |> validate_length(:bio, max: bio_limit)
537 |> validate_length(:name, max: name_limit)
538 |> validate_fields(remote?)
541 def update_as_admin_changeset(struct, params) do
543 |> update_changeset(params)
544 |> cast(params, [:email])
545 |> delete_change(:also_known_as)
546 |> unique_constraint(:email)
547 |> validate_format(:email, @email_regex)
550 @spec update_as_admin(%User{}, map) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
551 def update_as_admin(user, params) do
552 params = Map.put(params, "password_confirmation", params["password"])
553 changeset = update_as_admin_changeset(user, params)
555 if params["password"] do
556 reset_password(user, changeset, params)
558 User.update_and_set_cache(changeset)
562 def password_update_changeset(struct, params) do
564 |> cast(params, [:password, :password_confirmation])
565 |> validate_required([:password, :password_confirmation])
566 |> validate_confirmation(:password)
567 |> put_password_hash()
568 |> put_change(:password_reset_pending, false)
571 @spec reset_password(User.t(), map) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
572 def reset_password(%User{} = user, params) do
573 reset_password(user, user, params)
576 def reset_password(%User{id: user_id} = user, struct, params) do
579 |> Multi.update(:user, password_update_changeset(struct, params))
580 |> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
581 |> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))
583 case Repo.transaction(multi) do
584 {:ok, %{user: user} = _} -> set_cache(user)
585 {:error, _, changeset, _} -> {:error, changeset}
589 def update_password_reset_pending(user, value) do
592 |> put_change(:password_reset_pending, value)
593 |> update_and_set_cache()
596 def force_password_reset_async(user) do
597 BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
600 @spec force_password_reset(User.t()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
601 def force_password_reset(user), do: update_password_reset_pending(user, true)
603 def register_changeset(struct, params \\ %{}, opts \\ []) do
604 bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
605 name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
608 if is_nil(opts[:need_confirmation]) do
609 Pleroma.Config.get([:instance, :account_activation_required])
611 opts[:need_confirmation]
615 |> confirmation_changeset(need_confirmation: need_confirmation?)
616 |> cast(params, [:bio, :email, :name, :nickname, :password, :password_confirmation])
617 |> validate_required([:name, :nickname, :password, :password_confirmation])
618 |> validate_confirmation(:password)
619 |> unique_constraint(:email)
620 |> unique_constraint(:nickname)
621 |> validate_exclusion(:nickname, Pleroma.Config.get([User, :restricted_nicknames]))
622 |> validate_format(:nickname, local_nickname_regex())
623 |> validate_format(:email, @email_regex)
624 |> validate_length(:bio, max: bio_limit)
625 |> validate_length(:name, min: 1, max: name_limit)
626 |> maybe_validate_required_email(opts[:external])
629 |> unique_constraint(:ap_id)
630 |> put_following_and_follower_address()
633 def maybe_validate_required_email(changeset, true), do: changeset
635 def maybe_validate_required_email(changeset, _) do
636 if Pleroma.Config.get([:instance, :account_activation_required]) do
637 validate_required(changeset, [:email])
643 defp put_ap_id(changeset) do
644 ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
645 put_change(changeset, :ap_id, ap_id)
648 defp put_following_and_follower_address(changeset) do
649 followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
652 |> put_change(:follower_address, followers)
655 defp autofollow_users(user) do
656 candidates = Pleroma.Config.get([:instance, :autofollowed_nicknames])
659 User.Query.build(%{nickname: candidates, local: true, deactivated: false})
662 follow_all(user, autofollowed_users)
665 @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
666 def register(%Ecto.Changeset{} = changeset) do
667 with {:ok, user} <- Repo.insert(changeset) do
668 post_register_action(user)
672 def post_register_action(%User{} = user) do
673 with {:ok, user} <- autofollow_users(user),
674 {:ok, user} <- set_cache(user),
675 {:ok, _} <- User.WelcomeMessage.post_welcome_message_to_user(user),
676 {:ok, _} <- try_send_confirmation_email(user) do
681 def try_send_confirmation_email(%User{} = user) do
682 if user.confirmation_pending &&
683 Pleroma.Config.get([:instance, :account_activation_required]) do
685 |> Pleroma.Emails.UserEmail.account_confirmation_email()
686 |> Pleroma.Emails.Mailer.deliver_async()
694 def try_send_confirmation_email(users) do
695 Enum.each(users, &try_send_confirmation_email/1)
698 def needs_update?(%User{local: true}), do: false
700 def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
702 def needs_update?(%User{local: false} = user) do
703 NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
706 def needs_update?(_), do: true
708 @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
710 # "Locked" (self-locked) users demand explicit authorization of follow requests
711 def maybe_direct_follow(%User{} = follower, %User{local: true, locked: true} = followed) do
712 follow(follower, followed, :follow_pending)
715 def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
716 follow(follower, followed)
719 def maybe_direct_follow(%User{} = follower, %User{} = followed) do
720 if not ap_enabled?(followed) do
721 follow(follower, followed)
727 @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
728 @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
729 def follow_all(follower, followeds) do
731 |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
732 |> Enum.each(&follow(follower, &1, :follow_accept))
737 defdelegate following(user), to: FollowingRelationship
739 def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
740 deny_follow_blocked = Pleroma.Config.get([:user, :deny_follow_blocked])
743 followed.deactivated ->
744 {:error, "Could not follow user: #{followed.nickname} is deactivated."}
746 deny_follow_blocked and blocks?(followed, follower) ->
747 {:error, "Could not follow user: #{followed.nickname} blocked you."}
750 FollowingRelationship.follow(follower, followed, state)
752 {:ok, _} = update_follower_count(followed)
755 |> update_following_count()
760 def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
761 {:error, "Not subscribed!"}
764 def unfollow(%User{} = follower, %User{} = followed) do
765 case get_follow_state(follower, followed) do
766 state when state in [:follow_pending, :follow_accept] ->
767 FollowingRelationship.unfollow(follower, followed)
768 {:ok, followed} = update_follower_count(followed)
772 |> update_following_count()
775 {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
778 {:error, "Not subscribed!"}
782 defdelegate following?(follower, followed), to: FollowingRelationship
784 @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
785 def get_follow_state(%User{} = follower, %User{} = following) do
786 following_relationship = FollowingRelationship.get(follower, following)
788 case {following_relationship, following.local} do
790 case Utils.fetch_latest_follow(follower, following) do
791 %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
792 FollowingRelationship.state_to_enum(state)
798 {%{state: state}, _} ->
806 def locked?(%User{} = user) do
811 Repo.get_by(User, id: id)
814 def get_by_ap_id(ap_id) do
815 Repo.get_by(User, ap_id: ap_id)
818 def get_all_by_ap_id(ap_ids) do
819 from(u in __MODULE__,
820 where: u.ap_id in ^ap_ids
825 def get_all_by_ids(ids) do
826 from(u in __MODULE__, where: u.id in ^ids)
830 # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
831 # of the ap_id and the domain and tries to get that user
832 def get_by_guessed_nickname(ap_id) do
833 domain = URI.parse(ap_id).host
834 name = List.last(String.split(ap_id, "/"))
835 nickname = "#{name}@#{domain}"
837 get_cached_by_nickname(nickname)
840 def set_cache({:ok, user}), do: set_cache(user)
841 def set_cache({:error, err}), do: {:error, err}
843 def set_cache(%User{} = user) do
844 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
845 Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
849 def update_and_set_cache(struct, params) do
851 |> update_changeset(params)
852 |> update_and_set_cache()
855 def update_and_set_cache(changeset) do
856 with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
861 def invalidate_cache(user) do
862 Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
863 Cachex.del(:user_cache, "nickname:#{user.nickname}")
866 @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
867 def get_cached_by_ap_id(ap_id) do
868 key = "ap_id:#{ap_id}"
870 with {:ok, nil} <- Cachex.get(:user_cache, key),
871 user when not is_nil(user) <- get_by_ap_id(ap_id),
872 {:ok, true} <- Cachex.put(:user_cache, key, user) do
880 def get_cached_by_id(id) do
884 Cachex.fetch!(:user_cache, key, fn _ ->
888 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
889 {:commit, user.ap_id}
895 get_cached_by_ap_id(ap_id)
898 def get_cached_by_nickname(nickname) do
899 key = "nickname:#{nickname}"
901 Cachex.fetch!(:user_cache, key, fn ->
902 case get_or_fetch_by_nickname(nickname) do
903 {:ok, user} -> {:commit, user}
904 {:error, _error} -> {:ignore, nil}
909 def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
910 restrict_to_local = Pleroma.Config.get([:instance, :limit_to_local_content])
913 is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
914 get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
916 restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
917 get_cached_by_nickname(nickname_or_id)
919 restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
920 get_cached_by_nickname(nickname_or_id)
927 def get_by_nickname(nickname) do
928 Repo.get_by(User, nickname: nickname) ||
929 if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
930 Repo.get_by(User, nickname: local_nickname(nickname))
934 def get_by_email(email), do: Repo.get_by(User, email: email)
936 def get_by_nickname_or_email(nickname_or_email) do
937 get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
940 def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
942 def get_or_fetch_by_nickname(nickname) do
943 with %User{} = user <- get_by_nickname(nickname) do
947 with [_nick, _domain] <- String.split(nickname, "@"),
948 {:ok, user} <- fetch_by_nickname(nickname) do
951 _e -> {:error, "not found " <> nickname}
956 @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
957 def get_followers_query(%User{} = user, nil) do
958 User.Query.build(%{followers: user, deactivated: false})
961 def get_followers_query(user, page) do
963 |> get_followers_query(nil)
964 |> User.Query.paginate(page, 20)
967 @spec get_followers_query(User.t()) :: Ecto.Query.t()
968 def get_followers_query(user), do: get_followers_query(user, nil)
970 @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
971 def get_followers(user, page \\ nil) do
973 |> get_followers_query(page)
977 @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
978 def get_external_followers(user, page \\ nil) do
980 |> get_followers_query(page)
981 |> User.Query.build(%{external: true})
985 def get_followers_ids(user, page \\ nil) do
987 |> get_followers_query(page)
992 @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
993 def get_friends_query(%User{} = user, nil) do
994 User.Query.build(%{friends: user, deactivated: false})
997 def get_friends_query(user, page) do
999 |> get_friends_query(nil)
1000 |> User.Query.paginate(page, 20)
1003 @spec get_friends_query(User.t()) :: Ecto.Query.t()
1004 def get_friends_query(user), do: get_friends_query(user, nil)
1006 def get_friends(user, page \\ nil) do
1008 |> get_friends_query(page)
1012 def get_friends_ap_ids(user) do
1014 |> get_friends_query(nil)
1015 |> select([u], u.ap_id)
1019 def get_friends_ids(user, page \\ nil) do
1021 |> get_friends_query(page)
1022 |> select([u], u.id)
1026 defdelegate get_follow_requests(user), to: FollowingRelationship
1028 def increase_note_count(%User{} = user) do
1030 |> where(id: ^user.id)
1031 |> update([u], inc: [note_count: 1])
1033 |> Repo.update_all([])
1035 {1, [user]} -> set_cache(user)
1040 def decrease_note_count(%User{} = user) do
1042 |> where(id: ^user.id)
1045 note_count: fragment("greatest(0, note_count - 1)")
1049 |> Repo.update_all([])
1051 {1, [user]} -> set_cache(user)
1056 def update_note_count(%User{} = user, note_count \\ nil) do
1061 where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1067 |> cast(%{note_count: note_count}, [:note_count])
1068 |> update_and_set_cache()
1071 @spec maybe_fetch_follow_information(User.t()) :: User.t()
1072 def maybe_fetch_follow_information(user) do
1073 with {:ok, user} <- fetch_follow_information(user) do
1077 Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1083 def fetch_follow_information(user) do
1084 with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1086 |> follow_information_changeset(info)
1087 |> update_and_set_cache()
1091 defp follow_information_changeset(user, params) do
1098 :hide_followers_count,
1103 def update_follower_count(%User{} = user) do
1104 if user.local or !Pleroma.Config.get([:instance, :external_user_synchronization]) do
1105 follower_count_query =
1106 User.Query.build(%{followers: user, deactivated: false})
1107 |> select([u], %{count: count(u.id)})
1110 |> where(id: ^user.id)
1111 |> join(:inner, [u], s in subquery(follower_count_query))
1113 set: [follower_count: s.count]
1116 |> Repo.update_all([])
1118 {1, [user]} -> set_cache(user)
1122 {:ok, maybe_fetch_follow_information(user)}
1126 @spec update_following_count(User.t()) :: User.t()
1127 def update_following_count(%User{local: false} = user) do
1128 if Pleroma.Config.get([:instance, :external_user_synchronization]) do
1129 maybe_fetch_follow_information(user)
1135 def update_following_count(%User{local: true} = user) do
1136 following_count = FollowingRelationship.following_count(user)
1139 |> follow_information_changeset(%{following_count: following_count})
1143 def set_unread_conversation_count(%User{local: true} = user) do
1144 unread_query = Participation.unread_conversation_count_for_user(user)
1147 |> join(:inner, [u], p in subquery(unread_query))
1149 set: [unread_conversation_count: p.count]
1151 |> where([u], u.id == ^user.id)
1153 |> Repo.update_all([])
1155 {1, [user]} -> set_cache(user)
1160 def set_unread_conversation_count(user), do: {:ok, user}
1162 def increment_unread_conversation_count(conversation, %User{local: true} = user) do
1164 Participation.unread_conversation_count_for_user(user)
1165 |> where([p], p.conversation_id == ^conversation.id)
1168 |> join(:inner, [u], p in subquery(unread_query))
1170 inc: [unread_conversation_count: 1]
1172 |> where([u], u.id == ^user.id)
1173 |> where([u, p], p.count == 0)
1175 |> Repo.update_all([])
1177 {1, [user]} -> set_cache(user)
1182 def increment_unread_conversation_count(_, user), do: {:ok, user}
1184 @spec get_users_from_set([String.t()], boolean()) :: [User.t()]
1185 def get_users_from_set(ap_ids, local_only \\ true) do
1186 criteria = %{ap_id: ap_ids, deactivated: false}
1187 criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1189 User.Query.build(criteria)
1193 @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1194 def get_recipients_from_activity(%Activity{recipients: to}) do
1195 User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
1199 @spec mute(User.t(), User.t(), boolean()) ::
1200 {:ok, list(UserRelationship.t())} | {:error, String.t()}
1201 def mute(%User{} = muter, %User{} = mutee, notifications? \\ true) do
1202 add_to_mutes(muter, mutee, notifications?)
1205 def unmute(%User{} = muter, %User{} = mutee) do
1206 remove_from_mutes(muter, mutee)
1209 def subscribe(%User{} = subscriber, %User{} = target) do
1210 deny_follow_blocked = Pleroma.Config.get([:user, :deny_follow_blocked])
1212 if blocks?(target, subscriber) and deny_follow_blocked do
1213 {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1215 # Note: the relationship is inverse: subscriber acts as relationship target
1216 UserRelationship.create_inverse_subscription(target, subscriber)
1220 def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1221 with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1222 subscribe(subscriber, subscribee)
1226 def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1227 # Note: the relationship is inverse: subscriber acts as relationship target
1228 UserRelationship.delete_inverse_subscription(target, unsubscriber)
1231 def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1232 with %User{} = user <- get_cached_by_ap_id(ap_id) do
1233 unsubscribe(unsubscriber, user)
1237 def block(%User{} = blocker, %User{} = blocked) do
1238 # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1240 if following?(blocker, blocked) do
1241 {:ok, blocker, _} = unfollow(blocker, blocked)
1247 # clear any requested follows as well
1249 case CommonAPI.reject_follow_request(blocked, blocker) do
1250 {:ok, %User{} = updated_blocked} -> updated_blocked
1254 unsubscribe(blocked, blocker)
1256 if following?(blocked, blocker), do: unfollow(blocked, blocker)
1258 {:ok, blocker} = update_follower_count(blocker)
1259 {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1260 add_to_block(blocker, blocked)
1263 # helper to handle the block given only an actor's AP id
1264 def block(%User{} = blocker, %{ap_id: ap_id}) do
1265 block(blocker, get_cached_by_ap_id(ap_id))
1268 def unblock(%User{} = blocker, %User{} = blocked) do
1269 remove_from_block(blocker, blocked)
1272 # helper to handle the block given only an actor's AP id
1273 def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1274 unblock(blocker, get_cached_by_ap_id(ap_id))
1277 def mutes?(nil, _), do: false
1278 def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1280 def mutes_user?(%User{} = user, %User{} = target) do
1281 UserRelationship.mute_exists?(user, target)
1284 @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1285 def muted_notifications?(nil, _), do: false
1287 def muted_notifications?(%User{} = user, %User{} = target),
1288 do: UserRelationship.notification_mute_exists?(user, target)
1290 def blocks?(nil, _), do: false
1292 def blocks?(%User{} = user, %User{} = target) do
1293 blocks_user?(user, target) ||
1294 (blocks_domain?(user, target) and not User.following?(user, target))
1297 def blocks_user?(%User{} = user, %User{} = target) do
1298 UserRelationship.block_exists?(user, target)
1301 def blocks_user?(_, _), do: false
1303 def blocks_domain?(%User{} = user, %User{} = target) do
1304 domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1305 %{host: host} = URI.parse(target.ap_id)
1306 Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1309 def blocks_domain?(_, _), do: false
1311 def subscribed_to?(%User{} = user, %User{} = target) do
1312 # Note: the relationship is inverse: subscriber acts as relationship target
1313 UserRelationship.inverse_subscription_exists?(target, user)
1316 def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1317 with %User{} = target <- get_cached_by_ap_id(ap_id) do
1318 subscribed_to?(user, target)
1323 Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1324 E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1326 @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1327 def outgoing_relationships_ap_ids(_user, []), do: %{}
1329 def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1331 def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1332 when is_list(relationship_types) do
1335 |> assoc(:outgoing_relationships)
1336 |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1337 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1338 |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1339 |> group_by([user_rel, u], user_rel.relationship_type)
1341 |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1346 fn rel_type -> {rel_type, db_result[rel_type] || []} end
1350 def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1352 def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1354 def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1356 def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1357 when is_list(relationship_types) do
1359 |> assoc(:incoming_relationships)
1360 |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1361 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1362 |> maybe_filter_on_ap_id(ap_ids)
1363 |> select([user_rel, u], u.ap_id)
1368 defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1369 where(query, [user_rel, u], u.ap_id in ^ap_ids)
1372 defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1374 def deactivate_async(user, status \\ true) do
1375 BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
1378 def deactivate(user, status \\ true)
1380 def deactivate(users, status) when is_list(users) do
1381 Repo.transaction(fn ->
1382 for user <- users, do: deactivate(user, status)
1386 def deactivate(%User{} = user, status) do
1387 with {:ok, user} <- set_activation_status(user, status) do
1390 |> Enum.filter(& &1.local)
1391 |> Enum.each(fn follower ->
1392 follower |> update_following_count() |> set_cache()
1395 # Only update local user counts, remote will be update during the next pull.
1398 |> Enum.filter(& &1.local)
1399 |> Enum.each(&update_follower_count/1)
1405 def update_notification_settings(%User{} = user, settings) do
1407 |> cast(%{notification_settings: settings}, [])
1408 |> cast_embed(:notification_settings)
1409 |> validate_required([:notification_settings])
1410 |> update_and_set_cache()
1413 def delete(users) when is_list(users) do
1414 for user <- users, do: delete(user)
1417 def delete(%User{} = user) do
1418 BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1421 def perform(:force_password_reset, user), do: force_password_reset(user)
1423 @spec perform(atom(), User.t()) :: {:ok, User.t()}
1424 def perform(:delete, %User{} = user) do
1425 {:ok, _user} = ActivityPub.delete(user)
1427 # Remove all relationships
1430 |> Enum.each(fn follower ->
1431 ActivityPub.unfollow(follower, user)
1432 unfollow(follower, user)
1437 |> Enum.each(fn followed ->
1438 ActivityPub.unfollow(user, followed)
1439 unfollow(user, followed)
1442 delete_user_activities(user)
1446 |> change(%{deactivated: true, email: nil})
1447 |> update_and_set_cache()
1449 invalidate_cache(user)
1454 def perform(:deactivate_async, user, status), do: deactivate(user, status)
1456 @spec perform(atom(), User.t(), list()) :: list() | {:error, any()}
1457 def perform(:blocks_import, %User{} = blocker, blocked_identifiers)
1458 when is_list(blocked_identifiers) do
1460 blocked_identifiers,
1461 fn blocked_identifier ->
1462 with {:ok, %User{} = blocked} <- get_or_fetch(blocked_identifier),
1463 {:ok, _user_block} <- block(blocker, blocked),
1464 {:ok, _} <- ActivityPub.block(blocker, blocked) do
1468 Logger.debug("blocks_import failed for #{blocked_identifier} with: #{inspect(err)}")
1475 def perform(:follow_import, %User{} = follower, followed_identifiers)
1476 when is_list(followed_identifiers) do
1478 followed_identifiers,
1479 fn followed_identifier ->
1480 with {:ok, %User{} = followed} <- get_or_fetch(followed_identifier),
1481 {:ok, follower} <- maybe_direct_follow(follower, followed),
1482 {:ok, _} <- ActivityPub.follow(follower, followed) do
1486 Logger.debug("follow_import failed for #{followed_identifier} with: #{inspect(err)}")
1493 @spec external_users_query() :: Ecto.Query.t()
1494 def external_users_query do
1502 @spec external_users(keyword()) :: [User.t()]
1503 def external_users(opts \\ []) do
1505 external_users_query()
1506 |> select([u], struct(u, [:id, :ap_id]))
1510 do: where(query, [u], u.id > ^opts[:max_id]),
1515 do: limit(query, ^opts[:limit]),
1521 def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers) do
1522 BackgroundWorker.enqueue("blocks_import", %{
1523 "blocker_id" => blocker.id,
1524 "blocked_identifiers" => blocked_identifiers
1528 def follow_import(%User{} = follower, followed_identifiers)
1529 when is_list(followed_identifiers) do
1530 BackgroundWorker.enqueue("follow_import", %{
1531 "follower_id" => follower.id,
1532 "followed_identifiers" => followed_identifiers
1536 def delete_user_activities(%User{ap_id: ap_id}) do
1538 |> Activity.Queries.by_actor()
1539 |> RepoStreamer.chunk_stream(50)
1540 |> Stream.each(fn activities -> Enum.each(activities, &delete_activity/1) end)
1544 defp delete_activity(%{data: %{"type" => "Create"}} = activity) do
1546 |> Object.normalize()
1547 |> ActivityPub.delete()
1550 defp delete_activity(%{data: %{"type" => "Like"}} = activity) do
1551 object = Object.normalize(activity)
1554 |> get_cached_by_ap_id()
1555 |> ActivityPub.unlike(object)
1558 defp delete_activity(%{data: %{"type" => "Announce"}} = activity) do
1559 object = Object.normalize(activity)
1562 |> get_cached_by_ap_id()
1563 |> ActivityPub.unannounce(object)
1566 defp delete_activity(_activity), do: "Doing nothing"
1568 def html_filter_policy(%User{no_rich_text: true}) do
1569 Pleroma.HTML.Scrubber.TwitterText
1572 def html_filter_policy(_), do: Pleroma.Config.get([:markup, :scrub_policy])
1574 def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1576 def get_or_fetch_by_ap_id(ap_id) do
1577 user = get_cached_by_ap_id(ap_id)
1579 if !is_nil(user) and !needs_update?(user) do
1582 fetch_by_ap_id(ap_id)
1587 Creates an internal service actor by URI if missing.
1588 Optionally takes nickname for addressing.
1590 @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1591 def get_or_create_service_actor_by_ap_id(uri, nickname) do
1593 case get_cached_by_ap_id(uri) do
1595 with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1596 Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1600 %User{invisible: false} = user ->
1610 @spec set_invisible(User.t()) :: {:ok, User.t()}
1611 defp set_invisible(user) do
1613 |> change(%{invisible: true})
1614 |> update_and_set_cache()
1617 @spec create_service_actor(String.t(), String.t()) ::
1618 {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1619 defp create_service_actor(uri, nickname) do
1625 follower_address: uri <> "/followers"
1628 |> unique_constraint(:nickname)
1634 def public_key(%{source_data: %{"publicKey" => %{"publicKeyPem" => public_key_pem}}}) do
1637 |> :public_key.pem_decode()
1639 |> :public_key.pem_entry_decode()
1644 def public_key(_), do: {:error, "not found key"}
1646 def get_public_key_for_ap_id(ap_id) do
1647 with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1648 {:ok, public_key} <- public_key(user) do
1655 defp blank?(""), do: nil
1656 defp blank?(n), do: n
1658 def insert_or_update_user(data) do
1660 |> Map.put(:name, blank?(data[:name]) || data[:nickname])
1661 |> remote_user_creation()
1662 |> Repo.insert(on_conflict: {:replace_all_except, [:id]}, conflict_target: :nickname)
1666 def ap_enabled?(%User{local: true}), do: true
1667 def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1668 def ap_enabled?(_), do: false
1670 @doc "Gets or fetch a user by uri or nickname."
1671 @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1672 def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1673 def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1675 # wait a period of time and return newest version of the User structs
1676 # this is because we have synchronous follow APIs and need to simulate them
1677 # with an async handshake
1678 def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1679 with %User{} = a <- get_cached_by_id(a.id),
1680 %User{} = b <- get_cached_by_id(b.id) do
1687 def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1688 with :ok <- :timer.sleep(timeout),
1689 %User{} = a <- get_cached_by_id(a.id),
1690 %User{} = b <- get_cached_by_id(b.id) do
1697 def parse_bio(bio) when is_binary(bio) and bio != "" do
1699 |> CommonUtils.format_input("text/plain", mentions_format: :full)
1703 def parse_bio(_), do: ""
1705 def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1706 # TODO: get profile URLs other than user.ap_id
1707 profile_urls = [user.ap_id]
1710 |> CommonUtils.format_input("text/plain",
1711 mentions_format: :full,
1712 rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1717 def parse_bio(_, _), do: ""
1719 def tag(user_identifiers, tags) when is_list(user_identifiers) do
1720 Repo.transaction(fn ->
1721 for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1725 def tag(nickname, tags) when is_binary(nickname),
1726 do: tag(get_by_nickname(nickname), tags)
1728 def tag(%User{} = user, tags),
1729 do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1731 def untag(user_identifiers, tags) when is_list(user_identifiers) do
1732 Repo.transaction(fn ->
1733 for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1737 def untag(nickname, tags) when is_binary(nickname),
1738 do: untag(get_by_nickname(nickname), tags)
1740 def untag(%User{} = user, tags),
1741 do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1743 defp update_tags(%User{} = user, new_tags) do
1744 {:ok, updated_user} =
1746 |> change(%{tags: new_tags})
1747 |> update_and_set_cache()
1752 defp normalize_tags(tags) do
1755 |> Enum.map(&String.downcase/1)
1758 defp local_nickname_regex do
1759 if Pleroma.Config.get([:instance, :extended_nickname_format]) do
1760 @extended_local_nickname_regex
1762 @strict_local_nickname_regex
1766 def local_nickname(nickname_or_mention) do
1769 |> String.split("@")
1773 def full_nickname(nickname_or_mention),
1774 do: String.trim_leading(nickname_or_mention, "@")
1776 def error_user(ap_id) do
1780 nickname: "erroruser@example.com",
1781 inserted_at: NaiveDateTime.utc_now()
1785 @spec all_superusers() :: [User.t()]
1786 def all_superusers do
1787 User.Query.build(%{super_users: true, local: true, deactivated: false})
1791 def showing_reblogs?(%User{} = user, %User{} = target) do
1792 not UserRelationship.reblog_mute_exists?(user, target)
1796 The function returns a query to get users with no activity for given interval of days.
1797 Inactive users are those who didn't read any notification, or had any activity where
1798 the user is the activity's actor, during `inactivity_threshold` days.
1799 Deactivated users will not appear in this list.
1803 iex> Pleroma.User.list_inactive_users()
1806 @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
1807 def list_inactive_users_query(inactivity_threshold \\ 7) do
1808 negative_inactivity_threshold = -inactivity_threshold
1809 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
1810 # Subqueries are not supported in `where` clauses, join gets too complicated.
1811 has_read_notifications =
1812 from(n in Pleroma.Notification,
1813 where: n.seen == true,
1815 having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
1818 |> Pleroma.Repo.all()
1820 from(u in Pleroma.User,
1821 left_join: a in Pleroma.Activity,
1822 on: u.ap_id == a.actor,
1823 where: not is_nil(u.nickname),
1824 where: u.deactivated != ^true,
1825 where: u.id not in ^has_read_notifications,
1828 max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
1829 is_nil(max(a.inserted_at))
1834 Enable or disable email notifications for user
1838 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
1839 Pleroma.User{email_notifications: %{"digest" => true}}
1841 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
1842 Pleroma.User{email_notifications: %{"digest" => false}}
1844 @spec switch_email_notifications(t(), String.t(), boolean()) ::
1845 {:ok, t()} | {:error, Ecto.Changeset.t()}
1846 def switch_email_notifications(user, type, status) do
1847 User.update_email_notifications(user, %{type => status})
1851 Set `last_digest_emailed_at` value for the user to current time
1853 @spec touch_last_digest_emailed_at(t()) :: t()
1854 def touch_last_digest_emailed_at(user) do
1855 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
1857 {:ok, updated_user} =
1859 |> change(%{last_digest_emailed_at: now})
1860 |> update_and_set_cache()
1865 @spec toggle_confirmation(User.t()) :: {:ok, User.t()} | {:error, Changeset.t()}
1866 def toggle_confirmation(%User{} = user) do
1868 |> confirmation_changeset(need_confirmation: !user.confirmation_pending)
1869 |> update_and_set_cache()
1872 @spec toggle_confirmation([User.t()]) :: [{:ok, User.t()} | {:error, Changeset.t()}]
1873 def toggle_confirmation(users) do
1874 Enum.map(users, &toggle_confirmation/1)
1877 def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
1881 def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
1882 # use instance-default
1883 config = Pleroma.Config.get([:assets, :mascots])
1884 default_mascot = Pleroma.Config.get([:assets, :default_mascot])
1885 mascot = Keyword.get(config, default_mascot)
1888 "id" => "default-mascot",
1889 "url" => mascot[:url],
1890 "preview_url" => mascot[:url],
1892 "mime_type" => mascot[:mime_type]
1897 def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
1899 def ensure_keys_present(%User{} = user) do
1900 with {:ok, pem} <- Keys.generate_rsa_pem() do
1902 |> cast(%{keys: pem}, [:keys])
1903 |> validate_required([:keys])
1904 |> update_and_set_cache()
1908 def get_ap_ids_by_nicknames(nicknames) do
1910 where: u.nickname in ^nicknames,
1916 defdelegate search(query, opts \\ []), to: User.Search
1918 defp put_password_hash(
1919 %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
1921 change(changeset, password_hash: Pbkdf2.hashpwsalt(password))
1924 defp put_password_hash(changeset), do: changeset
1926 def is_internal_user?(%User{nickname: nil}), do: true
1927 def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
1928 def is_internal_user?(_), do: false
1930 # A hack because user delete activities have a fake id for whatever reason
1931 # TODO: Get rid of this
1932 def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
1934 def get_delivered_users_by_object_id(object_id) do
1936 inner_join: delivery in assoc(u, :deliveries),
1937 where: delivery.object_id == ^object_id
1942 def change_email(user, email) do
1944 |> cast(%{email: email}, [:email])
1945 |> validate_required([:email])
1946 |> unique_constraint(:email)
1947 |> validate_format(:email, @email_regex)
1948 |> update_and_set_cache()
1951 # Internal function; public one is `deactivate/2`
1952 defp set_activation_status(user, deactivated) do
1954 |> cast(%{deactivated: deactivated}, [:deactivated])
1955 |> update_and_set_cache()
1958 def update_banner(user, banner) do
1960 |> cast(%{banner: banner}, [:banner])
1961 |> update_and_set_cache()
1964 def update_background(user, background) do
1966 |> cast(%{background: background}, [:background])
1967 |> update_and_set_cache()
1970 def update_source_data(user, source_data) do
1972 |> cast(%{source_data: source_data}, [:source_data])
1973 |> update_and_set_cache()
1976 def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
1979 moderator: is_moderator
1983 # ``fields`` is an array of mastodon profile field, containing ``{"name": "…", "value": "…"}``.
1984 # For example: [{"name": "Pronoun", "value": "she/her"}, …]
1985 def fields(%{fields: nil, source_data: %{"attachment" => attachment}}) do
1986 limit = Pleroma.Config.get([:instance, :max_remote_account_fields], 0)
1989 |> Enum.filter(fn %{"type" => t} -> t == "PropertyValue" end)
1990 |> Enum.map(fn fields -> Map.take(fields, ["name", "value"]) end)
1994 def fields(%{fields: nil}), do: []
1996 def fields(%{fields: fields}), do: fields
1998 def validate_fields(changeset, remote? \\ false) do
1999 limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2000 limit = Pleroma.Config.get([:instance, limit_name], 0)
2003 |> validate_length(:fields, max: limit)
2004 |> validate_change(:fields, fn :fields, fields ->
2005 if Enum.all?(fields, &valid_field?/1) do
2013 defp valid_field?(%{"name" => name, "value" => value}) do
2014 name_limit = Pleroma.Config.get([:instance, :account_field_name_length], 255)
2015 value_limit = Pleroma.Config.get([:instance, :account_field_value_length], 255)
2017 is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2018 String.length(value) <= value_limit
2021 defp valid_field?(_), do: false
2023 defp truncate_field(%{"name" => name, "value" => value}) do
2025 String.split_at(name, Pleroma.Config.get([:instance, :account_field_name_length], 255))
2028 String.split_at(value, Pleroma.Config.get([:instance, :account_field_value_length], 255))
2030 %{"name" => name, "value" => value}
2033 def admin_api_update(user, params) do
2040 |> update_and_set_cache()
2043 @doc "Signs user out of all applications"
2044 def global_sign_out(user) do
2045 OAuth.Authorization.delete_user_authorizations(user)
2046 OAuth.Token.delete_user_tokens(user)
2049 def mascot_update(user, url) do
2051 |> cast(%{mascot: url}, [:mascot])
2052 |> validate_required([:mascot])
2053 |> update_and_set_cache()
2056 def mastodon_settings_update(user, settings) do
2058 |> cast(%{settings: settings}, [:settings])
2059 |> validate_required([:settings])
2060 |> update_and_set_cache()
2063 @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2064 def confirmation_changeset(user, need_confirmation: need_confirmation?) do
2066 if need_confirmation? do
2068 confirmation_pending: true,
2069 confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2073 confirmation_pending: false,
2074 confirmation_token: nil
2078 cast(user, params, [:confirmation_pending, :confirmation_token])
2081 def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2082 if id not in user.pinned_activities do
2083 max_pinned_statuses = Pleroma.Config.get([:instance, :max_pinned_statuses], 0)
2084 params = %{pinned_activities: user.pinned_activities ++ [id]}
2087 |> cast(params, [:pinned_activities])
2088 |> validate_length(:pinned_activities,
2089 max: max_pinned_statuses,
2090 message: "You have already pinned the maximum number of statuses"
2095 |> update_and_set_cache()
2098 def remove_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2099 params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2102 |> cast(params, [:pinned_activities])
2103 |> update_and_set_cache()
2106 def update_email_notifications(user, settings) do
2107 email_notifications =
2108 user.email_notifications
2109 |> Map.merge(settings)
2110 |> Map.take(["digest"])
2112 params = %{email_notifications: email_notifications}
2113 fields = [:email_notifications]
2116 |> cast(params, fields)
2117 |> validate_required(fields)
2118 |> update_and_set_cache()
2121 defp set_domain_blocks(user, domain_blocks) do
2122 params = %{domain_blocks: domain_blocks}
2125 |> cast(params, [:domain_blocks])
2126 |> validate_required([:domain_blocks])
2127 |> update_and_set_cache()
2130 def block_domain(user, domain_blocked) do
2131 set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2134 def unblock_domain(user, domain_blocked) do
2135 set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2138 @spec add_to_block(User.t(), User.t()) ::
2139 {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2140 defp add_to_block(%User{} = user, %User{} = blocked) do
2141 UserRelationship.create_block(user, blocked)
2144 @spec add_to_block(User.t(), User.t()) ::
2145 {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2146 defp remove_from_block(%User{} = user, %User{} = blocked) do
2147 UserRelationship.delete_block(user, blocked)
2150 defp add_to_mutes(%User{} = user, %User{} = muted_user, notifications?) do
2151 with {:ok, user_mute} <- UserRelationship.create_mute(user, muted_user),
2152 {:ok, user_notification_mute} <-
2153 (notifications? && UserRelationship.create_notification_mute(user, muted_user)) ||
2155 {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
2159 defp remove_from_mutes(user, %User{} = muted_user) do
2160 with {:ok, user_mute} <- UserRelationship.delete_mute(user, muted_user),
2161 {:ok, user_notification_mute} <-
2162 UserRelationship.delete_notification_mute(user, muted_user) do
2163 {:ok, [user_mute, user_notification_mute]}
2167 def set_invisible(user, invisible) do
2168 params = %{invisible: invisible}
2171 |> cast(params, [:invisible])
2172 |> validate_required([:invisible])
2173 |> update_and_set_cache()
2176 def sanitize_html(%User{} = user) do
2177 sanitize_html(user, nil)
2180 # User data that mastodon isn't filtering (treated as plaintext):
2183 def sanitize_html(%User{} = user, filter) do
2187 |> Enum.map(fn %{"name" => name, "value" => value} ->
2190 "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2195 |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2196 |> Map.put(:fields, fields)