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