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