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 def register_changeset(struct, params \\ %{}, opts \\ []) do
642 bio_limit = Config.get([:instance, :user_bio_length], 5000)
643 name_limit = Config.get([:instance, :user_name_length], 100)
644 reason_limit = Config.get([:instance, :registration_reason_length], 500)
645 params = Map.put_new(params, :accepts_chat_messages, true)
648 if is_nil(opts[:need_confirmation]) do
649 Config.get([:instance, :account_activation_required])
651 opts[:need_confirmation]
655 if is_nil(opts[:need_approval]) do
656 Config.get([:instance, :account_approval_required])
662 |> confirmation_changeset(need_confirmation: need_confirmation?)
663 |> approval_changeset(need_approval: need_approval?)
671 :password_confirmation,
673 :accepts_chat_messages,
676 |> validate_required([:name, :nickname, :password, :password_confirmation])
677 |> validate_confirmation(:password)
678 |> unique_constraint(:email)
679 |> validate_format(:email, @email_regex)
680 |> validate_change(:email, fn :email, email ->
682 Config.get([User, :email_blacklist])
683 |> Enum.all?(fn blacklisted_domain ->
684 !String.ends_with?(email, ["@" <> blacklisted_domain, "." <> blacklisted_domain])
687 if valid?, do: [], else: [email: "Invalid email"]
689 |> unique_constraint(:nickname)
690 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
691 |> validate_format(:nickname, local_nickname_regex())
692 |> validate_length(:bio, max: bio_limit)
693 |> validate_length(:name, min: 1, max: name_limit)
694 |> validate_length(:registration_reason, max: reason_limit)
695 |> maybe_validate_required_email(opts[:external])
698 |> unique_constraint(:ap_id)
699 |> put_following_and_follower_address()
702 def maybe_validate_required_email(changeset, true), do: changeset
704 def maybe_validate_required_email(changeset, _) do
705 if Config.get([:instance, :account_activation_required]) do
706 validate_required(changeset, [:email])
712 defp put_ap_id(changeset) do
713 ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
714 put_change(changeset, :ap_id, ap_id)
717 defp put_following_and_follower_address(changeset) do
718 followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
721 |> put_change(:follower_address, followers)
724 defp autofollow_users(user) do
725 candidates = Config.get([:instance, :autofollowed_nicknames])
728 User.Query.build(%{nickname: candidates, local: true, deactivated: false})
731 follow_all(user, autofollowed_users)
734 @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
735 def register(%Ecto.Changeset{} = changeset) do
736 with {:ok, user} <- Repo.insert(changeset) do
737 post_register_action(user)
741 def post_register_action(%User{} = user) do
742 with {:ok, user} <- autofollow_users(user),
743 {:ok, user} <- set_cache(user),
744 {:ok, _} <- send_welcome_email(user),
745 {:ok, _} <- send_welcome_message(user),
746 {:ok, _} <- send_welcome_chat_message(user),
747 {:ok, _} <- try_send_confirmation_email(user) do
752 def send_welcome_message(user) do
753 if User.WelcomeMessage.enabled?() do
754 User.WelcomeMessage.post_message(user)
761 def send_welcome_chat_message(user) do
762 if User.WelcomeChatMessage.enabled?() do
763 User.WelcomeChatMessage.post_message(user)
770 def send_welcome_email(%User{email: email} = user) when is_binary(email) do
771 if User.WelcomeEmail.enabled?() do
772 User.WelcomeEmail.send_email(user)
779 def send_welcome_email(_), do: {:ok, :noop}
781 @spec try_send_confirmation_email(User.t()) :: {:ok, :enqueued | :noop}
782 def try_send_confirmation_email(%User{confirmation_pending: true} = user) do
783 if Config.get([:instance, :account_activation_required]) do
784 send_confirmation_email(user)
791 def try_send_confirmation_email(_), do: {:ok, :noop}
793 @spec send_confirmation_email(Uset.t()) :: User.t()
794 def send_confirmation_email(%User{} = user) do
796 |> Pleroma.Emails.UserEmail.account_confirmation_email()
797 |> Pleroma.Emails.Mailer.deliver_async()
802 def needs_update?(%User{local: true}), do: false
804 def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
806 def needs_update?(%User{local: false} = user) do
807 NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
810 def needs_update?(_), do: true
812 @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
814 # "Locked" (self-locked) users demand explicit authorization of follow requests
815 def maybe_direct_follow(%User{} = follower, %User{local: true, locked: true} = followed) do
816 follow(follower, followed, :follow_pending)
819 def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
820 follow(follower, followed)
823 def maybe_direct_follow(%User{} = follower, %User{} = followed) do
824 if not ap_enabled?(followed) do
825 follow(follower, followed)
831 @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
832 @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
833 def follow_all(follower, followeds) do
835 |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
836 |> Enum.each(&follow(follower, &1, :follow_accept))
841 defdelegate following(user), to: FollowingRelationship
843 def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
844 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
847 followed.deactivated ->
848 {:error, "Could not follow user: #{followed.nickname} is deactivated."}
850 deny_follow_blocked and blocks?(followed, follower) ->
851 {:error, "Could not follow user: #{followed.nickname} blocked you."}
854 FollowingRelationship.follow(follower, followed, state)
856 {:ok, _} = update_follower_count(followed)
859 |> update_following_count()
863 def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
864 {:error, "Not subscribed!"}
867 @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
868 def unfollow(%User{} = follower, %User{} = followed) do
869 case do_unfollow(follower, followed) do
870 {:ok, follower, followed} ->
871 {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
878 @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
879 defp do_unfollow(%User{} = follower, %User{} = followed) do
880 case get_follow_state(follower, followed) do
881 state when state in [:follow_pending, :follow_accept] ->
882 FollowingRelationship.unfollow(follower, followed)
883 {:ok, followed} = update_follower_count(followed)
887 |> update_following_count()
889 {:ok, follower, followed}
892 {:error, "Not subscribed!"}
896 defdelegate following?(follower, followed), to: FollowingRelationship
898 @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
899 def get_follow_state(%User{} = follower, %User{} = following) do
900 following_relationship = FollowingRelationship.get(follower, following)
901 get_follow_state(follower, following, following_relationship)
904 def get_follow_state(
907 following_relationship
909 case {following_relationship, following.local} do
911 case Utils.fetch_latest_follow(follower, following) do
912 %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
913 FollowingRelationship.state_to_enum(state)
919 {%{state: state}, _} ->
927 def locked?(%User{} = user) do
932 Repo.get_by(User, id: id)
935 def get_by_ap_id(ap_id) do
936 Repo.get_by(User, ap_id: ap_id)
939 def get_all_by_ap_id(ap_ids) do
940 from(u in __MODULE__,
941 where: u.ap_id in ^ap_ids
946 def get_all_by_ids(ids) do
947 from(u in __MODULE__, where: u.id in ^ids)
951 # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
952 # of the ap_id and the domain and tries to get that user
953 def get_by_guessed_nickname(ap_id) do
954 domain = URI.parse(ap_id).host
955 name = List.last(String.split(ap_id, "/"))
956 nickname = "#{name}@#{domain}"
958 get_cached_by_nickname(nickname)
961 def set_cache({:ok, user}), do: set_cache(user)
962 def set_cache({:error, err}), do: {:error, err}
964 def set_cache(%User{} = user) do
965 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
966 Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
967 Cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
971 def update_and_set_cache(struct, params) do
973 |> update_changeset(params)
974 |> update_and_set_cache()
977 def update_and_set_cache(changeset) do
978 with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
983 def get_user_friends_ap_ids(user) do
984 from(u in User.get_friends_query(user), select: u.ap_id)
988 @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
989 def get_cached_user_friends_ap_ids(user) do
990 Cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
991 get_user_friends_ap_ids(user)
995 def invalidate_cache(user) do
996 Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
997 Cachex.del(:user_cache, "nickname:#{user.nickname}")
998 Cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
1001 @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
1002 def get_cached_by_ap_id(ap_id) do
1003 key = "ap_id:#{ap_id}"
1005 with {:ok, nil} <- Cachex.get(:user_cache, key),
1006 user when not is_nil(user) <- get_by_ap_id(ap_id),
1007 {:ok, true} <- Cachex.put(:user_cache, key, user) do
1015 def get_cached_by_id(id) do
1019 Cachex.fetch!(:user_cache, key, fn _ ->
1020 user = get_by_id(id)
1023 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1024 {:commit, user.ap_id}
1030 get_cached_by_ap_id(ap_id)
1033 def get_cached_by_nickname(nickname) do
1034 key = "nickname:#{nickname}"
1036 Cachex.fetch!(:user_cache, key, fn ->
1037 case get_or_fetch_by_nickname(nickname) do
1038 {:ok, user} -> {:commit, user}
1039 {:error, _error} -> {:ignore, nil}
1044 def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
1045 restrict_to_local = Config.get([:instance, :limit_to_local_content])
1048 is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
1049 get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
1051 restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
1052 get_cached_by_nickname(nickname_or_id)
1054 restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
1055 get_cached_by_nickname(nickname_or_id)
1062 @spec get_by_nickname(String.t()) :: User.t() | nil
1063 def get_by_nickname(nickname) do
1064 Repo.get_by(User, nickname: nickname) ||
1065 if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
1066 Repo.get_by(User, nickname: local_nickname(nickname))
1070 def get_by_email(email), do: Repo.get_by(User, email: email)
1072 def get_by_nickname_or_email(nickname_or_email) do
1073 get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
1076 def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
1078 def get_or_fetch_by_nickname(nickname) do
1079 with %User{} = user <- get_by_nickname(nickname) do
1083 with [_nick, _domain] <- String.split(nickname, "@"),
1084 {:ok, user} <- fetch_by_nickname(nickname) do
1087 _e -> {:error, "not found " <> nickname}
1092 @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1093 def get_followers_query(%User{} = user, nil) do
1094 User.Query.build(%{followers: user, deactivated: false})
1097 def get_followers_query(user, page) do
1099 |> get_followers_query(nil)
1100 |> User.Query.paginate(page, 20)
1103 @spec get_followers_query(User.t()) :: Ecto.Query.t()
1104 def get_followers_query(user), do: get_followers_query(user, nil)
1106 @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1107 def get_followers(user, page \\ nil) do
1109 |> get_followers_query(page)
1113 @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1114 def get_external_followers(user, page \\ nil) do
1116 |> get_followers_query(page)
1117 |> User.Query.build(%{external: true})
1121 def get_followers_ids(user, page \\ nil) do
1123 |> get_followers_query(page)
1124 |> select([u], u.id)
1128 @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1129 def get_friends_query(%User{} = user, nil) do
1130 User.Query.build(%{friends: user, deactivated: false})
1133 def get_friends_query(user, page) do
1135 |> get_friends_query(nil)
1136 |> User.Query.paginate(page, 20)
1139 @spec get_friends_query(User.t()) :: Ecto.Query.t()
1140 def get_friends_query(user), do: get_friends_query(user, nil)
1142 def get_friends(user, page \\ nil) do
1144 |> get_friends_query(page)
1148 def get_friends_ap_ids(user) do
1150 |> get_friends_query(nil)
1151 |> select([u], u.ap_id)
1155 def get_friends_ids(user, page \\ nil) do
1157 |> get_friends_query(page)
1158 |> select([u], u.id)
1162 defdelegate get_follow_requests(user), to: FollowingRelationship
1164 def increase_note_count(%User{} = user) do
1166 |> where(id: ^user.id)
1167 |> update([u], inc: [note_count: 1])
1169 |> Repo.update_all([])
1171 {1, [user]} -> set_cache(user)
1176 def decrease_note_count(%User{} = user) do
1178 |> where(id: ^user.id)
1181 note_count: fragment("greatest(0, note_count - 1)")
1185 |> Repo.update_all([])
1187 {1, [user]} -> set_cache(user)
1192 def update_note_count(%User{} = user, note_count \\ nil) do
1197 where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1203 |> cast(%{note_count: note_count}, [:note_count])
1204 |> update_and_set_cache()
1207 @spec maybe_fetch_follow_information(User.t()) :: User.t()
1208 def maybe_fetch_follow_information(user) do
1209 with {:ok, user} <- fetch_follow_information(user) do
1213 Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1219 def fetch_follow_information(user) do
1220 with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1222 |> follow_information_changeset(info)
1223 |> update_and_set_cache()
1227 defp follow_information_changeset(user, params) do
1234 :hide_followers_count,
1239 @spec update_follower_count(User.t()) :: {:ok, User.t()}
1240 def update_follower_count(%User{} = user) do
1241 if user.local or !Config.get([:instance, :external_user_synchronization]) do
1242 follower_count = FollowingRelationship.follower_count(user)
1245 |> follow_information_changeset(%{follower_count: follower_count})
1246 |> update_and_set_cache
1248 {:ok, maybe_fetch_follow_information(user)}
1252 @spec update_following_count(User.t()) :: {:ok, User.t()}
1253 def update_following_count(%User{local: false} = user) do
1254 if Config.get([:instance, :external_user_synchronization]) do
1255 {:ok, maybe_fetch_follow_information(user)}
1261 def update_following_count(%User{local: true} = user) do
1262 following_count = FollowingRelationship.following_count(user)
1265 |> follow_information_changeset(%{following_count: following_count})
1266 |> update_and_set_cache()
1269 def set_unread_conversation_count(%User{local: true} = user) do
1270 unread_query = Participation.unread_conversation_count_for_user(user)
1273 |> join(:inner, [u], p in subquery(unread_query))
1275 set: [unread_conversation_count: p.count]
1277 |> where([u], u.id == ^user.id)
1279 |> Repo.update_all([])
1281 {1, [user]} -> set_cache(user)
1286 def set_unread_conversation_count(user), do: {:ok, user}
1288 def increment_unread_conversation_count(conversation, %User{local: true} = user) do
1290 Participation.unread_conversation_count_for_user(user)
1291 |> where([p], p.conversation_id == ^conversation.id)
1294 |> join(:inner, [u], p in subquery(unread_query))
1296 inc: [unread_conversation_count: 1]
1298 |> where([u], u.id == ^user.id)
1299 |> where([u, p], p.count == 0)
1301 |> Repo.update_all([])
1303 {1, [user]} -> set_cache(user)
1308 def increment_unread_conversation_count(_, user), do: {:ok, user}
1310 @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1311 def get_users_from_set(ap_ids, opts \\ []) do
1312 local_only = Keyword.get(opts, :local_only, true)
1313 criteria = %{ap_id: ap_ids, deactivated: false}
1314 criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1316 User.Query.build(criteria)
1320 @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1321 def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1324 query = User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
1330 @spec mute(User.t(), User.t(), boolean()) ::
1331 {:ok, list(UserRelationship.t())} | {:error, String.t()}
1332 def mute(%User{} = muter, %User{} = mutee, notifications? \\ true) do
1333 add_to_mutes(muter, mutee, notifications?)
1336 def unmute(%User{} = muter, %User{} = mutee) do
1337 remove_from_mutes(muter, mutee)
1340 def subscribe(%User{} = subscriber, %User{} = target) do
1341 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
1343 if blocks?(target, subscriber) and deny_follow_blocked do
1344 {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1346 # Note: the relationship is inverse: subscriber acts as relationship target
1347 UserRelationship.create_inverse_subscription(target, subscriber)
1351 def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1352 with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1353 subscribe(subscriber, subscribee)
1357 def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1358 # Note: the relationship is inverse: subscriber acts as relationship target
1359 UserRelationship.delete_inverse_subscription(target, unsubscriber)
1362 def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1363 with %User{} = user <- get_cached_by_ap_id(ap_id) do
1364 unsubscribe(unsubscriber, user)
1368 def block(%User{} = blocker, %User{} = blocked) do
1369 # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1371 if following?(blocker, blocked) do
1372 {:ok, blocker, _} = unfollow(blocker, blocked)
1378 # clear any requested follows as well
1380 case CommonAPI.reject_follow_request(blocked, blocker) do
1381 {:ok, %User{} = updated_blocked} -> updated_blocked
1385 unsubscribe(blocked, blocker)
1387 unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
1388 if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)
1390 {:ok, blocker} = update_follower_count(blocker)
1391 {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1392 add_to_block(blocker, blocked)
1395 # helper to handle the block given only an actor's AP id
1396 def block(%User{} = blocker, %{ap_id: ap_id}) do
1397 block(blocker, get_cached_by_ap_id(ap_id))
1400 def unblock(%User{} = blocker, %User{} = blocked) do
1401 remove_from_block(blocker, blocked)
1404 # helper to handle the block given only an actor's AP id
1405 def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1406 unblock(blocker, get_cached_by_ap_id(ap_id))
1409 def mutes?(nil, _), do: false
1410 def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1412 def mutes_user?(%User{} = user, %User{} = target) do
1413 UserRelationship.mute_exists?(user, target)
1416 @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1417 def muted_notifications?(nil, _), do: false
1419 def muted_notifications?(%User{} = user, %User{} = target),
1420 do: UserRelationship.notification_mute_exists?(user, target)
1422 def blocks?(nil, _), do: false
1424 def blocks?(%User{} = user, %User{} = target) do
1425 blocks_user?(user, target) ||
1426 (blocks_domain?(user, target) and not User.following?(user, target))
1429 def blocks_user?(%User{} = user, %User{} = target) do
1430 UserRelationship.block_exists?(user, target)
1433 def blocks_user?(_, _), do: false
1435 def blocks_domain?(%User{} = user, %User{} = target) do
1436 domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1437 %{host: host} = URI.parse(target.ap_id)
1438 Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1441 def blocks_domain?(_, _), do: false
1443 def subscribed_to?(%User{} = user, %User{} = target) do
1444 # Note: the relationship is inverse: subscriber acts as relationship target
1445 UserRelationship.inverse_subscription_exists?(target, user)
1448 def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1449 with %User{} = target <- get_cached_by_ap_id(ap_id) do
1450 subscribed_to?(user, target)
1455 Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1456 E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1458 @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1459 def outgoing_relationships_ap_ids(_user, []), do: %{}
1461 def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1463 def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1464 when is_list(relationship_types) do
1467 |> assoc(:outgoing_relationships)
1468 |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1469 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1470 |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1471 |> group_by([user_rel, u], user_rel.relationship_type)
1473 |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1478 fn rel_type -> {rel_type, db_result[rel_type] || []} end
1482 def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1484 def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1486 def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1488 def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1489 when is_list(relationship_types) do
1491 |> assoc(:incoming_relationships)
1492 |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1493 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1494 |> maybe_filter_on_ap_id(ap_ids)
1495 |> select([user_rel, u], u.ap_id)
1500 defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1501 where(query, [user_rel, u], u.ap_id in ^ap_ids)
1504 defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1506 def deactivate_async(user, status \\ true) do
1507 BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
1510 def deactivate(user, status \\ true)
1512 def deactivate(users, status) when is_list(users) do
1513 Repo.transaction(fn ->
1514 for user <- users, do: deactivate(user, status)
1518 def deactivate(%User{} = user, status) do
1519 with {:ok, user} <- set_activation_status(user, status) do
1522 |> Enum.filter(& &1.local)
1523 |> Enum.each(&set_cache(update_following_count(&1)))
1525 # Only update local user counts, remote will be update during the next pull.
1528 |> Enum.filter(& &1.local)
1529 |> Enum.each(&do_unfollow(user, &1))
1535 def approve(users) when is_list(users) do
1536 Repo.transaction(fn ->
1537 Enum.map(users, fn user ->
1538 with {:ok, user} <- approve(user), do: user
1543 def approve(%User{} = user) do
1544 change(user, approval_pending: false)
1545 |> update_and_set_cache()
1548 def update_notification_settings(%User{} = user, settings) do
1550 |> cast(%{notification_settings: settings}, [])
1551 |> cast_embed(:notification_settings)
1552 |> validate_required([:notification_settings])
1553 |> update_and_set_cache()
1556 def delete(users) when is_list(users) do
1557 for user <- users, do: delete(user)
1560 def delete(%User{} = user) do
1561 BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1564 defp delete_and_invalidate_cache(%User{} = user) do
1565 invalidate_cache(user)
1569 defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)
1571 defp delete_or_deactivate(%User{local: true} = user) do
1572 status = account_status(user)
1575 :confirmation_pending ->
1576 delete_and_invalidate_cache(user)
1578 :approval_pending ->
1579 delete_and_invalidate_cache(user)
1583 |> change(%{deactivated: true, email: nil})
1584 |> update_and_set_cache()
1588 def perform(:force_password_reset, user), do: force_password_reset(user)
1590 @spec perform(atom(), User.t()) :: {:ok, User.t()}
1591 def perform(:delete, %User{} = user) do
1592 # Remove all relationships
1595 |> Enum.each(fn follower ->
1596 ActivityPub.unfollow(follower, user)
1597 unfollow(follower, user)
1602 |> Enum.each(fn followed ->
1603 ActivityPub.unfollow(user, followed)
1604 unfollow(user, followed)
1607 delete_user_activities(user)
1608 delete_notifications_from_user_activities(user)
1610 delete_outgoing_pending_follow_requests(user)
1612 delete_or_deactivate(user)
1615 def perform(:deactivate_async, user, status), do: deactivate(user, status)
1617 @spec perform(atom(), User.t(), list()) :: list() | {:error, any()}
1618 def perform(:blocks_import, %User{} = blocker, blocked_identifiers)
1619 when is_list(blocked_identifiers) do
1621 blocked_identifiers,
1622 fn blocked_identifier ->
1623 with {:ok, %User{} = blocked} <- get_or_fetch(blocked_identifier),
1624 {:ok, _block} <- CommonAPI.block(blocker, blocked) do
1628 Logger.debug("blocks_import failed for #{blocked_identifier} with: #{inspect(err)}")
1635 def perform(:follow_import, %User{} = follower, followed_identifiers)
1636 when is_list(followed_identifiers) do
1638 followed_identifiers,
1639 fn followed_identifier ->
1640 with {:ok, %User{} = followed} <- get_or_fetch(followed_identifier),
1641 {:ok, follower} <- maybe_direct_follow(follower, followed),
1642 {:ok, _, _, _} <- CommonAPI.follow(follower, followed) do
1646 Logger.debug("follow_import failed for #{followed_identifier} with: #{inspect(err)}")
1653 @spec external_users_query() :: Ecto.Query.t()
1654 def external_users_query do
1662 @spec external_users(keyword()) :: [User.t()]
1663 def external_users(opts \\ []) do
1665 external_users_query()
1666 |> select([u], struct(u, [:id, :ap_id]))
1670 do: where(query, [u], u.id > ^opts[:max_id]),
1675 do: limit(query, ^opts[:limit]),
1681 def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers) do
1682 BackgroundWorker.enqueue("blocks_import", %{
1683 "blocker_id" => blocker.id,
1684 "blocked_identifiers" => blocked_identifiers
1688 def follow_import(%User{} = follower, followed_identifiers)
1689 when is_list(followed_identifiers) do
1690 BackgroundWorker.enqueue("follow_import", %{
1691 "follower_id" => follower.id,
1692 "followed_identifiers" => followed_identifiers
1696 def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1698 |> join(:inner, [n], activity in assoc(n, :activity))
1699 |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1700 |> Repo.delete_all()
1703 def delete_user_activities(%User{ap_id: ap_id} = user) do
1705 |> Activity.Queries.by_actor()
1706 |> RepoStreamer.chunk_stream(50)
1707 |> Stream.each(fn activities ->
1708 Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1713 defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1714 with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1715 {:ok, delete_data, _} <- Builder.delete(user, object) do
1716 Pipeline.common_pipeline(delete_data, local: user.local)
1718 {:find_object, nil} ->
1719 # We have the create activity, but not the object, it was probably pruned.
1720 # Insert a tombstone and try again
1721 with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1722 {:ok, _tombstone} <- Object.create(tombstone_data) do
1723 delete_activity(activity, user)
1727 Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1728 Logger.error("Error: #{inspect(e)}")
1732 defp delete_activity(%{data: %{"type" => type}} = activity, user)
1733 when type in ["Like", "Announce"] do
1734 {:ok, undo, _} = Builder.undo(user, activity)
1735 Pipeline.common_pipeline(undo, local: user.local)
1738 defp delete_activity(_activity, _user), do: "Doing nothing"
1740 defp delete_outgoing_pending_follow_requests(user) do
1742 |> FollowingRelationship.outgoing_pending_follow_requests_query()
1743 |> Repo.delete_all()
1746 def html_filter_policy(%User{no_rich_text: true}) do
1747 Pleroma.HTML.Scrubber.TwitterText
1750 def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])
1752 def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1754 def get_or_fetch_by_ap_id(ap_id) do
1755 cached_user = get_cached_by_ap_id(ap_id)
1757 maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)
1759 case {cached_user, maybe_fetched_user} do
1760 {_, {:ok, %User{} = user}} ->
1763 {%User{} = user, _} ->
1767 {:error, :not_found}
1772 Creates an internal service actor by URI if missing.
1773 Optionally takes nickname for addressing.
1775 @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1776 def get_or_create_service_actor_by_ap_id(uri, nickname) do
1778 case get_cached_by_ap_id(uri) do
1780 with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1781 Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1785 %User{invisible: false} = user ->
1795 @spec set_invisible(User.t()) :: {:ok, User.t()}
1796 defp set_invisible(user) do
1798 |> change(%{invisible: true})
1799 |> update_and_set_cache()
1802 @spec create_service_actor(String.t(), String.t()) ::
1803 {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1804 defp create_service_actor(uri, nickname) do
1810 follower_address: uri <> "/followers"
1813 |> unique_constraint(:nickname)
1818 def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1821 |> :public_key.pem_decode()
1823 |> :public_key.pem_entry_decode()
1828 def public_key(_), do: {:error, "key not found"}
1830 def get_public_key_for_ap_id(ap_id) do
1831 with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1832 {:ok, public_key} <- public_key(user) do
1839 def ap_enabled?(%User{local: true}), do: true
1840 def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1841 def ap_enabled?(_), do: false
1843 @doc "Gets or fetch a user by uri or nickname."
1844 @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1845 def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1846 def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1848 # wait a period of time and return newest version of the User structs
1849 # this is because we have synchronous follow APIs and need to simulate them
1850 # with an async handshake
1851 def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1852 with %User{} = a <- get_cached_by_id(a.id),
1853 %User{} = b <- get_cached_by_id(b.id) do
1860 def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1861 with :ok <- :timer.sleep(timeout),
1862 %User{} = a <- get_cached_by_id(a.id),
1863 %User{} = b <- get_cached_by_id(b.id) do
1870 def parse_bio(bio) when is_binary(bio) and bio != "" do
1872 |> CommonUtils.format_input("text/plain", mentions_format: :full)
1876 def parse_bio(_), do: ""
1878 def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1879 # TODO: get profile URLs other than user.ap_id
1880 profile_urls = [user.ap_id]
1883 |> CommonUtils.format_input("text/plain",
1884 mentions_format: :full,
1885 rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1890 def parse_bio(_, _), do: ""
1892 def tag(user_identifiers, tags) when is_list(user_identifiers) do
1893 Repo.transaction(fn ->
1894 for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1898 def tag(nickname, tags) when is_binary(nickname),
1899 do: tag(get_by_nickname(nickname), tags)
1901 def tag(%User{} = user, tags),
1902 do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1904 def untag(user_identifiers, tags) when is_list(user_identifiers) do
1905 Repo.transaction(fn ->
1906 for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1910 def untag(nickname, tags) when is_binary(nickname),
1911 do: untag(get_by_nickname(nickname), tags)
1913 def untag(%User{} = user, tags),
1914 do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1916 defp update_tags(%User{} = user, new_tags) do
1917 {:ok, updated_user} =
1919 |> change(%{tags: new_tags})
1920 |> update_and_set_cache()
1925 defp normalize_tags(tags) do
1928 |> Enum.map(&String.downcase/1)
1931 defp local_nickname_regex do
1932 if Config.get([:instance, :extended_nickname_format]) do
1933 @extended_local_nickname_regex
1935 @strict_local_nickname_regex
1939 def local_nickname(nickname_or_mention) do
1942 |> String.split("@")
1946 def full_nickname(nickname_or_mention),
1947 do: String.trim_leading(nickname_or_mention, "@")
1949 def error_user(ap_id) do
1953 nickname: "erroruser@example.com",
1954 inserted_at: NaiveDateTime.utc_now()
1958 @spec all_superusers() :: [User.t()]
1959 def all_superusers do
1960 User.Query.build(%{super_users: true, local: true, deactivated: false})
1964 def muting_reblogs?(%User{} = user, %User{} = target) do
1965 UserRelationship.reblog_mute_exists?(user, target)
1968 def showing_reblogs?(%User{} = user, %User{} = target) do
1969 not muting_reblogs?(user, target)
1973 The function returns a query to get users with no activity for given interval of days.
1974 Inactive users are those who didn't read any notification, or had any activity where
1975 the user is the activity's actor, during `inactivity_threshold` days.
1976 Deactivated users will not appear in this list.
1980 iex> Pleroma.User.list_inactive_users()
1983 @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
1984 def list_inactive_users_query(inactivity_threshold \\ 7) do
1985 negative_inactivity_threshold = -inactivity_threshold
1986 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
1987 # Subqueries are not supported in `where` clauses, join gets too complicated.
1988 has_read_notifications =
1989 from(n in Pleroma.Notification,
1990 where: n.seen == true,
1992 having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
1995 |> Pleroma.Repo.all()
1997 from(u in Pleroma.User,
1998 left_join: a in Pleroma.Activity,
1999 on: u.ap_id == a.actor,
2000 where: not is_nil(u.nickname),
2001 where: u.deactivated != ^true,
2002 where: u.id not in ^has_read_notifications,
2005 max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
2006 is_nil(max(a.inserted_at))
2011 Enable or disable email notifications for user
2015 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
2016 Pleroma.User{email_notifications: %{"digest" => true}}
2018 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
2019 Pleroma.User{email_notifications: %{"digest" => false}}
2021 @spec switch_email_notifications(t(), String.t(), boolean()) ::
2022 {:ok, t()} | {:error, Ecto.Changeset.t()}
2023 def switch_email_notifications(user, type, status) do
2024 User.update_email_notifications(user, %{type => status})
2028 Set `last_digest_emailed_at` value for the user to current time
2030 @spec touch_last_digest_emailed_at(t()) :: t()
2031 def touch_last_digest_emailed_at(user) do
2032 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2034 {:ok, updated_user} =
2036 |> change(%{last_digest_emailed_at: now})
2037 |> update_and_set_cache()
2042 @spec toggle_confirmation(User.t()) :: {:ok, User.t()} | {:error, Changeset.t()}
2043 def toggle_confirmation(%User{} = user) do
2045 |> confirmation_changeset(need_confirmation: !user.confirmation_pending)
2046 |> update_and_set_cache()
2049 @spec toggle_confirmation([User.t()]) :: [{:ok, User.t()} | {:error, Changeset.t()}]
2050 def toggle_confirmation(users) do
2051 Enum.map(users, &toggle_confirmation/1)
2054 def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
2058 def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
2059 # use instance-default
2060 config = Config.get([:assets, :mascots])
2061 default_mascot = Config.get([:assets, :default_mascot])
2062 mascot = Keyword.get(config, default_mascot)
2065 "id" => "default-mascot",
2066 "url" => mascot[:url],
2067 "preview_url" => mascot[:url],
2069 "mime_type" => mascot[:mime_type]
2074 def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
2076 def ensure_keys_present(%User{} = user) do
2077 with {:ok, pem} <- Keys.generate_rsa_pem() do
2079 |> cast(%{keys: pem}, [:keys])
2080 |> validate_required([:keys])
2081 |> update_and_set_cache()
2085 def get_ap_ids_by_nicknames(nicknames) do
2087 where: u.nickname in ^nicknames,
2093 defdelegate search(query, opts \\ []), to: User.Search
2095 defp put_password_hash(
2096 %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2098 change(changeset, password_hash: Pbkdf2.hash_pwd_salt(password))
2101 defp put_password_hash(changeset), do: changeset
2103 def is_internal_user?(%User{nickname: nil}), do: true
2104 def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2105 def is_internal_user?(_), do: false
2107 # A hack because user delete activities have a fake id for whatever reason
2108 # TODO: Get rid of this
2109 def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2111 def get_delivered_users_by_object_id(object_id) do
2113 inner_join: delivery in assoc(u, :deliveries),
2114 where: delivery.object_id == ^object_id
2119 def change_email(user, email) do
2121 |> cast(%{email: email}, [:email])
2122 |> validate_required([:email])
2123 |> unique_constraint(:email)
2124 |> validate_format(:email, @email_regex)
2125 |> update_and_set_cache()
2128 # Internal function; public one is `deactivate/2`
2129 defp set_activation_status(user, deactivated) do
2131 |> cast(%{deactivated: deactivated}, [:deactivated])
2132 |> update_and_set_cache()
2135 def update_banner(user, banner) do
2137 |> cast(%{banner: banner}, [:banner])
2138 |> update_and_set_cache()
2141 def update_background(user, background) do
2143 |> cast(%{background: background}, [:background])
2144 |> update_and_set_cache()
2147 def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
2150 moderator: is_moderator
2154 def validate_fields(changeset, remote? \\ false) do
2155 limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2156 limit = Config.get([:instance, limit_name], 0)
2159 |> validate_length(:fields, max: limit)
2160 |> validate_change(:fields, fn :fields, fields ->
2161 if Enum.all?(fields, &valid_field?/1) do
2169 defp valid_field?(%{"name" => name, "value" => value}) do
2170 name_limit = Config.get([:instance, :account_field_name_length], 255)
2171 value_limit = Config.get([:instance, :account_field_value_length], 255)
2173 is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2174 String.length(value) <= value_limit
2177 defp valid_field?(_), do: false
2179 defp truncate_field(%{"name" => name, "value" => value}) do
2181 String.split_at(name, Config.get([:instance, :account_field_name_length], 255))
2184 String.split_at(value, Config.get([:instance, :account_field_value_length], 255))
2186 %{"name" => name, "value" => value}
2189 def admin_api_update(user, params) do
2196 |> update_and_set_cache()
2199 @doc "Signs user out of all applications"
2200 def global_sign_out(user) do
2201 OAuth.Authorization.delete_user_authorizations(user)
2202 OAuth.Token.delete_user_tokens(user)
2205 def mascot_update(user, url) do
2207 |> cast(%{mascot: url}, [:mascot])
2208 |> validate_required([:mascot])
2209 |> update_and_set_cache()
2212 def mastodon_settings_update(user, settings) do
2214 |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
2215 |> validate_required([:mastofe_settings])
2216 |> update_and_set_cache()
2219 @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2220 def confirmation_changeset(user, need_confirmation: need_confirmation?) do
2222 if need_confirmation? do
2224 confirmation_pending: true,
2225 confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2229 confirmation_pending: false,
2230 confirmation_token: nil
2234 cast(user, params, [:confirmation_pending, :confirmation_token])
2237 @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
2238 def approval_changeset(user, need_approval: need_approval?) do
2239 params = if need_approval?, do: %{approval_pending: true}, else: %{approval_pending: false}
2240 cast(user, params, [:approval_pending])
2243 def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2244 if id not in user.pinned_activities do
2245 max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2246 params = %{pinned_activities: user.pinned_activities ++ [id]}
2249 |> cast(params, [:pinned_activities])
2250 |> validate_length(:pinned_activities,
2251 max: max_pinned_statuses,
2252 message: "You have already pinned the maximum number of statuses"
2257 |> update_and_set_cache()
2260 def remove_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2261 params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2264 |> cast(params, [:pinned_activities])
2265 |> update_and_set_cache()
2268 def update_email_notifications(user, settings) do
2269 email_notifications =
2270 user.email_notifications
2271 |> Map.merge(settings)
2272 |> Map.take(["digest"])
2274 params = %{email_notifications: email_notifications}
2275 fields = [:email_notifications]
2278 |> cast(params, fields)
2279 |> validate_required(fields)
2280 |> update_and_set_cache()
2283 defp set_domain_blocks(user, domain_blocks) do
2284 params = %{domain_blocks: domain_blocks}
2287 |> cast(params, [:domain_blocks])
2288 |> validate_required([:domain_blocks])
2289 |> update_and_set_cache()
2292 def block_domain(user, domain_blocked) do
2293 set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2296 def unblock_domain(user, domain_blocked) do
2297 set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2300 @spec add_to_block(User.t(), User.t()) ::
2301 {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2302 defp add_to_block(%User{} = user, %User{} = blocked) do
2303 UserRelationship.create_block(user, blocked)
2306 @spec add_to_block(User.t(), User.t()) ::
2307 {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2308 defp remove_from_block(%User{} = user, %User{} = blocked) do
2309 UserRelationship.delete_block(user, blocked)
2312 defp add_to_mutes(%User{} = user, %User{} = muted_user, notifications?) do
2313 with {:ok, user_mute} <- UserRelationship.create_mute(user, muted_user),
2314 {:ok, user_notification_mute} <-
2315 (notifications? && UserRelationship.create_notification_mute(user, muted_user)) ||
2317 {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
2321 defp remove_from_mutes(user, %User{} = muted_user) do
2322 with {:ok, user_mute} <- UserRelationship.delete_mute(user, muted_user),
2323 {:ok, user_notification_mute} <-
2324 UserRelationship.delete_notification_mute(user, muted_user) do
2325 {:ok, [user_mute, user_notification_mute]}
2329 def set_invisible(user, invisible) do
2330 params = %{invisible: invisible}
2333 |> cast(params, [:invisible])
2334 |> validate_required([:invisible])
2335 |> update_and_set_cache()
2338 def sanitize_html(%User{} = user) do
2339 sanitize_html(user, nil)
2342 # User data that mastodon isn't filtering (treated as plaintext):
2345 def sanitize_html(%User{} = user, filter) do
2347 Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2350 "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2355 |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2356 |> Map.put(:fields, fields)