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, email: email} = user)
 818       when is_binary(email) do
 819     if Config.get([:instance, :account_activation_required]) do
 820       send_confirmation_email(user)
 821       {:ok, :enqueued}
 822     else
 823       {:ok, :noop}
 824     end
 825   end
 826
 827   def try_send_confirmation_email(_), do: {:ok, :noop}
 828
 829   @spec send_confirmation_email(Uset.t()) :: User.t()
 830   def send_confirmation_email(%User{} = user) do
 831     user
 832     |> Pleroma.Emails.UserEmail.account_confirmation_email()
 833     |> Pleroma.Emails.Mailer.deliver_async()
 834
 835     user
 836   end
 837
 838   def needs_update?(%User{local: true}), do: false
 839
 840   def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
 841
 842   def needs_update?(%User{local: false} = user) do
 843     NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
 844   end
 845
 846   def needs_update?(_), do: true
 847
 848   @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
 849
 850   # "Locked" (self-locked) users demand explicit authorization of follow requests
 851   def maybe_direct_follow(%User{} = follower, %User{local: true, locked: true} = followed) do
 852     follow(follower, followed, :follow_pending)
 853   end
 854
 855   def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
 856     follow(follower, followed)
 857   end
 858
 859   def maybe_direct_follow(%User{} = follower, %User{} = followed) do
 860     if not ap_enabled?(followed) do
 861       follow(follower, followed)
 862     else
 863       {:ok, follower}
 864     end
 865   end
 866
 867   @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
 868   @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
 869   def follow_all(follower, followeds) do
 870     followeds
 871     |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
 872     |> Enum.each(&follow(follower, &1, :follow_accept))
 873
 874     set_cache(follower)
 875   end
 876
 877   def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
 878     deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
 879
 880     cond do
 881       followed.deactivated ->
 882         {:error, "Could not follow user: #{followed.nickname} is deactivated."}
 883
 884       deny_follow_blocked and blocks?(followed, follower) ->
 885         {:error, "Could not follow user: #{followed.nickname} blocked you."}
 886
 887       true ->
 888         FollowingRelationship.follow(follower, followed, state)
 889
 890         {:ok, _} = update_follower_count(followed)
 891
 892         follower
 893         |> update_following_count()
 894     end
 895   end
 896
 897   def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
 898     {:error, "Not subscribed!"}
 899   end
 900
 901   @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
 902   def unfollow(%User{} = follower, %User{} = followed) do
 903     case do_unfollow(follower, followed) do
 904       {:ok, follower, followed} ->
 905         {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
 906
 907       error ->
 908         error
 909     end
 910   end
 911
 912   @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
 913   defp do_unfollow(%User{} = follower, %User{} = followed) do
 914     case get_follow_state(follower, followed) do
 915       state when state in [:follow_pending, :follow_accept] ->
 916         FollowingRelationship.unfollow(follower, followed)
 917         {:ok, followed} = update_follower_count(followed)
 918
 919         {:ok, follower} =
 920           follower
 921           |> update_following_count()
 922
 923         {:ok, follower, followed}
 924
 925       nil ->
 926         {:error, "Not subscribed!"}
 927     end
 928   end
 929
 930   @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
 931   def get_follow_state(%User{} = follower, %User{} = following) do
 932     following_relationship = FollowingRelationship.get(follower, following)
 933     get_follow_state(follower, following, following_relationship)
 934   end
 935
 936   def get_follow_state(
 937         %User{} = follower,
 938         %User{} = following,
 939         following_relationship
 940       ) do
 941     case {following_relationship, following.local} do
 942       {nil, false} ->
 943         case Utils.fetch_latest_follow(follower, following) do
 944           %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
 945             FollowingRelationship.state_to_enum(state)
 946
 947           _ ->
 948             nil
 949         end
 950
 951       {%{state: state}, _} ->
 952         state
 953
 954       {nil, _} ->
 955         nil
 956     end
 957   end
 958
 959   def locked?(%User{} = user) do
 960     user.locked || false
 961   end
 962
 963   def get_by_id(id) do
 964     Repo.get_by(User, id: id)
 965   end
 966
 967   def get_by_ap_id(ap_id) do
 968     Repo.get_by(User, ap_id: ap_id)
 969   end
 970
 971   def get_all_by_ap_id(ap_ids) do
 972     from(u in __MODULE__,
 973       where: u.ap_id in ^ap_ids
 974     )
 975     |> Repo.all()
 976   end
 977
 978   def get_all_by_ids(ids) do
 979     from(u in __MODULE__, where: u.id in ^ids)
 980     |> Repo.all()
 981   end
 982
 983   # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
 984   # of the ap_id and the domain and tries to get that user
 985   def get_by_guessed_nickname(ap_id) do
 986     domain = URI.parse(ap_id).host
 987     name = List.last(String.split(ap_id, "/"))
 988     nickname = "#{name}@#{domain}"
 989
 990     get_cached_by_nickname(nickname)
 991   end
 992
 993   def set_cache({:ok, user}), do: set_cache(user)
 994   def set_cache({:error, err}), do: {:error, err}
 995
 996   def set_cache(%User{} = user) do
 997     Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
 998     Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
 999     Cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
1000     {:ok, user}
1001   end
1002
1003   def update_and_set_cache(struct, params) do
1004     struct
1005     |> update_changeset(params)
1006     |> update_and_set_cache()
1007   end
1008
1009   def update_and_set_cache(changeset) do
1010     with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
1011       set_cache(user)
1012     end
1013   end
1014
1015   def get_user_friends_ap_ids(user) do
1016     from(u in User.get_friends_query(user), select: u.ap_id)
1017     |> Repo.all()
1018   end
1019
1020   @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
1021   def get_cached_user_friends_ap_ids(user) do
1022     Cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
1023       get_user_friends_ap_ids(user)
1024     end)
1025   end
1026
1027   def invalidate_cache(user) do
1028     Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
1029     Cachex.del(:user_cache, "nickname:#{user.nickname}")
1030     Cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
1031   end
1032
1033   @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
1034   def get_cached_by_ap_id(ap_id) do
1035     key = "ap_id:#{ap_id}"
1036
1037     with {:ok, nil} <- Cachex.get(:user_cache, key),
1038          user when not is_nil(user) <- get_by_ap_id(ap_id),
1039          {:ok, true} <- Cachex.put(:user_cache, key, user) do
1040       user
1041     else
1042       {:ok, user} -> user
1043       nil -> nil
1044     end
1045   end
1046
1047   def get_cached_by_id(id) do
1048     key = "id:#{id}"
1049
1050     ap_id =
1051       Cachex.fetch!(:user_cache, key, fn _ ->
1052         user = get_by_id(id)
1053
1054         if user do
1055           Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
1056           {:commit, user.ap_id}
1057         else
1058           {:ignore, ""}
1059         end
1060       end)
1061
1062     get_cached_by_ap_id(ap_id)
1063   end
1064
1065   def get_cached_by_nickname(nickname) do
1066     key = "nickname:#{nickname}"
1067
1068     Cachex.fetch!(:user_cache, key, fn ->
1069       case get_or_fetch_by_nickname(nickname) do
1070         {:ok, user} -> {:commit, user}
1071         {:error, _error} -> {:ignore, nil}
1072       end
1073     end)
1074   end
1075
1076   def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
1077     restrict_to_local = Config.get([:instance, :limit_to_local_content])
1078
1079     cond do
1080       is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
1081         get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
1082
1083       restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
1084         get_cached_by_nickname(nickname_or_id)
1085
1086       restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
1087         get_cached_by_nickname(nickname_or_id)
1088
1089       true ->
1090         nil
1091     end
1092   end
1093
1094   @spec get_by_nickname(String.t()) :: User.t() | nil
1095   def get_by_nickname(nickname) do
1096     Repo.get_by(User, nickname: nickname) ||
1097       if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
1098         Repo.get_by(User, nickname: local_nickname(nickname))
1099       end
1100   end
1101
1102   def get_by_email(email), do: Repo.get_by(User, email: email)
1103
1104   def get_by_nickname_or_email(nickname_or_email) do
1105     get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
1106   end
1107
1108   def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
1109
1110   def get_or_fetch_by_nickname(nickname) do
1111     with %User{} = user <- get_by_nickname(nickname) do
1112       {:ok, user}
1113     else
1114       _e ->
1115         with [_nick, _domain] <- String.split(nickname, "@"),
1116              {:ok, user} <- fetch_by_nickname(nickname) do
1117           {:ok, user}
1118         else
1119           _e -> {:error, "not found " <> nickname}
1120         end
1121     end
1122   end
1123
1124   @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1125   def get_followers_query(%User{} = user, nil) do
1126     User.Query.build(%{followers: user, deactivated: false})
1127   end
1128
1129   def get_followers_query(%User{} = user, page) do
1130     user
1131     |> get_followers_query(nil)
1132     |> User.Query.paginate(page, 20)
1133   end
1134
1135   @spec get_followers_query(User.t()) :: Ecto.Query.t()
1136   def get_followers_query(%User{} = user), do: get_followers_query(user, nil)
1137
1138   @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1139   def get_followers(%User{} = user, page \\ nil) do
1140     user
1141     |> get_followers_query(page)
1142     |> Repo.all()
1143   end
1144
1145   @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1146   def get_external_followers(%User{} = user, page \\ nil) do
1147     user
1148     |> get_followers_query(page)
1149     |> User.Query.build(%{external: true})
1150     |> Repo.all()
1151   end
1152
1153   def get_followers_ids(%User{} = user, page \\ nil) do
1154     user
1155     |> get_followers_query(page)
1156     |> select([u], u.id)
1157     |> Repo.all()
1158   end
1159
1160   @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1161   def get_friends_query(%User{} = user, nil) do
1162     User.Query.build(%{friends: user, deactivated: false})
1163   end
1164
1165   def get_friends_query(%User{} = user, page) do
1166     user
1167     |> get_friends_query(nil)
1168     |> User.Query.paginate(page, 20)
1169   end
1170
1171   @spec get_friends_query(User.t()) :: Ecto.Query.t()
1172   def get_friends_query(%User{} = user), do: get_friends_query(user, nil)
1173
1174   def get_friends(%User{} = user, page \\ nil) do
1175     user
1176     |> get_friends_query(page)
1177     |> Repo.all()
1178   end
1179
1180   def get_friends_ap_ids(%User{} = user) do
1181     user
1182     |> get_friends_query(nil)
1183     |> select([u], u.ap_id)
1184     |> Repo.all()
1185   end
1186
1187   def get_friends_ids(%User{} = user, page \\ nil) do
1188     user
1189     |> get_friends_query(page)
1190     |> select([u], u.id)
1191     |> Repo.all()
1192   end
1193
1194   def increase_note_count(%User{} = user) do
1195     User
1196     |> where(id: ^user.id)
1197     |> update([u], inc: [note_count: 1])
1198     |> select([u], u)
1199     |> Repo.update_all([])
1200     |> case do
1201       {1, [user]} -> set_cache(user)
1202       _ -> {:error, user}
1203     end
1204   end
1205
1206   def decrease_note_count(%User{} = user) do
1207     User
1208     |> where(id: ^user.id)
1209     |> update([u],
1210       set: [
1211         note_count: fragment("greatest(0, note_count - 1)")
1212       ]
1213     )
1214     |> select([u], u)
1215     |> Repo.update_all([])
1216     |> case do
1217       {1, [user]} -> set_cache(user)
1218       _ -> {:error, user}
1219     end
1220   end
1221
1222   def update_note_count(%User{} = user, note_count \\ nil) do
1223     note_count =
1224       note_count ||
1225         from(
1226           a in Object,
1227           where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1228           select: count(a.id)
1229         )
1230         |> Repo.one()
1231
1232     user
1233     |> cast(%{note_count: note_count}, [:note_count])
1234     |> update_and_set_cache()
1235   end
1236
1237   @spec maybe_fetch_follow_information(User.t()) :: User.t()
1238   def maybe_fetch_follow_information(user) do
1239     with {:ok, user} <- fetch_follow_information(user) do
1240       user
1241     else
1242       e ->
1243         Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1244
1245         user
1246     end
1247   end
1248
1249   def fetch_follow_information(user) do
1250     with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1251       user
1252       |> follow_information_changeset(info)
1253       |> update_and_set_cache()
1254     end
1255   end
1256
1257   defp follow_information_changeset(user, params) do
1258     user
1259     |> cast(params, [
1260       :hide_followers,
1261       :hide_follows,
1262       :follower_count,
1263       :following_count,
1264       :hide_followers_count,
1265       :hide_follows_count
1266     ])
1267   end
1268
1269   @spec update_follower_count(User.t()) :: {:ok, User.t()}
1270   def update_follower_count(%User{} = user) do
1271     if user.local or !Config.get([:instance, :external_user_synchronization]) do
1272       follower_count = FollowingRelationship.follower_count(user)
1273
1274       user
1275       |> follow_information_changeset(%{follower_count: follower_count})
1276       |> update_and_set_cache
1277     else
1278       {:ok, maybe_fetch_follow_information(user)}
1279     end
1280   end
1281
1282   @spec update_following_count(User.t()) :: {:ok, User.t()}
1283   def update_following_count(%User{local: false} = user) do
1284     if Config.get([:instance, :external_user_synchronization]) do
1285       {:ok, maybe_fetch_follow_information(user)}
1286     else
1287       {:ok, user}
1288     end
1289   end
1290
1291   def update_following_count(%User{local: true} = user) do
1292     following_count = FollowingRelationship.following_count(user)
1293
1294     user
1295     |> follow_information_changeset(%{following_count: following_count})
1296     |> update_and_set_cache()
1297   end
1298
1299   def set_unread_conversation_count(%User{local: true} = user) do
1300     unread_query = Participation.unread_conversation_count_for_user(user)
1301
1302     User
1303     |> join(:inner, [u], p in subquery(unread_query))
1304     |> update([u, p],
1305       set: [unread_conversation_count: p.count]
1306     )
1307     |> where([u], u.id == ^user.id)
1308     |> select([u], u)
1309     |> Repo.update_all([])
1310     |> case do
1311       {1, [user]} -> set_cache(user)
1312       _ -> {:error, user}
1313     end
1314   end
1315
1316   def set_unread_conversation_count(user), do: {:ok, user}
1317
1318   def increment_unread_conversation_count(conversation, %User{local: true} = user) do
1319     unread_query =
1320       Participation.unread_conversation_count_for_user(user)
1321       |> where([p], p.conversation_id == ^conversation.id)
1322
1323     User
1324     |> join(:inner, [u], p in subquery(unread_query))
1325     |> update([u, p],
1326       inc: [unread_conversation_count: 1]
1327     )
1328     |> where([u], u.id == ^user.id)
1329     |> where([u, p], p.count == 0)
1330     |> select([u], u)
1331     |> Repo.update_all([])
1332     |> case do
1333       {1, [user]} -> set_cache(user)
1334       _ -> {:error, user}
1335     end
1336   end
1337
1338   def increment_unread_conversation_count(_, user), do: {:ok, user}
1339
1340   @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1341   def get_users_from_set(ap_ids, opts \\ []) do
1342     local_only = Keyword.get(opts, :local_only, true)
1343     criteria = %{ap_id: ap_ids, deactivated: false}
1344     criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1345
1346     User.Query.build(criteria)
1347     |> Repo.all()
1348   end
1349
1350   @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1351   def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1352     to = [actor | to]
1353
1354     query = User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
1355
1356     query
1357     |> Repo.all()
1358   end
1359
1360   @spec mute(User.t(), User.t(), boolean()) ::
1361           {:ok, list(UserRelationship.t())} | {:error, String.t()}
1362   def mute(%User{} = muter, %User{} = mutee, notifications? \\ true) do
1363     add_to_mutes(muter, mutee, notifications?)
1364   end
1365
1366   def unmute(%User{} = muter, %User{} = mutee) do
1367     remove_from_mutes(muter, mutee)
1368   end
1369
1370   def subscribe(%User{} = subscriber, %User{} = target) do
1371     deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
1372
1373     if blocks?(target, subscriber) and deny_follow_blocked do
1374       {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1375     else
1376       # Note: the relationship is inverse: subscriber acts as relationship target
1377       UserRelationship.create_inverse_subscription(target, subscriber)
1378     end
1379   end
1380
1381   def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1382     with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1383       subscribe(subscriber, subscribee)
1384     end
1385   end
1386
1387   def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1388     # Note: the relationship is inverse: subscriber acts as relationship target
1389     UserRelationship.delete_inverse_subscription(target, unsubscriber)
1390   end
1391
1392   def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1393     with %User{} = user <- get_cached_by_ap_id(ap_id) do
1394       unsubscribe(unsubscriber, user)
1395     end
1396   end
1397
1398   def block(%User{} = blocker, %User{} = blocked) do
1399     # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1400     blocker =
1401       if following?(blocker, blocked) do
1402         {:ok, blocker, _} = unfollow(blocker, blocked)
1403         blocker
1404       else
1405         blocker
1406       end
1407
1408     # clear any requested follows as well
1409     blocked =
1410       case CommonAPI.reject_follow_request(blocked, blocker) do
1411         {:ok, %User{} = updated_blocked} -> updated_blocked
1412         nil -> blocked
1413       end
1414
1415     unsubscribe(blocked, blocker)
1416
1417     unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
1418     if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)
1419
1420     {:ok, blocker} = update_follower_count(blocker)
1421     {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1422     add_to_block(blocker, blocked)
1423   end
1424
1425   # helper to handle the block given only an actor's AP id
1426   def block(%User{} = blocker, %{ap_id: ap_id}) do
1427     block(blocker, get_cached_by_ap_id(ap_id))
1428   end
1429
1430   def unblock(%User{} = blocker, %User{} = blocked) do
1431     remove_from_block(blocker, blocked)
1432   end
1433
1434   # helper to handle the block given only an actor's AP id
1435   def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1436     unblock(blocker, get_cached_by_ap_id(ap_id))
1437   end
1438
1439   def mutes?(nil, _), do: false
1440   def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1441
1442   def mutes_user?(%User{} = user, %User{} = target) do
1443     UserRelationship.mute_exists?(user, target)
1444   end
1445
1446   @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1447   def muted_notifications?(nil, _), do: false
1448
1449   def muted_notifications?(%User{} = user, %User{} = target),
1450     do: UserRelationship.notification_mute_exists?(user, target)
1451
1452   def blocks?(nil, _), do: false
1453
1454   def blocks?(%User{} = user, %User{} = target) do
1455     blocks_user?(user, target) ||
1456       (blocks_domain?(user, target) and not User.following?(user, target))
1457   end
1458
1459   def blocks_user?(%User{} = user, %User{} = target) do
1460     UserRelationship.block_exists?(user, target)
1461   end
1462
1463   def blocks_user?(_, _), do: false
1464
1465   def blocks_domain?(%User{} = user, %User{} = target) do
1466     domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1467     %{host: host} = URI.parse(target.ap_id)
1468     Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1469   end
1470
1471   def blocks_domain?(_, _), do: false
1472
1473   def subscribed_to?(%User{} = user, %User{} = target) do
1474     # Note: the relationship is inverse: subscriber acts as relationship target
1475     UserRelationship.inverse_subscription_exists?(target, user)
1476   end
1477
1478   def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1479     with %User{} = target <- get_cached_by_ap_id(ap_id) do
1480       subscribed_to?(user, target)
1481     end
1482   end
1483
1484   @doc """
1485   Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1486   E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1487   """
1488   @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1489   def outgoing_relationships_ap_ids(_user, []), do: %{}
1490
1491   def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1492
1493   def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1494       when is_list(relationship_types) do
1495     db_result =
1496       user
1497       |> assoc(:outgoing_relationships)
1498       |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1499       |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1500       |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1501       |> group_by([user_rel, u], user_rel.relationship_type)
1502       |> Repo.all()
1503       |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1504
1505     Enum.into(
1506       relationship_types,
1507       %{},
1508       fn rel_type -> {rel_type, db_result[rel_type] || []} end
1509     )
1510   end
1511
1512   def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1513
1514   def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1515
1516   def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1517
1518   def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1519       when is_list(relationship_types) do
1520     user
1521     |> assoc(:incoming_relationships)
1522     |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1523     |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1524     |> maybe_filter_on_ap_id(ap_ids)
1525     |> select([user_rel, u], u.ap_id)
1526     |> distinct(true)
1527     |> Repo.all()
1528   end
1529
1530   defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1531     where(query, [user_rel, u], u.ap_id in ^ap_ids)
1532   end
1533
1534   defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1535
1536   def deactivate_async(user, status \\ true) do
1537     BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
1538   end
1539
1540   def deactivate(user, status \\ true)
1541
1542   def deactivate(users, status) when is_list(users) do
1543     Repo.transaction(fn ->
1544       for user <- users, do: deactivate(user, status)
1545     end)
1546   end
1547
1548   def deactivate(%User{} = user, status) do
1549     with {:ok, user} <- set_activation_status(user, status) do
1550       user
1551       |> get_followers()
1552       |> Enum.filter(& &1.local)
1553       |> Enum.each(&set_cache(update_following_count(&1)))
1554
1555       # Only update local user counts, remote will be update during the next pull.
1556       user
1557       |> get_friends()
1558       |> Enum.filter(& &1.local)
1559       |> Enum.each(&do_unfollow(user, &1))
1560
1561       {:ok, user}
1562     end
1563   end
1564
1565   def approve(users) when is_list(users) do
1566     Repo.transaction(fn ->
1567       Enum.map(users, fn user ->
1568         with {:ok, user} <- approve(user), do: user
1569       end)
1570     end)
1571   end
1572
1573   def approve(%User{} = user) do
1574     change(user, approval_pending: false)
1575     |> update_and_set_cache()
1576   end
1577
1578   def update_notification_settings(%User{} = user, settings) do
1579     user
1580     |> cast(%{notification_settings: settings}, [])
1581     |> cast_embed(:notification_settings)
1582     |> validate_required([:notification_settings])
1583     |> update_and_set_cache()
1584   end
1585
1586   @spec purge_user_changeset(User.t()) :: Changeset.t()
1587   def purge_user_changeset(user) do
1588     # "Right to be forgotten"
1589     # https://gdpr.eu/right-to-be-forgotten/
1590     change(user, %{
1591       bio: "",
1592       raw_bio: nil,
1593       email: nil,
1594       name: nil,
1595       password_hash: nil,
1596       keys: nil,
1597       public_key: nil,
1598       avatar: %{},
1599       tags: [],
1600       last_refreshed_at: nil,
1601       last_digest_emailed_at: nil,
1602       banner: %{},
1603       background: %{},
1604       note_count: 0,
1605       follower_count: 0,
1606       following_count: 0,
1607       locked: false,
1608       confirmation_pending: false,
1609       password_reset_pending: false,
1610       approval_pending: false,
1611       registration_reason: nil,
1612       confirmation_token: nil,
1613       domain_blocks: [],
1614       deactivated: true,
1615       ap_enabled: false,
1616       is_moderator: false,
1617       is_admin: false,
1618       mastofe_settings: nil,
1619       mascot: nil,
1620       emoji: %{},
1621       pleroma_settings_store: %{},
1622       fields: [],
1623       raw_fields: [],
1624       discoverable: false,
1625       also_known_as: []
1626     })
1627   end
1628
1629   def delete(users) when is_list(users) do
1630     for user <- users, do: delete(user)
1631   end
1632
1633   def delete(%User{} = user) do
1634     BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1635   end
1636
1637   defp delete_and_invalidate_cache(%User{} = user) do
1638     invalidate_cache(user)
1639     Repo.delete(user)
1640   end
1641
1642   defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)
1643
1644   defp delete_or_deactivate(%User{local: true} = user) do
1645     status = account_status(user)
1646
1647     case status do
1648       :confirmation_pending ->
1649         delete_and_invalidate_cache(user)
1650
1651       :approval_pending ->
1652         delete_and_invalidate_cache(user)
1653
1654       _ ->
1655         user
1656         |> purge_user_changeset()
1657         |> update_and_set_cache()
1658     end
1659   end
1660
1661   def perform(:force_password_reset, user), do: force_password_reset(user)
1662
1663   @spec perform(atom(), User.t()) :: {:ok, User.t()}
1664   def perform(:delete, %User{} = user) do
1665     # Remove all relationships
1666     user
1667     |> get_followers()
1668     |> Enum.each(fn follower ->
1669       ActivityPub.unfollow(follower, user)
1670       unfollow(follower, user)
1671     end)
1672
1673     user
1674     |> get_friends()
1675     |> Enum.each(fn followed ->
1676       ActivityPub.unfollow(user, followed)
1677       unfollow(user, followed)
1678     end)
1679
1680     delete_user_activities(user)
1681     delete_notifications_from_user_activities(user)
1682
1683     delete_outgoing_pending_follow_requests(user)
1684
1685     delete_or_deactivate(user)
1686   end
1687
1688   def perform(:deactivate_async, user, status), do: deactivate(user, status)
1689
1690   @spec perform(atom(), User.t(), list()) :: list() | {:error, any()}
1691   def perform(:blocks_import, %User{} = blocker, blocked_identifiers)
1692       when is_list(blocked_identifiers) do
1693     Enum.map(
1694       blocked_identifiers,
1695       fn blocked_identifier ->
1696         with {:ok, %User{} = blocked} <- get_or_fetch(blocked_identifier),
1697              {:ok, _block} <- CommonAPI.block(blocker, blocked) do
1698           blocked
1699         else
1700           err ->
1701             Logger.debug("blocks_import failed for #{blocked_identifier} with: #{inspect(err)}")
1702             err
1703         end
1704       end
1705     )
1706   end
1707
1708   def perform(:follow_import, %User{} = follower, followed_identifiers)
1709       when is_list(followed_identifiers) do
1710     Enum.map(
1711       followed_identifiers,
1712       fn followed_identifier ->
1713         with {:ok, %User{} = followed} <- get_or_fetch(followed_identifier),
1714              {:ok, follower} <- maybe_direct_follow(follower, followed),
1715              {:ok, _, _, _} <- CommonAPI.follow(follower, followed) do
1716           followed
1717         else
1718           err ->
1719             Logger.debug("follow_import failed for #{followed_identifier} with: #{inspect(err)}")
1720             err
1721         end
1722       end
1723     )
1724   end
1725
1726   @spec external_users_query() :: Ecto.Query.t()
1727   def external_users_query do
1728     User.Query.build(%{
1729       external: true,
1730       active: true,
1731       order_by: :id
1732     })
1733   end
1734
1735   @spec external_users(keyword()) :: [User.t()]
1736   def external_users(opts \\ []) do
1737     query =
1738       external_users_query()
1739       |> select([u], struct(u, [:id, :ap_id]))
1740
1741     query =
1742       if opts[:max_id],
1743         do: where(query, [u], u.id > ^opts[:max_id]),
1744         else: query
1745
1746     query =
1747       if opts[:limit],
1748         do: limit(query, ^opts[:limit]),
1749         else: query
1750
1751     Repo.all(query)
1752   end
1753
1754   def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers) do
1755     BackgroundWorker.enqueue("blocks_import", %{
1756       "blocker_id" => blocker.id,
1757       "blocked_identifiers" => blocked_identifiers
1758     })
1759   end
1760
1761   def follow_import(%User{} = follower, followed_identifiers)
1762       when is_list(followed_identifiers) do
1763     BackgroundWorker.enqueue("follow_import", %{
1764       "follower_id" => follower.id,
1765       "followed_identifiers" => followed_identifiers
1766     })
1767   end
1768
1769   def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1770     Notification
1771     |> join(:inner, [n], activity in assoc(n, :activity))
1772     |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1773     |> Repo.delete_all()
1774   end
1775
1776   def delete_user_activities(%User{ap_id: ap_id} = user) do
1777     ap_id
1778     |> Activity.Queries.by_actor()
1779     |> RepoStreamer.chunk_stream(50)
1780     |> Stream.each(fn activities ->
1781       Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1782     end)
1783     |> Stream.run()
1784   end
1785
1786   defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1787     with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1788          {:ok, delete_data, _} <- Builder.delete(user, object) do
1789       Pipeline.common_pipeline(delete_data, local: user.local)
1790     else
1791       {:find_object, nil} ->
1792         # We have the create activity, but not the object, it was probably pruned.
1793         # Insert a tombstone and try again
1794         with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1795              {:ok, _tombstone} <- Object.create(tombstone_data) do
1796           delete_activity(activity, user)
1797         end
1798
1799       e ->
1800         Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1801         Logger.error("Error: #{inspect(e)}")
1802     end
1803   end
1804
1805   defp delete_activity(%{data: %{"type" => type}} = activity, user)
1806        when type in ["Like", "Announce"] do
1807     {:ok, undo, _} = Builder.undo(user, activity)
1808     Pipeline.common_pipeline(undo, local: user.local)
1809   end
1810
1811   defp delete_activity(_activity, _user), do: "Doing nothing"
1812
1813   defp delete_outgoing_pending_follow_requests(user) do
1814     user
1815     |> FollowingRelationship.outgoing_pending_follow_requests_query()
1816     |> Repo.delete_all()
1817   end
1818
1819   def html_filter_policy(%User{no_rich_text: true}) do
1820     Pleroma.HTML.Scrubber.TwitterText
1821   end
1822
1823   def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])
1824
1825   def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1826
1827   def get_or_fetch_by_ap_id(ap_id) do
1828     cached_user = get_cached_by_ap_id(ap_id)
1829
1830     maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)
1831
1832     case {cached_user, maybe_fetched_user} do
1833       {_, {:ok, %User{} = user}} ->
1834         {:ok, user}
1835
1836       {%User{} = user, _} ->
1837         {:ok, user}
1838
1839       _ ->
1840         {:error, :not_found}
1841     end
1842   end
1843
1844   @doc """
1845   Creates an internal service actor by URI if missing.
1846   Optionally takes nickname for addressing.
1847   """
1848   @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1849   def get_or_create_service_actor_by_ap_id(uri, nickname) do
1850     {_, user} =
1851       case get_cached_by_ap_id(uri) do
1852         nil ->
1853           with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1854             Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1855             {:error, nil}
1856           end
1857
1858         %User{invisible: false} = user ->
1859           set_invisible(user)
1860
1861         user ->
1862           {:ok, user}
1863       end
1864
1865     user
1866   end
1867
1868   @spec set_invisible(User.t()) :: {:ok, User.t()}
1869   defp set_invisible(user) do
1870     user
1871     |> change(%{invisible: true})
1872     |> update_and_set_cache()
1873   end
1874
1875   @spec create_service_actor(String.t(), String.t()) ::
1876           {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1877   defp create_service_actor(uri, nickname) do
1878     %User{
1879       invisible: true,
1880       local: true,
1881       ap_id: uri,
1882       nickname: nickname,
1883       follower_address: uri <> "/followers"
1884     }
1885     |> change
1886     |> unique_constraint(:nickname)
1887     |> Repo.insert()
1888     |> set_cache()
1889   end
1890
1891   def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1892     key =
1893       public_key_pem
1894       |> :public_key.pem_decode()
1895       |> hd()
1896       |> :public_key.pem_entry_decode()
1897
1898     {:ok, key}
1899   end
1900
1901   def public_key(_), do: {:error, "key not found"}
1902
1903   def get_public_key_for_ap_id(ap_id) do
1904     with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1905          {:ok, public_key} <- public_key(user) do
1906       {:ok, public_key}
1907     else
1908       _ -> :error
1909     end
1910   end
1911
1912   def ap_enabled?(%User{local: true}), do: true
1913   def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1914   def ap_enabled?(_), do: false
1915
1916   @doc "Gets or fetch a user by uri or nickname."
1917   @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1918   def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1919   def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1920
1921   # wait a period of time and return newest version of the User structs
1922   # this is because we have synchronous follow APIs and need to simulate them
1923   # with an async handshake
1924   def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1925     with %User{} = a <- get_cached_by_id(a.id),
1926          %User{} = b <- get_cached_by_id(b.id) do
1927       {:ok, a, b}
1928     else
1929       nil -> :error
1930     end
1931   end
1932
1933   def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1934     with :ok <- :timer.sleep(timeout),
1935          %User{} = a <- get_cached_by_id(a.id),
1936          %User{} = b <- get_cached_by_id(b.id) do
1937       {:ok, a, b}
1938     else
1939       nil -> :error
1940     end
1941   end
1942
1943   def parse_bio(bio) when is_binary(bio) and bio != "" do
1944     bio
1945     |> CommonUtils.format_input("text/plain", mentions_format: :full)
1946     |> elem(0)
1947   end
1948
1949   def parse_bio(_), do: ""
1950
1951   def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1952     # TODO: get profile URLs other than user.ap_id
1953     profile_urls = [user.ap_id]
1954
1955     bio
1956     |> CommonUtils.format_input("text/plain",
1957       mentions_format: :full,
1958       rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1959     )
1960     |> elem(0)
1961   end
1962
1963   def parse_bio(_, _), do: ""
1964
1965   def tag(user_identifiers, tags) when is_list(user_identifiers) do
1966     Repo.transaction(fn ->
1967       for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1968     end)
1969   end
1970
1971   def tag(nickname, tags) when is_binary(nickname),
1972     do: tag(get_by_nickname(nickname), tags)
1973
1974   def tag(%User{} = user, tags),
1975     do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1976
1977   def untag(user_identifiers, tags) when is_list(user_identifiers) do
1978     Repo.transaction(fn ->
1979       for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1980     end)
1981   end
1982
1983   def untag(nickname, tags) when is_binary(nickname),
1984     do: untag(get_by_nickname(nickname), tags)
1985
1986   def untag(%User{} = user, tags),
1987     do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1988
1989   defp update_tags(%User{} = user, new_tags) do
1990     {:ok, updated_user} =
1991       user
1992       |> change(%{tags: new_tags})
1993       |> update_and_set_cache()
1994
1995     updated_user
1996   end
1997
1998   defp normalize_tags(tags) do
1999     [tags]
2000     |> List.flatten()
2001     |> Enum.map(&String.downcase/1)
2002   end
2003
2004   defp local_nickname_regex do
2005     if Config.get([:instance, :extended_nickname_format]) do
2006       @extended_local_nickname_regex
2007     else
2008       @strict_local_nickname_regex
2009     end
2010   end
2011
2012   def local_nickname(nickname_or_mention) do
2013     nickname_or_mention
2014     |> full_nickname()
2015     |> String.split("@")
2016     |> hd()
2017   end
2018
2019   def full_nickname(nickname_or_mention),
2020     do: String.trim_leading(nickname_or_mention, "@")
2021
2022   def error_user(ap_id) do
2023     %User{
2024       name: ap_id,
2025       ap_id: ap_id,
2026       nickname: "erroruser@example.com",
2027       inserted_at: NaiveDateTime.utc_now()
2028     }
2029   end
2030
2031   @spec all_superusers() :: [User.t()]
2032   def all_superusers do
2033     User.Query.build(%{super_users: true, local: true, deactivated: false})
2034     |> Repo.all()
2035   end
2036
2037   def muting_reblogs?(%User{} = user, %User{} = target) do
2038     UserRelationship.reblog_mute_exists?(user, target)
2039   end
2040
2041   def showing_reblogs?(%User{} = user, %User{} = target) do
2042     not muting_reblogs?(user, target)
2043   end
2044
2045   @doc """
2046   The function returns a query to get users with no activity for given interval of days.
2047   Inactive users are those who didn't read any notification, or had any activity where
2048   the user is the activity's actor, during `inactivity_threshold` days.
2049   Deactivated users will not appear in this list.
2050
2051   ## Examples
2052
2053       iex> Pleroma.User.list_inactive_users()
2054       %Ecto.Query{}
2055   """
2056   @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
2057   def list_inactive_users_query(inactivity_threshold \\ 7) do
2058     negative_inactivity_threshold = -inactivity_threshold
2059     now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2060     # Subqueries are not supported in `where` clauses, join gets too complicated.
2061     has_read_notifications =
2062       from(n in Pleroma.Notification,
2063         where: n.seen == true,
2064         group_by: n.id,
2065         having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
2066         select: n.user_id
2067       )
2068       |> Pleroma.Repo.all()
2069
2070     from(u in Pleroma.User,
2071       left_join: a in Pleroma.Activity,
2072       on: u.ap_id == a.actor,
2073       where: not is_nil(u.nickname),
2074       where: u.deactivated != ^true,
2075       where: u.id not in ^has_read_notifications,
2076       group_by: u.id,
2077       having:
2078         max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
2079           is_nil(max(a.inserted_at))
2080     )
2081   end
2082
2083   @doc """
2084   Enable or disable email notifications for user
2085
2086   ## Examples
2087
2088       iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
2089       Pleroma.User{email_notifications: %{"digest" => true}}
2090
2091       iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
2092       Pleroma.User{email_notifications: %{"digest" => false}}
2093   """
2094   @spec switch_email_notifications(t(), String.t(), boolean()) ::
2095           {:ok, t()} | {:error, Ecto.Changeset.t()}
2096   def switch_email_notifications(user, type, status) do
2097     User.update_email_notifications(user, %{type => status})
2098   end
2099
2100   @doc """
2101   Set `last_digest_emailed_at` value for the user to current time
2102   """
2103   @spec touch_last_digest_emailed_at(t()) :: t()
2104   def touch_last_digest_emailed_at(user) do
2105     now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2106
2107     {:ok, updated_user} =
2108       user
2109       |> change(%{last_digest_emailed_at: now})
2110       |> update_and_set_cache()
2111
2112     updated_user
2113   end
2114
2115   @spec toggle_confirmation(User.t()) :: {:ok, User.t()} | {:error, Changeset.t()}
2116   def toggle_confirmation(%User{} = user) do
2117     user
2118     |> confirmation_changeset(need_confirmation: !user.confirmation_pending)
2119     |> update_and_set_cache()
2120   end
2121
2122   @spec toggle_confirmation([User.t()]) :: [{:ok, User.t()} | {:error, Changeset.t()}]
2123   def toggle_confirmation(users) do
2124     Enum.map(users, &toggle_confirmation/1)
2125   end
2126
2127   @spec need_confirmation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
2128   def need_confirmation(%User{} = user, bool) do
2129     user
2130     |> confirmation_changeset(need_confirmation: bool)
2131     |> update_and_set_cache()
2132   end
2133
2134   def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
2135     mascot
2136   end
2137
2138   def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
2139     # use instance-default
2140     config = Config.get([:assets, :mascots])
2141     default_mascot = Config.get([:assets, :default_mascot])
2142     mascot = Keyword.get(config, default_mascot)
2143
2144     %{
2145       "id" => "default-mascot",
2146       "url" => mascot[:url],
2147       "preview_url" => mascot[:url],
2148       "pleroma" => %{
2149         "mime_type" => mascot[:mime_type]
2150       }
2151     }
2152   end
2153
2154   def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
2155
2156   def ensure_keys_present(%User{} = user) do
2157     with {:ok, pem} <- Keys.generate_rsa_pem() do
2158       user
2159       |> cast(%{keys: pem}, [:keys])
2160       |> validate_required([:keys])
2161       |> update_and_set_cache()
2162     end
2163   end
2164
2165   def get_ap_ids_by_nicknames(nicknames) do
2166     from(u in User,
2167       where: u.nickname in ^nicknames,
2168       select: u.ap_id
2169     )
2170     |> Repo.all()
2171   end
2172
2173   defp put_password_hash(
2174          %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2175        ) do
2176     change(changeset, password_hash: Pbkdf2.hash_pwd_salt(password))
2177   end
2178
2179   defp put_password_hash(changeset), do: changeset
2180
2181   def is_internal_user?(%User{nickname: nil}), do: true
2182   def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2183   def is_internal_user?(_), do: false
2184
2185   # A hack because user delete activities have a fake id for whatever reason
2186   # TODO: Get rid of this
2187   def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2188
2189   def get_delivered_users_by_object_id(object_id) do
2190     from(u in User,
2191       inner_join: delivery in assoc(u, :deliveries),
2192       where: delivery.object_id == ^object_id
2193     )
2194     |> Repo.all()
2195   end
2196
2197   def change_email(user, email) do
2198     user
2199     |> cast(%{email: email}, [:email])
2200     |> validate_required([:email])
2201     |> unique_constraint(:email)
2202     |> validate_format(:email, @email_regex)
2203     |> update_and_set_cache()
2204   end
2205
2206   # Internal function; public one is `deactivate/2`
2207   defp set_activation_status(user, deactivated) do
2208     user
2209     |> cast(%{deactivated: deactivated}, [:deactivated])
2210     |> update_and_set_cache()
2211   end
2212
2213   def update_banner(user, banner) do
2214     user
2215     |> cast(%{banner: banner}, [:banner])
2216     |> update_and_set_cache()
2217   end
2218
2219   def update_background(user, background) do
2220     user
2221     |> cast(%{background: background}, [:background])
2222     |> update_and_set_cache()
2223   end
2224
2225   def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
2226     %{
2227       admin: is_admin,
2228       moderator: is_moderator
2229     }
2230   end
2231
2232   def validate_fields(changeset, remote? \\ false) do
2233     limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2234     limit = Config.get([:instance, limit_name], 0)
2235
2236     changeset
2237     |> validate_length(:fields, max: limit)
2238     |> validate_change(:fields, fn :fields, fields ->
2239       if Enum.all?(fields, &valid_field?/1) do
2240         []
2241       else
2242         [fields: "invalid"]
2243       end
2244     end)
2245   end
2246
2247   defp valid_field?(%{"name" => name, "value" => value}) do
2248     name_limit = Config.get([:instance, :account_field_name_length], 255)
2249     value_limit = Config.get([:instance, :account_field_value_length], 255)
2250
2251     is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2252       String.length(value) <= value_limit
2253   end
2254
2255   defp valid_field?(_), do: false
2256
2257   defp truncate_field(%{"name" => name, "value" => value}) do
2258     {name, _chopped} =
2259       String.split_at(name, Config.get([:instance, :account_field_name_length], 255))
2260
2261     {value, _chopped} =
2262       String.split_at(value, Config.get([:instance, :account_field_value_length], 255))
2263
2264     %{"name" => name, "value" => value}
2265   end
2266
2267   def admin_api_update(user, params) do
2268     user
2269     |> cast(params, [
2270       :is_moderator,
2271       :is_admin,
2272       :show_role
2273     ])
2274     |> update_and_set_cache()
2275   end
2276
2277   @doc "Signs user out of all applications"
2278   def global_sign_out(user) do
2279     OAuth.Authorization.delete_user_authorizations(user)
2280     OAuth.Token.delete_user_tokens(user)
2281   end
2282
2283   def mascot_update(user, url) do
2284     user
2285     |> cast(%{mascot: url}, [:mascot])
2286     |> validate_required([:mascot])
2287     |> update_and_set_cache()
2288   end
2289
2290   def mastodon_settings_update(user, settings) do
2291     user
2292     |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
2293     |> validate_required([:mastofe_settings])
2294     |> update_and_set_cache()
2295   end
2296
2297   @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2298   def confirmation_changeset(user, need_confirmation: need_confirmation?) do
2299     params =
2300       if need_confirmation? do
2301         %{
2302           confirmation_pending: true,
2303           confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2304         }
2305       else
2306         %{
2307           confirmation_pending: false,
2308           confirmation_token: nil
2309         }
2310       end
2311
2312     cast(user, params, [:confirmation_pending, :confirmation_token])
2313   end
2314
2315   @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
2316   def approval_changeset(user, need_approval: need_approval?) do
2317     params = if need_approval?, do: %{approval_pending: true}, else: %{approval_pending: false}
2318     cast(user, params, [:approval_pending])
2319   end
2320
2321   def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2322     if id not in user.pinned_activities do
2323       max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2324       params = %{pinned_activities: user.pinned_activities ++ [id]}
2325
2326       user
2327       |> cast(params, [:pinned_activities])
2328       |> validate_length(:pinned_activities,
2329         max: max_pinned_statuses,
2330         message: "You have already pinned the maximum number of statuses"
2331       )
2332     else
2333       change(user)
2334     end
2335     |> update_and_set_cache()
2336   end
2337
2338   def remove_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2339     params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2340
2341     user
2342     |> cast(params, [:pinned_activities])
2343     |> update_and_set_cache()
2344   end
2345
2346   def update_email_notifications(user, settings) do
2347     email_notifications =
2348       user.email_notifications
2349       |> Map.merge(settings)
2350       |> Map.take(["digest"])
2351
2352     params = %{email_notifications: email_notifications}
2353     fields = [:email_notifications]
2354
2355     user
2356     |> cast(params, fields)
2357     |> validate_required(fields)
2358     |> update_and_set_cache()
2359   end
2360
2361   defp set_domain_blocks(user, domain_blocks) do
2362     params = %{domain_blocks: domain_blocks}
2363
2364     user
2365     |> cast(params, [:domain_blocks])
2366     |> validate_required([:domain_blocks])
2367     |> update_and_set_cache()
2368   end
2369
2370   def block_domain(user, domain_blocked) do
2371     set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2372   end
2373
2374   def unblock_domain(user, domain_blocked) do
2375     set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2376   end
2377
2378   @spec add_to_block(User.t(), User.t()) ::
2379           {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2380   defp add_to_block(%User{} = user, %User{} = blocked) do
2381     UserRelationship.create_block(user, blocked)
2382   end
2383
2384   @spec add_to_block(User.t(), User.t()) ::
2385           {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2386   defp remove_from_block(%User{} = user, %User{} = blocked) do
2387     UserRelationship.delete_block(user, blocked)
2388   end
2389
2390   defp add_to_mutes(%User{} = user, %User{} = muted_user, notifications?) do
2391     with {:ok, user_mute} <- UserRelationship.create_mute(user, muted_user),
2392          {:ok, user_notification_mute} <-
2393            (notifications? && UserRelationship.create_notification_mute(user, muted_user)) ||
2394              {:ok, nil} do
2395       {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
2396     end
2397   end
2398
2399   defp remove_from_mutes(user, %User{} = muted_user) do
2400     with {:ok, user_mute} <- UserRelationship.delete_mute(user, muted_user),
2401          {:ok, user_notification_mute} <-
2402            UserRelationship.delete_notification_mute(user, muted_user) do
2403       {:ok, [user_mute, user_notification_mute]}
2404     end
2405   end
2406
2407   def set_invisible(user, invisible) do
2408     params = %{invisible: invisible}
2409
2410     user
2411     |> cast(params, [:invisible])
2412     |> validate_required([:invisible])
2413     |> update_and_set_cache()
2414   end
2415
2416   def sanitize_html(%User{} = user) do
2417     sanitize_html(user, nil)
2418   end
2419
2420   # User data that mastodon isn't filtering (treated as plaintext):
2421   # - field name
2422   # - display name
2423   def sanitize_html(%User{} = user, filter) do
2424     fields =
2425       Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2426         %{
2427           "name" => name,
2428           "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2429         }
2430       end)
2431
2432     user
2433     |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2434     |> Map.put(:fields, fields)
2435   end
2436 end