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
  31   alias Pleroma.Web.ActivityPub.ActivityPub
  32   alias Pleroma.Web.ActivityPub.Builder
  33   alias Pleroma.Web.ActivityPub.Pipeline
  34   alias Pleroma.Web.ActivityPub.Utils
  35   alias Pleroma.Web.CommonAPI
  36   alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
  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(:search_rank, :float, virtual: true)
 103     field(:search_type, :integer, virtual: true)
 104     field(:tags, {:array, :string}, default: [])
 105     field(:last_refreshed_at, :naive_datetime_usec)
 106     field(:last_digest_emailed_at, :naive_datetime)
 107     field(:banner, :map, default: %{})
 108     field(:background, :map, default: %{})
 109     field(:note_count, :integer, default: 0)
 110     field(:follower_count, :integer, default: 0)
 111     field(:following_count, :integer, default: 0)
 112     field(:is_locked, :boolean, default: false)
 113     field(:is_confirmed, :boolean, default: true)
 114     field(:password_reset_pending, :boolean, default: false)
 115     field(:is_approved, :boolean, default: true)
 116     field(:registration_reason, :string, default: nil)
 117     field(:confirmation_token, :string, default: nil)
 118     field(:default_scope, :string, default: "public")
 119     field(:domain_blocks, {:array, :string}, default: [])
 120     field(:is_active, :boolean, default: true)
 121     field(:no_rich_text, :boolean, default: false)
 122     field(:ap_enabled, :boolean, default: false)
 123     field(:is_moderator, :boolean, default: false)
 124     field(:is_admin, :boolean, default: false)
 125     field(:show_role, :boolean, default: true)
 126     field(:mastofe_settings, :map, default: nil)
 127     field(:uri, ObjectValidators.Uri, default: nil)
 128     field(:hide_followers_count, :boolean, default: false)
 129     field(:hide_follows_count, :boolean, default: false)
 130     field(:hide_followers, :boolean, default: false)
 131     field(:hide_follows, :boolean, default: false)
 132     field(:hide_favorites, :boolean, default: true)
 133     field(:pinned_activities, {:array, :string}, default: [])
 134     field(:email_notifications, :map, default: %{"digest" => false})
 135     field(:mascot, :map, default: nil)
 136     field(:emoji, :map, default: %{})
 137     field(:pleroma_settings_store, :map, default: %{})
 138     field(:fields, {:array, :map}, default: [])
 139     field(:raw_fields, {:array, :map}, default: [])
 140     field(:is_discoverable, :boolean, default: false)
 141     field(:invisible, :boolean, default: false)
 142     field(:allow_following_move, :boolean, default: true)
 143     field(:skip_thread_containment, :boolean, default: false)
 144     field(:actor_type, :string, default: "Person")
 145     field(:also_known_as, {:array, ObjectValidators.ObjectID}, default: [])
 146     field(:inbox, :string)
 147     field(:shared_inbox, :string)
 148     field(:accepts_chat_messages, :boolean, default: nil)
 149     field(:last_active_at, :naive_datetime)
 150
 151     embeds_one(
 152       :notification_settings,
 153       Pleroma.User.NotificationSetting,
 154       on_replace: :update
 155     )
 156
 157     has_many(:notifications, Notification)
 158     has_many(:registrations, Registration)
 159     has_many(:deliveries, Delivery)
 160
 161     has_many(:outgoing_relationships, UserRelationship, foreign_key: :source_id)
 162     has_many(:incoming_relationships, UserRelationship, foreign_key: :target_id)
 163
 164     for {relationship_type,
 165          [
 166            {outgoing_relation, outgoing_relation_target},
 167            {incoming_relation, incoming_relation_source}
 168          ]} <- @user_relationships_config do
 169       # Definitions of `has_many` relations: :blocker_blocks, :muter_mutes, :reblog_muter_mutes,
 170       #   :notification_muter_mutes, :subscribee_subscriptions
 171       has_many(outgoing_relation, UserRelationship,
 172         foreign_key: :source_id,
 173         where: [relationship_type: relationship_type]
 174       )
 175
 176       # Definitions of `has_many` relations: :blockee_blocks, :mutee_mutes, :reblog_mutee_mutes,
 177       #   :notification_mutee_mutes, :subscriber_subscriptions
 178       has_many(incoming_relation, UserRelationship,
 179         foreign_key: :target_id,
 180         where: [relationship_type: relationship_type]
 181       )
 182
 183       # Definitions of `has_many` relations: :blocked_users, :muted_users, :reblog_muted_users,
 184       #   :notification_muted_users, :subscriber_users
 185       has_many(outgoing_relation_target, through: [outgoing_relation, :target])
 186
 187       # Definitions of `has_many` relations: :blocker_users, :muter_users, :reblog_muter_users,
 188       #   :notification_muter_users, :subscribee_users
 189       has_many(incoming_relation_source, through: [incoming_relation, :source])
 190     end
 191
 192     # `:blocks` is deprecated (replaced with `blocked_users` relation)
 193     field(:blocks, {:array, :string}, default: [])
 194     # `:mutes` is deprecated (replaced with `muted_users` relation)
 195     field(:mutes, {:array, :string}, default: [])
 196     # `:muted_reblogs` is deprecated (replaced with `reblog_muted_users` relation)
 197     field(:muted_reblogs, {:array, :string}, default: [])
 198     # `:muted_notifications` is deprecated (replaced with `notification_muted_users` relation)
 199     field(:muted_notifications, {:array, :string}, default: [])
 200     # `:subscribers` is deprecated (replaced with `subscriber_users` relation)
 201     field(:subscribers, {:array, :string}, default: [])
 202
 203     embeds_one(
 204       :multi_factor_authentication_settings,
 205       MFA.Settings,
 206       on_replace: :delete
 207     )
 208
 209     timestamps()
 210   end
 211
 212   for {_relationship_type, [{_outgoing_relation, outgoing_relation_target}, _]} <-
 213         @user_relationships_config do
 214     # `def blocked_users_relation/2`, `def muted_users_relation/2`,
 215     #   `def reblog_muted_users_relation/2`, `def notification_muted_users/2`,
 216     #   `def subscriber_users/2`
 217     def unquote(:"#{outgoing_relation_target}_relation")(user, restrict_deactivated? \\ false) do
 218       target_users_query = assoc(user, unquote(outgoing_relation_target))
 219
 220       if restrict_deactivated? do
 221         target_users_query
 222         |> User.Query.build(%{deactivated: false})
 223       else
 224         target_users_query
 225       end
 226     end
 227
 228     # `def blocked_users/2`, `def muted_users/2`, `def reblog_muted_users/2`,
 229     #   `def notification_muted_users/2`, `def subscriber_users/2`
 230     def unquote(outgoing_relation_target)(user, restrict_deactivated? \\ false) do
 231       __MODULE__
 232       |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
 233         user,
 234         restrict_deactivated?
 235       ])
 236       |> Repo.all()
 237     end
 238
 239     # `def blocked_users_ap_ids/2`, `def muted_users_ap_ids/2`, `def reblog_muted_users_ap_ids/2`,
 240     #   `def notification_muted_users_ap_ids/2`, `def subscriber_users_ap_ids/2`
 241     def unquote(:"#{outgoing_relation_target}_ap_ids")(user, restrict_deactivated? \\ false) do
 242       __MODULE__
 243       |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
 244         user,
 245         restrict_deactivated?
 246       ])
 247       |> select([u], u.ap_id)
 248       |> Repo.all()
 249     end
 250   end
 251
 252   def cached_blocked_users_ap_ids(user) do
 253     @cachex.fetch!(:user_cache, "blocked_users_ap_ids:#{user.ap_id}", fn _ ->
 254       blocked_users_ap_ids(user)
 255     end)
 256   end
 257
 258   def cached_muted_users_ap_ids(user) do
 259     @cachex.fetch!(:user_cache, "muted_users_ap_ids:#{user.ap_id}", fn _ ->
 260       muted_users_ap_ids(user)
 261     end)
 262   end
 263
 264   defdelegate following_count(user), to: FollowingRelationship
 265   defdelegate following(user), to: FollowingRelationship
 266   defdelegate following?(follower, followed), to: FollowingRelationship
 267   defdelegate following_ap_ids(user), to: FollowingRelationship
 268   defdelegate get_follow_requests(user), to: FollowingRelationship
 269   defdelegate search(query, opts \\ []), to: User.Search
 270
 271   @doc """
 272   Dumps Flake Id to SQL-compatible format (16-byte UUID).
 273   E.g. "9pQtDGXuq4p3VlcJEm" -> <<0, 0, 1, 110, 179, 218, 42, 92, 213, 41, 44, 227, 95, 213, 0, 0>>
 274   """
 275   def binary_id(source_id) when is_binary(source_id) do
 276     with {:ok, dumped_id} <- FlakeId.Ecto.CompatType.dump(source_id) do
 277       dumped_id
 278     else
 279       _ -> source_id
 280     end
 281   end
 282
 283   def binary_id(source_ids) when is_list(source_ids) do
 284     Enum.map(source_ids, &binary_id/1)
 285   end
 286
 287   def binary_id(%User{} = user), do: binary_id(user.id)
 288
 289   @doc "Returns status account"
 290   @spec account_status(User.t()) :: account_status()
 291   def account_status(%User{is_active: false}), do: :deactivated
 292   def account_status(%User{password_reset_pending: true}), do: :password_reset_pending
 293   def account_status(%User{local: true, is_approved: false}), do: :approval_pending
 294   def account_status(%User{local: true, is_confirmed: false}), do: :confirmation_pending
 295   def account_status(%User{}), do: :active
 296
 297   @spec visible_for(User.t(), User.t() | nil) ::
 298           :visible
 299           | :invisible
 300           | :restricted_unauthenticated
 301           | :deactivated
 302           | :confirmation_pending
 303   def visible_for(user, for_user \\ nil)
 304
 305   def visible_for(%User{invisible: true}, _), do: :invisible
 306
 307   def visible_for(%User{id: user_id}, %User{id: user_id}), do: :visible
 308
 309   def visible_for(%User{} = user, nil) do
 310     if restrict_unauthenticated?(user) do
 311       :restrict_unauthenticated
 312     else
 313       visible_account_status(user)
 314     end
 315   end
 316
 317   def visible_for(%User{} = user, for_user) do
 318     if superuser?(for_user) do
 319       :visible
 320     else
 321       visible_account_status(user)
 322     end
 323   end
 324
 325   def visible_for(_, _), do: :invisible
 326
 327   defp restrict_unauthenticated?(%User{local: true}) do
 328     Config.restrict_unauthenticated_access?(:profiles, :local)
 329   end
 330
 331   defp restrict_unauthenticated?(%User{local: _}) do
 332     Config.restrict_unauthenticated_access?(:profiles, :remote)
 333   end
 334
 335   defp visible_account_status(user) do
 336     status = account_status(user)
 337
 338     if status in [:active, :password_reset_pending] do
 339       :visible
 340     else
 341       status
 342     end
 343   end
 344
 345   @spec superuser?(User.t()) :: boolean()
 346   def superuser?(%User{local: true, is_admin: true}), do: true
 347   def superuser?(%User{local: true, is_moderator: true}), do: true
 348   def superuser?(_), do: false
 349
 350   @spec invisible?(User.t()) :: boolean()
 351   def invisible?(%User{invisible: true}), do: true
 352   def invisible?(_), do: false
 353
 354   def avatar_url(user, options \\ []) do
 355     case user.avatar do
 356       %{"url" => [%{"href" => href} | _]} ->
 357         href
 358
 359       _ ->
 360         unless options[:no_default] do
 361           Config.get([:assets, :default_user_avatar], "#{Web.base_url()}/images/avi.png")
 362         end
 363     end
 364   end
 365
 366   def banner_url(user, options \\ []) do
 367     case user.banner do
 368       %{"url" => [%{"href" => href} | _]} -> href
 369       _ -> !options[:no_default] && "#{Web.base_url()}/images/banner.png"
 370     end
 371   end
 372
 373   # Should probably be renamed or removed
 374   def ap_id(%User{nickname: nickname}), do: "#{Web.base_url()}/users/#{nickname}"
 375
 376   def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
 377   def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"
 378
 379   @spec ap_following(User.t()) :: String.t()
 380   def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
 381   def ap_following(%User{} = user), do: "#{ap_id(user)}/following"
 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         :hide_followers,
 446         :hide_follows,
 447         :hide_followers_count,
 448         :hide_follows_count,
 449         :follower_count,
 450         :fields,
 451         :following_count,
 452         :is_discoverable,
 453         :invisible,
 454         :actor_type,
 455         :also_known_as,
 456         :accepts_chat_messages
 457       ]
 458     )
 459     |> cast(params, [:name], empty_values: [])
 460     |> validate_required([:ap_id])
 461     |> validate_required([:name], trim: false)
 462     |> unique_constraint(:nickname)
 463     |> validate_format(:nickname, @email_regex)
 464     |> validate_length(:bio, max: bio_limit)
 465     |> validate_length(:name, max: name_limit)
 466     |> validate_fields(true)
 467     |> validate_non_local()
 468   end
 469
 470   defp validate_non_local(cng) do
 471     local? = get_field(cng, :local)
 472
 473     if local? do
 474       cng
 475       |> add_error(:local, "User is local, can't update with this changeset.")
 476     else
 477       cng
 478     end
 479   end
 480
 481   def update_changeset(struct, params \\ %{}) do
 482     bio_limit = Config.get([:instance, :user_bio_length], 5000)
 483     name_limit = Config.get([:instance, :user_name_length], 100)
 484
 485     struct
 486     |> cast(
 487       params,
 488       [
 489         :bio,
 490         :raw_bio,
 491         :name,
 492         :emoji,
 493         :avatar,
 494         :public_key,
 495         :inbox,
 496         :shared_inbox,
 497         :is_locked,
 498         :no_rich_text,
 499         :default_scope,
 500         :banner,
 501         :hide_follows,
 502         :hide_followers,
 503         :hide_followers_count,
 504         :hide_follows_count,
 505         :hide_favorites,
 506         :allow_following_move,
 507         :also_known_as,
 508         :background,
 509         :show_role,
 510         :skip_thread_containment,
 511         :fields,
 512         :raw_fields,
 513         :pleroma_settings_store,
 514         :is_discoverable,
 515         :actor_type,
 516         :accepts_chat_messages
 517       ]
 518     )
 519     |> unique_constraint(:nickname)
 520     |> validate_format(:nickname, local_nickname_regex())
 521     |> validate_length(:bio, max: bio_limit)
 522     |> validate_length(:name, min: 1, max: name_limit)
 523     |> validate_inclusion(:actor_type, ["Person", "Service"])
 524     |> put_fields()
 525     |> put_emoji()
 526     |> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
 527     |> put_change_if_present(:avatar, &put_upload(&1, :avatar))
 528     |> put_change_if_present(:banner, &put_upload(&1, :banner))
 529     |> put_change_if_present(:background, &put_upload(&1, :background))
 530     |> put_change_if_present(
 531       :pleroma_settings_store,
 532       &{:ok, Map.merge(struct.pleroma_settings_store, &1)}
 533     )
 534     |> validate_fields(false)
 535   end
 536
 537   defp put_fields(changeset) do
 538     if raw_fields = get_change(changeset, :raw_fields) do
 539       raw_fields =
 540         raw_fields
 541         |> Enum.filter(fn %{"name" => n} -> n != "" end)
 542
 543       fields =
 544         raw_fields
 545         |> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)
 546
 547       changeset
 548       |> put_change(:raw_fields, raw_fields)
 549       |> put_change(:fields, fields)
 550     else
 551       changeset
 552     end
 553   end
 554
 555   defp parse_fields(value) do
 556     value
 557     |> Formatter.linkify(mentions_format: :full)
 558     |> elem(0)
 559   end
 560
 561   defp put_emoji(changeset) do
 562     emojified_fields = [:bio, :name, :raw_fields]
 563
 564     if Enum.any?(changeset.changes, fn {k, _} -> k in emojified_fields end) do
 565       bio = Emoji.Formatter.get_emoji_map(get_field(changeset, :bio))
 566       name = Emoji.Formatter.get_emoji_map(get_field(changeset, :name))
 567
 568       emoji = Map.merge(bio, name)
 569
 570       emoji =
 571         changeset
 572         |> get_field(:raw_fields)
 573         |> Enum.reduce(emoji, fn x, acc ->
 574           Map.merge(acc, Emoji.Formatter.get_emoji_map(x["name"] <> x["value"]))
 575         end)
 576
 577       put_change(changeset, :emoji, emoji)
 578     else
 579       changeset
 580     end
 581   end
 582
 583   defp put_change_if_present(changeset, map_field, value_function) do
 584     with {:ok, value} <- fetch_change(changeset, map_field),
 585          {:ok, new_value} <- value_function.(value) do
 586       put_change(changeset, map_field, new_value)
 587     else
 588       _ -> changeset
 589     end
 590   end
 591
 592   defp put_upload(value, type) do
 593     with %Plug.Upload{} <- value,
 594          {:ok, object} <- ActivityPub.upload(value, type: type) do
 595       {:ok, object.data}
 596     end
 597   end
 598
 599   def update_as_admin_changeset(struct, params) do
 600     struct
 601     |> update_changeset(params)
 602     |> cast(params, [:email])
 603     |> delete_change(:also_known_as)
 604     |> unique_constraint(:email)
 605     |> validate_format(:email, @email_regex)
 606     |> validate_inclusion(:actor_type, ["Person", "Service"])
 607   end
 608
 609   @spec update_as_admin(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
 610   def update_as_admin(user, params) do
 611     params = Map.put(params, "password_confirmation", params["password"])
 612     changeset = update_as_admin_changeset(user, params)
 613
 614     if params["password"] do
 615       reset_password(user, changeset, params)
 616     else
 617       User.update_and_set_cache(changeset)
 618     end
 619   end
 620
 621   def password_update_changeset(struct, params) do
 622     struct
 623     |> cast(params, [:password, :password_confirmation])
 624     |> validate_required([:password, :password_confirmation])
 625     |> validate_confirmation(:password)
 626     |> put_password_hash()
 627     |> put_change(:password_reset_pending, false)
 628   end
 629
 630   @spec reset_password(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
 631   def reset_password(%User{} = user, params) do
 632     reset_password(user, user, params)
 633   end
 634
 635   def reset_password(%User{id: user_id} = user, struct, params) do
 636     multi =
 637       Multi.new()
 638       |> Multi.update(:user, password_update_changeset(struct, params))
 639       |> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
 640       |> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))
 641
 642     case Repo.transaction(multi) do
 643       {:ok, %{user: user} = _} -> set_cache(user)
 644       {:error, _, changeset, _} -> {:error, changeset}
 645     end
 646   end
 647
 648   def update_password_reset_pending(user, value) do
 649     user
 650     |> change()
 651     |> put_change(:password_reset_pending, value)
 652     |> update_and_set_cache()
 653   end
 654
 655   def force_password_reset_async(user) do
 656     BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
 657   end
 658
 659   @spec force_password_reset(User.t()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
 660   def force_password_reset(user), do: update_password_reset_pending(user, true)
 661
 662   # Used to auto-register LDAP accounts which won't have a password hash stored locally
 663   def register_changeset_ldap(struct, params = %{password: password})
 664       when is_nil(password) do
 665     params = Map.put_new(params, :accepts_chat_messages, true)
 666
 667     params =
 668       if Map.has_key?(params, :email) do
 669         Map.put_new(params, :email, params[:email])
 670       else
 671         params
 672       end
 673
 674     struct
 675     |> cast(params, [
 676       :name,
 677       :nickname,
 678       :email,
 679       :accepts_chat_messages
 680     ])
 681     |> validate_required([:name, :nickname])
 682     |> unique_constraint(:nickname)
 683     |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
 684     |> validate_format(:nickname, local_nickname_regex())
 685     |> put_ap_id()
 686     |> unique_constraint(:ap_id)
 687     |> put_following_and_follower_address()
 688   end
 689
 690   def register_changeset(struct, params \\ %{}, opts \\ []) do
 691     bio_limit = Config.get([:instance, :user_bio_length], 5000)
 692     name_limit = Config.get([:instance, :user_name_length], 100)
 693     reason_limit = Config.get([:instance, :registration_reason_length], 500)
 694     params = Map.put_new(params, :accepts_chat_messages, true)
 695
 696     confirmed? =
 697       if is_nil(opts[:confirmed]) do
 698         !Config.get([:instance, :account_activation_required])
 699       else
 700         opts[:confirmed]
 701       end
 702
 703     approved? =
 704       if is_nil(opts[:approved]) do
 705         !Config.get([:instance, :account_approval_required])
 706       else
 707         opts[:approved]
 708       end
 709
 710     struct
 711     |> confirmation_changeset(set_confirmation: confirmed?)
 712     |> approval_changeset(set_approval: approved?)
 713     |> cast(params, [
 714       :bio,
 715       :raw_bio,
 716       :email,
 717       :name,
 718       :nickname,
 719       :password,
 720       :password_confirmation,
 721       :emoji,
 722       :accepts_chat_messages,
 723       :registration_reason
 724     ])
 725     |> validate_required([:name, :nickname, :password, :password_confirmation])
 726     |> validate_confirmation(:password)
 727     |> unique_constraint(:email)
 728     |> validate_format(:email, @email_regex)
 729     |> validate_change(:email, fn :email, email ->
 730       valid? =
 731         Config.get([User, :email_blacklist])
 732         |> Enum.all?(fn blacklisted_domain ->
 733           !String.ends_with?(email, ["@" <> blacklisted_domain, "." <> blacklisted_domain])
 734         end)
 735
 736       if valid?, do: [], else: [email: "Invalid email"]
 737     end)
 738     |> unique_constraint(:nickname)
 739     |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
 740     |> validate_format(:nickname, local_nickname_regex())
 741     |> validate_length(:bio, max: bio_limit)
 742     |> validate_length(:name, min: 1, max: name_limit)
 743     |> validate_length(:registration_reason, max: reason_limit)
 744     |> maybe_validate_required_email(opts[:external])
 745     |> put_password_hash
 746     |> put_ap_id()
 747     |> unique_constraint(:ap_id)
 748     |> put_following_and_follower_address()
 749   end
 750
 751   def maybe_validate_required_email(changeset, true), do: changeset
 752
 753   def maybe_validate_required_email(changeset, _) do
 754     if Config.get([:instance, :account_activation_required]) do
 755       validate_required(changeset, [:email])
 756     else
 757       changeset
 758     end
 759   end
 760
 761   defp put_ap_id(changeset) do
 762     ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
 763     put_change(changeset, :ap_id, ap_id)
 764   end
 765
 766   defp put_following_and_follower_address(changeset) do
 767     followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
 768
 769     changeset
 770     |> put_change(:follower_address, followers)
 771   end
 772
 773   defp autofollow_users(user) do
 774     candidates = Config.get([:instance, :autofollowed_nicknames])
 775
 776     autofollowed_users =
 777       User.Query.build(%{nickname: candidates, local: true, is_active: true})
 778       |> Repo.all()
 779
 780     follow_all(user, autofollowed_users)
 781   end
 782
 783   defp autofollowing_users(user) do
 784     candidates = Config.get([:instance, :autofollowing_nicknames])
 785
 786     User.Query.build(%{nickname: candidates, local: true, deactivated: false})
 787     |> Repo.all()
 788     |> Enum.each(&follow(&1, user, :follow_accept))
 789
 790     {:ok, :success}
 791   end
 792
 793   @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
 794   def register(%Ecto.Changeset{} = changeset) do
 795     with {:ok, user} <- Repo.insert(changeset) do
 796       post_register_action(user)
 797     end
 798   end
 799
 800   def post_register_action(%User{is_confirmed: false} = user) do
 801     with {:ok, _} <- maybe_send_confirmation_email(user) do
 802       {:ok, user}
 803     end
 804   end
 805
 806   def post_register_action(%User{is_approved: false} = user) do
 807     with {:ok, _} <- send_user_approval_email(user),
 808          {:ok, _} <- send_admin_approval_emails(user) do
 809       {:ok, user}
 810     end
 811   end
 812
 813   def post_register_action(%User{is_approved: true, is_confirmed: true} = user) do
 814     with {:ok, user} <- autofollow_users(user),
 815          {:ok, _} <- autofollowing_users(user),
 816          {:ok, user} <- set_cache(user),
 817          {:ok, _} <- maybe_send_registration_email(user),
 818          {:ok, _} <- maybe_send_welcome_email(user),
 819          {:ok, _} <- maybe_send_welcome_message(user),
 820          {:ok, _} <- maybe_send_welcome_chat_message(user) do
 821       {:ok, user}
 822     end
 823   end
 824
 825   defp send_user_approval_email(user) do
 826     user
 827     |> Pleroma.Emails.UserEmail.approval_pending_email()
 828     |> Pleroma.Emails.Mailer.deliver_async()
 829
 830     {:ok, :enqueued}
 831   end
 832
 833   defp send_admin_approval_emails(user) do
 834     all_superusers()
 835     |> Enum.filter(fn user -> not is_nil(user.email) end)
 836     |> Enum.each(fn superuser ->
 837       superuser
 838       |> Pleroma.Emails.AdminEmail.new_unapproved_registration(user)
 839       |> Pleroma.Emails.Mailer.deliver_async()
 840     end)
 841
 842     {:ok, :enqueued}
 843   end
 844
 845   defp maybe_send_welcome_message(user) do
 846     if User.WelcomeMessage.enabled?() do
 847       User.WelcomeMessage.post_message(user)
 848       {:ok, :enqueued}
 849     else
 850       {:ok, :noop}
 851     end
 852   end
 853
 854   defp maybe_send_welcome_chat_message(user) do
 855     if User.WelcomeChatMessage.enabled?() do
 856       User.WelcomeChatMessage.post_message(user)
 857       {:ok, :enqueued}
 858     else
 859       {:ok, :noop}
 860     end
 861   end
 862
 863   defp maybe_send_welcome_email(%User{email: email} = user) when is_binary(email) do
 864     if User.WelcomeEmail.enabled?() do
 865       User.WelcomeEmail.send_email(user)
 866       {:ok, :enqueued}
 867     else
 868       {:ok, :noop}
 869     end
 870   end
 871
 872   defp maybe_send_welcome_email(_), do: {:ok, :noop}
 873
 874   @spec maybe_send_confirmation_email(User.t()) :: {:ok, :enqueued | :noop}
 875   def maybe_send_confirmation_email(%User{is_confirmed: false, email: email} = user)
 876       when is_binary(email) do
 877     if Config.get([:instance, :account_activation_required]) do
 878       send_confirmation_email(user)
 879       {:ok, :enqueued}
 880     else
 881       {:ok, :noop}
 882     end
 883   end
 884
 885   def maybe_send_confirmation_email(_), do: {:ok, :noop}
 886
 887   @spec send_confirmation_email(Uset.t()) :: User.t()
 888   def send_confirmation_email(%User{} = user) do
 889     user
 890     |> Pleroma.Emails.UserEmail.account_confirmation_email()
 891     |> Pleroma.Emails.Mailer.deliver_async()
 892
 893     user
 894   end
 895
 896   @spec maybe_send_registration_email(User.t()) :: {:ok, :enqueued | :noop}
 897   defp maybe_send_registration_email(%User{email: email} = user) when is_binary(email) do
 898     with false <- User.WelcomeEmail.enabled?(),
 899          false <- Config.get([:instance, :account_activation_required], false),
 900          false <- Config.get([:instance, :account_approval_required], false) do
 901       user
 902       |> Pleroma.Emails.UserEmail.successful_registration_email()
 903       |> Pleroma.Emails.Mailer.deliver_async()
 904
 905       {:ok, :enqueued}
 906     else
 907       _ ->
 908         {:ok, :noop}
 909     end
 910   end
 911
 912   defp maybe_send_registration_email(_), do: {:ok, :noop}
 913
 914   def needs_update?(%User{local: true}), do: false
 915
 916   def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
 917
 918   def needs_update?(%User{local: false} = user) do
 919     NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
 920   end
 921
 922   def needs_update?(_), do: true
 923
 924   @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
 925
 926   # "Locked" (self-locked) users demand explicit authorization of follow requests
 927   def maybe_direct_follow(%User{} = follower, %User{local: true, is_locked: true} = followed) do
 928     follow(follower, followed, :follow_pending)
 929   end
 930
 931   def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
 932     follow(follower, followed)
 933   end
 934
 935   def maybe_direct_follow(%User{} = follower, %User{} = followed) do
 936     if not ap_enabled?(followed) do
 937       follow(follower, followed)
 938     else
 939       {:ok, follower, followed}
 940     end
 941   end
 942
 943   @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
 944   @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
 945   def follow_all(follower, followeds) do
 946     followeds
 947     |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
 948     |> Enum.each(&follow(follower, &1, :follow_accept))
 949
 950     set_cache(follower)
 951   end
 952
 953   def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
 954     deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
 955
 956     cond do
 957       not followed.is_active ->
 958         {:error, "Could not follow user: #{followed.nickname} is deactivated."}
 959
 960       deny_follow_blocked and blocks?(followed, follower) ->
 961         {:error, "Could not follow user: #{followed.nickname} blocked you."}
 962
 963       true ->
 964         FollowingRelationship.follow(follower, followed, state)
 965     end
 966   end
 967
 968   def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
 969     {:error, "Not subscribed!"}
 970   end
 971
 972   @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
 973   def unfollow(%User{} = follower, %User{} = followed) do
 974     case do_unfollow(follower, followed) do
 975       {:ok, follower, followed} ->
 976         {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
 977
 978       error ->
 979         error
 980     end
 981   end
 982
 983   @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
 984   defp do_unfollow(%User{} = follower, %User{} = followed) do
 985     case get_follow_state(follower, followed) do
 986       state when state in [:follow_pending, :follow_accept] ->
 987         FollowingRelationship.unfollow(follower, followed)
 988
 989       nil ->
 990         {:error, "Not subscribed!"}
 991     end
 992   end
 993
 994   @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
 995   def get_follow_state(%User{} = follower, %User{} = following) do
 996     following_relationship = FollowingRelationship.get(follower, following)
 997     get_follow_state(follower, following, following_relationship)
 998   end
 999
1000   def get_follow_state(
1001         %User{} = follower,
1002         %User{} = following,
1003         following_relationship
1004       ) do
1005     case {following_relationship, following.local} do
1006       {nil, false} ->
1007         case Utils.fetch_latest_follow(follower, following) do
1008           %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
1009             FollowingRelationship.state_to_enum(state)
1010
1011           _ ->
1012             nil
1013         end
1014
1015       {%{state: state}, _} ->
1016         state
1017
1018       {nil, _} ->
1019         nil
1020     end
1021   end
1022
1023   def locked?(%User{} = user) do
1024     user.is_locked || false
1025   end
1026
1027   def get_by_id(id) do
1028     Repo.get_by(User, id: id)
1029   end
1030
1031   def get_by_ap_id(ap_id) do
1032     Repo.get_by(User, ap_id: ap_id)
1033   end
1034
1035   def get_all_by_ap_id(ap_ids) do
1036     from(u in __MODULE__,
1037       where: u.ap_id in ^ap_ids
1038     )
1039     |> Repo.all()
1040   end
1041
1042   def get_all_by_ids(ids) do
1043     from(u in __MODULE__, where: u.id in ^ids)
1044     |> Repo.all()
1045   end
1046
1047   # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
1048   # of the ap_id and the domain and tries to get that user
1049   def get_by_guessed_nickname(ap_id) do
1050     domain = URI.parse(ap_id).host
1051     name = List.last(String.split(ap_id, "/"))
1052     nickname = "#{name}@#{domain}"
1053
1054     get_cached_by_nickname(nickname)
1055   end
1056
1057   def set_cache({:ok, user}), do: set_cache(user)
1058   def set_cache({:error, err}), do: {:error, err}
1059
1060   def set_cache(%User{} = user) do
1061     @cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1062     @cachex.put(:user_cache, "nickname:#{user.nickname}", user)
1063     @cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
1064     {:ok, user}
1065   end
1066
1067   def update_and_set_cache(struct, params) do
1068     struct
1069     |> update_changeset(params)
1070     |> update_and_set_cache()
1071   end
1072
1073   def update_and_set_cache(changeset) do
1074     with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
1075       set_cache(user)
1076     end
1077   end
1078
1079   def get_user_friends_ap_ids(user) do
1080     from(u in User.get_friends_query(user), select: u.ap_id)
1081     |> Repo.all()
1082   end
1083
1084   @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
1085   def get_cached_user_friends_ap_ids(user) do
1086     @cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
1087       get_user_friends_ap_ids(user)
1088     end)
1089   end
1090
1091   def invalidate_cache(user) do
1092     @cachex.del(:user_cache, "ap_id:#{user.ap_id}")
1093     @cachex.del(:user_cache, "nickname:#{user.nickname}")
1094     @cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
1095     @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
1096     @cachex.del(:user_cache, "muted_users_ap_ids:#{user.ap_id}")
1097   end
1098
1099   @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
1100   def get_cached_by_ap_id(ap_id) do
1101     key = "ap_id:#{ap_id}"
1102
1103     with {:ok, nil} <- @cachex.get(:user_cache, key),
1104          user when not is_nil(user) <- get_by_ap_id(ap_id),
1105          {:ok, true} <- @cachex.put(:user_cache, key, user) do
1106       user
1107     else
1108       {:ok, user} -> user
1109       nil -> nil
1110     end
1111   end
1112
1113   def get_cached_by_id(id) do
1114     key = "id:#{id}"
1115
1116     ap_id =
1117       @cachex.fetch!(:user_cache, key, fn _ ->
1118         user = get_by_id(id)
1119
1120         if user do
1121           @cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1122           {:commit, user.ap_id}
1123         else
1124           {:ignore, ""}
1125         end
1126       end)
1127
1128     get_cached_by_ap_id(ap_id)
1129   end
1130
1131   def get_cached_by_nickname(nickname) do
1132     key = "nickname:#{nickname}"
1133
1134     @cachex.fetch!(:user_cache, key, fn _ ->
1135       case get_or_fetch_by_nickname(nickname) do
1136         {:ok, user} -> {:commit, user}
1137         {:error, _error} -> {:ignore, nil}
1138       end
1139     end)
1140   end
1141
1142   def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
1143     restrict_to_local = Config.get([:instance, :limit_to_local_content])
1144
1145     cond do
1146       is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
1147         get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
1148
1149       restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
1150         get_cached_by_nickname(nickname_or_id)
1151
1152       restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
1153         get_cached_by_nickname(nickname_or_id)
1154
1155       true ->
1156         nil
1157     end
1158   end
1159
1160   @spec get_by_nickname(String.t()) :: User.t() | nil
1161   def get_by_nickname(nickname) do
1162     Repo.get_by(User, nickname: nickname) ||
1163       if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
1164         Repo.get_by(User, nickname: local_nickname(nickname))
1165       end
1166   end
1167
1168   def get_by_email(email), do: Repo.get_by(User, email: email)
1169
1170   def get_by_nickname_or_email(nickname_or_email) do
1171     get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
1172   end
1173
1174   def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
1175
1176   def get_or_fetch_by_nickname(nickname) do
1177     with %User{} = user <- get_by_nickname(nickname) do
1178       {:ok, user}
1179     else
1180       _e ->
1181         with [_nick, _domain] <- String.split(nickname, "@"),
1182              {:ok, user} <- fetch_by_nickname(nickname) do
1183           {:ok, user}
1184         else
1185           _e -> {:error, "not found " <> nickname}
1186         end
1187     end
1188   end
1189
1190   @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1191   def get_followers_query(%User{} = user, nil) do
1192     User.Query.build(%{followers: user, is_active: true})
1193   end
1194
1195   def get_followers_query(%User{} = user, page) do
1196     user
1197     |> get_followers_query(nil)
1198     |> User.Query.paginate(page, 20)
1199   end
1200
1201   @spec get_followers_query(User.t()) :: Ecto.Query.t()
1202   def get_followers_query(%User{} = user), do: get_followers_query(user, nil)
1203
1204   @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1205   def get_followers(%User{} = user, page \\ nil) do
1206     user
1207     |> get_followers_query(page)
1208     |> Repo.all()
1209   end
1210
1211   @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1212   def get_external_followers(%User{} = user, page \\ nil) do
1213     user
1214     |> get_followers_query(page)
1215     |> User.Query.build(%{external: true})
1216     |> Repo.all()
1217   end
1218
1219   def get_followers_ids(%User{} = user, page \\ nil) do
1220     user
1221     |> get_followers_query(page)
1222     |> select([u], u.id)
1223     |> Repo.all()
1224   end
1225
1226   @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1227   def get_friends_query(%User{} = user, nil) do
1228     User.Query.build(%{friends: user, deactivated: false})
1229   end
1230
1231   def get_friends_query(%User{} = user, page) do
1232     user
1233     |> get_friends_query(nil)
1234     |> User.Query.paginate(page, 20)
1235   end
1236
1237   @spec get_friends_query(User.t()) :: Ecto.Query.t()
1238   def get_friends_query(%User{} = user), do: get_friends_query(user, nil)
1239
1240   def get_friends(%User{} = user, page \\ nil) do
1241     user
1242     |> get_friends_query(page)
1243     |> Repo.all()
1244   end
1245
1246   def get_friends_ap_ids(%User{} = user) do
1247     user
1248     |> get_friends_query(nil)
1249     |> select([u], u.ap_id)
1250     |> Repo.all()
1251   end
1252
1253   def get_friends_ids(%User{} = user, page \\ nil) do
1254     user
1255     |> get_friends_query(page)
1256     |> select([u], u.id)
1257     |> Repo.all()
1258   end
1259
1260   def increase_note_count(%User{} = user) do
1261     User
1262     |> where(id: ^user.id)
1263     |> update([u], inc: [note_count: 1])
1264     |> select([u], u)
1265     |> Repo.update_all([])
1266     |> case do
1267       {1, [user]} -> set_cache(user)
1268       _ -> {:error, user}
1269     end
1270   end
1271
1272   def decrease_note_count(%User{} = user) do
1273     User
1274     |> where(id: ^user.id)
1275     |> update([u],
1276       set: [
1277         note_count: fragment("greatest(0, note_count - 1)")
1278       ]
1279     )
1280     |> select([u], u)
1281     |> Repo.update_all([])
1282     |> case do
1283       {1, [user]} -> set_cache(user)
1284       _ -> {:error, user}
1285     end
1286   end
1287
1288   def update_note_count(%User{} = user, note_count \\ nil) do
1289     note_count =
1290       note_count ||
1291         from(
1292           a in Object,
1293           where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1294           select: count(a.id)
1295         )
1296         |> Repo.one()
1297
1298     user
1299     |> cast(%{note_count: note_count}, [:note_count])
1300     |> update_and_set_cache()
1301   end
1302
1303   @spec maybe_fetch_follow_information(User.t()) :: User.t()
1304   def maybe_fetch_follow_information(user) do
1305     with {:ok, user} <- fetch_follow_information(user) do
1306       user
1307     else
1308       e ->
1309         Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1310
1311         user
1312     end
1313   end
1314
1315   def fetch_follow_information(user) do
1316     with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1317       user
1318       |> follow_information_changeset(info)
1319       |> update_and_set_cache()
1320     end
1321   end
1322
1323   defp follow_information_changeset(user, params) do
1324     user
1325     |> cast(params, [
1326       :hide_followers,
1327       :hide_follows,
1328       :follower_count,
1329       :following_count,
1330       :hide_followers_count,
1331       :hide_follows_count
1332     ])
1333   end
1334
1335   @spec update_follower_count(User.t()) :: {:ok, User.t()}
1336   def update_follower_count(%User{} = user) do
1337     if user.local or !Config.get([:instance, :external_user_synchronization]) do
1338       follower_count = FollowingRelationship.follower_count(user)
1339
1340       user
1341       |> follow_information_changeset(%{follower_count: follower_count})
1342       |> update_and_set_cache
1343     else
1344       {:ok, maybe_fetch_follow_information(user)}
1345     end
1346   end
1347
1348   @spec update_following_count(User.t()) :: {:ok, User.t()}
1349   def update_following_count(%User{local: false} = user) do
1350     if Config.get([:instance, :external_user_synchronization]) do
1351       {:ok, maybe_fetch_follow_information(user)}
1352     else
1353       {:ok, user}
1354     end
1355   end
1356
1357   def update_following_count(%User{local: true} = user) do
1358     following_count = FollowingRelationship.following_count(user)
1359
1360     user
1361     |> follow_information_changeset(%{following_count: following_count})
1362     |> update_and_set_cache()
1363   end
1364
1365   @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1366   def get_users_from_set(ap_ids, opts \\ []) do
1367     local_only = Keyword.get(opts, :local_only, true)
1368     criteria = %{ap_id: ap_ids, is_active: true}
1369     criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1370
1371     User.Query.build(criteria)
1372     |> Repo.all()
1373   end
1374
1375   @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1376   def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1377     to = [actor | to]
1378
1379     query = User.Query.build(%{recipients_from_activity: to, local: true, is_active: true})
1380
1381     query
1382     |> Repo.all()
1383   end
1384
1385   @spec mute(User.t(), User.t(), map()) ::
1386           {:ok, list(UserRelationship.t())} | {:error, String.t()}
1387   def mute(%User{} = muter, %User{} = mutee, params \\ %{}) do
1388     notifications? = Map.get(params, :notifications, true)
1389     expires_in = Map.get(params, :expires_in, 0)
1390
1391     with {:ok, user_mute} <- UserRelationship.create_mute(muter, mutee),
1392          {:ok, user_notification_mute} <-
1393            (notifications? && UserRelationship.create_notification_mute(muter, mutee)) ||
1394              {:ok, nil} do
1395       if expires_in > 0 do
1396         Pleroma.Workers.MuteExpireWorker.enqueue(
1397           "unmute_user",
1398           %{"muter_id" => muter.id, "mutee_id" => mutee.id},
1399           schedule_in: expires_in
1400         )
1401       end
1402
1403       @cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
1404
1405       {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
1406     end
1407   end
1408
1409   def unmute(%User{} = muter, %User{} = mutee) do
1410     with {:ok, user_mute} <- UserRelationship.delete_mute(muter, mutee),
1411          {:ok, user_notification_mute} <-
1412            UserRelationship.delete_notification_mute(muter, mutee) do
1413       @cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
1414       {:ok, [user_mute, user_notification_mute]}
1415     end
1416   end
1417
1418   def unmute(muter_id, mutee_id) do
1419     with {:muter, %User{} = muter} <- {:muter, User.get_by_id(muter_id)},
1420          {:mutee, %User{} = mutee} <- {:mutee, User.get_by_id(mutee_id)} do
1421       unmute(muter, mutee)
1422     else
1423       {who, result} = error ->
1424         Logger.warn(
1425           "User.unmute/2 failed. #{who}: #{result}, muter_id: #{muter_id}, mutee_id: #{mutee_id}"
1426         )
1427
1428         {:error, error}
1429     end
1430   end
1431
1432   def subscribe(%User{} = subscriber, %User{} = target) do
1433     deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
1434
1435     if blocks?(target, subscriber) and deny_follow_blocked do
1436       {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1437     else
1438       # Note: the relationship is inverse: subscriber acts as relationship target
1439       UserRelationship.create_inverse_subscription(target, subscriber)
1440     end
1441   end
1442
1443   def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1444     with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1445       subscribe(subscriber, subscribee)
1446     end
1447   end
1448
1449   def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1450     # Note: the relationship is inverse: subscriber acts as relationship target
1451     UserRelationship.delete_inverse_subscription(target, unsubscriber)
1452   end
1453
1454   def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1455     with %User{} = user <- get_cached_by_ap_id(ap_id) do
1456       unsubscribe(unsubscriber, user)
1457     end
1458   end
1459
1460   def block(%User{} = blocker, %User{} = blocked) do
1461     # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1462     blocker =
1463       if following?(blocker, blocked) do
1464         {:ok, blocker, _} = unfollow(blocker, blocked)
1465         blocker
1466       else
1467         blocker
1468       end
1469
1470     # clear any requested follows as well
1471     blocked =
1472       case CommonAPI.reject_follow_request(blocked, blocker) do
1473         {:ok, %User{} = updated_blocked} -> updated_blocked
1474         nil -> blocked
1475       end
1476
1477     unsubscribe(blocked, blocker)
1478
1479     unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
1480     if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)
1481
1482     {:ok, blocker} = update_follower_count(blocker)
1483     {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1484     add_to_block(blocker, blocked)
1485   end
1486
1487   # helper to handle the block given only an actor's AP id
1488   def block(%User{} = blocker, %{ap_id: ap_id}) do
1489     block(blocker, get_cached_by_ap_id(ap_id))
1490   end
1491
1492   def unblock(%User{} = blocker, %User{} = blocked) do
1493     remove_from_block(blocker, blocked)
1494   end
1495
1496   # helper to handle the block given only an actor's AP id
1497   def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1498     unblock(blocker, get_cached_by_ap_id(ap_id))
1499   end
1500
1501   def mutes?(nil, _), do: false
1502   def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1503
1504   def mutes_user?(%User{} = user, %User{} = target) do
1505     UserRelationship.mute_exists?(user, target)
1506   end
1507
1508   @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1509   def muted_notifications?(nil, _), do: false
1510
1511   def muted_notifications?(%User{} = user, %User{} = target),
1512     do: UserRelationship.notification_mute_exists?(user, target)
1513
1514   def blocks?(nil, _), do: false
1515
1516   def blocks?(%User{} = user, %User{} = target) do
1517     blocks_user?(user, target) ||
1518       (blocks_domain?(user, target) and not User.following?(user, target))
1519   end
1520
1521   def blocks_user?(%User{} = user, %User{} = target) do
1522     UserRelationship.block_exists?(user, target)
1523   end
1524
1525   def blocks_user?(_, _), do: false
1526
1527   def blocks_domain?(%User{} = user, %User{} = target) do
1528     domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1529     %{host: host} = URI.parse(target.ap_id)
1530     Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1531   end
1532
1533   def blocks_domain?(_, _), do: false
1534
1535   def subscribed_to?(%User{} = user, %User{} = target) do
1536     # Note: the relationship is inverse: subscriber acts as relationship target
1537     UserRelationship.inverse_subscription_exists?(target, user)
1538   end
1539
1540   def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1541     with %User{} = target <- get_cached_by_ap_id(ap_id) do
1542       subscribed_to?(user, target)
1543     end
1544   end
1545
1546   @doc """
1547   Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1548   E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1549   """
1550   @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1551   def outgoing_relationships_ap_ids(_user, []), do: %{}
1552
1553   def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1554
1555   def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1556       when is_list(relationship_types) do
1557     db_result =
1558       user
1559       |> assoc(:outgoing_relationships)
1560       |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1561       |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1562       |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1563       |> group_by([user_rel, u], user_rel.relationship_type)
1564       |> Repo.all()
1565       |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1566
1567     Enum.into(
1568       relationship_types,
1569       %{},
1570       fn rel_type -> {rel_type, db_result[rel_type] || []} end
1571     )
1572   end
1573
1574   def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1575
1576   def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1577
1578   def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1579
1580   def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1581       when is_list(relationship_types) do
1582     user
1583     |> assoc(:incoming_relationships)
1584     |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1585     |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1586     |> maybe_filter_on_ap_id(ap_ids)
1587     |> select([user_rel, u], u.ap_id)
1588     |> distinct(true)
1589     |> Repo.all()
1590   end
1591
1592   defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1593     where(query, [user_rel, u], u.ap_id in ^ap_ids)
1594   end
1595
1596   defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1597
1598   def set_activation_async(user, status \\ true) do
1599     BackgroundWorker.enqueue("user_activation", %{"user_id" => user.id, "status" => status})
1600   end
1601
1602   @spec set_activation([User.t()], boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
1603   def set_activation(users, status) when is_list(users) do
1604     Repo.transaction(fn ->
1605       for user <- users, do: set_activation(user, status)
1606     end)
1607   end
1608
1609   @spec set_activation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
1610   def set_activation(%User{} = user, status) do
1611     with {:ok, user} <- set_activation_status(user, status) do
1612       user
1613       |> get_followers()
1614       |> Enum.filter(& &1.local)
1615       |> Enum.each(&set_cache(update_following_count(&1)))
1616
1617       # Only update local user counts, remote will be update during the next pull.
1618       user
1619       |> get_friends()
1620       |> Enum.filter(& &1.local)
1621       |> Enum.each(&do_unfollow(user, &1))
1622
1623       {:ok, user}
1624     end
1625   end
1626
1627   def approve(users) when is_list(users) do
1628     Repo.transaction(fn ->
1629       Enum.map(users, fn user ->
1630         with {:ok, user} <- approve(user), do: user
1631       end)
1632     end)
1633   end
1634
1635   def approve(%User{is_approved: false} = user) do
1636     with chg <- change(user, is_approved: true),
1637          {:ok, user} <- update_and_set_cache(chg) do
1638       post_register_action(user)
1639       {:ok, user}
1640     end
1641   end
1642
1643   def approve(%User{} = user), do: {:ok, user}
1644
1645   def confirm(users) when is_list(users) do
1646     Repo.transaction(fn ->
1647       Enum.map(users, fn user ->
1648         with {:ok, user} <- confirm(user), do: user
1649       end)
1650     end)
1651   end
1652
1653   def confirm(%User{is_confirmed: false} = user) do
1654     with chg <- confirmation_changeset(user, set_confirmation: true),
1655          {:ok, user} <- update_and_set_cache(chg) do
1656       post_register_action(user)
1657       {:ok, user}
1658     end
1659   end
1660
1661   def confirm(%User{} = user), do: {:ok, user}
1662
1663   def update_notification_settings(%User{} = user, settings) do
1664     user
1665     |> cast(%{notification_settings: settings}, [])
1666     |> cast_embed(:notification_settings)
1667     |> validate_required([:notification_settings])
1668     |> update_and_set_cache()
1669   end
1670
1671   @spec purge_user_changeset(User.t()) :: Changeset.t()
1672   def purge_user_changeset(user) do
1673     # "Right to be forgotten"
1674     # https://gdpr.eu/right-to-be-forgotten/
1675     change(user, %{
1676       bio: "",
1677       raw_bio: nil,
1678       email: nil,
1679       name: nil,
1680       password_hash: nil,
1681       keys: nil,
1682       public_key: nil,
1683       avatar: %{},
1684       tags: [],
1685       last_refreshed_at: nil,
1686       last_digest_emailed_at: nil,
1687       banner: %{},
1688       background: %{},
1689       note_count: 0,
1690       follower_count: 0,
1691       following_count: 0,
1692       is_locked: false,
1693       is_confirmed: true,
1694       password_reset_pending: false,
1695       is_approved: true,
1696       registration_reason: nil,
1697       confirmation_token: nil,
1698       domain_blocks: [],
1699       is_active: false,
1700       ap_enabled: false,
1701       is_moderator: false,
1702       is_admin: false,
1703       mastofe_settings: nil,
1704       mascot: nil,
1705       emoji: %{},
1706       pleroma_settings_store: %{},
1707       fields: [],
1708       raw_fields: [],
1709       is_discoverable: false,
1710       also_known_as: []
1711     })
1712   end
1713
1714   def delete(users) when is_list(users) do
1715     for user <- users, do: delete(user)
1716   end
1717
1718   def delete(%User{} = user) do
1719     BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1720   end
1721
1722   defp delete_and_invalidate_cache(%User{} = user) do
1723     invalidate_cache(user)
1724     Repo.delete(user)
1725   end
1726
1727   defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)
1728
1729   defp delete_or_deactivate(%User{local: true} = user) do
1730     status = account_status(user)
1731
1732     case status do
1733       :confirmation_pending ->
1734         delete_and_invalidate_cache(user)
1735
1736       :approval_pending ->
1737         delete_and_invalidate_cache(user)
1738
1739       _ ->
1740         user
1741         |> purge_user_changeset()
1742         |> update_and_set_cache()
1743     end
1744   end
1745
1746   def perform(:force_password_reset, user), do: force_password_reset(user)
1747
1748   @spec perform(atom(), User.t()) :: {:ok, User.t()}
1749   def perform(:delete, %User{} = user) do
1750     # Remove all relationships
1751     user
1752     |> get_followers()
1753     |> Enum.each(fn follower ->
1754       ActivityPub.unfollow(follower, user)
1755       unfollow(follower, user)
1756     end)
1757
1758     user
1759     |> get_friends()
1760     |> Enum.each(fn followed ->
1761       ActivityPub.unfollow(user, followed)
1762       unfollow(user, followed)
1763     end)
1764
1765     delete_user_activities(user)
1766     delete_notifications_from_user_activities(user)
1767
1768     delete_outgoing_pending_follow_requests(user)
1769
1770     delete_or_deactivate(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     |> validate_required([:email])
2232     |> unique_constraint(:email)
2233     |> validate_format(:email, @email_regex)
2234     |> update_and_set_cache()
2235   end
2236
2237   # Internal function; public one is `deactivate/2`
2238   defp set_activation_status(user, status) do
2239     user
2240     |> cast(%{is_active: status}, [:is_active])
2241     |> update_and_set_cache()
2242   end
2243
2244   def update_banner(user, banner) do
2245     user
2246     |> cast(%{banner: banner}, [:banner])
2247     |> update_and_set_cache()
2248   end
2249
2250   def update_background(user, background) do
2251     user
2252     |> cast(%{background: background}, [:background])
2253     |> update_and_set_cache()
2254   end
2255
2256   def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
2257     %{
2258       admin: is_admin,
2259       moderator: is_moderator
2260     }
2261   end
2262
2263   def validate_fields(changeset, remote? \\ false) do
2264     limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2265     limit = Config.get([:instance, limit_name], 0)
2266
2267     changeset
2268     |> validate_length(:fields, max: limit)
2269     |> validate_change(:fields, fn :fields, fields ->
2270       if Enum.all?(fields, &valid_field?/1) do
2271         []
2272       else
2273         [fields: "invalid"]
2274       end
2275     end)
2276   end
2277
2278   defp valid_field?(%{"name" => name, "value" => value}) do
2279     name_limit = Config.get([:instance, :account_field_name_length], 255)
2280     value_limit = Config.get([:instance, :account_field_value_length], 255)
2281
2282     is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2283       String.length(value) <= value_limit
2284   end
2285
2286   defp valid_field?(_), do: false
2287
2288   defp truncate_field(%{"name" => name, "value" => value}) do
2289     {name, _chopped} =
2290       String.split_at(name, Config.get([:instance, :account_field_name_length], 255))
2291
2292     {value, _chopped} =
2293       String.split_at(value, Config.get([:instance, :account_field_value_length], 255))
2294
2295     %{"name" => name, "value" => value}
2296   end
2297
2298   def admin_api_update(user, params) do
2299     user
2300     |> cast(params, [
2301       :is_moderator,
2302       :is_admin,
2303       :show_role
2304     ])
2305     |> update_and_set_cache()
2306   end
2307
2308   @doc "Signs user out of all applications"
2309   def global_sign_out(user) do
2310     OAuth.Authorization.delete_user_authorizations(user)
2311     OAuth.Token.delete_user_tokens(user)
2312   end
2313
2314   def mascot_update(user, url) do
2315     user
2316     |> cast(%{mascot: url}, [:mascot])
2317     |> validate_required([:mascot])
2318     |> update_and_set_cache()
2319   end
2320
2321   def mastodon_settings_update(user, settings) do
2322     user
2323     |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
2324     |> validate_required([:mastofe_settings])
2325     |> update_and_set_cache()
2326   end
2327
2328   @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2329   def confirmation_changeset(user, set_confirmation: confirmed?) do
2330     params =
2331       if confirmed? do
2332         %{
2333           is_confirmed: true,
2334           confirmation_token: nil
2335         }
2336       else
2337         %{
2338           is_confirmed: false,
2339           confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2340         }
2341       end
2342
2343     cast(user, params, [:is_confirmed, :confirmation_token])
2344   end
2345
2346   @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
2347   def approval_changeset(user, set_approval: approved?) do
2348     cast(user, %{is_approved: approved?}, [:is_approved])
2349   end
2350
2351   def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2352     if id not in user.pinned_activities do
2353       max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2354       params = %{pinned_activities: user.pinned_activities ++ [id]}
2355
2356       # if pinned activity was scheduled for deletion, we remove job
2357       if expiration = Pleroma.Workers.PurgeExpiredActivity.get_expiration(id) do
2358         Oban.cancel_job(expiration.id)
2359       end
2360
2361       user
2362       |> cast(params, [:pinned_activities])
2363       |> validate_length(:pinned_activities,
2364         max: max_pinned_statuses,
2365         message: "You have already pinned the maximum number of statuses"
2366       )
2367     else
2368       change(user)
2369     end
2370     |> update_and_set_cache()
2371   end
2372
2373   def remove_pinnned_activity(user, %Pleroma.Activity{id: id, data: data}) do
2374     params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2375
2376     # if pinned activity was scheduled for deletion, we reschedule it for deletion
2377     if data["expires_at"] do
2378       # MRF.ActivityExpirationPolicy used UTC timestamps for expires_at in original implementation
2379       {:ok, expires_at} =
2380         data["expires_at"] |> Pleroma.EctoType.ActivityPub.ObjectValidators.DateTime.cast()
2381
2382       Pleroma.Workers.PurgeExpiredActivity.enqueue(%{
2383         activity_id: id,
2384         expires_at: expires_at
2385       })
2386     end
2387
2388     user
2389     |> cast(params, [:pinned_activities])
2390     |> update_and_set_cache()
2391   end
2392
2393   def update_email_notifications(user, settings) do
2394     email_notifications =
2395       user.email_notifications
2396       |> Map.merge(settings)
2397       |> Map.take(["digest"])
2398
2399     params = %{email_notifications: email_notifications}
2400     fields = [:email_notifications]
2401
2402     user
2403     |> cast(params, fields)
2404     |> validate_required(fields)
2405     |> update_and_set_cache()
2406   end
2407
2408   defp set_domain_blocks(user, domain_blocks) do
2409     params = %{domain_blocks: domain_blocks}
2410
2411     user
2412     |> cast(params, [:domain_blocks])
2413     |> validate_required([:domain_blocks])
2414     |> update_and_set_cache()
2415   end
2416
2417   def block_domain(user, domain_blocked) do
2418     set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2419   end
2420
2421   def unblock_domain(user, domain_blocked) do
2422     set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2423   end
2424
2425   @spec add_to_block(User.t(), User.t()) ::
2426           {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2427   defp add_to_block(%User{} = user, %User{} = blocked) do
2428     with {:ok, relationship} <- UserRelationship.create_block(user, blocked) do
2429       @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
2430       {:ok, relationship}
2431     end
2432   end
2433
2434   @spec add_to_block(User.t(), User.t()) ::
2435           {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2436   defp remove_from_block(%User{} = user, %User{} = blocked) do
2437     with {:ok, relationship} <- UserRelationship.delete_block(user, blocked) do
2438       @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
2439       {:ok, relationship}
2440     end
2441   end
2442
2443   def set_invisible(user, invisible) do
2444     params = %{invisible: invisible}
2445
2446     user
2447     |> cast(params, [:invisible])
2448     |> validate_required([:invisible])
2449     |> update_and_set_cache()
2450   end
2451
2452   def sanitize_html(%User{} = user) do
2453     sanitize_html(user, nil)
2454   end
2455
2456   # User data that mastodon isn't filtering (treated as plaintext):
2457   # - field name
2458   # - display name
2459   def sanitize_html(%User{} = user, filter) do
2460     fields =
2461       Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2462         %{
2463           "name" => name,
2464           "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2465         }
2466       end)
2467
2468     user
2469     |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2470     |> Map.put(:fields, fields)
2471   end
2472
2473   def get_host(%User{ap_id: ap_id} = _user) do
2474     URI.parse(ap_id).host
2475   end
2476
2477   def update_last_active_at(%__MODULE__{local: true} = user) do
2478     user
2479     |> cast(%{last_active_at: NaiveDateTime.utc_now()}, [:last_active_at])
2480     |> update_and_set_cache()
2481   end
2482
2483   def active_user_count(weeks \\ 4) do
2484     active_after = Timex.shift(NaiveDateTime.utc_now(), weeks: -weeks)
2485
2486     __MODULE__
2487     |> where([u], u.last_active_at >= ^active_after)
2488     |> where([u], u.local == true)
2489     |> Repo.aggregate(:count)
2490   end
2491 end