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