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(changeset) do
1093     with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
1094       set_cache(user)
1095     end
1096   end
1097
1098   def get_user_friends_ap_ids(user) do
1099     from(u in User.get_friends_query(user), select: u.ap_id)
1100     |> Repo.all()
1101   end
1102
1103   @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
1104   def get_cached_user_friends_ap_ids(user) do
1105     @cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
1106       get_user_friends_ap_ids(user)
1107     end)
1108   end
1109
1110   def invalidate_cache(user) do
1111     @cachex.del(:user_cache, "ap_id:#{user.ap_id}")
1112     @cachex.del(:user_cache, "nickname:#{user.nickname}")
1113     @cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
1114     @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
1115     @cachex.del(:user_cache, "muted_users_ap_ids:#{user.ap_id}")
1116   end
1117
1118   @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
1119   def get_cached_by_ap_id(ap_id) do
1120     key = "ap_id:#{ap_id}"
1121
1122     with {:ok, nil} <- @cachex.get(:user_cache, key),
1123          user when not is_nil(user) <- get_by_ap_id(ap_id),
1124          {:ok, true} <- @cachex.put(:user_cache, key, user) do
1125       user
1126     else
1127       {:ok, user} -> user
1128       nil -> nil
1129     end
1130   end
1131
1132   def get_cached_by_id(id) do
1133     key = "id:#{id}"
1134
1135     ap_id =
1136       @cachex.fetch!(:user_cache, key, fn _ ->
1137         user = get_by_id(id)
1138
1139         if user do
1140           @cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1141           {:commit, user.ap_id}
1142         else
1143           {:ignore, ""}
1144         end
1145       end)
1146
1147     get_cached_by_ap_id(ap_id)
1148   end
1149
1150   def get_cached_by_nickname(nickname) do
1151     key = "nickname:#{nickname}"
1152
1153     @cachex.fetch!(:user_cache, key, fn _ ->
1154       case get_or_fetch_by_nickname(nickname) do
1155         {:ok, user} -> {:commit, user}
1156         {:error, _error} -> {:ignore, nil}
1157       end
1158     end)
1159   end
1160
1161   def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
1162     restrict_to_local = Config.get([:instance, :limit_to_local_content])
1163
1164     cond do
1165       is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
1166         get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
1167
1168       restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
1169         get_cached_by_nickname(nickname_or_id)
1170
1171       restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
1172         get_cached_by_nickname(nickname_or_id)
1173
1174       true ->
1175         nil
1176     end
1177   end
1178
1179   @spec get_by_nickname(String.t()) :: User.t() | nil
1180   def get_by_nickname(nickname) do
1181     Repo.get_by(User, nickname: nickname) ||
1182       if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
1183         Repo.get_by(User, nickname: local_nickname(nickname))
1184       end
1185   end
1186
1187   def get_by_email(email), do: Repo.get_by(User, email: email)
1188
1189   def get_by_nickname_or_email(nickname_or_email) do
1190     get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
1191   end
1192
1193   def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
1194
1195   def get_or_fetch_by_nickname(nickname) do
1196     with %User{} = user <- get_by_nickname(nickname) do
1197       {:ok, user}
1198     else
1199       _e ->
1200         with [_nick, _domain] <- String.split(nickname, "@"),
1201              {:ok, user} <- fetch_by_nickname(nickname) do
1202           {:ok, user}
1203         else
1204           _e -> {:error, "not found " <> nickname}
1205         end
1206     end
1207   end
1208
1209   @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1210   def get_followers_query(%User{} = user, nil) do
1211     User.Query.build(%{followers: user, is_active: true})
1212   end
1213
1214   def get_followers_query(%User{} = user, page) do
1215     user
1216     |> get_followers_query(nil)
1217     |> User.Query.paginate(page, 20)
1218   end
1219
1220   @spec get_followers_query(User.t()) :: Ecto.Query.t()
1221   def get_followers_query(%User{} = user), do: get_followers_query(user, nil)
1222
1223   @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1224   def get_followers(%User{} = user, page \\ nil) do
1225     user
1226     |> get_followers_query(page)
1227     |> Repo.all()
1228   end
1229
1230   @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1231   def get_external_followers(%User{} = user, page \\ nil) do
1232     user
1233     |> get_followers_query(page)
1234     |> User.Query.build(%{external: true})
1235     |> Repo.all()
1236   end
1237
1238   def get_followers_ids(%User{} = user, page \\ nil) do
1239     user
1240     |> get_followers_query(page)
1241     |> select([u], u.id)
1242     |> Repo.all()
1243   end
1244
1245   @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1246   def get_friends_query(%User{} = user, nil) do
1247     User.Query.build(%{friends: user, deactivated: false})
1248   end
1249
1250   def get_friends_query(%User{} = user, page) do
1251     user
1252     |> get_friends_query(nil)
1253     |> User.Query.paginate(page, 20)
1254   end
1255
1256   @spec get_friends_query(User.t()) :: Ecto.Query.t()
1257   def get_friends_query(%User{} = user), do: get_friends_query(user, nil)
1258
1259   def get_friends(%User{} = user, page \\ nil) do
1260     user
1261     |> get_friends_query(page)
1262     |> Repo.all()
1263   end
1264
1265   def get_friends_ap_ids(%User{} = user) do
1266     user
1267     |> get_friends_query(nil)
1268     |> select([u], u.ap_id)
1269     |> Repo.all()
1270   end
1271
1272   def get_friends_ids(%User{} = user, page \\ nil) do
1273     user
1274     |> get_friends_query(page)
1275     |> select([u], u.id)
1276     |> Repo.all()
1277   end
1278
1279   def increase_note_count(%User{} = user) do
1280     User
1281     |> where(id: ^user.id)
1282     |> update([u], inc: [note_count: 1])
1283     |> select([u], u)
1284     |> Repo.update_all([])
1285     |> case do
1286       {1, [user]} -> set_cache(user)
1287       _ -> {:error, user}
1288     end
1289   end
1290
1291   def decrease_note_count(%User{} = user) do
1292     User
1293     |> where(id: ^user.id)
1294     |> update([u],
1295       set: [
1296         note_count: fragment("greatest(0, note_count - 1)")
1297       ]
1298     )
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 update_note_count(%User{} = user, note_count \\ nil) do
1308     note_count =
1309       note_count ||
1310         from(
1311           a in Object,
1312           where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1313           select: count(a.id)
1314         )
1315         |> Repo.one()
1316
1317     user
1318     |> cast(%{note_count: note_count}, [:note_count])
1319     |> update_and_set_cache()
1320   end
1321
1322   @spec maybe_fetch_follow_information(User.t()) :: User.t()
1323   def maybe_fetch_follow_information(user) do
1324     with {:ok, user} <- fetch_follow_information(user) do
1325       user
1326     else
1327       e ->
1328         Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1329
1330         user
1331     end
1332   end
1333
1334   def fetch_follow_information(user) do
1335     with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1336       user
1337       |> follow_information_changeset(info)
1338       |> update_and_set_cache()
1339     end
1340   end
1341
1342   defp follow_information_changeset(user, params) do
1343     user
1344     |> cast(params, [
1345       :hide_followers,
1346       :hide_follows,
1347       :follower_count,
1348       :following_count,
1349       :hide_followers_count,
1350       :hide_follows_count
1351     ])
1352   end
1353
1354   @spec update_follower_count(User.t()) :: {:ok, User.t()}
1355   def update_follower_count(%User{} = user) do
1356     if user.local or !Config.get([:instance, :external_user_synchronization]) do
1357       follower_count = FollowingRelationship.follower_count(user)
1358
1359       user
1360       |> follow_information_changeset(%{follower_count: follower_count})
1361       |> update_and_set_cache
1362     else
1363       {:ok, maybe_fetch_follow_information(user)}
1364     end
1365   end
1366
1367   @spec update_following_count(User.t()) :: {:ok, User.t()}
1368   def update_following_count(%User{local: false} = user) do
1369     if Config.get([:instance, :external_user_synchronization]) do
1370       {:ok, maybe_fetch_follow_information(user)}
1371     else
1372       {:ok, user}
1373     end
1374   end
1375
1376   def update_following_count(%User{local: true} = user) do
1377     following_count = FollowingRelationship.following_count(user)
1378
1379     user
1380     |> follow_information_changeset(%{following_count: following_count})
1381     |> update_and_set_cache()
1382   end
1383
1384   @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1385   def get_users_from_set(ap_ids, opts \\ []) do
1386     local_only = Keyword.get(opts, :local_only, true)
1387     criteria = %{ap_id: ap_ids, is_active: true}
1388     criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1389
1390     User.Query.build(criteria)
1391     |> Repo.all()
1392   end
1393
1394   @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1395   def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1396     to = [actor | to]
1397
1398     query = User.Query.build(%{recipients_from_activity: to, local: true, is_active: true})
1399
1400     query
1401     |> Repo.all()
1402   end
1403
1404   @spec mute(User.t(), User.t(), map()) ::
1405           {:ok, list(UserRelationship.t())} | {:error, String.t()}
1406   def mute(%User{} = muter, %User{} = mutee, params \\ %{}) do
1407     notifications? = Map.get(params, :notifications, true)
1408     expires_in = Map.get(params, :expires_in, 0)
1409
1410     with {:ok, user_mute} <- UserRelationship.create_mute(muter, mutee),
1411          {:ok, user_notification_mute} <-
1412            (notifications? && UserRelationship.create_notification_mute(muter, mutee)) ||
1413              {:ok, nil} do
1414       if expires_in > 0 do
1415         Pleroma.Workers.MuteExpireWorker.enqueue(
1416           "unmute_user",
1417           %{"muter_id" => muter.id, "mutee_id" => mutee.id},
1418           schedule_in: expires_in
1419         )
1420       end
1421
1422       @cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
1423
1424       {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
1425     end
1426   end
1427
1428   def unmute(%User{} = muter, %User{} = mutee) do
1429     with {:ok, user_mute} <- UserRelationship.delete_mute(muter, mutee),
1430          {:ok, user_notification_mute} <-
1431            UserRelationship.delete_notification_mute(muter, mutee) do
1432       @cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
1433       {:ok, [user_mute, user_notification_mute]}
1434     end
1435   end
1436
1437   def unmute(muter_id, mutee_id) do
1438     with {:muter, %User{} = muter} <- {:muter, User.get_by_id(muter_id)},
1439          {:mutee, %User{} = mutee} <- {:mutee, User.get_by_id(mutee_id)} do
1440       unmute(muter, mutee)
1441     else
1442       {who, result} = error ->
1443         Logger.warn(
1444           "User.unmute/2 failed. #{who}: #{result}, muter_id: #{muter_id}, mutee_id: #{mutee_id}"
1445         )
1446
1447         {:error, error}
1448     end
1449   end
1450
1451   def subscribe(%User{} = subscriber, %User{} = target) do
1452     deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
1453
1454     if blocks?(target, subscriber) and deny_follow_blocked do
1455       {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1456     else
1457       # Note: the relationship is inverse: subscriber acts as relationship target
1458       UserRelationship.create_inverse_subscription(target, subscriber)
1459     end
1460   end
1461
1462   def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1463     with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1464       subscribe(subscriber, subscribee)
1465     end
1466   end
1467
1468   def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1469     # Note: the relationship is inverse: subscriber acts as relationship target
1470     UserRelationship.delete_inverse_subscription(target, unsubscriber)
1471   end
1472
1473   def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1474     with %User{} = user <- get_cached_by_ap_id(ap_id) do
1475       unsubscribe(unsubscriber, user)
1476     end
1477   end
1478
1479   def block(%User{} = blocker, %User{} = blocked) do
1480     # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1481     blocker =
1482       if following?(blocker, blocked) do
1483         {:ok, blocker, _} = unfollow(blocker, blocked)
1484         blocker
1485       else
1486         blocker
1487       end
1488
1489     # clear any requested follows as well
1490     blocked =
1491       case CommonAPI.reject_follow_request(blocked, blocker) do
1492         {:ok, %User{} = updated_blocked} -> updated_blocked
1493         nil -> blocked
1494       end
1495
1496     unsubscribe(blocked, blocker)
1497
1498     unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
1499     if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)
1500
1501     {:ok, blocker} = update_follower_count(blocker)
1502     {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1503     add_to_block(blocker, blocked)
1504   end
1505
1506   # helper to handle the block given only an actor's AP id
1507   def block(%User{} = blocker, %{ap_id: ap_id}) do
1508     block(blocker, get_cached_by_ap_id(ap_id))
1509   end
1510
1511   def unblock(%User{} = blocker, %User{} = blocked) do
1512     remove_from_block(blocker, blocked)
1513   end
1514
1515   # helper to handle the block given only an actor's AP id
1516   def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1517     unblock(blocker, get_cached_by_ap_id(ap_id))
1518   end
1519
1520   def mutes?(nil, _), do: false
1521   def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1522
1523   def mutes_user?(%User{} = user, %User{} = target) do
1524     UserRelationship.mute_exists?(user, target)
1525   end
1526
1527   @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1528   def muted_notifications?(nil, _), do: false
1529
1530   def muted_notifications?(%User{} = user, %User{} = target),
1531     do: UserRelationship.notification_mute_exists?(user, target)
1532
1533   def blocks?(nil, _), do: false
1534
1535   def blocks?(%User{} = user, %User{} = target) do
1536     blocks_user?(user, target) ||
1537       (blocks_domain?(user, target) and not User.following?(user, target))
1538   end
1539
1540   def blocks_user?(%User{} = user, %User{} = target) do
1541     UserRelationship.block_exists?(user, target)
1542   end
1543
1544   def blocks_user?(_, _), do: false
1545
1546   def blocks_domain?(%User{} = user, %User{} = target) do
1547     domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1548     %{host: host} = URI.parse(target.ap_id)
1549     Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1550   end
1551
1552   def blocks_domain?(_, _), do: false
1553
1554   def subscribed_to?(%User{} = user, %User{} = target) do
1555     # Note: the relationship is inverse: subscriber acts as relationship target
1556     UserRelationship.inverse_subscription_exists?(target, user)
1557   end
1558
1559   def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1560     with %User{} = target <- get_cached_by_ap_id(ap_id) do
1561       subscribed_to?(user, target)
1562     end
1563   end
1564
1565   @doc """
1566   Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1567   E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1568   """
1569   @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1570   def outgoing_relationships_ap_ids(_user, []), do: %{}
1571
1572   def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1573
1574   def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1575       when is_list(relationship_types) do
1576     db_result =
1577       user
1578       |> assoc(:outgoing_relationships)
1579       |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1580       |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1581       |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1582       |> group_by([user_rel, u], user_rel.relationship_type)
1583       |> Repo.all()
1584       |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1585
1586     Enum.into(
1587       relationship_types,
1588       %{},
1589       fn rel_type -> {rel_type, db_result[rel_type] || []} end
1590     )
1591   end
1592
1593   def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1594
1595   def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1596
1597   def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1598
1599   def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1600       when is_list(relationship_types) do
1601     user
1602     |> assoc(:incoming_relationships)
1603     |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1604     |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1605     |> maybe_filter_on_ap_id(ap_ids)
1606     |> select([user_rel, u], u.ap_id)
1607     |> distinct(true)
1608     |> Repo.all()
1609   end
1610
1611   defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1612     where(query, [user_rel, u], u.ap_id in ^ap_ids)
1613   end
1614
1615   defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1616
1617   def set_activation_async(user, status \\ true) do
1618     BackgroundWorker.enqueue("user_activation", %{"user_id" => user.id, "status" => status})
1619   end
1620
1621   @spec set_activation([User.t()], boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
1622   def set_activation(users, status) when is_list(users) do
1623     Repo.transaction(fn ->
1624       for user <- users, do: set_activation(user, status)
1625     end)
1626   end
1627
1628   @spec set_activation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
1629   def set_activation(%User{} = user, status) do
1630     with {:ok, user} <- set_activation_status(user, status) do
1631       user
1632       |> get_followers()
1633       |> Enum.filter(& &1.local)
1634       |> Enum.each(&set_cache(update_following_count(&1)))
1635
1636       # Only update local user counts, remote will be update during the next pull.
1637       user
1638       |> get_friends()
1639       |> Enum.filter(& &1.local)
1640       |> Enum.each(&do_unfollow(user, &1))
1641
1642       {:ok, user}
1643     end
1644   end
1645
1646   def approve(users) when is_list(users) do
1647     Repo.transaction(fn ->
1648       Enum.map(users, fn user ->
1649         with {:ok, user} <- approve(user), do: user
1650       end)
1651     end)
1652   end
1653
1654   def approve(%User{is_approved: false} = user) do
1655     with chg <- change(user, is_approved: true),
1656          {:ok, user} <- update_and_set_cache(chg) do
1657       post_register_action(user)
1658       {:ok, user}
1659     end
1660   end
1661
1662   def approve(%User{} = user), do: {:ok, user}
1663
1664   def confirm(users) when is_list(users) do
1665     Repo.transaction(fn ->
1666       Enum.map(users, fn user ->
1667         with {:ok, user} <- confirm(user), do: user
1668       end)
1669     end)
1670   end
1671
1672   def confirm(%User{is_confirmed: false} = user) do
1673     with chg <- confirmation_changeset(user, set_confirmation: true),
1674          {:ok, user} <- update_and_set_cache(chg) do
1675       post_register_action(user)
1676       {:ok, user}
1677     end
1678   end
1679
1680   def confirm(%User{} = user), do: {:ok, user}
1681
1682   def set_suggestion(users, is_suggested) when is_list(users) do
1683     Repo.transaction(fn ->
1684       Enum.map(users, fn user ->
1685         with {:ok, user} <- set_suggestion(user, is_suggested), do: user
1686       end)
1687     end)
1688   end
1689
1690   def set_suggestion(%User{is_suggested: is_suggested} = user, is_suggested), do: {:ok, user}
1691
1692   def set_suggestion(%User{} = user, is_suggested) when is_boolean(is_suggested) do
1693     user
1694     |> change(is_suggested: is_suggested)
1695     |> update_and_set_cache()
1696   end
1697
1698   def update_notification_settings(%User{} = user, settings) do
1699     user
1700     |> cast(%{notification_settings: settings}, [])
1701     |> cast_embed(:notification_settings)
1702     |> validate_required([:notification_settings])
1703     |> update_and_set_cache()
1704   end
1705
1706   @spec purge_user_changeset(User.t()) :: Changeset.t()
1707   def purge_user_changeset(user) do
1708     # "Right to be forgotten"
1709     # https://gdpr.eu/right-to-be-forgotten/
1710     change(user, %{
1711       bio: "",
1712       raw_bio: nil,
1713       email: nil,
1714       name: nil,
1715       password_hash: nil,
1716       avatar: %{},
1717       tags: [],
1718       last_refreshed_at: nil,
1719       last_digest_emailed_at: nil,
1720       banner: %{},
1721       background: %{},
1722       note_count: 0,
1723       follower_count: 0,
1724       following_count: 0,
1725       is_locked: false,
1726       password_reset_pending: false,
1727       registration_reason: nil,
1728       confirmation_token: nil,
1729       domain_blocks: [],
1730       is_active: false,
1731       ap_enabled: false,
1732       is_moderator: false,
1733       is_admin: false,
1734       mastofe_settings: nil,
1735       mascot: nil,
1736       emoji: %{},
1737       pleroma_settings_store: %{},
1738       fields: [],
1739       raw_fields: [],
1740       is_discoverable: false,
1741       also_known_as: []
1742       # id: preserved
1743       # ap_id: preserved
1744       # nickname: preserved
1745     })
1746   end
1747
1748   # Purge doesn't delete the user from the database.
1749   # It just nulls all its fields and deactivates it.
1750   # See `User.purge_user_changeset/1` above.
1751   defp purge(%User{} = user) do
1752     user
1753     |> purge_user_changeset()
1754     |> update_and_set_cache()
1755   end
1756
1757   def delete(users) when is_list(users) do
1758     for user <- users, do: delete(user)
1759   end
1760
1761   def delete(%User{} = user) do
1762     # Purge the user immediately
1763     purge(user)
1764     BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1765   end
1766
1767   # *Actually* delete the user from the DB
1768   defp delete_from_db(%User{} = user) do
1769     invalidate_cache(user)
1770     Repo.delete(user)
1771   end
1772
1773   # If the user never finalized their account, it's safe to delete them.
1774   defp maybe_delete_from_db(%User{local: true, is_confirmed: false} = user),
1775     do: delete_from_db(user)
1776
1777   defp maybe_delete_from_db(%User{local: true, is_approved: false} = user),
1778     do: delete_from_db(user)
1779
1780   defp maybe_delete_from_db(user), do: {:ok, user}
1781
1782   def perform(:force_password_reset, user), do: force_password_reset(user)
1783
1784   @spec perform(atom(), User.t()) :: {:ok, User.t()}
1785   def perform(:delete, %User{} = user) do
1786     # Purge the user again, in case perform/2 is called directly
1787     purge(user)
1788
1789     # Remove all relationships
1790     user
1791     |> get_followers()
1792     |> Enum.each(fn follower ->
1793       ActivityPub.unfollow(follower, user)
1794       unfollow(follower, user)
1795     end)
1796
1797     user
1798     |> get_friends()
1799     |> Enum.each(fn followed ->
1800       ActivityPub.unfollow(user, followed)
1801       unfollow(user, followed)
1802     end)
1803
1804     delete_user_activities(user)
1805     delete_notifications_from_user_activities(user)
1806     delete_outgoing_pending_follow_requests(user)
1807
1808     maybe_delete_from_db(user)
1809   end
1810
1811   def perform(:set_activation_async, user, status), do: set_activation(user, status)
1812
1813   @spec external_users_query() :: Ecto.Query.t()
1814   def external_users_query do
1815     User.Query.build(%{
1816       external: true,
1817       active: true,
1818       order_by: :id
1819     })
1820   end
1821
1822   @spec external_users(keyword()) :: [User.t()]
1823   def external_users(opts \\ []) do
1824     query =
1825       external_users_query()
1826       |> select([u], struct(u, [:id, :ap_id]))
1827
1828     query =
1829       if opts[:max_id],
1830         do: where(query, [u], u.id > ^opts[:max_id]),
1831         else: query
1832
1833     query =
1834       if opts[:limit],
1835         do: limit(query, ^opts[:limit]),
1836         else: query
1837
1838     Repo.all(query)
1839   end
1840
1841   def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1842     Notification
1843     |> join(:inner, [n], activity in assoc(n, :activity))
1844     |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1845     |> Repo.delete_all()
1846   end
1847
1848   def delete_user_activities(%User{ap_id: ap_id} = user) do
1849     ap_id
1850     |> Activity.Queries.by_actor()
1851     |> Repo.chunk_stream(50, :batches)
1852     |> Stream.each(fn activities ->
1853       Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1854     end)
1855     |> Stream.run()
1856   end
1857
1858   defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1859     with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1860          {:ok, delete_data, _} <- Builder.delete(user, object) do
1861       Pipeline.common_pipeline(delete_data, local: user.local)
1862     else
1863       {:find_object, nil} ->
1864         # We have the create activity, but not the object, it was probably pruned.
1865         # Insert a tombstone and try again
1866         with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1867              {:ok, _tombstone} <- Object.create(tombstone_data) do
1868           delete_activity(activity, user)
1869         end
1870
1871       e ->
1872         Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1873         Logger.error("Error: #{inspect(e)}")
1874     end
1875   end
1876
1877   defp delete_activity(%{data: %{"type" => type}} = activity, user)
1878        when type in ["Like", "Announce"] do
1879     {:ok, undo, _} = Builder.undo(user, activity)
1880     Pipeline.common_pipeline(undo, local: user.local)
1881   end
1882
1883   defp delete_activity(_activity, _user), do: "Doing nothing"
1884
1885   defp delete_outgoing_pending_follow_requests(user) do
1886     user
1887     |> FollowingRelationship.outgoing_pending_follow_requests_query()
1888     |> Repo.delete_all()
1889   end
1890
1891   def html_filter_policy(%User{no_rich_text: true}) do
1892     Pleroma.HTML.Scrubber.TwitterText
1893   end
1894
1895   def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])
1896
1897   def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1898
1899   def get_or_fetch_by_ap_id(ap_id) do
1900     cached_user = get_cached_by_ap_id(ap_id)
1901
1902     maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)
1903
1904     case {cached_user, maybe_fetched_user} do
1905       {_, {:ok, %User{} = user}} ->
1906         {:ok, user}
1907
1908       {%User{} = user, _} ->
1909         {:ok, user}
1910
1911       _ ->
1912         {:error, :not_found}
1913     end
1914   end
1915
1916   @doc """
1917   Creates an internal service actor by URI if missing.
1918   Optionally takes nickname for addressing.
1919   """
1920   @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1921   def get_or_create_service_actor_by_ap_id(uri, nickname) do
1922     {_, user} =
1923       case get_cached_by_ap_id(uri) do
1924         nil ->
1925           with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1926             Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1927             {:error, nil}
1928           end
1929
1930         %User{invisible: false} = user ->
1931           set_invisible(user)
1932
1933         user ->
1934           {:ok, user}
1935       end
1936
1937     user
1938   end
1939
1940   @spec set_invisible(User.t()) :: {:ok, User.t()}
1941   defp set_invisible(user) do
1942     user
1943     |> change(%{invisible: true})
1944     |> update_and_set_cache()
1945   end
1946
1947   @spec create_service_actor(String.t(), String.t()) ::
1948           {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1949   defp create_service_actor(uri, nickname) do
1950     %User{
1951       invisible: true,
1952       local: true,
1953       ap_id: uri,
1954       nickname: nickname,
1955       follower_address: uri <> "/followers"
1956     }
1957     |> change
1958     |> unique_constraint(:nickname)
1959     |> Repo.insert()
1960     |> set_cache()
1961   end
1962
1963   def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1964     key =
1965       public_key_pem
1966       |> :public_key.pem_decode()
1967       |> hd()
1968       |> :public_key.pem_entry_decode()
1969
1970     {:ok, key}
1971   end
1972
1973   def public_key(_), do: {:error, "key not found"}
1974
1975   def get_public_key_for_ap_id(ap_id) do
1976     with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1977          {:ok, public_key} <- public_key(user) do
1978       {:ok, public_key}
1979     else
1980       _ -> :error
1981     end
1982   end
1983
1984   def ap_enabled?(%User{local: true}), do: true
1985   def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1986   def ap_enabled?(_), do: false
1987
1988   @doc "Gets or fetch a user by uri or nickname."
1989   @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1990   def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1991   def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1992
1993   # wait a period of time and return newest version of the User structs
1994   # this is because we have synchronous follow APIs and need to simulate them
1995   # with an async handshake
1996   def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1997     with %User{} = a <- get_cached_by_id(a.id),
1998          %User{} = b <- get_cached_by_id(b.id) do
1999       {:ok, a, b}
2000     else
2001       nil -> :error
2002     end
2003   end
2004
2005   def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
2006     with :ok <- :timer.sleep(timeout),
2007          %User{} = a <- get_cached_by_id(a.id),
2008          %User{} = b <- get_cached_by_id(b.id) do
2009       {:ok, a, b}
2010     else
2011       nil -> :error
2012     end
2013   end
2014
2015   def parse_bio(bio) when is_binary(bio) and bio != "" do
2016     bio
2017     |> CommonUtils.format_input("text/plain", mentions_format: :full)
2018     |> elem(0)
2019   end
2020
2021   def parse_bio(_), do: ""
2022
2023   def parse_bio(bio, user) when is_binary(bio) and bio != "" do
2024     # TODO: get profile URLs other than user.ap_id
2025     profile_urls = [user.ap_id]
2026
2027     bio
2028     |> CommonUtils.format_input("text/plain",
2029       mentions_format: :full,
2030       rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
2031     )
2032     |> elem(0)
2033   end
2034
2035   def parse_bio(_, _), do: ""
2036
2037   def tag(user_identifiers, tags) when is_list(user_identifiers) do
2038     Repo.transaction(fn ->
2039       for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
2040     end)
2041   end
2042
2043   def tag(nickname, tags) when is_binary(nickname),
2044     do: tag(get_by_nickname(nickname), tags)
2045
2046   def tag(%User{} = user, tags),
2047     do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
2048
2049   def untag(user_identifiers, tags) when is_list(user_identifiers) do
2050     Repo.transaction(fn ->
2051       for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
2052     end)
2053   end
2054
2055   def untag(nickname, tags) when is_binary(nickname),
2056     do: untag(get_by_nickname(nickname), tags)
2057
2058   def untag(%User{} = user, tags),
2059     do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
2060
2061   defp update_tags(%User{} = user, new_tags) do
2062     {:ok, updated_user} =
2063       user
2064       |> change(%{tags: new_tags})
2065       |> update_and_set_cache()
2066
2067     updated_user
2068   end
2069
2070   defp normalize_tags(tags) do
2071     [tags]
2072     |> List.flatten()
2073     |> Enum.map(&String.downcase/1)
2074   end
2075
2076   defp local_nickname_regex do
2077     if Config.get([:instance, :extended_nickname_format]) do
2078       @extended_local_nickname_regex
2079     else
2080       @strict_local_nickname_regex
2081     end
2082   end
2083
2084   def local_nickname(nickname_or_mention) do
2085     nickname_or_mention
2086     |> full_nickname()
2087     |> String.split("@")
2088     |> hd()
2089   end
2090
2091   def full_nickname(%User{} = user) do
2092     if String.contains?(user.nickname, "@") do
2093       user.nickname
2094     else
2095       %{host: host} = URI.parse(user.ap_id)
2096       user.nickname <> "@" <> host
2097     end
2098   end
2099
2100   def full_nickname(nickname_or_mention),
2101     do: String.trim_leading(nickname_or_mention, "@")
2102
2103   def error_user(ap_id) do
2104     %User{
2105       name: ap_id,
2106       ap_id: ap_id,
2107       nickname: "erroruser@example.com",
2108       inserted_at: NaiveDateTime.utc_now()
2109     }
2110   end
2111
2112   @spec all_superusers() :: [User.t()]
2113   def all_superusers do
2114     User.Query.build(%{super_users: true, local: true, is_active: true})
2115     |> Repo.all()
2116   end
2117
2118   def muting_reblogs?(%User{} = user, %User{} = target) do
2119     UserRelationship.reblog_mute_exists?(user, target)
2120   end
2121
2122   def showing_reblogs?(%User{} = user, %User{} = target) do
2123     not muting_reblogs?(user, target)
2124   end
2125
2126   @doc """
2127   The function returns a query to get users with no activity for given interval of days.
2128   Inactive users are those who didn't read any notification, or had any activity where
2129   the user is the activity's actor, during `inactivity_threshold` days.
2130   Deactivated users will not appear in this list.
2131
2132   ## Examples
2133
2134       iex> Pleroma.User.list_inactive_users()
2135       %Ecto.Query{}
2136   """
2137   @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
2138   def list_inactive_users_query(inactivity_threshold \\ 7) do
2139     negative_inactivity_threshold = -inactivity_threshold
2140     now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2141     # Subqueries are not supported in `where` clauses, join gets too complicated.
2142     has_read_notifications =
2143       from(n in Pleroma.Notification,
2144         where: n.seen == true,
2145         group_by: n.id,
2146         having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
2147         select: n.user_id
2148       )
2149       |> Pleroma.Repo.all()
2150
2151     from(u in Pleroma.User,
2152       left_join: a in Pleroma.Activity,
2153       on: u.ap_id == a.actor,
2154       where: not is_nil(u.nickname),
2155       where: u.is_active == ^true,
2156       where: u.id not in ^has_read_notifications,
2157       group_by: u.id,
2158       having:
2159         max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
2160           is_nil(max(a.inserted_at))
2161     )
2162   end
2163
2164   @doc """
2165   Enable or disable email notifications for user
2166
2167   ## Examples
2168
2169       iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
2170       Pleroma.User{email_notifications: %{"digest" => true}}
2171
2172       iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
2173       Pleroma.User{email_notifications: %{"digest" => false}}
2174   """
2175   @spec switch_email_notifications(t(), String.t(), boolean()) ::
2176           {:ok, t()} | {:error, Ecto.Changeset.t()}
2177   def switch_email_notifications(user, type, status) do
2178     User.update_email_notifications(user, %{type => status})
2179   end
2180
2181   @doc """
2182   Set `last_digest_emailed_at` value for the user to current time
2183   """
2184   @spec touch_last_digest_emailed_at(t()) :: t()
2185   def touch_last_digest_emailed_at(user) do
2186     now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2187
2188     {:ok, updated_user} =
2189       user
2190       |> change(%{last_digest_emailed_at: now})
2191       |> update_and_set_cache()
2192
2193     updated_user
2194   end
2195
2196   @spec set_confirmation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
2197   def set_confirmation(%User{} = user, bool) do
2198     user
2199     |> confirmation_changeset(set_confirmation: bool)
2200     |> update_and_set_cache()
2201   end
2202
2203   def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
2204     mascot
2205   end
2206
2207   def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
2208     # use instance-default
2209     config = Config.get([:assets, :mascots])
2210     default_mascot = Config.get([:assets, :default_mascot])
2211     mascot = Keyword.get(config, default_mascot)
2212
2213     %{
2214       "id" => "default-mascot",
2215       "url" => mascot[:url],
2216       "preview_url" => mascot[:url],
2217       "pleroma" => %{
2218         "mime_type" => mascot[:mime_type]
2219       }
2220     }
2221   end
2222
2223   def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
2224
2225   def ensure_keys_present(%User{} = user) do
2226     with {:ok, pem} <- Keys.generate_rsa_pem() do
2227       user
2228       |> cast(%{keys: pem}, [:keys])
2229       |> validate_required([:keys])
2230       |> update_and_set_cache()
2231     end
2232   end
2233
2234   def get_ap_ids_by_nicknames(nicknames) do
2235     from(u in User,
2236       where: u.nickname in ^nicknames,
2237       select: u.ap_id
2238     )
2239     |> Repo.all()
2240   end
2241
2242   defp put_password_hash(
2243          %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2244        ) do
2245     change(changeset, password_hash: Pleroma.Password.Pbkdf2.hash_pwd_salt(password))
2246   end
2247
2248   defp put_password_hash(changeset), do: changeset
2249
2250   def is_internal_user?(%User{nickname: nil}), do: true
2251   def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2252   def is_internal_user?(_), do: false
2253
2254   # A hack because user delete activities have a fake id for whatever reason
2255   # TODO: Get rid of this
2256   def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2257
2258   def get_delivered_users_by_object_id(object_id) do
2259     from(u in User,
2260       inner_join: delivery in assoc(u, :deliveries),
2261       where: delivery.object_id == ^object_id
2262     )
2263     |> Repo.all()
2264   end
2265
2266   def change_email(user, email) do
2267     user
2268     |> cast(%{email: email}, [:email])
2269     |> maybe_validate_required_email(false)
2270     |> unique_constraint(:email)
2271     |> validate_format(:email, @email_regex)
2272     |> update_and_set_cache()
2273   end
2274
2275   # Internal function; public one is `deactivate/2`
2276   defp set_activation_status(user, status) do
2277     user
2278     |> cast(%{is_active: status}, [:is_active])
2279     |> update_and_set_cache()
2280   end
2281
2282   def update_banner(user, banner) do
2283     user
2284     |> cast(%{banner: banner}, [:banner])
2285     |> update_and_set_cache()
2286   end
2287
2288   def update_background(user, background) do
2289     user
2290     |> cast(%{background: background}, [:background])
2291     |> update_and_set_cache()
2292   end
2293
2294   def validate_fields(changeset, remote? \\ false) do
2295     limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2296     limit = Config.get([:instance, limit_name], 0)
2297
2298     changeset
2299     |> validate_length(:fields, max: limit)
2300     |> validate_change(:fields, fn :fields, fields ->
2301       if Enum.all?(fields, &valid_field?/1) do
2302         []
2303       else
2304         [fields: "invalid"]
2305       end
2306     end)
2307   end
2308
2309   defp valid_field?(%{"name" => name, "value" => value}) do
2310     name_limit = Config.get([:instance, :account_field_name_length], 255)
2311     value_limit = Config.get([:instance, :account_field_value_length], 255)
2312
2313     is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2314       String.length(value) <= value_limit
2315   end
2316
2317   defp valid_field?(_), do: false
2318
2319   defp truncate_field(%{"name" => name, "value" => value}) do
2320     {name, _chopped} =
2321       String.split_at(name, Config.get([:instance, :account_field_name_length], 255))
2322
2323     {value, _chopped} =
2324       String.split_at(value, Config.get([:instance, :account_field_value_length], 255))
2325
2326     %{"name" => name, "value" => value}
2327   end
2328
2329   def admin_api_update(user, params) do
2330     user
2331     |> cast(params, [
2332       :is_moderator,
2333       :is_admin,
2334       :show_role
2335     ])
2336     |> update_and_set_cache()
2337   end
2338
2339   @doc "Signs user out of all applications"
2340   def global_sign_out(user) do
2341     OAuth.Authorization.delete_user_authorizations(user)
2342     OAuth.Token.delete_user_tokens(user)
2343   end
2344
2345   def mascot_update(user, url) do
2346     user
2347     |> cast(%{mascot: url}, [:mascot])
2348     |> validate_required([:mascot])
2349     |> update_and_set_cache()
2350   end
2351
2352   def mastodon_settings_update(user, settings) do
2353     user
2354     |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
2355     |> validate_required([:mastofe_settings])
2356     |> update_and_set_cache()
2357   end
2358
2359   @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2360   def confirmation_changeset(user, set_confirmation: confirmed?) do
2361     params =
2362       if confirmed? do
2363         %{
2364           is_confirmed: true,
2365           confirmation_token: nil
2366         }
2367       else
2368         %{
2369           is_confirmed: false,
2370           confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2371         }
2372       end
2373
2374     cast(user, params, [:is_confirmed, :confirmation_token])
2375   end
2376
2377   @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
2378   def approval_changeset(user, set_approval: approved?) do
2379     cast(user, %{is_approved: approved?}, [:is_approved])
2380   end
2381
2382   @spec add_pinned_object_id(User.t(), String.t()) :: {:ok, User.t()} | {:error, term()}
2383   def add_pinned_object_id(%User{} = user, object_id) do
2384     if !user.pinned_objects[object_id] do
2385       params = %{pinned_objects: Map.put(user.pinned_objects, object_id, NaiveDateTime.utc_now())}
2386
2387       user
2388       |> cast(params, [:pinned_objects])
2389       |> validate_change(:pinned_objects, fn :pinned_objects, pinned_objects ->
2390         max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2391
2392         if Enum.count(pinned_objects) <= max_pinned_statuses do
2393           []
2394         else
2395           [pinned_objects: "You have already pinned the maximum number of statuses"]
2396         end
2397       end)
2398     else
2399       change(user)
2400     end
2401     |> update_and_set_cache()
2402   end
2403
2404   @spec remove_pinned_object_id(User.t(), String.t()) :: {:ok, t()} | {:error, term()}
2405   def remove_pinned_object_id(%User{} = user, object_id) do
2406     user
2407     |> cast(
2408       %{pinned_objects: Map.delete(user.pinned_objects, object_id)},
2409       [:pinned_objects]
2410     )
2411     |> update_and_set_cache()
2412   end
2413
2414   def update_email_notifications(user, settings) do
2415     email_notifications =
2416       user.email_notifications
2417       |> Map.merge(settings)
2418       |> Map.take(["digest"])
2419
2420     params = %{email_notifications: email_notifications}
2421     fields = [:email_notifications]
2422
2423     user
2424     |> cast(params, fields)
2425     |> validate_required(fields)
2426     |> update_and_set_cache()
2427   end
2428
2429   defp set_domain_blocks(user, domain_blocks) do
2430     params = %{domain_blocks: domain_blocks}
2431
2432     user
2433     |> cast(params, [:domain_blocks])
2434     |> validate_required([:domain_blocks])
2435     |> update_and_set_cache()
2436   end
2437
2438   def block_domain(user, domain_blocked) do
2439     set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2440   end
2441
2442   def unblock_domain(user, domain_blocked) do
2443     set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2444   end
2445
2446   @spec add_to_block(User.t(), User.t()) ::
2447           {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2448   defp add_to_block(%User{} = user, %User{} = blocked) do
2449     with {:ok, relationship} <- UserRelationship.create_block(user, blocked) do
2450       @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
2451       {:ok, relationship}
2452     end
2453   end
2454
2455   @spec add_to_block(User.t(), User.t()) ::
2456           {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2457   defp remove_from_block(%User{} = user, %User{} = blocked) do
2458     with {:ok, relationship} <- UserRelationship.delete_block(user, blocked) do
2459       @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
2460       {:ok, relationship}
2461     end
2462   end
2463
2464   def set_invisible(user, invisible) do
2465     params = %{invisible: invisible}
2466
2467     user
2468     |> cast(params, [:invisible])
2469     |> validate_required([:invisible])
2470     |> update_and_set_cache()
2471   end
2472
2473   def sanitize_html(%User{} = user) do
2474     sanitize_html(user, nil)
2475   end
2476
2477   # User data that mastodon isn't filtering (treated as plaintext):
2478   # - field name
2479   # - display name
2480   def sanitize_html(%User{} = user, filter) do
2481     fields =
2482       Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2483         %{
2484           "name" => name,
2485           "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2486         }
2487       end)
2488
2489     user
2490     |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2491     |> Map.put(:fields, fields)
2492   end
2493
2494   def get_host(%User{ap_id: ap_id} = _user) do
2495     URI.parse(ap_id).host
2496   end
2497
2498   def update_last_active_at(%__MODULE__{local: true} = user) do
2499     user
2500     |> cast(%{last_active_at: NaiveDateTime.utc_now()}, [:last_active_at])
2501     |> update_and_set_cache()
2502   end
2503
2504   def active_user_count(days \\ 30) do
2505     active_after = Timex.shift(NaiveDateTime.utc_now(), days: -days)
2506
2507     __MODULE__
2508     |> where([u], u.last_active_at >= ^active_after)
2509     |> where([u], u.local == true)
2510     |> Repo.aggregate(:count)
2511   end
2512
2513   def update_last_status_at(user) do
2514     User
2515     |> where(id: ^user.id)
2516     |> update([u], set: [last_status_at: fragment("NOW()")])
2517     |> select([u], u)
2518     |> Repo.update_all([])
2519     |> case do
2520       {1, [user]} -> set_cache(user)
2521       _ -> {:error, user}
2522     end
2523   end
2524 end