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