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

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