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

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