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