1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.User do
10 import Ecto, only: [assoc: 2]
13 alias Pleroma.Activity
15 alias Pleroma.Conversation.Participation
16 alias Pleroma.Delivery
17 alias Pleroma.EctoType.ActivityPub.ObjectValidators
19 alias Pleroma.FollowingRelationship
20 alias Pleroma.Formatter
24 alias Pleroma.Notification
26 alias Pleroma.Registration
28 alias Pleroma.RepoStreamer
30 alias Pleroma.UserRelationship
32 alias Pleroma.Web.ActivityPub.ActivityPub
33 alias Pleroma.Web.ActivityPub.Builder
34 alias Pleroma.Web.ActivityPub.Pipeline
35 alias Pleroma.Web.ActivityPub.Utils
36 alias Pleroma.Web.CommonAPI
37 alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
38 alias Pleroma.Web.OAuth
39 alias Pleroma.Web.RelMe
40 alias Pleroma.Workers.BackgroundWorker
44 @type t :: %__MODULE__{}
45 @type account_status :: :active | :deactivated | :password_reset_pending | :confirmation_pending
46 @primary_key {:id, FlakeId.Ecto.CompatType, autogenerate: true}
48 # credo:disable-for-next-line Credo.Check.Readability.MaxLineLength
49 @email_regex ~r/^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/
51 @strict_local_nickname_regex ~r/^[a-zA-Z\d]+$/
52 @extended_local_nickname_regex ~r/^[a-zA-Z\d_-]+$/
54 # AP ID user relationships (blocks, mutes etc.)
55 # Format: [rel_type: [outgoing_rel: :outgoing_rel_target, incoming_rel: :incoming_rel_source]]
56 @user_relationships_config [
58 blocker_blocks: :blocked_users,
59 blockee_blocks: :blocker_users
62 muter_mutes: :muted_users,
63 mutee_mutes: :muter_users
66 reblog_muter_mutes: :reblog_muted_users,
67 reblog_mutee_mutes: :reblog_muter_users
70 notification_muter_mutes: :notification_muted_users,
71 notification_mutee_mutes: :notification_muter_users
73 # Note: `inverse_subscription` relationship is inverse: subscriber acts as relationship target
74 inverse_subscription: [
75 subscribee_subscriptions: :subscriber_users,
76 subscriber_subscriptions: :subscribee_users
82 field(:raw_bio, :string)
83 field(:email, :string)
85 field(:nickname, :string)
86 field(:password_hash, :string)
87 field(:password, :string, virtual: true)
88 field(:password_confirmation, :string, virtual: true)
90 field(:public_key, :string)
91 field(:ap_id, :string)
92 field(:avatar, :map, default: %{})
93 field(:local, :boolean, default: true)
94 field(:follower_address, :string)
95 field(:following_address, :string)
96 field(:search_rank, :float, virtual: true)
97 field(:search_type, :integer, virtual: true)
98 field(:tags, {:array, :string}, default: [])
99 field(:last_refreshed_at, :naive_datetime_usec)
100 field(:last_digest_emailed_at, :naive_datetime)
101 field(:banner, :map, default: %{})
102 field(:background, :map, default: %{})
103 field(:note_count, :integer, default: 0)
104 field(:follower_count, :integer, default: 0)
105 field(:following_count, :integer, default: 0)
106 field(:locked, :boolean, default: false)
107 field(:confirmation_pending, :boolean, default: false)
108 field(:password_reset_pending, :boolean, default: false)
109 field(:confirmation_token, :string, default: nil)
110 field(:default_scope, :string, default: "public")
111 field(:domain_blocks, {:array, :string}, default: [])
112 field(:deactivated, :boolean, default: false)
113 field(:no_rich_text, :boolean, default: false)
114 field(:ap_enabled, :boolean, default: false)
115 field(:is_moderator, :boolean, default: false)
116 field(:is_admin, :boolean, default: false)
117 field(:show_role, :boolean, default: true)
118 field(:mastofe_settings, :map, default: nil)
119 field(:uri, ObjectValidators.Uri, default: nil)
120 field(:hide_followers_count, :boolean, default: false)
121 field(:hide_follows_count, :boolean, default: false)
122 field(:hide_followers, :boolean, default: false)
123 field(:hide_follows, :boolean, default: false)
124 field(:hide_favorites, :boolean, default: true)
125 field(:unread_conversation_count, :integer, default: 0)
126 field(:pinned_activities, {:array, :string}, default: [])
127 field(:email_notifications, :map, default: %{"digest" => false})
128 field(:mascot, :map, default: nil)
129 field(:emoji, :map, default: %{})
130 field(:pleroma_settings_store, :map, default: %{})
131 field(:fields, {:array, :map}, default: [])
132 field(:raw_fields, {:array, :map}, default: [])
133 field(:discoverable, :boolean, default: false)
134 field(:invisible, :boolean, default: false)
135 field(:allow_following_move, :boolean, default: true)
136 field(:skip_thread_containment, :boolean, default: false)
137 field(:actor_type, :string, default: "Person")
138 field(:also_known_as, {:array, :string}, default: [])
139 field(:inbox, :string)
140 field(:shared_inbox, :string)
141 field(:accepts_chat_messages, :boolean, default: nil)
144 :notification_settings,
145 Pleroma.User.NotificationSetting,
149 has_many(:notifications, Notification)
150 has_many(:registrations, Registration)
151 has_many(:deliveries, Delivery)
153 has_many(:outgoing_relationships, UserRelationship, foreign_key: :source_id)
154 has_many(:incoming_relationships, UserRelationship, foreign_key: :target_id)
156 for {relationship_type,
158 {outgoing_relation, outgoing_relation_target},
159 {incoming_relation, incoming_relation_source}
160 ]} <- @user_relationships_config do
161 # Definitions of `has_many` relations: :blocker_blocks, :muter_mutes, :reblog_muter_mutes,
162 # :notification_muter_mutes, :subscribee_subscriptions
163 has_many(outgoing_relation, UserRelationship,
164 foreign_key: :source_id,
165 where: [relationship_type: relationship_type]
168 # Definitions of `has_many` relations: :blockee_blocks, :mutee_mutes, :reblog_mutee_mutes,
169 # :notification_mutee_mutes, :subscriber_subscriptions
170 has_many(incoming_relation, UserRelationship,
171 foreign_key: :target_id,
172 where: [relationship_type: relationship_type]
175 # Definitions of `has_many` relations: :blocked_users, :muted_users, :reblog_muted_users,
176 # :notification_muted_users, :subscriber_users
177 has_many(outgoing_relation_target, through: [outgoing_relation, :target])
179 # Definitions of `has_many` relations: :blocker_users, :muter_users, :reblog_muter_users,
180 # :notification_muter_users, :subscribee_users
181 has_many(incoming_relation_source, through: [incoming_relation, :source])
184 # `:blocks` is deprecated (replaced with `blocked_users` relation)
185 field(:blocks, {:array, :string}, default: [])
186 # `:mutes` is deprecated (replaced with `muted_users` relation)
187 field(:mutes, {:array, :string}, default: [])
188 # `:muted_reblogs` is deprecated (replaced with `reblog_muted_users` relation)
189 field(:muted_reblogs, {:array, :string}, default: [])
190 # `:muted_notifications` is deprecated (replaced with `notification_muted_users` relation)
191 field(:muted_notifications, {:array, :string}, default: [])
192 # `:subscribers` is deprecated (replaced with `subscriber_users` relation)
193 field(:subscribers, {:array, :string}, default: [])
196 :multi_factor_authentication_settings,
204 for {_relationship_type, [{_outgoing_relation, outgoing_relation_target}, _]} <-
205 @user_relationships_config do
206 # `def blocked_users_relation/2`, `def muted_users_relation/2`,
207 # `def reblog_muted_users_relation/2`, `def notification_muted_users/2`,
208 # `def subscriber_users/2`
209 def unquote(:"#{outgoing_relation_target}_relation")(user, restrict_deactivated? \\ false) do
210 target_users_query = assoc(user, unquote(outgoing_relation_target))
212 if restrict_deactivated? do
213 restrict_deactivated(target_users_query)
219 # `def blocked_users/2`, `def muted_users/2`, `def reblog_muted_users/2`,
220 # `def notification_muted_users/2`, `def subscriber_users/2`
221 def unquote(outgoing_relation_target)(user, restrict_deactivated? \\ false) do
223 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
225 restrict_deactivated?
230 # `def blocked_users_ap_ids/2`, `def muted_users_ap_ids/2`, `def reblog_muted_users_ap_ids/2`,
231 # `def notification_muted_users_ap_ids/2`, `def subscriber_users_ap_ids/2`
232 def unquote(:"#{outgoing_relation_target}_ap_ids")(user, restrict_deactivated? \\ false) do
234 |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
236 restrict_deactivated?
238 |> select([u], u.ap_id)
244 Dumps Flake Id to SQL-compatible format (16-byte UUID).
245 E.g. "9pQtDGXuq4p3VlcJEm" -> <<0, 0, 1, 110, 179, 218, 42, 92, 213, 41, 44, 227, 95, 213, 0, 0>>
247 def binary_id(source_id) when is_binary(source_id) do
248 with {:ok, dumped_id} <- FlakeId.Ecto.CompatType.dump(source_id) do
255 def binary_id(source_ids) when is_list(source_ids) do
256 Enum.map(source_ids, &binary_id/1)
259 def binary_id(%User{} = user), do: binary_id(user.id)
261 @doc "Returns status account"
262 @spec account_status(User.t()) :: account_status()
263 def account_status(%User{deactivated: true}), do: :deactivated
264 def account_status(%User{password_reset_pending: true}), do: :password_reset_pending
266 def account_status(%User{confirmation_pending: true}) do
267 if Config.get([:instance, :account_activation_required]) do
268 :confirmation_pending
274 def account_status(%User{}), do: :active
276 @spec visible_for(User.t(), User.t() | nil) ::
279 | :restricted_unauthenticated
281 | :confirmation_pending
282 def visible_for(user, for_user \\ nil)
284 def visible_for(%User{invisible: true}, _), do: :invisible
286 def visible_for(%User{id: user_id}, %User{id: user_id}), do: :visible
288 def visible_for(%User{} = user, nil) do
289 if restrict_unauthenticated?(user) do
290 :restrict_unauthenticated
292 visible_account_status(user)
296 def visible_for(%User{} = user, for_user) do
297 if superuser?(for_user) do
300 visible_account_status(user)
304 def visible_for(_, _), do: :invisible
306 defp restrict_unauthenticated?(%User{local: local}) do
307 config_key = if local, do: :local, else: :remote
309 Config.get([:restrict_unauthenticated, :profiles, config_key], false)
312 defp visible_account_status(user) do
313 status = account_status(user)
315 if status in [:active, :password_reset_pending] do
322 @spec superuser?(User.t()) :: boolean()
323 def superuser?(%User{local: true, is_admin: true}), do: true
324 def superuser?(%User{local: true, is_moderator: true}), do: true
325 def superuser?(_), do: false
327 @spec invisible?(User.t()) :: boolean()
328 def invisible?(%User{invisible: true}), do: true
329 def invisible?(_), do: false
331 def avatar_url(user, options \\ []) do
333 %{"url" => [%{"href" => href} | _]} ->
337 unless options[:no_default] do
338 Config.get([:assets, :default_user_avatar], "#{Web.base_url()}/images/avi.png")
343 def banner_url(user, options \\ []) do
345 %{"url" => [%{"href" => href} | _]} -> href
346 _ -> !options[:no_default] && "#{Web.base_url()}/images/banner.png"
350 # Should probably be renamed or removed
351 def ap_id(%User{nickname: nickname}), do: "#{Web.base_url()}/users/#{nickname}"
353 def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
354 def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"
356 @spec ap_following(User.t()) :: String.t()
357 def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
358 def ap_following(%User{} = user), do: "#{ap_id(user)}/following"
360 @spec restrict_deactivated(Ecto.Query.t()) :: Ecto.Query.t()
361 def restrict_deactivated(query) do
362 from(u in query, where: u.deactivated != ^true)
365 defdelegate following_count(user), to: FollowingRelationship
367 defp truncate_fields_param(params) do
368 if Map.has_key?(params, :fields) do
369 Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
375 defp truncate_if_exists(params, key, max_length) do
376 if Map.has_key?(params, key) and is_binary(params[key]) do
377 {value, _chopped} = String.split_at(params[key], max_length)
378 Map.put(params, key, value)
384 defp fix_follower_address(%{follower_address: _, following_address: _} = params), do: params
386 defp fix_follower_address(%{nickname: nickname} = params),
387 do: Map.put(params, :follower_address, ap_followers(%User{nickname: nickname}))
389 defp fix_follower_address(params), do: params
391 def remote_user_changeset(struct \\ %User{local: false}, params) do
392 bio_limit = Config.get([:instance, :user_bio_length], 5000)
393 name_limit = Config.get([:instance, :user_name_length], 100)
396 case params[:name] do
397 name when is_binary(name) and byte_size(name) > 0 -> name
398 _ -> params[:nickname]
403 |> Map.put(:name, name)
404 |> Map.put_new(:last_refreshed_at, NaiveDateTime.utc_now())
405 |> truncate_if_exists(:name, name_limit)
406 |> truncate_if_exists(:bio, bio_limit)
407 |> truncate_fields_param()
408 |> fix_follower_address()
432 :hide_followers_count,
441 :accepts_chat_messages
444 |> validate_required([:name, :ap_id])
445 |> unique_constraint(:nickname)
446 |> validate_format(:nickname, @email_regex)
447 |> validate_length(:bio, max: bio_limit)
448 |> validate_length(:name, max: name_limit)
449 |> validate_fields(true)
452 def update_changeset(struct, params \\ %{}) do
453 bio_limit = Config.get([:instance, :user_bio_length], 5000)
454 name_limit = Config.get([:instance, :user_name_length], 100)
474 :hide_followers_count,
477 :allow_following_move,
480 :skip_thread_containment,
483 :pleroma_settings_store,
487 :accepts_chat_messages
490 |> unique_constraint(:nickname)
491 |> validate_format(:nickname, local_nickname_regex())
492 |> validate_length(:bio, max: bio_limit)
493 |> validate_length(:name, min: 1, max: name_limit)
494 |> validate_inclusion(:actor_type, ["Person", "Service"])
497 |> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
498 |> put_change_if_present(:avatar, &put_upload(&1, :avatar))
499 |> put_change_if_present(:banner, &put_upload(&1, :banner))
500 |> put_change_if_present(:background, &put_upload(&1, :background))
501 |> put_change_if_present(
502 :pleroma_settings_store,
503 &{:ok, Map.merge(struct.pleroma_settings_store, &1)}
505 |> validate_fields(false)
508 defp put_fields(changeset) do
509 if raw_fields = get_change(changeset, :raw_fields) do
512 |> Enum.filter(fn %{"name" => n} -> n != "" end)
516 |> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)
519 |> put_change(:raw_fields, raw_fields)
520 |> put_change(:fields, fields)
526 defp parse_fields(value) do
528 |> Formatter.linkify(mentions_format: :full)
532 defp put_emoji(changeset) do
533 emojified_fields = [:bio, :name, :raw_fields]
535 if Enum.any?(changeset.changes, fn {k, _} -> k in emojified_fields end) do
536 bio = Emoji.Formatter.get_emoji_map(get_field(changeset, :bio))
537 name = Emoji.Formatter.get_emoji_map(get_field(changeset, :name))
539 emoji = Map.merge(bio, name)
543 |> get_field(:raw_fields)
544 |> Enum.reduce(emoji, fn x, acc ->
545 Map.merge(acc, Emoji.Formatter.get_emoji_map(x["name"] <> x["value"]))
548 put_change(changeset, :emoji, emoji)
554 defp put_change_if_present(changeset, map_field, value_function) do
555 with {:ok, value} <- fetch_change(changeset, map_field),
556 {:ok, new_value} <- value_function.(value) do
557 put_change(changeset, map_field, new_value)
563 defp put_upload(value, type) do
564 with %Plug.Upload{} <- value,
565 {:ok, object} <- ActivityPub.upload(value, type: type) do
570 def update_as_admin_changeset(struct, params) do
572 |> update_changeset(params)
573 |> cast(params, [:email])
574 |> delete_change(:also_known_as)
575 |> unique_constraint(:email)
576 |> validate_format(:email, @email_regex)
577 |> validate_inclusion(:actor_type, ["Person", "Service"])
580 @spec update_as_admin(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
581 def update_as_admin(user, params) do
582 params = Map.put(params, "password_confirmation", params["password"])
583 changeset = update_as_admin_changeset(user, params)
585 if params["password"] do
586 reset_password(user, changeset, params)
588 User.update_and_set_cache(changeset)
592 def password_update_changeset(struct, params) do
594 |> cast(params, [:password, :password_confirmation])
595 |> validate_required([:password, :password_confirmation])
596 |> validate_confirmation(:password)
597 |> put_password_hash()
598 |> put_change(:password_reset_pending, false)
601 @spec reset_password(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
602 def reset_password(%User{} = user, params) do
603 reset_password(user, user, params)
606 def reset_password(%User{id: user_id} = user, struct, params) do
609 |> Multi.update(:user, password_update_changeset(struct, params))
610 |> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
611 |> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))
613 case Repo.transaction(multi) do
614 {:ok, %{user: user} = _} -> set_cache(user)
615 {:error, _, changeset, _} -> {:error, changeset}
619 def update_password_reset_pending(user, value) do
622 |> put_change(:password_reset_pending, value)
623 |> update_and_set_cache()
626 def force_password_reset_async(user) do
627 BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
630 @spec force_password_reset(User.t()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
631 def force_password_reset(user), do: update_password_reset_pending(user, true)
633 def register_changeset(struct, params \\ %{}, opts \\ []) do
634 bio_limit = Config.get([:instance, :user_bio_length], 5000)
635 name_limit = Config.get([:instance, :user_name_length], 100)
636 params = Map.put_new(params, :accepts_chat_messages, true)
639 if is_nil(opts[:need_confirmation]) do
640 Config.get([:instance, :account_activation_required])
642 opts[:need_confirmation]
646 |> confirmation_changeset(need_confirmation: need_confirmation?)
654 :password_confirmation,
656 :accepts_chat_messages
658 |> validate_required([:name, :nickname, :password, :password_confirmation])
659 |> validate_confirmation(:password)
660 |> unique_constraint(:email)
661 |> unique_constraint(:nickname)
662 |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
663 |> validate_format(:nickname, local_nickname_regex())
664 |> validate_format(:email, @email_regex)
665 |> validate_length(:bio, max: bio_limit)
666 |> validate_length(:name, min: 1, max: name_limit)
667 |> maybe_validate_required_email(opts[:external])
670 |> unique_constraint(:ap_id)
671 |> put_following_and_follower_address()
674 def maybe_validate_required_email(changeset, true), do: changeset
676 def maybe_validate_required_email(changeset, _) do
677 if Config.get([:instance, :account_activation_required]) do
678 validate_required(changeset, [:email])
684 defp put_ap_id(changeset) do
685 ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
686 put_change(changeset, :ap_id, ap_id)
689 defp put_following_and_follower_address(changeset) do
690 followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
693 |> put_change(:follower_address, followers)
696 defp autofollow_users(user) do
697 candidates = Config.get([:instance, :autofollowed_nicknames])
700 User.Query.build(%{nickname: candidates, local: true, deactivated: false})
703 follow_all(user, autofollowed_users)
706 @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
707 def register(%Ecto.Changeset{} = changeset) do
708 with {:ok, user} <- Repo.insert(changeset) do
709 post_register_action(user)
713 def post_register_action(%User{} = user) do
714 with {:ok, user} <- autofollow_users(user),
715 {:ok, user} <- set_cache(user),
716 {:ok, _} <- send_welcome_email(user),
717 {:ok, _} <- send_welcome_message(user),
718 {:ok, _} <- try_send_confirmation_email(user) do
723 def send_welcome_message(user) do
724 if User.WelcomeMessage.enabled?() do
725 User.WelcomeMessage.post_message(user)
732 def send_welcome_email(%User{email: email} = user) when is_binary(email) do
733 if User.WelcomeEmail.enabled?() do
734 User.WelcomeEmail.send_email(user)
741 def send_welcome_email(_), do: {:ok, :noop}
743 @spec try_send_confirmation_email(User.t()) :: {:ok, :enqueued | :noop}
744 def try_send_confirmation_email(%User{confirmation_pending: true} = user) do
745 if Config.get([:instance, :account_activation_required]) do
746 send_confirmation_email(user)
753 def try_send_confirmation_email(_), do: {:ok, :noop}
755 @spec send_confirmation_email(Uset.t()) :: User.t()
756 def send_confirmation_email(%User{} = user) do
758 |> Pleroma.Emails.UserEmail.account_confirmation_email()
759 |> Pleroma.Emails.Mailer.deliver_async()
764 def needs_update?(%User{local: true}), do: false
766 def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
768 def needs_update?(%User{local: false} = user) do
769 NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
772 def needs_update?(_), do: true
774 @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
776 # "Locked" (self-locked) users demand explicit authorization of follow requests
777 def maybe_direct_follow(%User{} = follower, %User{local: true, locked: true} = followed) do
778 follow(follower, followed, :follow_pending)
781 def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
782 follow(follower, followed)
785 def maybe_direct_follow(%User{} = follower, %User{} = followed) do
786 if not ap_enabled?(followed) do
787 follow(follower, followed)
793 @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
794 @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
795 def follow_all(follower, followeds) do
797 |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
798 |> Enum.each(&follow(follower, &1, :follow_accept))
803 defdelegate following(user), to: FollowingRelationship
805 def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
806 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
809 followed.deactivated ->
810 {:error, "Could not follow user: #{followed.nickname} is deactivated."}
812 deny_follow_blocked and blocks?(followed, follower) ->
813 {:error, "Could not follow user: #{followed.nickname} blocked you."}
816 FollowingRelationship.follow(follower, followed, state)
818 {:ok, _} = update_follower_count(followed)
821 |> update_following_count()
825 def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
826 {:error, "Not subscribed!"}
829 @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
830 def unfollow(%User{} = follower, %User{} = followed) do
831 case do_unfollow(follower, followed) do
832 {:ok, follower, followed} ->
833 {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
840 @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
841 defp do_unfollow(%User{} = follower, %User{} = followed) do
842 case get_follow_state(follower, followed) do
843 state when state in [:follow_pending, :follow_accept] ->
844 FollowingRelationship.unfollow(follower, followed)
845 {:ok, followed} = update_follower_count(followed)
849 |> update_following_count()
851 {:ok, follower, followed}
854 {:error, "Not subscribed!"}
858 defdelegate following?(follower, followed), to: FollowingRelationship
860 @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
861 def get_follow_state(%User{} = follower, %User{} = following) do
862 following_relationship = FollowingRelationship.get(follower, following)
863 get_follow_state(follower, following, following_relationship)
866 def get_follow_state(
869 following_relationship
871 case {following_relationship, following.local} do
873 case Utils.fetch_latest_follow(follower, following) do
874 %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
875 FollowingRelationship.state_to_enum(state)
881 {%{state: state}, _} ->
889 def locked?(%User{} = user) do
894 Repo.get_by(User, id: id)
897 def get_by_ap_id(ap_id) do
898 Repo.get_by(User, ap_id: ap_id)
901 def get_all_by_ap_id(ap_ids) do
902 from(u in __MODULE__,
903 where: u.ap_id in ^ap_ids
908 def get_all_by_ids(ids) do
909 from(u in __MODULE__, where: u.id in ^ids)
913 # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
914 # of the ap_id and the domain and tries to get that user
915 def get_by_guessed_nickname(ap_id) do
916 domain = URI.parse(ap_id).host
917 name = List.last(String.split(ap_id, "/"))
918 nickname = "#{name}@#{domain}"
920 get_cached_by_nickname(nickname)
923 def set_cache({:ok, user}), do: set_cache(user)
924 def set_cache({:error, err}), do: {:error, err}
926 def set_cache(%User{} = user) do
927 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
928 Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
929 Cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
933 def update_and_set_cache(struct, params) do
935 |> update_changeset(params)
936 |> update_and_set_cache()
939 def update_and_set_cache(changeset) do
940 with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
945 def get_user_friends_ap_ids(user) do
946 from(u in User.get_friends_query(user), select: u.ap_id)
950 @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
951 def get_cached_user_friends_ap_ids(user) do
952 Cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
953 get_user_friends_ap_ids(user)
957 def invalidate_cache(user) do
958 Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
959 Cachex.del(:user_cache, "nickname:#{user.nickname}")
960 Cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
963 @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
964 def get_cached_by_ap_id(ap_id) do
965 key = "ap_id:#{ap_id}"
967 with {:ok, nil} <- Cachex.get(:user_cache, key),
968 user when not is_nil(user) <- get_by_ap_id(ap_id),
969 {:ok, true} <- Cachex.put(:user_cache, key, user) do
977 def get_cached_by_id(id) do
981 Cachex.fetch!(:user_cache, key, fn _ ->
985 Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
986 {:commit, user.ap_id}
992 get_cached_by_ap_id(ap_id)
995 def get_cached_by_nickname(nickname) do
996 key = "nickname:#{nickname}"
998 Cachex.fetch!(:user_cache, key, fn ->
999 case get_or_fetch_by_nickname(nickname) do
1000 {:ok, user} -> {:commit, user}
1001 {:error, _error} -> {:ignore, nil}
1006 def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
1007 restrict_to_local = Config.get([:instance, :limit_to_local_content])
1010 is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
1011 get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
1013 restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
1014 get_cached_by_nickname(nickname_or_id)
1016 restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
1017 get_cached_by_nickname(nickname_or_id)
1024 @spec get_by_nickname(String.t()) :: User.t() | nil
1025 def get_by_nickname(nickname) do
1026 Repo.get_by(User, nickname: nickname) ||
1027 if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
1028 Repo.get_by(User, nickname: local_nickname(nickname))
1032 def get_by_email(email), do: Repo.get_by(User, email: email)
1034 def get_by_nickname_or_email(nickname_or_email) do
1035 get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
1038 def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
1040 def get_or_fetch_by_nickname(nickname) do
1041 with %User{} = user <- get_by_nickname(nickname) do
1045 with [_nick, _domain] <- String.split(nickname, "@"),
1046 {:ok, user} <- fetch_by_nickname(nickname) do
1049 _e -> {:error, "not found " <> nickname}
1054 @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1055 def get_followers_query(%User{} = user, nil) do
1056 User.Query.build(%{followers: user, deactivated: false})
1059 def get_followers_query(user, page) do
1061 |> get_followers_query(nil)
1062 |> User.Query.paginate(page, 20)
1065 @spec get_followers_query(User.t()) :: Ecto.Query.t()
1066 def get_followers_query(user), do: get_followers_query(user, nil)
1068 @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1069 def get_followers(user, page \\ nil) do
1071 |> get_followers_query(page)
1075 @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1076 def get_external_followers(user, page \\ nil) do
1078 |> get_followers_query(page)
1079 |> User.Query.build(%{external: true})
1083 def get_followers_ids(user, page \\ nil) do
1085 |> get_followers_query(page)
1086 |> select([u], u.id)
1090 @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1091 def get_friends_query(%User{} = user, nil) do
1092 User.Query.build(%{friends: user, deactivated: false})
1095 def get_friends_query(user, page) do
1097 |> get_friends_query(nil)
1098 |> User.Query.paginate(page, 20)
1101 @spec get_friends_query(User.t()) :: Ecto.Query.t()
1102 def get_friends_query(user), do: get_friends_query(user, nil)
1104 def get_friends(user, page \\ nil) do
1106 |> get_friends_query(page)
1110 def get_friends_ap_ids(user) do
1112 |> get_friends_query(nil)
1113 |> select([u], u.ap_id)
1117 def get_friends_ids(user, page \\ nil) do
1119 |> get_friends_query(page)
1120 |> select([u], u.id)
1124 defdelegate get_follow_requests(user), to: FollowingRelationship
1126 def increase_note_count(%User{} = user) do
1128 |> where(id: ^user.id)
1129 |> update([u], inc: [note_count: 1])
1131 |> Repo.update_all([])
1133 {1, [user]} -> set_cache(user)
1138 def decrease_note_count(%User{} = user) do
1140 |> where(id: ^user.id)
1143 note_count: fragment("greatest(0, note_count - 1)")
1147 |> Repo.update_all([])
1149 {1, [user]} -> set_cache(user)
1154 def update_note_count(%User{} = user, note_count \\ nil) do
1159 where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1165 |> cast(%{note_count: note_count}, [:note_count])
1166 |> update_and_set_cache()
1169 @spec maybe_fetch_follow_information(User.t()) :: User.t()
1170 def maybe_fetch_follow_information(user) do
1171 with {:ok, user} <- fetch_follow_information(user) do
1175 Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1181 def fetch_follow_information(user) do
1182 with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1184 |> follow_information_changeset(info)
1185 |> update_and_set_cache()
1189 defp follow_information_changeset(user, params) do
1196 :hide_followers_count,
1201 @spec update_follower_count(User.t()) :: {:ok, User.t()}
1202 def update_follower_count(%User{} = user) do
1203 if user.local or !Config.get([:instance, :external_user_synchronization]) do
1204 follower_count = FollowingRelationship.follower_count(user)
1207 |> follow_information_changeset(%{follower_count: follower_count})
1208 |> update_and_set_cache
1210 {:ok, maybe_fetch_follow_information(user)}
1214 @spec update_following_count(User.t()) :: {:ok, User.t()}
1215 def update_following_count(%User{local: false} = user) do
1216 if Config.get([:instance, :external_user_synchronization]) do
1217 {:ok, maybe_fetch_follow_information(user)}
1223 def update_following_count(%User{local: true} = user) do
1224 following_count = FollowingRelationship.following_count(user)
1227 |> follow_information_changeset(%{following_count: following_count})
1228 |> update_and_set_cache()
1231 def set_unread_conversation_count(%User{local: true} = user) do
1232 unread_query = Participation.unread_conversation_count_for_user(user)
1235 |> join(:inner, [u], p in subquery(unread_query))
1237 set: [unread_conversation_count: p.count]
1239 |> where([u], u.id == ^user.id)
1241 |> Repo.update_all([])
1243 {1, [user]} -> set_cache(user)
1248 def set_unread_conversation_count(user), do: {:ok, user}
1250 def increment_unread_conversation_count(conversation, %User{local: true} = user) do
1252 Participation.unread_conversation_count_for_user(user)
1253 |> where([p], p.conversation_id == ^conversation.id)
1256 |> join(:inner, [u], p in subquery(unread_query))
1258 inc: [unread_conversation_count: 1]
1260 |> where([u], u.id == ^user.id)
1261 |> where([u, p], p.count == 0)
1263 |> Repo.update_all([])
1265 {1, [user]} -> set_cache(user)
1270 def increment_unread_conversation_count(_, user), do: {:ok, user}
1272 @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1273 def get_users_from_set(ap_ids, opts \\ []) do
1274 local_only = Keyword.get(opts, :local_only, true)
1275 criteria = %{ap_id: ap_ids, deactivated: false}
1276 criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1278 User.Query.build(criteria)
1282 @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1283 def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1286 query = User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
1292 @spec mute(User.t(), User.t(), boolean()) ::
1293 {:ok, list(UserRelationship.t())} | {:error, String.t()}
1294 def mute(%User{} = muter, %User{} = mutee, notifications? \\ true) do
1295 add_to_mutes(muter, mutee, notifications?)
1298 def unmute(%User{} = muter, %User{} = mutee) do
1299 remove_from_mutes(muter, mutee)
1302 def subscribe(%User{} = subscriber, %User{} = target) do
1303 deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
1305 if blocks?(target, subscriber) and deny_follow_blocked do
1306 {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1308 # Note: the relationship is inverse: subscriber acts as relationship target
1309 UserRelationship.create_inverse_subscription(target, subscriber)
1313 def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1314 with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1315 subscribe(subscriber, subscribee)
1319 def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1320 # Note: the relationship is inverse: subscriber acts as relationship target
1321 UserRelationship.delete_inverse_subscription(target, unsubscriber)
1324 def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1325 with %User{} = user <- get_cached_by_ap_id(ap_id) do
1326 unsubscribe(unsubscriber, user)
1330 def block(%User{} = blocker, %User{} = blocked) do
1331 # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1333 if following?(blocker, blocked) do
1334 {:ok, blocker, _} = unfollow(blocker, blocked)
1340 # clear any requested follows as well
1342 case CommonAPI.reject_follow_request(blocked, blocker) do
1343 {:ok, %User{} = updated_blocked} -> updated_blocked
1347 unsubscribe(blocked, blocker)
1349 unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
1350 if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)
1352 {:ok, blocker} = update_follower_count(blocker)
1353 {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1354 add_to_block(blocker, blocked)
1357 # helper to handle the block given only an actor's AP id
1358 def block(%User{} = blocker, %{ap_id: ap_id}) do
1359 block(blocker, get_cached_by_ap_id(ap_id))
1362 def unblock(%User{} = blocker, %User{} = blocked) do
1363 remove_from_block(blocker, blocked)
1366 # helper to handle the block given only an actor's AP id
1367 def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1368 unblock(blocker, get_cached_by_ap_id(ap_id))
1371 def mutes?(nil, _), do: false
1372 def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1374 def mutes_user?(%User{} = user, %User{} = target) do
1375 UserRelationship.mute_exists?(user, target)
1378 @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1379 def muted_notifications?(nil, _), do: false
1381 def muted_notifications?(%User{} = user, %User{} = target),
1382 do: UserRelationship.notification_mute_exists?(user, target)
1384 def blocks?(nil, _), do: false
1386 def blocks?(%User{} = user, %User{} = target) do
1387 blocks_user?(user, target) ||
1388 (blocks_domain?(user, target) and not User.following?(user, target))
1391 def blocks_user?(%User{} = user, %User{} = target) do
1392 UserRelationship.block_exists?(user, target)
1395 def blocks_user?(_, _), do: false
1397 def blocks_domain?(%User{} = user, %User{} = target) do
1398 domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1399 %{host: host} = URI.parse(target.ap_id)
1400 Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1403 def blocks_domain?(_, _), do: false
1405 def subscribed_to?(%User{} = user, %User{} = target) do
1406 # Note: the relationship is inverse: subscriber acts as relationship target
1407 UserRelationship.inverse_subscription_exists?(target, user)
1410 def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1411 with %User{} = target <- get_cached_by_ap_id(ap_id) do
1412 subscribed_to?(user, target)
1417 Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1418 E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1420 @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1421 def outgoing_relationships_ap_ids(_user, []), do: %{}
1423 def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1425 def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1426 when is_list(relationship_types) do
1429 |> assoc(:outgoing_relationships)
1430 |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1431 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1432 |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1433 |> group_by([user_rel, u], user_rel.relationship_type)
1435 |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1440 fn rel_type -> {rel_type, db_result[rel_type] || []} end
1444 def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1446 def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1448 def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1450 def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1451 when is_list(relationship_types) do
1453 |> assoc(:incoming_relationships)
1454 |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1455 |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1456 |> maybe_filter_on_ap_id(ap_ids)
1457 |> select([user_rel, u], u.ap_id)
1462 defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1463 where(query, [user_rel, u], u.ap_id in ^ap_ids)
1466 defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1468 def deactivate_async(user, status \\ true) do
1469 BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
1472 def deactivate(user, status \\ true)
1474 def deactivate(users, status) when is_list(users) do
1475 Repo.transaction(fn ->
1476 for user <- users, do: deactivate(user, status)
1480 def deactivate(%User{} = user, status) do
1481 with {:ok, user} <- set_activation_status(user, status) do
1484 |> Enum.filter(& &1.local)
1485 |> Enum.each(&set_cache(update_following_count(&1)))
1487 # Only update local user counts, remote will be update during the next pull.
1490 |> Enum.filter(& &1.local)
1491 |> Enum.each(&do_unfollow(user, &1))
1497 def update_notification_settings(%User{} = user, settings) do
1499 |> cast(%{notification_settings: settings}, [])
1500 |> cast_embed(:notification_settings)
1501 |> validate_required([:notification_settings])
1502 |> update_and_set_cache()
1505 def delete(users) when is_list(users) do
1506 for user <- users, do: delete(user)
1509 def delete(%User{} = user) do
1510 BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1513 defp delete_and_invalidate_cache(%User{} = user) do
1514 invalidate_cache(user)
1518 defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)
1520 defp delete_or_deactivate(%User{local: true} = user) do
1521 status = account_status(user)
1523 if status == :confirmation_pending do
1524 delete_and_invalidate_cache(user)
1527 |> change(%{deactivated: true, email: nil})
1528 |> update_and_set_cache()
1532 def perform(:force_password_reset, user), do: force_password_reset(user)
1534 @spec perform(atom(), User.t()) :: {:ok, User.t()}
1535 def perform(:delete, %User{} = user) do
1536 # Remove all relationships
1539 |> Enum.each(fn follower ->
1540 ActivityPub.unfollow(follower, user)
1541 unfollow(follower, user)
1546 |> Enum.each(fn followed ->
1547 ActivityPub.unfollow(user, followed)
1548 unfollow(user, followed)
1551 delete_user_activities(user)
1552 delete_notifications_from_user_activities(user)
1554 delete_outgoing_pending_follow_requests(user)
1556 delete_or_deactivate(user)
1559 def perform(:deactivate_async, user, status), do: deactivate(user, status)
1561 @spec perform(atom(), User.t(), list()) :: list() | {:error, any()}
1562 def perform(:blocks_import, %User{} = blocker, blocked_identifiers)
1563 when is_list(blocked_identifiers) do
1565 blocked_identifiers,
1566 fn blocked_identifier ->
1567 with {:ok, %User{} = blocked} <- get_or_fetch(blocked_identifier),
1568 {:ok, _block} <- CommonAPI.block(blocker, blocked) do
1572 Logger.debug("blocks_import failed for #{blocked_identifier} with: #{inspect(err)}")
1579 def perform(:follow_import, %User{} = follower, followed_identifiers)
1580 when is_list(followed_identifiers) do
1582 followed_identifiers,
1583 fn followed_identifier ->
1584 with {:ok, %User{} = followed} <- get_or_fetch(followed_identifier),
1585 {:ok, follower} <- maybe_direct_follow(follower, followed),
1586 {:ok, _, _, _} <- CommonAPI.follow(follower, followed) do
1590 Logger.debug("follow_import failed for #{followed_identifier} with: #{inspect(err)}")
1597 @spec external_users_query() :: Ecto.Query.t()
1598 def external_users_query do
1606 @spec external_users(keyword()) :: [User.t()]
1607 def external_users(opts \\ []) do
1609 external_users_query()
1610 |> select([u], struct(u, [:id, :ap_id]))
1614 do: where(query, [u], u.id > ^opts[:max_id]),
1619 do: limit(query, ^opts[:limit]),
1625 def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers) do
1626 BackgroundWorker.enqueue("blocks_import", %{
1627 "blocker_id" => blocker.id,
1628 "blocked_identifiers" => blocked_identifiers
1632 def follow_import(%User{} = follower, followed_identifiers)
1633 when is_list(followed_identifiers) do
1634 BackgroundWorker.enqueue("follow_import", %{
1635 "follower_id" => follower.id,
1636 "followed_identifiers" => followed_identifiers
1640 def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1642 |> join(:inner, [n], activity in assoc(n, :activity))
1643 |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1644 |> Repo.delete_all()
1647 def delete_user_activities(%User{ap_id: ap_id} = user) do
1649 |> Activity.Queries.by_actor()
1650 |> RepoStreamer.chunk_stream(50)
1651 |> Stream.each(fn activities ->
1652 Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1657 defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1658 with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1659 {:ok, delete_data, _} <- Builder.delete(user, object) do
1660 Pipeline.common_pipeline(delete_data, local: user.local)
1662 {:find_object, nil} ->
1663 # We have the create activity, but not the object, it was probably pruned.
1664 # Insert a tombstone and try again
1665 with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1666 {:ok, _tombstone} <- Object.create(tombstone_data) do
1667 delete_activity(activity, user)
1671 Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1672 Logger.error("Error: #{inspect(e)}")
1676 defp delete_activity(%{data: %{"type" => type}} = activity, user)
1677 when type in ["Like", "Announce"] do
1678 {:ok, undo, _} = Builder.undo(user, activity)
1679 Pipeline.common_pipeline(undo, local: user.local)
1682 defp delete_activity(_activity, _user), do: "Doing nothing"
1684 defp delete_outgoing_pending_follow_requests(user) do
1686 |> FollowingRelationship.outgoing_pending_follow_requests_query()
1687 |> Repo.delete_all()
1690 def html_filter_policy(%User{no_rich_text: true}) do
1691 Pleroma.HTML.Scrubber.TwitterText
1694 def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])
1696 def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1698 def get_or_fetch_by_ap_id(ap_id) do
1699 cached_user = get_cached_by_ap_id(ap_id)
1701 maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)
1703 case {cached_user, maybe_fetched_user} do
1704 {_, {:ok, %User{} = user}} ->
1707 {%User{} = user, _} ->
1711 {:error, :not_found}
1716 Creates an internal service actor by URI if missing.
1717 Optionally takes nickname for addressing.
1719 @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1720 def get_or_create_service_actor_by_ap_id(uri, nickname) do
1722 case get_cached_by_ap_id(uri) do
1724 with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1725 Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1729 %User{invisible: false} = user ->
1739 @spec set_invisible(User.t()) :: {:ok, User.t()}
1740 defp set_invisible(user) do
1742 |> change(%{invisible: true})
1743 |> update_and_set_cache()
1746 @spec create_service_actor(String.t(), String.t()) ::
1747 {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1748 defp create_service_actor(uri, nickname) do
1754 follower_address: uri <> "/followers"
1757 |> unique_constraint(:nickname)
1762 def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1765 |> :public_key.pem_decode()
1767 |> :public_key.pem_entry_decode()
1772 def public_key(_), do: {:error, "key not found"}
1774 def get_public_key_for_ap_id(ap_id) do
1775 with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1776 {:ok, public_key} <- public_key(user) do
1783 def ap_enabled?(%User{local: true}), do: true
1784 def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1785 def ap_enabled?(_), do: false
1787 @doc "Gets or fetch a user by uri or nickname."
1788 @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1789 def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1790 def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1792 # wait a period of time and return newest version of the User structs
1793 # this is because we have synchronous follow APIs and need to simulate them
1794 # with an async handshake
1795 def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1796 with %User{} = a <- get_cached_by_id(a.id),
1797 %User{} = b <- get_cached_by_id(b.id) do
1804 def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1805 with :ok <- :timer.sleep(timeout),
1806 %User{} = a <- get_cached_by_id(a.id),
1807 %User{} = b <- get_cached_by_id(b.id) do
1814 def parse_bio(bio) when is_binary(bio) and bio != "" do
1816 |> CommonUtils.format_input("text/plain", mentions_format: :full)
1820 def parse_bio(_), do: ""
1822 def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1823 # TODO: get profile URLs other than user.ap_id
1824 profile_urls = [user.ap_id]
1827 |> CommonUtils.format_input("text/plain",
1828 mentions_format: :full,
1829 rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1834 def parse_bio(_, _), do: ""
1836 def tag(user_identifiers, tags) when is_list(user_identifiers) do
1837 Repo.transaction(fn ->
1838 for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1842 def tag(nickname, tags) when is_binary(nickname),
1843 do: tag(get_by_nickname(nickname), tags)
1845 def tag(%User{} = user, tags),
1846 do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1848 def untag(user_identifiers, tags) when is_list(user_identifiers) do
1849 Repo.transaction(fn ->
1850 for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1854 def untag(nickname, tags) when is_binary(nickname),
1855 do: untag(get_by_nickname(nickname), tags)
1857 def untag(%User{} = user, tags),
1858 do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1860 defp update_tags(%User{} = user, new_tags) do
1861 {:ok, updated_user} =
1863 |> change(%{tags: new_tags})
1864 |> update_and_set_cache()
1869 defp normalize_tags(tags) do
1872 |> Enum.map(&String.downcase/1)
1875 defp local_nickname_regex do
1876 if Config.get([:instance, :extended_nickname_format]) do
1877 @extended_local_nickname_regex
1879 @strict_local_nickname_regex
1883 def local_nickname(nickname_or_mention) do
1886 |> String.split("@")
1890 def full_nickname(nickname_or_mention),
1891 do: String.trim_leading(nickname_or_mention, "@")
1893 def error_user(ap_id) do
1897 nickname: "erroruser@example.com",
1898 inserted_at: NaiveDateTime.utc_now()
1902 @spec all_superusers() :: [User.t()]
1903 def all_superusers do
1904 User.Query.build(%{super_users: true, local: true, deactivated: false})
1908 def muting_reblogs?(%User{} = user, %User{} = target) do
1909 UserRelationship.reblog_mute_exists?(user, target)
1912 def showing_reblogs?(%User{} = user, %User{} = target) do
1913 not muting_reblogs?(user, target)
1917 The function returns a query to get users with no activity for given interval of days.
1918 Inactive users are those who didn't read any notification, or had any activity where
1919 the user is the activity's actor, during `inactivity_threshold` days.
1920 Deactivated users will not appear in this list.
1924 iex> Pleroma.User.list_inactive_users()
1927 @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
1928 def list_inactive_users_query(inactivity_threshold \\ 7) do
1929 negative_inactivity_threshold = -inactivity_threshold
1930 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
1931 # Subqueries are not supported in `where` clauses, join gets too complicated.
1932 has_read_notifications =
1933 from(n in Pleroma.Notification,
1934 where: n.seen == true,
1936 having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
1939 |> Pleroma.Repo.all()
1941 from(u in Pleroma.User,
1942 left_join: a in Pleroma.Activity,
1943 on: u.ap_id == a.actor,
1944 where: not is_nil(u.nickname),
1945 where: u.deactivated != ^true,
1946 where: u.id not in ^has_read_notifications,
1949 max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
1950 is_nil(max(a.inserted_at))
1955 Enable or disable email notifications for user
1959 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
1960 Pleroma.User{email_notifications: %{"digest" => true}}
1962 iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
1963 Pleroma.User{email_notifications: %{"digest" => false}}
1965 @spec switch_email_notifications(t(), String.t(), boolean()) ::
1966 {:ok, t()} | {:error, Ecto.Changeset.t()}
1967 def switch_email_notifications(user, type, status) do
1968 User.update_email_notifications(user, %{type => status})
1972 Set `last_digest_emailed_at` value for the user to current time
1974 @spec touch_last_digest_emailed_at(t()) :: t()
1975 def touch_last_digest_emailed_at(user) do
1976 now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
1978 {:ok, updated_user} =
1980 |> change(%{last_digest_emailed_at: now})
1981 |> update_and_set_cache()
1986 @spec toggle_confirmation(User.t()) :: {:ok, User.t()} | {:error, Changeset.t()}
1987 def toggle_confirmation(%User{} = user) do
1989 |> confirmation_changeset(need_confirmation: !user.confirmation_pending)
1990 |> update_and_set_cache()
1993 @spec toggle_confirmation([User.t()]) :: [{:ok, User.t()} | {:error, Changeset.t()}]
1994 def toggle_confirmation(users) do
1995 Enum.map(users, &toggle_confirmation/1)
1998 def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
2002 def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
2003 # use instance-default
2004 config = Config.get([:assets, :mascots])
2005 default_mascot = Config.get([:assets, :default_mascot])
2006 mascot = Keyword.get(config, default_mascot)
2009 "id" => "default-mascot",
2010 "url" => mascot[:url],
2011 "preview_url" => mascot[:url],
2013 "mime_type" => mascot[:mime_type]
2018 def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
2020 def ensure_keys_present(%User{} = user) do
2021 with {:ok, pem} <- Keys.generate_rsa_pem() do
2023 |> cast(%{keys: pem}, [:keys])
2024 |> validate_required([:keys])
2025 |> update_and_set_cache()
2029 def get_ap_ids_by_nicknames(nicknames) do
2031 where: u.nickname in ^nicknames,
2037 defdelegate search(query, opts \\ []), to: User.Search
2039 defp put_password_hash(
2040 %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2042 change(changeset, password_hash: Pbkdf2.hash_pwd_salt(password))
2045 defp put_password_hash(changeset), do: changeset
2047 def is_internal_user?(%User{nickname: nil}), do: true
2048 def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2049 def is_internal_user?(_), do: false
2051 # A hack because user delete activities have a fake id for whatever reason
2052 # TODO: Get rid of this
2053 def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2055 def get_delivered_users_by_object_id(object_id) do
2057 inner_join: delivery in assoc(u, :deliveries),
2058 where: delivery.object_id == ^object_id
2063 def change_email(user, email) do
2065 |> cast(%{email: email}, [:email])
2066 |> validate_required([:email])
2067 |> unique_constraint(:email)
2068 |> validate_format(:email, @email_regex)
2069 |> update_and_set_cache()
2072 # Internal function; public one is `deactivate/2`
2073 defp set_activation_status(user, deactivated) do
2075 |> cast(%{deactivated: deactivated}, [:deactivated])
2076 |> update_and_set_cache()
2079 def update_banner(user, banner) do
2081 |> cast(%{banner: banner}, [:banner])
2082 |> update_and_set_cache()
2085 def update_background(user, background) do
2087 |> cast(%{background: background}, [:background])
2088 |> update_and_set_cache()
2091 def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
2094 moderator: is_moderator
2098 def validate_fields(changeset, remote? \\ false) do
2099 limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2100 limit = Config.get([:instance, limit_name], 0)
2103 |> validate_length(:fields, max: limit)
2104 |> validate_change(:fields, fn :fields, fields ->
2105 if Enum.all?(fields, &valid_field?/1) do
2113 defp valid_field?(%{"name" => name, "value" => value}) do
2114 name_limit = Config.get([:instance, :account_field_name_length], 255)
2115 value_limit = Config.get([:instance, :account_field_value_length], 255)
2117 is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2118 String.length(value) <= value_limit
2121 defp valid_field?(_), do: false
2123 defp truncate_field(%{"name" => name, "value" => value}) do
2125 String.split_at(name, Config.get([:instance, :account_field_name_length], 255))
2128 String.split_at(value, Config.get([:instance, :account_field_value_length], 255))
2130 %{"name" => name, "value" => value}
2133 def admin_api_update(user, params) do
2140 |> update_and_set_cache()
2143 @doc "Signs user out of all applications"
2144 def global_sign_out(user) do
2145 OAuth.Authorization.delete_user_authorizations(user)
2146 OAuth.Token.delete_user_tokens(user)
2149 def mascot_update(user, url) do
2151 |> cast(%{mascot: url}, [:mascot])
2152 |> validate_required([:mascot])
2153 |> update_and_set_cache()
2156 def mastodon_settings_update(user, settings) do
2158 |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
2159 |> validate_required([:mastofe_settings])
2160 |> update_and_set_cache()
2163 @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2164 def confirmation_changeset(user, need_confirmation: need_confirmation?) do
2166 if need_confirmation? do
2168 confirmation_pending: true,
2169 confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2173 confirmation_pending: false,
2174 confirmation_token: nil
2178 cast(user, params, [:confirmation_pending, :confirmation_token])
2181 def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2182 if id not in user.pinned_activities do
2183 max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2184 params = %{pinned_activities: user.pinned_activities ++ [id]}
2187 |> cast(params, [:pinned_activities])
2188 |> validate_length(:pinned_activities,
2189 max: max_pinned_statuses,
2190 message: "You have already pinned the maximum number of statuses"
2195 |> update_and_set_cache()
2198 def remove_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2199 params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2202 |> cast(params, [:pinned_activities])
2203 |> update_and_set_cache()
2206 def update_email_notifications(user, settings) do
2207 email_notifications =
2208 user.email_notifications
2209 |> Map.merge(settings)
2210 |> Map.take(["digest"])
2212 params = %{email_notifications: email_notifications}
2213 fields = [:email_notifications]
2216 |> cast(params, fields)
2217 |> validate_required(fields)
2218 |> update_and_set_cache()
2221 defp set_domain_blocks(user, domain_blocks) do
2222 params = %{domain_blocks: domain_blocks}
2225 |> cast(params, [:domain_blocks])
2226 |> validate_required([:domain_blocks])
2227 |> update_and_set_cache()
2230 def block_domain(user, domain_blocked) do
2231 set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2234 def unblock_domain(user, domain_blocked) do
2235 set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2238 @spec add_to_block(User.t(), User.t()) ::
2239 {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2240 defp add_to_block(%User{} = user, %User{} = blocked) do
2241 UserRelationship.create_block(user, blocked)
2244 @spec add_to_block(User.t(), User.t()) ::
2245 {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2246 defp remove_from_block(%User{} = user, %User{} = blocked) do
2247 UserRelationship.delete_block(user, blocked)
2250 defp add_to_mutes(%User{} = user, %User{} = muted_user, notifications?) do
2251 with {:ok, user_mute} <- UserRelationship.create_mute(user, muted_user),
2252 {:ok, user_notification_mute} <-
2253 (notifications? && UserRelationship.create_notification_mute(user, muted_user)) ||
2255 {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
2259 defp remove_from_mutes(user, %User{} = muted_user) do
2260 with {:ok, user_mute} <- UserRelationship.delete_mute(user, muted_user),
2261 {:ok, user_notification_mute} <-
2262 UserRelationship.delete_notification_mute(user, muted_user) do
2263 {:ok, [user_mute, user_notification_mute]}
2267 def set_invisible(user, invisible) do
2268 params = %{invisible: invisible}
2271 |> cast(params, [:invisible])
2272 |> validate_required([:invisible])
2273 |> update_and_set_cache()
2276 def sanitize_html(%User{} = user) do
2277 sanitize_html(user, nil)
2280 # User data that mastodon isn't filtering (treated as plaintext):
2283 def sanitize_html(%User{} = user, filter) do
2285 Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2288 "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2293 |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2294 |> Map.put(:fields, fields)