1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.User do
10 import Ecto, only: [assoc: 2]
13 alias Pleroma.Activity
15 alias Pleroma.Conversation.Participation
16 alias Pleroma.Delivery
17 alias Pleroma.EctoType.ActivityPub.ObjectValidators
19 alias Pleroma.FollowingRelationship
20 alias Pleroma.Formatter
24 alias Pleroma.Notification
26 alias Pleroma.Registration
28 alias Pleroma.RepoStreamer
30 alias Pleroma.UserRelationship
32 alias Pleroma.Web.ActivityPub.ActivityPub
33 alias Pleroma.Web.ActivityPub.Builder
34 alias Pleroma.Web.ActivityPub.Pipeline
35 alias Pleroma.Web.ActivityPub.Utils
36 alias Pleroma.Web.CommonAPI
37 alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
38 alias Pleroma.Web.OAuth
39 alias Pleroma.Web.RelMe
40 alias Pleroma.Workers.BackgroundWorker
44 @type t :: %__MODULE__{}
45 @type account_status :: :active | :deactivated | :password_reset_pending | :confirmation_pending
46 @primary_key {:id, FlakeId.Ecto.CompatType, autogenerate: true}
48 # credo:disable-for-next-line Credo.Check.Readability.MaxLineLength
49 @email_regex ~r/^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/
51 @strict_local_nickname_regex ~r/^[a-zA-Z\d]+$/
52 @extended_local_nickname_regex ~r/^[a-zA-Z\d_-]+$/
54 # AP ID user relationships (blocks, mutes etc.)
55 # Format: [rel_type: [outgoing_rel: :outgoing_rel_target, incoming_rel: :incoming_rel_source]]
56 @user_relationships_config [
58 blocker_blocks: :blocked_users,
59 blockee_blocks: :blocker_users
62 muter_mutes: :muted_users,
63 mutee_mutes: :muter_users
66 reblog_muter_mutes: :reblog_muted_users,
67 reblog_mutee_mutes: :reblog_muter_users
70 notification_muter_mutes: :notification_muted_users,
71 notification_mutee_mutes: :notification_muter_users
73 # Note: `inverse_subscription` relationship is inverse: subscriber acts as relationship target
74 inverse_subscription: [
75 subscribee_subscriptions: :subscriber_users,
76 subscriber_subscriptions: :subscribee_users
82 field(:raw_bio, :string)
83 field(:email, :string)
85 field(:nickname, :string)
86 field(:password_hash, :string)
87 field(:password, :string, virtual: true)
88 field(:password_confirmation, :string, virtual: true)
90 field(:public_key, :string)
91 field(:ap_id, :string)
92 field(:avatar, :map, default: %{})
93 field(:local, :boolean, default: true)
94 field(:follower_address, :string)
95 field(:following_address, :string)
96 field(:search_rank, :float, virtual: true)
97 field(:search_type, :integer, virtual: true)
98 field(:tags, {:array, :string}, default: [])
99 field(:last_refreshed_at, :naive_datetime_usec)
100 field(:last_digest_emailed_at, :naive_datetime)
101 field(:banner, :map, default: %{})
102 field(:background, :map, default: %{})
103 field(:note_count, :integer, default: 0)
104 field(:follower_count, :integer, default: 0)
105 field(:following_count, :integer, default: 0)
106 field(:locked, :boolean, default: false)
107 field(:confirmation_pending, :boolean, default: false)
108 field(:password_reset_pending, :boolean, default: false)
109 field(:confirmation_token, :string, default: nil)
110 field(:default_scope, :string, default: "public")
111 field(:domain_blocks, {:array, :string}, default: [])
112 field(:deactivated, :boolean, default: false)
113 field(:no_rich_text, :boolean, default: false)
114 field(:ap_enabled, :boolean, default: false)
115 field(:is_moderator, :boolean, default: false)
116 field(:is_admin, :boolean, default: false)
117 field(:show_role, :boolean, default: true)
118 field(:mastofe_settings, :map, default: nil)
119 field(:uri, ObjectValidators.Uri, default: nil)
120 field(:hide_followers_count, :boolean, default: false)
121 field(:hide_follows_count, :boolean, default: false)
122 field(:hide_followers, :boolean, default: false)
123 field(:hide_follows, :boolean, default: false)
124 field(:hide_favorites, :boolean, default: true)
125 field(:unread_conversation_count, :integer, default: 0)
126 field(:pinned_activities, {:array, :string}, default: [])
127 field(:email_notifications, :map, default: %{"digest" => false})
128 field(:mascot, :map, default: nil)
129 field(:emoji, :map, default: %{})
130 field(:pleroma_settings_store, :map, default: %{})
131 field(:fields, {:array, :map}, default: [])
132 field(:raw_fields, {:array, :map}, default: [])
133 field(:discoverable, :boolean, default: false)
134 field(:invisible, :boolean, default: false)
135 field(:allow_following_move, :boolean, default: true)
136 field(:skip_thread_containment, :boolean, default: false)
137 field(:actor_type, :string, default: "Person")
138 field(:also_known_as, {:array, :string}, default: [])
139 field(:inbox, :string)
140 field(:shared_inbox, :string)
141 field(:accepts_chat_messages, :boolean, default: nil)
144 :notification_settings,
145 Pleroma.User.NotificationSetting,
149 has_many(:notifications, Notification)
150 has_many(:registrations, Registration)
151 has_many(:deliveries, Delivery)
153 has_many(:outgoing_relationships, UserRelationship, foreign_key: :source_id)
154 has_many(:incoming_relationships, UserRelationship, foreign_key: :target_id)
156 for {relationship_type,
158 {outgoing_relation, outgoing_relation_target},
159 {incoming_relation, incoming_relation_source}
160 ]} <- @user_relationships_config do
161 # Definitions of `has_many` relations: :blocker_blocks, :muter_mutes, :reblog_muter_mutes,
162 # :notification_muter_mutes, :subscribee_subscriptions
163 has_many(outgoing_relation, UserRelationship,
164 foreign_key: :source_id,
165 where: [relationship_type: relationship_type]
168 # Definitions of `has_many` relations: :blockee_blocks, :mutee_mutes, :reblog_mutee_mutes,
169 # :notification_mutee_mutes, :subscriber_subscriptions
170 has_many(incoming_relation, UserRelationship,
171 foreign_key: :target_id,
172 where: [relationship_type: relationship_type]
175 # Definitions of `has_many` relations: :blocked_users, :muted_users, :reblog_muted_users,
176 # :notification_muted_users, :subscriber_users
177 has_many(outgoing_relation_target, through: [outgoing_relation, :target])
179 # Definitions of `has_many` relations: :blocker_users, :muter_users, :reblog_muter_users,
180 # :notification_muter_users, :subscribee_users
181 has_many(incoming_relation_source, through: [incoming_relation, :source])
184 # `:blocks` is deprecated (replaced with `blocked_users` relation)
185 field(:blocks, {:array, :string}, default: [])
186 # `:mutes` is deprecated (replaced with `muted_users` relation)
187 field(:mutes, {:array, :string}, default: [])
188 # `:muted_reblogs` is deprecated (replaced with `reblog_muted_users` relation)
189 field(:muted_reblogs, {:array, :string}, default: [])
190 # `:muted_notifications` is deprecated (replaced with `notification_muted_users` relation)
191 field(:muted_notifications, {:array, :string}, default: [])
192 # `:subscribers` is deprecated (replaced with `subscriber_users` relation)
193 field(:subscribers, {:array, :string}, default: [])
196 :multi_factor_authentication_settings,
204 for {_relationship_type, [{_outgoing_relation, outgoing_relation_target}, _]} <-
205 @user_relationships_config do
206 # `def blocked_users_relation/2`, `def muted_users_relation/2`,
207 # `def reblog_muted_users_relation/2`, `def notification_muted_users/2`,
208 # `def subscriber_users/2`
209 def unquote(:"#{outgoing_relation_target}_relation")(user, restrict_deactivated? \\ false) do
210 target_users_query = assoc(user, unquote(outgoing_relation_target))
212 if restrict_deactivated? do
213 restrict_deactivated(target_users_query)
219 # `def blocked_users/2`, `def muted_users/2`, `def reblog_muted_users/2`,
220 # `def notification_muted_users/2`, `def subscriber_users/2`
221 def unquote(outgoing_relation_target)(user, restrict_deactivated? \\ false) do
223 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
225 restrict_deactivated?
230 # `def blocked_users_ap_ids/2`, `def muted_users_ap_ids/2`, `def reblog_muted_users_ap_ids/2`,
231 # `def notification_muted_users_ap_ids/2`, `def subscriber_users_ap_ids/2`
232 def unquote(:"#{outgoing_relation_target}_ap_ids")(user, restrict_deactivated? \\ false) do
234 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
236 restrict_deactivated?
238 |> select([u], u.ap_id)
244 Dumps Flake Id to SQL-compatible format (16-byte UUID).
245 E.g. "9pQtDGXuq4p3VlcJEm" -> <<0, 0, 1, 110, 179, 218, 42, 92, 213, 41, 44, 227, 95, 213, 0, 0>>
247 def binary_id(source_id) when is_binary(source_id) do
248 with {:ok, dumped_id} <- FlakeId.Ecto.CompatType.dump(source_id) do
255 def binary_id(source_ids) when is_list(source_ids) do
256 Enum.map(source_ids, &binary_id/1)
259 def binary_id(%User{} = user), do: binary_id(user.id)
261 @doc "Returns status account"
262 @spec account_status(User.t()) :: account_status()
263 def account_status(%User{deactivated: true}), do: :deactivated
264 def account_status(%User{password_reset_pending: true}), do: :password_reset_pending
266 def account_status(%User{confirmation_pending: true}) do
267 if Config.get([:instance, :account_activation_required]) do
268 :confirmation_pending
274 def account_status(%User{}), do: :active
276 @spec visible_for(User.t(), User.t() | nil) ::
279 | :restricted_unauthenticated
281 | :confirmation_pending
282 def visible_for(user, for_user \\ nil)
284 def visible_for(%User{invisible: true}, _), do: :invisible
286 def visible_for(%User{id: user_id}, %User{id: user_id}), do: :visible
288 def visible_for(%User{} = user, nil) do
289 if restrict_unauthenticated?(user) do
290 :restrict_unauthenticated
292 visible_account_status(user)
296 def visible_for(%User{} = user, for_user) do
297 if superuser?(for_user) do
300 visible_account_status(user)
304 def visible_for(_, _), do: :invisible
306 defp restrict_unauthenticated?(%User{local: local}) do
307 config_key = if local, do: :local, else: :remote
309 Config.get([:restrict_unauthenticated, :profiles, config_key], false)
312 defp visible_account_status(user) do
313 status = account_status(user)
315 if status in [:active, :password_reset_pending] do
322 @spec superuser?(User.t()) :: boolean()
323 def superuser?(%User{local: true, is_admin: true}), do: true
324 def superuser?(%User{local: true, is_moderator: true}), do: true
325 def superuser?(_), do: false
327 @spec invisible?(User.t()) :: boolean()
328 def invisible?(%User{invisible: true}), do: true
329 def invisible?(_), do: false
331 def avatar_url(user, options \\ []) do
333 %{"url" => [%{"href" => href} | _]} ->
337 unless options[:no_default] do
338 Config.get([:assets, :default_user_avatar], "#{Web.base_url()}/images/avi.png")
343 def banner_url(user, options \\ []) do
345 %{"url" => [%{"href" => href} | _]} -> href
346 _ -> !options[:no_default] && "#{Web.base_url()}/images/banner.png"
350 # Should probably be renamed or removed
351 def ap_id(%User{nickname: nickname}), do: "#{Web.base_url()}/users/#{nickname}"
353 def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
354 def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"
356 @spec ap_following(User.t()) :: String.t()
357 def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
358 def ap_following(%User{} = user), do: "#{ap_id(user)}/following"
360 @spec restrict_deactivated(Ecto.Query.t()) :: Ecto.Query.t()
361 def restrict_deactivated(query) do
362 from(u in query, where: u.deactivated != ^true)
365 defdelegate following_count(user), to: FollowingRelationship
367 defp truncate_fields_param(params) do
368 if Map.has_key?(params, :fields) do
369 Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
375 defp truncate_if_exists(params, key, max_length) do
376 if Map.has_key?(params, key) and is_binary(params[key]) do
377 {value, _chopped} = String.split_at(params[key], max_length)
378 Map.put(params, key, value)
384 defp fix_follower_address(%{follower_address: _, following_address: _} = params), do: params
386 defp fix_follower_address(%{nickname: nickname} = params),
387 do: Map.put(params, :follower_address, ap_followers(%User{nickname: nickname}))
389 defp fix_follower_address(params), do: params
391 def remote_user_changeset(struct \\ %User{local: false}, params) do
392 bio_limit = Config.get([:instance, :user_bio_length], 5000)
393 name_limit = Config.get([:instance, :user_name_length], 100)
396 case params[:name] do
397 name when is_binary(name) and byte_size(name) > 0 -> name
398 _ -> params[:nickname]
403 |> Map.put(:name, name)
404 |> Map.put_new(:last_refreshed_at, NaiveDateTime.utc_now())
405 |> truncate_if_exists(:name, name_limit)
406 |> truncate_if_exists(:bio, bio_limit)
407 |> truncate_fields_param()
408 |> fix_follower_address()
432 :hide_followers_count,
441 :accepts_chat_messages
444 |> validate_required([:name, :ap_id])
445 |> unique_constraint(:nickname)
446 |> validate_format(:nickname, @email_regex)
447 |> validate_length(:bio, max: bio_limit)
448 |> validate_length(:name, max: name_limit)
449 |> validate_fields(true)
452 def update_changeset(struct, params \\ %{}) do
453 bio_limit = Config.get([:instance, :user_bio_length], 5000)
454 name_limit = Config.get([:instance, :user_name_length], 100)
474 :hide_followers_count,
477 :allow_following_move,
480 :skip_thread_containment,
483 :pleroma_settings_store,
487 :accepts_chat_messages
490 |> unique_constraint(:nickname)
491 |> validate_format(:nickname, local_nickname_regex())
492 |> validate_length(:bio, max: bio_limit)
493 |> validate_length(:name, min: 1, max: name_limit)
494 |> validate_inclusion(:actor_type, ["Person", "Service"])
497 |> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
498 |> put_change_if_present(:avatar, &put_upload(&1, :avatar))
499 |> put_change_if_present(:banner, &put_upload(&1, :banner))
500 |> put_change_if_present(:background, &put_upload(&1, :background))
501 |> put_change_if_present(
502 :pleroma_settings_store,
503 &{:ok, Map.merge(struct.pleroma_settings_store, &1)}
505 |> validate_fields(false)
508 defp put_fields(changeset) do
509 if raw_fields = get_change(changeset, :raw_fields) do
512 |> Enum.filter(fn %{"name" => n} -> n != "" end)
516 |> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)
519 |> put_change(:raw_fields, raw_fields)
520 |> put_change(:fields, fields)
526 defp parse_fields(value) do
528 |> Formatter.linkify(mentions_format: :full)
532 defp put_emoji(changeset) do
533 emojified_fields = [:bio, :name, :raw_fields]
535 if Enum.any?(changeset.changes, fn {k, _} -> k in emojified_fields end) do
536 bio = Emoji.Formatter.get_emoji_map(get_field(changeset, :bio))
537 name = Emoji.Formatter.get_emoji_map(get_field(changeset, :name))
539 emoji = Map.merge(bio, name)
543 |> get_field(:raw_fields)
544 |> Enum.reduce(emoji, fn x, acc ->
545 Map.merge(acc, Emoji.Formatter.get_emoji_map(x["name"] <> x["value"]))
548 put_change(changeset, :emoji, emoji)
554 defp put_change_if_present(changeset, map_field, value_function) do
555 with {:ok, value} <- fetch_change(changeset, map_field),
556 {:ok, new_value} <- value_function.(value) do
557 put_change(changeset, map_field, new_value)
563 defp put_upload(value, type) do
564 with %Plug.Upload{} <- value,
565 {:ok, object} <- ActivityPub.upload(value, type: type) do
570 def update_as_admin_changeset(struct, params) do
572 |> update_changeset(params)
573 |> cast(params, [:email])
574 |> delete_change(:also_known_as)
575 |> unique_constraint(:email)
576 |> validate_format(:email, @email_regex)
577 |> validate_inclusion(:actor_type, ["Person", "Service"])
580 @spec update_as_admin(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
581 def update_as_admin(user, params) do
582 params = Map.put(params, "password_confirmation", params["password"])
583 changeset = update_as_admin_changeset(user, params)
585 if params["password"] do
586 reset_password(user, changeset, params)
588 User.update_and_set_cache(changeset)
592 def password_update_changeset(struct, params) do
594 |> cast(params, [:password, :password_confirmation])
595 |> validate_required([:password, :password_confirmation])
596 |> validate_confirmation(:password)
597 |> put_password_hash()
598 |> put_change(:password_reset_pending, false)
601 @spec reset_password(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
602 def reset_password(%User{} = user, params) do
603 reset_password(user, user, params)
606 def reset_password(%User{id: user_id} = user, struct, params) do
609 |> Multi.update(:user, password_update_changeset(struct, params))
610 |> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
611 |> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))
613 case Repo.transaction(multi) do
614 {:ok, %{user: user} = _} -> set_cache(user)
615 {:error, _, changeset, _} -> {:error, changeset}
619 def update_password_reset_pending(user, value) do
622 |> put_change(:password_reset_pending, value)
623 |> update_and_set_cache()
626 def force_password_reset_async(user) do
627 BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
630 @spec force_password_reset(User.t()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
631 def force_password_reset(user), do: update_password_reset_pending(user, true)
633 def register_changeset(struct, params \\ %{}, opts \\ []) do
634 bio_limit = Config.get([:instance, :user_bio_length], 5000)
635 name_limit = Config.get([:instance, :user_name_length], 100)
636 params = Map.put_new(params, :accepts_chat_messages, true)
639 if is_nil(opts[:need_confirmation]) do
640 Config.get([:instance, :account_activation_required])
642 opts[:need_confirmation]
646 |> confirmation_changeset(need_confirmation: need_confirmation?)
654 :password_confirmation,
656 :accepts_chat_messages
658 |> validate_required([:name, :nickname, :password, :password_confirmation])
659 |> validate_confirmation(:password)
660 |> unique_constraint(:email)
661 |> unique_constraint(:nickname)
662 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
663 |> validate_format(:nickname, local_nickname_regex())
664 |> validate_format(:email, @email_regex)
665 |> validate_length(:bio, max: bio_limit)
666 |> validate_length(:name, min: 1, max: name_limit)
667 |> maybe_validate_required_email(opts[:external])
670 |> unique_constraint(:ap_id)
671 |> put_following_and_follower_address()
674 def maybe_validate_required_email(changeset, true), do: changeset
676 def maybe_validate_required_email(changeset, _) do
677 if Config.get([:instance, :account_activation_required]) do
678 validate_required(changeset, [:email])
684 defp put_ap_id(changeset) do
685 ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
686 put_change(changeset, :ap_id, ap_id)
689 defp put_following_and_follower_address(changeset) do
690 followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
693 |> put_change(:follower_address, followers)
696 defp autofollow_users(user) do
697 candidates = Config.get([:instance, :autofollowed_nicknames])
700 User.Query.build(%{nickname: candidates, local: true, deactivated: false})
703 follow_all(user, autofollowed_users)
706 @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
707 def register(%Ecto.Changeset{} = changeset) do
708 with {:ok, user} <- Repo.insert(changeset) do
709 post_register_action(user)
713 def post_register_action(%User{} = user) do
714 with {:ok, user} <- autofollow_users(user),
715 {:ok, user} <- set_cache(user),
716 {:ok, _} <- User.WelcomeMessage.post_welcome_message_to_user(user),
717 {:ok, _} <- try_send_confirmation_email(user) do
722 @spec try_send_confirmation_email(User.t()) :: {:ok, :enqueued | :noop}
723 def try_send_confirmation_email(%User{confirmation_pending: true} = user) do
724 if Config.get([:instance, :account_activation_required]) do
725 send_confirmation_email(user)
732 def try_send_confirmation_email(_), do: {:ok, :noop}
734 @spec send_confirmation_email(Uset.t()) :: User.t()
735 def send_confirmation_email(%User{} = user) do
737 |> Pleroma.Emails.UserEmail.account_confirmation_email()
738 |> Pleroma.Emails.Mailer.deliver_async()
743 def needs_update?(%User{local: true}), do: false
745 def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
747 def needs_update?(%User{local: false} = user) do
748 NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
751 def needs_update?(_), do: true
753 @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
755 # "Locked" (self-locked) users demand explicit authorization of follow requests
756 def maybe_direct_follow(%User{} = follower, %User{local: true, locked: true} = followed) do
757 follow(follower, followed, :follow_pending)
760 def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
761 follow(follower, followed)
764 def maybe_direct_follow(%User{} = follower, %User{} = followed) do
765 if not ap_enabled?(followed) do
766 follow(follower, followed)
772 @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
773 @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
774 def follow_all(follower, followeds) do
776 |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
777 |> Enum.each(&follow(follower, &1, :follow_accept))
782 defdelegate following(user), to: FollowingRelationship
784 def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
785 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
788 followed.deactivated ->
789 {:error, "Could not follow user: #{followed.nickname} is deactivated."}
791 deny_follow_blocked and blocks?(followed, follower) ->
792 {:error, "Could not follow user: #{followed.nickname} blocked you."}
795 FollowingRelationship.follow(follower, followed, state)
797 {:ok, _} = update_follower_count(followed)
800 |> update_following_count()
804 def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
805 {:error, "Not subscribed!"}
808 @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
809 def unfollow(%User{} = follower, %User{} = followed) do
810 case do_unfollow(follower, followed) do
811 {:ok, follower, followed} ->
812 {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
819 @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
820 defp do_unfollow(%User{} = follower, %User{} = followed) do
821 case get_follow_state(follower, followed) do
822 state when state in [:follow_pending, :follow_accept] ->
823 FollowingRelationship.unfollow(follower, followed)
824 {:ok, followed} = update_follower_count(followed)
828 |> update_following_count()
830 {:ok, follower, followed}
833 {:error, "Not subscribed!"}
837 defdelegate following?(follower, followed), to: FollowingRelationship
839 @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
840 def get_follow_state(%User{} = follower, %User{} = following) do
841 following_relationship = FollowingRelationship.get(follower, following)
842 get_follow_state(follower, following, following_relationship)
845 def get_follow_state(
848 following_relationship
850 case {following_relationship, following.local} do
852 case Utils.fetch_latest_follow(follower, following) do
853 %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
854 FollowingRelationship.state_to_enum(state)
860 {%{state: state}, _} ->
868 def locked?(%User{} = user) do
873 Repo.get_by(User, id: id)
876 def get_by_ap_id(ap_id) do
877 Repo.get_by(User, ap_id: ap_id)
880 def get_all_by_ap_id(ap_ids) do
881 from(u in __MODULE__,
882 where: u.ap_id in ^ap_ids
887 def get_all_by_ids(ids) do
888 from(u in __MODULE__, where: u.id in ^ids)
892 # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
893 # of the ap_id and the domain and tries to get that user
894 def get_by_guessed_nickname(ap_id) do
895 domain = URI.parse(ap_id).host
896 name = List.last(String.split(ap_id, "/"))
897 nickname = "#{name}@#{domain}"
899 get_cached_by_nickname(nickname)
902 def set_cache({:ok, user}), do: set_cache(user)
903 def set_cache({:error, err}), do: {:error, err}
905 def set_cache(%User{} = user) do
906 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
907 Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
908 Cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
912 def update_and_set_cache(struct, params) do
914 |> update_changeset(params)
915 |> update_and_set_cache()
918 def update_and_set_cache(changeset) do
919 with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
924 def get_user_friends_ap_ids(user) do
925 from(u in User.get_friends_query(user), select: u.ap_id)
929 @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
930 def get_cached_user_friends_ap_ids(user) do
931 Cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
932 get_user_friends_ap_ids(user)
936 def invalidate_cache(user) do
937 Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
938 Cachex.del(:user_cache, "nickname:#{user.nickname}")
939 Cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
942 @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
943 def get_cached_by_ap_id(ap_id) do
944 key = "ap_id:#{ap_id}"
946 with {:ok, nil} <- Cachex.get(:user_cache, key),
947 user when not is_nil(user) <- get_by_ap_id(ap_id),
948 {:ok, true} <- Cachex.put(:user_cache, key, user) do
956 def get_cached_by_id(id) do
960 Cachex.fetch!(:user_cache, key, fn _ ->
964 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
965 {:commit, user.ap_id}
971 get_cached_by_ap_id(ap_id)
974 def get_cached_by_nickname(nickname) do
975 key = "nickname:#{nickname}"
977 Cachex.fetch!(:user_cache, key, fn ->
978 case get_or_fetch_by_nickname(nickname) do
979 {:ok, user} -> {:commit, user}
980 {:error, _error} -> {:ignore, nil}
985 def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
986 restrict_to_local = Config.get([:instance, :limit_to_local_content])
989 is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
990 get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
992 restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
993 get_cached_by_nickname(nickname_or_id)
995 restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
996 get_cached_by_nickname(nickname_or_id)
1003 @spec get_by_nickname(String.t()) :: User.t() | nil
1004 def get_by_nickname(nickname) do
1005 Repo.get_by(User, nickname: nickname) ||
1006 if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
1007 Repo.get_by(User, nickname: local_nickname(nickname))
1011 def get_by_email(email), do: Repo.get_by(User, email: email)
1013 def get_by_nickname_or_email(nickname_or_email) do
1014 get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
1017 def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
1019 def get_or_fetch_by_nickname(nickname) do
1020 with %User{} = user <- get_by_nickname(nickname) do
1024 with [_nick, _domain] <- String.split(nickname, "@"),
1025 {:ok, user} <- fetch_by_nickname(nickname) do
1028 _e -> {:error, "not found " <> nickname}
1033 @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1034 def get_followers_query(%User{} = user, nil) do
1035 User.Query.build(%{followers: user, deactivated: false})
1038 def get_followers_query(user, page) do
1040 |> get_followers_query(nil)
1041 |> User.Query.paginate(page, 20)
1044 @spec get_followers_query(User.t()) :: Ecto.Query.t()
1045 def get_followers_query(user), do: get_followers_query(user, nil)
1047 @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1048 def get_followers(user, page \\ nil) do
1050 |> get_followers_query(page)
1054 @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1055 def get_external_followers(user, page \\ nil) do
1057 |> get_followers_query(page)
1058 |> User.Query.build(%{external: true})
1062 def get_followers_ids(user, page \\ nil) do
1064 |> get_followers_query(page)
1065 |> select([u], u.id)
1069 @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1070 def get_friends_query(%User{} = user, nil) do
1071 User.Query.build(%{friends: user, deactivated: false})
1074 def get_friends_query(user, page) do
1076 |> get_friends_query(nil)
1077 |> User.Query.paginate(page, 20)
1080 @spec get_friends_query(User.t()) :: Ecto.Query.t()
1081 def get_friends_query(user), do: get_friends_query(user, nil)
1083 def get_friends(user, page \\ nil) do
1085 |> get_friends_query(page)
1089 def get_friends_ap_ids(user) do
1091 |> get_friends_query(nil)
1092 |> select([u], u.ap_id)
1096 def get_friends_ids(user, page \\ nil) do
1098 |> get_friends_query(page)
1099 |> select([u], u.id)
1103 defdelegate get_follow_requests(user), to: FollowingRelationship
1105 def increase_note_count(%User{} = user) do
1107 |> where(id: ^user.id)
1108 |> update([u], inc: [note_count: 1])
1110 |> Repo.update_all([])
1112 {1, [user]} -> set_cache(user)
1117 def decrease_note_count(%User{} = user) do
1119 |> where(id: ^user.id)
1122 note_count: fragment("greatest(0, note_count - 1)")
1126 |> Repo.update_all([])
1128 {1, [user]} -> set_cache(user)
1133 def update_note_count(%User{} = user, note_count \\ nil) do
1138 where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1144 |> cast(%{note_count: note_count}, [:note_count])
1145 |> update_and_set_cache()
1148 @spec maybe_fetch_follow_information(User.t()) :: User.t()
1149 def maybe_fetch_follow_information(user) do
1150 with {:ok, user} <- fetch_follow_information(user) do
1154 Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1160 def fetch_follow_information(user) do
1161 with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1163 |> follow_information_changeset(info)
1164 |> update_and_set_cache()
1168 defp follow_information_changeset(user, params) do
1175 :hide_followers_count,
1180 @spec update_follower_count(User.t()) :: {:ok, User.t()}
1181 def update_follower_count(%User{} = user) do
1182 if user.local or !Config.get([:instance, :external_user_synchronization]) do
1183 follower_count = FollowingRelationship.follower_count(user)
1186 |> follow_information_changeset(%{follower_count: follower_count})
1187 |> update_and_set_cache
1189 {:ok, maybe_fetch_follow_information(user)}
1193 @spec update_following_count(User.t()) :: {:ok, User.t()}
1194 def update_following_count(%User{local: false} = user) do
1195 if Config.get([:instance, :external_user_synchronization]) do
1196 {:ok, maybe_fetch_follow_information(user)}
1202 def update_following_count(%User{local: true} = user) do
1203 following_count = FollowingRelationship.following_count(user)
1206 |> follow_information_changeset(%{following_count: following_count})
1207 |> update_and_set_cache()
1210 def set_unread_conversation_count(%User{local: true} = user) do
1211 unread_query = Participation.unread_conversation_count_for_user(user)
1214 |> join(:inner, [u], p in subquery(unread_query))
1216 set: [unread_conversation_count: p.count]
1218 |> where([u], u.id == ^user.id)
1220 |> Repo.update_all([])
1222 {1, [user]} -> set_cache(user)
1227 def set_unread_conversation_count(user), do: {:ok, user}
1229 def increment_unread_conversation_count(conversation, %User{local: true} = user) do
1231 Participation.unread_conversation_count_for_user(user)
1232 |> where([p], p.conversation_id == ^conversation.id)
1235 |> join(:inner, [u], p in subquery(unread_query))
1237 inc: [unread_conversation_count: 1]
1239 |> where([u], u.id == ^user.id)
1240 |> where([u, p], p.count == 0)
1242 |> Repo.update_all([])
1244 {1, [user]} -> set_cache(user)
1249 def increment_unread_conversation_count(_, user), do: {:ok, user}
1251 @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1252 def get_users_from_set(ap_ids, opts \\ []) do
1253 local_only = Keyword.get(opts, :local_only, true)
1254 criteria = %{ap_id: ap_ids, deactivated: false}
1255 criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1257 User.Query.build(criteria)
1261 @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1262 def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1265 query = User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
1271 @spec mute(User.t(), User.t(), boolean()) ::
1272 {:ok, list(UserRelationship.t())} | {:error, String.t()}
1273 def mute(%User{} = muter, %User{} = mutee, notifications? \\ true) do
1274 add_to_mutes(muter, mutee, notifications?)
1277 def unmute(%User{} = muter, %User{} = mutee) do
1278 remove_from_mutes(muter, mutee)
1281 def subscribe(%User{} = subscriber, %User{} = target) do
1282 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
1284 if blocks?(target, subscriber) and deny_follow_blocked do
1285 {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1287 # Note: the relationship is inverse: subscriber acts as relationship target
1288 UserRelationship.create_inverse_subscription(target, subscriber)
1292 def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1293 with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1294 subscribe(subscriber, subscribee)
1298 def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1299 # Note: the relationship is inverse: subscriber acts as relationship target
1300 UserRelationship.delete_inverse_subscription(target, unsubscriber)
1303 def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1304 with %User{} = user <- get_cached_by_ap_id(ap_id) do
1305 unsubscribe(unsubscriber, user)
1309 def block(%User{} = blocker, %User{} = blocked) do
1310 # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1312 if following?(blocker, blocked) do
1313 {:ok, blocker, _} = unfollow(blocker, blocked)
1319 # clear any requested follows as well
1321 case CommonAPI.reject_follow_request(blocked, blocker) do
1322 {:ok, %User{} = updated_blocked} -> updated_blocked
1326 unsubscribe(blocked, blocker)
1328 unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
1329 if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)
1331 {:ok, blocker} = update_follower_count(blocker)
1332 {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1333 add_to_block(blocker, blocked)
1336 # helper to handle the block given only an actor's AP id
1337 def block(%User{} = blocker, %{ap_id: ap_id}) do
1338 block(blocker, get_cached_by_ap_id(ap_id))
1341 def unblock(%User{} = blocker, %User{} = blocked) do
1342 remove_from_block(blocker, blocked)
1345 # helper to handle the block given only an actor's AP id
1346 def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1347 unblock(blocker, get_cached_by_ap_id(ap_id))
1350 def mutes?(nil, _), do: false
1351 def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1353 def mutes_user?(%User{} = user, %User{} = target) do
1354 UserRelationship.mute_exists?(user, target)
1357 @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1358 def muted_notifications?(nil, _), do: false
1360 def muted_notifications?(%User{} = user, %User{} = target),
1361 do: UserRelationship.notification_mute_exists?(user, target)
1363 def blocks?(nil, _), do: false
1365 def blocks?(%User{} = user, %User{} = target) do
1366 blocks_user?(user, target) ||
1367 (blocks_domain?(user, target) and not User.following?(user, target))
1370 def blocks_user?(%User{} = user, %User{} = target) do
1371 UserRelationship.block_exists?(user, target)
1374 def blocks_user?(_, _), do: false
1376 def blocks_domain?(%User{} = user, %User{} = target) do
1377 domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1378 %{host: host} = URI.parse(target.ap_id)
1379 Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1382 def blocks_domain?(_, _), do: false
1384 def subscribed_to?(%User{} = user, %User{} = target) do
1385 # Note: the relationship is inverse: subscriber acts as relationship target
1386 UserRelationship.inverse_subscription_exists?(target, user)
1389 def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1390 with %User{} = target <- get_cached_by_ap_id(ap_id) do
1391 subscribed_to?(user, target)
1396 Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1397 E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1399 @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1400 def outgoing_relationships_ap_ids(_user, []), do: %{}
1402 def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1404 def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1405 when is_list(relationship_types) do
1408 |> assoc(:outgoing_relationships)
1409 |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1410 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1411 |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1412 |> group_by([user_rel, u], user_rel.relationship_type)
1414 |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1419 fn rel_type -> {rel_type, db_result[rel_type] || []} end
1423 def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1425 def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1427 def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1429 def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1430 when is_list(relationship_types) do
1432 |> assoc(:incoming_relationships)
1433 |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1434 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1435 |> maybe_filter_on_ap_id(ap_ids)
1436 |> select([user_rel, u], u.ap_id)
1441 defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1442 where(query, [user_rel, u], u.ap_id in ^ap_ids)
1445 defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1447 def deactivate_async(user, status \\ true) do
1448 BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
1451 def deactivate(user, status \\ true)
1453 def deactivate(users, status) when is_list(users) do
1454 Repo.transaction(fn ->
1455 for user <- users, do: deactivate(user, status)
1459 def deactivate(%User{} = user, status) do
1460 with {:ok, user} <- set_activation_status(user, status) do
1463 |> Enum.filter(& &1.local)
1464 |> Enum.each(&set_cache(update_following_count(&1)))
1466 # Only update local user counts, remote will be update during the next pull.
1469 |> Enum.filter(& &1.local)
1470 |> Enum.each(&do_unfollow(user, &1))
1476 def update_notification_settings(%User{} = user, settings) do
1478 |> cast(%{notification_settings: settings}, [])
1479 |> cast_embed(:notification_settings)
1480 |> validate_required([:notification_settings])
1481 |> update_and_set_cache()
1484 def delete(users) when is_list(users) do
1485 for user <- users, do: delete(user)
1488 def delete(%User{} = user) do
1489 BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1492 defp delete_and_invalidate_cache(%User{} = user) do
1493 invalidate_cache(user)
1497 defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)
1499 defp delete_or_deactivate(%User{local: true} = user) do
1500 status = account_status(user)
1502 if status == :confirmation_pending do
1503 delete_and_invalidate_cache(user)
1506 |> change(%{deactivated: true, email: nil})
1507 |> update_and_set_cache()
1511 def perform(:force_password_reset, user), do: force_password_reset(user)
1513 @spec perform(atom(), User.t()) :: {:ok, User.t()}
1514 def perform(:delete, %User{} = user) do
1515 # Remove all relationships
1518 |> Enum.each(fn follower ->
1519 ActivityPub.unfollow(follower, user)
1520 unfollow(follower, user)
1525 |> Enum.each(fn followed ->
1526 ActivityPub.unfollow(user, followed)
1527 unfollow(user, followed)
1530 delete_user_activities(user)
1531 delete_notifications_from_user_activities(user)
1533 delete_outgoing_pending_follow_requests(user)
1535 delete_or_deactivate(user)
1538 def perform(:deactivate_async, user, status), do: deactivate(user, status)
1540 @spec perform(atom(), User.t(), list()) :: list() | {:error, any()}
1541 def perform(:blocks_import, %User{} = blocker, blocked_identifiers)
1542 when is_list(blocked_identifiers) do
1544 blocked_identifiers,
1545 fn blocked_identifier ->
1546 with {:ok, %User{} = blocked} <- get_or_fetch(blocked_identifier),
1547 {:ok, _block} <- CommonAPI.block(blocker, blocked) do
1551 Logger.debug("blocks_import failed for #{blocked_identifier} with: #{inspect(err)}")
1558 def perform(:follow_import, %User{} = follower, followed_identifiers)
1559 when is_list(followed_identifiers) do
1561 followed_identifiers,
1562 fn followed_identifier ->
1563 with {:ok, %User{} = followed} <- get_or_fetch(followed_identifier),
1564 {:ok, follower} <- maybe_direct_follow(follower, followed),
1565 {:ok, _, _, _} <- CommonAPI.follow(follower, followed) do
1569 Logger.debug("follow_import failed for #{followed_identifier} with: #{inspect(err)}")
1576 @spec external_users_query() :: Ecto.Query.t()
1577 def external_users_query do
1585 @spec external_users(keyword()) :: [User.t()]
1586 def external_users(opts \\ []) do
1588 external_users_query()
1589 |> select([u], struct(u, [:id, :ap_id]))
1593 do: where(query, [u], u.id > ^opts[:max_id]),
1598 do: limit(query, ^opts[:limit]),
1604 def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers) do
1605 BackgroundWorker.enqueue("blocks_import", %{
1606 "blocker_id" => blocker.id,
1607 "blocked_identifiers" => blocked_identifiers
1611 def follow_import(%User{} = follower, followed_identifiers)
1612 when is_list(followed_identifiers) do
1613 BackgroundWorker.enqueue("follow_import", %{
1614 "follower_id" => follower.id,
1615 "followed_identifiers" => followed_identifiers
1619 def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1621 |> join(:inner, [n], activity in assoc(n, :activity))
1622 |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1623 |> Repo.delete_all()
1626 def delete_user_activities(%User{ap_id: ap_id} = user) do
1628 |> Activity.Queries.by_actor()
1629 |> RepoStreamer.chunk_stream(50)
1630 |> Stream.each(fn activities ->
1631 Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1636 defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1637 with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1638 {:ok, delete_data, _} <- Builder.delete(user, object) do
1639 Pipeline.common_pipeline(delete_data, local: user.local)
1641 {:find_object, nil} ->
1642 # We have the create activity, but not the object, it was probably pruned.
1643 # Insert a tombstone and try again
1644 with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1645 {:ok, _tombstone} <- Object.create(tombstone_data) do
1646 delete_activity(activity, user)
1650 Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1651 Logger.error("Error: #{inspect(e)}")
1655 defp delete_activity(%{data: %{"type" => type}} = activity, user)
1656 when type in ["Like", "Announce"] do
1657 {:ok, undo, _} = Builder.undo(user, activity)
1658 Pipeline.common_pipeline(undo, local: user.local)
1661 defp delete_activity(_activity, _user), do: "Doing nothing"
1663 defp delete_outgoing_pending_follow_requests(user) do
1665 |> FollowingRelationship.outgoing_pending_follow_requests_query()
1666 |> Repo.delete_all()
1669 def html_filter_policy(%User{no_rich_text: true}) do
1670 Pleroma.HTML.Scrubber.TwitterText
1673 def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])
1675 def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1677 def get_or_fetch_by_ap_id(ap_id) do
1678 cached_user = get_cached_by_ap_id(ap_id)
1680 maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)
1682 case {cached_user, maybe_fetched_user} do
1683 {_, {:ok, %User{} = user}} ->
1686 {%User{} = user, _} ->
1690 {:error, :not_found}
1695 Creates an internal service actor by URI if missing.
1696 Optionally takes nickname for addressing.
1698 @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1699 def get_or_create_service_actor_by_ap_id(uri, nickname) do
1701 case get_cached_by_ap_id(uri) do
1703 with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1704 Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1708 %User{invisible: false} = user ->
1718 @spec set_invisible(User.t()) :: {:ok, User.t()}
1719 defp set_invisible(user) do
1721 |> change(%{invisible: true})
1722 |> update_and_set_cache()
1725 @spec create_service_actor(String.t(), String.t()) ::
1726 {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1727 defp create_service_actor(uri, nickname) do
1733 follower_address: uri <> "/followers"
1736 |> unique_constraint(:nickname)
1741 def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1744 |> :public_key.pem_decode()
1746 |> :public_key.pem_entry_decode()
1751 def public_key(_), do: {:error, "key not found"}
1753 def get_public_key_for_ap_id(ap_id) do
1754 with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1755 {:ok, public_key} <- public_key(user) do
1762 def ap_enabled?(%User{local: true}), do: true
1763 def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1764 def ap_enabled?(_), do: false
1766 @doc "Gets or fetch a user by uri or nickname."
1767 @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1768 def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1769 def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1771 # wait a period of time and return newest version of the User structs
1772 # this is because we have synchronous follow APIs and need to simulate them
1773 # with an async handshake
1774 def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1775 with %User{} = a <- get_cached_by_id(a.id),
1776 %User{} = b <- get_cached_by_id(b.id) do
1783 def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1784 with :ok <- :timer.sleep(timeout),
1785 %User{} = a <- get_cached_by_id(a.id),
1786 %User{} = b <- get_cached_by_id(b.id) do
1793 def parse_bio(bio) when is_binary(bio) and bio != "" do
1795 |> CommonUtils.format_input("text/plain", mentions_format: :full)
1799 def parse_bio(_), do: ""
1801 def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1802 # TODO: get profile URLs other than user.ap_id
1803 profile_urls = [user.ap_id]
1806 |> CommonUtils.format_input("text/plain",
1807 mentions_format: :full,
1808 rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1813 def parse_bio(_, _), do: ""
1815 def tag(user_identifiers, tags) when is_list(user_identifiers) do
1816 Repo.transaction(fn ->
1817 for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1821 def tag(nickname, tags) when is_binary(nickname),
1822 do: tag(get_by_nickname(nickname), tags)
1824 def tag(%User{} = user, tags),
1825 do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1827 def untag(user_identifiers, tags) when is_list(user_identifiers) do
1828 Repo.transaction(fn ->
1829 for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1833 def untag(nickname, tags) when is_binary(nickname),
1834 do: untag(get_by_nickname(nickname), tags)
1836 def untag(%User{} = user, tags),
1837 do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1839 defp update_tags(%User{} = user, new_tags) do
1840 {:ok, updated_user} =
1842 |> change(%{tags: new_tags})
1843 |> update_and_set_cache()
1848 defp normalize_tags(tags) do
1851 |> Enum.map(&String.downcase/1)
1854 defp local_nickname_regex do
1855 if Config.get([:instance, :extended_nickname_format]) do
1856 @extended_local_nickname_regex
1858 @strict_local_nickname_regex
1862 def local_nickname(nickname_or_mention) do
1865 |> String.split("@")
1869 def full_nickname(nickname_or_mention),
1870 do: String.trim_leading(nickname_or_mention, "@")
1872 def error_user(ap_id) do
1876 nickname: "erroruser@example.com",
1877 inserted_at: NaiveDateTime.utc_now()
1881 @spec all_superusers() :: [User.t()]
1882 def all_superusers do
1883 User.Query.build(%{super_users: true, local: true, deactivated: false})
1887 def muting_reblogs?(%User{} = user, %User{} = target) do
1888 UserRelationship.reblog_mute_exists?(user, target)
1891 def showing_reblogs?(%User{} = user, %User{} = target) do
1892 not muting_reblogs?(user, target)
1896 The function returns a query to get users with no activity for given interval of days.
1897 Inactive users are those who didn't read any notification, or had any activity where
1898 the user is the activity's actor, during `inactivity_threshold` days.
1899 Deactivated users will not appear in this list.
1903 iex> Pleroma.User.list_inactive_users()
1906 @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
1907 def list_inactive_users_query(inactivity_threshold \\ 7) do
1908 negative_inactivity_threshold = -inactivity_threshold
1909 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
1910 # Subqueries are not supported in `where` clauses, join gets too complicated.
1911 has_read_notifications =
1912 from(n in Pleroma.Notification,
1913 where: n.seen == true,
1915 having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
1918 |> Pleroma.Repo.all()
1920 from(u in Pleroma.User,
1921 left_join: a in Pleroma.Activity,
1922 on: u.ap_id == a.actor,
1923 where: not is_nil(u.nickname),
1924 where: u.deactivated != ^true,
1925 where: u.id not in ^has_read_notifications,
1928 max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
1929 is_nil(max(a.inserted_at))
1934 Enable or disable email notifications for user
1938 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
1939 Pleroma.User{email_notifications: %{"digest" => true}}
1941 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
1942 Pleroma.User{email_notifications: %{"digest" => false}}
1944 @spec switch_email_notifications(t(), String.t(), boolean()) ::
1945 {:ok, t()} | {:error, Ecto.Changeset.t()}
1946 def switch_email_notifications(user, type, status) do
1947 User.update_email_notifications(user, %{type => status})
1951 Set `last_digest_emailed_at` value for the user to current time
1953 @spec touch_last_digest_emailed_at(t()) :: t()
1954 def touch_last_digest_emailed_at(user) do
1955 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
1957 {:ok, updated_user} =
1959 |> change(%{last_digest_emailed_at: now})
1960 |> update_and_set_cache()
1965 @spec toggle_confirmation(User.t()) :: {:ok, User.t()} | {:error, Changeset.t()}
1966 def toggle_confirmation(%User{} = user) do
1968 |> confirmation_changeset(need_confirmation: !user.confirmation_pending)
1969 |> update_and_set_cache()
1972 @spec toggle_confirmation([User.t()]) :: [{:ok, User.t()} | {:error, Changeset.t()}]
1973 def toggle_confirmation(users) do
1974 Enum.map(users, &toggle_confirmation/1)
1977 def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
1981 def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
1982 # use instance-default
1983 config = Config.get([:assets, :mascots])
1984 default_mascot = Config.get([:assets, :default_mascot])
1985 mascot = Keyword.get(config, default_mascot)
1988 "id" => "default-mascot",
1989 "url" => mascot[:url],
1990 "preview_url" => mascot[:url],
1992 "mime_type" => mascot[:mime_type]
1997 def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
1999 def ensure_keys_present(%User{} = user) do
2000 with {:ok, pem} <- Keys.generate_rsa_pem() do
2002 |> cast(%{keys: pem}, [:keys])
2003 |> validate_required([:keys])
2004 |> update_and_set_cache()
2008 def get_ap_ids_by_nicknames(nicknames) do
2010 where: u.nickname in ^nicknames,
2016 defdelegate search(query, opts \\ []), to: User.Search
2018 defp put_password_hash(
2019 %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2021 change(changeset, password_hash: Pbkdf2.hash_pwd_salt(password))
2024 defp put_password_hash(changeset), do: changeset
2026 def is_internal_user?(%User{nickname: nil}), do: true
2027 def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2028 def is_internal_user?(_), do: false
2030 # A hack because user delete activities have a fake id for whatever reason
2031 # TODO: Get rid of this
2032 def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2034 def get_delivered_users_by_object_id(object_id) do
2036 inner_join: delivery in assoc(u, :deliveries),
2037 where: delivery.object_id == ^object_id
2042 def change_email(user, email) do
2044 |> cast(%{email: email}, [:email])
2045 |> validate_required([:email])
2046 |> unique_constraint(:email)
2047 |> validate_format(:email, @email_regex)
2048 |> update_and_set_cache()
2051 # Internal function; public one is `deactivate/2`
2052 defp set_activation_status(user, deactivated) do
2054 |> cast(%{deactivated: deactivated}, [:deactivated])
2055 |> update_and_set_cache()
2058 def update_banner(user, banner) do
2060 |> cast(%{banner: banner}, [:banner])
2061 |> update_and_set_cache()
2064 def update_background(user, background) do
2066 |> cast(%{background: background}, [:background])
2067 |> update_and_set_cache()
2070 def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
2073 moderator: is_moderator
2077 def validate_fields(changeset, remote? \\ false) do
2078 limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2079 limit = Config.get([:instance, limit_name], 0)
2082 |> validate_length(:fields, max: limit)
2083 |> validate_change(:fields, fn :fields, fields ->
2084 if Enum.all?(fields, &valid_field?/1) do
2092 defp valid_field?(%{"name" => name, "value" => value}) do
2093 name_limit = Config.get([:instance, :account_field_name_length], 255)
2094 value_limit = Config.get([:instance, :account_field_value_length], 255)
2096 is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2097 String.length(value) <= value_limit
2100 defp valid_field?(_), do: false
2102 defp truncate_field(%{"name" => name, "value" => value}) do
2104 String.split_at(name, Config.get([:instance, :account_field_name_length], 255))
2107 String.split_at(value, Config.get([:instance, :account_field_value_length], 255))
2109 %{"name" => name, "value" => value}
2112 def admin_api_update(user, params) do
2119 |> update_and_set_cache()
2122 @doc "Signs user out of all applications"
2123 def global_sign_out(user) do
2124 OAuth.Authorization.delete_user_authorizations(user)
2125 OAuth.Token.delete_user_tokens(user)
2128 def mascot_update(user, url) do
2130 |> cast(%{mascot: url}, [:mascot])
2131 |> validate_required([:mascot])
2132 |> update_and_set_cache()
2135 def mastodon_settings_update(user, settings) do
2137 |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
2138 |> validate_required([:mastofe_settings])
2139 |> update_and_set_cache()
2142 @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2143 def confirmation_changeset(user, need_confirmation: need_confirmation?) do
2145 if need_confirmation? do
2147 confirmation_pending: true,
2148 confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2152 confirmation_pending: false,
2153 confirmation_token: nil
2157 cast(user, params, [:confirmation_pending, :confirmation_token])
2160 def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2161 if id not in user.pinned_activities do
2162 max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2163 params = %{pinned_activities: user.pinned_activities ++ [id]}
2166 |> cast(params, [:pinned_activities])
2167 |> validate_length(:pinned_activities,
2168 max: max_pinned_statuses,
2169 message: "You have already pinned the maximum number of statuses"
2174 |> update_and_set_cache()
2177 def remove_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2178 params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2181 |> cast(params, [:pinned_activities])
2182 |> update_and_set_cache()
2185 def update_email_notifications(user, settings) do
2186 email_notifications =
2187 user.email_notifications
2188 |> Map.merge(settings)
2189 |> Map.take(["digest"])
2191 params = %{email_notifications: email_notifications}
2192 fields = [:email_notifications]
2195 |> cast(params, fields)
2196 |> validate_required(fields)
2197 |> update_and_set_cache()
2200 defp set_domain_blocks(user, domain_blocks) do
2201 params = %{domain_blocks: domain_blocks}
2204 |> cast(params, [:domain_blocks])
2205 |> validate_required([:domain_blocks])
2206 |> update_and_set_cache()
2209 def block_domain(user, domain_blocked) do
2210 set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2213 def unblock_domain(user, domain_blocked) do
2214 set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2217 @spec add_to_block(User.t(), User.t()) ::
2218 {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2219 defp add_to_block(%User{} = user, %User{} = blocked) do
2220 UserRelationship.create_block(user, blocked)
2223 @spec add_to_block(User.t(), User.t()) ::
2224 {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2225 defp remove_from_block(%User{} = user, %User{} = blocked) do
2226 UserRelationship.delete_block(user, blocked)
2229 defp add_to_mutes(%User{} = user, %User{} = muted_user, notifications?) do
2230 with {:ok, user_mute} <- UserRelationship.create_mute(user, muted_user),
2231 {:ok, user_notification_mute} <-
2232 (notifications? && UserRelationship.create_notification_mute(user, muted_user)) ||
2234 {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
2238 defp remove_from_mutes(user, %User{} = muted_user) do
2239 with {:ok, user_mute} <- UserRelationship.delete_mute(user, muted_user),
2240 {:ok, user_notification_mute} <-
2241 UserRelationship.delete_notification_mute(user, muted_user) do
2242 {:ok, [user_mute, user_notification_mute]}
2246 def set_invisible(user, invisible) do
2247 params = %{invisible: invisible}
2250 |> cast(params, [:invisible])
2251 |> validate_required([:invisible])
2252 |> update_and_set_cache()
2255 def sanitize_html(%User{} = user) do
2256 sanitize_html(user, nil)
2259 # User data that mastodon isn't filtering (treated as plaintext):
2262 def sanitize_html(%User{} = user, filter) do
2264 Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2267 "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2272 |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2273 |> Map.put(:fields, fields)