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

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