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