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 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     unsubscribe(blocked, blocker)
1459
1460     unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
1461     if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)
1462
1463     {:ok, blocker} = update_follower_count(blocker)
1464     {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1465     add_to_block(blocker, blocked)
1466   end
1467
1468   # helper to handle the block given only an actor's AP id
1469   def block(%User{} = blocker, %{ap_id: ap_id}) do
1470     block(blocker, get_cached_by_ap_id(ap_id))
1471   end
1472
1473   def unblock(%User{} = blocker, %User{} = blocked) do
1474     remove_from_block(blocker, blocked)
1475   end
1476
1477   # helper to handle the block given only an actor's AP id
1478   def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1479     unblock(blocker, get_cached_by_ap_id(ap_id))
1480   end
1481
1482   def mutes?(nil, _), do: false
1483   def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1484
1485   def mutes_user?(%User{} = user, %User{} = target) do
1486     UserRelationship.mute_exists?(user, target)
1487   end
1488
1489   @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1490   def muted_notifications?(nil, _), do: false
1491
1492   def muted_notifications?(%User{} = user, %User{} = target),
1493     do: UserRelationship.notification_mute_exists?(user, target)
1494
1495   def blocks?(nil, _), do: false
1496
1497   def blocks?(%User{} = user, %User{} = target) do
1498     blocks_user?(user, target) ||
1499       (blocks_domain?(user, target) and not User.following?(user, target))
1500   end
1501
1502   def blocks_user?(%User{} = user, %User{} = target) do
1503     UserRelationship.block_exists?(user, target)
1504   end
1505
1506   def blocks_user?(_, _), do: false
1507
1508   def blocks_domain?(%User{} = user, %User{} = target) do
1509     domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1510     %{host: host} = URI.parse(target.ap_id)
1511     Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1512   end
1513
1514   def blocks_domain?(_, _), do: false
1515
1516   def subscribed_to?(%User{} = user, %User{} = target) do
1517     # Note: the relationship is inverse: subscriber acts as relationship target
1518     UserRelationship.inverse_subscription_exists?(target, user)
1519   end
1520
1521   def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1522     with %User{} = target <- get_cached_by_ap_id(ap_id) do
1523       subscribed_to?(user, target)
1524     end
1525   end
1526
1527   @doc """
1528   Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1529   E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1530   """
1531   @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1532   def outgoing_relationships_ap_ids(_user, []), do: %{}
1533
1534   def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1535
1536   def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1537       when is_list(relationship_types) do
1538     db_result =
1539       user
1540       |> assoc(:outgoing_relationships)
1541       |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1542       |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1543       |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1544       |> group_by([user_rel, u], user_rel.relationship_type)
1545       |> Repo.all()
1546       |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1547
1548     Enum.into(
1549       relationship_types,
1550       %{},
1551       fn rel_type -> {rel_type, db_result[rel_type] || []} end
1552     )
1553   end
1554
1555   def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1556
1557   def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1558
1559   def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1560
1561   def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1562       when is_list(relationship_types) do
1563     user
1564     |> assoc(:incoming_relationships)
1565     |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1566     |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1567     |> maybe_filter_on_ap_id(ap_ids)
1568     |> select([user_rel, u], u.ap_id)
1569     |> distinct(true)
1570     |> Repo.all()
1571   end
1572
1573   defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1574     where(query, [user_rel, u], u.ap_id in ^ap_ids)
1575   end
1576
1577   defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1578
1579   def set_activation_async(user, status \\ true) do
1580     BackgroundWorker.enqueue("user_activation", %{"user_id" => user.id, "status" => status})
1581   end
1582
1583   @spec set_activation([User.t()], boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
1584   def set_activation(users, status) when is_list(users) do
1585     Repo.transaction(fn ->
1586       for user <- users, do: set_activation(user, status)
1587     end)
1588   end
1589
1590   @spec set_activation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
1591   def set_activation(%User{} = user, status) do
1592     with {:ok, user} <- set_activation_status(user, status) do
1593       user
1594       |> get_followers()
1595       |> Enum.filter(& &1.local)
1596       |> Enum.each(&set_cache(update_following_count(&1)))
1597
1598       # Only update local user counts, remote will be update during the next pull.
1599       user
1600       |> get_friends()
1601       |> Enum.filter(& &1.local)
1602       |> Enum.each(&do_unfollow(user, &1))
1603
1604       {:ok, user}
1605     end
1606   end
1607
1608   def approve(users) when is_list(users) do
1609     Repo.transaction(fn ->
1610       Enum.map(users, fn user ->
1611         with {:ok, user} <- approve(user), do: user
1612       end)
1613     end)
1614   end
1615
1616   def approve(%User{is_approved: false} = user) do
1617     with chg <- change(user, is_approved: true),
1618          {:ok, user} <- update_and_set_cache(chg) do
1619       post_register_action(user)
1620       {:ok, user}
1621     end
1622   end
1623
1624   def approve(%User{} = user), do: {:ok, user}
1625
1626   def confirm(users) when is_list(users) do
1627     Repo.transaction(fn ->
1628       Enum.map(users, fn user ->
1629         with {:ok, user} <- confirm(user), do: user
1630       end)
1631     end)
1632   end
1633
1634   def confirm(%User{is_confirmed: false} = user) do
1635     with chg <- confirmation_changeset(user, set_confirmation: true),
1636          {:ok, user} <- update_and_set_cache(chg) do
1637       post_register_action(user)
1638       {:ok, user}
1639     end
1640   end
1641
1642   def confirm(%User{} = user), do: {:ok, user}
1643
1644   def set_suggestion(users, is_suggested) when is_list(users) do
1645     Repo.transaction(fn ->
1646       Enum.map(users, fn user ->
1647         with {:ok, user} <- set_suggestion(user, is_suggested), do: user
1648       end)
1649     end)
1650   end
1651
1652   def set_suggestion(%User{is_suggested: is_suggested} = user, is_suggested), do: {:ok, user}
1653
1654   def set_suggestion(%User{} = user, is_suggested) when is_boolean(is_suggested) do
1655     user
1656     |> change(is_suggested: is_suggested)
1657     |> update_and_set_cache()
1658   end
1659
1660   def update_notification_settings(%User{} = user, settings) do
1661     user
1662     |> cast(%{notification_settings: settings}, [])
1663     |> cast_embed(:notification_settings)
1664     |> validate_required([:notification_settings])
1665     |> update_and_set_cache()
1666   end
1667
1668   @spec purge_user_changeset(User.t()) :: Changeset.t()
1669   def purge_user_changeset(user) do
1670     # "Right to be forgotten"
1671     # https://gdpr.eu/right-to-be-forgotten/
1672     change(user, %{
1673       bio: "",
1674       raw_bio: nil,
1675       email: nil,
1676       name: nil,
1677       password_hash: nil,
1678       avatar: %{},
1679       tags: [],
1680       last_refreshed_at: nil,
1681       last_digest_emailed_at: nil,
1682       banner: %{},
1683       background: %{},
1684       note_count: 0,
1685       follower_count: 0,
1686       following_count: 0,
1687       is_locked: false,
1688       password_reset_pending: false,
1689       registration_reason: nil,
1690       confirmation_token: nil,
1691       domain_blocks: [],
1692       is_active: false,
1693       ap_enabled: false,
1694       is_moderator: false,
1695       is_admin: false,
1696       mastofe_settings: nil,
1697       mascot: nil,
1698       emoji: %{},
1699       pleroma_settings_store: %{},
1700       fields: [],
1701       raw_fields: [],
1702       is_discoverable: false,
1703       also_known_as: []
1704       # id: preserved
1705       # ap_id: preserved
1706       # nickname: preserved
1707     })
1708   end
1709
1710   # Purge doesn't delete the user from the database.
1711   # It just nulls all its fields and deactivates it.
1712   # See `User.purge_user_changeset/1` above.
1713   defp purge(%User{} = user) do
1714     user
1715     |> purge_user_changeset()
1716     |> update_and_set_cache()
1717   end
1718
1719   def delete(users) when is_list(users) do
1720     for user <- users, do: delete(user)
1721   end
1722
1723   def delete(%User{} = user) do
1724     # Purge the user immediately
1725     purge(user)
1726     BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1727   end
1728
1729   # *Actually* delete the user from the DB
1730   defp delete_from_db(%User{} = user) do
1731     invalidate_cache(user)
1732     Repo.delete(user)
1733   end
1734
1735   # If the user never finalized their account, it's safe to delete them.
1736   defp maybe_delete_from_db(%User{local: true, is_confirmed: false} = user),
1737     do: delete_from_db(user)
1738
1739   defp maybe_delete_from_db(%User{local: true, is_approved: false} = user),
1740     do: delete_from_db(user)
1741
1742   defp maybe_delete_from_db(user), do: {:ok, user}
1743
1744   def perform(:force_password_reset, user), do: force_password_reset(user)
1745
1746   @spec perform(atom(), User.t()) :: {:ok, User.t()}
1747   def perform(:delete, %User{} = user) do
1748     # Purge the user again, in case perform/2 is called directly
1749     purge(user)
1750
1751     # Remove all relationships
1752     user
1753     |> get_followers()
1754     |> Enum.each(fn follower ->
1755       ActivityPub.unfollow(follower, user)
1756       unfollow(follower, user)
1757     end)
1758
1759     user
1760     |> get_friends()
1761     |> Enum.each(fn followed ->
1762       ActivityPub.unfollow(user, followed)
1763       unfollow(user, followed)
1764     end)
1765
1766     delete_user_activities(user)
1767     delete_notifications_from_user_activities(user)
1768     delete_outgoing_pending_follow_requests(user)
1769
1770     maybe_delete_from_db(user)
1771   end
1772
1773   def perform(:set_activation_async, user, status), do: set_activation(user, status)
1774
1775   @spec external_users_query() :: Ecto.Query.t()
1776   def external_users_query do
1777     User.Query.build(%{
1778       external: true,
1779       active: true,
1780       order_by: :id
1781     })
1782   end
1783
1784   @spec external_users(keyword()) :: [User.t()]
1785   def external_users(opts \\ []) do
1786     query =
1787       external_users_query()
1788       |> select([u], struct(u, [:id, :ap_id]))
1789
1790     query =
1791       if opts[:max_id],
1792         do: where(query, [u], u.id > ^opts[:max_id]),
1793         else: query
1794
1795     query =
1796       if opts[:limit],
1797         do: limit(query, ^opts[:limit]),
1798         else: query
1799
1800     Repo.all(query)
1801   end
1802
1803   def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1804     Notification
1805     |> join(:inner, [n], activity in assoc(n, :activity))
1806     |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1807     |> Repo.delete_all()
1808   end
1809
1810   def delete_user_activities(%User{ap_id: ap_id} = user) do
1811     ap_id
1812     |> Activity.Queries.by_actor()
1813     |> Repo.chunk_stream(50, :batches)
1814     |> Stream.each(fn activities ->
1815       Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1816     end)
1817     |> Stream.run()
1818   end
1819
1820   defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1821     with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1822          {:ok, delete_data, _} <- Builder.delete(user, object) do
1823       Pipeline.common_pipeline(delete_data, local: user.local)
1824     else
1825       {:find_object, nil} ->
1826         # We have the create activity, but not the object, it was probably pruned.
1827         # Insert a tombstone and try again
1828         with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1829              {:ok, _tombstone} <- Object.create(tombstone_data) do
1830           delete_activity(activity, user)
1831         end
1832
1833       e ->
1834         Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1835         Logger.error("Error: #{inspect(e)}")
1836     end
1837   end
1838
1839   defp delete_activity(%{data: %{"type" => type}} = activity, user)
1840        when type in ["Like", "Announce"] do
1841     {:ok, undo, _} = Builder.undo(user, activity)
1842     Pipeline.common_pipeline(undo, local: user.local)
1843   end
1844
1845   defp delete_activity(_activity, _user), do: "Doing nothing"
1846
1847   defp delete_outgoing_pending_follow_requests(user) do
1848     user
1849     |> FollowingRelationship.outgoing_pending_follow_requests_query()
1850     |> Repo.delete_all()
1851   end
1852
1853   def html_filter_policy(%User{no_rich_text: true}) do
1854     Pleroma.HTML.Scrubber.TwitterText
1855   end
1856
1857   def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])
1858
1859   def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1860
1861   def get_or_fetch_by_ap_id(ap_id) do
1862     cached_user = get_cached_by_ap_id(ap_id)
1863
1864     maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)
1865
1866     case {cached_user, maybe_fetched_user} do
1867       {_, {:ok, %User{} = user}} ->
1868         {:ok, user}
1869
1870       {%User{} = user, _} ->
1871         {:ok, user}
1872
1873       _ ->
1874         {:error, :not_found}
1875     end
1876   end
1877
1878   @doc """
1879   Creates an internal service actor by URI if missing.
1880   Optionally takes nickname for addressing.
1881   """
1882   @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1883   def get_or_create_service_actor_by_ap_id(uri, nickname) do
1884     {_, user} =
1885       case get_cached_by_ap_id(uri) do
1886         nil ->
1887           with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1888             Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1889             {:error, nil}
1890           end
1891
1892         %User{invisible: false} = user ->
1893           set_invisible(user)
1894
1895         user ->
1896           {:ok, user}
1897       end
1898
1899     user
1900   end
1901
1902   @spec set_invisible(User.t()) :: {:ok, User.t()}
1903   defp set_invisible(user) do
1904     user
1905     |> change(%{invisible: true})
1906     |> update_and_set_cache()
1907   end
1908
1909   @spec create_service_actor(String.t(), String.t()) ::
1910           {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1911   defp create_service_actor(uri, nickname) do
1912     %User{
1913       invisible: true,
1914       local: true,
1915       ap_id: uri,
1916       nickname: nickname,
1917       follower_address: uri <> "/followers"
1918     }
1919     |> change
1920     |> unique_constraint(:nickname)
1921     |> Repo.insert()
1922     |> set_cache()
1923   end
1924
1925   def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1926     key =
1927       public_key_pem
1928       |> :public_key.pem_decode()
1929       |> hd()
1930       |> :public_key.pem_entry_decode()
1931
1932     {:ok, key}
1933   end
1934
1935   def public_key(_), do: {:error, "key not found"}
1936
1937   def get_public_key_for_ap_id(ap_id) do
1938     with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1939          {:ok, public_key} <- public_key(user) do
1940       {:ok, public_key}
1941     else
1942       _ -> :error
1943     end
1944   end
1945
1946   def ap_enabled?(%User{local: true}), do: true
1947   def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1948   def ap_enabled?(_), do: false
1949
1950   @doc "Gets or fetch a user by uri or nickname."
1951   @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1952   def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1953   def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1954
1955   # wait a period of time and return newest version of the User structs
1956   # this is because we have synchronous follow APIs and need to simulate them
1957   # with an async handshake
1958   def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1959     with %User{} = a <- get_cached_by_id(a.id),
1960          %User{} = b <- get_cached_by_id(b.id) do
1961       {:ok, a, b}
1962     else
1963       nil -> :error
1964     end
1965   end
1966
1967   def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1968     with :ok <- :timer.sleep(timeout),
1969          %User{} = a <- get_cached_by_id(a.id),
1970          %User{} = b <- get_cached_by_id(b.id) do
1971       {:ok, a, b}
1972     else
1973       nil -> :error
1974     end
1975   end
1976
1977   def parse_bio(bio) when is_binary(bio) and bio != "" do
1978     bio
1979     |> CommonUtils.format_input("text/plain", mentions_format: :full)
1980     |> elem(0)
1981   end
1982
1983   def parse_bio(_), do: ""
1984
1985   def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1986     # TODO: get profile URLs other than user.ap_id
1987     profile_urls = [user.ap_id]
1988
1989     bio
1990     |> CommonUtils.format_input("text/plain",
1991       mentions_format: :full,
1992       rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1993     )
1994     |> elem(0)
1995   end
1996
1997   def parse_bio(_, _), do: ""
1998
1999   def tag(user_identifiers, tags) when is_list(user_identifiers) do
2000     Repo.transaction(fn ->
2001       for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
2002     end)
2003   end
2004
2005   def tag(nickname, tags) when is_binary(nickname),
2006     do: tag(get_by_nickname(nickname), tags)
2007
2008   def tag(%User{} = user, tags),
2009     do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
2010
2011   def untag(user_identifiers, tags) when is_list(user_identifiers) do
2012     Repo.transaction(fn ->
2013       for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
2014     end)
2015   end
2016
2017   def untag(nickname, tags) when is_binary(nickname),
2018     do: untag(get_by_nickname(nickname), tags)
2019
2020   def untag(%User{} = user, tags),
2021     do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
2022
2023   defp update_tags(%User{} = user, new_tags) do
2024     {:ok, updated_user} =
2025       user
2026       |> change(%{tags: new_tags})
2027       |> update_and_set_cache()
2028
2029     updated_user
2030   end
2031
2032   defp normalize_tags(tags) do
2033     [tags]
2034     |> List.flatten()
2035     |> Enum.map(&String.downcase/1)
2036   end
2037
2038   defp local_nickname_regex do
2039     if Config.get([:instance, :extended_nickname_format]) do
2040       @extended_local_nickname_regex
2041     else
2042       @strict_local_nickname_regex
2043     end
2044   end
2045
2046   def local_nickname(nickname_or_mention) do
2047     nickname_or_mention
2048     |> full_nickname()
2049     |> String.split("@")
2050     |> hd()
2051   end
2052
2053   def full_nickname(%User{} = user) do
2054     if String.contains?(user.nickname, "@") do
2055       user.nickname
2056     else
2057       %{host: host} = URI.parse(user.ap_id)
2058       user.nickname <> "@" <> host
2059     end
2060   end
2061
2062   def full_nickname(nickname_or_mention),
2063     do: String.trim_leading(nickname_or_mention, "@")
2064
2065   def error_user(ap_id) do
2066     %User{
2067       name: ap_id,
2068       ap_id: ap_id,
2069       nickname: "erroruser@example.com",
2070       inserted_at: NaiveDateTime.utc_now()
2071     }
2072   end
2073
2074   @spec all_superusers() :: [User.t()]
2075   def all_superusers do
2076     User.Query.build(%{super_users: true, local: true, is_active: true})
2077     |> Repo.all()
2078   end
2079
2080   def muting_reblogs?(%User{} = user, %User{} = target) do
2081     UserRelationship.reblog_mute_exists?(user, target)
2082   end
2083
2084   def showing_reblogs?(%User{} = user, %User{} = target) do
2085     not muting_reblogs?(user, target)
2086   end
2087
2088   @doc """
2089   The function returns a query to get users with no activity for given interval of days.
2090   Inactive users are those who didn't read any notification, or had any activity where
2091   the user is the activity's actor, during `inactivity_threshold` days.
2092   Deactivated users will not appear in this list.
2093
2094   ## Examples
2095
2096       iex> Pleroma.User.list_inactive_users()
2097       %Ecto.Query{}
2098   """
2099   @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
2100   def list_inactive_users_query(inactivity_threshold \\ 7) do
2101     negative_inactivity_threshold = -inactivity_threshold
2102     now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2103     # Subqueries are not supported in `where` clauses, join gets too complicated.
2104     has_read_notifications =
2105       from(n in Pleroma.Notification,
2106         where: n.seen == true,
2107         group_by: n.id,
2108         having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
2109         select: n.user_id
2110       )
2111       |> Pleroma.Repo.all()
2112
2113     from(u in Pleroma.User,
2114       left_join: a in Pleroma.Activity,
2115       on: u.ap_id == a.actor,
2116       where: not is_nil(u.nickname),
2117       where: u.is_active == ^true,
2118       where: u.id not in ^has_read_notifications,
2119       group_by: u.id,
2120       having:
2121         max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
2122           is_nil(max(a.inserted_at))
2123     )
2124   end
2125
2126   @doc """
2127   Enable or disable email notifications for user
2128
2129   ## Examples
2130
2131       iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
2132       Pleroma.User{email_notifications: %{"digest" => true}}
2133
2134       iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
2135       Pleroma.User{email_notifications: %{"digest" => false}}
2136   """
2137   @spec switch_email_notifications(t(), String.t(), boolean()) ::
2138           {:ok, t()} | {:error, Ecto.Changeset.t()}
2139   def switch_email_notifications(user, type, status) do
2140     User.update_email_notifications(user, %{type => status})
2141   end
2142
2143   @doc """
2144   Set `last_digest_emailed_at` value for the user to current time
2145   """
2146   @spec touch_last_digest_emailed_at(t()) :: t()
2147   def touch_last_digest_emailed_at(user) do
2148     now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2149
2150     {:ok, updated_user} =
2151       user
2152       |> change(%{last_digest_emailed_at: now})
2153       |> update_and_set_cache()
2154
2155     updated_user
2156   end
2157
2158   @spec set_confirmation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
2159   def set_confirmation(%User{} = user, bool) do
2160     user
2161     |> confirmation_changeset(set_confirmation: bool)
2162     |> update_and_set_cache()
2163   end
2164
2165   def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
2166     mascot
2167   end
2168
2169   def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
2170     # use instance-default
2171     config = Config.get([:assets, :mascots])
2172     default_mascot = Config.get([:assets, :default_mascot])
2173     mascot = Keyword.get(config, default_mascot)
2174
2175     %{
2176       "id" => "default-mascot",
2177       "url" => mascot[:url],
2178       "preview_url" => mascot[:url],
2179       "pleroma" => %{
2180         "mime_type" => mascot[:mime_type]
2181       }
2182     }
2183   end
2184
2185   def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
2186
2187   def ensure_keys_present(%User{} = user) do
2188     with {:ok, pem} <- Keys.generate_rsa_pem() do
2189       user
2190       |> cast(%{keys: pem}, [:keys])
2191       |> validate_required([:keys])
2192       |> update_and_set_cache()
2193     end
2194   end
2195
2196   def get_ap_ids_by_nicknames(nicknames) do
2197     from(u in User,
2198       where: u.nickname in ^nicknames,
2199       select: u.ap_id
2200     )
2201     |> Repo.all()
2202   end
2203
2204   defp put_password_hash(
2205          %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2206        ) do
2207     change(changeset, password_hash: Pleroma.Password.Pbkdf2.hash_pwd_salt(password))
2208   end
2209
2210   defp put_password_hash(changeset), do: changeset
2211
2212   def is_internal_user?(%User{nickname: nil}), do: true
2213   def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2214   def is_internal_user?(_), do: false
2215
2216   # A hack because user delete activities have a fake id for whatever reason
2217   # TODO: Get rid of this
2218   def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2219
2220   def get_delivered_users_by_object_id(object_id) do
2221     from(u in User,
2222       inner_join: delivery in assoc(u, :deliveries),
2223       where: delivery.object_id == ^object_id
2224     )
2225     |> Repo.all()
2226   end
2227
2228   def change_email(user, email) do
2229     user
2230     |> cast(%{email: email}, [:email])
2231     |> maybe_validate_required_email(false)
2232     |> unique_constraint(:email)
2233     |> validate_format(:email, @email_regex)
2234     |> update_and_set_cache()
2235   end
2236
2237   def alias_users(user) do
2238     user.also_known_as
2239     |> Enum.map(&User.get_cached_by_ap_id/1)
2240     |> Enum.filter(fn user -> user != nil end)
2241   end
2242
2243   def add_alias(user, new_alias_user) do
2244     current_aliases = user.also_known_as || []
2245     new_alias_ap_id = new_alias_user.ap_id
2246
2247     if new_alias_ap_id in current_aliases do
2248       {:ok, user}
2249     else
2250       user
2251       |> cast(%{also_known_as: current_aliases ++ [new_alias_ap_id]}, [:also_known_as])
2252       |> update_and_set_cache()
2253     end
2254   end
2255
2256   def delete_alias(user, alias_user) do
2257     current_aliases = user.also_known_as || []
2258     alias_ap_id = alias_user.ap_id
2259
2260     if alias_ap_id in current_aliases do
2261       user
2262       |> cast(%{also_known_as: current_aliases -- [alias_ap_id]}, [:also_known_as])
2263       |> update_and_set_cache()
2264     else
2265       {:error, :no_such_alias}
2266     end
2267   end
2268
2269   # Internal function; public one is `deactivate/2`
2270   defp set_activation_status(user, status) do
2271     user
2272     |> cast(%{is_active: status}, [:is_active])
2273     |> update_and_set_cache()
2274   end
2275
2276   def update_banner(user, banner) do
2277     user
2278     |> cast(%{banner: banner}, [:banner])
2279     |> update_and_set_cache()
2280   end
2281
2282   def update_background(user, background) do
2283     user
2284     |> cast(%{background: background}, [:background])
2285     |> update_and_set_cache()
2286   end
2287
2288   def validate_fields(changeset, remote? \\ false) do
2289     limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2290     limit = Config.get([:instance, limit_name], 0)
2291
2292     changeset
2293     |> validate_length(:fields, max: limit)
2294     |> validate_change(:fields, fn :fields, fields ->
2295       if Enum.all?(fields, &valid_field?/1) do
2296         []
2297       else
2298         [fields: "invalid"]
2299       end
2300     end)
2301   end
2302
2303   defp valid_field?(%{"name" => name, "value" => value}) do
2304     name_limit = Config.get([:instance, :account_field_name_length], 255)
2305     value_limit = Config.get([:instance, :account_field_value_length], 255)
2306
2307     is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2308       String.length(value) <= value_limit
2309   end
2310
2311   defp valid_field?(_), do: false
2312
2313   defp truncate_field(%{"name" => name, "value" => value}) do
2314     {name, _chopped} =
2315       String.split_at(name, Config.get([:instance, :account_field_name_length], 255))
2316
2317     {value, _chopped} =
2318       String.split_at(value, Config.get([:instance, :account_field_value_length], 255))
2319
2320     %{"name" => name, "value" => value}
2321   end
2322
2323   def admin_api_update(user, params) do
2324     user
2325     |> cast(params, [
2326       :is_moderator,
2327       :is_admin,
2328       :show_role
2329     ])
2330     |> update_and_set_cache()
2331   end
2332
2333   @doc "Signs user out of all applications"
2334   def global_sign_out(user) do
2335     OAuth.Authorization.delete_user_authorizations(user)
2336     OAuth.Token.delete_user_tokens(user)
2337   end
2338
2339   def mascot_update(user, url) do
2340     user
2341     |> cast(%{mascot: url}, [:mascot])
2342     |> validate_required([:mascot])
2343     |> update_and_set_cache()
2344   end
2345
2346   def mastodon_settings_update(user, settings) do
2347     user
2348     |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
2349     |> validate_required([:mastofe_settings])
2350     |> update_and_set_cache()
2351   end
2352
2353   @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2354   def confirmation_changeset(user, set_confirmation: confirmed?) do
2355     params =
2356       if confirmed? do
2357         %{
2358           is_confirmed: true,
2359           confirmation_token: nil
2360         }
2361       else
2362         %{
2363           is_confirmed: false,
2364           confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2365         }
2366       end
2367
2368     cast(user, params, [:is_confirmed, :confirmation_token])
2369   end
2370
2371   @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
2372   def approval_changeset(user, set_approval: approved?) do
2373     cast(user, %{is_approved: approved?}, [:is_approved])
2374   end
2375
2376   @spec add_pinned_object_id(User.t(), String.t()) :: {:ok, User.t()} | {:error, term()}
2377   def add_pinned_object_id(%User{} = user, object_id) do
2378     if !user.pinned_objects[object_id] do
2379       params = %{pinned_objects: Map.put(user.pinned_objects, object_id, NaiveDateTime.utc_now())}
2380
2381       user
2382       |> cast(params, [:pinned_objects])
2383       |> validate_change(:pinned_objects, fn :pinned_objects, pinned_objects ->
2384         max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2385
2386         if Enum.count(pinned_objects) <= max_pinned_statuses do
2387           []
2388         else
2389           [pinned_objects: "You have already pinned the maximum number of statuses"]
2390         end
2391       end)
2392     else
2393       change(user)
2394     end
2395     |> update_and_set_cache()
2396   end
2397
2398   @spec remove_pinned_object_id(User.t(), String.t()) :: {:ok, t()} | {:error, term()}
2399   def remove_pinned_object_id(%User{} = user, object_id) do
2400     user
2401     |> cast(
2402       %{pinned_objects: Map.delete(user.pinned_objects, object_id)},
2403       [:pinned_objects]
2404     )
2405     |> update_and_set_cache()
2406   end
2407
2408   def update_email_notifications(user, settings) do
2409     email_notifications =
2410       user.email_notifications
2411       |> Map.merge(settings)
2412       |> Map.take(["digest"])
2413
2414     params = %{email_notifications: email_notifications}
2415     fields = [:email_notifications]
2416
2417     user
2418     |> cast(params, fields)
2419     |> validate_required(fields)
2420     |> update_and_set_cache()
2421   end
2422
2423   defp set_domain_blocks(user, domain_blocks) do
2424     params = %{domain_blocks: domain_blocks}
2425
2426     user
2427     |> cast(params, [:domain_blocks])
2428     |> validate_required([:domain_blocks])
2429     |> update_and_set_cache()
2430   end
2431
2432   def block_domain(user, domain_blocked) do
2433     set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2434   end
2435
2436   def unblock_domain(user, domain_blocked) do
2437     set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2438   end
2439
2440   @spec add_to_block(User.t(), User.t()) ::
2441           {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2442   defp add_to_block(%User{} = user, %User{} = blocked) do
2443     with {:ok, relationship} <- UserRelationship.create_block(user, blocked) do
2444       @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
2445       {:ok, relationship}
2446     end
2447   end
2448
2449   @spec add_to_block(User.t(), User.t()) ::
2450           {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2451   defp remove_from_block(%User{} = user, %User{} = blocked) do
2452     with {:ok, relationship} <- UserRelationship.delete_block(user, blocked) do
2453       @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
2454       {:ok, relationship}
2455     end
2456   end
2457
2458   def set_invisible(user, invisible) do
2459     params = %{invisible: invisible}
2460
2461     user
2462     |> cast(params, [:invisible])
2463     |> validate_required([:invisible])
2464     |> update_and_set_cache()
2465   end
2466
2467   def sanitize_html(%User{} = user) do
2468     sanitize_html(user, nil)
2469   end
2470
2471   # User data that mastodon isn't filtering (treated as plaintext):
2472   # - field name
2473   # - display name
2474   def sanitize_html(%User{} = user, filter) do
2475     fields =
2476       Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2477         %{
2478           "name" => name,
2479           "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2480         }
2481       end)
2482
2483     user
2484     |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2485     |> Map.put(:fields, fields)
2486   end
2487
2488   def get_host(%User{ap_id: ap_id} = _user) do
2489     URI.parse(ap_id).host
2490   end
2491
2492   def update_last_active_at(%__MODULE__{local: true} = user) do
2493     user
2494     |> cast(%{last_active_at: NaiveDateTime.utc_now()}, [:last_active_at])
2495     |> update_and_set_cache()
2496   end
2497
2498   def active_user_count(days \\ 30) do
2499     active_after = Timex.shift(NaiveDateTime.utc_now(), days: -days)
2500
2501     __MODULE__
2502     |> where([u], u.last_active_at >= ^active_after)
2503     |> where([u], u.local == true)
2504     |> Repo.aggregate(:count)
2505   end
2506
2507   def update_last_status_at(user) do
2508     User
2509     |> where(id: ^user.id)
2510     |> update([u], set: [last_status_at: fragment("NOW()")])
2511     |> select([u], u)
2512     |> Repo.update_all([])
2513     |> case do
2514       {1, [user]} -> set_cache(user)
2515       _ -> {:error, user}
2516     end
2517   end
2518 end