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