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