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     field(:is_suggested, :boolean, default: false)
 152     field(:last_status_at, :naive_datetime)
 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 set_suggestion(users, is_suggested) when is_list(users) do
1682     Repo.transaction(fn ->
1683       Enum.map(users, fn user ->
1684         with {:ok, user} <- set_suggestion(user, is_suggested), do: user
1685       end)
1686     end)
1687   end
1688
1689   def set_suggestion(%User{is_suggested: is_suggested} = user, is_suggested), do: {:ok, user}
1690
1691   def set_suggestion(%User{} = user, is_suggested) when is_boolean(is_suggested) do
1692     user
1693     |> change(is_suggested: is_suggested)
1694     |> update_and_set_cache()
1695   end
1696
1697   def update_notification_settings(%User{} = user, settings) do
1698     user
1699     |> cast(%{notification_settings: settings}, [])
1700     |> cast_embed(:notification_settings)
1701     |> validate_required([:notification_settings])
1702     |> update_and_set_cache()
1703   end
1704
1705   @spec purge_user_changeset(User.t()) :: Changeset.t()
1706   def purge_user_changeset(user) do
1707     # "Right to be forgotten"
1708     # https://gdpr.eu/right-to-be-forgotten/
1709     change(user, %{
1710       bio: "",
1711       raw_bio: nil,
1712       email: nil,
1713       name: nil,
1714       password_hash: nil,
1715       avatar: %{},
1716       tags: [],
1717       last_refreshed_at: nil,
1718       last_digest_emailed_at: nil,
1719       banner: %{},
1720       background: %{},
1721       note_count: 0,
1722       follower_count: 0,
1723       following_count: 0,
1724       is_locked: false,
1725       password_reset_pending: false,
1726       registration_reason: nil,
1727       confirmation_token: nil,
1728       domain_blocks: [],
1729       is_active: false,
1730       ap_enabled: false,
1731       is_moderator: false,
1732       is_admin: false,
1733       mascot: nil,
1734       emoji: %{},
1735       pleroma_settings_store: %{},
1736       fields: [],
1737       raw_fields: [],
1738       is_discoverable: false,
1739       also_known_as: []
1740       # id: preserved
1741       # ap_id: preserved
1742       # nickname: preserved
1743     })
1744   end
1745
1746   # Purge doesn't delete the user from the database.
1747   # It just nulls all its fields and deactivates it.
1748   # See `User.purge_user_changeset/1` above.
1749   defp purge(%User{} = user) do
1750     user
1751     |> purge_user_changeset()
1752     |> update_and_set_cache()
1753   end
1754
1755   def delete(users) when is_list(users) do
1756     for user <- users, do: delete(user)
1757   end
1758
1759   def delete(%User{} = user) do
1760     # Purge the user immediately
1761     purge(user)
1762     BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1763   end
1764
1765   # *Actually* delete the user from the DB
1766   defp delete_from_db(%User{} = user) do
1767     invalidate_cache(user)
1768     Repo.delete(user)
1769   end
1770
1771   # If the user never finalized their account, it's safe to delete them.
1772   defp maybe_delete_from_db(%User{local: true, is_confirmed: false} = user),
1773     do: delete_from_db(user)
1774
1775   defp maybe_delete_from_db(%User{local: true, is_approved: false} = user),
1776     do: delete_from_db(user)
1777
1778   defp maybe_delete_from_db(user), do: {:ok, user}
1779
1780   def perform(:force_password_reset, user), do: force_password_reset(user)
1781
1782   @spec perform(atom(), User.t()) :: {:ok, User.t()}
1783   def perform(:delete, %User{} = user) do
1784     # Purge the user again, in case perform/2 is called directly
1785     purge(user)
1786
1787     # Remove all relationships
1788     user
1789     |> get_followers()
1790     |> Enum.each(fn follower ->
1791       ActivityPub.unfollow(follower, user)
1792       unfollow(follower, user)
1793     end)
1794
1795     user
1796     |> get_friends()
1797     |> Enum.each(fn followed ->
1798       ActivityPub.unfollow(user, followed)
1799       unfollow(user, followed)
1800     end)
1801
1802     delete_user_activities(user)
1803     delete_notifications_from_user_activities(user)
1804     delete_outgoing_pending_follow_requests(user)
1805
1806     maybe_delete_from_db(user)
1807   end
1808
1809   def perform(:set_activation_async, user, status), do: set_activation(user, status)
1810
1811   @spec external_users_query() :: Ecto.Query.t()
1812   def external_users_query do
1813     User.Query.build(%{
1814       external: true,
1815       active: true,
1816       order_by: :id
1817     })
1818   end
1819
1820   @spec external_users(keyword()) :: [User.t()]
1821   def external_users(opts \\ []) do
1822     query =
1823       external_users_query()
1824       |> select([u], struct(u, [:id, :ap_id]))
1825
1826     query =
1827       if opts[:max_id],
1828         do: where(query, [u], u.id > ^opts[:max_id]),
1829         else: query
1830
1831     query =
1832       if opts[:limit],
1833         do: limit(query, ^opts[:limit]),
1834         else: query
1835
1836     Repo.all(query)
1837   end
1838
1839   def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1840     Notification
1841     |> join(:inner, [n], activity in assoc(n, :activity))
1842     |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1843     |> Repo.delete_all()
1844   end
1845
1846   def delete_user_activities(%User{ap_id: ap_id} = user) do
1847     ap_id
1848     |> Activity.Queries.by_actor()
1849     |> Repo.chunk_stream(50, :batches)
1850     |> Stream.each(fn activities ->
1851       Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1852     end)
1853     |> Stream.run()
1854   end
1855
1856   defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1857     with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1858          {:ok, delete_data, _} <- Builder.delete(user, object) do
1859       Pipeline.common_pipeline(delete_data, local: user.local)
1860     else
1861       {:find_object, nil} ->
1862         # We have the create activity, but not the object, it was probably pruned.
1863         # Insert a tombstone and try again
1864         with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1865              {:ok, _tombstone} <- Object.create(tombstone_data) do
1866           delete_activity(activity, user)
1867         end
1868
1869       e ->
1870         Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1871         Logger.error("Error: #{inspect(e)}")
1872     end
1873   end
1874
1875   defp delete_activity(%{data: %{"type" => type}} = activity, user)
1876        when type in ["Like", "Announce"] do
1877     {:ok, undo, _} = Builder.undo(user, activity)
1878     Pipeline.common_pipeline(undo, local: user.local)
1879   end
1880
1881   defp delete_activity(_activity, _user), do: "Doing nothing"
1882
1883   defp delete_outgoing_pending_follow_requests(user) do
1884     user
1885     |> FollowingRelationship.outgoing_pending_follow_requests_query()
1886     |> Repo.delete_all()
1887   end
1888
1889   def html_filter_policy(%User{no_rich_text: true}) do
1890     Pleroma.HTML.Scrubber.TwitterText
1891   end
1892
1893   def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])
1894
1895   def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1896
1897   def get_or_fetch_by_ap_id(ap_id) do
1898     cached_user = get_cached_by_ap_id(ap_id)
1899
1900     maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)
1901
1902     case {cached_user, maybe_fetched_user} do
1903       {_, {:ok, %User{} = user}} ->
1904         {:ok, user}
1905
1906       {%User{} = user, _} ->
1907         {:ok, user}
1908
1909       _ ->
1910         {:error, :not_found}
1911     end
1912   end
1913
1914   @doc """
1915   Creates an internal service actor by URI if missing.
1916   Optionally takes nickname for addressing.
1917   """
1918   @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1919   def get_or_create_service_actor_by_ap_id(uri, nickname) do
1920     {_, user} =
1921       case get_cached_by_ap_id(uri) do
1922         nil ->
1923           with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1924             Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1925             {:error, nil}
1926           end
1927
1928         %User{invisible: false} = user ->
1929           set_invisible(user)
1930
1931         user ->
1932           {:ok, user}
1933       end
1934
1935     user
1936   end
1937
1938   @spec set_invisible(User.t()) :: {:ok, User.t()}
1939   defp set_invisible(user) do
1940     user
1941     |> change(%{invisible: true})
1942     |> update_and_set_cache()
1943   end
1944
1945   @spec create_service_actor(String.t(), String.t()) ::
1946           {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1947   defp create_service_actor(uri, nickname) do
1948     %User{
1949       invisible: true,
1950       local: true,
1951       ap_id: uri,
1952       nickname: nickname,
1953       follower_address: uri <> "/followers"
1954     }
1955     |> change
1956     |> unique_constraint(:nickname)
1957     |> Repo.insert()
1958     |> set_cache()
1959   end
1960
1961   def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1962     key =
1963       public_key_pem
1964       |> :public_key.pem_decode()
1965       |> hd()
1966       |> :public_key.pem_entry_decode()
1967
1968     {:ok, key}
1969   end
1970
1971   def public_key(_), do: {:error, "key not found"}
1972
1973   def get_public_key_for_ap_id(ap_id) do
1974     with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1975          {:ok, public_key} <- public_key(user) do
1976       {:ok, public_key}
1977     else
1978       _ -> :error
1979     end
1980   end
1981
1982   def ap_enabled?(%User{local: true}), do: true
1983   def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1984   def ap_enabled?(_), do: false
1985
1986   @doc "Gets or fetch a user by uri or nickname."
1987   @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1988   def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1989   def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1990
1991   # wait a period of time and return newest version of the User structs
1992   # this is because we have synchronous follow APIs and need to simulate them
1993   # with an async handshake
1994   def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1995     with %User{} = a <- get_cached_by_id(a.id),
1996          %User{} = b <- get_cached_by_id(b.id) do
1997       {:ok, a, b}
1998     else
1999       nil -> :error
2000     end
2001   end
2002
2003   def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
2004     with :ok <- :timer.sleep(timeout),
2005          %User{} = a <- get_cached_by_id(a.id),
2006          %User{} = b <- get_cached_by_id(b.id) do
2007       {:ok, a, b}
2008     else
2009       nil -> :error
2010     end
2011   end
2012
2013   def parse_bio(bio) when is_binary(bio) and bio != "" do
2014     bio
2015     |> CommonUtils.format_input("text/plain", mentions_format: :full)
2016     |> elem(0)
2017   end
2018
2019   def parse_bio(_), do: ""
2020
2021   def parse_bio(bio, user) when is_binary(bio) and bio != "" do
2022     # TODO: get profile URLs other than user.ap_id
2023     profile_urls = [user.ap_id]
2024
2025     bio
2026     |> CommonUtils.format_input("text/plain",
2027       mentions_format: :full,
2028       rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
2029     )
2030     |> elem(0)
2031   end
2032
2033   def parse_bio(_, _), do: ""
2034
2035   def tag(user_identifiers, tags) when is_list(user_identifiers) do
2036     Repo.transaction(fn ->
2037       for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
2038     end)
2039   end
2040
2041   def tag(nickname, tags) when is_binary(nickname),
2042     do: tag(get_by_nickname(nickname), tags)
2043
2044   def tag(%User{} = user, tags),
2045     do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
2046
2047   def untag(user_identifiers, tags) when is_list(user_identifiers) do
2048     Repo.transaction(fn ->
2049       for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
2050     end)
2051   end
2052
2053   def untag(nickname, tags) when is_binary(nickname),
2054     do: untag(get_by_nickname(nickname), tags)
2055
2056   def untag(%User{} = user, tags),
2057     do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
2058
2059   defp update_tags(%User{} = user, new_tags) do
2060     {:ok, updated_user} =
2061       user
2062       |> change(%{tags: new_tags})
2063       |> update_and_set_cache()
2064
2065     updated_user
2066   end
2067
2068   defp normalize_tags(tags) do
2069     [tags]
2070     |> List.flatten()
2071     |> Enum.map(&String.downcase/1)
2072   end
2073
2074   defp local_nickname_regex do
2075     if Config.get([:instance, :extended_nickname_format]) do
2076       @extended_local_nickname_regex
2077     else
2078       @strict_local_nickname_regex
2079     end
2080   end
2081
2082   def local_nickname(nickname_or_mention) do
2083     nickname_or_mention
2084     |> full_nickname()
2085     |> String.split("@")
2086     |> hd()
2087   end
2088
2089   def full_nickname(%User{} = user) do
2090     if String.contains?(user.nickname, "@") do
2091       user.nickname
2092     else
2093       %{host: host} = URI.parse(user.ap_id)
2094       user.nickname <> "@" <> host
2095     end
2096   end
2097
2098   def full_nickname(nickname_or_mention),
2099     do: String.trim_leading(nickname_or_mention, "@")
2100
2101   def error_user(ap_id) do
2102     %User{
2103       name: ap_id,
2104       ap_id: ap_id,
2105       nickname: "erroruser@example.com",
2106       inserted_at: NaiveDateTime.utc_now()
2107     }
2108   end
2109
2110   @spec all_superusers() :: [User.t()]
2111   def all_superusers do
2112     User.Query.build(%{super_users: true, local: true, is_active: true})
2113     |> Repo.all()
2114   end
2115
2116   def muting_reblogs?(%User{} = user, %User{} = target) do
2117     UserRelationship.reblog_mute_exists?(user, target)
2118   end
2119
2120   def showing_reblogs?(%User{} = user, %User{} = target) do
2121     not muting_reblogs?(user, target)
2122   end
2123
2124   @doc """
2125   The function returns a query to get users with no activity for given interval of days.
2126   Inactive users are those who didn't read any notification, or had any activity where
2127   the user is the activity's actor, during `inactivity_threshold` days.
2128   Deactivated users will not appear in this list.
2129
2130   ## Examples
2131
2132       iex> Pleroma.User.list_inactive_users()
2133       %Ecto.Query{}
2134   """
2135   @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
2136   def list_inactive_users_query(inactivity_threshold \\ 7) do
2137     negative_inactivity_threshold = -inactivity_threshold
2138     now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2139     # Subqueries are not supported in `where` clauses, join gets too complicated.
2140     has_read_notifications =
2141       from(n in Pleroma.Notification,
2142         where: n.seen == true,
2143         group_by: n.id,
2144         having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
2145         select: n.user_id
2146       )
2147       |> Pleroma.Repo.all()
2148
2149     from(u in Pleroma.User,
2150       left_join: a in Pleroma.Activity,
2151       on: u.ap_id == a.actor,
2152       where: not is_nil(u.nickname),
2153       where: u.is_active == ^true,
2154       where: u.id not in ^has_read_notifications,
2155       group_by: u.id,
2156       having:
2157         max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
2158           is_nil(max(a.inserted_at))
2159     )
2160   end
2161
2162   @doc """
2163   Enable or disable email notifications for user
2164
2165   ## Examples
2166
2167       iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
2168       Pleroma.User{email_notifications: %{"digest" => true}}
2169
2170       iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
2171       Pleroma.User{email_notifications: %{"digest" => false}}
2172   """
2173   @spec switch_email_notifications(t(), String.t(), boolean()) ::
2174           {:ok, t()} | {:error, Ecto.Changeset.t()}
2175   def switch_email_notifications(user, type, status) do
2176     User.update_email_notifications(user, %{type => status})
2177   end
2178
2179   @doc """
2180   Set `last_digest_emailed_at` value for the user to current time
2181   """
2182   @spec touch_last_digest_emailed_at(t()) :: t()
2183   def touch_last_digest_emailed_at(user) do
2184     now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2185
2186     {:ok, updated_user} =
2187       user
2188       |> change(%{last_digest_emailed_at: now})
2189       |> update_and_set_cache()
2190
2191     updated_user
2192   end
2193
2194   @spec set_confirmation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
2195   def set_confirmation(%User{} = user, bool) do
2196     user
2197     |> confirmation_changeset(set_confirmation: bool)
2198     |> update_and_set_cache()
2199   end
2200
2201   def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
2202     mascot
2203   end
2204
2205   def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
2206     # use instance-default
2207     config = Config.get([:assets, :mascots])
2208     default_mascot = Config.get([:assets, :default_mascot])
2209     mascot = Keyword.get(config, default_mascot)
2210
2211     %{
2212       "id" => "default-mascot",
2213       "url" => mascot[:url],
2214       "preview_url" => mascot[:url],
2215       "pleroma" => %{
2216         "mime_type" => mascot[:mime_type]
2217       }
2218     }
2219   end
2220
2221   def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
2222
2223   def ensure_keys_present(%User{} = user) do
2224     with {:ok, pem} <- Keys.generate_rsa_pem() do
2225       user
2226       |> cast(%{keys: pem}, [:keys])
2227       |> validate_required([:keys])
2228       |> update_and_set_cache()
2229     end
2230   end
2231
2232   def get_ap_ids_by_nicknames(nicknames) do
2233     from(u in User,
2234       where: u.nickname in ^nicknames,
2235       select: u.ap_id
2236     )
2237     |> Repo.all()
2238   end
2239
2240   defp put_password_hash(
2241          %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2242        ) do
2243     change(changeset, password_hash: Pleroma.Password.Pbkdf2.hash_pwd_salt(password))
2244   end
2245
2246   defp put_password_hash(changeset), do: changeset
2247
2248   def is_internal_user?(%User{nickname: nil}), do: true
2249   def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2250   def is_internal_user?(_), do: false
2251
2252   # A hack because user delete activities have a fake id for whatever reason
2253   # TODO: Get rid of this
2254   def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2255
2256   def get_delivered_users_by_object_id(object_id) do
2257     from(u in User,
2258       inner_join: delivery in assoc(u, :deliveries),
2259       where: delivery.object_id == ^object_id
2260     )
2261     |> Repo.all()
2262   end
2263
2264   def change_email(user, email) do
2265     user
2266     |> cast(%{email: email}, [:email])
2267     |> maybe_validate_required_email(false)
2268     |> unique_constraint(:email)
2269     |> validate_format(:email, @email_regex)
2270     |> update_and_set_cache()
2271   end
2272
2273   # Internal function; public one is `deactivate/2`
2274   defp set_activation_status(user, status) do
2275     user
2276     |> cast(%{is_active: status}, [:is_active])
2277     |> update_and_set_cache()
2278   end
2279
2280   def update_banner(user, banner) do
2281     user
2282     |> cast(%{banner: banner}, [:banner])
2283     |> update_and_set_cache()
2284   end
2285
2286   def update_background(user, background) do
2287     user
2288     |> cast(%{background: background}, [:background])
2289     |> update_and_set_cache()
2290   end
2291
2292   def validate_fields(changeset, remote? \\ false) do
2293     limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2294     limit = Config.get([:instance, limit_name], 0)
2295
2296     changeset
2297     |> validate_length(:fields, max: limit)
2298     |> validate_change(:fields, fn :fields, fields ->
2299       if Enum.all?(fields, &valid_field?/1) do
2300         []
2301       else
2302         [fields: "invalid"]
2303       end
2304     end)
2305   end
2306
2307   defp valid_field?(%{"name" => name, "value" => value}) do
2308     name_limit = Config.get([:instance, :account_field_name_length], 255)
2309     value_limit = Config.get([:instance, :account_field_value_length], 255)
2310
2311     is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2312       String.length(value) <= value_limit
2313   end
2314
2315   defp valid_field?(_), do: false
2316
2317   defp truncate_field(%{"name" => name, "value" => value}) do
2318     {name, _chopped} =
2319       String.split_at(name, Config.get([:instance, :account_field_name_length], 255))
2320
2321     {value, _chopped} =
2322       String.split_at(value, Config.get([:instance, :account_field_value_length], 255))
2323
2324     %{"name" => name, "value" => value}
2325   end
2326
2327   def admin_api_update(user, params) do
2328     user
2329     |> cast(params, [
2330       :is_moderator,
2331       :is_admin,
2332       :show_role
2333     ])
2334     |> update_and_set_cache()
2335   end
2336
2337   @doc "Signs user out of all applications"
2338   def global_sign_out(user) do
2339     OAuth.Authorization.delete_user_authorizations(user)
2340     OAuth.Token.delete_user_tokens(user)
2341   end
2342
2343   def mascot_update(user, url) do
2344     user
2345     |> cast(%{mascot: url}, [:mascot])
2346     |> validate_required([:mascot])
2347     |> update_and_set_cache()
2348   end
2349
2350   @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2351   def confirmation_changeset(user, set_confirmation: confirmed?) do
2352     params =
2353       if confirmed? do
2354         %{
2355           is_confirmed: true,
2356           confirmation_token: nil
2357         }
2358       else
2359         %{
2360           is_confirmed: false,
2361           confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2362         }
2363       end
2364
2365     cast(user, params, [:is_confirmed, :confirmation_token])
2366   end
2367
2368   @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
2369   def approval_changeset(user, set_approval: approved?) do
2370     cast(user, %{is_approved: approved?}, [:is_approved])
2371   end
2372
2373   @spec add_pinned_object_id(User.t(), String.t()) :: {:ok, User.t()} | {:error, term()}
2374   def add_pinned_object_id(%User{} = user, object_id) do
2375     if !user.pinned_objects[object_id] do
2376       params = %{pinned_objects: Map.put(user.pinned_objects, object_id, NaiveDateTime.utc_now())}
2377
2378       user
2379       |> cast(params, [:pinned_objects])
2380       |> validate_change(:pinned_objects, fn :pinned_objects, pinned_objects ->
2381         max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2382
2383         if Enum.count(pinned_objects) <= max_pinned_statuses do
2384           []
2385         else
2386           [pinned_objects: "You have already pinned the maximum number of statuses"]
2387         end
2388       end)
2389     else
2390       change(user)
2391     end
2392     |> update_and_set_cache()
2393   end
2394
2395   @spec remove_pinned_object_id(User.t(), String.t()) :: {:ok, t()} | {:error, term()}
2396   def remove_pinned_object_id(%User{} = user, object_id) do
2397     user
2398     |> cast(
2399       %{pinned_objects: Map.delete(user.pinned_objects, object_id)},
2400       [:pinned_objects]
2401     )
2402     |> update_and_set_cache()
2403   end
2404
2405   def update_email_notifications(user, settings) do
2406     email_notifications =
2407       user.email_notifications
2408       |> Map.merge(settings)
2409       |> Map.take(["digest"])
2410
2411     params = %{email_notifications: email_notifications}
2412     fields = [:email_notifications]
2413
2414     user
2415     |> cast(params, fields)
2416     |> validate_required(fields)
2417     |> update_and_set_cache()
2418   end
2419
2420   defp set_domain_blocks(user, domain_blocks) do
2421     params = %{domain_blocks: domain_blocks}
2422
2423     user
2424     |> cast(params, [:domain_blocks])
2425     |> validate_required([:domain_blocks])
2426     |> update_and_set_cache()
2427   end
2428
2429   def block_domain(user, domain_blocked) do
2430     set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2431   end
2432
2433   def unblock_domain(user, domain_blocked) do
2434     set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2435   end
2436
2437   @spec add_to_block(User.t(), User.t()) ::
2438           {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2439   defp add_to_block(%User{} = user, %User{} = blocked) do
2440     with {:ok, relationship} <- UserRelationship.create_block(user, blocked) do
2441       @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
2442       {:ok, relationship}
2443     end
2444   end
2445
2446   @spec add_to_block(User.t(), User.t()) ::
2447           {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2448   defp remove_from_block(%User{} = user, %User{} = blocked) do
2449     with {:ok, relationship} <- UserRelationship.delete_block(user, blocked) do
2450       @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
2451       {:ok, relationship}
2452     end
2453   end
2454
2455   def set_invisible(user, invisible) do
2456     params = %{invisible: invisible}
2457
2458     user
2459     |> cast(params, [:invisible])
2460     |> validate_required([:invisible])
2461     |> update_and_set_cache()
2462   end
2463
2464   def sanitize_html(%User{} = user) do
2465     sanitize_html(user, nil)
2466   end
2467
2468   # User data that mastodon isn't filtering (treated as plaintext):
2469   # - field name
2470   # - display name
2471   def sanitize_html(%User{} = user, filter) do
2472     fields =
2473       Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2474         %{
2475           "name" => name,
2476           "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2477         }
2478       end)
2479
2480     user
2481     |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2482     |> Map.put(:fields, fields)
2483   end
2484
2485   def get_host(%User{ap_id: ap_id} = _user) do
2486     URI.parse(ap_id).host
2487   end
2488
2489   def update_last_active_at(%__MODULE__{local: true} = user) do
2490     user
2491     |> cast(%{last_active_at: NaiveDateTime.utc_now()}, [:last_active_at])
2492     |> update_and_set_cache()
2493   end
2494
2495   def active_user_count(days \\ 30) do
2496     active_after = Timex.shift(NaiveDateTime.utc_now(), days: -days)
2497
2498     __MODULE__
2499     |> where([u], u.last_active_at >= ^active_after)
2500     |> where([u], u.local == true)
2501     |> Repo.aggregate(:count)
2502   end
2503
2504   def update_last_status_at(user) do
2505     User
2506     |> where(id: ^user.id)
2507     |> update([u], set: [last_status_at: fragment("NOW()")])
2508     |> select([u], u)
2509     |> Repo.update_all([])
2510     |> case do
2511       {1, [user]} -> set_cache(user)
2512       _ -> {:error, user}
2513     end
2514   end
2515 end