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