1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.User do
10 import Ecto, only: [assoc: 2]
13 alias Pleroma.Activity
15 alias Pleroma.Conversation.Participation
16 alias Pleroma.Delivery
17 alias Pleroma.EctoType.ActivityPub.ObjectValidators
19 alias Pleroma.FollowingRelationship
20 alias Pleroma.Formatter
24 alias Pleroma.Notification
26 alias Pleroma.Registration
28 alias Pleroma.RepoStreamer
30 alias Pleroma.UserRelationship
32 alias Pleroma.Web.ActivityPub.ActivityPub
33 alias Pleroma.Web.ActivityPub.Builder
34 alias Pleroma.Web.ActivityPub.Pipeline
35 alias Pleroma.Web.ActivityPub.Utils
36 alias Pleroma.Web.CommonAPI
37 alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
38 alias Pleroma.Web.OAuth
39 alias Pleroma.Web.RelMe
40 alias Pleroma.Workers.BackgroundWorker
44 @type t :: %__MODULE__{}
45 @type account_status :: :active | :deactivated | :password_reset_pending | :confirmation_pending
46 @primary_key {:id, FlakeId.Ecto.CompatType, autogenerate: true}
48 # credo:disable-for-next-line Credo.Check.Readability.MaxLineLength
49 @email_regex ~r/^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/
51 @strict_local_nickname_regex ~r/^[a-zA-Z\d]+$/
52 @extended_local_nickname_regex ~r/^[a-zA-Z\d_-]+$/
54 # AP ID user relationships (blocks, mutes etc.)
55 # Format: [rel_type: [outgoing_rel: :outgoing_rel_target, incoming_rel: :incoming_rel_source]]
56 @user_relationships_config [
58 blocker_blocks: :blocked_users,
59 blockee_blocks: :blocker_users
62 muter_mutes: :muted_users,
63 mutee_mutes: :muter_users
66 reblog_muter_mutes: :reblog_muted_users,
67 reblog_mutee_mutes: :reblog_muter_users
70 notification_muter_mutes: :notification_muted_users,
71 notification_mutee_mutes: :notification_muter_users
73 # Note: `inverse_subscription` relationship is inverse: subscriber acts as relationship target
74 inverse_subscription: [
75 subscribee_subscriptions: :subscriber_users,
76 subscriber_subscriptions: :subscribee_users
82 field(:raw_bio, :string)
83 field(:email, :string)
85 field(:nickname, :string)
86 field(:password_hash, :string)
87 field(:password, :string, virtual: true)
88 field(:password_confirmation, :string, virtual: true)
90 field(:public_key, :string)
91 field(:ap_id, :string)
93 field(:local, :boolean, default: true)
94 field(:follower_address, :string)
95 field(:following_address, :string)
96 field(:search_rank, :float, virtual: true)
97 field(:search_type, :integer, virtual: true)
98 field(:tags, {:array, :string}, default: [])
99 field(:last_refreshed_at, :naive_datetime_usec)
100 field(:last_digest_emailed_at, :naive_datetime)
101 field(:banner, :map, default: %{})
102 field(:background, :map, default: %{})
103 field(:note_count, :integer, default: 0)
104 field(:follower_count, :integer, default: 0)
105 field(:following_count, :integer, default: 0)
106 field(:locked, :boolean, default: false)
107 field(:confirmation_pending, :boolean, default: false)
108 field(:password_reset_pending, :boolean, default: false)
109 field(:confirmation_token, :string, default: nil)
110 field(:default_scope, :string, default: "public")
111 field(:domain_blocks, {:array, :string}, default: [])
112 field(:deactivated, :boolean, default: false)
113 field(:no_rich_text, :boolean, default: false)
114 field(:ap_enabled, :boolean, default: false)
115 field(:is_moderator, :boolean, default: false)
116 field(:is_admin, :boolean, default: false)
117 field(:show_role, :boolean, default: true)
118 field(:mastofe_settings, :map, default: nil)
119 field(:uri, ObjectValidators.Uri, default: nil)
120 field(:hide_followers_count, :boolean, default: false)
121 field(:hide_follows_count, :boolean, default: false)
122 field(:hide_followers, :boolean, default: false)
123 field(:hide_follows, :boolean, default: false)
124 field(:hide_favorites, :boolean, default: true)
125 field(:unread_conversation_count, :integer, default: 0)
126 field(:pinned_activities, {:array, :string}, default: [])
127 field(:email_notifications, :map, default: %{"digest" => false})
128 field(:mascot, :map, default: nil)
129 field(:emoji, :map, default: %{})
130 field(:pleroma_settings_store, :map, default: %{})
131 field(:fields, {:array, :map}, default: [])
132 field(:raw_fields, {:array, :map}, default: [])
133 field(:discoverable, :boolean, default: false)
134 field(:invisible, :boolean, default: false)
135 field(:allow_following_move, :boolean, default: true)
136 field(:skip_thread_containment, :boolean, default: false)
137 field(:actor_type, :string, default: "Person")
138 field(:also_known_as, {:array, :string}, default: [])
139 field(:inbox, :string)
140 field(:shared_inbox, :string)
141 field(:accepts_chat_messages, :boolean, default: nil)
144 :notification_settings,
145 Pleroma.User.NotificationSetting,
149 has_many(:notifications, Notification)
150 has_many(:registrations, Registration)
151 has_many(:deliveries, Delivery)
153 has_many(:outgoing_relationships, UserRelationship, foreign_key: :source_id)
154 has_many(:incoming_relationships, UserRelationship, foreign_key: :target_id)
156 for {relationship_type,
158 {outgoing_relation, outgoing_relation_target},
159 {incoming_relation, incoming_relation_source}
160 ]} <- @user_relationships_config do
161 # Definitions of `has_many` relations: :blocker_blocks, :muter_mutes, :reblog_muter_mutes,
162 # :notification_muter_mutes, :subscribee_subscriptions
163 has_many(outgoing_relation, UserRelationship,
164 foreign_key: :source_id,
165 where: [relationship_type: relationship_type]
168 # Definitions of `has_many` relations: :blockee_blocks, :mutee_mutes, :reblog_mutee_mutes,
169 # :notification_mutee_mutes, :subscriber_subscriptions
170 has_many(incoming_relation, UserRelationship,
171 foreign_key: :target_id,
172 where: [relationship_type: relationship_type]
175 # Definitions of `has_many` relations: :blocked_users, :muted_users, :reblog_muted_users,
176 # :notification_muted_users, :subscriber_users
177 has_many(outgoing_relation_target, through: [outgoing_relation, :target])
179 # Definitions of `has_many` relations: :blocker_users, :muter_users, :reblog_muter_users,
180 # :notification_muter_users, :subscribee_users
181 has_many(incoming_relation_source, through: [incoming_relation, :source])
184 # `:blocks` is deprecated (replaced with `blocked_users` relation)
185 field(:blocks, {:array, :string}, default: [])
186 # `:mutes` is deprecated (replaced with `muted_users` relation)
187 field(:mutes, {:array, :string}, default: [])
188 # `:muted_reblogs` is deprecated (replaced with `reblog_muted_users` relation)
189 field(:muted_reblogs, {:array, :string}, default: [])
190 # `:muted_notifications` is deprecated (replaced with `notification_muted_users` relation)
191 field(:muted_notifications, {:array, :string}, default: [])
192 # `:subscribers` is deprecated (replaced with `subscriber_users` relation)
193 field(:subscribers, {:array, :string}, default: [])
196 :multi_factor_authentication_settings,
204 for {_relationship_type, [{_outgoing_relation, outgoing_relation_target}, _]} <-
205 @user_relationships_config do
206 # `def blocked_users_relation/2`, `def muted_users_relation/2`,
207 # `def reblog_muted_users_relation/2`, `def notification_muted_users/2`,
208 # `def subscriber_users/2`
209 def unquote(:"#{outgoing_relation_target}_relation")(user, restrict_deactivated? \\ false) do
210 target_users_query = assoc(user, unquote(outgoing_relation_target))
212 if restrict_deactivated? do
213 restrict_deactivated(target_users_query)
219 # `def blocked_users/2`, `def muted_users/2`, `def reblog_muted_users/2`,
220 # `def notification_muted_users/2`, `def subscriber_users/2`
221 def unquote(outgoing_relation_target)(user, restrict_deactivated? \\ false) do
223 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
225 restrict_deactivated?
230 # `def blocked_users_ap_ids/2`, `def muted_users_ap_ids/2`, `def reblog_muted_users_ap_ids/2`,
231 # `def notification_muted_users_ap_ids/2`, `def subscriber_users_ap_ids/2`
232 def unquote(:"#{outgoing_relation_target}_ap_ids")(user, restrict_deactivated? \\ false) do
234 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
236 restrict_deactivated?
238 |> select([u], u.ap_id)
244 Dumps Flake Id to SQL-compatible format (16-byte UUID).
245 E.g. "9pQtDGXuq4p3VlcJEm" -> <<0, 0, 1, 110, 179, 218, 42, 92, 213, 41, 44, 227, 95, 213, 0, 0>>
247 def binary_id(source_id) when is_binary(source_id) do
248 with {:ok, dumped_id} <- FlakeId.Ecto.CompatType.dump(source_id) do
255 def binary_id(source_ids) when is_list(source_ids) do
256 Enum.map(source_ids, &binary_id/1)
259 def binary_id(%User{} = user), do: binary_id(user.id)
261 @doc "Returns status account"
262 @spec account_status(User.t()) :: account_status()
263 def account_status(%User{deactivated: true}), do: :deactivated
264 def account_status(%User{password_reset_pending: true}), do: :password_reset_pending
266 def account_status(%User{confirmation_pending: true}) do
267 if Config.get([:instance, :account_activation_required]) do
268 :confirmation_pending
274 def account_status(%User{}), do: :active
276 @spec visible_for(User.t(), User.t() | nil) ::
279 | :restricted_unauthenticated
281 | :confirmation_pending
282 def visible_for(user, for_user \\ nil)
284 def visible_for(%User{invisible: true}, _), do: :invisible
286 def visible_for(%User{id: user_id}, %User{id: user_id}), do: :visible
288 def visible_for(%User{} = user, nil) do
289 if restrict_unauthenticated?(user) do
290 :restrict_unauthenticated
292 visible_account_status(user)
296 def visible_for(%User{} = user, for_user) do
297 if superuser?(for_user) do
300 visible_account_status(user)
304 def visible_for(_, _), do: :invisible
306 defp restrict_unauthenticated?(%User{local: local}) do
307 config_key = if local, do: :local, else: :remote
309 Config.get([:restrict_unauthenticated, :profiles, config_key], false)
312 defp visible_account_status(user) do
313 status = account_status(user)
315 if status in [:active, :password_reset_pending] do
322 @spec superuser?(User.t()) :: boolean()
323 def superuser?(%User{local: true, is_admin: true}), do: true
324 def superuser?(%User{local: true, is_moderator: true}), do: true
325 def superuser?(_), do: false
327 @spec invisible?(User.t()) :: boolean()
328 def invisible?(%User{invisible: true}), do: true
329 def invisible?(_), do: false
331 def avatar_url(user, options \\ []) do
333 %{"url" => [%{"href" => href} | _]} ->
337 unless options[:no_default] do
338 Config.get([:assets, :default_user_avatar], "#{Web.base_url()}/images/avi.png")
343 def banner_url(user, options \\ []) do
345 %{"url" => [%{"href" => href} | _]} -> href
346 _ -> !options[:no_default] && "#{Web.base_url()}/images/banner.png"
350 # Should probably be renamed or removed
351 def ap_id(%User{nickname: nickname}), do: "#{Web.base_url()}/users/#{nickname}"
353 def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
354 def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"
356 @spec ap_following(User.t()) :: String.t()
357 def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
358 def ap_following(%User{} = user), do: "#{ap_id(user)}/following"
360 @spec restrict_deactivated(Ecto.Query.t()) :: Ecto.Query.t()
361 def restrict_deactivated(query) do
362 from(u in query, where: u.deactivated != ^true)
365 defdelegate following_count(user), to: FollowingRelationship
367 defp truncate_fields_param(params) do
368 if Map.has_key?(params, :fields) do
369 Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
375 defp truncate_if_exists(params, key, max_length) do
376 if Map.has_key?(params, key) and is_binary(params[key]) do
377 {value, _chopped} = String.split_at(params[key], max_length)
378 Map.put(params, key, value)
384 defp fix_follower_address(%{follower_address: _, following_address: _} = params), do: params
386 defp fix_follower_address(%{nickname: nickname} = params),
387 do: Map.put(params, :follower_address, ap_followers(%User{nickname: nickname}))
389 defp fix_follower_address(params), do: params
391 def remote_user_changeset(struct \\ %User{local: false}, params) do
392 bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
393 name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
396 case params[:name] do
397 name when is_binary(name) and byte_size(name) > 0 -> name
398 _ -> params[:nickname]
403 |> Map.put(:name, name)
404 |> Map.put_new(:last_refreshed_at, NaiveDateTime.utc_now())
405 |> truncate_if_exists(:name, name_limit)
406 |> truncate_if_exists(:bio, bio_limit)
407 |> truncate_fields_param()
408 |> fix_follower_address()
432 :hide_followers_count,
443 |> validate_required([:name, :ap_id])
444 |> unique_constraint(:nickname)
445 |> validate_format(:nickname, @email_regex)
446 |> validate_length(:bio, max: bio_limit)
447 |> validate_length(:name, max: name_limit)
448 |> validate_fields(true)
451 def update_changeset(struct, params \\ %{}) do
452 bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
453 name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
473 :hide_followers_count,
476 :allow_following_move,
479 :skip_thread_containment,
482 :pleroma_settings_store,
488 |> unique_constraint(:nickname)
489 |> validate_format(:nickname, local_nickname_regex())
490 |> validate_length(:bio, max: bio_limit)
491 |> validate_length(:name, min: 1, max: name_limit)
492 |> validate_inclusion(:actor_type, ["Person", "Service"])
495 |> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
496 |> put_change_if_present(:avatar, &put_upload(&1, :avatar))
497 |> put_change_if_present(:banner, &put_upload(&1, :banner))
498 |> put_change_if_present(:background, &put_upload(&1, :background))
499 |> put_change_if_present(
500 :pleroma_settings_store,
501 &{:ok, Map.merge(struct.pleroma_settings_store, &1)}
503 |> validate_fields(false)
506 defp put_fields(changeset) do
507 if raw_fields = get_change(changeset, :raw_fields) do
510 |> Enum.filter(fn %{"name" => n} -> n != "" end)
514 |> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)
517 |> put_change(:raw_fields, raw_fields)
518 |> put_change(:fields, fields)
524 defp parse_fields(value) do
526 |> Formatter.linkify(mentions_format: :full)
530 defp put_emoji(changeset) do
531 bio = get_change(changeset, :bio)
532 name = get_change(changeset, :name)
535 emoji = Map.merge(Emoji.Formatter.get_emoji_map(bio), Emoji.Formatter.get_emoji_map(name))
536 put_change(changeset, :emoji, emoji)
542 defp put_change_if_present(changeset, map_field, value_function) do
543 if value = get_change(changeset, map_field) do
544 with {:ok, new_value} <- value_function.(value) do
545 put_change(changeset, map_field, new_value)
554 defp put_upload(value, type) do
555 with %Plug.Upload{} <- value,
556 {:ok, object} <- ActivityPub.upload(value, type: type) do
561 def update_as_admin_changeset(struct, params) do
563 |> update_changeset(params)
564 |> cast(params, [:email])
565 |> delete_change(:also_known_as)
566 |> unique_constraint(:email)
567 |> validate_format(:email, @email_regex)
568 |> validate_inclusion(:actor_type, ["Person", "Service"])
571 @spec update_as_admin(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
572 def update_as_admin(user, params) do
573 params = Map.put(params, "password_confirmation", params["password"])
574 changeset = update_as_admin_changeset(user, params)
576 if params["password"] do
577 reset_password(user, changeset, params)
579 User.update_and_set_cache(changeset)
583 def password_update_changeset(struct, params) do
585 |> cast(params, [:password, :password_confirmation])
586 |> validate_required([:password, :password_confirmation])
587 |> validate_confirmation(:password)
588 |> put_password_hash()
589 |> put_change(:password_reset_pending, false)
592 @spec reset_password(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
593 def reset_password(%User{} = user, params) do
594 reset_password(user, user, params)
597 def reset_password(%User{id: user_id} = user, struct, params) do
600 |> Multi.update(:user, password_update_changeset(struct, params))
601 |> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
602 |> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))
604 case Repo.transaction(multi) do
605 {:ok, %{user: user} = _} -> set_cache(user)
606 {:error, _, changeset, _} -> {:error, changeset}
610 def update_password_reset_pending(user, value) do
613 |> put_change(:password_reset_pending, value)
614 |> update_and_set_cache()
617 def force_password_reset_async(user) do
618 BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
621 @spec force_password_reset(User.t()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
622 def force_password_reset(user), do: update_password_reset_pending(user, true)
624 def register_changeset(struct, params \\ %{}, opts \\ []) do
625 bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
626 name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
627 params = Map.put_new(params, :accepts_chat_messages, true)
630 if is_nil(opts[:need_confirmation]) do
631 Pleroma.Config.get([:instance, :account_activation_required])
633 opts[:need_confirmation]
637 |> confirmation_changeset(need_confirmation: need_confirmation?)
645 :password_confirmation,
647 :accepts_chat_messages
649 |> validate_required([:name, :nickname, :password, :password_confirmation])
650 |> validate_confirmation(:password)
651 |> unique_constraint(:email)
652 |> unique_constraint(:nickname)
653 |> validate_exclusion(:nickname, Pleroma.Config.get([User, :restricted_nicknames]))
654 |> validate_format(:nickname, local_nickname_regex())
655 |> validate_format(:email, @email_regex)
656 |> validate_length(:bio, max: bio_limit)
657 |> validate_length(:name, min: 1, max: name_limit)
658 |> maybe_validate_required_email(opts[:external])
661 |> unique_constraint(:ap_id)
662 |> put_following_and_follower_address()
665 def maybe_validate_required_email(changeset, true), do: changeset
667 def maybe_validate_required_email(changeset, _) do
668 if Pleroma.Config.get([:instance, :account_activation_required]) do
669 validate_required(changeset, [:email])
675 defp put_ap_id(changeset) do
676 ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
677 put_change(changeset, :ap_id, ap_id)
680 defp put_following_and_follower_address(changeset) do
681 followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
684 |> put_change(:follower_address, followers)
687 defp autofollow_users(user) do
688 candidates = Pleroma.Config.get([:instance, :autofollowed_nicknames])
691 User.Query.build(%{nickname: candidates, local: true, deactivated: false})
694 follow_all(user, autofollowed_users)
697 @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
698 def register(%Ecto.Changeset{} = changeset) do
699 with {:ok, user} <- Repo.insert(changeset) do
700 post_register_action(user)
704 def post_register_action(%User{} = user) do
705 with {:ok, user} <- autofollow_users(user),
706 {:ok, user} <- set_cache(user),
707 {:ok, _} <- User.WelcomeMessage.post_welcome_message_to_user(user),
708 {:ok, _} <- try_send_confirmation_email(user) do
713 def try_send_confirmation_email(%User{} = user) do
714 if user.confirmation_pending &&
715 Pleroma.Config.get([:instance, :account_activation_required]) do
717 |> Pleroma.Emails.UserEmail.account_confirmation_email()
718 |> Pleroma.Emails.Mailer.deliver_async()
726 def try_send_confirmation_email(users) do
727 Enum.each(users, &try_send_confirmation_email/1)
730 def needs_update?(%User{local: true}), do: false
732 def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
734 def needs_update?(%User{local: false} = user) do
735 NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
738 def needs_update?(_), do: true
740 @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
742 # "Locked" (self-locked) users demand explicit authorization of follow requests
743 def maybe_direct_follow(%User{} = follower, %User{local: true, locked: true} = followed) do
744 follow(follower, followed, :follow_pending)
747 def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
748 follow(follower, followed)
751 def maybe_direct_follow(%User{} = follower, %User{} = followed) do
752 if not ap_enabled?(followed) do
753 follow(follower, followed)
759 @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
760 @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
761 def follow_all(follower, followeds) do
763 |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
764 |> Enum.each(&follow(follower, &1, :follow_accept))
769 defdelegate following(user), to: FollowingRelationship
771 def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
772 deny_follow_blocked = Pleroma.Config.get([:user, :deny_follow_blocked])
775 followed.deactivated ->
776 {:error, "Could not follow user: #{followed.nickname} is deactivated."}
778 deny_follow_blocked and blocks?(followed, follower) ->
779 {:error, "Could not follow user: #{followed.nickname} blocked you."}
782 FollowingRelationship.follow(follower, followed, state)
784 {:ok, _} = update_follower_count(followed)
787 |> update_following_count()
791 def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
792 {:error, "Not subscribed!"}
795 @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
796 def unfollow(%User{} = follower, %User{} = followed) do
797 case do_unfollow(follower, followed) do
798 {:ok, follower, followed} ->
799 {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
806 @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
807 defp do_unfollow(%User{} = follower, %User{} = followed) do
808 case get_follow_state(follower, followed) do
809 state when state in [:follow_pending, :follow_accept] ->
810 FollowingRelationship.unfollow(follower, followed)
811 {:ok, followed} = update_follower_count(followed)
815 |> update_following_count()
817 {:ok, follower, followed}
820 {:error, "Not subscribed!"}
824 defdelegate following?(follower, followed), to: FollowingRelationship
826 @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
827 def get_follow_state(%User{} = follower, %User{} = following) do
828 following_relationship = FollowingRelationship.get(follower, following)
829 get_follow_state(follower, following, following_relationship)
832 def get_follow_state(
835 following_relationship
837 case {following_relationship, following.local} do
839 case Utils.fetch_latest_follow(follower, following) do
840 %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
841 FollowingRelationship.state_to_enum(state)
847 {%{state: state}, _} ->
855 def locked?(%User{} = user) do
860 Repo.get_by(User, id: id)
863 def get_by_ap_id(ap_id) do
864 Repo.get_by(User, ap_id: ap_id)
867 def get_all_by_ap_id(ap_ids) do
868 from(u in __MODULE__,
869 where: u.ap_id in ^ap_ids
874 def get_all_by_ids(ids) do
875 from(u in __MODULE__, where: u.id in ^ids)
879 # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
880 # of the ap_id and the domain and tries to get that user
881 def get_by_guessed_nickname(ap_id) do
882 domain = URI.parse(ap_id).host
883 name = List.last(String.split(ap_id, "/"))
884 nickname = "#{name}@#{domain}"
886 get_cached_by_nickname(nickname)
889 def set_cache({:ok, user}), do: set_cache(user)
890 def set_cache({:error, err}), do: {:error, err}
892 def set_cache(%User{} = user) do
893 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
894 Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
895 Cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
899 def update_and_set_cache(struct, params) do
901 |> update_changeset(params)
902 |> update_and_set_cache()
905 def update_and_set_cache(changeset) do
906 with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
911 def get_user_friends_ap_ids(user) do
912 from(u in User.get_friends_query(user), select: u.ap_id)
916 @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
917 def get_cached_user_friends_ap_ids(user) do
918 Cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
919 get_user_friends_ap_ids(user)
923 def invalidate_cache(user) do
924 Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
925 Cachex.del(:user_cache, "nickname:#{user.nickname}")
926 Cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
929 @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
930 def get_cached_by_ap_id(ap_id) do
931 key = "ap_id:#{ap_id}"
933 with {:ok, nil} <- Cachex.get(:user_cache, key),
934 user when not is_nil(user) <- get_by_ap_id(ap_id),
935 {:ok, true} <- Cachex.put(:user_cache, key, user) do
943 def get_cached_by_id(id) do
947 Cachex.fetch!(:user_cache, key, fn _ ->
951 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
952 {:commit, user.ap_id}
958 get_cached_by_ap_id(ap_id)
961 def get_cached_by_nickname(nickname) do
962 key = "nickname:#{nickname}"
964 Cachex.fetch!(:user_cache, key, fn ->
965 case get_or_fetch_by_nickname(nickname) do
966 {:ok, user} -> {:commit, user}
967 {:error, _error} -> {:ignore, nil}
972 def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
973 restrict_to_local = Pleroma.Config.get([:instance, :limit_to_local_content])
976 is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
977 get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
979 restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
980 get_cached_by_nickname(nickname_or_id)
982 restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
983 get_cached_by_nickname(nickname_or_id)
990 @spec get_by_nickname(String.t()) :: User.t() | nil
991 def get_by_nickname(nickname) do
992 Repo.get_by(User, nickname: nickname) ||
993 if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
994 Repo.get_by(User, nickname: local_nickname(nickname))
998 def get_by_email(email), do: Repo.get_by(User, email: email)
1000 def get_by_nickname_or_email(nickname_or_email) do
1001 get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
1004 def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
1006 def get_or_fetch_by_nickname(nickname) do
1007 with %User{} = user <- get_by_nickname(nickname) do
1011 with [_nick, _domain] <- String.split(nickname, "@"),
1012 {:ok, user} <- fetch_by_nickname(nickname) do
1015 _e -> {:error, "not found " <> nickname}
1020 @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1021 def get_followers_query(%User{} = user, nil) do
1022 User.Query.build(%{followers: user, deactivated: false})
1025 def get_followers_query(user, page) do
1027 |> get_followers_query(nil)
1028 |> User.Query.paginate(page, 20)
1031 @spec get_followers_query(User.t()) :: Ecto.Query.t()
1032 def get_followers_query(user), do: get_followers_query(user, nil)
1034 @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1035 def get_followers(user, page \\ nil) do
1037 |> get_followers_query(page)
1041 @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1042 def get_external_followers(user, page \\ nil) do
1044 |> get_followers_query(page)
1045 |> User.Query.build(%{external: true})
1049 def get_followers_ids(user, page \\ nil) do
1051 |> get_followers_query(page)
1052 |> select([u], u.id)
1056 @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1057 def get_friends_query(%User{} = user, nil) do
1058 User.Query.build(%{friends: user, deactivated: false})
1061 def get_friends_query(user, page) do
1063 |> get_friends_query(nil)
1064 |> User.Query.paginate(page, 20)
1067 @spec get_friends_query(User.t()) :: Ecto.Query.t()
1068 def get_friends_query(user), do: get_friends_query(user, nil)
1070 def get_friends(user, page \\ nil) do
1072 |> get_friends_query(page)
1076 def get_friends_ap_ids(user) do
1078 |> get_friends_query(nil)
1079 |> select([u], u.ap_id)
1083 def get_friends_ids(user, page \\ nil) do
1085 |> get_friends_query(page)
1086 |> select([u], u.id)
1090 defdelegate get_follow_requests(user), to: FollowingRelationship
1092 def increase_note_count(%User{} = user) do
1094 |> where(id: ^user.id)
1095 |> update([u], inc: [note_count: 1])
1097 |> Repo.update_all([])
1099 {1, [user]} -> set_cache(user)
1104 def decrease_note_count(%User{} = user) do
1106 |> where(id: ^user.id)
1109 note_count: fragment("greatest(0, note_count - 1)")
1113 |> Repo.update_all([])
1115 {1, [user]} -> set_cache(user)
1120 def update_note_count(%User{} = user, note_count \\ nil) do
1125 where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1131 |> cast(%{note_count: note_count}, [:note_count])
1132 |> update_and_set_cache()
1135 @spec maybe_fetch_follow_information(User.t()) :: User.t()
1136 def maybe_fetch_follow_information(user) do
1137 with {:ok, user} <- fetch_follow_information(user) do
1141 Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1147 def fetch_follow_information(user) do
1148 with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1150 |> follow_information_changeset(info)
1151 |> update_and_set_cache()
1155 defp follow_information_changeset(user, params) do
1162 :hide_followers_count,
1167 @spec update_follower_count(User.t()) :: {:ok, User.t()}
1168 def update_follower_count(%User{} = user) do
1169 if user.local or !Pleroma.Config.get([:instance, :external_user_synchronization]) do
1170 follower_count = FollowingRelationship.follower_count(user)
1173 |> follow_information_changeset(%{follower_count: follower_count})
1174 |> update_and_set_cache
1176 {:ok, maybe_fetch_follow_information(user)}
1180 @spec update_following_count(User.t()) :: {:ok, User.t()}
1181 def update_following_count(%User{local: false} = user) do
1182 if Pleroma.Config.get([:instance, :external_user_synchronization]) do
1183 {:ok, maybe_fetch_follow_information(user)}
1189 def update_following_count(%User{local: true} = user) do
1190 following_count = FollowingRelationship.following_count(user)
1193 |> follow_information_changeset(%{following_count: following_count})
1194 |> update_and_set_cache()
1197 def set_unread_conversation_count(%User{local: true} = user) do
1198 unread_query = Participation.unread_conversation_count_for_user(user)
1201 |> join(:inner, [u], p in subquery(unread_query))
1203 set: [unread_conversation_count: p.count]
1205 |> where([u], u.id == ^user.id)
1207 |> Repo.update_all([])
1209 {1, [user]} -> set_cache(user)
1214 def set_unread_conversation_count(user), do: {:ok, user}
1216 def increment_unread_conversation_count(conversation, %User{local: true} = user) do
1218 Participation.unread_conversation_count_for_user(user)
1219 |> where([p], p.conversation_id == ^conversation.id)
1222 |> join(:inner, [u], p in subquery(unread_query))
1224 inc: [unread_conversation_count: 1]
1226 |> where([u], u.id == ^user.id)
1227 |> where([u, p], p.count == 0)
1229 |> Repo.update_all([])
1231 {1, [user]} -> set_cache(user)
1236 def increment_unread_conversation_count(_, user), do: {:ok, user}
1238 @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1239 def get_users_from_set(ap_ids, opts \\ []) do
1240 local_only = Keyword.get(opts, :local_only, true)
1241 criteria = %{ap_id: ap_ids, deactivated: false}
1242 criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1244 User.Query.build(criteria)
1248 @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1249 def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1252 query = User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
1258 @spec mute(User.t(), User.t(), boolean()) ::
1259 {:ok, list(UserRelationship.t())} | {:error, String.t()}
1260 def mute(%User{} = muter, %User{} = mutee, notifications? \\ true) do
1261 add_to_mutes(muter, mutee, notifications?)
1264 def unmute(%User{} = muter, %User{} = mutee) do
1265 remove_from_mutes(muter, mutee)
1268 def subscribe(%User{} = subscriber, %User{} = target) do
1269 deny_follow_blocked = Pleroma.Config.get([:user, :deny_follow_blocked])
1271 if blocks?(target, subscriber) and deny_follow_blocked do
1272 {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1274 # Note: the relationship is inverse: subscriber acts as relationship target
1275 UserRelationship.create_inverse_subscription(target, subscriber)
1279 def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1280 with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1281 subscribe(subscriber, subscribee)
1285 def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1286 # Note: the relationship is inverse: subscriber acts as relationship target
1287 UserRelationship.delete_inverse_subscription(target, unsubscriber)
1290 def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1291 with %User{} = user <- get_cached_by_ap_id(ap_id) do
1292 unsubscribe(unsubscriber, user)
1296 def block(%User{} = blocker, %User{} = blocked) do
1297 # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1299 if following?(blocker, blocked) do
1300 {:ok, blocker, _} = unfollow(blocker, blocked)
1306 # clear any requested follows as well
1308 case CommonAPI.reject_follow_request(blocked, blocker) do
1309 {:ok, %User{} = updated_blocked} -> updated_blocked
1313 unsubscribe(blocked, blocker)
1315 unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
1316 if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)
1318 {:ok, blocker} = update_follower_count(blocker)
1319 {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1320 add_to_block(blocker, blocked)
1323 # helper to handle the block given only an actor's AP id
1324 def block(%User{} = blocker, %{ap_id: ap_id}) do
1325 block(blocker, get_cached_by_ap_id(ap_id))
1328 def unblock(%User{} = blocker, %User{} = blocked) do
1329 remove_from_block(blocker, blocked)
1332 # helper to handle the block given only an actor's AP id
1333 def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1334 unblock(blocker, get_cached_by_ap_id(ap_id))
1337 def mutes?(nil, _), do: false
1338 def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1340 def mutes_user?(%User{} = user, %User{} = target) do
1341 UserRelationship.mute_exists?(user, target)
1344 @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1345 def muted_notifications?(nil, _), do: false
1347 def muted_notifications?(%User{} = user, %User{} = target),
1348 do: UserRelationship.notification_mute_exists?(user, target)
1350 def blocks?(nil, _), do: false
1352 def blocks?(%User{} = user, %User{} = target) do
1353 blocks_user?(user, target) ||
1354 (blocks_domain?(user, target) and not User.following?(user, target))
1357 def blocks_user?(%User{} = user, %User{} = target) do
1358 UserRelationship.block_exists?(user, target)
1361 def blocks_user?(_, _), do: false
1363 def blocks_domain?(%User{} = user, %User{} = target) do
1364 domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1365 %{host: host} = URI.parse(target.ap_id)
1366 Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1369 def blocks_domain?(_, _), do: false
1371 def subscribed_to?(%User{} = user, %User{} = target) do
1372 # Note: the relationship is inverse: subscriber acts as relationship target
1373 UserRelationship.inverse_subscription_exists?(target, user)
1376 def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1377 with %User{} = target <- get_cached_by_ap_id(ap_id) do
1378 subscribed_to?(user, target)
1383 Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1384 E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1386 @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1387 def outgoing_relationships_ap_ids(_user, []), do: %{}
1389 def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1391 def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1392 when is_list(relationship_types) do
1395 |> assoc(:outgoing_relationships)
1396 |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1397 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1398 |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1399 |> group_by([user_rel, u], user_rel.relationship_type)
1401 |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1406 fn rel_type -> {rel_type, db_result[rel_type] || []} end
1410 def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1412 def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1414 def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1416 def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1417 when is_list(relationship_types) do
1419 |> assoc(:incoming_relationships)
1420 |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1421 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1422 |> maybe_filter_on_ap_id(ap_ids)
1423 |> select([user_rel, u], u.ap_id)
1428 defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1429 where(query, [user_rel, u], u.ap_id in ^ap_ids)
1432 defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1434 def deactivate_async(user, status \\ true) do
1435 BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
1438 def deactivate(user, status \\ true)
1440 def deactivate(users, status) when is_list(users) do
1441 Repo.transaction(fn ->
1442 for user <- users, do: deactivate(user, status)
1446 def deactivate(%User{} = user, status) do
1447 with {:ok, user} <- set_activation_status(user, status) do
1450 |> Enum.filter(& &1.local)
1451 |> Enum.each(&set_cache(update_following_count(&1)))
1453 # Only update local user counts, remote will be update during the next pull.
1456 |> Enum.filter(& &1.local)
1457 |> Enum.each(&do_unfollow(user, &1))
1463 def update_notification_settings(%User{} = user, settings) do
1465 |> cast(%{notification_settings: settings}, [])
1466 |> cast_embed(:notification_settings)
1467 |> validate_required([:notification_settings])
1468 |> update_and_set_cache()
1471 def delete(users) when is_list(users) do
1472 for user <- users, do: delete(user)
1475 def delete(%User{} = user) do
1476 BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1479 defp delete_and_invalidate_cache(%User{} = user) do
1480 invalidate_cache(user)
1484 defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)
1486 defp delete_or_deactivate(%User{local: true} = user) do
1487 status = account_status(user)
1489 if status == :confirmation_pending do
1490 delete_and_invalidate_cache(user)
1493 |> change(%{deactivated: true, email: nil})
1494 |> update_and_set_cache()
1498 def perform(:force_password_reset, user), do: force_password_reset(user)
1500 @spec perform(atom(), User.t()) :: {:ok, User.t()}
1501 def perform(:delete, %User{} = user) do
1502 # Remove all relationships
1505 |> Enum.each(fn follower ->
1506 ActivityPub.unfollow(follower, user)
1507 unfollow(follower, user)
1512 |> Enum.each(fn followed ->
1513 ActivityPub.unfollow(user, followed)
1514 unfollow(user, followed)
1517 delete_user_activities(user)
1518 delete_notifications_from_user_activities(user)
1520 delete_outgoing_pending_follow_requests(user)
1522 delete_or_deactivate(user)
1525 def perform(:deactivate_async, user, status), do: deactivate(user, status)
1527 @spec perform(atom(), User.t(), list()) :: list() | {:error, any()}
1528 def perform(:blocks_import, %User{} = blocker, blocked_identifiers)
1529 when is_list(blocked_identifiers) do
1531 blocked_identifiers,
1532 fn blocked_identifier ->
1533 with {:ok, %User{} = blocked} <- get_or_fetch(blocked_identifier),
1534 {:ok, _block} <- CommonAPI.block(blocker, blocked) do
1538 Logger.debug("blocks_import failed for #{blocked_identifier} with: #{inspect(err)}")
1545 def perform(:follow_import, %User{} = follower, followed_identifiers)
1546 when is_list(followed_identifiers) do
1548 followed_identifiers,
1549 fn followed_identifier ->
1550 with {:ok, %User{} = followed} <- get_or_fetch(followed_identifier),
1551 {:ok, follower} <- maybe_direct_follow(follower, followed),
1552 {:ok, _} <- ActivityPub.follow(follower, followed) do
1556 Logger.debug("follow_import failed for #{followed_identifier} with: #{inspect(err)}")
1563 @spec external_users_query() :: Ecto.Query.t()
1564 def external_users_query do
1572 @spec external_users(keyword()) :: [User.t()]
1573 def external_users(opts \\ []) do
1575 external_users_query()
1576 |> select([u], struct(u, [:id, :ap_id]))
1580 do: where(query, [u], u.id > ^opts[:max_id]),
1585 do: limit(query, ^opts[:limit]),
1591 def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers) do
1592 BackgroundWorker.enqueue("blocks_import", %{
1593 "blocker_id" => blocker.id,
1594 "blocked_identifiers" => blocked_identifiers
1598 def follow_import(%User{} = follower, followed_identifiers)
1599 when is_list(followed_identifiers) do
1600 BackgroundWorker.enqueue("follow_import", %{
1601 "follower_id" => follower.id,
1602 "followed_identifiers" => followed_identifiers
1606 def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1608 |> join(:inner, [n], activity in assoc(n, :activity))
1609 |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1610 |> Repo.delete_all()
1613 def delete_user_activities(%User{ap_id: ap_id} = user) do
1615 |> Activity.Queries.by_actor()
1616 |> RepoStreamer.chunk_stream(50)
1617 |> Stream.each(fn activities ->
1618 Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1623 defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1624 with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1625 {:ok, delete_data, _} <- Builder.delete(user, object) do
1626 Pipeline.common_pipeline(delete_data, local: user.local)
1628 {:find_object, nil} ->
1629 # We have the create activity, but not the object, it was probably pruned.
1630 # Insert a tombstone and try again
1631 with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1632 {:ok, _tombstone} <- Object.create(tombstone_data) do
1633 delete_activity(activity, user)
1637 Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1638 Logger.error("Error: #{inspect(e)}")
1642 defp delete_activity(%{data: %{"type" => type}} = activity, user)
1643 when type in ["Like", "Announce"] do
1644 {:ok, undo, _} = Builder.undo(user, activity)
1645 Pipeline.common_pipeline(undo, local: user.local)
1648 defp delete_activity(_activity, _user), do: "Doing nothing"
1650 defp delete_outgoing_pending_follow_requests(user) do
1652 |> FollowingRelationship.outgoing_pending_follow_requests_query()
1653 |> Repo.delete_all()
1656 def html_filter_policy(%User{no_rich_text: true}) do
1657 Pleroma.HTML.Scrubber.TwitterText
1660 def html_filter_policy(_), do: Pleroma.Config.get([:markup, :scrub_policy])
1662 def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1664 def get_or_fetch_by_ap_id(ap_id) do
1665 cached_user = get_cached_by_ap_id(ap_id)
1667 maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)
1669 case {cached_user, maybe_fetched_user} do
1670 {_, {:ok, %User{} = user}} ->
1673 {%User{} = user, _} ->
1677 {:error, :not_found}
1682 Creates an internal service actor by URI if missing.
1683 Optionally takes nickname for addressing.
1685 @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1686 def get_or_create_service_actor_by_ap_id(uri, nickname) do
1688 case get_cached_by_ap_id(uri) do
1690 with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1691 Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1695 %User{invisible: false} = user ->
1705 @spec set_invisible(User.t()) :: {:ok, User.t()}
1706 defp set_invisible(user) do
1708 |> change(%{invisible: true})
1709 |> update_and_set_cache()
1712 @spec create_service_actor(String.t(), String.t()) ::
1713 {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1714 defp create_service_actor(uri, nickname) do
1720 follower_address: uri <> "/followers"
1723 |> unique_constraint(:nickname)
1728 def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1731 |> :public_key.pem_decode()
1733 |> :public_key.pem_entry_decode()
1738 def public_key(_), do: {:error, "key not found"}
1740 def get_public_key_for_ap_id(ap_id) do
1741 with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1742 {:ok, public_key} <- public_key(user) do
1749 def ap_enabled?(%User{local: true}), do: true
1750 def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1751 def ap_enabled?(_), do: false
1753 @doc "Gets or fetch a user by uri or nickname."
1754 @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1755 def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1756 def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1758 # wait a period of time and return newest version of the User structs
1759 # this is because we have synchronous follow APIs and need to simulate them
1760 # with an async handshake
1761 def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1762 with %User{} = a <- get_cached_by_id(a.id),
1763 %User{} = b <- get_cached_by_id(b.id) do
1770 def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1771 with :ok <- :timer.sleep(timeout),
1772 %User{} = a <- get_cached_by_id(a.id),
1773 %User{} = b <- get_cached_by_id(b.id) do
1780 def parse_bio(bio) when is_binary(bio) and bio != "" do
1782 |> CommonUtils.format_input("text/plain", mentions_format: :full)
1786 def parse_bio(_), do: ""
1788 def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1789 # TODO: get profile URLs other than user.ap_id
1790 profile_urls = [user.ap_id]
1793 |> CommonUtils.format_input("text/plain",
1794 mentions_format: :full,
1795 rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1800 def parse_bio(_, _), do: ""
1802 def tag(user_identifiers, tags) when is_list(user_identifiers) do
1803 Repo.transaction(fn ->
1804 for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1808 def tag(nickname, tags) when is_binary(nickname),
1809 do: tag(get_by_nickname(nickname), tags)
1811 def tag(%User{} = user, tags),
1812 do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1814 def untag(user_identifiers, tags) when is_list(user_identifiers) do
1815 Repo.transaction(fn ->
1816 for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1820 def untag(nickname, tags) when is_binary(nickname),
1821 do: untag(get_by_nickname(nickname), tags)
1823 def untag(%User{} = user, tags),
1824 do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1826 defp update_tags(%User{} = user, new_tags) do
1827 {:ok, updated_user} =
1829 |> change(%{tags: new_tags})
1830 |> update_and_set_cache()
1835 defp normalize_tags(tags) do
1838 |> Enum.map(&String.downcase/1)
1841 defp local_nickname_regex do
1842 if Pleroma.Config.get([:instance, :extended_nickname_format]) do
1843 @extended_local_nickname_regex
1845 @strict_local_nickname_regex
1849 def local_nickname(nickname_or_mention) do
1852 |> String.split("@")
1856 def full_nickname(nickname_or_mention),
1857 do: String.trim_leading(nickname_or_mention, "@")
1859 def error_user(ap_id) do
1863 nickname: "erroruser@example.com",
1864 inserted_at: NaiveDateTime.utc_now()
1868 @spec all_superusers() :: [User.t()]
1869 def all_superusers do
1870 User.Query.build(%{super_users: true, local: true, deactivated: false})
1874 def muting_reblogs?(%User{} = user, %User{} = target) do
1875 UserRelationship.reblog_mute_exists?(user, target)
1878 def showing_reblogs?(%User{} = user, %User{} = target) do
1879 not muting_reblogs?(user, target)
1883 The function returns a query to get users with no activity for given interval of days.
1884 Inactive users are those who didn't read any notification, or had any activity where
1885 the user is the activity's actor, during `inactivity_threshold` days.
1886 Deactivated users will not appear in this list.
1890 iex> Pleroma.User.list_inactive_users()
1893 @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
1894 def list_inactive_users_query(inactivity_threshold \\ 7) do
1895 negative_inactivity_threshold = -inactivity_threshold
1896 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
1897 # Subqueries are not supported in `where` clauses, join gets too complicated.
1898 has_read_notifications =
1899 from(n in Pleroma.Notification,
1900 where: n.seen == true,
1902 having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
1905 |> Pleroma.Repo.all()
1907 from(u in Pleroma.User,
1908 left_join: a in Pleroma.Activity,
1909 on: u.ap_id == a.actor,
1910 where: not is_nil(u.nickname),
1911 where: u.deactivated != ^true,
1912 where: u.id not in ^has_read_notifications,
1915 max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
1916 is_nil(max(a.inserted_at))
1921 Enable or disable email notifications for user
1925 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
1926 Pleroma.User{email_notifications: %{"digest" => true}}
1928 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
1929 Pleroma.User{email_notifications: %{"digest" => false}}
1931 @spec switch_email_notifications(t(), String.t(), boolean()) ::
1932 {:ok, t()} | {:error, Ecto.Changeset.t()}
1933 def switch_email_notifications(user, type, status) do
1934 User.update_email_notifications(user, %{type => status})
1938 Set `last_digest_emailed_at` value for the user to current time
1940 @spec touch_last_digest_emailed_at(t()) :: t()
1941 def touch_last_digest_emailed_at(user) do
1942 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
1944 {:ok, updated_user} =
1946 |> change(%{last_digest_emailed_at: now})
1947 |> update_and_set_cache()
1952 @spec toggle_confirmation(User.t()) :: {:ok, User.t()} | {:error, Changeset.t()}
1953 def toggle_confirmation(%User{} = user) do
1955 |> confirmation_changeset(need_confirmation: !user.confirmation_pending)
1956 |> update_and_set_cache()
1959 @spec toggle_confirmation([User.t()]) :: [{:ok, User.t()} | {:error, Changeset.t()}]
1960 def toggle_confirmation(users) do
1961 Enum.map(users, &toggle_confirmation/1)
1964 def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
1968 def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
1969 # use instance-default
1970 config = Pleroma.Config.get([:assets, :mascots])
1971 default_mascot = Pleroma.Config.get([:assets, :default_mascot])
1972 mascot = Keyword.get(config, default_mascot)
1975 "id" => "default-mascot",
1976 "url" => mascot[:url],
1977 "preview_url" => mascot[:url],
1979 "mime_type" => mascot[:mime_type]
1984 def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
1986 def ensure_keys_present(%User{} = user) do
1987 with {:ok, pem} <- Keys.generate_rsa_pem() do
1989 |> cast(%{keys: pem}, [:keys])
1990 |> validate_required([:keys])
1991 |> update_and_set_cache()
1995 def get_ap_ids_by_nicknames(nicknames) do
1997 where: u.nickname in ^nicknames,
2003 defdelegate search(query, opts \\ []), to: User.Search
2005 defp put_password_hash(
2006 %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2008 change(changeset, password_hash: Pbkdf2.hash_pwd_salt(password))
2011 defp put_password_hash(changeset), do: changeset
2013 def is_internal_user?(%User{nickname: nil}), do: true
2014 def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2015 def is_internal_user?(_), do: false
2017 # A hack because user delete activities have a fake id for whatever reason
2018 # TODO: Get rid of this
2019 def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2021 def get_delivered_users_by_object_id(object_id) do
2023 inner_join: delivery in assoc(u, :deliveries),
2024 where: delivery.object_id == ^object_id
2029 def change_email(user, email) do
2031 |> cast(%{email: email}, [:email])
2032 |> validate_required([:email])
2033 |> unique_constraint(:email)
2034 |> validate_format(:email, @email_regex)
2035 |> update_and_set_cache()
2038 # Internal function; public one is `deactivate/2`
2039 defp set_activation_status(user, deactivated) do
2041 |> cast(%{deactivated: deactivated}, [:deactivated])
2042 |> update_and_set_cache()
2045 def update_banner(user, banner) do
2047 |> cast(%{banner: banner}, [:banner])
2048 |> update_and_set_cache()
2051 def update_background(user, background) do
2053 |> cast(%{background: background}, [:background])
2054 |> update_and_set_cache()
2057 def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
2060 moderator: is_moderator
2064 def validate_fields(changeset, remote? \\ false) do
2065 limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2066 limit = Pleroma.Config.get([:instance, limit_name], 0)
2069 |> validate_length(:fields, max: limit)
2070 |> validate_change(:fields, fn :fields, fields ->
2071 if Enum.all?(fields, &valid_field?/1) do
2079 defp valid_field?(%{"name" => name, "value" => value}) do
2080 name_limit = Pleroma.Config.get([:instance, :account_field_name_length], 255)
2081 value_limit = Pleroma.Config.get([:instance, :account_field_value_length], 255)
2083 is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2084 String.length(value) <= value_limit
2087 defp valid_field?(_), do: false
2089 defp truncate_field(%{"name" => name, "value" => value}) do
2091 String.split_at(name, Pleroma.Config.get([:instance, :account_field_name_length], 255))
2094 String.split_at(value, Pleroma.Config.get([:instance, :account_field_value_length], 255))
2096 %{"name" => name, "value" => value}
2099 def admin_api_update(user, params) do
2106 |> update_and_set_cache()
2109 @doc "Signs user out of all applications"
2110 def global_sign_out(user) do
2111 OAuth.Authorization.delete_user_authorizations(user)
2112 OAuth.Token.delete_user_tokens(user)
2115 def mascot_update(user, url) do
2117 |> cast(%{mascot: url}, [:mascot])
2118 |> validate_required([:mascot])
2119 |> update_and_set_cache()
2122 def mastodon_settings_update(user, settings) do
2124 |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
2125 |> validate_required([:mastofe_settings])
2126 |> update_and_set_cache()
2129 @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2130 def confirmation_changeset(user, need_confirmation: need_confirmation?) do
2132 if need_confirmation? do
2134 confirmation_pending: true,
2135 confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2139 confirmation_pending: false,
2140 confirmation_token: nil
2144 cast(user, params, [:confirmation_pending, :confirmation_token])
2147 def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2148 if id not in user.pinned_activities do
2149 max_pinned_statuses = Pleroma.Config.get([:instance, :max_pinned_statuses], 0)
2150 params = %{pinned_activities: user.pinned_activities ++ [id]}
2153 |> cast(params, [:pinned_activities])
2154 |> validate_length(:pinned_activities,
2155 max: max_pinned_statuses,
2156 message: "You have already pinned the maximum number of statuses"
2161 |> update_and_set_cache()
2164 def remove_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2165 params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2168 |> cast(params, [:pinned_activities])
2169 |> update_and_set_cache()
2172 def update_email_notifications(user, settings) do
2173 email_notifications =
2174 user.email_notifications
2175 |> Map.merge(settings)
2176 |> Map.take(["digest"])
2178 params = %{email_notifications: email_notifications}
2179 fields = [:email_notifications]
2182 |> cast(params, fields)
2183 |> validate_required(fields)
2184 |> update_and_set_cache()
2187 defp set_domain_blocks(user, domain_blocks) do
2188 params = %{domain_blocks: domain_blocks}
2191 |> cast(params, [:domain_blocks])
2192 |> validate_required([:domain_blocks])
2193 |> update_and_set_cache()
2196 def block_domain(user, domain_blocked) do
2197 set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2200 def unblock_domain(user, domain_blocked) do
2201 set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2204 @spec add_to_block(User.t(), User.t()) ::
2205 {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2206 defp add_to_block(%User{} = user, %User{} = blocked) do
2207 UserRelationship.create_block(user, blocked)
2210 @spec add_to_block(User.t(), User.t()) ::
2211 {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2212 defp remove_from_block(%User{} = user, %User{} = blocked) do
2213 UserRelationship.delete_block(user, blocked)
2216 defp add_to_mutes(%User{} = user, %User{} = muted_user, notifications?) do
2217 with {:ok, user_mute} <- UserRelationship.create_mute(user, muted_user),
2218 {:ok, user_notification_mute} <-
2219 (notifications? && UserRelationship.create_notification_mute(user, muted_user)) ||
2221 {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
2225 defp remove_from_mutes(user, %User{} = muted_user) do
2226 with {:ok, user_mute} <- UserRelationship.delete_mute(user, muted_user),
2227 {:ok, user_notification_mute} <-
2228 UserRelationship.delete_notification_mute(user, muted_user) do
2229 {:ok, [user_mute, user_notification_mute]}
2233 def set_invisible(user, invisible) do
2234 params = %{invisible: invisible}
2237 |> cast(params, [:invisible])
2238 |> validate_required([:invisible])
2239 |> update_and_set_cache()
2242 def sanitize_html(%User{} = user) do
2243 sanitize_html(user, nil)
2246 # User data that mastodon isn't filtering (treated as plaintext):
2249 def sanitize_html(%User{} = user, filter) do
2251 Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2254 "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2259 |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2260 |> Map.put(:fields, fields)