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 ::
48 | :password_reset_pending
49 | :confirmation_pending
51 @primary_key {:id, FlakeId.Ecto.CompatType, autogenerate: true}
53 # credo:disable-for-next-line Credo.Check.Readability.MaxLineLength
54 @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])?)*$/
56 @strict_local_nickname_regex ~r/^[a-zA-Z\d]+$/
57 @extended_local_nickname_regex ~r/^[a-zA-Z\d_-]+$/
59 # AP ID user relationships (blocks, mutes etc.)
60 # Format: [rel_type: [outgoing_rel: :outgoing_rel_target, incoming_rel: :incoming_rel_source]]
61 @user_relationships_config [
63 blocker_blocks: :blocked_users,
64 blockee_blocks: :blocker_users
67 muter_mutes: :muted_users,
68 mutee_mutes: :muter_users
71 reblog_muter_mutes: :reblog_muted_users,
72 reblog_mutee_mutes: :reblog_muter_users
75 notification_muter_mutes: :notification_muted_users,
76 notification_mutee_mutes: :notification_muter_users
78 # Note: `inverse_subscription` relationship is inverse: subscriber acts as relationship target
79 inverse_subscription: [
80 subscribee_subscriptions: :subscriber_users,
81 subscriber_subscriptions: :subscribee_users
87 field(:raw_bio, :string)
88 field(:email, :string)
90 field(:nickname, :string)
91 field(:password_hash, :string)
92 field(:password, :string, virtual: true)
93 field(:password_confirmation, :string, virtual: true)
95 field(:public_key, :string)
96 field(:ap_id, :string)
97 field(:avatar, :map, default: %{})
98 field(:local, :boolean, default: true)
99 field(:follower_address, :string)
100 field(:following_address, :string)
101 field(:search_rank, :float, virtual: true)
102 field(:search_type, :integer, virtual: true)
103 field(:tags, {:array, :string}, default: [])
104 field(:last_refreshed_at, :naive_datetime_usec)
105 field(:last_digest_emailed_at, :naive_datetime)
106 field(:banner, :map, default: %{})
107 field(:background, :map, default: %{})
108 field(:note_count, :integer, default: 0)
109 field(:follower_count, :integer, default: 0)
110 field(:following_count, :integer, default: 0)
111 field(:locked, :boolean, default: false)
112 field(:confirmation_pending, :boolean, default: false)
113 field(:password_reset_pending, :boolean, default: false)
114 field(:approval_pending, :boolean, default: false)
115 field(:registration_reason, :string, default: nil)
116 field(:confirmation_token, :string, default: nil)
117 field(:default_scope, :string, default: "public")
118 field(:domain_blocks, {:array, :string}, default: [])
119 field(:deactivated, :boolean, default: false)
120 field(:no_rich_text, :boolean, default: false)
121 field(:ap_enabled, :boolean, default: false)
122 field(:is_moderator, :boolean, default: false)
123 field(:is_admin, :boolean, default: false)
124 field(:show_role, :boolean, default: true)
125 field(:mastofe_settings, :map, default: nil)
126 field(:uri, ObjectValidators.Uri, default: nil)
127 field(:hide_followers_count, :boolean, default: false)
128 field(:hide_follows_count, :boolean, default: false)
129 field(:hide_followers, :boolean, default: false)
130 field(:hide_follows, :boolean, default: false)
131 field(:hide_favorites, :boolean, default: true)
132 field(:unread_conversation_count, :integer, default: 0)
133 field(:pinned_activities, {:array, :string}, default: [])
134 field(:email_notifications, :map, default: %{"digest" => false})
135 field(:mascot, :map, default: nil)
136 field(:emoji, :map, default: %{})
137 field(:pleroma_settings_store, :map, default: %{})
138 field(:fields, {:array, :map}, default: [])
139 field(:raw_fields, {:array, :map}, default: [])
140 field(:discoverable, :boolean, default: false)
141 field(:invisible, :boolean, default: false)
142 field(:allow_following_move, :boolean, default: true)
143 field(:skip_thread_containment, :boolean, default: false)
144 field(:actor_type, :string, default: "Person")
145 field(:also_known_as, {:array, :string}, default: [])
146 field(:inbox, :string)
147 field(:shared_inbox, :string)
148 field(:accepts_chat_messages, :boolean, default: nil)
151 :notification_settings,
152 Pleroma.User.NotificationSetting,
156 has_many(:notifications, Notification)
157 has_many(:registrations, Registration)
158 has_many(:deliveries, Delivery)
160 has_many(:outgoing_relationships, UserRelationship, foreign_key: :source_id)
161 has_many(:incoming_relationships, UserRelationship, foreign_key: :target_id)
163 for {relationship_type,
165 {outgoing_relation, outgoing_relation_target},
166 {incoming_relation, incoming_relation_source}
167 ]} <- @user_relationships_config do
168 # Definitions of `has_many` relations: :blocker_blocks, :muter_mutes, :reblog_muter_mutes,
169 # :notification_muter_mutes, :subscribee_subscriptions
170 has_many(outgoing_relation, UserRelationship,
171 foreign_key: :source_id,
172 where: [relationship_type: relationship_type]
175 # Definitions of `has_many` relations: :blockee_blocks, :mutee_mutes, :reblog_mutee_mutes,
176 # :notification_mutee_mutes, :subscriber_subscriptions
177 has_many(incoming_relation, UserRelationship,
178 foreign_key: :target_id,
179 where: [relationship_type: relationship_type]
182 # Definitions of `has_many` relations: :blocked_users, :muted_users, :reblog_muted_users,
183 # :notification_muted_users, :subscriber_users
184 has_many(outgoing_relation_target, through: [outgoing_relation, :target])
186 # Definitions of `has_many` relations: :blocker_users, :muter_users, :reblog_muter_users,
187 # :notification_muter_users, :subscribee_users
188 has_many(incoming_relation_source, through: [incoming_relation, :source])
191 # `:blocks` is deprecated (replaced with `blocked_users` relation)
192 field(:blocks, {:array, :string}, default: [])
193 # `:mutes` is deprecated (replaced with `muted_users` relation)
194 field(:mutes, {:array, :string}, default: [])
195 # `:muted_reblogs` is deprecated (replaced with `reblog_muted_users` relation)
196 field(:muted_reblogs, {:array, :string}, default: [])
197 # `:muted_notifications` is deprecated (replaced with `notification_muted_users` relation)
198 field(:muted_notifications, {:array, :string}, default: [])
199 # `:subscribers` is deprecated (replaced with `subscriber_users` relation)
200 field(:subscribers, {:array, :string}, default: [])
203 :multi_factor_authentication_settings,
211 for {_relationship_type, [{_outgoing_relation, outgoing_relation_target}, _]} <-
212 @user_relationships_config do
213 # `def blocked_users_relation/2`, `def muted_users_relation/2`,
214 # `def reblog_muted_users_relation/2`, `def notification_muted_users/2`,
215 # `def subscriber_users/2`
216 def unquote(:"#{outgoing_relation_target}_relation")(user, restrict_deactivated? \\ false) do
217 target_users_query = assoc(user, unquote(outgoing_relation_target))
219 if restrict_deactivated? do
220 restrict_deactivated(target_users_query)
226 # `def blocked_users/2`, `def muted_users/2`, `def reblog_muted_users/2`,
227 # `def notification_muted_users/2`, `def subscriber_users/2`
228 def unquote(outgoing_relation_target)(user, restrict_deactivated? \\ false) do
230 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
232 restrict_deactivated?
237 # `def blocked_users_ap_ids/2`, `def muted_users_ap_ids/2`, `def reblog_muted_users_ap_ids/2`,
238 # `def notification_muted_users_ap_ids/2`, `def subscriber_users_ap_ids/2`
239 def unquote(:"#{outgoing_relation_target}_ap_ids")(user, restrict_deactivated? \\ false) do
241 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
243 restrict_deactivated?
245 |> select([u], u.ap_id)
251 Dumps Flake Id to SQL-compatible format (16-byte UUID).
252 E.g. "9pQtDGXuq4p3VlcJEm" -> <<0, 0, 1, 110, 179, 218, 42, 92, 213, 41, 44, 227, 95, 213, 0, 0>>
254 def binary_id(source_id) when is_binary(source_id) do
255 with {:ok, dumped_id} <- FlakeId.Ecto.CompatType.dump(source_id) do
262 def binary_id(source_ids) when is_list(source_ids) do
263 Enum.map(source_ids, &binary_id/1)
266 def binary_id(%User{} = user), do: binary_id(user.id)
268 @doc "Returns status account"
269 @spec account_status(User.t()) :: account_status()
270 def account_status(%User{deactivated: true}), do: :deactivated
271 def account_status(%User{password_reset_pending: true}), do: :password_reset_pending
272 def account_status(%User{approval_pending: true}), do: :approval_pending
274 def account_status(%User{confirmation_pending: true}) do
275 if Config.get([:instance, :account_activation_required]) do
276 :confirmation_pending
282 def account_status(%User{}), do: :active
284 @spec visible_for(User.t(), User.t() | nil) ::
287 | :restricted_unauthenticated
289 | :confirmation_pending
290 def visible_for(user, for_user \\ nil)
292 def visible_for(%User{invisible: true}, _), do: :invisible
294 def visible_for(%User{id: user_id}, %User{id: user_id}), do: :visible
296 def visible_for(%User{} = user, nil) do
297 if restrict_unauthenticated?(user) do
298 :restrict_unauthenticated
300 visible_account_status(user)
304 def visible_for(%User{} = user, for_user) do
305 if superuser?(for_user) do
308 visible_account_status(user)
312 def visible_for(_, _), do: :invisible
314 defp restrict_unauthenticated?(%User{local: local}) do
315 config_key = if local, do: :local, else: :remote
317 Config.get([:restrict_unauthenticated, :profiles, config_key], false)
320 defp visible_account_status(user) do
321 status = account_status(user)
323 if status in [:active, :password_reset_pending] do
330 @spec superuser?(User.t()) :: boolean()
331 def superuser?(%User{local: true, is_admin: true}), do: true
332 def superuser?(%User{local: true, is_moderator: true}), do: true
333 def superuser?(_), do: false
335 @spec invisible?(User.t()) :: boolean()
336 def invisible?(%User{invisible: true}), do: true
337 def invisible?(_), do: false
339 def avatar_url(user, options \\ []) do
341 %{"url" => [%{"href" => href} | _]} ->
345 unless options[:no_default] do
346 Config.get([:assets, :default_user_avatar], "#{Web.base_url()}/images/avi.png")
351 def banner_url(user, options \\ []) do
353 %{"url" => [%{"href" => href} | _]} -> href
354 _ -> !options[:no_default] && "#{Web.base_url()}/images/banner.png"
358 # Should probably be renamed or removed
359 def ap_id(%User{nickname: nickname}), do: "#{Web.base_url()}/users/#{nickname}"
361 def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
362 def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"
364 @spec ap_following(User.t()) :: String.t()
365 def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
366 def ap_following(%User{} = user), do: "#{ap_id(user)}/following"
368 @spec restrict_deactivated(Ecto.Query.t()) :: Ecto.Query.t()
369 def restrict_deactivated(query) do
370 from(u in query, where: u.deactivated != ^true)
373 defdelegate following_count(user), to: FollowingRelationship
375 defp truncate_fields_param(params) do
376 if Map.has_key?(params, :fields) do
377 Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
383 defp truncate_if_exists(params, key, max_length) do
384 if Map.has_key?(params, key) and is_binary(params[key]) do
385 {value, _chopped} = String.split_at(params[key], max_length)
386 Map.put(params, key, value)
392 defp fix_follower_address(%{follower_address: _, following_address: _} = params), do: params
394 defp fix_follower_address(%{nickname: nickname} = params),
395 do: Map.put(params, :follower_address, ap_followers(%User{nickname: nickname}))
397 defp fix_follower_address(params), do: params
399 def remote_user_changeset(struct \\ %User{local: false}, params) do
400 bio_limit = Config.get([:instance, :user_bio_length], 5000)
401 name_limit = Config.get([:instance, :user_name_length], 100)
404 case params[:name] do
405 name when is_binary(name) and byte_size(name) > 0 -> name
406 _ -> params[:nickname]
411 |> Map.put(:name, name)
412 |> Map.put_new(:last_refreshed_at, NaiveDateTime.utc_now())
413 |> truncate_if_exists(:name, name_limit)
414 |> truncate_if_exists(:bio, bio_limit)
415 |> truncate_fields_param()
416 |> fix_follower_address()
440 :hide_followers_count,
449 :accepts_chat_messages
452 |> validate_required([:name, :ap_id])
453 |> unique_constraint(:nickname)
454 |> validate_format(:nickname, @email_regex)
455 |> validate_length(:bio, max: bio_limit)
456 |> validate_length(:name, max: name_limit)
457 |> validate_fields(true)
460 def update_changeset(struct, params \\ %{}) do
461 bio_limit = Config.get([:instance, :user_bio_length], 5000)
462 name_limit = Config.get([:instance, :user_name_length], 100)
482 :hide_followers_count,
485 :allow_following_move,
488 :skip_thread_containment,
491 :pleroma_settings_store,
495 :accepts_chat_messages
498 |> unique_constraint(:nickname)
499 |> validate_format(:nickname, local_nickname_regex())
500 |> validate_length(:bio, max: bio_limit)
501 |> validate_length(:name, min: 1, max: name_limit)
502 |> validate_inclusion(:actor_type, ["Person", "Service"])
505 |> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
506 |> put_change_if_present(:avatar, &put_upload(&1, :avatar))
507 |> put_change_if_present(:banner, &put_upload(&1, :banner))
508 |> put_change_if_present(:background, &put_upload(&1, :background))
509 |> put_change_if_present(
510 :pleroma_settings_store,
511 &{:ok, Map.merge(struct.pleroma_settings_store, &1)}
513 |> validate_fields(false)
516 defp put_fields(changeset) do
517 if raw_fields = get_change(changeset, :raw_fields) do
520 |> Enum.filter(fn %{"name" => n} -> n != "" end)
524 |> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)
527 |> put_change(:raw_fields, raw_fields)
528 |> put_change(:fields, fields)
534 defp parse_fields(value) do
536 |> Formatter.linkify(mentions_format: :full)
540 defp put_emoji(changeset) do
541 emojified_fields = [:bio, :name, :raw_fields]
543 if Enum.any?(changeset.changes, fn {k, _} -> k in emojified_fields end) do
544 bio = Emoji.Formatter.get_emoji_map(get_field(changeset, :bio))
545 name = Emoji.Formatter.get_emoji_map(get_field(changeset, :name))
547 emoji = Map.merge(bio, name)
551 |> get_field(:raw_fields)
552 |> Enum.reduce(emoji, fn x, acc ->
553 Map.merge(acc, Emoji.Formatter.get_emoji_map(x["name"] <> x["value"]))
556 put_change(changeset, :emoji, emoji)
562 defp put_change_if_present(changeset, map_field, value_function) do
563 with {:ok, value} <- fetch_change(changeset, map_field),
564 {:ok, new_value} <- value_function.(value) do
565 put_change(changeset, map_field, new_value)
571 defp put_upload(value, type) do
572 with %Plug.Upload{} <- value,
573 {:ok, object} <- ActivityPub.upload(value, type: type) do
578 def update_as_admin_changeset(struct, params) do
580 |> update_changeset(params)
581 |> cast(params, [:email])
582 |> delete_change(:also_known_as)
583 |> unique_constraint(:email)
584 |> validate_format(:email, @email_regex)
585 |> validate_inclusion(:actor_type, ["Person", "Service"])
588 @spec update_as_admin(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
589 def update_as_admin(user, params) do
590 params = Map.put(params, "password_confirmation", params["password"])
591 changeset = update_as_admin_changeset(user, params)
593 if params["password"] do
594 reset_password(user, changeset, params)
596 User.update_and_set_cache(changeset)
600 def password_update_changeset(struct, params) do
602 |> cast(params, [:password, :password_confirmation])
603 |> validate_required([:password, :password_confirmation])
604 |> validate_confirmation(:password)
605 |> put_password_hash()
606 |> put_change(:password_reset_pending, false)
609 @spec reset_password(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
610 def reset_password(%User{} = user, params) do
611 reset_password(user, user, params)
614 def reset_password(%User{id: user_id} = user, struct, params) do
617 |> Multi.update(:user, password_update_changeset(struct, params))
618 |> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
619 |> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))
621 case Repo.transaction(multi) do
622 {:ok, %{user: user} = _} -> set_cache(user)
623 {:error, _, changeset, _} -> {:error, changeset}
627 def update_password_reset_pending(user, value) do
630 |> put_change(:password_reset_pending, value)
631 |> update_and_set_cache()
634 def force_password_reset_async(user) do
635 BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
638 @spec force_password_reset(User.t()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
639 def force_password_reset(user), do: update_password_reset_pending(user, true)
641 # Used to auto-register LDAP accounts which don't have a password hash
642 def register_changeset(struct, params = %{password: password})
643 when is_nil(password) do
644 params = Map.put_new(params, :accepts_chat_messages, true)
650 :accepts_chat_messages
652 |> unique_constraint(:nickname)
653 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
654 |> validate_format(:nickname, local_nickname_regex())
656 |> unique_constraint(:ap_id)
657 |> put_following_and_follower_address()
660 def register_changeset(struct, params \\ %{}, opts \\ []) do
661 bio_limit = Config.get([:instance, :user_bio_length], 5000)
662 name_limit = Config.get([:instance, :user_name_length], 100)
663 reason_limit = Config.get([:instance, :registration_reason_length], 500)
664 params = Map.put_new(params, :accepts_chat_messages, true)
667 if is_nil(opts[:need_confirmation]) do
668 Config.get([:instance, :account_activation_required])
670 opts[:need_confirmation]
674 if is_nil(opts[:need_approval]) do
675 Config.get([:instance, :account_approval_required])
681 |> confirmation_changeset(need_confirmation: need_confirmation?)
682 |> approval_changeset(need_approval: need_approval?)
690 :password_confirmation,
692 :accepts_chat_messages,
695 |> validate_required([:name, :nickname, :password, :password_confirmation])
696 |> validate_confirmation(:password)
697 |> unique_constraint(:email)
698 |> validate_format(:email, @email_regex)
699 |> validate_change(:email, fn :email, email ->
701 Config.get([User, :email_blacklist])
702 |> Enum.all?(fn blacklisted_domain ->
703 !String.ends_with?(email, ["@" <> blacklisted_domain, "." <> blacklisted_domain])
706 if valid?, do: [], else: [email: "Invalid email"]
708 |> unique_constraint(:nickname)
709 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
710 |> validate_format(:nickname, local_nickname_regex())
711 |> validate_length(:bio, max: bio_limit)
712 |> validate_length(:name, min: 1, max: name_limit)
713 |> validate_length(:registration_reason, max: reason_limit)
714 |> maybe_validate_required_email(opts[:external])
717 |> unique_constraint(:ap_id)
718 |> put_following_and_follower_address()
721 def maybe_validate_required_email(changeset, true), do: changeset
723 def maybe_validate_required_email(changeset, _) do
724 if Config.get([:instance, :account_activation_required]) do
725 validate_required(changeset, [:email])
731 defp put_ap_id(changeset) do
732 ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
733 put_change(changeset, :ap_id, ap_id)
736 defp put_following_and_follower_address(changeset) do
737 followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
740 |> put_change(:follower_address, followers)
743 defp autofollow_users(user) do
744 candidates = Config.get([:instance, :autofollowed_nicknames])
747 User.Query.build(%{nickname: candidates, local: true, deactivated: false})
750 follow_all(user, autofollowed_users)
753 @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
754 def register(%Ecto.Changeset{} = changeset) do
755 with {:ok, user} <- Repo.insert(changeset) do
756 post_register_action(user)
760 def post_register_action(%User{} = user) do
761 with {:ok, user} <- autofollow_users(user),
762 {:ok, user} <- set_cache(user),
763 {:ok, _} <- send_welcome_email(user),
764 {:ok, _} <- send_welcome_message(user),
765 {:ok, _} <- send_welcome_chat_message(user),
766 {:ok, _} <- try_send_confirmation_email(user) do
771 def send_welcome_message(user) do
772 if User.WelcomeMessage.enabled?() do
773 User.WelcomeMessage.post_message(user)
780 def send_welcome_chat_message(user) do
781 if User.WelcomeChatMessage.enabled?() do
782 User.WelcomeChatMessage.post_message(user)
789 def send_welcome_email(%User{email: email} = user) when is_binary(email) do
790 if User.WelcomeEmail.enabled?() do
791 User.WelcomeEmail.send_email(user)
798 def send_welcome_email(_), do: {:ok, :noop}
800 @spec try_send_confirmation_email(User.t()) :: {:ok, :enqueued | :noop}
801 def try_send_confirmation_email(%User{confirmation_pending: true} = user) do
802 if Config.get([:instance, :account_activation_required]) do
803 send_confirmation_email(user)
810 def try_send_confirmation_email(_), do: {:ok, :noop}
812 @spec send_confirmation_email(Uset.t()) :: User.t()
813 def send_confirmation_email(%User{} = user) do
815 |> Pleroma.Emails.UserEmail.account_confirmation_email()
816 |> Pleroma.Emails.Mailer.deliver_async()
821 def needs_update?(%User{local: true}), do: false
823 def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
825 def needs_update?(%User{local: false} = user) do
826 NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
829 def needs_update?(_), do: true
831 @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
833 # "Locked" (self-locked) users demand explicit authorization of follow requests
834 def maybe_direct_follow(%User{} = follower, %User{local: true, locked: true} = followed) do
835 follow(follower, followed, :follow_pending)
838 def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
839 follow(follower, followed)
842 def maybe_direct_follow(%User{} = follower, %User{} = followed) do
843 if not ap_enabled?(followed) do
844 follow(follower, followed)
850 @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
851 @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
852 def follow_all(follower, followeds) do
854 |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
855 |> Enum.each(&follow(follower, &1, :follow_accept))
860 defdelegate following(user), to: FollowingRelationship
862 def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
863 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
866 followed.deactivated ->
867 {:error, "Could not follow user: #{followed.nickname} is deactivated."}
869 deny_follow_blocked and blocks?(followed, follower) ->
870 {:error, "Could not follow user: #{followed.nickname} blocked you."}
873 FollowingRelationship.follow(follower, followed, state)
875 {:ok, _} = update_follower_count(followed)
878 |> update_following_count()
882 def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
883 {:error, "Not subscribed!"}
886 @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
887 def unfollow(%User{} = follower, %User{} = followed) do
888 case do_unfollow(follower, followed) do
889 {:ok, follower, followed} ->
890 {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
897 @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
898 defp do_unfollow(%User{} = follower, %User{} = followed) do
899 case get_follow_state(follower, followed) do
900 state when state in [:follow_pending, :follow_accept] ->
901 FollowingRelationship.unfollow(follower, followed)
902 {:ok, followed} = update_follower_count(followed)
906 |> update_following_count()
908 {:ok, follower, followed}
911 {:error, "Not subscribed!"}
915 defdelegate following?(follower, followed), to: FollowingRelationship
917 @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
918 def get_follow_state(%User{} = follower, %User{} = following) do
919 following_relationship = FollowingRelationship.get(follower, following)
920 get_follow_state(follower, following, following_relationship)
923 def get_follow_state(
926 following_relationship
928 case {following_relationship, following.local} do
930 case Utils.fetch_latest_follow(follower, following) do
931 %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
932 FollowingRelationship.state_to_enum(state)
938 {%{state: state}, _} ->
946 def locked?(%User{} = user) do
951 Repo.get_by(User, id: id)
954 def get_by_ap_id(ap_id) do
955 Repo.get_by(User, ap_id: ap_id)
958 def get_all_by_ap_id(ap_ids) do
959 from(u in __MODULE__,
960 where: u.ap_id in ^ap_ids
965 def get_all_by_ids(ids) do
966 from(u in __MODULE__, where: u.id in ^ids)
970 # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
971 # of the ap_id and the domain and tries to get that user
972 def get_by_guessed_nickname(ap_id) do
973 domain = URI.parse(ap_id).host
974 name = List.last(String.split(ap_id, "/"))
975 nickname = "#{name}@#{domain}"
977 get_cached_by_nickname(nickname)
980 def set_cache({:ok, user}), do: set_cache(user)
981 def set_cache({:error, err}), do: {:error, err}
983 def set_cache(%User{} = user) do
984 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
985 Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
986 Cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
990 def update_and_set_cache(struct, params) do
992 |> update_changeset(params)
993 |> update_and_set_cache()
996 def update_and_set_cache(changeset) do
997 with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
1002 def get_user_friends_ap_ids(user) do
1003 from(u in User.get_friends_query(user), select: u.ap_id)
1007 @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
1008 def get_cached_user_friends_ap_ids(user) do
1009 Cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
1010 get_user_friends_ap_ids(user)
1014 def invalidate_cache(user) do
1015 Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
1016 Cachex.del(:user_cache, "nickname:#{user.nickname}")
1017 Cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
1020 @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
1021 def get_cached_by_ap_id(ap_id) do
1022 key = "ap_id:#{ap_id}"
1024 with {:ok, nil} <- Cachex.get(:user_cache, key),
1025 user when not is_nil(user) <- get_by_ap_id(ap_id),
1026 {:ok, true} <- Cachex.put(:user_cache, key, user) do
1034 def get_cached_by_id(id) do
1038 Cachex.fetch!(:user_cache, key, fn _ ->
1039 user = get_by_id(id)
1042 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1043 {:commit, user.ap_id}
1049 get_cached_by_ap_id(ap_id)
1052 def get_cached_by_nickname(nickname) do
1053 key = "nickname:#{nickname}"
1055 Cachex.fetch!(:user_cache, key, fn ->
1056 case get_or_fetch_by_nickname(nickname) do
1057 {:ok, user} -> {:commit, user}
1058 {:error, _error} -> {:ignore, nil}
1063 def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
1064 restrict_to_local = Config.get([:instance, :limit_to_local_content])
1067 is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
1068 get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
1070 restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
1071 get_cached_by_nickname(nickname_or_id)
1073 restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
1074 get_cached_by_nickname(nickname_or_id)
1081 @spec get_by_nickname(String.t()) :: User.t() | nil
1082 def get_by_nickname(nickname) do
1083 Repo.get_by(User, nickname: nickname) ||
1084 if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
1085 Repo.get_by(User, nickname: local_nickname(nickname))
1089 def get_by_email(email), do: Repo.get_by(User, email: email)
1091 def get_by_nickname_or_email(nickname_or_email) do
1092 get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
1095 def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
1097 def get_or_fetch_by_nickname(nickname) do
1098 with %User{} = user <- get_by_nickname(nickname) do
1102 with [_nick, _domain] <- String.split(nickname, "@"),
1103 {:ok, user} <- fetch_by_nickname(nickname) do
1106 _e -> {:error, "not found " <> nickname}
1111 @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1112 def get_followers_query(%User{} = user, nil) do
1113 User.Query.build(%{followers: user, deactivated: false})
1116 def get_followers_query(user, page) do
1118 |> get_followers_query(nil)
1119 |> User.Query.paginate(page, 20)
1122 @spec get_followers_query(User.t()) :: Ecto.Query.t()
1123 def get_followers_query(user), do: get_followers_query(user, nil)
1125 @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1126 def get_followers(user, page \\ nil) do
1128 |> get_followers_query(page)
1132 @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1133 def get_external_followers(user, page \\ nil) do
1135 |> get_followers_query(page)
1136 |> User.Query.build(%{external: true})
1140 def get_followers_ids(user, page \\ nil) do
1142 |> get_followers_query(page)
1143 |> select([u], u.id)
1147 @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1148 def get_friends_query(%User{} = user, nil) do
1149 User.Query.build(%{friends: user, deactivated: false})
1152 def get_friends_query(user, page) do
1154 |> get_friends_query(nil)
1155 |> User.Query.paginate(page, 20)
1158 @spec get_friends_query(User.t()) :: Ecto.Query.t()
1159 def get_friends_query(user), do: get_friends_query(user, nil)
1161 def get_friends(user, page \\ nil) do
1163 |> get_friends_query(page)
1167 def get_friends_ap_ids(user) do
1169 |> get_friends_query(nil)
1170 |> select([u], u.ap_id)
1174 def get_friends_ids(user, page \\ nil) do
1176 |> get_friends_query(page)
1177 |> select([u], u.id)
1181 defdelegate get_follow_requests(user), to: FollowingRelationship
1183 def increase_note_count(%User{} = user) do
1185 |> where(id: ^user.id)
1186 |> update([u], inc: [note_count: 1])
1188 |> Repo.update_all([])
1190 {1, [user]} -> set_cache(user)
1195 def decrease_note_count(%User{} = user) do
1197 |> where(id: ^user.id)
1200 note_count: fragment("greatest(0, note_count - 1)")
1204 |> Repo.update_all([])
1206 {1, [user]} -> set_cache(user)
1211 def update_note_count(%User{} = user, note_count \\ nil) do
1216 where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1222 |> cast(%{note_count: note_count}, [:note_count])
1223 |> update_and_set_cache()
1226 @spec maybe_fetch_follow_information(User.t()) :: User.t()
1227 def maybe_fetch_follow_information(user) do
1228 with {:ok, user} <- fetch_follow_information(user) do
1232 Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1238 def fetch_follow_information(user) do
1239 with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1241 |> follow_information_changeset(info)
1242 |> update_and_set_cache()
1246 defp follow_information_changeset(user, params) do
1253 :hide_followers_count,
1258 @spec update_follower_count(User.t()) :: {:ok, User.t()}
1259 def update_follower_count(%User{} = user) do
1260 if user.local or !Config.get([:instance, :external_user_synchronization]) do
1261 follower_count = FollowingRelationship.follower_count(user)
1264 |> follow_information_changeset(%{follower_count: follower_count})
1265 |> update_and_set_cache
1267 {:ok, maybe_fetch_follow_information(user)}
1271 @spec update_following_count(User.t()) :: {:ok, User.t()}
1272 def update_following_count(%User{local: false} = user) do
1273 if Config.get([:instance, :external_user_synchronization]) do
1274 {:ok, maybe_fetch_follow_information(user)}
1280 def update_following_count(%User{local: true} = user) do
1281 following_count = FollowingRelationship.following_count(user)
1284 |> follow_information_changeset(%{following_count: following_count})
1285 |> update_and_set_cache()
1288 def set_unread_conversation_count(%User{local: true} = user) do
1289 unread_query = Participation.unread_conversation_count_for_user(user)
1292 |> join(:inner, [u], p in subquery(unread_query))
1294 set: [unread_conversation_count: p.count]
1296 |> where([u], u.id == ^user.id)
1298 |> Repo.update_all([])
1300 {1, [user]} -> set_cache(user)
1305 def set_unread_conversation_count(user), do: {:ok, user}
1307 def increment_unread_conversation_count(conversation, %User{local: true} = user) do
1309 Participation.unread_conversation_count_for_user(user)
1310 |> where([p], p.conversation_id == ^conversation.id)
1313 |> join(:inner, [u], p in subquery(unread_query))
1315 inc: [unread_conversation_count: 1]
1317 |> where([u], u.id == ^user.id)
1318 |> where([u, p], p.count == 0)
1320 |> Repo.update_all([])
1322 {1, [user]} -> set_cache(user)
1327 def increment_unread_conversation_count(_, user), do: {:ok, user}
1329 @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1330 def get_users_from_set(ap_ids, opts \\ []) do
1331 local_only = Keyword.get(opts, :local_only, true)
1332 criteria = %{ap_id: ap_ids, deactivated: false}
1333 criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1335 User.Query.build(criteria)
1339 @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1340 def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1343 query = User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
1349 @spec mute(User.t(), User.t(), boolean()) ::
1350 {:ok, list(UserRelationship.t())} | {:error, String.t()}
1351 def mute(%User{} = muter, %User{} = mutee, notifications? \\ true) do
1352 add_to_mutes(muter, mutee, notifications?)
1355 def unmute(%User{} = muter, %User{} = mutee) do
1356 remove_from_mutes(muter, mutee)
1359 def subscribe(%User{} = subscriber, %User{} = target) do
1360 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
1362 if blocks?(target, subscriber) and deny_follow_blocked do
1363 {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1365 # Note: the relationship is inverse: subscriber acts as relationship target
1366 UserRelationship.create_inverse_subscription(target, subscriber)
1370 def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1371 with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1372 subscribe(subscriber, subscribee)
1376 def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1377 # Note: the relationship is inverse: subscriber acts as relationship target
1378 UserRelationship.delete_inverse_subscription(target, unsubscriber)
1381 def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1382 with %User{} = user <- get_cached_by_ap_id(ap_id) do
1383 unsubscribe(unsubscriber, user)
1387 def block(%User{} = blocker, %User{} = blocked) do
1388 # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1390 if following?(blocker, blocked) do
1391 {:ok, blocker, _} = unfollow(blocker, blocked)
1397 # clear any requested follows as well
1399 case CommonAPI.reject_follow_request(blocked, blocker) do
1400 {:ok, %User{} = updated_blocked} -> updated_blocked
1404 unsubscribe(blocked, blocker)
1406 unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
1407 if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)
1409 {:ok, blocker} = update_follower_count(blocker)
1410 {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1411 add_to_block(blocker, blocked)
1414 # helper to handle the block given only an actor's AP id
1415 def block(%User{} = blocker, %{ap_id: ap_id}) do
1416 block(blocker, get_cached_by_ap_id(ap_id))
1419 def unblock(%User{} = blocker, %User{} = blocked) do
1420 remove_from_block(blocker, blocked)
1423 # helper to handle the block given only an actor's AP id
1424 def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1425 unblock(blocker, get_cached_by_ap_id(ap_id))
1428 def mutes?(nil, _), do: false
1429 def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1431 def mutes_user?(%User{} = user, %User{} = target) do
1432 UserRelationship.mute_exists?(user, target)
1435 @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1436 def muted_notifications?(nil, _), do: false
1438 def muted_notifications?(%User{} = user, %User{} = target),
1439 do: UserRelationship.notification_mute_exists?(user, target)
1441 def blocks?(nil, _), do: false
1443 def blocks?(%User{} = user, %User{} = target) do
1444 blocks_user?(user, target) ||
1445 (blocks_domain?(user, target) and not User.following?(user, target))
1448 def blocks_user?(%User{} = user, %User{} = target) do
1449 UserRelationship.block_exists?(user, target)
1452 def blocks_user?(_, _), do: false
1454 def blocks_domain?(%User{} = user, %User{} = target) do
1455 domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1456 %{host: host} = URI.parse(target.ap_id)
1457 Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1460 def blocks_domain?(_, _), do: false
1462 def subscribed_to?(%User{} = user, %User{} = target) do
1463 # Note: the relationship is inverse: subscriber acts as relationship target
1464 UserRelationship.inverse_subscription_exists?(target, user)
1467 def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1468 with %User{} = target <- get_cached_by_ap_id(ap_id) do
1469 subscribed_to?(user, target)
1474 Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1475 E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1477 @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1478 def outgoing_relationships_ap_ids(_user, []), do: %{}
1480 def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1482 def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1483 when is_list(relationship_types) do
1486 |> assoc(:outgoing_relationships)
1487 |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1488 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1489 |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1490 |> group_by([user_rel, u], user_rel.relationship_type)
1492 |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1497 fn rel_type -> {rel_type, db_result[rel_type] || []} end
1501 def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1503 def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1505 def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1507 def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1508 when is_list(relationship_types) do
1510 |> assoc(:incoming_relationships)
1511 |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1512 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1513 |> maybe_filter_on_ap_id(ap_ids)
1514 |> select([user_rel, u], u.ap_id)
1519 defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1520 where(query, [user_rel, u], u.ap_id in ^ap_ids)
1523 defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1525 def deactivate_async(user, status \\ true) do
1526 BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
1529 def deactivate(user, status \\ true)
1531 def deactivate(users, status) when is_list(users) do
1532 Repo.transaction(fn ->
1533 for user <- users, do: deactivate(user, status)
1537 def deactivate(%User{} = user, status) do
1538 with {:ok, user} <- set_activation_status(user, status) do
1541 |> Enum.filter(& &1.local)
1542 |> Enum.each(&set_cache(update_following_count(&1)))
1544 # Only update local user counts, remote will be update during the next pull.
1547 |> Enum.filter(& &1.local)
1548 |> Enum.each(&do_unfollow(user, &1))
1554 def approve(users) when is_list(users) do
1555 Repo.transaction(fn ->
1556 Enum.map(users, fn user ->
1557 with {:ok, user} <- approve(user), do: user
1562 def approve(%User{} = user) do
1563 change(user, approval_pending: false)
1564 |> update_and_set_cache()
1567 def update_notification_settings(%User{} = user, settings) do
1569 |> cast(%{notification_settings: settings}, [])
1570 |> cast_embed(:notification_settings)
1571 |> validate_required([:notification_settings])
1572 |> update_and_set_cache()
1575 def delete(users) when is_list(users) do
1576 for user <- users, do: delete(user)
1579 def delete(%User{} = user) do
1580 BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1583 defp delete_and_invalidate_cache(%User{} = user) do
1584 invalidate_cache(user)
1588 defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)
1590 defp delete_or_deactivate(%User{local: true} = user) do
1591 status = account_status(user)
1594 :confirmation_pending ->
1595 delete_and_invalidate_cache(user)
1597 :approval_pending ->
1598 delete_and_invalidate_cache(user)
1602 |> change(%{deactivated: true, email: nil})
1603 |> update_and_set_cache()
1607 def perform(:force_password_reset, user), do: force_password_reset(user)
1609 @spec perform(atom(), User.t()) :: {:ok, User.t()}
1610 def perform(:delete, %User{} = user) do
1611 # Remove all relationships
1614 |> Enum.each(fn follower ->
1615 ActivityPub.unfollow(follower, user)
1616 unfollow(follower, user)
1621 |> Enum.each(fn followed ->
1622 ActivityPub.unfollow(user, followed)
1623 unfollow(user, followed)
1626 delete_user_activities(user)
1627 delete_notifications_from_user_activities(user)
1629 delete_outgoing_pending_follow_requests(user)
1631 delete_or_deactivate(user)
1634 def perform(:deactivate_async, user, status), do: deactivate(user, status)
1636 @spec perform(atom(), User.t(), list()) :: list() | {:error, any()}
1637 def perform(:blocks_import, %User{} = blocker, blocked_identifiers)
1638 when is_list(blocked_identifiers) do
1640 blocked_identifiers,
1641 fn blocked_identifier ->
1642 with {:ok, %User{} = blocked} <- get_or_fetch(blocked_identifier),
1643 {:ok, _block} <- CommonAPI.block(blocker, blocked) do
1647 Logger.debug("blocks_import failed for #{blocked_identifier} with: #{inspect(err)}")
1654 def perform(:follow_import, %User{} = follower, followed_identifiers)
1655 when is_list(followed_identifiers) do
1657 followed_identifiers,
1658 fn followed_identifier ->
1659 with {:ok, %User{} = followed} <- get_or_fetch(followed_identifier),
1660 {:ok, follower} <- maybe_direct_follow(follower, followed),
1661 {:ok, _, _, _} <- CommonAPI.follow(follower, followed) do
1665 Logger.debug("follow_import failed for #{followed_identifier} with: #{inspect(err)}")
1672 @spec external_users_query() :: Ecto.Query.t()
1673 def external_users_query do
1681 @spec external_users(keyword()) :: [User.t()]
1682 def external_users(opts \\ []) do
1684 external_users_query()
1685 |> select([u], struct(u, [:id, :ap_id]))
1689 do: where(query, [u], u.id > ^opts[:max_id]),
1694 do: limit(query, ^opts[:limit]),
1700 def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers) do
1701 BackgroundWorker.enqueue("blocks_import", %{
1702 "blocker_id" => blocker.id,
1703 "blocked_identifiers" => blocked_identifiers
1707 def follow_import(%User{} = follower, followed_identifiers)
1708 when is_list(followed_identifiers) do
1709 BackgroundWorker.enqueue("follow_import", %{
1710 "follower_id" => follower.id,
1711 "followed_identifiers" => followed_identifiers
1715 def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1717 |> join(:inner, [n], activity in assoc(n, :activity))
1718 |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1719 |> Repo.delete_all()
1722 def delete_user_activities(%User{ap_id: ap_id} = user) do
1724 |> Activity.Queries.by_actor()
1725 |> RepoStreamer.chunk_stream(50)
1726 |> Stream.each(fn activities ->
1727 Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1732 defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1733 with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1734 {:ok, delete_data, _} <- Builder.delete(user, object) do
1735 Pipeline.common_pipeline(delete_data, local: user.local)
1737 {:find_object, nil} ->
1738 # We have the create activity, but not the object, it was probably pruned.
1739 # Insert a tombstone and try again
1740 with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1741 {:ok, _tombstone} <- Object.create(tombstone_data) do
1742 delete_activity(activity, user)
1746 Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1747 Logger.error("Error: #{inspect(e)}")
1751 defp delete_activity(%{data: %{"type" => type}} = activity, user)
1752 when type in ["Like", "Announce"] do
1753 {:ok, undo, _} = Builder.undo(user, activity)
1754 Pipeline.common_pipeline(undo, local: user.local)
1757 defp delete_activity(_activity, _user), do: "Doing nothing"
1759 defp delete_outgoing_pending_follow_requests(user) do
1761 |> FollowingRelationship.outgoing_pending_follow_requests_query()
1762 |> Repo.delete_all()
1765 def html_filter_policy(%User{no_rich_text: true}) do
1766 Pleroma.HTML.Scrubber.TwitterText
1769 def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])
1771 def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1773 def get_or_fetch_by_ap_id(ap_id) do
1774 cached_user = get_cached_by_ap_id(ap_id)
1776 maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)
1778 case {cached_user, maybe_fetched_user} do
1779 {_, {:ok, %User{} = user}} ->
1782 {%User{} = user, _} ->
1786 {:error, :not_found}
1791 Creates an internal service actor by URI if missing.
1792 Optionally takes nickname for addressing.
1794 @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1795 def get_or_create_service_actor_by_ap_id(uri, nickname) do
1797 case get_cached_by_ap_id(uri) do
1799 with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1800 Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1804 %User{invisible: false} = user ->
1814 @spec set_invisible(User.t()) :: {:ok, User.t()}
1815 defp set_invisible(user) do
1817 |> change(%{invisible: true})
1818 |> update_and_set_cache()
1821 @spec create_service_actor(String.t(), String.t()) ::
1822 {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1823 defp create_service_actor(uri, nickname) do
1829 follower_address: uri <> "/followers"
1832 |> unique_constraint(:nickname)
1837 def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1840 |> :public_key.pem_decode()
1842 |> :public_key.pem_entry_decode()
1847 def public_key(_), do: {:error, "key not found"}
1849 def get_public_key_for_ap_id(ap_id) do
1850 with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1851 {:ok, public_key} <- public_key(user) do
1858 def ap_enabled?(%User{local: true}), do: true
1859 def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1860 def ap_enabled?(_), do: false
1862 @doc "Gets or fetch a user by uri or nickname."
1863 @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1864 def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1865 def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1867 # wait a period of time and return newest version of the User structs
1868 # this is because we have synchronous follow APIs and need to simulate them
1869 # with an async handshake
1870 def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1871 with %User{} = a <- get_cached_by_id(a.id),
1872 %User{} = b <- get_cached_by_id(b.id) do
1879 def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1880 with :ok <- :timer.sleep(timeout),
1881 %User{} = a <- get_cached_by_id(a.id),
1882 %User{} = b <- get_cached_by_id(b.id) do
1889 def parse_bio(bio) when is_binary(bio) and bio != "" do
1891 |> CommonUtils.format_input("text/plain", mentions_format: :full)
1895 def parse_bio(_), do: ""
1897 def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1898 # TODO: get profile URLs other than user.ap_id
1899 profile_urls = [user.ap_id]
1902 |> CommonUtils.format_input("text/plain",
1903 mentions_format: :full,
1904 rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1909 def parse_bio(_, _), do: ""
1911 def tag(user_identifiers, tags) when is_list(user_identifiers) do
1912 Repo.transaction(fn ->
1913 for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1917 def tag(nickname, tags) when is_binary(nickname),
1918 do: tag(get_by_nickname(nickname), tags)
1920 def tag(%User{} = user, tags),
1921 do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1923 def untag(user_identifiers, tags) when is_list(user_identifiers) do
1924 Repo.transaction(fn ->
1925 for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1929 def untag(nickname, tags) when is_binary(nickname),
1930 do: untag(get_by_nickname(nickname), tags)
1932 def untag(%User{} = user, tags),
1933 do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1935 defp update_tags(%User{} = user, new_tags) do
1936 {:ok, updated_user} =
1938 |> change(%{tags: new_tags})
1939 |> update_and_set_cache()
1944 defp normalize_tags(tags) do
1947 |> Enum.map(&String.downcase/1)
1950 defp local_nickname_regex do
1951 if Config.get([:instance, :extended_nickname_format]) do
1952 @extended_local_nickname_regex
1954 @strict_local_nickname_regex
1958 def local_nickname(nickname_or_mention) do
1961 |> String.split("@")
1965 def full_nickname(nickname_or_mention),
1966 do: String.trim_leading(nickname_or_mention, "@")
1968 def error_user(ap_id) do
1972 nickname: "erroruser@example.com",
1973 inserted_at: NaiveDateTime.utc_now()
1977 @spec all_superusers() :: [User.t()]
1978 def all_superusers do
1979 User.Query.build(%{super_users: true, local: true, deactivated: false})
1983 def muting_reblogs?(%User{} = user, %User{} = target) do
1984 UserRelationship.reblog_mute_exists?(user, target)
1987 def showing_reblogs?(%User{} = user, %User{} = target) do
1988 not muting_reblogs?(user, target)
1992 The function returns a query to get users with no activity for given interval of days.
1993 Inactive users are those who didn't read any notification, or had any activity where
1994 the user is the activity's actor, during `inactivity_threshold` days.
1995 Deactivated users will not appear in this list.
1999 iex> Pleroma.User.list_inactive_users()
2002 @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
2003 def list_inactive_users_query(inactivity_threshold \\ 7) do
2004 negative_inactivity_threshold = -inactivity_threshold
2005 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2006 # Subqueries are not supported in `where` clauses, join gets too complicated.
2007 has_read_notifications =
2008 from(n in Pleroma.Notification,
2009 where: n.seen == true,
2011 having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
2014 |> Pleroma.Repo.all()
2016 from(u in Pleroma.User,
2017 left_join: a in Pleroma.Activity,
2018 on: u.ap_id == a.actor,
2019 where: not is_nil(u.nickname),
2020 where: u.deactivated != ^true,
2021 where: u.id not in ^has_read_notifications,
2024 max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
2025 is_nil(max(a.inserted_at))
2030 Enable or disable email notifications for user
2034 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
2035 Pleroma.User{email_notifications: %{"digest" => true}}
2037 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
2038 Pleroma.User{email_notifications: %{"digest" => false}}
2040 @spec switch_email_notifications(t(), String.t(), boolean()) ::
2041 {:ok, t()} | {:error, Ecto.Changeset.t()}
2042 def switch_email_notifications(user, type, status) do
2043 User.update_email_notifications(user, %{type => status})
2047 Set `last_digest_emailed_at` value for the user to current time
2049 @spec touch_last_digest_emailed_at(t()) :: t()
2050 def touch_last_digest_emailed_at(user) do
2051 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2053 {:ok, updated_user} =
2055 |> change(%{last_digest_emailed_at: now})
2056 |> update_and_set_cache()
2061 @spec toggle_confirmation(User.t()) :: {:ok, User.t()} | {:error, Changeset.t()}
2062 def toggle_confirmation(%User{} = user) do
2064 |> confirmation_changeset(need_confirmation: !user.confirmation_pending)
2065 |> update_and_set_cache()
2068 @spec toggle_confirmation([User.t()]) :: [{:ok, User.t()} | {:error, Changeset.t()}]
2069 def toggle_confirmation(users) do
2070 Enum.map(users, &toggle_confirmation/1)
2073 def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
2077 def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
2078 # use instance-default
2079 config = Config.get([:assets, :mascots])
2080 default_mascot = Config.get([:assets, :default_mascot])
2081 mascot = Keyword.get(config, default_mascot)
2084 "id" => "default-mascot",
2085 "url" => mascot[:url],
2086 "preview_url" => mascot[:url],
2088 "mime_type" => mascot[:mime_type]
2093 def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
2095 def ensure_keys_present(%User{} = user) do
2096 with {:ok, pem} <- Keys.generate_rsa_pem() do
2098 |> cast(%{keys: pem}, [:keys])
2099 |> validate_required([:keys])
2100 |> update_and_set_cache()
2104 def get_ap_ids_by_nicknames(nicknames) do
2106 where: u.nickname in ^nicknames,
2112 defdelegate search(query, opts \\ []), to: User.Search
2114 defp put_password_hash(
2115 %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2117 change(changeset, password_hash: Pbkdf2.hash_pwd_salt(password))
2120 defp put_password_hash(changeset), do: changeset
2122 def is_internal_user?(%User{nickname: nil}), do: true
2123 def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2124 def is_internal_user?(_), do: false
2126 # A hack because user delete activities have a fake id for whatever reason
2127 # TODO: Get rid of this
2128 def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2130 def get_delivered_users_by_object_id(object_id) do
2132 inner_join: delivery in assoc(u, :deliveries),
2133 where: delivery.object_id == ^object_id
2138 def change_email(user, email) do
2140 |> cast(%{email: email}, [:email])
2141 |> validate_required([:email])
2142 |> unique_constraint(:email)
2143 |> validate_format(:email, @email_regex)
2144 |> update_and_set_cache()
2147 # Internal function; public one is `deactivate/2`
2148 defp set_activation_status(user, deactivated) do
2150 |> cast(%{deactivated: deactivated}, [:deactivated])
2151 |> update_and_set_cache()
2154 def update_banner(user, banner) do
2156 |> cast(%{banner: banner}, [:banner])
2157 |> update_and_set_cache()
2160 def update_background(user, background) do
2162 |> cast(%{background: background}, [:background])
2163 |> update_and_set_cache()
2166 def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
2169 moderator: is_moderator
2173 def validate_fields(changeset, remote? \\ false) do
2174 limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2175 limit = Config.get([:instance, limit_name], 0)
2178 |> validate_length(:fields, max: limit)
2179 |> validate_change(:fields, fn :fields, fields ->
2180 if Enum.all?(fields, &valid_field?/1) do
2188 defp valid_field?(%{"name" => name, "value" => value}) do
2189 name_limit = Config.get([:instance, :account_field_name_length], 255)
2190 value_limit = Config.get([:instance, :account_field_value_length], 255)
2192 is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2193 String.length(value) <= value_limit
2196 defp valid_field?(_), do: false
2198 defp truncate_field(%{"name" => name, "value" => value}) do
2200 String.split_at(name, Config.get([:instance, :account_field_name_length], 255))
2203 String.split_at(value, Config.get([:instance, :account_field_value_length], 255))
2205 %{"name" => name, "value" => value}
2208 def admin_api_update(user, params) do
2215 |> update_and_set_cache()
2218 @doc "Signs user out of all applications"
2219 def global_sign_out(user) do
2220 OAuth.Authorization.delete_user_authorizations(user)
2221 OAuth.Token.delete_user_tokens(user)
2224 def mascot_update(user, url) do
2226 |> cast(%{mascot: url}, [:mascot])
2227 |> validate_required([:mascot])
2228 |> update_and_set_cache()
2231 def mastodon_settings_update(user, settings) do
2233 |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
2234 |> validate_required([:mastofe_settings])
2235 |> update_and_set_cache()
2238 @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2239 def confirmation_changeset(user, need_confirmation: need_confirmation?) do
2241 if need_confirmation? do
2243 confirmation_pending: true,
2244 confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2248 confirmation_pending: false,
2249 confirmation_token: nil
2253 cast(user, params, [:confirmation_pending, :confirmation_token])
2256 @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
2257 def approval_changeset(user, need_approval: need_approval?) do
2258 params = if need_approval?, do: %{approval_pending: true}, else: %{approval_pending: false}
2259 cast(user, params, [:approval_pending])
2262 def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2263 if id not in user.pinned_activities do
2264 max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2265 params = %{pinned_activities: user.pinned_activities ++ [id]}
2268 |> cast(params, [:pinned_activities])
2269 |> validate_length(:pinned_activities,
2270 max: max_pinned_statuses,
2271 message: "You have already pinned the maximum number of statuses"
2276 |> update_and_set_cache()
2279 def remove_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2280 params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2283 |> cast(params, [:pinned_activities])
2284 |> update_and_set_cache()
2287 def update_email_notifications(user, settings) do
2288 email_notifications =
2289 user.email_notifications
2290 |> Map.merge(settings)
2291 |> Map.take(["digest"])
2293 params = %{email_notifications: email_notifications}
2294 fields = [:email_notifications]
2297 |> cast(params, fields)
2298 |> validate_required(fields)
2299 |> update_and_set_cache()
2302 defp set_domain_blocks(user, domain_blocks) do
2303 params = %{domain_blocks: domain_blocks}
2306 |> cast(params, [:domain_blocks])
2307 |> validate_required([:domain_blocks])
2308 |> update_and_set_cache()
2311 def block_domain(user, domain_blocked) do
2312 set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2315 def unblock_domain(user, domain_blocked) do
2316 set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2319 @spec add_to_block(User.t(), User.t()) ::
2320 {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2321 defp add_to_block(%User{} = user, %User{} = blocked) do
2322 UserRelationship.create_block(user, blocked)
2325 @spec add_to_block(User.t(), User.t()) ::
2326 {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2327 defp remove_from_block(%User{} = user, %User{} = blocked) do
2328 UserRelationship.delete_block(user, blocked)
2331 defp add_to_mutes(%User{} = user, %User{} = muted_user, notifications?) do
2332 with {:ok, user_mute} <- UserRelationship.create_mute(user, muted_user),
2333 {:ok, user_notification_mute} <-
2334 (notifications? && UserRelationship.create_notification_mute(user, muted_user)) ||
2336 {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
2340 defp remove_from_mutes(user, %User{} = muted_user) do
2341 with {:ok, user_mute} <- UserRelationship.delete_mute(user, muted_user),
2342 {:ok, user_notification_mute} <-
2343 UserRelationship.delete_notification_mute(user, muted_user) do
2344 {:ok, [user_mute, user_notification_mute]}
2348 def set_invisible(user, invisible) do
2349 params = %{invisible: invisible}
2352 |> cast(params, [:invisible])
2353 |> validate_required([:invisible])
2354 |> update_and_set_cache()
2357 def sanitize_html(%User{} = user) do
2358 sanitize_html(user, nil)
2361 # User data that mastodon isn't filtering (treated as plaintext):
2364 def sanitize_html(%User{} = user, filter) do
2366 Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2369 "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2374 |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2375 |> Map.put(:fields, fields)