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