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