git.squeep.com Git - akkoma/blob - lib/pleroma/user.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.User do
   6   use Ecto.Schema
   7
   8   import Ecto.Changeset
   9   import Ecto.Query
  10   import Ecto, only: [assoc: 2]
  11
  12   alias Ecto.Multi
  13   alias Pleroma.Activity
  14   alias Pleroma.Config
  15   alias Pleroma.Conversation.Participation
  16   alias Pleroma.Delivery
  17   alias Pleroma.EctoType.ActivityPub.ObjectValidators
  18   alias Pleroma.Emoji
  19   alias Pleroma.FollowingRelationship
  20   alias Pleroma.Formatter
  21   alias Pleroma.HTML
  22   alias Pleroma.Keys
  23   alias Pleroma.MFA
  24   alias Pleroma.Notification
  25   alias Pleroma.Object
  26   alias Pleroma.Registration
  27   alias Pleroma.Repo
  28   alias Pleroma.User
  29   alias Pleroma.UserRelationship
  30   alias Pleroma.Web
  31   alias Pleroma.Web.ActivityPub.ActivityPub
  32   alias Pleroma.Web.ActivityPub.Builder
  33   alias Pleroma.Web.ActivityPub.Pipeline
  34   alias Pleroma.Web.ActivityPub.Utils
  35   alias Pleroma.Web.CommonAPI
  36   alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
  37   alias Pleroma.Web.OAuth
  38   alias Pleroma.Web.RelMe
  39   alias Pleroma.Workers.BackgroundWorker
  40
  41   require Logger
  42
  43   @type t :: %__MODULE__{}
  44   @type account_status ::
  45           :active
  46           | :deactivated
  47           | :password_reset_pending
  48           | :confirmation_pending
  49           | :approval_pending
  50   @primary_key {:id, FlakeId.Ecto.CompatType, autogenerate: true}
  51
  52   # credo:disable-for-next-line Credo.Check.Readability.MaxLineLength
  53   @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])?)*$/
  54
  55   @strict_local_nickname_regex ~r/^[a-zA-Z\d]+$/
  56   @extended_local_nickname_regex ~r/^[a-zA-Z\d_-]+$/
  57
  58   # AP ID user relationships (blocks, mutes etc.)
  59   # Format: [rel_type: [outgoing_rel: :outgoing_rel_target, incoming_rel: :incoming_rel_source]]
  60   @user_relationships_config [
  61     block: [
  62       blocker_blocks: :blocked_users,
  63       blockee_blocks: :blocker_users
  64     ],
  65     mute: [
  66       muter_mutes: :muted_users,
  67       mutee_mutes: :muter_users
  68     ],
  69     reblog_mute: [
  70       reblog_muter_mutes: :reblog_muted_users,
  71       reblog_mutee_mutes: :reblog_muter_users
  72     ],
  73     notification_mute: [
  74       notification_muter_mutes: :notification_muted_users,
  75       notification_mutee_mutes: :notification_muter_users
  76     ],
  77     # Note: `inverse_subscription` relationship is inverse: subscriber acts as relationship target
  78     inverse_subscription: [
  79       subscribee_subscriptions: :subscriber_users,
  80       subscriber_subscriptions: :subscribee_users
  81     ]
  82   ]
  83
  84   schema "users" do
  85     field(:bio, :string, default: "")
  86     field(:raw_bio, :string)
  87     field(:email, :string)
  88     field(:name, :string)
  89     field(:nickname, :string)
  90     field(:password_hash, :string)
  91     field(:password, :string, virtual: true)
  92     field(:password_confirmation, :string, virtual: true)
  93     field(:keys, :string)
  94     field(:public_key, :string)
  95     field(:ap_id, :string)
  96     field(:avatar, :map, default: %{})
  97     field(:local, :boolean, default: true)
  98     field(:follower_address, :string)
  99     field(:following_address, :string)
 100     field(:search_rank, :float, virtual: true)
 101     field(:search_type, :integer, virtual: true)
 102     field(:tags, {:array, :string}, default: [])
 103     field(:last_refreshed_at, :naive_datetime_usec)
 104     field(:last_digest_emailed_at, :naive_datetime)
 105     field(:banner, :map, default: %{})
 106     field(:background, :map, default: %{})
 107     field(:note_count, :integer, default: 0)
 108     field(:follower_count, :integer, default: 0)
 109     field(:following_count, :integer, default: 0)
 110     field(:is_locked, :boolean, default: false)
 111     field(:confirmation_pending, :boolean, default: false)
 112     field(:password_reset_pending, :boolean, default: false)
 113     field(:approval_pending, :boolean, default: false)
 114     field(:registration_reason, :string, default: nil)
 115     field(:confirmation_token, :string, default: nil)
 116     field(:default_scope, :string, default: "public")
 117     field(:domain_blocks, {:array, :string}, default: [])
 118     field(:deactivated, :boolean, default: false)
 119     field(:no_rich_text, :boolean, default: false)
 120     field(:ap_enabled, :boolean, default: false)
 121     field(:is_moderator, :boolean, default: false)
 122     field(:is_admin, :boolean, default: false)
 123     field(:show_role, :boolean, default: true)
 124     field(:mastofe_settings, :map, default: nil)
 125     field(:uri, ObjectValidators.Uri, default: nil)
 126     field(:hide_followers_count, :boolean, default: false)
 127     field(:hide_follows_count, :boolean, default: false)
 128     field(:hide_followers, :boolean, default: false)
 129     field(:hide_follows, :boolean, default: false)
 130     field(:hide_favorites, :boolean, default: true)
 131     field(:pinned_activities, {:array, :string}, default: [])
 132     field(:email_notifications, :map, default: %{"digest" => false})
 133     field(:mascot, :map, default: nil)
 134     field(:emoji, :map, default: %{})
 135     field(:pleroma_settings_store, :map, default: %{})
 136     field(:fields, {:array, :map}, default: [])
 137     field(:raw_fields, {:array, :map}, default: [])
 138     field(:is_discoverable, :boolean, default: false)
 139     field(:invisible, :boolean, default: false)
 140     field(:allow_following_move, :boolean, default: true)
 141     field(:skip_thread_containment, :boolean, default: false)
 142     field(:actor_type, :string, default: "Person")
 143     field(:also_known_as, {:array, :string}, default: [])
 144     field(:inbox, :string)
 145     field(:shared_inbox, :string)
 146     field(:accepts_chat_messages, :boolean, default: nil)
 147
 148     embeds_one(
 149       :notification_settings,
 150       Pleroma.User.NotificationSetting,
 151       on_replace: :update
 152     )
 153
 154     has_many(:notifications, Notification)
 155     has_many(:registrations, Registration)
 156     has_many(:deliveries, Delivery)
 157
 158     has_many(:outgoing_relationships, UserRelationship, foreign_key: :source_id)
 159     has_many(:incoming_relationships, UserRelationship, foreign_key: :target_id)
 160
 161     for {relationship_type,
 162          [
 163            {outgoing_relation, outgoing_relation_target},
 164            {incoming_relation, incoming_relation_source}
 165          ]} <- @user_relationships_config do
 166       # Definitions of `has_many` relations: :blocker_blocks, :muter_mutes, :reblog_muter_mutes,
 167       #   :notification_muter_mutes, :subscribee_subscriptions
 168       has_many(outgoing_relation, UserRelationship,
 169         foreign_key: :source_id,
 170         where: [relationship_type: relationship_type]
 171       )
 172
 173       # Definitions of `has_many` relations: :blockee_blocks, :mutee_mutes, :reblog_mutee_mutes,
 174       #   :notification_mutee_mutes, :subscriber_subscriptions
 175       has_many(incoming_relation, UserRelationship,
 176         foreign_key: :target_id,
 177         where: [relationship_type: relationship_type]
 178       )
 179
 180       # Definitions of `has_many` relations: :blocked_users, :muted_users, :reblog_muted_users,
 181       #   :notification_muted_users, :subscriber_users
 182       has_many(outgoing_relation_target, through: [outgoing_relation, :target])
 183
 184       # Definitions of `has_many` relations: :blocker_users, :muter_users, :reblog_muter_users,
 185       #   :notification_muter_users, :subscribee_users
 186       has_many(incoming_relation_source, through: [incoming_relation, :source])
 187     end
 188
 189     # `:blocks` is deprecated (replaced with `blocked_users` relation)
 190     field(:blocks, {:array, :string}, default: [])
 191     # `:mutes` is deprecated (replaced with `muted_users` relation)
 192     field(:mutes, {:array, :string}, default: [])
 193     # `:muted_reblogs` is deprecated (replaced with `reblog_muted_users` relation)
 194     field(:muted_reblogs, {:array, :string}, default: [])
 195     # `:muted_notifications` is deprecated (replaced with `notification_muted_users` relation)
 196     field(:muted_notifications, {:array, :string}, default: [])
 197     # `:subscribers` is deprecated (replaced with `subscriber_users` relation)
 198     field(:subscribers, {:array, :string}, default: [])
 199
 200     embeds_one(
 201       :multi_factor_authentication_settings,
 202       MFA.Settings,
 203       on_replace: :delete
 204     )
 205
 206     timestamps()
 207   end
 208
 209   for {_relationship_type, [{_outgoing_relation, outgoing_relation_target}, _]} <-
 210         @user_relationships_config do
 211     # `def blocked_users_relation/2`, `def muted_users_relation/2`,
 212     #   `def reblog_muted_users_relation/2`, `def notification_muted_users/2`,
 213     #   `def subscriber_users/2`
 214     def unquote(:"#{outgoing_relation_target}_relation")(user, restrict_deactivated? \\ false) do
 215       target_users_query = assoc(user, unquote(outgoing_relation_target))
 216
 217       if restrict_deactivated? do
 218         restrict_deactivated(target_users_query)
 219       else
 220         target_users_query
 221       end
 222     end
 223
 224     # `def blocked_users/2`, `def muted_users/2`, `def reblog_muted_users/2`,
 225     #   `def notification_muted_users/2`, `def subscriber_users/2`
 226     def unquote(outgoing_relation_target)(user, restrict_deactivated? \\ false) do
 227       __MODULE__
 228       |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
 229         user,
 230         restrict_deactivated?
 231       ])
 232       |> Repo.all()
 233     end
 234
 235     # `def blocked_users_ap_ids/2`, `def muted_users_ap_ids/2`, `def reblog_muted_users_ap_ids/2`,
 236     #   `def notification_muted_users_ap_ids/2`, `def subscriber_users_ap_ids/2`
 237     def unquote(:"#{outgoing_relation_target}_ap_ids")(user, restrict_deactivated? \\ false) do
 238       __MODULE__
 239       |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
 240         user,
 241         restrict_deactivated?
 242       ])
 243       |> select([u], u.ap_id)
 244       |> Repo.all()
 245     end
 246   end
 247
 248   def cached_blocked_users_ap_ids(user) do
 249     Cachex.fetch!(:user_cache, "blocked_users_ap_ids:#{user.ap_id}", fn _ ->
 250       blocked_users_ap_ids(user)
 251     end)
 252   end
 253
 254   def cached_muted_users_ap_ids(user) do
 255     Cachex.fetch!(:user_cache, "muted_users_ap_ids:#{user.ap_id}", fn _ ->
 256       muted_users_ap_ids(user)
 257     end)
 258   end
 259
 260   defdelegate following_count(user), to: FollowingRelationship
 261   defdelegate following(user), to: FollowingRelationship
 262   defdelegate following?(follower, followed), to: FollowingRelationship
 263   defdelegate following_ap_ids(user), to: FollowingRelationship
 264   defdelegate get_follow_requests(user), to: FollowingRelationship
 265   defdelegate search(query, opts \\ []), to: User.Search
 266
 267   @doc """
 268   Dumps Flake Id to SQL-compatible format (16-byte UUID).
 269   E.g. "9pQtDGXuq4p3VlcJEm" -> <<0, 0, 1, 110, 179, 218, 42, 92, 213, 41, 44, 227, 95, 213, 0, 0>>
 270   """
 271   def binary_id(source_id) when is_binary(source_id) do
 272     with {:ok, dumped_id} <- FlakeId.Ecto.CompatType.dump(source_id) do
 273       dumped_id
 274     else
 275       _ -> source_id
 276     end
 277   end
 278
 279   def binary_id(source_ids) when is_list(source_ids) do
 280     Enum.map(source_ids, &binary_id/1)
 281   end
 282
 283   def binary_id(%User{} = user), do: binary_id(user.id)
 284
 285   @doc "Returns status account"
 286   @spec account_status(User.t()) :: account_status()
 287   def account_status(%User{deactivated: true}), do: :deactivated
 288   def account_status(%User{password_reset_pending: true}), do: :password_reset_pending
 289   def account_status(%User{local: true, approval_pending: true}), do: :approval_pending
 290
 291   def account_status(%User{local: true, confirmation_pending: true}) do
 292     if Config.get([:instance, :account_activation_required]) do
 293       :confirmation_pending
 294     else
 295       :active
 296     end
 297   end
 298
 299   def account_status(%User{}), do: :active
 300
 301   @spec visible_for(User.t(), User.t() | nil) ::
 302           :visible
 303           | :invisible
 304           | :restricted_unauthenticated
 305           | :deactivated
 306           | :confirmation_pending
 307   def visible_for(user, for_user \\ nil)
 308
 309   def visible_for(%User{invisible: true}, _), do: :invisible
 310
 311   def visible_for(%User{id: user_id}, %User{id: user_id}), do: :visible
 312
 313   def visible_for(%User{} = user, nil) do
 314     if restrict_unauthenticated?(user) do
 315       :restrict_unauthenticated
 316     else
 317       visible_account_status(user)
 318     end
 319   end
 320
 321   def visible_for(%User{} = user, for_user) do
 322     if superuser?(for_user) do
 323       :visible
 324     else
 325       visible_account_status(user)
 326     end
 327   end
 328
 329   def visible_for(_, _), do: :invisible
 330
 331   defp restrict_unauthenticated?(%User{local: true}) do
 332     Config.restrict_unauthenticated_access?(:profiles, :local)
 333   end
 334
 335   defp restrict_unauthenticated?(%User{local: _}) do
 336     Config.restrict_unauthenticated_access?(:profiles, :remote)
 337   end
 338
 339   defp visible_account_status(user) do
 340     status = account_status(user)
 341
 342     if status in [:active, :password_reset_pending] do
 343       :visible
 344     else
 345       status
 346     end
 347   end
 348
 349   @spec superuser?(User.t()) :: boolean()
 350   def superuser?(%User{local: true, is_admin: true}), do: true
 351   def superuser?(%User{local: true, is_moderator: true}), do: true
 352   def superuser?(_), do: false
 353
 354   @spec invisible?(User.t()) :: boolean()
 355   def invisible?(%User{invisible: true}), do: true
 356   def invisible?(_), do: false
 357
 358   def avatar_url(user, options \\ []) do
 359     case user.avatar do
 360       %{"url" => [%{"href" => href} | _]} ->
 361         href
 362
 363       _ ->
 364         unless options[:no_default] do
 365           Config.get([:assets, :default_user_avatar], "#{Web.base_url()}/images/avi.png")
 366         end
 367     end
 368   end
 369
 370   def banner_url(user, options \\ []) do
 371     case user.banner do
 372       %{"url" => [%{"href" => href} | _]} -> href
 373       _ -> !options[:no_default] && "#{Web.base_url()}/images/banner.png"
 374     end
 375   end
 376
 377   # Should probably be renamed or removed
 378   def ap_id(%User{nickname: nickname}), do: "#{Web.base_url()}/users/#{nickname}"
 379
 380   def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
 381   def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"
 382
 383   @spec ap_following(User.t()) :: String.t()
 384   def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
 385   def ap_following(%User{} = user), do: "#{ap_id(user)}/following"
 386
 387   @spec restrict_deactivated(Ecto.Query.t()) :: Ecto.Query.t()
 388   def restrict_deactivated(query) do
 389     from(u in query, where: u.deactivated != ^true)
 390   end
 391
 392   defp truncate_fields_param(params) do
 393     if Map.has_key?(params, :fields) do
 394       Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
 395     else
 396       params
 397     end
 398   end
 399
 400   defp truncate_if_exists(params, key, max_length) do
 401     if Map.has_key?(params, key) and is_binary(params[key]) do
 402       {value, _chopped} = String.split_at(params[key], max_length)
 403       Map.put(params, key, value)
 404     else
 405       params
 406     end
 407   end
 408
 409   defp fix_follower_address(%{follower_address: _, following_address: _} = params), do: params
 410
 411   defp fix_follower_address(%{nickname: nickname} = params),
 412     do: Map.put(params, :follower_address, ap_followers(%User{nickname: nickname}))
 413
 414   defp fix_follower_address(params), do: params
 415
 416   def remote_user_changeset(struct \\ %User{local: false}, params) do
 417     bio_limit = Config.get([:instance, :user_bio_length], 5000)
 418     name_limit = Config.get([:instance, :user_name_length], 100)
 419
 420     name =
 421       case params[:name] do
 422         name when is_binary(name) and byte_size(name) > 0 -> name
 423         _ -> params[:nickname]
 424       end
 425
 426     params =
 427       params
 428       |> Map.put(:name, name)
 429       |> Map.put_new(:last_refreshed_at, NaiveDateTime.utc_now())
 430       |> truncate_if_exists(:name, name_limit)
 431       |> truncate_if_exists(:bio, bio_limit)
 432       |> truncate_fields_param()
 433       |> fix_follower_address()
 434
 435     struct
 436     |> cast(
 437       params,
 438       [
 439         :bio,
 440         :emoji,
 441         :ap_id,
 442         :inbox,
 443         :shared_inbox,
 444         :nickname,
 445         :public_key,
 446         :avatar,
 447         :ap_enabled,
 448         :banner,
 449         :is_locked,
 450         :last_refreshed_at,
 451         :uri,
 452         :follower_address,
 453         :following_address,
 454         :hide_followers,
 455         :hide_follows,
 456         :hide_followers_count,
 457         :hide_follows_count,
 458         :follower_count,
 459         :fields,
 460         :following_count,
 461         :is_discoverable,
 462         :invisible,
 463         :actor_type,
 464         :also_known_as,
 465         :accepts_chat_messages
 466       ]
 467     )
 468     |> cast(params, [:name], empty_values: [])
 469     |> validate_required([:ap_id])
 470     |> validate_required([:name], trim: false)
 471     |> unique_constraint(:nickname)
 472     |> validate_format(:nickname, @email_regex)
 473     |> validate_length(:bio, max: bio_limit)
 474     |> validate_length(:name, max: name_limit)
 475     |> validate_fields(true)
 476     |> validate_non_local()
 477   end
 478
 479   defp validate_non_local(cng) do
 480     local? = get_field(cng, :local)
 481
 482     if local? do
 483       cng
 484       |> add_error(:local, "User is local, can't update with this changeset.")
 485     else
 486       cng
 487     end
 488   end
 489
 490   def update_changeset(struct, params \\ %{}) do
 491     bio_limit = Config.get([:instance, :user_bio_length], 5000)
 492     name_limit = Config.get([:instance, :user_name_length], 100)
 493
 494     struct
 495     |> cast(
 496       params,
 497       [
 498         :bio,
 499         :raw_bio,
 500         :name,
 501         :emoji,
 502         :avatar,
 503         :public_key,
 504         :inbox,
 505         :shared_inbox,
 506         :is_locked,
 507         :no_rich_text,
 508         :default_scope,
 509         :banner,
 510         :hide_follows,
 511         :hide_followers,
 512         :hide_followers_count,
 513         :hide_follows_count,
 514         :hide_favorites,
 515         :allow_following_move,
 516         :background,
 517         :show_role,
 518         :skip_thread_containment,
 519         :fields,
 520         :raw_fields,
 521         :pleroma_settings_store,
 522         :is_discoverable,
 523         :actor_type,
 524         :also_known_as,
 525         :accepts_chat_messages
 526       ]
 527     )
 528     |> unique_constraint(:nickname)
 529     |> validate_format(:nickname, local_nickname_regex())
 530     |> validate_length(:bio, max: bio_limit)
 531     |> validate_length(:name, min: 1, max: name_limit)
 532     |> validate_inclusion(:actor_type, ["Person", "Service"])
 533     |> put_fields()
 534     |> put_emoji()
 535     |> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
 536     |> put_change_if_present(:avatar, &put_upload(&1, :avatar))
 537     |> put_change_if_present(:banner, &put_upload(&1, :banner))
 538     |> put_change_if_present(:background, &put_upload(&1, :background))
 539     |> put_change_if_present(
 540       :pleroma_settings_store,
 541       &{:ok, Map.merge(struct.pleroma_settings_store, &1)}
 542     )
 543     |> validate_fields(false)
 544   end
 545
 546   defp put_fields(changeset) do
 547     if raw_fields = get_change(changeset, :raw_fields) do
 548       raw_fields =
 549         raw_fields
 550         |> Enum.filter(fn %{"name" => n} -> n != "" end)
 551
 552       fields =
 553         raw_fields
 554         |> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)
 555
 556       changeset
 557       |> put_change(:raw_fields, raw_fields)
 558       |> put_change(:fields, fields)
 559     else
 560       changeset
 561     end
 562   end
 563
 564   defp parse_fields(value) do
 565     value
 566     |> Formatter.linkify(mentions_format: :full)
 567     |> elem(0)
 568   end
 569
 570   defp put_emoji(changeset) do
 571     emojified_fields = [:bio, :name, :raw_fields]
 572
 573     if Enum.any?(changeset.changes, fn {k, _} -> k in emojified_fields end) do
 574       bio = Emoji.Formatter.get_emoji_map(get_field(changeset, :bio))
 575       name = Emoji.Formatter.get_emoji_map(get_field(changeset, :name))
 576
 577       emoji = Map.merge(bio, name)
 578
 579       emoji =
 580         changeset
 581         |> get_field(:raw_fields)
 582         |> Enum.reduce(emoji, fn x, acc ->
 583           Map.merge(acc, Emoji.Formatter.get_emoji_map(x["name"] <> x["value"]))
 584         end)
 585
 586       put_change(changeset, :emoji, emoji)
 587     else
 588       changeset
 589     end
 590   end
 591
 592   defp put_change_if_present(changeset, map_field, value_function) do
 593     with {:ok, value} <- fetch_change(changeset, map_field),
 594          {:ok, new_value} <- value_function.(value) do
 595       put_change(changeset, map_field, new_value)
 596     else
 597       _ -> changeset
 598     end
 599   end
 600
 601   defp put_upload(value, type) do
 602     with %Plug.Upload{} <- value,
 603          {:ok, object} <- ActivityPub.upload(value, type: type) do
 604       {:ok, object.data}
 605     end
 606   end
 607
 608   def update_as_admin_changeset(struct, params) do
 609     struct
 610     |> update_changeset(params)
 611     |> cast(params, [:email])
 612     |> delete_change(:also_known_as)
 613     |> unique_constraint(:email)
 614     |> validate_format(:email, @email_regex)
 615     |> validate_inclusion(:actor_type, ["Person", "Service"])
 616   end
 617
 618   @spec update_as_admin(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
 619   def update_as_admin(user, params) do
 620     params = Map.put(params, "password_confirmation", params["password"])
 621     changeset = update_as_admin_changeset(user, params)
 622
 623     if params["password"] do
 624       reset_password(user, changeset, params)
 625     else
 626       User.update_and_set_cache(changeset)
 627     end
 628   end
 629
 630   def password_update_changeset(struct, params) do
 631     struct
 632     |> cast(params, [:password, :password_confirmation])
 633     |> validate_required([:password, :password_confirmation])
 634     |> validate_confirmation(:password)
 635     |> put_password_hash()
 636     |> put_change(:password_reset_pending, false)
 637   end
 638
 639   @spec reset_password(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
 640   def reset_password(%User{} = user, params) do
 641     reset_password(user, user, params)
 642   end
 643
 644   def reset_password(%User{id: user_id} = user, struct, params) do
 645     multi =
 646       Multi.new()
 647       |> Multi.update(:user, password_update_changeset(struct, params))
 648       |> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
 649       |> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))
 650
 651     case Repo.transaction(multi) do
 652       {:ok, %{user: user} = _} -> set_cache(user)
 653       {:error, _, changeset, _} -> {:error, changeset}
 654     end
 655   end
 656
 657   def update_password_reset_pending(user, value) do
 658     user
 659     |> change()
 660     |> put_change(:password_reset_pending, value)
 661     |> update_and_set_cache()
 662   end
 663
 664   def force_password_reset_async(user) do
 665     BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
 666   end
 667
 668   @spec force_password_reset(User.t()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
 669   def force_password_reset(user), do: update_password_reset_pending(user, true)
 670
 671   # Used to auto-register LDAP accounts which won't have a password hash stored locally
 672   def register_changeset_ldap(struct, params = %{password: password})
 673       when is_nil(password) do
 674     params = Map.put_new(params, :accepts_chat_messages, true)
 675
 676     params =
 677       if Map.has_key?(params, :email) do
 678         Map.put_new(params, :email, params[:email])
 679       else
 680         params
 681       end
 682
 683     struct
 684     |> cast(params, [
 685       :name,
 686       :nickname,
 687       :email,
 688       :accepts_chat_messages
 689     ])
 690     |> validate_required([:name, :nickname])
 691     |> unique_constraint(:nickname)
 692     |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
 693     |> validate_format(:nickname, local_nickname_regex())
 694     |> put_ap_id()
 695     |> unique_constraint(:ap_id)
 696     |> put_following_and_follower_address()
 697   end
 698
 699   def register_changeset(struct, params \\ %{}, opts \\ []) do
 700     bio_limit = Config.get([:instance, :user_bio_length], 5000)
 701     name_limit = Config.get([:instance, :user_name_length], 100)
 702     reason_limit = Config.get([:instance, :registration_reason_length], 500)
 703     params = Map.put_new(params, :accepts_chat_messages, true)
 704
 705     need_confirmation? =
 706       if is_nil(opts[:need_confirmation]) do
 707         Config.get([:instance, :account_activation_required])
 708       else
 709         opts[:need_confirmation]
 710       end
 711
 712     need_approval? =
 713       if is_nil(opts[:need_approval]) do
 714         Config.get([:instance, :account_approval_required])
 715       else
 716         opts[:need_approval]
 717       end
 718
 719     struct
 720     |> confirmation_changeset(need_confirmation: need_confirmation?)
 721     |> approval_changeset(need_approval: need_approval?)
 722     |> cast(params, [
 723       :bio,
 724       :raw_bio,
 725       :email,
 726       :name,
 727       :nickname,
 728       :password,
 729       :password_confirmation,
 730       :emoji,
 731       :accepts_chat_messages,
 732       :registration_reason
 733     ])
 734     |> validate_required([:name, :nickname, :password, :password_confirmation])
 735     |> validate_confirmation(:password)
 736     |> unique_constraint(:email)
 737     |> validate_format(:email, @email_regex)
 738     |> validate_change(:email, fn :email, email ->
 739       valid? =
 740         Config.get([User, :email_blacklist])
 741         |> Enum.all?(fn blacklisted_domain ->
 742           !String.ends_with?(email, ["@" <> blacklisted_domain, "." <> blacklisted_domain])
 743         end)
 744
 745       if valid?, do: [], else: [email: "Invalid email"]
 746     end)
 747     |> unique_constraint(:nickname)
 748     |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
 749     |> validate_format(:nickname, local_nickname_regex())
 750     |> validate_length(:bio, max: bio_limit)
 751     |> validate_length(:name, min: 1, max: name_limit)
 752     |> validate_length(:registration_reason, max: reason_limit)
 753     |> maybe_validate_required_email(opts[:external])
 754     |> put_password_hash
 755     |> put_ap_id()
 756     |> unique_constraint(:ap_id)
 757     |> put_following_and_follower_address()
 758   end
 759
 760   def maybe_validate_required_email(changeset, true), do: changeset
 761
 762   def maybe_validate_required_email(changeset, _) do
 763     if Config.get([:instance, :account_activation_required]) do
 764       validate_required(changeset, [:email])
 765     else
 766       changeset
 767     end
 768   end
 769
 770   defp put_ap_id(changeset) do
 771     ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
 772     put_change(changeset, :ap_id, ap_id)
 773   end
 774
 775   defp put_following_and_follower_address(changeset) do
 776     followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
 777
 778     changeset
 779     |> put_change(:follower_address, followers)
 780   end
 781
 782   defp autofollow_users(user) do
 783     candidates = Config.get([:instance, :autofollowed_nicknames])
 784
 785     autofollowed_users =
 786       User.Query.build(%{nickname: candidates, local: true, deactivated: false})
 787       |> Repo.all()
 788
 789     follow_all(user, autofollowed_users)
 790   end
 791
 792   defp autofollowing_users(user) do
 793     candidates = Config.get([:instance, :autofollowing_nicknames])
 794
 795     User.Query.build(%{nickname: candidates, local: true, deactivated: false})
 796     |> Repo.all()
 797     |> Enum.each(&follow(&1, user, :follow_accept))
 798
 799     {:ok, :success}
 800   end
 801
 802   @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
 803   def register(%Ecto.Changeset{} = changeset) do
 804     with {:ok, user} <- Repo.insert(changeset) do
 805       post_register_action(user)
 806     end
 807   end
 808
 809   def post_register_action(%User{} = user) do
 810     with {:ok, user} <- autofollow_users(user),
 811          {:ok, _} <- autofollowing_users(user),
 812          {:ok, user} <- set_cache(user),
 813          {:ok, _} <- send_welcome_email(user),
 814          {:ok, _} <- send_welcome_message(user),
 815          {:ok, _} <- send_welcome_chat_message(user),
 816          {:ok, _} <- try_send_confirmation_email(user) do
 817       {:ok, user}
 818     end
 819   end
 820
 821   def send_welcome_message(user) do
 822     if User.WelcomeMessage.enabled?() do
 823       User.WelcomeMessage.post_message(user)
 824       {:ok, :enqueued}
 825     else
 826       {:ok, :noop}
 827     end
 828   end
 829
 830   def send_welcome_chat_message(user) do
 831     if User.WelcomeChatMessage.enabled?() do
 832       User.WelcomeChatMessage.post_message(user)
 833       {:ok, :enqueued}
 834     else
 835       {:ok, :noop}
 836     end
 837   end
 838
 839   def send_welcome_email(%User{email: email} = user) when is_binary(email) do
 840     if User.WelcomeEmail.enabled?() do
 841       User.WelcomeEmail.send_email(user)
 842       {:ok, :enqueued}
 843     else
 844       {:ok, :noop}
 845     end
 846   end
 847
 848   def send_welcome_email(_), do: {:ok, :noop}
 849
 850   @spec try_send_confirmation_email(User.t()) :: {:ok, :enqueued | :noop}
 851   def try_send_confirmation_email(%User{confirmation_pending: true, email: email} = user)
 852       when is_binary(email) do
 853     if Config.get([:instance, :account_activation_required]) do
 854       send_confirmation_email(user)
 855       {:ok, :enqueued}
 856     else
 857       {:ok, :noop}
 858     end
 859   end
 860
 861   def try_send_confirmation_email(_), do: {:ok, :noop}
 862
 863   @spec send_confirmation_email(Uset.t()) :: User.t()
 864   def send_confirmation_email(%User{} = user) do
 865     user
 866     |> Pleroma.Emails.UserEmail.account_confirmation_email()
 867     |> Pleroma.Emails.Mailer.deliver_async()
 868
 869     user
 870   end
 871
 872   def needs_update?(%User{local: true}), do: false
 873
 874   def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
 875
 876   def needs_update?(%User{local: false} = user) do
 877     NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
 878   end
 879
 880   def needs_update?(_), do: true
 881
 882   @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
 883
 884   # "Locked" (self-locked) users demand explicit authorization of follow requests
 885   def maybe_direct_follow(%User{} = follower, %User{local: true, is_locked: true} = followed) do
 886     follow(follower, followed, :follow_pending)
 887   end
 888
 889   def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
 890     follow(follower, followed)
 891   end
 892
 893   def maybe_direct_follow(%User{} = follower, %User{} = followed) do
 894     if not ap_enabled?(followed) do
 895       follow(follower, followed)
 896     else
 897       {:ok, follower, followed}
 898     end
 899   end
 900
 901   @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
 902   @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
 903   def follow_all(follower, followeds) do
 904     followeds
 905     |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
 906     |> Enum.each(&follow(follower, &1, :follow_accept))
 907
 908     set_cache(follower)
 909   end
 910
 911   def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
 912     deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
 913
 914     cond do
 915       followed.deactivated ->
 916         {:error, "Could not follow user: #{followed.nickname} is deactivated."}
 917
 918       deny_follow_blocked and blocks?(followed, follower) ->
 919         {:error, "Could not follow user: #{followed.nickname} blocked you."}
 920
 921       true ->
 922         FollowingRelationship.follow(follower, followed, state)
 923     end
 924   end
 925
 926   def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
 927     {:error, "Not subscribed!"}
 928   end
 929
 930   @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
 931   def unfollow(%User{} = follower, %User{} = followed) do
 932     case do_unfollow(follower, followed) do
 933       {:ok, follower, followed} ->
 934         {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
 935
 936       error ->
 937         error
 938     end
 939   end
 940
 941   @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
 942   defp do_unfollow(%User{} = follower, %User{} = followed) do
 943     case get_follow_state(follower, followed) do
 944       state when state in [:follow_pending, :follow_accept] ->
 945         FollowingRelationship.unfollow(follower, followed)
 946
 947       nil ->
 948         {:error, "Not subscribed!"}
 949     end
 950   end
 951
 952   @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
 953   def get_follow_state(%User{} = follower, %User{} = following) do
 954     following_relationship = FollowingRelationship.get(follower, following)
 955     get_follow_state(follower, following, following_relationship)
 956   end
 957
 958   def get_follow_state(
 959         %User{} = follower,
 960         %User{} = following,
 961         following_relationship
 962       ) do
 963     case {following_relationship, following.local} do
 964       {nil, false} ->
 965         case Utils.fetch_latest_follow(follower, following) do
 966           %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
 967             FollowingRelationship.state_to_enum(state)
 968
 969           _ ->
 970             nil
 971         end
 972
 973       {%{state: state}, _} ->
 974         state
 975
 976       {nil, _} ->
 977         nil
 978     end
 979   end
 980
 981   def locked?(%User{} = user) do
 982     user.is_locked || false
 983   end
 984
 985   def get_by_id(id) do
 986     Repo.get_by(User, id: id)
 987   end
 988
 989   def get_by_ap_id(ap_id) do
 990     Repo.get_by(User, ap_id: ap_id)
 991   end
 992
 993   def get_all_by_ap_id(ap_ids) do
 994     from(u in __MODULE__,
 995       where: u.ap_id in ^ap_ids
 996     )
 997     |> Repo.all()
 998   end
 999
1000   def get_all_by_ids(ids) do
1001     from(u in __MODULE__, where: u.id in ^ids)
1002     |> Repo.all()
1003   end
1004
1005   # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
1006   # of the ap_id and the domain and tries to get that user
1007   def get_by_guessed_nickname(ap_id) do
1008     domain = URI.parse(ap_id).host
1009     name = List.last(String.split(ap_id, "/"))
1010     nickname = "#{name}@#{domain}"
1011
1012     get_cached_by_nickname(nickname)
1013   end
1014
1015   def set_cache({:ok, user}), do: set_cache(user)
1016   def set_cache({:error, err}), do: {:error, err}
1017
1018   def set_cache(%User{} = user) do
1019     Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1020     Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
1021     Cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
1022     {:ok, user}
1023   end
1024
1025   def update_and_set_cache(struct, params) do
1026     struct
1027     |> update_changeset(params)
1028     |> update_and_set_cache()
1029   end
1030
1031   def update_and_set_cache(changeset) do
1032     with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
1033       set_cache(user)
1034     end
1035   end
1036
1037   def get_user_friends_ap_ids(user) do
1038     from(u in User.get_friends_query(user), select: u.ap_id)
1039     |> Repo.all()
1040   end
1041
1042   @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
1043   def get_cached_user_friends_ap_ids(user) do
1044     Cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
1045       get_user_friends_ap_ids(user)
1046     end)
1047   end
1048
1049   def invalidate_cache(user) do
1050     Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
1051     Cachex.del(:user_cache, "nickname:#{user.nickname}")
1052     Cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
1053     Cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
1054     Cachex.del(:user_cache, "muted_users_ap_ids:#{user.ap_id}")
1055   end
1056
1057   @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
1058   def get_cached_by_ap_id(ap_id) do
1059     key = "ap_id:#{ap_id}"
1060
1061     with {:ok, nil} <- Cachex.get(:user_cache, key),
1062          user when not is_nil(user) <- get_by_ap_id(ap_id),
1063          {:ok, true} <- Cachex.put(:user_cache, key, user) do
1064       user
1065     else
1066       {:ok, user} -> user
1067       nil -> nil
1068     end
1069   end
1070
1071   def get_cached_by_id(id) do
1072     key = "id:#{id}"
1073
1074     ap_id =
1075       Cachex.fetch!(:user_cache, key, fn _ ->
1076         user = get_by_id(id)
1077
1078         if user do
1079           Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1080           {:commit, user.ap_id}
1081         else
1082           {:ignore, ""}
1083         end
1084       end)
1085
1086     get_cached_by_ap_id(ap_id)
1087   end
1088
1089   def get_cached_by_nickname(nickname) do
1090     key = "nickname:#{nickname}"
1091
1092     Cachex.fetch!(:user_cache, key, fn ->
1093       case get_or_fetch_by_nickname(nickname) do
1094         {:ok, user} -> {:commit, user}
1095         {:error, _error} -> {:ignore, nil}
1096       end
1097     end)
1098   end
1099
1100   def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
1101     restrict_to_local = Config.get([:instance, :limit_to_local_content])
1102
1103     cond do
1104       is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
1105         get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
1106
1107       restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
1108         get_cached_by_nickname(nickname_or_id)
1109
1110       restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
1111         get_cached_by_nickname(nickname_or_id)
1112
1113       true ->
1114         nil
1115     end
1116   end
1117
1118   @spec get_by_nickname(String.t()) :: User.t() | nil
1119   def get_by_nickname(nickname) do
1120     Repo.get_by(User, nickname: nickname) ||
1121       if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
1122         Repo.get_by(User, nickname: local_nickname(nickname))
1123       end
1124   end
1125
1126   def get_by_email(email), do: Repo.get_by(User, email: email)
1127
1128   def get_by_nickname_or_email(nickname_or_email) do
1129     get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
1130   end
1131
1132   def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
1133
1134   def get_or_fetch_by_nickname(nickname) do
1135     with %User{} = user <- get_by_nickname(nickname) do
1136       {:ok, user}
1137     else
1138       _e ->
1139         with [_nick, _domain] <- String.split(nickname, "@"),
1140              {:ok, user} <- fetch_by_nickname(nickname) do
1141           {:ok, user}
1142         else
1143           _e -> {:error, "not found " <> nickname}
1144         end
1145     end
1146   end
1147
1148   @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1149   def get_followers_query(%User{} = user, nil) do
1150     User.Query.build(%{followers: user, deactivated: false})
1151   end
1152
1153   def get_followers_query(%User{} = user, page) do
1154     user
1155     |> get_followers_query(nil)
1156     |> User.Query.paginate(page, 20)
1157   end
1158
1159   @spec get_followers_query(User.t()) :: Ecto.Query.t()
1160   def get_followers_query(%User{} = user), do: get_followers_query(user, nil)
1161
1162   @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1163   def get_followers(%User{} = user, page \\ nil) do
1164     user
1165     |> get_followers_query(page)
1166     |> Repo.all()
1167   end
1168
1169   @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1170   def get_external_followers(%User{} = user, page \\ nil) do
1171     user
1172     |> get_followers_query(page)
1173     |> User.Query.build(%{external: true})
1174     |> Repo.all()
1175   end
1176
1177   def get_followers_ids(%User{} = user, page \\ nil) do
1178     user
1179     |> get_followers_query(page)
1180     |> select([u], u.id)
1181     |> Repo.all()
1182   end
1183
1184   @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1185   def get_friends_query(%User{} = user, nil) do
1186     User.Query.build(%{friends: user, deactivated: false})
1187   end
1188
1189   def get_friends_query(%User{} = user, page) do
1190     user
1191     |> get_friends_query(nil)
1192     |> User.Query.paginate(page, 20)
1193   end
1194
1195   @spec get_friends_query(User.t()) :: Ecto.Query.t()
1196   def get_friends_query(%User{} = user), do: get_friends_query(user, nil)
1197
1198   def get_friends(%User{} = user, page \\ nil) do
1199     user
1200     |> get_friends_query(page)
1201     |> Repo.all()
1202   end
1203
1204   def get_friends_ap_ids(%User{} = user) do
1205     user
1206     |> get_friends_query(nil)
1207     |> select([u], u.ap_id)
1208     |> Repo.all()
1209   end
1210
1211   def get_friends_ids(%User{} = user, page \\ nil) do
1212     user
1213     |> get_friends_query(page)
1214     |> select([u], u.id)
1215     |> Repo.all()
1216   end
1217
1218   def increase_note_count(%User{} = user) do
1219     User
1220     |> where(id: ^user.id)
1221     |> update([u], inc: [note_count: 1])
1222     |> select([u], u)
1223     |> Repo.update_all([])
1224     |> case do
1225       {1, [user]} -> set_cache(user)
1226       _ -> {:error, user}
1227     end
1228   end
1229
1230   def decrease_note_count(%User{} = user) do
1231     User
1232     |> where(id: ^user.id)
1233     |> update([u],
1234       set: [
1235         note_count: fragment("greatest(0, note_count - 1)")
1236       ]
1237     )
1238     |> select([u], u)
1239     |> Repo.update_all([])
1240     |> case do
1241       {1, [user]} -> set_cache(user)
1242       _ -> {:error, user}
1243     end
1244   end
1245
1246   def update_note_count(%User{} = user, note_count \\ nil) do
1247     note_count =
1248       note_count ||
1249         from(
1250           a in Object,
1251           where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1252           select: count(a.id)
1253         )
1254         |> Repo.one()
1255
1256     user
1257     |> cast(%{note_count: note_count}, [:note_count])
1258     |> update_and_set_cache()
1259   end
1260
1261   @spec maybe_fetch_follow_information(User.t()) :: User.t()
1262   def maybe_fetch_follow_information(user) do
1263     with {:ok, user} <- fetch_follow_information(user) do
1264       user
1265     else
1266       e ->
1267         Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1268
1269         user
1270     end
1271   end
1272
1273   def fetch_follow_information(user) do
1274     with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1275       user
1276       |> follow_information_changeset(info)
1277       |> update_and_set_cache()
1278     end
1279   end
1280
1281   defp follow_information_changeset(user, params) do
1282     user
1283     |> cast(params, [
1284       :hide_followers,
1285       :hide_follows,
1286       :follower_count,
1287       :following_count,
1288       :hide_followers_count,
1289       :hide_follows_count
1290     ])
1291   end
1292
1293   @spec update_follower_count(User.t()) :: {:ok, User.t()}
1294   def update_follower_count(%User{} = user) do
1295     if user.local or !Config.get([:instance, :external_user_synchronization]) do
1296       follower_count = FollowingRelationship.follower_count(user)
1297
1298       user
1299       |> follow_information_changeset(%{follower_count: follower_count})
1300       |> update_and_set_cache
1301     else
1302       {:ok, maybe_fetch_follow_information(user)}
1303     end
1304   end
1305
1306   @spec update_following_count(User.t()) :: {:ok, User.t()}
1307   def update_following_count(%User{local: false} = user) do
1308     if Config.get([:instance, :external_user_synchronization]) do
1309       {:ok, maybe_fetch_follow_information(user)}
1310     else
1311       {:ok, user}
1312     end
1313   end
1314
1315   def update_following_count(%User{local: true} = user) do
1316     following_count = FollowingRelationship.following_count(user)
1317
1318     user
1319     |> follow_information_changeset(%{following_count: following_count})
1320     |> update_and_set_cache()
1321   end
1322
1323   @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1324   def get_users_from_set(ap_ids, opts \\ []) do
1325     local_only = Keyword.get(opts, :local_only, true)
1326     criteria = %{ap_id: ap_ids, deactivated: false}
1327     criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1328
1329     User.Query.build(criteria)
1330     |> Repo.all()
1331   end
1332
1333   @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1334   def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1335     to = [actor | to]
1336
1337     query = User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
1338
1339     query
1340     |> Repo.all()
1341   end
1342
1343   @spec mute(User.t(), User.t(), map()) ::
1344           {:ok, list(UserRelationship.t())} | {:error, String.t()}
1345   def mute(%User{} = muter, %User{} = mutee, params \\ %{}) do
1346     notifications? = Map.get(params, :notifications, true)
1347     expires_in = Map.get(params, :expires_in, 0)
1348
1349     with {:ok, user_mute} <- UserRelationship.create_mute(muter, mutee),
1350          {:ok, user_notification_mute} <-
1351            (notifications? && UserRelationship.create_notification_mute(muter, mutee)) ||
1352              {:ok, nil} do
1353       if expires_in > 0 do
1354         Pleroma.Workers.MuteExpireWorker.enqueue(
1355           "unmute_user",
1356           %{"muter_id" => muter.id, "mutee_id" => mutee.id},
1357           schedule_in: expires_in
1358         )
1359       end
1360
1361       Cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
1362
1363       {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
1364     end
1365   end
1366
1367   def unmute(%User{} = muter, %User{} = mutee) do
1368     with {:ok, user_mute} <- UserRelationship.delete_mute(muter, mutee),
1369          {:ok, user_notification_mute} <-
1370            UserRelationship.delete_notification_mute(muter, mutee) do
1371       Cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
1372       {:ok, [user_mute, user_notification_mute]}
1373     end
1374   end
1375
1376   def unmute(muter_id, mutee_id) do
1377     with {:muter, %User{} = muter} <- {:muter, User.get_by_id(muter_id)},
1378          {:mutee, %User{} = mutee} <- {:mutee, User.get_by_id(mutee_id)} do
1379       unmute(muter, mutee)
1380     else
1381       {who, result} = error ->
1382         Logger.warn(
1383           "User.unmute/2 failed. #{who}: #{result}, muter_id: #{muter_id}, mutee_id: #{mutee_id}"
1384         )
1385
1386         {:error, error}
1387     end
1388   end
1389
1390   def subscribe(%User{} = subscriber, %User{} = target) do
1391     deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
1392
1393     if blocks?(target, subscriber) and deny_follow_blocked do
1394       {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1395     else
1396       # Note: the relationship is inverse: subscriber acts as relationship target
1397       UserRelationship.create_inverse_subscription(target, subscriber)
1398     end
1399   end
1400
1401   def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1402     with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1403       subscribe(subscriber, subscribee)
1404     end
1405   end
1406
1407   def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1408     # Note: the relationship is inverse: subscriber acts as relationship target
1409     UserRelationship.delete_inverse_subscription(target, unsubscriber)
1410   end
1411
1412   def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1413     with %User{} = user <- get_cached_by_ap_id(ap_id) do
1414       unsubscribe(unsubscriber, user)
1415     end
1416   end
1417
1418   def block(%User{} = blocker, %User{} = blocked) do
1419     # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1420     blocker =
1421       if following?(blocker, blocked) do
1422         {:ok, blocker, _} = unfollow(blocker, blocked)
1423         blocker
1424       else
1425         blocker
1426       end
1427
1428     # clear any requested follows as well
1429     blocked =
1430       case CommonAPI.reject_follow_request(blocked, blocker) do
1431         {:ok, %User{} = updated_blocked} -> updated_blocked
1432         nil -> blocked
1433       end
1434
1435     unsubscribe(blocked, blocker)
1436
1437     unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
1438     if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)
1439
1440     {:ok, blocker} = update_follower_count(blocker)
1441     {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1442     add_to_block(blocker, blocked)
1443   end
1444
1445   # helper to handle the block given only an actor's AP id
1446   def block(%User{} = blocker, %{ap_id: ap_id}) do
1447     block(blocker, get_cached_by_ap_id(ap_id))
1448   end
1449
1450   def unblock(%User{} = blocker, %User{} = blocked) do
1451     remove_from_block(blocker, blocked)
1452   end
1453
1454   # helper to handle the block given only an actor's AP id
1455   def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1456     unblock(blocker, get_cached_by_ap_id(ap_id))
1457   end
1458
1459   def mutes?(nil, _), do: false
1460   def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1461
1462   def mutes_user?(%User{} = user, %User{} = target) do
1463     UserRelationship.mute_exists?(user, target)
1464   end
1465
1466   @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1467   def muted_notifications?(nil, _), do: false
1468
1469   def muted_notifications?(%User{} = user, %User{} = target),
1470     do: UserRelationship.notification_mute_exists?(user, target)
1471
1472   def blocks?(nil, _), do: false
1473
1474   def blocks?(%User{} = user, %User{} = target) do
1475     blocks_user?(user, target) ||
1476       (blocks_domain?(user, target) and not User.following?(user, target))
1477   end
1478
1479   def blocks_user?(%User{} = user, %User{} = target) do
1480     UserRelationship.block_exists?(user, target)
1481   end
1482
1483   def blocks_user?(_, _), do: false
1484
1485   def blocks_domain?(%User{} = user, %User{} = target) do
1486     domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1487     %{host: host} = URI.parse(target.ap_id)
1488     Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1489   end
1490
1491   def blocks_domain?(_, _), do: false
1492
1493   def subscribed_to?(%User{} = user, %User{} = target) do
1494     # Note: the relationship is inverse: subscriber acts as relationship target
1495     UserRelationship.inverse_subscription_exists?(target, user)
1496   end
1497
1498   def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1499     with %User{} = target <- get_cached_by_ap_id(ap_id) do
1500       subscribed_to?(user, target)
1501     end
1502   end
1503
1504   @doc """
1505   Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1506   E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1507   """
1508   @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1509   def outgoing_relationships_ap_ids(_user, []), do: %{}
1510
1511   def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1512
1513   def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1514       when is_list(relationship_types) do
1515     db_result =
1516       user
1517       |> assoc(:outgoing_relationships)
1518       |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1519       |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1520       |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1521       |> group_by([user_rel, u], user_rel.relationship_type)
1522       |> Repo.all()
1523       |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1524
1525     Enum.into(
1526       relationship_types,
1527       %{},
1528       fn rel_type -> {rel_type, db_result[rel_type] || []} end
1529     )
1530   end
1531
1532   def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1533
1534   def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1535
1536   def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1537
1538   def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1539       when is_list(relationship_types) do
1540     user
1541     |> assoc(:incoming_relationships)
1542     |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1543     |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1544     |> maybe_filter_on_ap_id(ap_ids)
1545     |> select([user_rel, u], u.ap_id)
1546     |> distinct(true)
1547     |> Repo.all()
1548   end
1549
1550   defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1551     where(query, [user_rel, u], u.ap_id in ^ap_ids)
1552   end
1553
1554   defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1555
1556   def deactivate_async(user, status \\ true) do
1557     BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
1558   end
1559
1560   def deactivate(user, status \\ true)
1561
1562   def deactivate(users, status) when is_list(users) do
1563     Repo.transaction(fn ->
1564       for user <- users, do: deactivate(user, status)
1565     end)
1566   end
1567
1568   def deactivate(%User{} = user, status) do
1569     with {:ok, user} <- set_activation_status(user, status) do
1570       user
1571       |> get_followers()
1572       |> Enum.filter(& &1.local)
1573       |> Enum.each(&set_cache(update_following_count(&1)))
1574
1575       # Only update local user counts, remote will be update during the next pull.
1576       user
1577       |> get_friends()
1578       |> Enum.filter(& &1.local)
1579       |> Enum.each(&do_unfollow(user, &1))
1580
1581       {:ok, user}
1582     end
1583   end
1584
1585   def approve(users) when is_list(users) do
1586     Repo.transaction(fn ->
1587       Enum.map(users, fn user ->
1588         with {:ok, user} <- approve(user), do: user
1589       end)
1590     end)
1591   end
1592
1593   def approve(%User{} = user) do
1594     change(user, approval_pending: false)
1595     |> update_and_set_cache()
1596   end
1597
1598   def update_notification_settings(%User{} = user, settings) do
1599     user
1600     |> cast(%{notification_settings: settings}, [])
1601     |> cast_embed(:notification_settings)
1602     |> validate_required([:notification_settings])
1603     |> update_and_set_cache()
1604   end
1605
1606   @spec purge_user_changeset(User.t()) :: Changeset.t()
1607   def purge_user_changeset(user) do
1608     # "Right to be forgotten"
1609     # https://gdpr.eu/right-to-be-forgotten/
1610     change(user, %{
1611       bio: "",
1612       raw_bio: nil,
1613       email: nil,
1614       name: nil,
1615       password_hash: nil,
1616       keys: nil,
1617       public_key: nil,
1618       avatar: %{},
1619       tags: [],
1620       last_refreshed_at: nil,
1621       last_digest_emailed_at: nil,
1622       banner: %{},
1623       background: %{},
1624       note_count: 0,
1625       follower_count: 0,
1626       following_count: 0,
1627       is_locked: false,
1628       confirmation_pending: false,
1629       password_reset_pending: false,
1630       approval_pending: false,
1631       registration_reason: nil,
1632       confirmation_token: nil,
1633       domain_blocks: [],
1634       deactivated: true,
1635       ap_enabled: false,
1636       is_moderator: false,
1637       is_admin: false,
1638       mastofe_settings: nil,
1639       mascot: nil,
1640       emoji: %{},
1641       pleroma_settings_store: %{},
1642       fields: [],
1643       raw_fields: [],
1644       is_discoverable: false,
1645       also_known_as: []
1646     })
1647   end
1648
1649   def delete(users) when is_list(users) do
1650     for user <- users, do: delete(user)
1651   end
1652
1653   def delete(%User{} = user) do
1654     BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1655   end
1656
1657   defp delete_and_invalidate_cache(%User{} = user) do
1658     invalidate_cache(user)
1659     Repo.delete(user)
1660   end
1661
1662   defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)
1663
1664   defp delete_or_deactivate(%User{local: true} = user) do
1665     status = account_status(user)
1666
1667     case status do
1668       :confirmation_pending ->
1669         delete_and_invalidate_cache(user)
1670
1671       :approval_pending ->
1672         delete_and_invalidate_cache(user)
1673
1674       _ ->
1675         user
1676         |> purge_user_changeset()
1677         |> update_and_set_cache()
1678     end
1679   end
1680
1681   def perform(:force_password_reset, user), do: force_password_reset(user)
1682
1683   @spec perform(atom(), User.t()) :: {:ok, User.t()}
1684   def perform(:delete, %User{} = user) do
1685     # Remove all relationships
1686     user
1687     |> get_followers()
1688     |> Enum.each(fn follower ->
1689       ActivityPub.unfollow(follower, user)
1690       unfollow(follower, user)
1691     end)
1692
1693     user
1694     |> get_friends()
1695     |> Enum.each(fn followed ->
1696       ActivityPub.unfollow(user, followed)
1697       unfollow(user, followed)
1698     end)
1699
1700     delete_user_activities(user)
1701     delete_notifications_from_user_activities(user)
1702
1703     delete_outgoing_pending_follow_requests(user)
1704
1705     delete_or_deactivate(user)
1706   end
1707
1708   def perform(:deactivate_async, user, status), do: deactivate(user, status)
1709
1710   @spec external_users_query() :: Ecto.Query.t()
1711   def external_users_query do
1712     User.Query.build(%{
1713       external: true,
1714       active: true,
1715       order_by: :id
1716     })
1717   end
1718
1719   @spec external_users(keyword()) :: [User.t()]
1720   def external_users(opts \\ []) do
1721     query =
1722       external_users_query()
1723       |> select([u], struct(u, [:id, :ap_id]))
1724
1725     query =
1726       if opts[:max_id],
1727         do: where(query, [u], u.id > ^opts[:max_id]),
1728         else: query
1729
1730     query =
1731       if opts[:limit],
1732         do: limit(query, ^opts[:limit]),
1733         else: query
1734
1735     Repo.all(query)
1736   end
1737
1738   def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1739     Notification
1740     |> join(:inner, [n], activity in assoc(n, :activity))
1741     |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1742     |> Repo.delete_all()
1743   end
1744
1745   def delete_user_activities(%User{ap_id: ap_id} = user) do
1746     ap_id
1747     |> Activity.Queries.by_actor()
1748     |> Repo.chunk_stream(50, :batches)
1749     |> Stream.each(fn activities ->
1750       Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1751     end)
1752     |> Stream.run()
1753   end
1754
1755   defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1756     with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1757          {:ok, delete_data, _} <- Builder.delete(user, object) do
1758       Pipeline.common_pipeline(delete_data, local: user.local)
1759     else
1760       {:find_object, nil} ->
1761         # We have the create activity, but not the object, it was probably pruned.
1762         # Insert a tombstone and try again
1763         with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1764              {:ok, _tombstone} <- Object.create(tombstone_data) do
1765           delete_activity(activity, user)
1766         end
1767
1768       e ->
1769         Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1770         Logger.error("Error: #{inspect(e)}")
1771     end
1772   end
1773
1774   defp delete_activity(%{data: %{"type" => type}} = activity, user)
1775        when type in ["Like", "Announce"] do
1776     {:ok, undo, _} = Builder.undo(user, activity)
1777     Pipeline.common_pipeline(undo, local: user.local)
1778   end
1779
1780   defp delete_activity(_activity, _user), do: "Doing nothing"
1781
1782   defp delete_outgoing_pending_follow_requests(user) do
1783     user
1784     |> FollowingRelationship.outgoing_pending_follow_requests_query()
1785     |> Repo.delete_all()
1786   end
1787
1788   def html_filter_policy(%User{no_rich_text: true}) do
1789     Pleroma.HTML.Scrubber.TwitterText
1790   end
1791
1792   def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])
1793
1794   def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1795
1796   def get_or_fetch_by_ap_id(ap_id) do
1797     cached_user = get_cached_by_ap_id(ap_id)
1798
1799     maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)
1800
1801     case {cached_user, maybe_fetched_user} do
1802       {_, {:ok, %User{} = user}} ->
1803         {:ok, user}
1804
1805       {%User{} = user, _} ->
1806         {:ok, user}
1807
1808       _ ->
1809         {:error, :not_found}
1810     end
1811   end
1812
1813   @doc """
1814   Creates an internal service actor by URI if missing.
1815   Optionally takes nickname for addressing.
1816   """
1817   @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1818   def get_or_create_service_actor_by_ap_id(uri, nickname) do
1819     {_, user} =
1820       case get_cached_by_ap_id(uri) do
1821         nil ->
1822           with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1823             Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1824             {:error, nil}
1825           end
1826
1827         %User{invisible: false} = user ->
1828           set_invisible(user)
1829
1830         user ->
1831           {:ok, user}
1832       end
1833
1834     user
1835   end
1836
1837   @spec set_invisible(User.t()) :: {:ok, User.t()}
1838   defp set_invisible(user) do
1839     user
1840     |> change(%{invisible: true})
1841     |> update_and_set_cache()
1842   end
1843
1844   @spec create_service_actor(String.t(), String.t()) ::
1845           {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1846   defp create_service_actor(uri, nickname) do
1847     %User{
1848       invisible: true,
1849       local: true,
1850       ap_id: uri,
1851       nickname: nickname,
1852       follower_address: uri <> "/followers"
1853     }
1854     |> change
1855     |> unique_constraint(:nickname)
1856     |> Repo.insert()
1857     |> set_cache()
1858   end
1859
1860   def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1861     key =
1862       public_key_pem
1863       |> :public_key.pem_decode()
1864       |> hd()
1865       |> :public_key.pem_entry_decode()
1866
1867     {:ok, key}
1868   end
1869
1870   def public_key(_), do: {:error, "key not found"}
1871
1872   def get_public_key_for_ap_id(ap_id) do
1873     with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1874          {:ok, public_key} <- public_key(user) do
1875       {:ok, public_key}
1876     else
1877       _ -> :error
1878     end
1879   end
1880
1881   def ap_enabled?(%User{local: true}), do: true
1882   def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1883   def ap_enabled?(_), do: false
1884
1885   @doc "Gets or fetch a user by uri or nickname."
1886   @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1887   def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1888   def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1889
1890   # wait a period of time and return newest version of the User structs
1891   # this is because we have synchronous follow APIs and need to simulate them
1892   # with an async handshake
1893   def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1894     with %User{} = a <- get_cached_by_id(a.id),
1895          %User{} = b <- get_cached_by_id(b.id) do
1896       {:ok, a, b}
1897     else
1898       nil -> :error
1899     end
1900   end
1901
1902   def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1903     with :ok <- :timer.sleep(timeout),
1904          %User{} = a <- get_cached_by_id(a.id),
1905          %User{} = b <- get_cached_by_id(b.id) do
1906       {:ok, a, b}
1907     else
1908       nil -> :error
1909     end
1910   end
1911
1912   def parse_bio(bio) when is_binary(bio) and bio != "" do
1913     bio
1914     |> CommonUtils.format_input("text/plain", mentions_format: :full)
1915     |> elem(0)
1916   end
1917
1918   def parse_bio(_), do: ""
1919
1920   def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1921     # TODO: get profile URLs other than user.ap_id
1922     profile_urls = [user.ap_id]
1923
1924     bio
1925     |> CommonUtils.format_input("text/plain",
1926       mentions_format: :full,
1927       rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1928     )
1929     |> elem(0)
1930   end
1931
1932   def parse_bio(_, _), do: ""
1933
1934   def tag(user_identifiers, tags) when is_list(user_identifiers) do
1935     Repo.transaction(fn ->
1936       for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1937     end)
1938   end
1939
1940   def tag(nickname, tags) when is_binary(nickname),
1941     do: tag(get_by_nickname(nickname), tags)
1942
1943   def tag(%User{} = user, tags),
1944     do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1945
1946   def untag(user_identifiers, tags) when is_list(user_identifiers) do
1947     Repo.transaction(fn ->
1948       for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1949     end)
1950   end
1951
1952   def untag(nickname, tags) when is_binary(nickname),
1953     do: untag(get_by_nickname(nickname), tags)
1954
1955   def untag(%User{} = user, tags),
1956     do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1957
1958   defp update_tags(%User{} = user, new_tags) do
1959     {:ok, updated_user} =
1960       user
1961       |> change(%{tags: new_tags})
1962       |> update_and_set_cache()
1963
1964     updated_user
1965   end
1966
1967   defp normalize_tags(tags) do
1968     [tags]
1969     |> List.flatten()
1970     |> Enum.map(&String.downcase/1)
1971   end
1972
1973   defp local_nickname_regex do
1974     if Config.get([:instance, :extended_nickname_format]) do
1975       @extended_local_nickname_regex
1976     else
1977       @strict_local_nickname_regex
1978     end
1979   end
1980
1981   def local_nickname(nickname_or_mention) do
1982     nickname_or_mention
1983     |> full_nickname()
1984     |> String.split("@")
1985     |> hd()
1986   end
1987
1988   def full_nickname(nickname_or_mention),
1989     do: String.trim_leading(nickname_or_mention, "@")
1990
1991   def error_user(ap_id) do
1992     %User{
1993       name: ap_id,
1994       ap_id: ap_id,
1995       nickname: "erroruser@example.com",
1996       inserted_at: NaiveDateTime.utc_now()
1997     }
1998   end
1999
2000   @spec all_superusers() :: [User.t()]
2001   def all_superusers do
2002     User.Query.build(%{super_users: true, local: true, deactivated: false})
2003     |> Repo.all()
2004   end
2005
2006   def muting_reblogs?(%User{} = user, %User{} = target) do
2007     UserRelationship.reblog_mute_exists?(user, target)
2008   end
2009
2010   def showing_reblogs?(%User{} = user, %User{} = target) do
2011     not muting_reblogs?(user, target)
2012   end
2013
2014   @doc """
2015   The function returns a query to get users with no activity for given interval of days.
2016   Inactive users are those who didn't read any notification, or had any activity where
2017   the user is the activity's actor, during `inactivity_threshold` days.
2018   Deactivated users will not appear in this list.
2019
2020   ## Examples
2021
2022       iex> Pleroma.User.list_inactive_users()
2023       %Ecto.Query{}
2024   """
2025   @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
2026   def list_inactive_users_query(inactivity_threshold \\ 7) do
2027     negative_inactivity_threshold = -inactivity_threshold
2028     now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2029     # Subqueries are not supported in `where` clauses, join gets too complicated.
2030     has_read_notifications =
2031       from(n in Pleroma.Notification,
2032         where: n.seen == true,
2033         group_by: n.id,
2034         having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
2035         select: n.user_id
2036       )
2037       |> Pleroma.Repo.all()
2038
2039     from(u in Pleroma.User,
2040       left_join: a in Pleroma.Activity,
2041       on: u.ap_id == a.actor,
2042       where: not is_nil(u.nickname),
2043       where: u.deactivated != ^true,
2044       where: u.id not in ^has_read_notifications,
2045       group_by: u.id,
2046       having:
2047         max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
2048           is_nil(max(a.inserted_at))
2049     )
2050   end
2051
2052   @doc """
2053   Enable or disable email notifications for user
2054
2055   ## Examples
2056
2057       iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
2058       Pleroma.User{email_notifications: %{"digest" => true}}
2059
2060       iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
2061       Pleroma.User{email_notifications: %{"digest" => false}}
2062   """
2063   @spec switch_email_notifications(t(), String.t(), boolean()) ::
2064           {:ok, t()} | {:error, Ecto.Changeset.t()}
2065   def switch_email_notifications(user, type, status) do
2066     User.update_email_notifications(user, %{type => status})
2067   end
2068
2069   @doc """
2070   Set `last_digest_emailed_at` value for the user to current time
2071   """
2072   @spec touch_last_digest_emailed_at(t()) :: t()
2073   def touch_last_digest_emailed_at(user) do
2074     now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2075
2076     {:ok, updated_user} =
2077       user
2078       |> change(%{last_digest_emailed_at: now})
2079       |> update_and_set_cache()
2080
2081     updated_user
2082   end
2083
2084   @spec toggle_confirmation(User.t()) :: {:ok, User.t()} | {:error, Changeset.t()}
2085   def toggle_confirmation(%User{} = user) do
2086     user
2087     |> confirmation_changeset(need_confirmation: !user.confirmation_pending)
2088     |> update_and_set_cache()
2089   end
2090
2091   @spec toggle_confirmation([User.t()]) :: [{:ok, User.t()} | {:error, Changeset.t()}]
2092   def toggle_confirmation(users) do
2093     Enum.map(users, &toggle_confirmation/1)
2094   end
2095
2096   @spec need_confirmation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
2097   def need_confirmation(%User{} = user, bool) do
2098     user
2099     |> confirmation_changeset(need_confirmation: bool)
2100     |> update_and_set_cache()
2101   end
2102
2103   def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
2104     mascot
2105   end
2106
2107   def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
2108     # use instance-default
2109     config = Config.get([:assets, :mascots])
2110     default_mascot = Config.get([:assets, :default_mascot])
2111     mascot = Keyword.get(config, default_mascot)
2112
2113     %{
2114       "id" => "default-mascot",
2115       "url" => mascot[:url],
2116       "preview_url" => mascot[:url],
2117       "pleroma" => %{
2118         "mime_type" => mascot[:mime_type]
2119       }
2120     }
2121   end
2122
2123   def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
2124
2125   def ensure_keys_present(%User{} = user) do
2126     with {:ok, pem} <- Keys.generate_rsa_pem() do
2127       user
2128       |> cast(%{keys: pem}, [:keys])
2129       |> validate_required([:keys])
2130       |> update_and_set_cache()
2131     end
2132   end
2133
2134   def get_ap_ids_by_nicknames(nicknames) do
2135     from(u in User,
2136       where: u.nickname in ^nicknames,
2137       select: u.ap_id
2138     )
2139     |> Repo.all()
2140   end
2141
2142   defp put_password_hash(
2143          %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2144        ) do
2145     change(changeset, password_hash: Pbkdf2.hash_pwd_salt(password))
2146   end
2147
2148   defp put_password_hash(changeset), do: changeset
2149
2150   def is_internal_user?(%User{nickname: nil}), do: true
2151   def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2152   def is_internal_user?(_), do: false
2153
2154   # A hack because user delete activities have a fake id for whatever reason
2155   # TODO: Get rid of this
2156   def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2157
2158   def get_delivered_users_by_object_id(object_id) do
2159     from(u in User,
2160       inner_join: delivery in assoc(u, :deliveries),
2161       where: delivery.object_id == ^object_id
2162     )
2163     |> Repo.all()
2164   end
2165
2166   def change_email(user, email) do
2167     user
2168     |> cast(%{email: email}, [:email])
2169     |> validate_required([:email])
2170     |> unique_constraint(:email)
2171     |> validate_format(:email, @email_regex)
2172     |> update_and_set_cache()
2173   end
2174
2175   # Internal function; public one is `deactivate/2`
2176   defp set_activation_status(user, deactivated) do
2177     user
2178     |> cast(%{deactivated: deactivated}, [:deactivated])
2179     |> update_and_set_cache()
2180   end
2181
2182   def update_banner(user, banner) do
2183     user
2184     |> cast(%{banner: banner}, [:banner])
2185     |> update_and_set_cache()
2186   end
2187
2188   def update_background(user, background) do
2189     user
2190     |> cast(%{background: background}, [:background])
2191     |> update_and_set_cache()
2192   end
2193
2194   def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
2195     %{
2196       admin: is_admin,
2197       moderator: is_moderator
2198     }
2199   end
2200
2201   def validate_fields(changeset, remote? \\ false) do
2202     limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2203     limit = Config.get([:instance, limit_name], 0)
2204
2205     changeset
2206     |> validate_length(:fields, max: limit)
2207     |> validate_change(:fields, fn :fields, fields ->
2208       if Enum.all?(fields, &valid_field?/1) do
2209         []
2210       else
2211         [fields: "invalid"]
2212       end
2213     end)
2214   end
2215
2216   defp valid_field?(%{"name" => name, "value" => value}) do
2217     name_limit = Config.get([:instance, :account_field_name_length], 255)
2218     value_limit = Config.get([:instance, :account_field_value_length], 255)
2219
2220     is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2221       String.length(value) <= value_limit
2222   end
2223
2224   defp valid_field?(_), do: false
2225
2226   defp truncate_field(%{"name" => name, "value" => value}) do
2227     {name, _chopped} =
2228       String.split_at(name, Config.get([:instance, :account_field_name_length], 255))
2229
2230     {value, _chopped} =
2231       String.split_at(value, Config.get([:instance, :account_field_value_length], 255))
2232
2233     %{"name" => name, "value" => value}
2234   end
2235
2236   def admin_api_update(user, params) do
2237     user
2238     |> cast(params, [
2239       :is_moderator,
2240       :is_admin,
2241       :show_role
2242     ])
2243     |> update_and_set_cache()
2244   end
2245
2246   @doc "Signs user out of all applications"
2247   def global_sign_out(user) do
2248     OAuth.Authorization.delete_user_authorizations(user)
2249     OAuth.Token.delete_user_tokens(user)
2250   end
2251
2252   def mascot_update(user, url) do
2253     user
2254     |> cast(%{mascot: url}, [:mascot])
2255     |> validate_required([:mascot])
2256     |> update_and_set_cache()
2257   end
2258
2259   def mastodon_settings_update(user, settings) do
2260     user
2261     |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
2262     |> validate_required([:mastofe_settings])
2263     |> update_and_set_cache()
2264   end
2265
2266   @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2267   def confirmation_changeset(user, need_confirmation: need_confirmation?) do
2268     params =
2269       if need_confirmation? do
2270         %{
2271           confirmation_pending: true,
2272           confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2273         }
2274       else
2275         %{
2276           confirmation_pending: false,
2277           confirmation_token: nil
2278         }
2279       end
2280
2281     cast(user, params, [:confirmation_pending, :confirmation_token])
2282   end
2283
2284   @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
2285   def approval_changeset(user, need_approval: need_approval?) do
2286     params = if need_approval?, do: %{approval_pending: true}, else: %{approval_pending: false}
2287     cast(user, params, [:approval_pending])
2288   end
2289
2290   def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2291     if id not in user.pinned_activities do
2292       max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2293       params = %{pinned_activities: user.pinned_activities ++ [id]}
2294
2295       # if pinned activity was scheduled for deletion, we remove job
2296       if expiration = Pleroma.Workers.PurgeExpiredActivity.get_expiration(id) do
2297         Oban.cancel_job(expiration.id)
2298       end
2299
2300       user
2301       |> cast(params, [:pinned_activities])
2302       |> validate_length(:pinned_activities,
2303         max: max_pinned_statuses,
2304         message: "You have already pinned the maximum number of statuses"
2305       )
2306     else
2307       change(user)
2308     end
2309     |> update_and_set_cache()
2310   end
2311
2312   def remove_pinnned_activity(user, %Pleroma.Activity{id: id, data: data}) do
2313     params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2314
2315     # if pinned activity was scheduled for deletion, we reschedule it for deletion
2316     if data["expires_at"] do
2317       # MRF.ActivityExpirationPolicy used UTC timestamps for expires_at in original implementation
2318       {:ok, expires_at} =
2319         data["expires_at"] |> Pleroma.EctoType.ActivityPub.ObjectValidators.DateTime.cast()
2320
2321       Pleroma.Workers.PurgeExpiredActivity.enqueue(%{
2322         activity_id: id,
2323         expires_at: expires_at
2324       })
2325     end
2326
2327     user
2328     |> cast(params, [:pinned_activities])
2329     |> update_and_set_cache()
2330   end
2331
2332   def update_email_notifications(user, settings) do
2333     email_notifications =
2334       user.email_notifications
2335       |> Map.merge(settings)
2336       |> Map.take(["digest"])
2337
2338     params = %{email_notifications: email_notifications}
2339     fields = [:email_notifications]
2340
2341     user
2342     |> cast(params, fields)
2343     |> validate_required(fields)
2344     |> update_and_set_cache()
2345   end
2346
2347   defp set_domain_blocks(user, domain_blocks) do
2348     params = %{domain_blocks: domain_blocks}
2349
2350     user
2351     |> cast(params, [:domain_blocks])
2352     |> validate_required([:domain_blocks])
2353     |> update_and_set_cache()
2354   end
2355
2356   def block_domain(user, domain_blocked) do
2357     set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2358   end
2359
2360   def unblock_domain(user, domain_blocked) do
2361     set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2362   end
2363
2364   @spec add_to_block(User.t(), User.t()) ::
2365           {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2366   defp add_to_block(%User{} = user, %User{} = blocked) do
2367     with {:ok, relationship} <- UserRelationship.create_block(user, blocked) do
2368       Cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
2369       {:ok, relationship}
2370     end
2371   end
2372
2373   @spec add_to_block(User.t(), User.t()) ::
2374           {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2375   defp remove_from_block(%User{} = user, %User{} = blocked) do
2376     with {:ok, relationship} <- UserRelationship.delete_block(user, blocked) do
2377       Cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
2378       {:ok, relationship}
2379     end
2380   end
2381
2382   def set_invisible(user, invisible) do
2383     params = %{invisible: invisible}
2384
2385     user
2386     |> cast(params, [:invisible])
2387     |> validate_required([:invisible])
2388     |> update_and_set_cache()
2389   end
2390
2391   def sanitize_html(%User{} = user) do
2392     sanitize_html(user, nil)
2393   end
2394
2395   # User data that mastodon isn't filtering (treated as plaintext):
2396   # - field name
2397   # - display name
2398   def sanitize_html(%User{} = user, filter) do
2399     fields =
2400       Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2401         %{
2402           "name" => name,
2403           "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2404         }
2405       end)
2406
2407     user
2408     |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2409     |> Map.put(:fields, fields)
2410   end
2411
2412   def get_host(%User{ap_id: ap_id} = _user) do
2413     URI.parse(ap_id).host
2414   end
2415 end