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