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

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