git.squeep.com Git - akkoma/blob - lib/pleroma/user.ex

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