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