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 won't have a password hash stored locally
642 def register_changeset_ldap(struct, params = %{password: password})
643 when is_nil(password) do
644 params = Map.put_new(params, :accepts_chat_messages, true)
647 if Map.has_key?(params, :email) do
648 Map.put_new(params, :email, params[:email])
658 :accepts_chat_messages
660 |> validate_required([:name, :nickname])
661 |> unique_constraint(:nickname)
662 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
663 |> validate_format(:nickname, local_nickname_regex())
665 |> unique_constraint(:ap_id)
666 |> put_following_and_follower_address()
669 def register_changeset(struct, params \\ %{}, opts \\ []) do
670 bio_limit = Config.get([:instance, :user_bio_length], 5000)
671 name_limit = Config.get([:instance, :user_name_length], 100)
672 reason_limit = Config.get([:instance, :registration_reason_length], 500)
673 params = Map.put_new(params, :accepts_chat_messages, true)
676 if is_nil(opts[:need_confirmation]) do
677 Config.get([:instance, :account_activation_required])
679 opts[:need_confirmation]
683 if is_nil(opts[:need_approval]) do
684 Config.get([:instance, :account_approval_required])
690 |> confirmation_changeset(need_confirmation: need_confirmation?)
691 |> approval_changeset(need_approval: need_approval?)
699 :password_confirmation,
701 :accepts_chat_messages,
704 |> validate_required([:name, :nickname, :password, :password_confirmation])
705 |> validate_confirmation(:password)
706 |> unique_constraint(:email)
707 |> validate_format(:email, @email_regex)
708 |> validate_change(:email, fn :email, email ->
710 Config.get([User, :email_blacklist])
711 |> Enum.all?(fn blacklisted_domain ->
712 !String.ends_with?(email, ["@" <> blacklisted_domain, "." <> blacklisted_domain])
715 if valid?, do: [], else: [email: "Invalid email"]
717 |> unique_constraint(:nickname)
718 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
719 |> validate_format(:nickname, local_nickname_regex())
720 |> validate_length(:bio, max: bio_limit)
721 |> validate_length(:name, min: 1, max: name_limit)
722 |> validate_length(:registration_reason, max: reason_limit)
723 |> maybe_validate_required_email(opts[:external])
726 |> unique_constraint(:ap_id)
727 |> put_following_and_follower_address()
730 def maybe_validate_required_email(changeset, true), do: changeset
732 def maybe_validate_required_email(changeset, _) do
733 if Config.get([:instance, :account_activation_required]) do
734 validate_required(changeset, [:email])
740 defp put_ap_id(changeset) do
741 ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
742 put_change(changeset, :ap_id, ap_id)
745 defp put_following_and_follower_address(changeset) do
746 followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
749 |> put_change(:follower_address, followers)
752 defp autofollow_users(user) do
753 candidates = Config.get([:instance, :autofollowed_nicknames])
756 User.Query.build(%{nickname: candidates, local: true, deactivated: false})
759 follow_all(user, autofollowed_users)
762 @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
763 def register(%Ecto.Changeset{} = changeset) do
764 with {:ok, user} <- Repo.insert(changeset) do
765 post_register_action(user)
769 def post_register_action(%User{} = user) do
770 with {:ok, user} <- autofollow_users(user),
771 {:ok, user} <- set_cache(user),
772 {:ok, _} <- send_welcome_email(user),
773 {:ok, _} <- send_welcome_message(user),
774 {:ok, _} <- send_welcome_chat_message(user),
775 {:ok, _} <- try_send_confirmation_email(user) do
780 def send_welcome_message(user) do
781 if User.WelcomeMessage.enabled?() do
782 User.WelcomeMessage.post_message(user)
789 def send_welcome_chat_message(user) do
790 if User.WelcomeChatMessage.enabled?() do
791 User.WelcomeChatMessage.post_message(user)
798 def send_welcome_email(%User{email: email} = user) when is_binary(email) do
799 if User.WelcomeEmail.enabled?() do
800 User.WelcomeEmail.send_email(user)
807 def send_welcome_email(_), do: {:ok, :noop}
809 @spec try_send_confirmation_email(User.t()) :: {:ok, :enqueued | :noop}
810 def try_send_confirmation_email(%User{confirmation_pending: true} = user) do
811 if Config.get([:instance, :account_activation_required]) do
812 send_confirmation_email(user)
819 def try_send_confirmation_email(_), do: {:ok, :noop}
821 @spec send_confirmation_email(Uset.t()) :: User.t()
822 def send_confirmation_email(%User{} = user) do
824 |> Pleroma.Emails.UserEmail.account_confirmation_email()
825 |> Pleroma.Emails.Mailer.deliver_async()
830 def needs_update?(%User{local: true}), do: false
832 def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
834 def needs_update?(%User{local: false} = user) do
835 NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
838 def needs_update?(_), do: true
840 @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
842 # "Locked" (self-locked) users demand explicit authorization of follow requests
843 def maybe_direct_follow(%User{} = follower, %User{local: true, locked: true} = followed) do
844 follow(follower, followed, :follow_pending)
847 def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
848 follow(follower, followed)
851 def maybe_direct_follow(%User{} = follower, %User{} = followed) do
852 if not ap_enabled?(followed) do
853 follow(follower, followed)
859 @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
860 @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
861 def follow_all(follower, followeds) do
863 |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
864 |> Enum.each(&follow(follower, &1, :follow_accept))
869 defdelegate following(user), to: FollowingRelationship
871 def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
872 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
875 followed.deactivated ->
876 {:error, "Could not follow user: #{followed.nickname} is deactivated."}
878 deny_follow_blocked and blocks?(followed, follower) ->
879 {:error, "Could not follow user: #{followed.nickname} blocked you."}
882 FollowingRelationship.follow(follower, followed, state)
884 {:ok, _} = update_follower_count(followed)
887 |> update_following_count()
891 def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
892 {:error, "Not subscribed!"}
895 @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
896 def unfollow(%User{} = follower, %User{} = followed) do
897 case do_unfollow(follower, followed) do
898 {:ok, follower, followed} ->
899 {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
906 @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
907 defp do_unfollow(%User{} = follower, %User{} = followed) do
908 case get_follow_state(follower, followed) do
909 state when state in [:follow_pending, :follow_accept] ->
910 FollowingRelationship.unfollow(follower, followed)
911 {:ok, followed} = update_follower_count(followed)
915 |> update_following_count()
917 {:ok, follower, followed}
920 {:error, "Not subscribed!"}
924 defdelegate following?(follower, followed), to: FollowingRelationship
926 @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
927 def get_follow_state(%User{} = follower, %User{} = following) do
928 following_relationship = FollowingRelationship.get(follower, following)
929 get_follow_state(follower, following, following_relationship)
932 def get_follow_state(
935 following_relationship
937 case {following_relationship, following.local} do
939 case Utils.fetch_latest_follow(follower, following) do
940 %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
941 FollowingRelationship.state_to_enum(state)
947 {%{state: state}, _} ->
955 def locked?(%User{} = user) do
960 Repo.get_by(User, id: id)
963 def get_by_ap_id(ap_id) do
964 Repo.get_by(User, ap_id: ap_id)
967 def get_all_by_ap_id(ap_ids) do
968 from(u in __MODULE__,
969 where: u.ap_id in ^ap_ids
974 def get_all_by_ids(ids) do
975 from(u in __MODULE__, where: u.id in ^ids)
979 # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
980 # of the ap_id and the domain and tries to get that user
981 def get_by_guessed_nickname(ap_id) do
982 domain = URI.parse(ap_id).host
983 name = List.last(String.split(ap_id, "/"))
984 nickname = "#{name}@#{domain}"
986 get_cached_by_nickname(nickname)
989 def set_cache({:ok, user}), do: set_cache(user)
990 def set_cache({:error, err}), do: {:error, err}
992 def set_cache(%User{} = user) do
993 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
994 Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
995 Cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
999 def update_and_set_cache(struct, params) do
1001 |> update_changeset(params)
1002 |> update_and_set_cache()
1005 def update_and_set_cache(changeset) do
1006 with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
1011 def get_user_friends_ap_ids(user) do
1012 from(u in User.get_friends_query(user), select: u.ap_id)
1016 @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
1017 def get_cached_user_friends_ap_ids(user) do
1018 Cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
1019 get_user_friends_ap_ids(user)
1023 def invalidate_cache(user) do
1024 Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
1025 Cachex.del(:user_cache, "nickname:#{user.nickname}")
1026 Cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
1029 @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
1030 def get_cached_by_ap_id(ap_id) do
1031 key = "ap_id:#{ap_id}"
1033 with {:ok, nil} <- Cachex.get(:user_cache, key),
1034 user when not is_nil(user) <- get_by_ap_id(ap_id),
1035 {:ok, true} <- Cachex.put(:user_cache, key, user) do
1043 def get_cached_by_id(id) do
1047 Cachex.fetch!(:user_cache, key, fn _ ->
1048 user = get_by_id(id)
1051 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1052 {:commit, user.ap_id}
1058 get_cached_by_ap_id(ap_id)
1061 def get_cached_by_nickname(nickname) do
1062 key = "nickname:#{nickname}"
1064 Cachex.fetch!(:user_cache, key, fn ->
1065 case get_or_fetch_by_nickname(nickname) do
1066 {:ok, user} -> {:commit, user}
1067 {:error, _error} -> {:ignore, nil}
1072 def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
1073 restrict_to_local = Config.get([:instance, :limit_to_local_content])
1076 is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
1077 get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
1079 restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
1080 get_cached_by_nickname(nickname_or_id)
1082 restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
1083 get_cached_by_nickname(nickname_or_id)
1090 @spec get_by_nickname(String.t()) :: User.t() | nil
1091 def get_by_nickname(nickname) do
1092 Repo.get_by(User, nickname: nickname) ||
1093 if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
1094 Repo.get_by(User, nickname: local_nickname(nickname))
1098 def get_by_email(email), do: Repo.get_by(User, email: email)
1100 def get_by_nickname_or_email(nickname_or_email) do
1101 get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
1104 def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
1106 def get_or_fetch_by_nickname(nickname) do
1107 with %User{} = user <- get_by_nickname(nickname) do
1111 with [_nick, _domain] <- String.split(nickname, "@"),
1112 {:ok, user} <- fetch_by_nickname(nickname) do
1115 _e -> {:error, "not found " <> nickname}
1120 @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1121 def get_followers_query(%User{} = user, nil) do
1122 User.Query.build(%{followers: user, deactivated: false})
1125 def get_followers_query(user, page) do
1127 |> get_followers_query(nil)
1128 |> User.Query.paginate(page, 20)
1131 @spec get_followers_query(User.t()) :: Ecto.Query.t()
1132 def get_followers_query(user), do: get_followers_query(user, nil)
1134 @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1135 def get_followers(user, page \\ nil) do
1137 |> get_followers_query(page)
1141 @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1142 def get_external_followers(user, page \\ nil) do
1144 |> get_followers_query(page)
1145 |> User.Query.build(%{external: true})
1149 def get_followers_ids(user, page \\ nil) do
1151 |> get_followers_query(page)
1152 |> select([u], u.id)
1156 @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1157 def get_friends_query(%User{} = user, nil) do
1158 User.Query.build(%{friends: user, deactivated: false})
1161 def get_friends_query(user, page) do
1163 |> get_friends_query(nil)
1164 |> User.Query.paginate(page, 20)
1167 @spec get_friends_query(User.t()) :: Ecto.Query.t()
1168 def get_friends_query(user), do: get_friends_query(user, nil)
1170 def get_friends(user, page \\ nil) do
1172 |> get_friends_query(page)
1176 def get_friends_ap_ids(user) do
1178 |> get_friends_query(nil)
1179 |> select([u], u.ap_id)
1183 def get_friends_ids(user, page \\ nil) do
1185 |> get_friends_query(page)
1186 |> select([u], u.id)
1190 defdelegate get_follow_requests(user), to: FollowingRelationship
1192 def increase_note_count(%User{} = user) do
1194 |> where(id: ^user.id)
1195 |> update([u], inc: [note_count: 1])
1197 |> Repo.update_all([])
1199 {1, [user]} -> set_cache(user)
1204 def decrease_note_count(%User{} = user) do
1206 |> where(id: ^user.id)
1209 note_count: fragment("greatest(0, note_count - 1)")
1213 |> Repo.update_all([])
1215 {1, [user]} -> set_cache(user)
1220 def update_note_count(%User{} = user, note_count \\ nil) do
1225 where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1231 |> cast(%{note_count: note_count}, [:note_count])
1232 |> update_and_set_cache()
1235 @spec maybe_fetch_follow_information(User.t()) :: User.t()
1236 def maybe_fetch_follow_information(user) do
1237 with {:ok, user} <- fetch_follow_information(user) do
1241 Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1247 def fetch_follow_information(user) do
1248 with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1250 |> follow_information_changeset(info)
1251 |> update_and_set_cache()
1255 defp follow_information_changeset(user, params) do
1262 :hide_followers_count,
1267 @spec update_follower_count(User.t()) :: {:ok, User.t()}
1268 def update_follower_count(%User{} = user) do
1269 if user.local or !Config.get([:instance, :external_user_synchronization]) do
1270 follower_count = FollowingRelationship.follower_count(user)
1273 |> follow_information_changeset(%{follower_count: follower_count})
1274 |> update_and_set_cache
1276 {:ok, maybe_fetch_follow_information(user)}
1280 @spec update_following_count(User.t()) :: {:ok, User.t()}
1281 def update_following_count(%User{local: false} = user) do
1282 if Config.get([:instance, :external_user_synchronization]) do
1283 {:ok, maybe_fetch_follow_information(user)}
1289 def update_following_count(%User{local: true} = user) do
1290 following_count = FollowingRelationship.following_count(user)
1293 |> follow_information_changeset(%{following_count: following_count})
1294 |> update_and_set_cache()
1297 def set_unread_conversation_count(%User{local: true} = user) do
1298 unread_query = Participation.unread_conversation_count_for_user(user)
1301 |> join(:inner, [u], p in subquery(unread_query))
1303 set: [unread_conversation_count: p.count]
1305 |> where([u], u.id == ^user.id)
1307 |> Repo.update_all([])
1309 {1, [user]} -> set_cache(user)
1314 def set_unread_conversation_count(user), do: {:ok, user}
1316 def increment_unread_conversation_count(conversation, %User{local: true} = user) do
1318 Participation.unread_conversation_count_for_user(user)
1319 |> where([p], p.conversation_id == ^conversation.id)
1322 |> join(:inner, [u], p in subquery(unread_query))
1324 inc: [unread_conversation_count: 1]
1326 |> where([u], u.id == ^user.id)
1327 |> where([u, p], p.count == 0)
1329 |> Repo.update_all([])
1331 {1, [user]} -> set_cache(user)
1336 def increment_unread_conversation_count(_, user), do: {:ok, user}
1338 @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1339 def get_users_from_set(ap_ids, opts \\ []) do
1340 local_only = Keyword.get(opts, :local_only, true)
1341 criteria = %{ap_id: ap_ids, deactivated: false}
1342 criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1344 User.Query.build(criteria)
1348 @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1349 def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1352 query = User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
1358 @spec mute(User.t(), User.t(), boolean()) ::
1359 {:ok, list(UserRelationship.t())} | {:error, String.t()}
1360 def mute(%User{} = muter, %User{} = mutee, notifications? \\ true) do
1361 add_to_mutes(muter, mutee, notifications?)
1364 def unmute(%User{} = muter, %User{} = mutee) do
1365 remove_from_mutes(muter, mutee)
1368 def subscribe(%User{} = subscriber, %User{} = target) do
1369 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
1371 if blocks?(target, subscriber) and deny_follow_blocked do
1372 {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1374 # Note: the relationship is inverse: subscriber acts as relationship target
1375 UserRelationship.create_inverse_subscription(target, subscriber)
1379 def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1380 with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1381 subscribe(subscriber, subscribee)
1385 def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1386 # Note: the relationship is inverse: subscriber acts as relationship target
1387 UserRelationship.delete_inverse_subscription(target, unsubscriber)
1390 def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1391 with %User{} = user <- get_cached_by_ap_id(ap_id) do
1392 unsubscribe(unsubscriber, user)
1396 def block(%User{} = blocker, %User{} = blocked) do
1397 # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1399 if following?(blocker, blocked) do
1400 {:ok, blocker, _} = unfollow(blocker, blocked)
1406 # clear any requested follows as well
1408 case CommonAPI.reject_follow_request(blocked, blocker) do
1409 {:ok, %User{} = updated_blocked} -> updated_blocked
1413 unsubscribe(blocked, blocker)
1415 unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
1416 if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)
1418 {:ok, blocker} = update_follower_count(blocker)
1419 {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1420 add_to_block(blocker, blocked)
1423 # helper to handle the block given only an actor's AP id
1424 def block(%User{} = blocker, %{ap_id: ap_id}) do
1425 block(blocker, get_cached_by_ap_id(ap_id))
1428 def unblock(%User{} = blocker, %User{} = blocked) do
1429 remove_from_block(blocker, blocked)
1432 # helper to handle the block given only an actor's AP id
1433 def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1434 unblock(blocker, get_cached_by_ap_id(ap_id))
1437 def mutes?(nil, _), do: false
1438 def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1440 def mutes_user?(%User{} = user, %User{} = target) do
1441 UserRelationship.mute_exists?(user, target)
1444 @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1445 def muted_notifications?(nil, _), do: false
1447 def muted_notifications?(%User{} = user, %User{} = target),
1448 do: UserRelationship.notification_mute_exists?(user, target)
1450 def blocks?(nil, _), do: false
1452 def blocks?(%User{} = user, %User{} = target) do
1453 blocks_user?(user, target) ||
1454 (blocks_domain?(user, target) and not User.following?(user, target))
1457 def blocks_user?(%User{} = user, %User{} = target) do
1458 UserRelationship.block_exists?(user, target)
1461 def blocks_user?(_, _), do: false
1463 def blocks_domain?(%User{} = user, %User{} = target) do
1464 domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1465 %{host: host} = URI.parse(target.ap_id)
1466 Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1469 def blocks_domain?(_, _), do: false
1471 def subscribed_to?(%User{} = user, %User{} = target) do
1472 # Note: the relationship is inverse: subscriber acts as relationship target
1473 UserRelationship.inverse_subscription_exists?(target, user)
1476 def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1477 with %User{} = target <- get_cached_by_ap_id(ap_id) do
1478 subscribed_to?(user, target)
1483 Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1484 E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1486 @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1487 def outgoing_relationships_ap_ids(_user, []), do: %{}
1489 def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1491 def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1492 when is_list(relationship_types) do
1495 |> assoc(:outgoing_relationships)
1496 |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1497 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1498 |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1499 |> group_by([user_rel, u], user_rel.relationship_type)
1501 |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1506 fn rel_type -> {rel_type, db_result[rel_type] || []} end
1510 def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1512 def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1514 def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1516 def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1517 when is_list(relationship_types) do
1519 |> assoc(:incoming_relationships)
1520 |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1521 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1522 |> maybe_filter_on_ap_id(ap_ids)
1523 |> select([user_rel, u], u.ap_id)
1528 defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1529 where(query, [user_rel, u], u.ap_id in ^ap_ids)
1532 defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1534 def deactivate_async(user, status \\ true) do
1535 BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
1538 def deactivate(user, status \\ true)
1540 def deactivate(users, status) when is_list(users) do
1541 Repo.transaction(fn ->
1542 for user <- users, do: deactivate(user, status)
1546 def deactivate(%User{} = user, status) do
1547 with {:ok, user} <- set_activation_status(user, status) do
1550 |> Enum.filter(& &1.local)
1551 |> Enum.each(&set_cache(update_following_count(&1)))
1553 # Only update local user counts, remote will be update during the next pull.
1556 |> Enum.filter(& &1.local)
1557 |> Enum.each(&do_unfollow(user, &1))
1563 def approve(users) when is_list(users) do
1564 Repo.transaction(fn ->
1565 Enum.map(users, fn user ->
1566 with {:ok, user} <- approve(user), do: user
1571 def approve(%User{} = user) do
1572 change(user, approval_pending: false)
1573 |> update_and_set_cache()
1576 def update_notification_settings(%User{} = user, settings) do
1578 |> cast(%{notification_settings: settings}, [])
1579 |> cast_embed(:notification_settings)
1580 |> validate_required([:notification_settings])
1581 |> update_and_set_cache()
1584 def delete(users) when is_list(users) do
1585 for user <- users, do: delete(user)
1588 def delete(%User{} = user) do
1589 BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1592 defp delete_and_invalidate_cache(%User{} = user) do
1593 invalidate_cache(user)
1597 defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)
1599 defp delete_or_deactivate(%User{local: true} = user) do
1600 status = account_status(user)
1603 :confirmation_pending ->
1604 delete_and_invalidate_cache(user)
1606 :approval_pending ->
1607 delete_and_invalidate_cache(user)
1611 |> change(%{deactivated: true, email: nil})
1612 |> update_and_set_cache()
1616 def perform(:force_password_reset, user), do: force_password_reset(user)
1618 @spec perform(atom(), User.t()) :: {:ok, User.t()}
1619 def perform(:delete, %User{} = user) do
1620 # Remove all relationships
1623 |> Enum.each(fn follower ->
1624 ActivityPub.unfollow(follower, user)
1625 unfollow(follower, user)
1630 |> Enum.each(fn followed ->
1631 ActivityPub.unfollow(user, followed)
1632 unfollow(user, followed)
1635 delete_user_activities(user)
1636 delete_notifications_from_user_activities(user)
1638 delete_outgoing_pending_follow_requests(user)
1640 delete_or_deactivate(user)
1643 def perform(:deactivate_async, user, status), do: deactivate(user, status)
1645 @spec perform(atom(), User.t(), list()) :: list() | {:error, any()}
1646 def perform(:blocks_import, %User{} = blocker, blocked_identifiers)
1647 when is_list(blocked_identifiers) do
1649 blocked_identifiers,
1650 fn blocked_identifier ->
1651 with {:ok, %User{} = blocked} <- get_or_fetch(blocked_identifier),
1652 {:ok, _block} <- CommonAPI.block(blocker, blocked) do
1656 Logger.debug("blocks_import failed for #{blocked_identifier} with: #{inspect(err)}")
1663 def perform(:follow_import, %User{} = follower, followed_identifiers)
1664 when is_list(followed_identifiers) do
1666 followed_identifiers,
1667 fn followed_identifier ->
1668 with {:ok, %User{} = followed} <- get_or_fetch(followed_identifier),
1669 {:ok, follower} <- maybe_direct_follow(follower, followed),
1670 {:ok, _, _, _} <- CommonAPI.follow(follower, followed) do
1674 Logger.debug("follow_import failed for #{followed_identifier} with: #{inspect(err)}")
1681 @spec external_users_query() :: Ecto.Query.t()
1682 def external_users_query do
1690 @spec external_users(keyword()) :: [User.t()]
1691 def external_users(opts \\ []) do
1693 external_users_query()
1694 |> select([u], struct(u, [:id, :ap_id]))
1698 do: where(query, [u], u.id > ^opts[:max_id]),
1703 do: limit(query, ^opts[:limit]),
1709 def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers) do
1710 BackgroundWorker.enqueue("blocks_import", %{
1711 "blocker_id" => blocker.id,
1712 "blocked_identifiers" => blocked_identifiers
1716 def follow_import(%User{} = follower, followed_identifiers)
1717 when is_list(followed_identifiers) do
1718 BackgroundWorker.enqueue("follow_import", %{
1719 "follower_id" => follower.id,
1720 "followed_identifiers" => followed_identifiers
1724 def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1726 |> join(:inner, [n], activity in assoc(n, :activity))
1727 |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1728 |> Repo.delete_all()
1731 def delete_user_activities(%User{ap_id: ap_id} = user) do
1733 |> Activity.Queries.by_actor()
1734 |> RepoStreamer.chunk_stream(50)
1735 |> Stream.each(fn activities ->
1736 Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1741 defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1742 with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1743 {:ok, delete_data, _} <- Builder.delete(user, object) do
1744 Pipeline.common_pipeline(delete_data, local: user.local)
1746 {:find_object, nil} ->
1747 # We have the create activity, but not the object, it was probably pruned.
1748 # Insert a tombstone and try again
1749 with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1750 {:ok, _tombstone} <- Object.create(tombstone_data) do
1751 delete_activity(activity, user)
1755 Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1756 Logger.error("Error: #{inspect(e)}")
1760 defp delete_activity(%{data: %{"type" => type}} = activity, user)
1761 when type in ["Like", "Announce"] do
1762 {:ok, undo, _} = Builder.undo(user, activity)
1763 Pipeline.common_pipeline(undo, local: user.local)
1766 defp delete_activity(_activity, _user), do: "Doing nothing"
1768 defp delete_outgoing_pending_follow_requests(user) do
1770 |> FollowingRelationship.outgoing_pending_follow_requests_query()
1771 |> Repo.delete_all()
1774 def html_filter_policy(%User{no_rich_text: true}) do
1775 Pleroma.HTML.Scrubber.TwitterText
1778 def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])
1780 def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1782 def get_or_fetch_by_ap_id(ap_id) do
1783 cached_user = get_cached_by_ap_id(ap_id)
1785 maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)
1787 case {cached_user, maybe_fetched_user} do
1788 {_, {:ok, %User{} = user}} ->
1791 {%User{} = user, _} ->
1795 {:error, :not_found}
1800 Creates an internal service actor by URI if missing.
1801 Optionally takes nickname for addressing.
1803 @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1804 def get_or_create_service_actor_by_ap_id(uri, nickname) do
1806 case get_cached_by_ap_id(uri) do
1808 with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1809 Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1813 %User{invisible: false} = user ->
1823 @spec set_invisible(User.t()) :: {:ok, User.t()}
1824 defp set_invisible(user) do
1826 |> change(%{invisible: true})
1827 |> update_and_set_cache()
1830 @spec create_service_actor(String.t(), String.t()) ::
1831 {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1832 defp create_service_actor(uri, nickname) do
1838 follower_address: uri <> "/followers"
1841 |> unique_constraint(:nickname)
1846 def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1849 |> :public_key.pem_decode()
1851 |> :public_key.pem_entry_decode()
1856 def public_key(_), do: {:error, "key not found"}
1858 def get_public_key_for_ap_id(ap_id) do
1859 with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1860 {:ok, public_key} <- public_key(user) do
1867 def ap_enabled?(%User{local: true}), do: true
1868 def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1869 def ap_enabled?(_), do: false
1871 @doc "Gets or fetch a user by uri or nickname."
1872 @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1873 def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1874 def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1876 # wait a period of time and return newest version of the User structs
1877 # this is because we have synchronous follow APIs and need to simulate them
1878 # with an async handshake
1879 def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1880 with %User{} = a <- get_cached_by_id(a.id),
1881 %User{} = b <- get_cached_by_id(b.id) do
1888 def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1889 with :ok <- :timer.sleep(timeout),
1890 %User{} = a <- get_cached_by_id(a.id),
1891 %User{} = b <- get_cached_by_id(b.id) do
1898 def parse_bio(bio) when is_binary(bio) and bio != "" do
1900 |> CommonUtils.format_input("text/plain", mentions_format: :full)
1904 def parse_bio(_), do: ""
1906 def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1907 # TODO: get profile URLs other than user.ap_id
1908 profile_urls = [user.ap_id]
1911 |> CommonUtils.format_input("text/plain",
1912 mentions_format: :full,
1913 rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1918 def parse_bio(_, _), do: ""
1920 def tag(user_identifiers, tags) when is_list(user_identifiers) do
1921 Repo.transaction(fn ->
1922 for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1926 def tag(nickname, tags) when is_binary(nickname),
1927 do: tag(get_by_nickname(nickname), tags)
1929 def tag(%User{} = user, tags),
1930 do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1932 def untag(user_identifiers, tags) when is_list(user_identifiers) do
1933 Repo.transaction(fn ->
1934 for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1938 def untag(nickname, tags) when is_binary(nickname),
1939 do: untag(get_by_nickname(nickname), tags)
1941 def untag(%User{} = user, tags),
1942 do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1944 defp update_tags(%User{} = user, new_tags) do
1945 {:ok, updated_user} =
1947 |> change(%{tags: new_tags})
1948 |> update_and_set_cache()
1953 defp normalize_tags(tags) do
1956 |> Enum.map(&String.downcase/1)
1959 defp local_nickname_regex do
1960 if Config.get([:instance, :extended_nickname_format]) do
1961 @extended_local_nickname_regex
1963 @strict_local_nickname_regex
1967 def local_nickname(nickname_or_mention) do
1970 |> String.split("@")
1974 def full_nickname(nickname_or_mention),
1975 do: String.trim_leading(nickname_or_mention, "@")
1977 def error_user(ap_id) do
1981 nickname: "erroruser@example.com",
1982 inserted_at: NaiveDateTime.utc_now()
1986 @spec all_superusers() :: [User.t()]
1987 def all_superusers do
1988 User.Query.build(%{super_users: true, local: true, deactivated: false})
1992 def muting_reblogs?(%User{} = user, %User{} = target) do
1993 UserRelationship.reblog_mute_exists?(user, target)
1996 def showing_reblogs?(%User{} = user, %User{} = target) do
1997 not muting_reblogs?(user, target)
2001 The function returns a query to get users with no activity for given interval of days.
2002 Inactive users are those who didn't read any notification, or had any activity where
2003 the user is the activity's actor, during `inactivity_threshold` days.
2004 Deactivated users will not appear in this list.
2008 iex> Pleroma.User.list_inactive_users()
2011 @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
2012 def list_inactive_users_query(inactivity_threshold \\ 7) do
2013 negative_inactivity_threshold = -inactivity_threshold
2014 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2015 # Subqueries are not supported in `where` clauses, join gets too complicated.
2016 has_read_notifications =
2017 from(n in Pleroma.Notification,
2018 where: n.seen == true,
2020 having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
2023 |> Pleroma.Repo.all()
2025 from(u in Pleroma.User,
2026 left_join: a in Pleroma.Activity,
2027 on: u.ap_id == a.actor,
2028 where: not is_nil(u.nickname),
2029 where: u.deactivated != ^true,
2030 where: u.id not in ^has_read_notifications,
2033 max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
2034 is_nil(max(a.inserted_at))
2039 Enable or disable email notifications for user
2043 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
2044 Pleroma.User{email_notifications: %{"digest" => true}}
2046 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
2047 Pleroma.User{email_notifications: %{"digest" => false}}
2049 @spec switch_email_notifications(t(), String.t(), boolean()) ::
2050 {:ok, t()} | {:error, Ecto.Changeset.t()}
2051 def switch_email_notifications(user, type, status) do
2052 User.update_email_notifications(user, %{type => status})
2056 Set `last_digest_emailed_at` value for the user to current time
2058 @spec touch_last_digest_emailed_at(t()) :: t()
2059 def touch_last_digest_emailed_at(user) do
2060 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2062 {:ok, updated_user} =
2064 |> change(%{last_digest_emailed_at: now})
2065 |> update_and_set_cache()
2070 @spec toggle_confirmation(User.t()) :: {:ok, User.t()} | {:error, Changeset.t()}
2071 def toggle_confirmation(%User{} = user) do
2073 |> confirmation_changeset(need_confirmation: !user.confirmation_pending)
2074 |> update_and_set_cache()
2077 @spec toggle_confirmation([User.t()]) :: [{:ok, User.t()} | {:error, Changeset.t()}]
2078 def toggle_confirmation(users) do
2079 Enum.map(users, &toggle_confirmation/1)
2082 def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
2086 def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
2087 # use instance-default
2088 config = Config.get([:assets, :mascots])
2089 default_mascot = Config.get([:assets, :default_mascot])
2090 mascot = Keyword.get(config, default_mascot)
2093 "id" => "default-mascot",
2094 "url" => mascot[:url],
2095 "preview_url" => mascot[:url],
2097 "mime_type" => mascot[:mime_type]
2102 def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
2104 def ensure_keys_present(%User{} = user) do
2105 with {:ok, pem} <- Keys.generate_rsa_pem() do
2107 |> cast(%{keys: pem}, [:keys])
2108 |> validate_required([:keys])
2109 |> update_and_set_cache()
2113 def get_ap_ids_by_nicknames(nicknames) do
2115 where: u.nickname in ^nicknames,
2121 defdelegate search(query, opts \\ []), to: User.Search
2123 defp put_password_hash(
2124 %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2126 change(changeset, password_hash: Pbkdf2.hash_pwd_salt(password))
2129 defp put_password_hash(changeset), do: changeset
2131 def is_internal_user?(%User{nickname: nil}), do: true
2132 def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2133 def is_internal_user?(_), do: false
2135 # A hack because user delete activities have a fake id for whatever reason
2136 # TODO: Get rid of this
2137 def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2139 def get_delivered_users_by_object_id(object_id) do
2141 inner_join: delivery in assoc(u, :deliveries),
2142 where: delivery.object_id == ^object_id
2147 def change_email(user, email) do
2149 |> cast(%{email: email}, [:email])
2150 |> validate_required([:email])
2151 |> unique_constraint(:email)
2152 |> validate_format(:email, @email_regex)
2153 |> update_and_set_cache()
2156 # Internal function; public one is `deactivate/2`
2157 defp set_activation_status(user, deactivated) do
2159 |> cast(%{deactivated: deactivated}, [:deactivated])
2160 |> update_and_set_cache()
2163 def update_banner(user, banner) do
2165 |> cast(%{banner: banner}, [:banner])
2166 |> update_and_set_cache()
2169 def update_background(user, background) do
2171 |> cast(%{background: background}, [:background])
2172 |> update_and_set_cache()
2175 def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
2178 moderator: is_moderator
2182 def validate_fields(changeset, remote? \\ false) do
2183 limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2184 limit = Config.get([:instance, limit_name], 0)
2187 |> validate_length(:fields, max: limit)
2188 |> validate_change(:fields, fn :fields, fields ->
2189 if Enum.all?(fields, &valid_field?/1) do
2197 defp valid_field?(%{"name" => name, "value" => value}) do
2198 name_limit = Config.get([:instance, :account_field_name_length], 255)
2199 value_limit = Config.get([:instance, :account_field_value_length], 255)
2201 is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2202 String.length(value) <= value_limit
2205 defp valid_field?(_), do: false
2207 defp truncate_field(%{"name" => name, "value" => value}) do
2209 String.split_at(name, Config.get([:instance, :account_field_name_length], 255))
2212 String.split_at(value, Config.get([:instance, :account_field_value_length], 255))
2214 %{"name" => name, "value" => value}
2217 def admin_api_update(user, params) do
2224 |> update_and_set_cache()
2227 @doc "Signs user out of all applications"
2228 def global_sign_out(user) do
2229 OAuth.Authorization.delete_user_authorizations(user)
2230 OAuth.Token.delete_user_tokens(user)
2233 def mascot_update(user, url) do
2235 |> cast(%{mascot: url}, [:mascot])
2236 |> validate_required([:mascot])
2237 |> update_and_set_cache()
2240 def mastodon_settings_update(user, settings) do
2242 |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
2243 |> validate_required([:mastofe_settings])
2244 |> update_and_set_cache()
2247 @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2248 def confirmation_changeset(user, need_confirmation: need_confirmation?) do
2250 if need_confirmation? do
2252 confirmation_pending: true,
2253 confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2257 confirmation_pending: false,
2258 confirmation_token: nil
2262 cast(user, params, [:confirmation_pending, :confirmation_token])
2265 @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
2266 def approval_changeset(user, need_approval: need_approval?) do
2267 params = if need_approval?, do: %{approval_pending: true}, else: %{approval_pending: false}
2268 cast(user, params, [:approval_pending])
2271 def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2272 if id not in user.pinned_activities do
2273 max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2274 params = %{pinned_activities: user.pinned_activities ++ [id]}
2277 |> cast(params, [:pinned_activities])
2278 |> validate_length(:pinned_activities,
2279 max: max_pinned_statuses,
2280 message: "You have already pinned the maximum number of statuses"
2285 |> update_and_set_cache()
2288 def remove_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2289 params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2292 |> cast(params, [:pinned_activities])
2293 |> update_and_set_cache()
2296 def update_email_notifications(user, settings) do
2297 email_notifications =
2298 user.email_notifications
2299 |> Map.merge(settings)
2300 |> Map.take(["digest"])
2302 params = %{email_notifications: email_notifications}
2303 fields = [:email_notifications]
2306 |> cast(params, fields)
2307 |> validate_required(fields)
2308 |> update_and_set_cache()
2311 defp set_domain_blocks(user, domain_blocks) do
2312 params = %{domain_blocks: domain_blocks}
2315 |> cast(params, [:domain_blocks])
2316 |> validate_required([:domain_blocks])
2317 |> update_and_set_cache()
2320 def block_domain(user, domain_blocked) do
2321 set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2324 def unblock_domain(user, domain_blocked) do
2325 set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2328 @spec add_to_block(User.t(), User.t()) ::
2329 {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2330 defp add_to_block(%User{} = user, %User{} = blocked) do
2331 UserRelationship.create_block(user, blocked)
2334 @spec add_to_block(User.t(), User.t()) ::
2335 {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2336 defp remove_from_block(%User{} = user, %User{} = blocked) do
2337 UserRelationship.delete_block(user, blocked)
2340 defp add_to_mutes(%User{} = user, %User{} = muted_user, notifications?) do
2341 with {:ok, user_mute} <- UserRelationship.create_mute(user, muted_user),
2342 {:ok, user_notification_mute} <-
2343 (notifications? && UserRelationship.create_notification_mute(user, muted_user)) ||
2345 {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
2349 defp remove_from_mutes(user, %User{} = muted_user) do
2350 with {:ok, user_mute} <- UserRelationship.delete_mute(user, muted_user),
2351 {:ok, user_notification_mute} <-
2352 UserRelationship.delete_notification_mute(user, muted_user) do
2353 {:ok, [user_mute, user_notification_mute]}
2357 def set_invisible(user, invisible) do
2358 params = %{invisible: invisible}
2361 |> cast(params, [:invisible])
2362 |> validate_required([:invisible])
2363 |> update_and_set_cache()
2366 def sanitize_html(%User{} = user) do
2367 sanitize_html(user, nil)
2370 # User data that mastodon isn't filtering (treated as plaintext):
2373 def sanitize_html(%User{} = user, filter) do
2375 Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2378 "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2383 |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2384 |> Map.put(:fields, fields)