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