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