git.squeep.com Git - akkoma/blob - lib/pleroma/user.ex

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