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

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