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(:is_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         :is_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         :is_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         :is_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         :is_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   defp autofollowing_users(user) do
 769     candidates = Config.get([:instance, :autofollowing_nicknames])
 770
 771     User.Query.build(%{nickname: candidates, local: true, deactivated: false})
 772     |> Repo.all()
 773     |> Enum.each(&follow(&1, user, :follow_accept))
 774
 775     {:ok, :success}
 776   end
 777
 778   @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
 779   def register(%Ecto.Changeset{} = changeset) do
 780     with {:ok, user} <- Repo.insert(changeset) do
 781       post_register_action(user)
 782     end
 783   end
 784
 785   def post_register_action(%User{} = user) do
 786     with {:ok, user} <- autofollow_users(user),
 787          {:ok, _} <- autofollowing_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),
 792          {:ok, _} <- try_send_confirmation_email(user) do
 793       {:ok, user}
 794     end
 795   end
 796
 797   def send_welcome_message(user) do
 798     if User.WelcomeMessage.enabled?() do
 799       User.WelcomeMessage.post_message(user)
 800       {:ok, :enqueued}
 801     else
 802       {:ok, :noop}
 803     end
 804   end
 805
 806   def send_welcome_chat_message(user) do
 807     if User.WelcomeChatMessage.enabled?() do
 808       User.WelcomeChatMessage.post_message(user)
 809       {:ok, :enqueued}
 810     else
 811       {:ok, :noop}
 812     end
 813   end
 814
 815   def send_welcome_email(%User{email: email} = user) when is_binary(email) do
 816     if User.WelcomeEmail.enabled?() do
 817       User.WelcomeEmail.send_email(user)
 818       {:ok, :enqueued}
 819     else
 820       {:ok, :noop}
 821     end
 822   end
 823
 824   def send_welcome_email(_), do: {:ok, :noop}
 825
 826   @spec try_send_confirmation_email(User.t()) :: {:ok, :enqueued | :noop}
 827   def try_send_confirmation_email(%User{confirmation_pending: true, email: email} = user)
 828       when is_binary(email) do
 829     if Config.get([:instance, :account_activation_required]) do
 830       send_confirmation_email(user)
 831       {:ok, :enqueued}
 832     else
 833       {:ok, :noop}
 834     end
 835   end
 836
 837   def try_send_confirmation_email(_), do: {:ok, :noop}
 838
 839   @spec send_confirmation_email(Uset.t()) :: User.t()
 840   def send_confirmation_email(%User{} = user) do
 841     user
 842     |> Pleroma.Emails.UserEmail.account_confirmation_email()
 843     |> Pleroma.Emails.Mailer.deliver_async()
 844
 845     user
 846   end
 847
 848   def needs_update?(%User{local: true}), do: false
 849
 850   def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
 851
 852   def needs_update?(%User{local: false} = user) do
 853     NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
 854   end
 855
 856   def needs_update?(_), do: true
 857
 858   @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
 859
 860   # "Locked" (self-locked) users demand explicit authorization of follow requests
 861   def maybe_direct_follow(%User{} = follower, %User{local: true, is_locked: true} = followed) do
 862     follow(follower, followed, :follow_pending)
 863   end
 864
 865   def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
 866     follow(follower, followed)
 867   end
 868
 869   def maybe_direct_follow(%User{} = follower, %User{} = followed) do
 870     if not ap_enabled?(followed) do
 871       follow(follower, followed)
 872     else
 873       {:ok, follower}
 874     end
 875   end
 876
 877   @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
 878   @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
 879   def follow_all(follower, followeds) do
 880     followeds
 881     |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
 882     |> Enum.each(&follow(follower, &1, :follow_accept))
 883
 884     set_cache(follower)
 885   end
 886
 887   def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
 888     deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
 889
 890     cond do
 891       followed.deactivated ->
 892         {:error, "Could not follow user: #{followed.nickname} is deactivated."}
 893
 894       deny_follow_blocked and blocks?(followed, follower) ->
 895         {:error, "Could not follow user: #{followed.nickname} blocked you."}
 896
 897       true ->
 898         FollowingRelationship.follow(follower, followed, state)
 899
 900         {:ok, _} = update_follower_count(followed)
 901
 902         follower
 903         |> update_following_count()
 904     end
 905   end
 906
 907   def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
 908     {:error, "Not subscribed!"}
 909   end
 910
 911   @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
 912   def unfollow(%User{} = follower, %User{} = followed) do
 913     case do_unfollow(follower, followed) do
 914       {:ok, follower, followed} ->
 915         {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
 916
 917       error ->
 918         error
 919     end
 920   end
 921
 922   @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
 923   defp do_unfollow(%User{} = follower, %User{} = followed) do
 924     case get_follow_state(follower, followed) do
 925       state when state in [:follow_pending, :follow_accept] ->
 926         FollowingRelationship.unfollow(follower, followed)
 927         {:ok, followed} = update_follower_count(followed)
 928
 929         {:ok, follower} = update_following_count(follower)
 930
 931         {:ok, follower, followed}
 932
 933       nil ->
 934         {:error, "Not subscribed!"}
 935     end
 936   end
 937
 938   @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
 939   def get_follow_state(%User{} = follower, %User{} = following) do
 940     following_relationship = FollowingRelationship.get(follower, following)
 941     get_follow_state(follower, following, following_relationship)
 942   end
 943
 944   def get_follow_state(
 945         %User{} = follower,
 946         %User{} = following,
 947         following_relationship
 948       ) do
 949     case {following_relationship, following.local} do
 950       {nil, false} ->
 951         case Utils.fetch_latest_follow(follower, following) do
 952           %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
 953             FollowingRelationship.state_to_enum(state)
 954
 955           _ ->
 956             nil
 957         end
 958
 959       {%{state: state}, _} ->
 960         state
 961
 962       {nil, _} ->
 963         nil
 964     end
 965   end
 966
 967   def locked?(%User{} = user) do
 968     user.is_locked || false
 969   end
 970
 971   def get_by_id(id) do
 972     Repo.get_by(User, id: id)
 973   end
 974
 975   def get_by_ap_id(ap_id) do
 976     Repo.get_by(User, ap_id: ap_id)
 977   end
 978
 979   def get_all_by_ap_id(ap_ids) do
 980     from(u in __MODULE__,
 981       where: u.ap_id in ^ap_ids
 982     )
 983     |> Repo.all()
 984   end
 985
 986   def get_all_by_ids(ids) do
 987     from(u in __MODULE__, where: u.id in ^ids)
 988     |> Repo.all()
 989   end
 990
 991   # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
 992   # of the ap_id and the domain and tries to get that user
 993   def get_by_guessed_nickname(ap_id) do
 994     domain = URI.parse(ap_id).host
 995     name = List.last(String.split(ap_id, "/"))
 996     nickname = "#{name}@#{domain}"
 997
 998     get_cached_by_nickname(nickname)
 999   end
1000
1001   def set_cache({:ok, user}), do: set_cache(user)
1002   def set_cache({:error, err}), do: {:error, err}
1003
1004   def set_cache(%User{} = user) do
1005     Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1006     Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
1007     Cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
1008     {:ok, user}
1009   end
1010
1011   def update_and_set_cache(struct, params) do
1012     struct
1013     |> update_changeset(params)
1014     |> update_and_set_cache()
1015   end
1016
1017   def update_and_set_cache(changeset) do
1018     with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
1019       set_cache(user)
1020     end
1021   end
1022
1023   def get_user_friends_ap_ids(user) do
1024     from(u in User.get_friends_query(user), select: u.ap_id)
1025     |> Repo.all()
1026   end
1027
1028   @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
1029   def get_cached_user_friends_ap_ids(user) do
1030     Cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
1031       get_user_friends_ap_ids(user)
1032     end)
1033   end
1034
1035   def invalidate_cache(user) do
1036     Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
1037     Cachex.del(:user_cache, "nickname:#{user.nickname}")
1038     Cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
1039   end
1040
1041   @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
1042   def get_cached_by_ap_id(ap_id) do
1043     key = "ap_id:#{ap_id}"
1044
1045     with {:ok, nil} <- Cachex.get(:user_cache, key),
1046          user when not is_nil(user) <- get_by_ap_id(ap_id),
1047          {:ok, true} <- Cachex.put(:user_cache, key, user) do
1048       user
1049     else
1050       {:ok, user} -> user
1051       nil -> nil
1052     end
1053   end
1054
1055   def get_cached_by_id(id) do
1056     key = "id:#{id}"
1057
1058     ap_id =
1059       Cachex.fetch!(:user_cache, key, fn _ ->
1060         user = get_by_id(id)
1061
1062         if user do
1063           Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1064           {:commit, user.ap_id}
1065         else
1066           {:ignore, ""}
1067         end
1068       end)
1069
1070     get_cached_by_ap_id(ap_id)
1071   end
1072
1073   def get_cached_by_nickname(nickname) do
1074     key = "nickname:#{nickname}"
1075
1076     Cachex.fetch!(:user_cache, key, fn ->
1077       case get_or_fetch_by_nickname(nickname) do
1078         {:ok, user} -> {:commit, user}
1079         {:error, _error} -> {:ignore, nil}
1080       end
1081     end)
1082   end
1083
1084   def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
1085     restrict_to_local = Config.get([:instance, :limit_to_local_content])
1086
1087     cond do
1088       is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
1089         get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
1090
1091       restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
1092         get_cached_by_nickname(nickname_or_id)
1093
1094       restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
1095         get_cached_by_nickname(nickname_or_id)
1096
1097       true ->
1098         nil
1099     end
1100   end
1101
1102   @spec get_by_nickname(String.t()) :: User.t() | nil
1103   def get_by_nickname(nickname) do
1104     Repo.get_by(User, nickname: nickname) ||
1105       if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
1106         Repo.get_by(User, nickname: local_nickname(nickname))
1107       end
1108   end
1109
1110   def get_by_email(email), do: Repo.get_by(User, email: email)
1111
1112   def get_by_nickname_or_email(nickname_or_email) do
1113     get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
1114   end
1115
1116   def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
1117
1118   def get_or_fetch_by_nickname(nickname) do
1119     with %User{} = user <- get_by_nickname(nickname) do
1120       {:ok, user}
1121     else
1122       _e ->
1123         with [_nick, _domain] <- String.split(nickname, "@"),
1124              {:ok, user} <- fetch_by_nickname(nickname) do
1125           {:ok, user}
1126         else
1127           _e -> {:error, "not found " <> nickname}
1128         end
1129     end
1130   end
1131
1132   @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1133   def get_followers_query(%User{} = user, nil) do
1134     User.Query.build(%{followers: user, deactivated: false})
1135   end
1136
1137   def get_followers_query(%User{} = user, page) do
1138     user
1139     |> get_followers_query(nil)
1140     |> User.Query.paginate(page, 20)
1141   end
1142
1143   @spec get_followers_query(User.t()) :: Ecto.Query.t()
1144   def get_followers_query(%User{} = user), do: get_followers_query(user, nil)
1145
1146   @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1147   def get_followers(%User{} = user, page \\ nil) do
1148     user
1149     |> get_followers_query(page)
1150     |> Repo.all()
1151   end
1152
1153   @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1154   def get_external_followers(%User{} = user, page \\ nil) do
1155     user
1156     |> get_followers_query(page)
1157     |> User.Query.build(%{external: true})
1158     |> Repo.all()
1159   end
1160
1161   def get_followers_ids(%User{} = user, page \\ nil) do
1162     user
1163     |> get_followers_query(page)
1164     |> select([u], u.id)
1165     |> Repo.all()
1166   end
1167
1168   @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1169   def get_friends_query(%User{} = user, nil) do
1170     User.Query.build(%{friends: user, deactivated: false})
1171   end
1172
1173   def get_friends_query(%User{} = user, page) do
1174     user
1175     |> get_friends_query(nil)
1176     |> User.Query.paginate(page, 20)
1177   end
1178
1179   @spec get_friends_query(User.t()) :: Ecto.Query.t()
1180   def get_friends_query(%User{} = user), do: get_friends_query(user, nil)
1181
1182   def get_friends(%User{} = user, page \\ nil) do
1183     user
1184     |> get_friends_query(page)
1185     |> Repo.all()
1186   end
1187
1188   def get_friends_ap_ids(%User{} = user) do
1189     user
1190     |> get_friends_query(nil)
1191     |> select([u], u.ap_id)
1192     |> Repo.all()
1193   end
1194
1195   def get_friends_ids(%User{} = user, page \\ nil) do
1196     user
1197     |> get_friends_query(page)
1198     |> select([u], u.id)
1199     |> Repo.all()
1200   end
1201
1202   def increase_note_count(%User{} = user) do
1203     User
1204     |> where(id: ^user.id)
1205     |> update([u], inc: [note_count: 1])
1206     |> select([u], u)
1207     |> Repo.update_all([])
1208     |> case do
1209       {1, [user]} -> set_cache(user)
1210       _ -> {:error, user}
1211     end
1212   end
1213
1214   def decrease_note_count(%User{} = user) do
1215     User
1216     |> where(id: ^user.id)
1217     |> update([u],
1218       set: [
1219         note_count: fragment("greatest(0, note_count - 1)")
1220       ]
1221     )
1222     |> select([u], u)
1223     |> Repo.update_all([])
1224     |> case do
1225       {1, [user]} -> set_cache(user)
1226       _ -> {:error, user}
1227     end
1228   end
1229
1230   def update_note_count(%User{} = user, note_count \\ nil) do
1231     note_count =
1232       note_count ||
1233         from(
1234           a in Object,
1235           where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1236           select: count(a.id)
1237         )
1238         |> Repo.one()
1239
1240     user
1241     |> cast(%{note_count: note_count}, [:note_count])
1242     |> update_and_set_cache()
1243   end
1244
1245   @spec maybe_fetch_follow_information(User.t()) :: User.t()
1246   def maybe_fetch_follow_information(user) do
1247     with {:ok, user} <- fetch_follow_information(user) do
1248       user
1249     else
1250       e ->
1251         Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1252
1253         user
1254     end
1255   end
1256
1257   def fetch_follow_information(user) do
1258     with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1259       user
1260       |> follow_information_changeset(info)
1261       |> update_and_set_cache()
1262     end
1263   end
1264
1265   defp follow_information_changeset(user, params) do
1266     user
1267     |> cast(params, [
1268       :hide_followers,
1269       :hide_follows,
1270       :follower_count,
1271       :following_count,
1272       :hide_followers_count,
1273       :hide_follows_count
1274     ])
1275   end
1276
1277   @spec update_follower_count(User.t()) :: {:ok, User.t()}
1278   def update_follower_count(%User{} = user) do
1279     if user.local or !Config.get([:instance, :external_user_synchronization]) do
1280       follower_count = FollowingRelationship.follower_count(user)
1281
1282       user
1283       |> follow_information_changeset(%{follower_count: follower_count})
1284       |> update_and_set_cache
1285     else
1286       {:ok, maybe_fetch_follow_information(user)}
1287     end
1288   end
1289
1290   @spec update_following_count(User.t()) :: {:ok, User.t()}
1291   def update_following_count(%User{local: false} = user) do
1292     if Config.get([:instance, :external_user_synchronization]) do
1293       {:ok, maybe_fetch_follow_information(user)}
1294     else
1295       {:ok, user}
1296     end
1297   end
1298
1299   def update_following_count(%User{local: true} = user) do
1300     following_count = FollowingRelationship.following_count(user)
1301
1302     user
1303     |> follow_information_changeset(%{following_count: following_count})
1304     |> update_and_set_cache()
1305   end
1306
1307   def set_unread_conversation_count(%User{local: true} = user) do
1308     unread_query = Participation.unread_conversation_count_for_user(user)
1309
1310     User
1311     |> join(:inner, [u], p in subquery(unread_query))
1312     |> update([u, p],
1313       set: [unread_conversation_count: p.count]
1314     )
1315     |> where([u], u.id == ^user.id)
1316     |> select([u], u)
1317     |> Repo.update_all([])
1318     |> case do
1319       {1, [user]} -> set_cache(user)
1320       _ -> {:error, user}
1321     end
1322   end
1323
1324   def set_unread_conversation_count(user), do: {:ok, user}
1325
1326   def increment_unread_conversation_count(conversation, %User{local: true} = user) do
1327     unread_query =
1328       Participation.unread_conversation_count_for_user(user)
1329       |> where([p], p.conversation_id == ^conversation.id)
1330
1331     User
1332     |> join(:inner, [u], p in subquery(unread_query))
1333     |> update([u, p],
1334       inc: [unread_conversation_count: 1]
1335     )
1336     |> where([u], u.id == ^user.id)
1337     |> where([u, p], p.count == 0)
1338     |> select([u], u)
1339     |> Repo.update_all([])
1340     |> case do
1341       {1, [user]} -> set_cache(user)
1342       _ -> {:error, user}
1343     end
1344   end
1345
1346   def increment_unread_conversation_count(_, user), do: {:ok, user}
1347
1348   @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1349   def get_users_from_set(ap_ids, opts \\ []) do
1350     local_only = Keyword.get(opts, :local_only, true)
1351     criteria = %{ap_id: ap_ids, deactivated: false}
1352     criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1353
1354     User.Query.build(criteria)
1355     |> Repo.all()
1356   end
1357
1358   @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1359   def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1360     to = [actor | to]
1361
1362     query = User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
1363
1364     query
1365     |> Repo.all()
1366   end
1367
1368   @spec mute(User.t(), User.t(), boolean()) ::
1369           {:ok, list(UserRelationship.t())} | {:error, String.t()}
1370   def mute(%User{} = muter, %User{} = mutee, notifications? \\ true) do
1371     add_to_mutes(muter, mutee, notifications?)
1372   end
1373
1374   def unmute(%User{} = muter, %User{} = mutee) do
1375     remove_from_mutes(muter, mutee)
1376   end
1377
1378   def subscribe(%User{} = subscriber, %User{} = target) do
1379     deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
1380
1381     if blocks?(target, subscriber) and deny_follow_blocked do
1382       {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1383     else
1384       # Note: the relationship is inverse: subscriber acts as relationship target
1385       UserRelationship.create_inverse_subscription(target, subscriber)
1386     end
1387   end
1388
1389   def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1390     with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1391       subscribe(subscriber, subscribee)
1392     end
1393   end
1394
1395   def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1396     # Note: the relationship is inverse: subscriber acts as relationship target
1397     UserRelationship.delete_inverse_subscription(target, unsubscriber)
1398   end
1399
1400   def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1401     with %User{} = user <- get_cached_by_ap_id(ap_id) do
1402       unsubscribe(unsubscriber, user)
1403     end
1404   end
1405
1406   def block(%User{} = blocker, %User{} = blocked) do
1407     # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1408     blocker =
1409       if following?(blocker, blocked) do
1410         {:ok, blocker, _} = unfollow(blocker, blocked)
1411         blocker
1412       else
1413         blocker
1414       end
1415
1416     # clear any requested follows as well
1417     blocked =
1418       case CommonAPI.reject_follow_request(blocked, blocker) do
1419         {:ok, %User{} = updated_blocked} -> updated_blocked
1420         nil -> blocked
1421       end
1422
1423     unsubscribe(blocked, blocker)
1424
1425     unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
1426     if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)
1427
1428     {:ok, blocker} = update_follower_count(blocker)
1429     {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1430     add_to_block(blocker, blocked)
1431   end
1432
1433   # helper to handle the block given only an actor's AP id
1434   def block(%User{} = blocker, %{ap_id: ap_id}) do
1435     block(blocker, get_cached_by_ap_id(ap_id))
1436   end
1437
1438   def unblock(%User{} = blocker, %User{} = blocked) do
1439     remove_from_block(blocker, blocked)
1440   end
1441
1442   # helper to handle the block given only an actor's AP id
1443   def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1444     unblock(blocker, get_cached_by_ap_id(ap_id))
1445   end
1446
1447   def mutes?(nil, _), do: false
1448   def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1449
1450   def mutes_user?(%User{} = user, %User{} = target) do
1451     UserRelationship.mute_exists?(user, target)
1452   end
1453
1454   @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1455   def muted_notifications?(nil, _), do: false
1456
1457   def muted_notifications?(%User{} = user, %User{} = target),
1458     do: UserRelationship.notification_mute_exists?(user, target)
1459
1460   def blocks?(nil, _), do: false
1461
1462   def blocks?(%User{} = user, %User{} = target) do
1463     blocks_user?(user, target) ||
1464       (blocks_domain?(user, target) and not User.following?(user, target))
1465   end
1466
1467   def blocks_user?(%User{} = user, %User{} = target) do
1468     UserRelationship.block_exists?(user, target)
1469   end
1470
1471   def blocks_user?(_, _), do: false
1472
1473   def blocks_domain?(%User{} = user, %User{} = target) do
1474     domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1475     %{host: host} = URI.parse(target.ap_id)
1476     Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1477   end
1478
1479   def blocks_domain?(_, _), do: false
1480
1481   def subscribed_to?(%User{} = user, %User{} = target) do
1482     # Note: the relationship is inverse: subscriber acts as relationship target
1483     UserRelationship.inverse_subscription_exists?(target, user)
1484   end
1485
1486   def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1487     with %User{} = target <- get_cached_by_ap_id(ap_id) do
1488       subscribed_to?(user, target)
1489     end
1490   end
1491
1492   @doc """
1493   Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1494   E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1495   """
1496   @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1497   def outgoing_relationships_ap_ids(_user, []), do: %{}
1498
1499   def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1500
1501   def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1502       when is_list(relationship_types) do
1503     db_result =
1504       user
1505       |> assoc(:outgoing_relationships)
1506       |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1507       |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1508       |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1509       |> group_by([user_rel, u], user_rel.relationship_type)
1510       |> Repo.all()
1511       |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1512
1513     Enum.into(
1514       relationship_types,
1515       %{},
1516       fn rel_type -> {rel_type, db_result[rel_type] || []} end
1517     )
1518   end
1519
1520   def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1521
1522   def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1523
1524   def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1525
1526   def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1527       when is_list(relationship_types) do
1528     user
1529     |> assoc(:incoming_relationships)
1530     |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1531     |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1532     |> maybe_filter_on_ap_id(ap_ids)
1533     |> select([user_rel, u], u.ap_id)
1534     |> distinct(true)
1535     |> Repo.all()
1536   end
1537
1538   defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1539     where(query, [user_rel, u], u.ap_id in ^ap_ids)
1540   end
1541
1542   defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1543
1544   def deactivate_async(user, status \\ true) do
1545     BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
1546   end
1547
1548   def deactivate(user, status \\ true)
1549
1550   def deactivate(users, status) when is_list(users) do
1551     Repo.transaction(fn ->
1552       for user <- users, do: deactivate(user, status)
1553     end)
1554   end
1555
1556   def deactivate(%User{} = user, status) do
1557     with {:ok, user} <- set_activation_status(user, status) do
1558       user
1559       |> get_followers()
1560       |> Enum.filter(& &1.local)
1561       |> Enum.each(&set_cache(update_following_count(&1)))
1562
1563       # Only update local user counts, remote will be update during the next pull.
1564       user
1565       |> get_friends()
1566       |> Enum.filter(& &1.local)
1567       |> Enum.each(&do_unfollow(user, &1))
1568
1569       {:ok, user}
1570     end
1571   end
1572
1573   def approve(users) when is_list(users) do
1574     Repo.transaction(fn ->
1575       Enum.map(users, fn user ->
1576         with {:ok, user} <- approve(user), do: user
1577       end)
1578     end)
1579   end
1580
1581   def approve(%User{} = user) do
1582     change(user, approval_pending: false)
1583     |> update_and_set_cache()
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       is_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       is_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