git.squeep.com Git - akkoma/blob - lib/pleroma/user.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.User do
   6   use Ecto.Schema
   7
   8   import Ecto.Changeset
   9   import Ecto.Query
  10   import Ecto, only: [assoc: 2]
  11
  12   alias Ecto.Multi
  13   alias Pleroma.Activity
  14   alias Pleroma.Config
  15   alias Pleroma.Conversation.Participation
  16   alias Pleroma.Delivery
  17   alias Pleroma.EctoType.ActivityPub.ObjectValidators
  18   alias Pleroma.Emoji
  19   alias Pleroma.FollowingRelationship
  20   alias Pleroma.Formatter
  21   alias Pleroma.HTML
  22   alias Pleroma.Keys
  23   alias Pleroma.MFA
  24   alias Pleroma.Notification
  25   alias Pleroma.Object
  26   alias Pleroma.Registration
  27   alias Pleroma.Repo
  28   alias Pleroma.User
  29   alias Pleroma.UserRelationship
  30   alias Pleroma.Web
  31   alias Pleroma.Web.ActivityPub.ActivityPub
  32   alias Pleroma.Web.ActivityPub.Builder
  33   alias Pleroma.Web.ActivityPub.Pipeline
  34   alias Pleroma.Web.ActivityPub.Utils
  35   alias Pleroma.Web.CommonAPI
  36   alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
  37   alias Pleroma.Web.OAuth
  38   alias Pleroma.Web.RelMe
  39   alias Pleroma.Workers.BackgroundWorker
  40
  41   require Logger
  42
  43   @type t :: %__MODULE__{}
  44   @type account_status ::
  45           :active
  46           | :deactivated
  47           | :password_reset_pending
  48           | :confirmation_pending
  49           | :approval_pending
  50   @primary_key {:id, FlakeId.Ecto.CompatType, autogenerate: true}
  51
  52   # credo:disable-for-next-line Credo.Check.Readability.MaxLineLength
  53   @email_regex ~r/^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/
  54   @url_regex ~r/^https?:\/\/[^\s]{1,256}$/
  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(:is_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{local: true, approval_pending: true}), do: :approval_pending
 280
 281   def account_status(%User{local: true, 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         :is_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         :is_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         :also_known_as,
 494         :background,
 495         :show_role,
 496         :skip_thread_containment,
 497         :fields,
 498         :raw_fields,
 499         :pleroma_settings_store,
 500         :discoverable,
 501         :actor_type,
 502         :accepts_chat_messages
 503       ]
 504     )
 505     |> unique_constraint(:nickname)
 506     |> validate_format(:nickname, local_nickname_regex())
 507     |> validate_also_known_as()
 508     |> validate_length(:bio, max: bio_limit)
 509     |> validate_length(:name, min: 1, max: name_limit)
 510     |> validate_inclusion(:actor_type, ["Person", "Service"])
 511     |> put_fields()
 512     |> put_emoji()
 513     |> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
 514     |> put_change_if_present(:avatar, &put_upload(&1, :avatar))
 515     |> put_change_if_present(:banner, &put_upload(&1, :banner))
 516     |> put_change_if_present(:background, &put_upload(&1, :background))
 517     |> put_change_if_present(
 518       :pleroma_settings_store,
 519       &{:ok, Map.merge(struct.pleroma_settings_store, &1)}
 520     )
 521     |> validate_fields(false)
 522   end
 523
 524   defp put_fields(changeset) do
 525     if raw_fields = get_change(changeset, :raw_fields) do
 526       raw_fields =
 527         raw_fields
 528         |> Enum.filter(fn %{"name" => n} -> n != "" end)
 529
 530       fields =
 531         raw_fields
 532         |> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)
 533
 534       changeset
 535       |> put_change(:raw_fields, raw_fields)
 536       |> put_change(:fields, fields)
 537     else
 538       changeset
 539     end
 540   end
 541
 542   defp parse_fields(value) do
 543     value
 544     |> Formatter.linkify(mentions_format: :full)
 545     |> elem(0)
 546   end
 547
 548   defp put_emoji(changeset) do
 549     emojified_fields = [:bio, :name, :raw_fields]
 550
 551     if Enum.any?(changeset.changes, fn {k, _} -> k in emojified_fields end) do
 552       bio = Emoji.Formatter.get_emoji_map(get_field(changeset, :bio))
 553       name = Emoji.Formatter.get_emoji_map(get_field(changeset, :name))
 554
 555       emoji = Map.merge(bio, name)
 556
 557       emoji =
 558         changeset
 559         |> get_field(:raw_fields)
 560         |> Enum.reduce(emoji, fn x, acc ->
 561           Map.merge(acc, Emoji.Formatter.get_emoji_map(x["name"] <> x["value"]))
 562         end)
 563
 564       put_change(changeset, :emoji, emoji)
 565     else
 566       changeset
 567     end
 568   end
 569
 570   defp put_change_if_present(changeset, map_field, value_function) do
 571     with {:ok, value} <- fetch_change(changeset, map_field),
 572          {:ok, new_value} <- value_function.(value) do
 573       put_change(changeset, map_field, new_value)
 574     else
 575       _ -> changeset
 576     end
 577   end
 578
 579   defp put_upload(value, type) do
 580     with %Plug.Upload{} <- value,
 581          {:ok, object} <- ActivityPub.upload(value, type: type) do
 582       {:ok, object.data}
 583     end
 584   end
 585
 586   def update_as_admin_changeset(struct, params) do
 587     struct
 588     |> update_changeset(params)
 589     |> cast(params, [:email])
 590     |> delete_change(:also_known_as)
 591     |> unique_constraint(:email)
 592     |> validate_format(:email, @email_regex)
 593     |> validate_inclusion(:actor_type, ["Person", "Service"])
 594   end
 595
 596   @spec update_as_admin(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
 597   def update_as_admin(user, params) do
 598     params = Map.put(params, "password_confirmation", params["password"])
 599     changeset = update_as_admin_changeset(user, params)
 600
 601     if params["password"] do
 602       reset_password(user, changeset, params)
 603     else
 604       User.update_and_set_cache(changeset)
 605     end
 606   end
 607
 608   def password_update_changeset(struct, params) do
 609     struct
 610     |> cast(params, [:password, :password_confirmation])
 611     |> validate_required([:password, :password_confirmation])
 612     |> validate_confirmation(:password)
 613     |> put_password_hash()
 614     |> put_change(:password_reset_pending, false)
 615   end
 616
 617   @spec reset_password(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
 618   def reset_password(%User{} = user, params) do
 619     reset_password(user, user, params)
 620   end
 621
 622   def reset_password(%User{id: user_id} = user, struct, params) do
 623     multi =
 624       Multi.new()
 625       |> Multi.update(:user, password_update_changeset(struct, params))
 626       |> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
 627       |> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))
 628
 629     case Repo.transaction(multi) do
 630       {:ok, %{user: user} = _} -> set_cache(user)
 631       {:error, _, changeset, _} -> {:error, changeset}
 632     end
 633   end
 634
 635   def update_password_reset_pending(user, value) do
 636     user
 637     |> change()
 638     |> put_change(:password_reset_pending, value)
 639     |> update_and_set_cache()
 640   end
 641
 642   def force_password_reset_async(user) do
 643     BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
 644   end
 645
 646   @spec force_password_reset(User.t()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
 647   def force_password_reset(user), do: update_password_reset_pending(user, true)
 648
 649   # Used to auto-register LDAP accounts which won't have a password hash stored locally
 650   def register_changeset_ldap(struct, params = %{password: password})
 651       when is_nil(password) do
 652     params = Map.put_new(params, :accepts_chat_messages, true)
 653
 654     params =
 655       if Map.has_key?(params, :email) do
 656         Map.put_new(params, :email, params[:email])
 657       else
 658         params
 659       end
 660
 661     struct
 662     |> cast(params, [
 663       :name,
 664       :nickname,
 665       :email,
 666       :accepts_chat_messages
 667     ])
 668     |> validate_required([:name, :nickname])
 669     |> unique_constraint(:nickname)
 670     |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
 671     |> validate_format(:nickname, local_nickname_regex())
 672     |> put_ap_id()
 673     |> unique_constraint(:ap_id)
 674     |> put_following_and_follower_address()
 675   end
 676
 677   def register_changeset(struct, params \\ %{}, opts \\ []) do
 678     bio_limit = Config.get([:instance, :user_bio_length], 5000)
 679     name_limit = Config.get([:instance, :user_name_length], 100)
 680     reason_limit = Config.get([:instance, :registration_reason_length], 500)
 681     params = Map.put_new(params, :accepts_chat_messages, true)
 682
 683     need_confirmation? =
 684       if is_nil(opts[:need_confirmation]) do
 685         Config.get([:instance, :account_activation_required])
 686       else
 687         opts[:need_confirmation]
 688       end
 689
 690     need_approval? =
 691       if is_nil(opts[:need_approval]) do
 692         Config.get([:instance, :account_approval_required])
 693       else
 694         opts[:need_approval]
 695       end
 696
 697     struct
 698     |> confirmation_changeset(need_confirmation: need_confirmation?)
 699     |> approval_changeset(need_approval: need_approval?)
 700     |> cast(params, [
 701       :bio,
 702       :raw_bio,
 703       :email,
 704       :name,
 705       :nickname,
 706       :password,
 707       :password_confirmation,
 708       :emoji,
 709       :accepts_chat_messages,
 710       :registration_reason
 711     ])
 712     |> validate_required([:name, :nickname, :password, :password_confirmation])
 713     |> validate_confirmation(:password)
 714     |> unique_constraint(:email)
 715     |> validate_format(:email, @email_regex)
 716     |> validate_change(:email, fn :email, email ->
 717       valid? =
 718         Config.get([User, :email_blacklist])
 719         |> Enum.all?(fn blacklisted_domain ->
 720           !String.ends_with?(email, ["@" <> blacklisted_domain, "." <> blacklisted_domain])
 721         end)
 722
 723       if valid?, do: [], else: [email: "Invalid email"]
 724     end)
 725     |> unique_constraint(:nickname)
 726     |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
 727     |> validate_format(:nickname, local_nickname_regex())
 728     |> validate_length(:bio, max: bio_limit)
 729     |> validate_length(:name, min: 1, max: name_limit)
 730     |> validate_length(:registration_reason, max: reason_limit)
 731     |> maybe_validate_required_email(opts[:external])
 732     |> put_password_hash
 733     |> put_ap_id()
 734     |> unique_constraint(:ap_id)
 735     |> put_following_and_follower_address()
 736   end
 737
 738   def maybe_validate_required_email(changeset, true), do: changeset
 739
 740   def maybe_validate_required_email(changeset, _) do
 741     if Config.get([:instance, :account_activation_required]) do
 742       validate_required(changeset, [:email])
 743     else
 744       changeset
 745     end
 746   end
 747
 748   defp put_ap_id(changeset) do
 749     ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
 750     put_change(changeset, :ap_id, ap_id)
 751   end
 752
 753   defp put_following_and_follower_address(changeset) do
 754     followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
 755
 756     changeset
 757     |> put_change(:follower_address, followers)
 758   end
 759
 760   defp autofollow_users(user) do
 761     candidates = Config.get([:instance, :autofollowed_nicknames])
 762
 763     autofollowed_users =
 764       User.Query.build(%{nickname: candidates, local: true, deactivated: false})
 765       |> Repo.all()
 766
 767     follow_all(user, autofollowed_users)
 768   end
 769
 770   @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
 771   def register(%Ecto.Changeset{} = changeset) do
 772     with {:ok, user} <- Repo.insert(changeset) do
 773       post_register_action(user)
 774     end
 775   end
 776
 777   def post_register_action(%User{} = user) do
 778     with {:ok, user} <- autofollow_users(user),
 779          {:ok, user} <- set_cache(user),
 780          {:ok, _} <- send_welcome_email(user),
 781          {:ok, _} <- send_welcome_message(user),
 782          {:ok, _} <- send_welcome_chat_message(user),
 783          {:ok, _} <- try_send_confirmation_email(user) do
 784       {:ok, user}
 785     end
 786   end
 787
 788   def send_welcome_message(user) do
 789     if User.WelcomeMessage.enabled?() do
 790       User.WelcomeMessage.post_message(user)
 791       {:ok, :enqueued}
 792     else
 793       {:ok, :noop}
 794     end
 795   end
 796
 797   def send_welcome_chat_message(user) do
 798     if User.WelcomeChatMessage.enabled?() do
 799       User.WelcomeChatMessage.post_message(user)
 800       {:ok, :enqueued}
 801     else
 802       {:ok, :noop}
 803     end
 804   end
 805
 806   def send_welcome_email(%User{email: email} = user) when is_binary(email) do
 807     if User.WelcomeEmail.enabled?() do
 808       User.WelcomeEmail.send_email(user)
 809       {:ok, :enqueued}
 810     else
 811       {:ok, :noop}
 812     end
 813   end
 814
 815   def send_welcome_email(_), do: {:ok, :noop}
 816
 817   @spec try_send_confirmation_email(User.t()) :: {:ok, :enqueued | :noop}
 818   def try_send_confirmation_email(%User{confirmation_pending: true, email: email} = user)
 819       when is_binary(email) do
 820     if Config.get([:instance, :account_activation_required]) do
 821       send_confirmation_email(user)
 822       {:ok, :enqueued}
 823     else
 824       {:ok, :noop}
 825     end
 826   end
 827
 828   def try_send_confirmation_email(_), do: {:ok, :noop}
 829
 830   @spec send_confirmation_email(Uset.t()) :: User.t()
 831   def send_confirmation_email(%User{} = user) do
 832     user
 833     |> Pleroma.Emails.UserEmail.account_confirmation_email()
 834     |> Pleroma.Emails.Mailer.deliver_async()
 835
 836     user
 837   end
 838
 839   def needs_update?(%User{local: true}), do: false
 840
 841   def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
 842
 843   def needs_update?(%User{local: false} = user) do
 844     NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
 845   end
 846
 847   def needs_update?(_), do: true
 848
 849   @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
 850
 851   # "Locked" (self-locked) users demand explicit authorization of follow requests
 852   def maybe_direct_follow(%User{} = follower, %User{local: true, is_locked: true} = followed) do
 853     follow(follower, followed, :follow_pending)
 854   end
 855
 856   def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
 857     follow(follower, followed)
 858   end
 859
 860   def maybe_direct_follow(%User{} = follower, %User{} = followed) do
 861     if not ap_enabled?(followed) do
 862       follow(follower, followed)
 863     else
 864       {:ok, follower}
 865     end
 866   end
 867
 868   @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
 869   @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
 870   def follow_all(follower, followeds) do
 871     followeds
 872     |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
 873     |> Enum.each(&follow(follower, &1, :follow_accept))
 874
 875     set_cache(follower)
 876   end
 877
 878   def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
 879     deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
 880
 881     cond do
 882       followed.deactivated ->
 883         {:error, "Could not follow user: #{followed.nickname} is deactivated."}
 884
 885       deny_follow_blocked and blocks?(followed, follower) ->
 886         {:error, "Could not follow user: #{followed.nickname} blocked you."}
 887
 888       true ->
 889         FollowingRelationship.follow(follower, followed, state)
 890
 891         {:ok, _} = update_follower_count(followed)
 892
 893         follower
 894         |> update_following_count()
 895     end
 896   end
 897
 898   def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
 899     {:error, "Not subscribed!"}
 900   end
 901
 902   @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
 903   def unfollow(%User{} = follower, %User{} = followed) do
 904     case do_unfollow(follower, followed) do
 905       {:ok, follower, followed} ->
 906         {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
 907
 908       error ->
 909         error
 910     end
 911   end
 912
 913   @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
 914   defp do_unfollow(%User{} = follower, %User{} = followed) do
 915     case get_follow_state(follower, followed) do
 916       state when state in [:follow_pending, :follow_accept] ->
 917         FollowingRelationship.unfollow(follower, followed)
 918         {:ok, followed} = update_follower_count(followed)
 919
 920         {:ok, follower} = update_following_count(follower)
 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.is_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{} = 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{} = 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{} = 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{} = 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{} = 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{} = 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{} = user), do: get_friends_query(user, nil)
1172
1173   def get_friends(%User{} = user, page \\ nil) do
1174     user
1175     |> get_friends_query(page)
1176     |> Repo.all()
1177   end
1178
1179   def get_friends_ap_ids(%User{} = 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{} = 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       is_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     |> Repo.chunk_stream(50, :batches)
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, opts \\ []), do: ActivityPub.make_user_from_ap_id(ap_id, opts)
1774
1775   def get_or_fetch_by_ap_id(ap_id, opts \\ []) 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, opts)
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, opts \\ []) do
1852     with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id, opts),
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   @spec need_confirmation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
2076   def need_confirmation(%User{} = user, bool) do
2077     user
2078     |> confirmation_changeset(need_confirmation: bool)
2079     |> update_and_set_cache()
2080   end
2081
2082   def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
2083     mascot
2084   end
2085
2086   def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
2087     # use instance-default
2088     config = Config.get([:assets, :mascots])
2089     default_mascot = Config.get([:assets, :default_mascot])
2090     mascot = Keyword.get(config, default_mascot)
2091
2092     %{
2093       "id" => "default-mascot",
2094       "url" => mascot[:url],
2095       "preview_url" => mascot[:url],
2096       "pleroma" => %{
2097         "mime_type" => mascot[:mime_type]
2098       }
2099     }
2100   end
2101
2102   def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
2103
2104   def ensure_keys_present(%User{} = user) do
2105     with {:ok, pem} <- Keys.generate_rsa_pem() do
2106       user
2107       |> cast(%{keys: pem}, [:keys])
2108       |> validate_required([:keys])
2109       |> update_and_set_cache()
2110     end
2111   end
2112
2113   def get_ap_ids_by_nicknames(nicknames) do
2114     from(u in User,
2115       where: u.nickname in ^nicknames,
2116       select: u.ap_id
2117     )
2118     |> Repo.all()
2119   end
2120
2121   defp put_password_hash(
2122          %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2123        ) do
2124     change(changeset, password_hash: Pbkdf2.hash_pwd_salt(password))
2125   end
2126
2127   defp put_password_hash(changeset), do: changeset
2128
2129   def is_internal_user?(%User{nickname: nil}), do: true
2130   def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2131   def is_internal_user?(_), do: false
2132
2133   # A hack because user delete activities have a fake id for whatever reason
2134   # TODO: Get rid of this
2135   def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2136
2137   def get_delivered_users_by_object_id(object_id) do
2138     from(u in User,
2139       inner_join: delivery in assoc(u, :deliveries),
2140       where: delivery.object_id == ^object_id
2141     )
2142     |> Repo.all()
2143   end
2144
2145   def change_email(user, email) do
2146     user
2147     |> cast(%{email: email}, [:email])
2148     |> validate_required([:email])
2149     |> unique_constraint(:email)
2150     |> validate_format(:email, @email_regex)
2151     |> update_and_set_cache()
2152   end
2153
2154   # Internal function; public one is `deactivate/2`
2155   defp set_activation_status(user, deactivated) do
2156     user
2157     |> cast(%{deactivated: deactivated}, [:deactivated])
2158     |> update_and_set_cache()
2159   end
2160
2161   def update_banner(user, banner) do
2162     user
2163     |> cast(%{banner: banner}, [:banner])
2164     |> update_and_set_cache()
2165   end
2166
2167   def update_background(user, background) do
2168     user
2169     |> cast(%{background: background}, [:background])
2170     |> update_and_set_cache()
2171   end
2172
2173   def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
2174     %{
2175       admin: is_admin,
2176       moderator: is_moderator
2177     }
2178   end
2179
2180   def validate_fields(changeset, remote? \\ false) do
2181     limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2182     limit = Config.get([:instance, limit_name], 0)
2183
2184     changeset
2185     |> validate_length(:fields, max: limit)
2186     |> validate_change(:fields, fn :fields, fields ->
2187       if Enum.all?(fields, &valid_field?/1) do
2188         []
2189       else
2190         [fields: "invalid"]
2191       end
2192     end)
2193   end
2194
2195   defp valid_field?(%{"name" => name, "value" => value}) do
2196     name_limit = Config.get([:instance, :account_field_name_length], 255)
2197     value_limit = Config.get([:instance, :account_field_value_length], 255)
2198
2199     is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2200       String.length(value) <= value_limit
2201   end
2202
2203   defp valid_field?(_), do: false
2204
2205   defp truncate_field(%{"name" => name, "value" => value}) do
2206     {name, _chopped} =
2207       String.split_at(name, Config.get([:instance, :account_field_name_length], 255))
2208
2209     {value, _chopped} =
2210       String.split_at(value, Config.get([:instance, :account_field_value_length], 255))
2211
2212     %{"name" => name, "value" => value}
2213   end
2214
2215   def admin_api_update(user, params) do
2216     user
2217     |> cast(params, [
2218       :is_moderator,
2219       :is_admin,
2220       :show_role
2221     ])
2222     |> update_and_set_cache()
2223   end
2224
2225   @doc "Signs user out of all applications"
2226   def global_sign_out(user) do
2227     OAuth.Authorization.delete_user_authorizations(user)
2228     OAuth.Token.delete_user_tokens(user)
2229   end
2230
2231   def mascot_update(user, url) do
2232     user
2233     |> cast(%{mascot: url}, [:mascot])
2234     |> validate_required([:mascot])
2235     |> update_and_set_cache()
2236   end
2237
2238   def mastodon_settings_update(user, settings) do
2239     user
2240     |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
2241     |> validate_required([:mastofe_settings])
2242     |> update_and_set_cache()
2243   end
2244
2245   @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2246   def confirmation_changeset(user, need_confirmation: need_confirmation?) do
2247     params =
2248       if need_confirmation? do
2249         %{
2250           confirmation_pending: true,
2251           confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2252         }
2253       else
2254         %{
2255           confirmation_pending: false,
2256           confirmation_token: nil
2257         }
2258       end
2259
2260     cast(user, params, [:confirmation_pending, :confirmation_token])
2261   end
2262
2263   @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
2264   def approval_changeset(user, need_approval: need_approval?) do
2265     params = if need_approval?, do: %{approval_pending: true}, else: %{approval_pending: false}
2266     cast(user, params, [:approval_pending])
2267   end
2268
2269   def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2270     if id not in user.pinned_activities do
2271       max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2272       params = %{pinned_activities: user.pinned_activities ++ [id]}
2273
2274       # if pinned activity was scheduled for deletion, we remove job
2275       if expiration = Pleroma.Workers.PurgeExpiredActivity.get_expiration(id) do
2276         Oban.cancel_job(expiration.id)
2277       end
2278
2279       user
2280       |> cast(params, [:pinned_activities])
2281       |> validate_length(:pinned_activities,
2282         max: max_pinned_statuses,
2283         message: "You have already pinned the maximum number of statuses"
2284       )
2285     else
2286       change(user)
2287     end
2288     |> update_and_set_cache()
2289   end
2290
2291   def remove_pinnned_activity(user, %Pleroma.Activity{id: id, data: data}) do
2292     params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2293
2294     # if pinned activity was scheduled for deletion, we reschedule it for deletion
2295     if data["expires_at"] do
2296       # MRF.ActivityExpirationPolicy used UTC timestamps for expires_at in original implementation
2297       {:ok, expires_at} =
2298         data["expires_at"] |> Pleroma.EctoType.ActivityPub.ObjectValidators.DateTime.cast()
2299
2300       Pleroma.Workers.PurgeExpiredActivity.enqueue(%{
2301         activity_id: id,
2302         expires_at: expires_at
2303       })
2304     end
2305
2306     user
2307     |> cast(params, [:pinned_activities])
2308     |> update_and_set_cache()
2309   end
2310
2311   def update_email_notifications(user, settings) do
2312     email_notifications =
2313       user.email_notifications
2314       |> Map.merge(settings)
2315       |> Map.take(["digest"])
2316
2317     params = %{email_notifications: email_notifications}
2318     fields = [:email_notifications]
2319
2320     user
2321     |> cast(params, fields)
2322     |> validate_required(fields)
2323     |> update_and_set_cache()
2324   end
2325
2326   defp set_domain_blocks(user, domain_blocks) do
2327     params = %{domain_blocks: domain_blocks}
2328
2329     user
2330     |> cast(params, [:domain_blocks])
2331     |> validate_required([:domain_blocks])
2332     |> update_and_set_cache()
2333   end
2334
2335   def block_domain(user, domain_blocked) do
2336     set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2337   end
2338
2339   def unblock_domain(user, domain_blocked) do
2340     set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2341   end
2342
2343   @spec add_to_block(User.t(), User.t()) ::
2344           {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2345   defp add_to_block(%User{} = user, %User{} = blocked) do
2346     UserRelationship.create_block(user, blocked)
2347   end
2348
2349   @spec add_to_block(User.t(), User.t()) ::
2350           {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2351   defp remove_from_block(%User{} = user, %User{} = blocked) do
2352     UserRelationship.delete_block(user, blocked)
2353   end
2354
2355   defp add_to_mutes(%User{} = user, %User{} = muted_user, notifications?) do
2356     with {:ok, user_mute} <- UserRelationship.create_mute(user, muted_user),
2357          {:ok, user_notification_mute} <-
2358            (notifications? && UserRelationship.create_notification_mute(user, muted_user)) ||
2359              {:ok, nil} do
2360       {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
2361     end
2362   end
2363
2364   defp remove_from_mutes(user, %User{} = muted_user) do
2365     with {:ok, user_mute} <- UserRelationship.delete_mute(user, muted_user),
2366          {:ok, user_notification_mute} <-
2367            UserRelationship.delete_notification_mute(user, muted_user) do
2368       {:ok, [user_mute, user_notification_mute]}
2369     end
2370   end
2371
2372   def set_invisible(user, invisible) do
2373     params = %{invisible: invisible}
2374
2375     user
2376     |> cast(params, [:invisible])
2377     |> validate_required([:invisible])
2378     |> update_and_set_cache()
2379   end
2380
2381   def sanitize_html(%User{} = user) do
2382     sanitize_html(user, nil)
2383   end
2384
2385   # User data that mastodon isn't filtering (treated as plaintext):
2386   # - field name
2387   # - display name
2388   def sanitize_html(%User{} = user, filter) do
2389     fields =
2390       Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2391         %{
2392           "name" => name,
2393           "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2394         }
2395       end)
2396
2397     user
2398     |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2399     |> Map.put(:fields, fields)
2400   end
2401
2402   defp validate_also_known_as(changeset) do
2403     validate_change(changeset, :also_known_as, fn :also_known_as, also_known_as ->
2404       case Enum.all?(also_known_as, fn a -> Regex.match?(@url_regex, a) end) do
2405         true -> []
2406         false -> [also_known_as: "Invalid ap_id format. Must be a URL."]
2407       end
2408     end)
2409   end
2410 end