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

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