1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.User do
10 import Ecto, only: [assoc: 2]
13 alias Pleroma.Activity
15 alias Pleroma.Conversation.Participation
16 alias Pleroma.Delivery
17 alias Pleroma.EctoType.ActivityPub.ObjectValidators
19 alias Pleroma.FollowingRelationship
20 alias Pleroma.Formatter
24 alias Pleroma.Notification
26 alias Pleroma.Registration
28 alias Pleroma.RepoStreamer
30 alias Pleroma.UserRelationship
32 alias Pleroma.Web.ActivityPub.ActivityPub
33 alias Pleroma.Web.ActivityPub.Builder
34 alias Pleroma.Web.ActivityPub.Pipeline
35 alias Pleroma.Web.ActivityPub.Utils
36 alias Pleroma.Web.CommonAPI
37 alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
38 alias Pleroma.Web.OAuth
39 alias Pleroma.Web.RelMe
40 alias Pleroma.Workers.BackgroundWorker
44 @type t :: %__MODULE__{}
45 @type account_status :: :active | :deactivated | :password_reset_pending | :confirmation_pending
46 @primary_key {:id, FlakeId.Ecto.CompatType, autogenerate: true}
48 # credo:disable-for-next-line Credo.Check.Readability.MaxLineLength
49 @email_regex ~r/^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/
51 @strict_local_nickname_regex ~r/^[a-zA-Z\d]+$/
52 @extended_local_nickname_regex ~r/^[a-zA-Z\d_-]+$/
54 # AP ID user relationships (blocks, mutes etc.)
55 # Format: [rel_type: [outgoing_rel: :outgoing_rel_target, incoming_rel: :incoming_rel_source]]
56 @user_relationships_config [
58 blocker_blocks: :blocked_users,
59 blockee_blocks: :blocker_users
62 muter_mutes: :muted_users,
63 mutee_mutes: :muter_users
66 reblog_muter_mutes: :reblog_muted_users,
67 reblog_mutee_mutes: :reblog_muter_users
70 notification_muter_mutes: :notification_muted_users,
71 notification_mutee_mutes: :notification_muter_users
73 # Note: `inverse_subscription` relationship is inverse: subscriber acts as relationship target
74 inverse_subscription: [
75 subscribee_subscriptions: :subscriber_users,
76 subscriber_subscriptions: :subscribee_users
82 field(:raw_bio, :string)
83 field(:email, :string)
85 field(:nickname, :string)
86 field(:password_hash, :string)
87 field(:password, :string, virtual: true)
88 field(:password_confirmation, :string, virtual: true)
90 field(:public_key, :string)
91 field(:ap_id, :string)
93 field(:local, :boolean, default: true)
94 field(:follower_address, :string)
95 field(:following_address, :string)
96 field(:search_rank, :float, virtual: true)
97 field(:search_type, :integer, virtual: true)
98 field(:tags, {:array, :string}, default: [])
99 field(:last_refreshed_at, :naive_datetime_usec)
100 field(:last_digest_emailed_at, :naive_datetime)
101 field(:banner, :map, default: %{})
102 field(:background, :map, default: %{})
103 field(:note_count, :integer, default: 0)
104 field(:follower_count, :integer, default: 0)
105 field(:following_count, :integer, default: 0)
106 field(:locked, :boolean, default: false)
107 field(:confirmation_pending, :boolean, default: false)
108 field(:password_reset_pending, :boolean, default: false)
109 field(:confirmation_token, :string, default: nil)
110 field(:default_scope, :string, default: "public")
111 field(:domain_blocks, {:array, :string}, default: [])
112 field(:deactivated, :boolean, default: false)
113 field(:no_rich_text, :boolean, default: false)
114 field(:ap_enabled, :boolean, default: false)
115 field(:is_moderator, :boolean, default: false)
116 field(:is_admin, :boolean, default: false)
117 field(:show_role, :boolean, default: true)
118 field(:settings, :map, default: nil)
119 field(:uri, ObjectValidators.Uri, default: nil)
120 field(:hide_followers_count, :boolean, default: false)
121 field(:hide_follows_count, :boolean, default: false)
122 field(:hide_followers, :boolean, default: false)
123 field(:hide_follows, :boolean, default: false)
124 field(:hide_favorites, :boolean, default: true)
125 field(:unread_conversation_count, :integer, default: 0)
126 field(:pinned_activities, {:array, :string}, default: [])
127 field(:email_notifications, :map, default: %{"digest" => false})
128 field(:mascot, :map, default: nil)
129 field(:emoji, :map, default: %{})
130 field(:pleroma_settings_store, :map, default: %{})
131 field(:fields, {:array, :map}, default: [])
132 field(:raw_fields, {:array, :map}, default: [])
133 field(:discoverable, :boolean, default: false)
134 field(:invisible, :boolean, default: false)
135 field(:allow_following_move, :boolean, default: true)
136 field(:skip_thread_containment, :boolean, default: false)
137 field(:actor_type, :string, default: "Person")
138 field(:also_known_as, {:array, :string}, default: [])
139 field(:inbox, :string)
140 field(:shared_inbox, :string)
143 :notification_settings,
144 Pleroma.User.NotificationSetting,
148 has_many(:notifications, Notification)
149 has_many(:registrations, Registration)
150 has_many(:deliveries, Delivery)
152 has_many(:outgoing_relationships, UserRelationship, foreign_key: :source_id)
153 has_many(:incoming_relationships, UserRelationship, foreign_key: :target_id)
155 for {relationship_type,
157 {outgoing_relation, outgoing_relation_target},
158 {incoming_relation, incoming_relation_source}
159 ]} <- @user_relationships_config do
160 # Definitions of `has_many` relations: :blocker_blocks, :muter_mutes, :reblog_muter_mutes,
161 # :notification_muter_mutes, :subscribee_subscriptions
162 has_many(outgoing_relation, UserRelationship,
163 foreign_key: :source_id,
164 where: [relationship_type: relationship_type]
167 # Definitions of `has_many` relations: :blockee_blocks, :mutee_mutes, :reblog_mutee_mutes,
168 # :notification_mutee_mutes, :subscriber_subscriptions
169 has_many(incoming_relation, UserRelationship,
170 foreign_key: :target_id,
171 where: [relationship_type: relationship_type]
174 # Definitions of `has_many` relations: :blocked_users, :muted_users, :reblog_muted_users,
175 # :notification_muted_users, :subscriber_users
176 has_many(outgoing_relation_target, through: [outgoing_relation, :target])
178 # Definitions of `has_many` relations: :blocker_users, :muter_users, :reblog_muter_users,
179 # :notification_muter_users, :subscribee_users
180 has_many(incoming_relation_source, through: [incoming_relation, :source])
183 # `:blocks` is deprecated (replaced with `blocked_users` relation)
184 field(:blocks, {:array, :string}, default: [])
185 # `:mutes` is deprecated (replaced with `muted_users` relation)
186 field(:mutes, {:array, :string}, default: [])
187 # `:muted_reblogs` is deprecated (replaced with `reblog_muted_users` relation)
188 field(:muted_reblogs, {:array, :string}, default: [])
189 # `:muted_notifications` is deprecated (replaced with `notification_muted_users` relation)
190 field(:muted_notifications, {:array, :string}, default: [])
191 # `:subscribers` is deprecated (replaced with `subscriber_users` relation)
192 field(:subscribers, {:array, :string}, default: [])
195 :multi_factor_authentication_settings,
203 for {_relationship_type, [{_outgoing_relation, outgoing_relation_target}, _]} <-
204 @user_relationships_config do
205 # `def blocked_users_relation/2`, `def muted_users_relation/2`,
206 # `def reblog_muted_users_relation/2`, `def notification_muted_users/2`,
207 # `def subscriber_users/2`
208 def unquote(:"#{outgoing_relation_target}_relation")(user, restrict_deactivated? \\ false) do
209 target_users_query = assoc(user, unquote(outgoing_relation_target))
211 if restrict_deactivated? do
212 restrict_deactivated(target_users_query)
218 # `def blocked_users/2`, `def muted_users/2`, `def reblog_muted_users/2`,
219 # `def notification_muted_users/2`, `def subscriber_users/2`
220 def unquote(outgoing_relation_target)(user, restrict_deactivated? \\ false) do
222 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
224 restrict_deactivated?
229 # `def blocked_users_ap_ids/2`, `def muted_users_ap_ids/2`, `def reblog_muted_users_ap_ids/2`,
230 # `def notification_muted_users_ap_ids/2`, `def subscriber_users_ap_ids/2`
231 def unquote(:"#{outgoing_relation_target}_ap_ids")(user, restrict_deactivated? \\ false) do
233 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
235 restrict_deactivated?
237 |> select([u], u.ap_id)
243 Dumps Flake Id to SQL-compatible format (16-byte UUID).
244 E.g. "9pQtDGXuq4p3VlcJEm" -> <<0, 0, 1, 110, 179, 218, 42, 92, 213, 41, 44, 227, 95, 213, 0, 0>>
246 def binary_id(source_id) when is_binary(source_id) do
247 with {:ok, dumped_id} <- FlakeId.Ecto.CompatType.dump(source_id) do
254 def binary_id(source_ids) when is_list(source_ids) do
255 Enum.map(source_ids, &binary_id/1)
258 def binary_id(%User{} = user), do: binary_id(user.id)
260 @doc "Returns status account"
261 @spec account_status(User.t()) :: account_status()
262 def account_status(%User{deactivated: true}), do: :deactivated
263 def account_status(%User{password_reset_pending: true}), do: :password_reset_pending
265 def account_status(%User{confirmation_pending: true}) do
266 case Config.get([:instance, :account_activation_required]) do
267 true -> :confirmation_pending
272 def account_status(%User{}), do: :active
274 @spec visible_for?(User.t(), User.t() | nil) :: boolean()
275 def visible_for?(user, for_user \\ nil)
277 def visible_for?(%User{invisible: true}, _), do: false
279 def visible_for?(%User{id: user_id}, %User{id: user_id}), do: true
281 def visible_for?(%User{local: local} = user, nil) do
287 if Config.get([:restrict_unauthenticated, :profiles, cfg_key]),
289 else: account_status(user) == :active
292 def visible_for?(%User{} = user, for_user) do
293 account_status(user) == :active || superuser?(for_user)
296 def visible_for?(_, _), do: false
298 @spec superuser?(User.t()) :: boolean()
299 def superuser?(%User{local: true, is_admin: true}), do: true
300 def superuser?(%User{local: true, is_moderator: true}), do: true
301 def superuser?(_), do: false
303 @spec invisible?(User.t()) :: boolean()
304 def invisible?(%User{invisible: true}), do: true
305 def invisible?(_), do: false
307 def avatar_url(user, options \\ []) do
309 %{"url" => [%{"href" => href} | _]} ->
313 unless options[:no_default] do
314 Config.get([:assets, :default_user_avatar], "#{Web.base_url()}/images/avi.png")
319 def banner_url(user, options \\ []) do
321 %{"url" => [%{"href" => href} | _]} -> href
322 _ -> !options[:no_default] && "#{Web.base_url()}/images/banner.png"
326 # Should probably be renamed or removed
327 def ap_id(%User{nickname: nickname}), do: "#{Web.base_url()}/users/#{nickname}"
329 def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
330 def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"
332 @spec ap_following(User.t()) :: String.t()
333 def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
334 def ap_following(%User{} = user), do: "#{ap_id(user)}/following"
336 @spec restrict_deactivated(Ecto.Query.t()) :: Ecto.Query.t()
337 def restrict_deactivated(query) do
338 from(u in query, where: u.deactivated != ^true)
341 defdelegate following_count(user), to: FollowingRelationship
343 defp truncate_fields_param(params) do
344 if Map.has_key?(params, :fields) do
345 Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
351 defp truncate_if_exists(params, key, max_length) do
352 if Map.has_key?(params, key) and is_binary(params[key]) do
353 {value, _chopped} = String.split_at(params[key], max_length)
354 Map.put(params, key, value)
360 defp fix_follower_address(%{follower_address: _, following_address: _} = params), do: params
362 defp fix_follower_address(%{nickname: nickname} = params),
363 do: Map.put(params, :follower_address, ap_followers(%User{nickname: nickname}))
365 defp fix_follower_address(params), do: params
367 def remote_user_changeset(struct \\ %User{local: false}, params) do
368 bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
369 name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
372 case params[:name] do
373 name when is_binary(name) and byte_size(name) > 0 -> name
374 _ -> params[:nickname]
379 |> Map.put(:name, name)
380 |> Map.put_new(:last_refreshed_at, NaiveDateTime.utc_now())
381 |> truncate_if_exists(:name, name_limit)
382 |> truncate_if_exists(:bio, bio_limit)
383 |> truncate_fields_param()
384 |> fix_follower_address()
408 :hide_followers_count,
419 |> validate_required([:name, :ap_id])
420 |> unique_constraint(:nickname)
421 |> validate_format(:nickname, @email_regex)
422 |> validate_length(:bio, max: bio_limit)
423 |> validate_length(:name, max: name_limit)
424 |> validate_fields(true)
427 def update_changeset(struct, params \\ %{}) do
428 bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
429 name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
449 :hide_followers_count,
452 :allow_following_move,
455 :skip_thread_containment,
458 :pleroma_settings_store,
464 |> unique_constraint(:nickname)
465 |> validate_format(:nickname, local_nickname_regex())
466 |> validate_length(:bio, max: bio_limit)
467 |> validate_length(:name, min: 1, max: name_limit)
468 |> validate_inclusion(:actor_type, ["Person", "Service"])
471 |> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
472 |> put_change_if_present(:avatar, &put_upload(&1, :avatar))
473 |> put_change_if_present(:banner, &put_upload(&1, :banner))
474 |> put_change_if_present(:background, &put_upload(&1, :background))
475 |> put_change_if_present(
476 :pleroma_settings_store,
477 &{:ok, Map.merge(struct.pleroma_settings_store, &1)}
479 |> validate_fields(false)
482 defp put_fields(changeset) do
483 if raw_fields = get_change(changeset, :raw_fields) do
486 |> Enum.filter(fn %{"name" => n} -> n != "" end)
490 |> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)
493 |> put_change(:raw_fields, raw_fields)
494 |> put_change(:fields, fields)
500 defp parse_fields(value) do
502 |> Formatter.linkify(mentions_format: :full)
506 defp put_emoji(changeset) do
507 bio = get_change(changeset, :bio)
508 name = get_change(changeset, :name)
511 emoji = Map.merge(Emoji.Formatter.get_emoji_map(bio), Emoji.Formatter.get_emoji_map(name))
512 put_change(changeset, :emoji, emoji)
518 defp put_change_if_present(changeset, map_field, value_function) do
519 if value = get_change(changeset, map_field) do
520 with {:ok, new_value} <- value_function.(value) do
521 put_change(changeset, map_field, new_value)
530 defp put_upload(value, type) do
531 with %Plug.Upload{} <- value,
532 {:ok, object} <- ActivityPub.upload(value, type: type) do
537 def update_as_admin_changeset(struct, params) do
539 |> update_changeset(params)
540 |> cast(params, [:email])
541 |> delete_change(:also_known_as)
542 |> unique_constraint(:email)
543 |> validate_format(:email, @email_regex)
544 |> validate_inclusion(:actor_type, ["Person", "Service"])
547 @spec update_as_admin(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
548 def update_as_admin(user, params) do
549 params = Map.put(params, "password_confirmation", params["password"])
550 changeset = update_as_admin_changeset(user, params)
552 if params["password"] do
553 reset_password(user, changeset, params)
555 User.update_and_set_cache(changeset)
559 def password_update_changeset(struct, params) do
561 |> cast(params, [:password, :password_confirmation])
562 |> validate_required([:password, :password_confirmation])
563 |> validate_confirmation(:password)
564 |> put_password_hash()
565 |> put_change(:password_reset_pending, false)
568 @spec reset_password(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
569 def reset_password(%User{} = user, params) do
570 reset_password(user, user, params)
573 def reset_password(%User{id: user_id} = user, struct, params) do
576 |> Multi.update(:user, password_update_changeset(struct, params))
577 |> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
578 |> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))
580 case Repo.transaction(multi) do
581 {:ok, %{user: user} = _} -> set_cache(user)
582 {:error, _, changeset, _} -> {:error, changeset}
586 def update_password_reset_pending(user, value) do
589 |> put_change(:password_reset_pending, value)
590 |> update_and_set_cache()
593 def force_password_reset_async(user) do
594 BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
597 @spec force_password_reset(User.t()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
598 def force_password_reset(user), do: update_password_reset_pending(user, true)
600 def register_changeset(struct, params \\ %{}, opts \\ []) do
601 bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
602 name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
605 if is_nil(opts[:need_confirmation]) do
606 Pleroma.Config.get([:instance, :account_activation_required])
608 opts[:need_confirmation]
612 |> confirmation_changeset(need_confirmation: need_confirmation?)
620 :password_confirmation,
623 |> validate_required([:name, :nickname, :password, :password_confirmation])
624 |> validate_confirmation(:password)
625 |> unique_constraint(:email)
626 |> unique_constraint(:nickname)
627 |> validate_exclusion(:nickname, Pleroma.Config.get([User, :restricted_nicknames]))
628 |> validate_format(:nickname, local_nickname_regex())
629 |> validate_format(:email, @email_regex)
630 |> validate_length(:bio, max: bio_limit)
631 |> validate_length(:name, min: 1, max: name_limit)
632 |> maybe_validate_required_email(opts[:external])
635 |> unique_constraint(:ap_id)
636 |> put_following_and_follower_address()
639 def maybe_validate_required_email(changeset, true), do: changeset
641 def maybe_validate_required_email(changeset, _) do
642 if Pleroma.Config.get([:instance, :account_activation_required]) do
643 validate_required(changeset, [:email])
649 defp put_ap_id(changeset) do
650 ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
651 put_change(changeset, :ap_id, ap_id)
654 defp put_following_and_follower_address(changeset) do
655 followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
658 |> put_change(:follower_address, followers)
661 defp autofollow_users(user) do
662 candidates = Pleroma.Config.get([:instance, :autofollowed_nicknames])
665 User.Query.build(%{nickname: candidates, local: true, deactivated: false})
668 follow_all(user, autofollowed_users)
671 @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
672 def register(%Ecto.Changeset{} = changeset) do
673 with {:ok, user} <- Repo.insert(changeset) do
674 post_register_action(user)
678 def post_register_action(%User{} = user) do
679 with {:ok, user} <- autofollow_users(user),
680 {:ok, user} <- set_cache(user),
681 {:ok, _} <- User.WelcomeMessage.post_welcome_message_to_user(user),
682 {:ok, _} <- try_send_confirmation_email(user) do
687 def try_send_confirmation_email(%User{} = user) do
688 if user.confirmation_pending &&
689 Pleroma.Config.get([:instance, :account_activation_required]) do
691 |> Pleroma.Emails.UserEmail.account_confirmation_email()
692 |> Pleroma.Emails.Mailer.deliver_async()
700 def try_send_confirmation_email(users) do
701 Enum.each(users, &try_send_confirmation_email/1)
704 def needs_update?(%User{local: true}), do: false
706 def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
708 def needs_update?(%User{local: false} = user) do
709 NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
712 def needs_update?(_), do: true
714 @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
716 # "Locked" (self-locked) users demand explicit authorization of follow requests
717 def maybe_direct_follow(%User{} = follower, %User{local: true, locked: true} = followed) do
718 follow(follower, followed, :follow_pending)
721 def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
722 follow(follower, followed)
725 def maybe_direct_follow(%User{} = follower, %User{} = followed) do
726 if not ap_enabled?(followed) do
727 follow(follower, followed)
733 @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
734 @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
735 def follow_all(follower, followeds) do
737 |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
738 |> Enum.each(&follow(follower, &1, :follow_accept))
743 defdelegate following(user), to: FollowingRelationship
745 def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
746 deny_follow_blocked = Pleroma.Config.get([:user, :deny_follow_blocked])
749 followed.deactivated ->
750 {:error, "Could not follow user: #{followed.nickname} is deactivated."}
752 deny_follow_blocked and blocks?(followed, follower) ->
753 {:error, "Could not follow user: #{followed.nickname} blocked you."}
756 FollowingRelationship.follow(follower, followed, state)
758 {:ok, _} = update_follower_count(followed)
761 |> update_following_count()
765 def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
766 {:error, "Not subscribed!"}
769 @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
770 def unfollow(%User{} = follower, %User{} = followed) do
771 case do_unfollow(follower, followed) do
772 {:ok, follower, followed} ->
773 {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
780 @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
781 defp do_unfollow(%User{} = follower, %User{} = followed) do
782 case get_follow_state(follower, followed) do
783 state when state in [:follow_pending, :follow_accept] ->
784 FollowingRelationship.unfollow(follower, followed)
785 {:ok, followed} = update_follower_count(followed)
789 |> update_following_count()
791 {:ok, follower, followed}
794 {:error, "Not subscribed!"}
798 defdelegate following?(follower, followed), to: FollowingRelationship
800 @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
801 def get_follow_state(%User{} = follower, %User{} = following) do
802 following_relationship = FollowingRelationship.get(follower, following)
803 get_follow_state(follower, following, following_relationship)
806 def get_follow_state(
809 following_relationship
811 case {following_relationship, following.local} do
813 case Utils.fetch_latest_follow(follower, following) do
814 %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
815 FollowingRelationship.state_to_enum(state)
821 {%{state: state}, _} ->
829 def locked?(%User{} = user) do
834 Repo.get_by(User, id: id)
837 def get_by_ap_id(ap_id) do
838 Repo.get_by(User, ap_id: ap_id)
841 def get_all_by_ap_id(ap_ids) do
842 from(u in __MODULE__,
843 where: u.ap_id in ^ap_ids
848 def get_all_by_ids(ids) do
849 from(u in __MODULE__, where: u.id in ^ids)
853 # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
854 # of the ap_id and the domain and tries to get that user
855 def get_by_guessed_nickname(ap_id) do
856 domain = URI.parse(ap_id).host
857 name = List.last(String.split(ap_id, "/"))
858 nickname = "#{name}@#{domain}"
860 get_cached_by_nickname(nickname)
863 def set_cache({:ok, user}), do: set_cache(user)
864 def set_cache({:error, err}), do: {:error, err}
866 def set_cache(%User{} = user) do
867 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
868 Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
869 Cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
873 def update_and_set_cache(struct, params) do
875 |> update_changeset(params)
876 |> update_and_set_cache()
879 def update_and_set_cache(changeset) do
880 with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
885 def get_user_friends_ap_ids(user) do
886 from(u in User.get_friends_query(user), select: u.ap_id)
890 @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
891 def get_cached_user_friends_ap_ids(user) do
892 Cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
893 get_user_friends_ap_ids(user)
897 def invalidate_cache(user) do
898 Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
899 Cachex.del(:user_cache, "nickname:#{user.nickname}")
900 Cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
903 @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
904 def get_cached_by_ap_id(ap_id) do
905 key = "ap_id:#{ap_id}"
907 with {:ok, nil} <- Cachex.get(:user_cache, key),
908 user when not is_nil(user) <- get_by_ap_id(ap_id),
909 {:ok, true} <- Cachex.put(:user_cache, key, user) do
917 def get_cached_by_id(id) do
921 Cachex.fetch!(:user_cache, key, fn _ ->
925 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
926 {:commit, user.ap_id}
932 get_cached_by_ap_id(ap_id)
935 def get_cached_by_nickname(nickname) do
936 key = "nickname:#{nickname}"
938 Cachex.fetch!(:user_cache, key, fn ->
939 case get_or_fetch_by_nickname(nickname) do
940 {:ok, user} -> {:commit, user}
941 {:error, _error} -> {:ignore, nil}
946 def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
947 restrict_to_local = Pleroma.Config.get([:instance, :limit_to_local_content])
950 is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
951 get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
953 restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
954 get_cached_by_nickname(nickname_or_id)
956 restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
957 get_cached_by_nickname(nickname_or_id)
964 @spec get_by_nickname(String.t()) :: User.t() | nil
965 def get_by_nickname(nickname) do
966 Repo.get_by(User, nickname: nickname) ||
967 if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
968 Repo.get_by(User, nickname: local_nickname(nickname))
972 def get_by_email(email), do: Repo.get_by(User, email: email)
974 def get_by_nickname_or_email(nickname_or_email) do
975 get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
978 def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
980 def get_or_fetch_by_nickname(nickname) do
981 with %User{} = user <- get_by_nickname(nickname) do
985 with [_nick, _domain] <- String.split(nickname, "@"),
986 {:ok, user} <- fetch_by_nickname(nickname) do
989 _e -> {:error, "not found " <> nickname}
994 @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
995 def get_followers_query(%User{} = user, nil) do
996 User.Query.build(%{followers: user, deactivated: false})
999 def get_followers_query(user, page) do
1001 |> get_followers_query(nil)
1002 |> User.Query.paginate(page, 20)
1005 @spec get_followers_query(User.t()) :: Ecto.Query.t()
1006 def get_followers_query(user), do: get_followers_query(user, nil)
1008 @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1009 def get_followers(user, page \\ nil) do
1011 |> get_followers_query(page)
1015 @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1016 def get_external_followers(user, page \\ nil) do
1018 |> get_followers_query(page)
1019 |> User.Query.build(%{external: true})
1023 def get_followers_ids(user, page \\ nil) do
1025 |> get_followers_query(page)
1026 |> select([u], u.id)
1030 @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1031 def get_friends_query(%User{} = user, nil) do
1032 User.Query.build(%{friends: user, deactivated: false})
1035 def get_friends_query(user, page) do
1037 |> get_friends_query(nil)
1038 |> User.Query.paginate(page, 20)
1041 @spec get_friends_query(User.t()) :: Ecto.Query.t()
1042 def get_friends_query(user), do: get_friends_query(user, nil)
1044 def get_friends(user, page \\ nil) do
1046 |> get_friends_query(page)
1050 def get_friends_ap_ids(user) do
1052 |> get_friends_query(nil)
1053 |> select([u], u.ap_id)
1057 def get_friends_ids(user, page \\ nil) do
1059 |> get_friends_query(page)
1060 |> select([u], u.id)
1064 defdelegate get_follow_requests(user), to: FollowingRelationship
1066 def increase_note_count(%User{} = user) do
1068 |> where(id: ^user.id)
1069 |> update([u], inc: [note_count: 1])
1071 |> Repo.update_all([])
1073 {1, [user]} -> set_cache(user)
1078 def decrease_note_count(%User{} = user) do
1080 |> where(id: ^user.id)
1083 note_count: fragment("greatest(0, note_count - 1)")
1087 |> Repo.update_all([])
1089 {1, [user]} -> set_cache(user)
1094 def update_note_count(%User{} = user, note_count \\ nil) do
1099 where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1105 |> cast(%{note_count: note_count}, [:note_count])
1106 |> update_and_set_cache()
1109 @spec maybe_fetch_follow_information(User.t()) :: User.t()
1110 def maybe_fetch_follow_information(user) do
1111 with {:ok, user} <- fetch_follow_information(user) do
1115 Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1121 def fetch_follow_information(user) do
1122 with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1124 |> follow_information_changeset(info)
1125 |> update_and_set_cache()
1129 defp follow_information_changeset(user, params) do
1136 :hide_followers_count,
1141 @spec update_follower_count(User.t()) :: {:ok, User.t()}
1142 def update_follower_count(%User{} = user) do
1143 if user.local or !Pleroma.Config.get([:instance, :external_user_synchronization]) do
1144 follower_count = FollowingRelationship.follower_count(user)
1147 |> follow_information_changeset(%{follower_count: follower_count})
1148 |> update_and_set_cache
1150 {:ok, maybe_fetch_follow_information(user)}
1154 @spec update_following_count(User.t()) :: {:ok, User.t()}
1155 def update_following_count(%User{local: false} = user) do
1156 if Pleroma.Config.get([:instance, :external_user_synchronization]) do
1157 {:ok, maybe_fetch_follow_information(user)}
1163 def update_following_count(%User{local: true} = user) do
1164 following_count = FollowingRelationship.following_count(user)
1167 |> follow_information_changeset(%{following_count: following_count})
1168 |> update_and_set_cache()
1171 def set_unread_conversation_count(%User{local: true} = user) do
1172 unread_query = Participation.unread_conversation_count_for_user(user)
1175 |> join(:inner, [u], p in subquery(unread_query))
1177 set: [unread_conversation_count: p.count]
1179 |> where([u], u.id == ^user.id)
1181 |> Repo.update_all([])
1183 {1, [user]} -> set_cache(user)
1188 def set_unread_conversation_count(user), do: {:ok, user}
1190 def increment_unread_conversation_count(conversation, %User{local: true} = user) do
1192 Participation.unread_conversation_count_for_user(user)
1193 |> where([p], p.conversation_id == ^conversation.id)
1196 |> join(:inner, [u], p in subquery(unread_query))
1198 inc: [unread_conversation_count: 1]
1200 |> where([u], u.id == ^user.id)
1201 |> where([u, p], p.count == 0)
1203 |> Repo.update_all([])
1205 {1, [user]} -> set_cache(user)
1210 def increment_unread_conversation_count(_, user), do: {:ok, user}
1212 @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1213 def get_users_from_set(ap_ids, opts \\ []) do
1214 local_only = Keyword.get(opts, :local_only, true)
1215 criteria = %{ap_id: ap_ids, deactivated: false}
1216 criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1218 User.Query.build(criteria)
1222 @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1223 def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1226 query = User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
1232 @spec mute(User.t(), User.t(), boolean()) ::
1233 {:ok, list(UserRelationship.t())} | {:error, String.t()}
1234 def mute(%User{} = muter, %User{} = mutee, notifications? \\ true) do
1235 add_to_mutes(muter, mutee, notifications?)
1238 def unmute(%User{} = muter, %User{} = mutee) do
1239 remove_from_mutes(muter, mutee)
1242 def subscribe(%User{} = subscriber, %User{} = target) do
1243 deny_follow_blocked = Pleroma.Config.get([:user, :deny_follow_blocked])
1245 if blocks?(target, subscriber) and deny_follow_blocked do
1246 {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1248 # Note: the relationship is inverse: subscriber acts as relationship target
1249 UserRelationship.create_inverse_subscription(target, subscriber)
1253 def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1254 with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1255 subscribe(subscriber, subscribee)
1259 def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1260 # Note: the relationship is inverse: subscriber acts as relationship target
1261 UserRelationship.delete_inverse_subscription(target, unsubscriber)
1264 def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1265 with %User{} = user <- get_cached_by_ap_id(ap_id) do
1266 unsubscribe(unsubscriber, user)
1270 def block(%User{} = blocker, %User{} = blocked) do
1271 # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1273 if following?(blocker, blocked) do
1274 {:ok, blocker, _} = unfollow(blocker, blocked)
1280 # clear any requested follows as well
1282 case CommonAPI.reject_follow_request(blocked, blocker) do
1283 {:ok, %User{} = updated_blocked} -> updated_blocked
1287 unsubscribe(blocked, blocker)
1289 if following?(blocked, blocker), do: unfollow(blocked, blocker)
1291 {:ok, blocker} = update_follower_count(blocker)
1292 {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1293 add_to_block(blocker, blocked)
1296 # helper to handle the block given only an actor's AP id
1297 def block(%User{} = blocker, %{ap_id: ap_id}) do
1298 block(blocker, get_cached_by_ap_id(ap_id))
1301 def unblock(%User{} = blocker, %User{} = blocked) do
1302 remove_from_block(blocker, blocked)
1305 # helper to handle the block given only an actor's AP id
1306 def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1307 unblock(blocker, get_cached_by_ap_id(ap_id))
1310 def mutes?(nil, _), do: false
1311 def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1313 def mutes_user?(%User{} = user, %User{} = target) do
1314 UserRelationship.mute_exists?(user, target)
1317 @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1318 def muted_notifications?(nil, _), do: false
1320 def muted_notifications?(%User{} = user, %User{} = target),
1321 do: UserRelationship.notification_mute_exists?(user, target)
1323 def blocks?(nil, _), do: false
1325 def blocks?(%User{} = user, %User{} = target) do
1326 blocks_user?(user, target) ||
1327 (blocks_domain?(user, target) and not User.following?(user, target))
1330 def blocks_user?(%User{} = user, %User{} = target) do
1331 UserRelationship.block_exists?(user, target)
1334 def blocks_user?(_, _), do: false
1336 def blocks_domain?(%User{} = user, %User{} = target) do
1337 domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1338 %{host: host} = URI.parse(target.ap_id)
1339 Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1342 def blocks_domain?(_, _), do: false
1344 def subscribed_to?(%User{} = user, %User{} = target) do
1345 # Note: the relationship is inverse: subscriber acts as relationship target
1346 UserRelationship.inverse_subscription_exists?(target, user)
1349 def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1350 with %User{} = target <- get_cached_by_ap_id(ap_id) do
1351 subscribed_to?(user, target)
1356 Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1357 E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1359 @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1360 def outgoing_relationships_ap_ids(_user, []), do: %{}
1362 def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1364 def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1365 when is_list(relationship_types) do
1368 |> assoc(:outgoing_relationships)
1369 |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1370 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1371 |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1372 |> group_by([user_rel, u], user_rel.relationship_type)
1374 |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1379 fn rel_type -> {rel_type, db_result[rel_type] || []} end
1383 def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1385 def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1387 def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1389 def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1390 when is_list(relationship_types) do
1392 |> assoc(:incoming_relationships)
1393 |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1394 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1395 |> maybe_filter_on_ap_id(ap_ids)
1396 |> select([user_rel, u], u.ap_id)
1401 defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1402 where(query, [user_rel, u], u.ap_id in ^ap_ids)
1405 defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1407 def deactivate_async(user, status \\ true) do
1408 BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
1411 def deactivate(user, status \\ true)
1413 def deactivate(users, status) when is_list(users) do
1414 Repo.transaction(fn ->
1415 for user <- users, do: deactivate(user, status)
1419 def deactivate(%User{} = user, status) do
1420 with {:ok, user} <- set_activation_status(user, status) do
1423 |> Enum.filter(& &1.local)
1424 |> Enum.each(&set_cache(update_following_count(&1)))
1426 # Only update local user counts, remote will be update during the next pull.
1429 |> Enum.filter(& &1.local)
1430 |> Enum.each(&do_unfollow(user, &1))
1436 def update_notification_settings(%User{} = user, settings) do
1438 |> cast(%{notification_settings: settings}, [])
1439 |> cast_embed(:notification_settings)
1440 |> validate_required([:notification_settings])
1441 |> update_and_set_cache()
1444 def delete(users) when is_list(users) do
1445 for user <- users, do: delete(user)
1448 def delete(%User{} = user) do
1449 BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1452 defp delete_and_invalidate_cache(%User{} = user) do
1453 invalidate_cache(user)
1457 defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)
1459 defp delete_or_deactivate(%User{local: true} = user) do
1460 status = account_status(user)
1462 if status == :confirmation_pending do
1463 delete_and_invalidate_cache(user)
1466 |> change(%{deactivated: true, email: nil})
1467 |> update_and_set_cache()
1471 def perform(:force_password_reset, user), do: force_password_reset(user)
1473 @spec perform(atom(), User.t()) :: {:ok, User.t()}
1474 def perform(:delete, %User{} = user) do
1475 # Remove all relationships
1478 |> Enum.each(fn follower ->
1479 ActivityPub.unfollow(follower, user)
1480 unfollow(follower, user)
1485 |> Enum.each(fn followed ->
1486 ActivityPub.unfollow(user, followed)
1487 unfollow(user, followed)
1490 delete_user_activities(user)
1491 delete_notifications_from_user_activities(user)
1493 delete_outgoing_pending_follow_requests(user)
1495 delete_or_deactivate(user)
1498 def perform(:deactivate_async, user, status), do: deactivate(user, status)
1500 @spec perform(atom(), User.t(), list()) :: list() | {:error, any()}
1501 def perform(:blocks_import, %User{} = blocker, blocked_identifiers)
1502 when is_list(blocked_identifiers) do
1504 blocked_identifiers,
1505 fn blocked_identifier ->
1506 with {:ok, %User{} = blocked} <- get_or_fetch(blocked_identifier),
1507 {:ok, _user_block} <- block(blocker, blocked),
1508 {:ok, _} <- ActivityPub.block(blocker, blocked) do
1512 Logger.debug("blocks_import failed for #{blocked_identifier} with: #{inspect(err)}")
1519 def perform(:follow_import, %User{} = follower, followed_identifiers)
1520 when is_list(followed_identifiers) do
1522 followed_identifiers,
1523 fn followed_identifier ->
1524 with {:ok, %User{} = followed} <- get_or_fetch(followed_identifier),
1525 {:ok, follower} <- maybe_direct_follow(follower, followed),
1526 {:ok, _} <- ActivityPub.follow(follower, followed) do
1530 Logger.debug("follow_import failed for #{followed_identifier} with: #{inspect(err)}")
1537 @spec external_users_query() :: Ecto.Query.t()
1538 def external_users_query do
1546 @spec external_users(keyword()) :: [User.t()]
1547 def external_users(opts \\ []) do
1549 external_users_query()
1550 |> select([u], struct(u, [:id, :ap_id]))
1554 do: where(query, [u], u.id > ^opts[:max_id]),
1559 do: limit(query, ^opts[:limit]),
1565 def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers) do
1566 BackgroundWorker.enqueue("blocks_import", %{
1567 "blocker_id" => blocker.id,
1568 "blocked_identifiers" => blocked_identifiers
1572 def follow_import(%User{} = follower, followed_identifiers)
1573 when is_list(followed_identifiers) do
1574 BackgroundWorker.enqueue("follow_import", %{
1575 "follower_id" => follower.id,
1576 "followed_identifiers" => followed_identifiers
1580 def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1582 |> join(:inner, [n], activity in assoc(n, :activity))
1583 |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1584 |> Repo.delete_all()
1587 def delete_user_activities(%User{ap_id: ap_id} = user) do
1589 |> Activity.Queries.by_actor()
1590 |> RepoStreamer.chunk_stream(50)
1591 |> Stream.each(fn activities ->
1592 Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1597 defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1598 with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1599 {:ok, delete_data, _} <- Builder.delete(user, object) do
1600 Pipeline.common_pipeline(delete_data, local: user.local)
1602 {:find_object, nil} ->
1603 # We have the create activity, but not the object, it was probably pruned.
1604 # Insert a tombstone and try again
1605 with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1606 {:ok, _tombstone} <- Object.create(tombstone_data) do
1607 delete_activity(activity, user)
1611 Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1612 Logger.error("Error: #{inspect(e)}")
1616 defp delete_activity(%{data: %{"type" => type}} = activity, user)
1617 when type in ["Like", "Announce"] do
1618 {:ok, undo, _} = Builder.undo(user, activity)
1619 Pipeline.common_pipeline(undo, local: user.local)
1622 defp delete_activity(_activity, _user), do: "Doing nothing"
1624 defp delete_outgoing_pending_follow_requests(user) do
1626 |> FollowingRelationship.outgoing_pending_follow_requests_query()
1627 |> Repo.delete_all()
1630 def html_filter_policy(%User{no_rich_text: true}) do
1631 Pleroma.HTML.Scrubber.TwitterText
1634 def html_filter_policy(_), do: Pleroma.Config.get([:markup, :scrub_policy])
1636 def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1638 def get_or_fetch_by_ap_id(ap_id) do
1639 cached_user = get_cached_by_ap_id(ap_id)
1641 maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)
1643 case {cached_user, maybe_fetched_user} do
1644 {_, {:ok, %User{} = user}} ->
1647 {%User{} = user, _} ->
1651 {:error, :not_found}
1656 Creates an internal service actor by URI if missing.
1657 Optionally takes nickname for addressing.
1659 @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1660 def get_or_create_service_actor_by_ap_id(uri, nickname) do
1662 case get_cached_by_ap_id(uri) do
1664 with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1665 Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1669 %User{invisible: false} = user ->
1679 @spec set_invisible(User.t()) :: {:ok, User.t()}
1680 defp set_invisible(user) do
1682 |> change(%{invisible: true})
1683 |> update_and_set_cache()
1686 @spec create_service_actor(String.t(), String.t()) ::
1687 {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1688 defp create_service_actor(uri, nickname) do
1694 follower_address: uri <> "/followers"
1697 |> unique_constraint(:nickname)
1702 def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1705 |> :public_key.pem_decode()
1707 |> :public_key.pem_entry_decode()
1712 def public_key(_), do: {:error, "key not found"}
1714 def get_public_key_for_ap_id(ap_id) do
1715 with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1716 {:ok, public_key} <- public_key(user) do
1723 def ap_enabled?(%User{local: true}), do: true
1724 def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1725 def ap_enabled?(_), do: false
1727 @doc "Gets or fetch a user by uri or nickname."
1728 @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1729 def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1730 def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1732 # wait a period of time and return newest version of the User structs
1733 # this is because we have synchronous follow APIs and need to simulate them
1734 # with an async handshake
1735 def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1736 with %User{} = a <- get_cached_by_id(a.id),
1737 %User{} = b <- get_cached_by_id(b.id) do
1744 def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1745 with :ok <- :timer.sleep(timeout),
1746 %User{} = a <- get_cached_by_id(a.id),
1747 %User{} = b <- get_cached_by_id(b.id) do
1754 def parse_bio(bio) when is_binary(bio) and bio != "" do
1756 |> CommonUtils.format_input("text/plain", mentions_format: :full)
1760 def parse_bio(_), do: ""
1762 def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1763 # TODO: get profile URLs other than user.ap_id
1764 profile_urls = [user.ap_id]
1767 |> CommonUtils.format_input("text/plain",
1768 mentions_format: :full,
1769 rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1774 def parse_bio(_, _), do: ""
1776 def tag(user_identifiers, tags) when is_list(user_identifiers) do
1777 Repo.transaction(fn ->
1778 for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1782 def tag(nickname, tags) when is_binary(nickname),
1783 do: tag(get_by_nickname(nickname), tags)
1785 def tag(%User{} = user, tags),
1786 do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1788 def untag(user_identifiers, tags) when is_list(user_identifiers) do
1789 Repo.transaction(fn ->
1790 for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1794 def untag(nickname, tags) when is_binary(nickname),
1795 do: untag(get_by_nickname(nickname), tags)
1797 def untag(%User{} = user, tags),
1798 do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1800 defp update_tags(%User{} = user, new_tags) do
1801 {:ok, updated_user} =
1803 |> change(%{tags: new_tags})
1804 |> update_and_set_cache()
1809 defp normalize_tags(tags) do
1812 |> Enum.map(&String.downcase/1)
1815 defp local_nickname_regex do
1816 if Pleroma.Config.get([:instance, :extended_nickname_format]) do
1817 @extended_local_nickname_regex
1819 @strict_local_nickname_regex
1823 def local_nickname(nickname_or_mention) do
1826 |> String.split("@")
1830 def full_nickname(nickname_or_mention),
1831 do: String.trim_leading(nickname_or_mention, "@")
1833 def error_user(ap_id) do
1837 nickname: "erroruser@example.com",
1838 inserted_at: NaiveDateTime.utc_now()
1842 @spec all_superusers() :: [User.t()]
1843 def all_superusers do
1844 User.Query.build(%{super_users: true, local: true, deactivated: false})
1848 def muting_reblogs?(%User{} = user, %User{} = target) do
1849 UserRelationship.reblog_mute_exists?(user, target)
1852 def showing_reblogs?(%User{} = user, %User{} = target) do
1853 not muting_reblogs?(user, target)
1857 The function returns a query to get users with no activity for given interval of days.
1858 Inactive users are those who didn't read any notification, or had any activity where
1859 the user is the activity's actor, during `inactivity_threshold` days.
1860 Deactivated users will not appear in this list.
1864 iex> Pleroma.User.list_inactive_users()
1867 @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
1868 def list_inactive_users_query(inactivity_threshold \\ 7) do
1869 negative_inactivity_threshold = -inactivity_threshold
1870 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
1871 # Subqueries are not supported in `where` clauses, join gets too complicated.
1872 has_read_notifications =
1873 from(n in Pleroma.Notification,
1874 where: n.seen == true,
1876 having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
1879 |> Pleroma.Repo.all()
1881 from(u in Pleroma.User,
1882 left_join: a in Pleroma.Activity,
1883 on: u.ap_id == a.actor,
1884 where: not is_nil(u.nickname),
1885 where: u.deactivated != ^true,
1886 where: u.id not in ^has_read_notifications,
1889 max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
1890 is_nil(max(a.inserted_at))
1895 Enable or disable email notifications for user
1899 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
1900 Pleroma.User{email_notifications: %{"digest" => true}}
1902 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
1903 Pleroma.User{email_notifications: %{"digest" => false}}
1905 @spec switch_email_notifications(t(), String.t(), boolean()) ::
1906 {:ok, t()} | {:error, Ecto.Changeset.t()}
1907 def switch_email_notifications(user, type, status) do
1908 User.update_email_notifications(user, %{type => status})
1912 Set `last_digest_emailed_at` value for the user to current time
1914 @spec touch_last_digest_emailed_at(t()) :: t()
1915 def touch_last_digest_emailed_at(user) do
1916 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
1918 {:ok, updated_user} =
1920 |> change(%{last_digest_emailed_at: now})
1921 |> update_and_set_cache()
1926 @spec toggle_confirmation(User.t()) :: {:ok, User.t()} | {:error, Changeset.t()}
1927 def toggle_confirmation(%User{} = user) do
1929 |> confirmation_changeset(need_confirmation: !user.confirmation_pending)
1930 |> update_and_set_cache()
1933 @spec toggle_confirmation([User.t()]) :: [{:ok, User.t()} | {:error, Changeset.t()}]
1934 def toggle_confirmation(users) do
1935 Enum.map(users, &toggle_confirmation/1)
1938 def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
1942 def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
1943 # use instance-default
1944 config = Pleroma.Config.get([:assets, :mascots])
1945 default_mascot = Pleroma.Config.get([:assets, :default_mascot])
1946 mascot = Keyword.get(config, default_mascot)
1949 "id" => "default-mascot",
1950 "url" => mascot[:url],
1951 "preview_url" => mascot[:url],
1953 "mime_type" => mascot[:mime_type]
1958 def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
1960 def ensure_keys_present(%User{} = user) do
1961 with {:ok, pem} <- Keys.generate_rsa_pem() do
1963 |> cast(%{keys: pem}, [:keys])
1964 |> validate_required([:keys])
1965 |> update_and_set_cache()
1969 def get_ap_ids_by_nicknames(nicknames) do
1971 where: u.nickname in ^nicknames,
1977 defdelegate search(query, opts \\ []), to: User.Search
1979 defp put_password_hash(
1980 %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
1982 change(changeset, password_hash: Pbkdf2.hash_pwd_salt(password))
1985 defp put_password_hash(changeset), do: changeset
1987 def is_internal_user?(%User{nickname: nil}), do: true
1988 def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
1989 def is_internal_user?(_), do: false
1991 # A hack because user delete activities have a fake id for whatever reason
1992 # TODO: Get rid of this
1993 def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
1995 def get_delivered_users_by_object_id(object_id) do
1997 inner_join: delivery in assoc(u, :deliveries),
1998 where: delivery.object_id == ^object_id
2003 def change_email(user, email) do
2005 |> cast(%{email: email}, [:email])
2006 |> validate_required([:email])
2007 |> unique_constraint(:email)
2008 |> validate_format(:email, @email_regex)
2009 |> update_and_set_cache()
2012 # Internal function; public one is `deactivate/2`
2013 defp set_activation_status(user, deactivated) do
2015 |> cast(%{deactivated: deactivated}, [:deactivated])
2016 |> update_and_set_cache()
2019 def update_banner(user, banner) do
2021 |> cast(%{banner: banner}, [:banner])
2022 |> update_and_set_cache()
2025 def update_background(user, background) do
2027 |> cast(%{background: background}, [:background])
2028 |> update_and_set_cache()
2031 def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
2034 moderator: is_moderator
2038 def validate_fields(changeset, remote? \\ false) do
2039 limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2040 limit = Pleroma.Config.get([:instance, limit_name], 0)
2043 |> validate_length(:fields, max: limit)
2044 |> validate_change(:fields, fn :fields, fields ->
2045 if Enum.all?(fields, &valid_field?/1) do
2053 defp valid_field?(%{"name" => name, "value" => value}) do
2054 name_limit = Pleroma.Config.get([:instance, :account_field_name_length], 255)
2055 value_limit = Pleroma.Config.get([:instance, :account_field_value_length], 255)
2057 is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2058 String.length(value) <= value_limit
2061 defp valid_field?(_), do: false
2063 defp truncate_field(%{"name" => name, "value" => value}) do
2065 String.split_at(name, Pleroma.Config.get([:instance, :account_field_name_length], 255))
2068 String.split_at(value, Pleroma.Config.get([:instance, :account_field_value_length], 255))
2070 %{"name" => name, "value" => value}
2073 def admin_api_update(user, params) do
2080 |> update_and_set_cache()
2083 @doc "Signs user out of all applications"
2084 def global_sign_out(user) do
2085 OAuth.Authorization.delete_user_authorizations(user)
2086 OAuth.Token.delete_user_tokens(user)
2089 def mascot_update(user, url) do
2091 |> cast(%{mascot: url}, [:mascot])
2092 |> validate_required([:mascot])
2093 |> update_and_set_cache()
2096 def mastodon_settings_update(user, settings) do
2098 |> cast(%{settings: settings}, [:settings])
2099 |> validate_required([:settings])
2100 |> update_and_set_cache()
2103 @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2104 def confirmation_changeset(user, need_confirmation: need_confirmation?) do
2106 if need_confirmation? do
2108 confirmation_pending: true,
2109 confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2113 confirmation_pending: false,
2114 confirmation_token: nil
2118 cast(user, params, [:confirmation_pending, :confirmation_token])
2121 def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2122 if id not in user.pinned_activities do
2123 max_pinned_statuses = Pleroma.Config.get([:instance, :max_pinned_statuses], 0)
2124 params = %{pinned_activities: user.pinned_activities ++ [id]}
2127 |> cast(params, [:pinned_activities])
2128 |> validate_length(:pinned_activities,
2129 max: max_pinned_statuses,
2130 message: "You have already pinned the maximum number of statuses"
2135 |> update_and_set_cache()
2138 def remove_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2139 params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2142 |> cast(params, [:pinned_activities])
2143 |> update_and_set_cache()
2146 def update_email_notifications(user, settings) do
2147 email_notifications =
2148 user.email_notifications
2149 |> Map.merge(settings)
2150 |> Map.take(["digest"])
2152 params = %{email_notifications: email_notifications}
2153 fields = [:email_notifications]
2156 |> cast(params, fields)
2157 |> validate_required(fields)
2158 |> update_and_set_cache()
2161 defp set_domain_blocks(user, domain_blocks) do
2162 params = %{domain_blocks: domain_blocks}
2165 |> cast(params, [:domain_blocks])
2166 |> validate_required([:domain_blocks])
2167 |> update_and_set_cache()
2170 def block_domain(user, domain_blocked) do
2171 set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2174 def unblock_domain(user, domain_blocked) do
2175 set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2178 @spec add_to_block(User.t(), User.t()) ::
2179 {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2180 defp add_to_block(%User{} = user, %User{} = blocked) do
2181 UserRelationship.create_block(user, blocked)
2184 @spec add_to_block(User.t(), User.t()) ::
2185 {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2186 defp remove_from_block(%User{} = user, %User{} = blocked) do
2187 UserRelationship.delete_block(user, blocked)
2190 defp add_to_mutes(%User{} = user, %User{} = muted_user, notifications?) do
2191 with {:ok, user_mute} <- UserRelationship.create_mute(user, muted_user),
2192 {:ok, user_notification_mute} <-
2193 (notifications? && UserRelationship.create_notification_mute(user, muted_user)) ||
2195 {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
2199 defp remove_from_mutes(user, %User{} = muted_user) do
2200 with {:ok, user_mute} <- UserRelationship.delete_mute(user, muted_user),
2201 {:ok, user_notification_mute} <-
2202 UserRelationship.delete_notification_mute(user, muted_user) do
2203 {:ok, [user_mute, user_notification_mute]}
2207 def set_invisible(user, invisible) do
2208 params = %{invisible: invisible}
2211 |> cast(params, [:invisible])
2212 |> validate_required([:invisible])
2213 |> update_and_set_cache()
2216 def sanitize_html(%User{} = user) do
2217 sanitize_html(user, nil)
2220 # User data that mastodon isn't filtering (treated as plaintext):
2223 def sanitize_html(%User{} = user, filter) do
2225 Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2228 "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2233 |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2234 |> Map.put(:fields, fields)