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