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