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