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