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

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