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