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       keys: nil,
1699       public_key: nil,
1700       avatar: %{},
1701       tags: [],
1702       last_refreshed_at: nil,
1703       last_digest_emailed_at: nil,
1704       banner: %{},
1705       background: %{},
1706       note_count: 0,
1707       follower_count: 0,
1708       following_count: 0,
1709       is_locked: false,
1710       is_confirmed: true,
1711       password_reset_pending: false,
1712       is_approved: true,
1713       registration_reason: nil,
1714       confirmation_token: nil,
1715       domain_blocks: [],
1716       is_active: false,
1717       ap_enabled: false,
1718       is_moderator: false,
1719       is_admin: false,
1720       mastofe_settings: nil,
1721       mascot: nil,
1722       emoji: %{},
1723       pleroma_settings_store: %{},
1724       fields: [],
1725       raw_fields: [],
1726       is_discoverable: false,
1727       also_known_as: []
1728     })
1729   end
1730
1731   def delete(users) when is_list(users) do
1732     for user <- users, do: delete(user)
1733   end
1734
1735   def delete(%User{} = user) do
1736     BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1737   end
1738
1739   defp delete_and_invalidate_cache(%User{} = user) do
1740     invalidate_cache(user)
1741     Repo.delete(user)
1742   end
1743
1744   defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)
1745
1746   defp delete_or_deactivate(%User{local: true} = user) do
1747     status = account_status(user)
1748
1749     case status do
1750       :confirmation_pending ->
1751         delete_and_invalidate_cache(user)
1752
1753       :approval_pending ->
1754         delete_and_invalidate_cache(user)
1755
1756       _ ->
1757         user
1758         |> purge_user_changeset()
1759         |> update_and_set_cache()
1760     end
1761   end
1762
1763   def perform(:force_password_reset, user), do: force_password_reset(user)
1764
1765   @spec perform(atom(), User.t()) :: {:ok, User.t()}
1766   def perform(:delete, %User{} = user) do
1767     # Remove all relationships
1768     user
1769     |> get_followers()
1770     |> Enum.each(fn follower ->
1771       ActivityPub.unfollow(follower, user)
1772       unfollow(follower, user)
1773     end)
1774
1775     user
1776     |> get_friends()
1777     |> Enum.each(fn followed ->
1778       ActivityPub.unfollow(user, followed)
1779       unfollow(user, followed)
1780     end)
1781
1782     delete_user_activities(user)
1783     delete_notifications_from_user_activities(user)
1784
1785     delete_outgoing_pending_follow_requests(user)
1786
1787     delete_or_deactivate(user)
1788   end
1789
1790   def perform(:set_activation_async, user, status), do: set_activation(user, status)
1791
1792   @spec external_users_query() :: Ecto.Query.t()
1793   def external_users_query do
1794     User.Query.build(%{
1795       external: true,
1796       active: true,
1797       order_by: :id
1798     })
1799   end
1800
1801   @spec external_users(keyword()) :: [User.t()]
1802   def external_users(opts \\ []) do
1803     query =
1804       external_users_query()
1805       |> select([u], struct(u, [:id, :ap_id]))
1806
1807     query =
1808       if opts[:max_id],
1809         do: where(query, [u], u.id > ^opts[:max_id]),
1810         else: query
1811
1812     query =
1813       if opts[:limit],
1814         do: limit(query, ^opts[:limit]),
1815         else: query
1816
1817     Repo.all(query)
1818   end
1819
1820   def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1821     Notification
1822     |> join(:inner, [n], activity in assoc(n, :activity))
1823     |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1824     |> Repo.delete_all()
1825   end
1826
1827   def delete_user_activities(%User{ap_id: ap_id} = user) do
1828     ap_id
1829     |> Activity.Queries.by_actor()
1830     |> Repo.chunk_stream(50, :batches)
1831     |> Stream.each(fn activities ->
1832       Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1833     end)
1834     |> Stream.run()
1835   end
1836
1837   defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1838     with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1839          {:ok, delete_data, _} <- Builder.delete(user, object) do
1840       Pipeline.common_pipeline(delete_data, local: user.local)
1841     else
1842       {:find_object, nil} ->
1843         # We have the create activity, but not the object, it was probably pruned.
1844         # Insert a tombstone and try again
1845         with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1846              {:ok, _tombstone} <- Object.create(tombstone_data) do
1847           delete_activity(activity, user)
1848         end
1849
1850       e ->
1851         Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1852         Logger.error("Error: #{inspect(e)}")
1853     end
1854   end
1855
1856   defp delete_activity(%{data: %{"type" => type}} = activity, user)
1857        when type in ["Like", "Announce"] do
1858     {:ok, undo, _} = Builder.undo(user, activity)
1859     Pipeline.common_pipeline(undo, local: user.local)
1860   end
1861
1862   defp delete_activity(_activity, _user), do: "Doing nothing"
1863
1864   defp delete_outgoing_pending_follow_requests(user) do
1865     user
1866     |> FollowingRelationship.outgoing_pending_follow_requests_query()
1867     |> Repo.delete_all()
1868   end
1869
1870   def html_filter_policy(%User{no_rich_text: true}) do
1871     Pleroma.HTML.Scrubber.TwitterText
1872   end
1873
1874   def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])
1875
1876   def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1877
1878   def get_or_fetch_by_ap_id(ap_id) do
1879     cached_user = get_cached_by_ap_id(ap_id)
1880
1881     maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)
1882
1883     case {cached_user, maybe_fetched_user} do
1884       {_, {:ok, %User{} = user}} ->
1885         {:ok, user}
1886
1887       {%User{} = user, _} ->
1888         {:ok, user}
1889
1890       _ ->
1891         {:error, :not_found}
1892     end
1893   end
1894
1895   @doc """
1896   Creates an internal service actor by URI if missing.
1897   Optionally takes nickname for addressing.
1898   """
1899   @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1900   def get_or_create_service_actor_by_ap_id(uri, nickname) do
1901     {_, user} =
1902       case get_cached_by_ap_id(uri) do
1903         nil ->
1904           with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1905             Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1906             {:error, nil}
1907           end
1908
1909         %User{invisible: false} = user ->
1910           set_invisible(user)
1911
1912         user ->
1913           {:ok, user}
1914       end
1915
1916     user
1917   end
1918
1919   @spec set_invisible(User.t()) :: {:ok, User.t()}
1920   defp set_invisible(user) do
1921     user
1922     |> change(%{invisible: true})
1923     |> update_and_set_cache()
1924   end
1925
1926   @spec create_service_actor(String.t(), String.t()) ::
1927           {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1928   defp create_service_actor(uri, nickname) do
1929     %User{
1930       invisible: true,
1931       local: true,
1932       ap_id: uri,
1933       nickname: nickname,
1934       follower_address: uri <> "/followers"
1935     }
1936     |> change
1937     |> unique_constraint(:nickname)
1938     |> Repo.insert()
1939     |> set_cache()
1940   end
1941
1942   def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1943     key =
1944       public_key_pem
1945       |> :public_key.pem_decode()
1946       |> hd()
1947       |> :public_key.pem_entry_decode()
1948
1949     {:ok, key}
1950   end
1951
1952   def public_key(_), do: {:error, "key not found"}
1953
1954   def get_public_key_for_ap_id(ap_id) do
1955     with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1956          {:ok, public_key} <- public_key(user) do
1957       {:ok, public_key}
1958     else
1959       _ -> :error
1960     end
1961   end
1962
1963   def ap_enabled?(%User{local: true}), do: true
1964   def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1965   def ap_enabled?(_), do: false
1966
1967   @doc "Gets or fetch a user by uri or nickname."
1968   @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1969   def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1970   def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1971
1972   # wait a period of time and return newest version of the User structs
1973   # this is because we have synchronous follow APIs and need to simulate them
1974   # with an async handshake
1975   def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1976     with %User{} = a <- get_cached_by_id(a.id),
1977          %User{} = b <- get_cached_by_id(b.id) do
1978       {:ok, a, b}
1979     else
1980       nil -> :error
1981     end
1982   end
1983
1984   def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1985     with :ok <- :timer.sleep(timeout),
1986          %User{} = a <- get_cached_by_id(a.id),
1987          %User{} = b <- get_cached_by_id(b.id) do
1988       {:ok, a, b}
1989     else
1990       nil -> :error
1991     end
1992   end
1993
1994   def parse_bio(bio) when is_binary(bio) and bio != "" do
1995     bio
1996     |> CommonUtils.format_input("text/plain", mentions_format: :full)
1997     |> elem(0)
1998   end
1999
2000   def parse_bio(_), do: ""
2001
2002   def parse_bio(bio, user) when is_binary(bio) and bio != "" do
2003     # TODO: get profile URLs other than user.ap_id
2004     profile_urls = [user.ap_id]
2005
2006     bio
2007     |> CommonUtils.format_input("text/plain",
2008       mentions_format: :full,
2009       rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
2010     )
2011     |> elem(0)
2012   end
2013
2014   def parse_bio(_, _), do: ""
2015
2016   def tag(user_identifiers, tags) when is_list(user_identifiers) do
2017     Repo.transaction(fn ->
2018       for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
2019     end)
2020   end
2021
2022   def tag(nickname, tags) when is_binary(nickname),
2023     do: tag(get_by_nickname(nickname), tags)
2024
2025   def tag(%User{} = user, tags),
2026     do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
2027
2028   def untag(user_identifiers, tags) when is_list(user_identifiers) do
2029     Repo.transaction(fn ->
2030       for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
2031     end)
2032   end
2033
2034   def untag(nickname, tags) when is_binary(nickname),
2035     do: untag(get_by_nickname(nickname), tags)
2036
2037   def untag(%User{} = user, tags),
2038     do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
2039
2040   defp update_tags(%User{} = user, new_tags) do
2041     {:ok, updated_user} =
2042       user
2043       |> change(%{tags: new_tags})
2044       |> update_and_set_cache()
2045
2046     updated_user
2047   end
2048
2049   defp normalize_tags(tags) do
2050     [tags]
2051     |> List.flatten()
2052     |> Enum.map(&String.downcase/1)
2053   end
2054
2055   defp local_nickname_regex do
2056     if Config.get([:instance, :extended_nickname_format]) do
2057       @extended_local_nickname_regex
2058     else
2059       @strict_local_nickname_regex
2060     end
2061   end
2062
2063   def local_nickname(nickname_or_mention) do
2064     nickname_or_mention
2065     |> full_nickname()
2066     |> String.split("@")
2067     |> hd()
2068   end
2069
2070   def full_nickname(%User{} = user) do
2071     if String.contains?(user.nickname, "@") do
2072       user.nickname
2073     else
2074       %{host: host} = URI.parse(user.ap_id)
2075       user.nickname <> "@" <> host
2076     end
2077   end
2078
2079   def full_nickname(nickname_or_mention),
2080     do: String.trim_leading(nickname_or_mention, "@")
2081
2082   def error_user(ap_id) do
2083     %User{
2084       name: ap_id,
2085       ap_id: ap_id,
2086       nickname: "erroruser@example.com",
2087       inserted_at: NaiveDateTime.utc_now()
2088     }
2089   end
2090
2091   @spec all_superusers() :: [User.t()]
2092   def all_superusers do
2093     User.Query.build(%{super_users: true, local: true, is_active: true})
2094     |> Repo.all()
2095   end
2096
2097   def muting_reblogs?(%User{} = user, %User{} = target) do
2098     UserRelationship.reblog_mute_exists?(user, target)
2099   end
2100
2101   def showing_reblogs?(%User{} = user, %User{} = target) do
2102     not muting_reblogs?(user, target)
2103   end
2104
2105   @doc """
2106   The function returns a query to get users with no activity for given interval of days.
2107   Inactive users are those who didn't read any notification, or had any activity where
2108   the user is the activity's actor, during `inactivity_threshold` days.
2109   Deactivated users will not appear in this list.
2110
2111   ## Examples
2112
2113       iex> Pleroma.User.list_inactive_users()
2114       %Ecto.Query{}
2115   """
2116   @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
2117   def list_inactive_users_query(inactivity_threshold \\ 7) do
2118     negative_inactivity_threshold = -inactivity_threshold
2119     now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2120     # Subqueries are not supported in `where` clauses, join gets too complicated.
2121     has_read_notifications =
2122       from(n in Pleroma.Notification,
2123         where: n.seen == true,
2124         group_by: n.id,
2125         having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
2126         select: n.user_id
2127       )
2128       |> Pleroma.Repo.all()
2129
2130     from(u in Pleroma.User,
2131       left_join: a in Pleroma.Activity,
2132       on: u.ap_id == a.actor,
2133       where: not is_nil(u.nickname),
2134       where: u.is_active == ^true,
2135       where: u.id not in ^has_read_notifications,
2136       group_by: u.id,
2137       having:
2138         max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
2139           is_nil(max(a.inserted_at))
2140     )
2141   end
2142
2143   @doc """
2144   Enable or disable email notifications for user
2145
2146   ## Examples
2147
2148       iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
2149       Pleroma.User{email_notifications: %{"digest" => true}}
2150
2151       iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
2152       Pleroma.User{email_notifications: %{"digest" => false}}
2153   """
2154   @spec switch_email_notifications(t(), String.t(), boolean()) ::
2155           {:ok, t()} | {:error, Ecto.Changeset.t()}
2156   def switch_email_notifications(user, type, status) do
2157     User.update_email_notifications(user, %{type => status})
2158   end
2159
2160   @doc """
2161   Set `last_digest_emailed_at` value for the user to current time
2162   """
2163   @spec touch_last_digest_emailed_at(t()) :: t()
2164   def touch_last_digest_emailed_at(user) do
2165     now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
2166
2167     {:ok, updated_user} =
2168       user
2169       |> change(%{last_digest_emailed_at: now})
2170       |> update_and_set_cache()
2171
2172     updated_user
2173   end
2174
2175   @spec set_confirmation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
2176   def set_confirmation(%User{} = user, bool) do
2177     user
2178     |> confirmation_changeset(set_confirmation: bool)
2179     |> update_and_set_cache()
2180   end
2181
2182   def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
2183     mascot
2184   end
2185
2186   def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
2187     # use instance-default
2188     config = Config.get([:assets, :mascots])
2189     default_mascot = Config.get([:assets, :default_mascot])
2190     mascot = Keyword.get(config, default_mascot)
2191
2192     %{
2193       "id" => "default-mascot",
2194       "url" => mascot[:url],
2195       "preview_url" => mascot[:url],
2196       "pleroma" => %{
2197         "mime_type" => mascot[:mime_type]
2198       }
2199     }
2200   end
2201
2202   def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
2203
2204   def ensure_keys_present(%User{} = user) do
2205     with {:ok, pem} <- Keys.generate_rsa_pem() do
2206       user
2207       |> cast(%{keys: pem}, [:keys])
2208       |> validate_required([:keys])
2209       |> update_and_set_cache()
2210     end
2211   end
2212
2213   def get_ap_ids_by_nicknames(nicknames) do
2214     from(u in User,
2215       where: u.nickname in ^nicknames,
2216       select: u.ap_id
2217     )
2218     |> Repo.all()
2219   end
2220
2221   defp put_password_hash(
2222          %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2223        ) do
2224     change(changeset, password_hash: Pleroma.Password.Pbkdf2.hash_pwd_salt(password))
2225   end
2226
2227   defp put_password_hash(changeset), do: changeset
2228
2229   def is_internal_user?(%User{nickname: nil}), do: true
2230   def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2231   def is_internal_user?(_), do: false
2232
2233   # A hack because user delete activities have a fake id for whatever reason
2234   # TODO: Get rid of this
2235   def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2236
2237   def get_delivered_users_by_object_id(object_id) do
2238     from(u in User,
2239       inner_join: delivery in assoc(u, :deliveries),
2240       where: delivery.object_id == ^object_id
2241     )
2242     |> Repo.all()
2243   end
2244
2245   def change_email(user, email) do
2246     user
2247     |> cast(%{email: email}, [:email])
2248     |> validate_required([:email])
2249     |> unique_constraint(:email)
2250     |> validate_format(:email, @email_regex)
2251     |> update_and_set_cache()
2252   end
2253
2254   # Internal function; public one is `deactivate/2`
2255   defp set_activation_status(user, status) do
2256     user
2257     |> cast(%{is_active: status}, [:is_active])
2258     |> update_and_set_cache()
2259   end
2260
2261   def update_banner(user, banner) do
2262     user
2263     |> cast(%{banner: banner}, [:banner])
2264     |> update_and_set_cache()
2265   end
2266
2267   def update_background(user, background) do
2268     user
2269     |> cast(%{background: background}, [:background])
2270     |> update_and_set_cache()
2271   end
2272
2273   def validate_fields(changeset, remote? \\ false) do
2274     limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2275     limit = Config.get([:instance, limit_name], 0)
2276
2277     changeset
2278     |> validate_length(:fields, max: limit)
2279     |> validate_change(:fields, fn :fields, fields ->
2280       if Enum.all?(fields, &valid_field?/1) do
2281         []
2282       else
2283         [fields: "invalid"]
2284       end
2285     end)
2286   end
2287
2288   defp valid_field?(%{"name" => name, "value" => value}) do
2289     name_limit = Config.get([:instance, :account_field_name_length], 255)
2290     value_limit = Config.get([:instance, :account_field_value_length], 255)
2291
2292     is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2293       String.length(value) <= value_limit
2294   end
2295
2296   defp valid_field?(_), do: false
2297
2298   defp truncate_field(%{"name" => name, "value" => value}) do
2299     {name, _chopped} =
2300       String.split_at(name, Config.get([:instance, :account_field_name_length], 255))
2301
2302     {value, _chopped} =
2303       String.split_at(value, Config.get([:instance, :account_field_value_length], 255))
2304
2305     %{"name" => name, "value" => value}
2306   end
2307
2308   def admin_api_update(user, params) do
2309     user
2310     |> cast(params, [
2311       :is_moderator,
2312       :is_admin,
2313       :show_role
2314     ])
2315     |> update_and_set_cache()
2316   end
2317
2318   @doc "Signs user out of all applications"
2319   def global_sign_out(user) do
2320     OAuth.Authorization.delete_user_authorizations(user)
2321     OAuth.Token.delete_user_tokens(user)
2322   end
2323
2324   def mascot_update(user, url) do
2325     user
2326     |> cast(%{mascot: url}, [:mascot])
2327     |> validate_required([:mascot])
2328     |> update_and_set_cache()
2329   end
2330
2331   def mastodon_settings_update(user, settings) do
2332     user
2333     |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
2334     |> validate_required([:mastofe_settings])
2335     |> update_and_set_cache()
2336   end
2337
2338   @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2339   def confirmation_changeset(user, set_confirmation: confirmed?) do
2340     params =
2341       if confirmed? do
2342         %{
2343           is_confirmed: true,
2344           confirmation_token: nil
2345         }
2346       else
2347         %{
2348           is_confirmed: false,
2349           confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2350         }
2351       end
2352
2353     cast(user, params, [:is_confirmed, :confirmation_token])
2354   end
2355
2356   @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
2357   def approval_changeset(user, set_approval: approved?) do
2358     cast(user, %{is_approved: approved?}, [:is_approved])
2359   end
2360
2361   @spec add_pinned_object_id(User.t(), String.t()) :: {:ok, User.t()} | {:error, term()}
2362   def add_pinned_object_id(%User{} = user, object_id) do
2363     if !user.pinned_objects[object_id] do
2364       params = %{pinned_objects: Map.put(user.pinned_objects, object_id, NaiveDateTime.utc_now())}
2365
2366       user
2367       |> cast(params, [:pinned_objects])
2368       |> validate_change(:pinned_objects, fn :pinned_objects, pinned_objects ->
2369         max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2370
2371         if Enum.count(pinned_objects) <= max_pinned_statuses do
2372           []
2373         else
2374           [pinned_objects: "You have already pinned the maximum number of statuses"]
2375         end
2376       end)
2377     else
2378       change(user)
2379     end
2380     |> update_and_set_cache()
2381   end
2382
2383   @spec remove_pinned_object_id(User.t(), String.t()) :: {:ok, t()} | {:error, term()}
2384   def remove_pinned_object_id(%User{} = user, object_id) do
2385     user
2386     |> cast(
2387       %{pinned_objects: Map.delete(user.pinned_objects, object_id)},
2388       [:pinned_objects]
2389     )
2390     |> update_and_set_cache()
2391   end
2392
2393   def update_email_notifications(user, settings) do
2394     email_notifications =
2395       user.email_notifications
2396       |> Map.merge(settings)
2397       |> Map.take(["digest"])
2398
2399     params = %{email_notifications: email_notifications}
2400     fields = [:email_notifications]
2401
2402     user
2403     |> cast(params, fields)
2404     |> validate_required(fields)
2405     |> update_and_set_cache()
2406   end
2407
2408   defp set_domain_blocks(user, domain_blocks) do
2409     params = %{domain_blocks: domain_blocks}
2410
2411     user
2412     |> cast(params, [:domain_blocks])
2413     |> validate_required([:domain_blocks])
2414     |> update_and_set_cache()
2415   end
2416
2417   def block_domain(user, domain_blocked) do
2418     set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2419   end
2420
2421   def unblock_domain(user, domain_blocked) do
2422     set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2423   end
2424
2425   @spec add_to_block(User.t(), User.t()) ::
2426           {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2427   defp add_to_block(%User{} = user, %User{} = blocked) do
2428     with {:ok, relationship} <- UserRelationship.create_block(user, blocked) do
2429       @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
2430       {:ok, relationship}
2431     end
2432   end
2433
2434   @spec add_to_block(User.t(), User.t()) ::
2435           {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2436   defp remove_from_block(%User{} = user, %User{} = blocked) do
2437     with {:ok, relationship} <- UserRelationship.delete_block(user, blocked) do
2438       @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
2439       {:ok, relationship}
2440     end
2441   end
2442
2443   def set_invisible(user, invisible) do
2444     params = %{invisible: invisible}
2445
2446     user
2447     |> cast(params, [:invisible])
2448     |> validate_required([:invisible])
2449     |> update_and_set_cache()
2450   end
2451
2452   def sanitize_html(%User{} = user) do
2453     sanitize_html(user, nil)
2454   end
2455
2456   # User data that mastodon isn't filtering (treated as plaintext):
2457   # - field name
2458   # - display name
2459   def sanitize_html(%User{} = user, filter) do
2460     fields =
2461       Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2462         %{
2463           "name" => name,
2464           "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2465         }
2466       end)
2467
2468     user
2469     |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2470     |> Map.put(:fields, fields)
2471   end
2472
2473   def get_host(%User{ap_id: ap_id} = _user) do
2474     URI.parse(ap_id).host
2475   end
2476
2477   def update_last_active_at(%__MODULE__{local: true} = user) do
2478     user
2479     |> cast(%{last_active_at: NaiveDateTime.utc_now()}, [:last_active_at])
2480     |> update_and_set_cache()
2481   end
2482
2483   def active_user_count(weeks \\ 4) do
2484     active_after = Timex.shift(NaiveDateTime.utc_now(), weeks: -weeks)
2485
2486     __MODULE__
2487     |> where([u], u.last_active_at >= ^active_after)
2488     |> where([u], u.local == true)
2489     |> Repo.aggregate(:count)
2490   end
2491 end