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
 294   def account_status(%User{local: true, is_confirmed: false}) do
 295     if Config.get([:instance, :account_activation_required]) do
 296       :confirmation_pending
 297     else
 298       :active
 299     end
 300   end
 301
 302   def account_status(%User{}), do: :active
 303
 304   @spec visible_for(User.t(), User.t() | nil) ::
 305           :visible
 306           | :invisible
 307           | :restricted_unauthenticated
 308           | :deactivated
 309           | :confirmation_pending
 310   def visible_for(user, for_user \\ nil)
 311
 312   def visible_for(%User{invisible: true}, _), do: :invisible
 313
 314   def visible_for(%User{id: user_id}, %User{id: user_id}), do: :visible
 315
 316   def visible_for(%User{} = user, nil) do
 317     if restrict_unauthenticated?(user) do
 318       :restrict_unauthenticated
 319     else
 320       visible_account_status(user)
 321     end
 322   end
 323
 324   def visible_for(%User{} = user, for_user) do
 325     if superuser?(for_user) do
 326       :visible
 327     else
 328       visible_account_status(user)
 329     end
 330   end
 331
 332   def visible_for(_, _), do: :invisible
 333
 334   defp restrict_unauthenticated?(%User{local: true}) do
 335     Config.restrict_unauthenticated_access?(:profiles, :local)
 336   end
 337
 338   defp restrict_unauthenticated?(%User{local: _}) do
 339     Config.restrict_unauthenticated_access?(:profiles, :remote)
 340   end
 341
 342   defp visible_account_status(user) do
 343     status = account_status(user)
 344
 345     if status in [:active, :password_reset_pending] do
 346       :visible
 347     else
 348       status
 349     end
 350   end
 351
 352   @spec superuser?(User.t()) :: boolean()
 353   def superuser?(%User{local: true, is_admin: true}), do: true
 354   def superuser?(%User{local: true, is_moderator: true}), do: true
 355   def superuser?(_), do: false
 356
 357   @spec invisible?(User.t()) :: boolean()
 358   def invisible?(%User{invisible: true}), do: true
 359   def invisible?(_), do: false
 360
 361   def avatar_url(user, options \\ []) do
 362     case user.avatar do
 363       %{"url" => [%{"href" => href} | _]} ->
 364         href
 365
 366       _ ->
 367         unless options[:no_default] do
 368           Config.get([:assets, :default_user_avatar], "#{Web.base_url()}/images/avi.png")
 369         end
 370     end
 371   end
 372
 373   def banner_url(user, options \\ []) do
 374     case user.banner do
 375       %{"url" => [%{"href" => href} | _]} -> href
 376       _ -> !options[:no_default] && "#{Web.base_url()}/images/banner.png"
 377     end
 378   end
 379
 380   # Should probably be renamed or removed
 381   def ap_id(%User{nickname: nickname}), do: "#{Web.base_url()}/users/#{nickname}"
 382
 383   def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
 384   def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"
 385
 386   @spec ap_following(User.t()) :: String.t()
 387   def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
 388   def ap_following(%User{} = user), do: "#{ap_id(user)}/following"
 389
 390   defp truncate_fields_param(params) do
 391     if Map.has_key?(params, :fields) do
 392       Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
 393     else
 394       params
 395     end
 396   end
 397
 398   defp truncate_if_exists(params, key, max_length) do
 399     if Map.has_key?(params, key) and is_binary(params[key]) do
 400       {value, _chopped} = String.split_at(params[key], max_length)
 401       Map.put(params, key, value)
 402     else
 403       params
 404     end
 405   end
 406
 407   defp fix_follower_address(%{follower_address: _, following_address: _} = params), do: params
 408
 409   defp fix_follower_address(%{nickname: nickname} = params),
 410     do: Map.put(params, :follower_address, ap_followers(%User{nickname: nickname}))
 411
 412   defp fix_follower_address(params), do: params
 413
 414   def remote_user_changeset(struct \\ %User{local: false}, params) do
 415     bio_limit = Config.get([:instance, :user_bio_length], 5000)
 416     name_limit = Config.get([:instance, :user_name_length], 100)
 417
 418     name =
 419       case params[:name] do
 420         name when is_binary(name) and byte_size(name) > 0 -> name
 421         _ -> params[:nickname]
 422       end
 423
 424     params =
 425       params
 426       |> Map.put(:name, name)
 427       |> Map.put_new(:last_refreshed_at, NaiveDateTime.utc_now())
 428       |> truncate_if_exists(:name, name_limit)
 429       |> truncate_if_exists(:bio, bio_limit)
 430       |> truncate_fields_param()
 431       |> fix_follower_address()
 432
 433     struct
 434     |> cast(
 435       params,
 436       [
 437         :bio,
 438         :emoji,
 439         :ap_id,
 440         :inbox,
 441         :shared_inbox,
 442         :nickname,
 443         :public_key,
 444         :avatar,
 445         :ap_enabled,
 446         :banner,
 447         :is_locked,
 448         :last_refreshed_at,
 449         :uri,
 450         :follower_address,
 451         :following_address,
 452         :hide_followers,
 453         :hide_follows,
 454         :hide_followers_count,
 455         :hide_follows_count,
 456         :follower_count,
 457         :fields,
 458         :following_count,
 459         :is_discoverable,
 460         :invisible,
 461         :actor_type,
 462         :also_known_as,
 463         :accepts_chat_messages
 464       ]
 465     )
 466     |> cast(params, [:name], empty_values: [])
 467     |> validate_required([:ap_id])
 468     |> validate_required([:name], trim: false)
 469     |> unique_constraint(:nickname)
 470     |> validate_format(:nickname, @email_regex)
 471     |> validate_length(:bio, max: bio_limit)
 472     |> validate_length(:name, max: name_limit)
 473     |> validate_fields(true)
 474     |> validate_non_local()
 475   end
 476
 477   defp validate_non_local(cng) do
 478     local? = get_field(cng, :local)
 479
 480     if local? do
 481       cng
 482       |> add_error(:local, "User is local, can't update with this changeset.")
 483     else
 484       cng
 485     end
 486   end
 487
 488   def update_changeset(struct, params \\ %{}) do
 489     bio_limit = Config.get([:instance, :user_bio_length], 5000)
 490     name_limit = Config.get([:instance, :user_name_length], 100)
 491
 492     struct
 493     |> cast(
 494       params,
 495       [
 496         :bio,
 497         :raw_bio,
 498         :name,
 499         :emoji,
 500         :avatar,
 501         :public_key,
 502         :inbox,
 503         :shared_inbox,
 504         :is_locked,
 505         :no_rich_text,
 506         :default_scope,
 507         :banner,
 508         :hide_follows,
 509         :hide_followers,
 510         :hide_followers_count,
 511         :hide_follows_count,
 512         :hide_favorites,
 513         :allow_following_move,
 514         :also_known_as,
 515         :background,
 516         :show_role,
 517         :skip_thread_containment,
 518         :fields,
 519         :raw_fields,
 520         :pleroma_settings_store,
 521         :is_discoverable,
 522         :actor_type,
 523         :accepts_chat_messages
 524       ]
 525     )
 526     |> unique_constraint(:nickname)
 527     |> validate_format(:nickname, local_nickname_regex())
 528     |> validate_length(:bio, max: bio_limit)
 529     |> validate_length(:name, min: 1, max: name_limit)
 530     |> validate_inclusion(:actor_type, ["Person", "Service"])
 531     |> put_fields()
 532     |> put_emoji()
 533     |> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
 534     |> put_change_if_present(:avatar, &put_upload(&1, :avatar))
 535     |> put_change_if_present(:banner, &put_upload(&1, :banner))
 536     |> put_change_if_present(:background, &put_upload(&1, :background))
 537     |> put_change_if_present(
 538       :pleroma_settings_store,
 539       &{:ok, Map.merge(struct.pleroma_settings_store, &1)}
 540     )
 541     |> validate_fields(false)
 542   end
 543
 544   defp put_fields(changeset) do
 545     if raw_fields = get_change(changeset, :raw_fields) do
 546       raw_fields =
 547         raw_fields
 548         |> Enum.filter(fn %{"name" => n} -> n != "" end)
 549
 550       fields =
 551         raw_fields
 552         |> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)
 553
 554       changeset
 555       |> put_change(:raw_fields, raw_fields)
 556       |> put_change(:fields, fields)
 557     else
 558       changeset
 559     end
 560   end
 561
 562   defp parse_fields(value) do
 563     value
 564     |> Formatter.linkify(mentions_format: :full)
 565     |> elem(0)
 566   end
 567
 568   defp put_emoji(changeset) do
 569     emojified_fields = [:bio, :name, :raw_fields]
 570
 571     if Enum.any?(changeset.changes, fn {k, _} -> k in emojified_fields end) do
 572       bio = Emoji.Formatter.get_emoji_map(get_field(changeset, :bio))
 573       name = Emoji.Formatter.get_emoji_map(get_field(changeset, :name))
 574
 575       emoji = Map.merge(bio, name)
 576
 577       emoji =
 578         changeset
 579         |> get_field(:raw_fields)
 580         |> Enum.reduce(emoji, fn x, acc ->
 581           Map.merge(acc, Emoji.Formatter.get_emoji_map(x["name"] <> x["value"]))
 582         end)
 583
 584       put_change(changeset, :emoji, emoji)
 585     else
 586       changeset
 587     end
 588   end
 589
 590   defp put_change_if_present(changeset, map_field, value_function) do
 591     with {:ok, value} <- fetch_change(changeset, map_field),
 592          {:ok, new_value} <- value_function.(value) do
 593       put_change(changeset, map_field, new_value)
 594     else
 595       _ -> changeset
 596     end
 597   end
 598
 599   defp put_upload(value, type) do
 600     with %Plug.Upload{} <- value,
 601          {:ok, object} <- ActivityPub.upload(value, type: type) do
 602       {:ok, object.data}
 603     end
 604   end
 605
 606   def update_as_admin_changeset(struct, params) do
 607     struct
 608     |> update_changeset(params)
 609     |> cast(params, [:email])
 610     |> delete_change(:also_known_as)
 611     |> unique_constraint(:email)
 612     |> validate_format(:email, @email_regex)
 613     |> validate_inclusion(:actor_type, ["Person", "Service"])
 614   end
 615
 616   @spec update_as_admin(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
 617   def update_as_admin(user, params) do
 618     params = Map.put(params, "password_confirmation", params["password"])
 619     changeset = update_as_admin_changeset(user, params)
 620
 621     if params["password"] do
 622       reset_password(user, changeset, params)
 623     else
 624       User.update_and_set_cache(changeset)
 625     end
 626   end
 627
 628   def password_update_changeset(struct, params) do
 629     struct
 630     |> cast(params, [:password, :password_confirmation])
 631     |> validate_required([:password, :password_confirmation])
 632     |> validate_confirmation(:password)
 633     |> put_password_hash()
 634     |> put_change(:password_reset_pending, false)
 635   end
 636
 637   @spec reset_password(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
 638   def reset_password(%User{} = user, params) do
 639     reset_password(user, user, params)
 640   end
 641
 642   def reset_password(%User{id: user_id} = user, struct, params) do
 643     multi =
 644       Multi.new()
 645       |> Multi.update(:user, password_update_changeset(struct, params))
 646       |> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
 647       |> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))
 648
 649     case Repo.transaction(multi) do
 650       {:ok, %{user: user} = _} -> set_cache(user)
 651       {:error, _, changeset, _} -> {:error, changeset}
 652     end
 653   end
 654
 655   def update_password_reset_pending(user, value) do
 656     user
 657     |> change()
 658     |> put_change(:password_reset_pending, value)
 659     |> update_and_set_cache()
 660   end
 661
 662   def force_password_reset_async(user) do
 663     BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
 664   end
 665
 666   @spec force_password_reset(User.t()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
 667   def force_password_reset(user), do: update_password_reset_pending(user, true)
 668
 669   # Used to auto-register LDAP accounts which won't have a password hash stored locally
 670   def register_changeset_ldap(struct, params = %{password: password})
 671       when is_nil(password) do
 672     params = Map.put_new(params, :accepts_chat_messages, true)
 673
 674     params =
 675       if Map.has_key?(params, :email) do
 676         Map.put_new(params, :email, params[:email])
 677       else
 678         params
 679       end
 680
 681     struct
 682     |> cast(params, [
 683       :name,
 684       :nickname,
 685       :email,
 686       :accepts_chat_messages
 687     ])
 688     |> validate_required([:name, :nickname])
 689     |> unique_constraint(:nickname)
 690     |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
 691     |> validate_format(:nickname, local_nickname_regex())
 692     |> put_ap_id()
 693     |> unique_constraint(:ap_id)
 694     |> put_following_and_follower_address()
 695   end
 696
 697   def register_changeset(struct, params \\ %{}, opts \\ []) do
 698     bio_limit = Config.get([:instance, :user_bio_length], 5000)
 699     name_limit = Config.get([:instance, :user_name_length], 100)
 700     reason_limit = Config.get([:instance, :registration_reason_length], 500)
 701     params = Map.put_new(params, :accepts_chat_messages, true)
 702
 703     confirmed? =
 704       if is_nil(opts[:confirmed]) do
 705         !Config.get([:instance, :account_activation_required])
 706       else
 707         opts[:confirmed]
 708       end
 709
 710     approved? =
 711       if is_nil(opts[:approved]) do
 712         !Config.get([:instance, :account_approval_required])
 713       else
 714         opts[:approved]
 715       end
 716
 717     struct
 718     |> confirmation_changeset(set_confirmation: confirmed?)
 719     |> approval_changeset(set_approval: approved?)
 720     |> cast(params, [
 721       :bio,
 722       :raw_bio,
 723       :email,
 724       :name,
 725       :nickname,
 726       :password,
 727       :password_confirmation,
 728       :emoji,
 729       :accepts_chat_messages,
 730       :registration_reason
 731     ])
 732     |> validate_required([:name, :nickname, :password, :password_confirmation])
 733     |> validate_confirmation(:password)
 734     |> unique_constraint(:email)
 735     |> validate_format(:email, @email_regex)
 736     |> validate_change(:email, fn :email, email ->
 737       valid? =
 738         Config.get([User, :email_blacklist])
 739         |> Enum.all?(fn blacklisted_domain ->
 740           !String.ends_with?(email, ["@" <> blacklisted_domain, "." <> blacklisted_domain])
 741         end)
 742
 743       if valid?, do: [], else: [email: "Invalid email"]
 744     end)
 745     |> unique_constraint(:nickname)
 746     |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
 747     |> validate_format(:nickname, local_nickname_regex())
 748     |> validate_length(:bio, max: bio_limit)
 749     |> validate_length(:name, min: 1, max: name_limit)
 750     |> validate_length(:registration_reason, max: reason_limit)
 751     |> maybe_validate_required_email(opts[:external])
 752     |> put_password_hash
 753     |> put_ap_id()
 754     |> unique_constraint(:ap_id)
 755     |> put_following_and_follower_address()
 756   end
 757
 758   def maybe_validate_required_email(changeset, true), do: changeset
 759
 760   def maybe_validate_required_email(changeset, _) do
 761     if Config.get([:instance, :account_activation_required]) do
 762       validate_required(changeset, [:email])
 763     else
 764       changeset
 765     end
 766   end
 767
 768   defp put_ap_id(changeset) do
 769     ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
 770     put_change(changeset, :ap_id, ap_id)
 771   end
 772
 773   defp put_following_and_follower_address(changeset) do
 774     followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
 775
 776     changeset
 777     |> put_change(:follower_address, followers)
 778   end
 779
 780   defp autofollow_users(user) do
 781     candidates = Config.get([:instance, :autofollowed_nicknames])
 782
 783     autofollowed_users =
 784       User.Query.build(%{nickname: candidates, local: true, is_active: true})
 785       |> Repo.all()
 786
 787     follow_all(user, autofollowed_users)
 788   end
 789
 790   defp autofollowing_users(user) do
 791     candidates = Config.get([:instance, :autofollowing_nicknames])
 792
 793     User.Query.build(%{nickname: candidates, local: true, deactivated: false})
 794     |> Repo.all()
 795     |> Enum.each(&follow(&1, user, :follow_accept))
 796
 797     {:ok, :success}
 798   end
 799
 800   @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
 801   def register(%Ecto.Changeset{} = changeset) do
 802     with {:ok, user} <- Repo.insert(changeset) do
 803       post_register_action(user)
 804     end
 805   end
 806
 807   def post_register_action(%User{is_confirmed: false} = user) do
 808     with {:ok, _} <- try_send_confirmation_email(user) do
 809       {:ok, user}
 810     end
 811   end
 812
 813   def post_register_action(%User{is_approved: false} = user) do
 814     with {:ok, _} <- send_user_approval_email(user),
 815          {:ok, _} <- send_admin_approval_emails(user) do
 816       {:ok, user}
 817     end
 818   end
 819
 820   def post_register_action(%User{is_approved: true, is_confirmed: true} = user) do
 821     with {:ok, user} <- autofollow_users(user),
 822          {:ok, _} <- autofollowing_users(user),
 823          {:ok, user} <- set_cache(user),
 824          {:ok, _} <- send_welcome_email(user),
 825          {:ok, _} <- send_welcome_message(user),
 826          {:ok, _} <- send_welcome_chat_message(user) do
 827       {:ok, user}
 828     end
 829   end
 830
 831   defp send_user_approval_email(user) do
 832     user
 833     |> Pleroma.Emails.UserEmail.approval_pending_email()
 834     |> Pleroma.Emails.Mailer.deliver_async()
 835
 836     {:ok, :enqueued}
 837   end
 838
 839   defp send_admin_approval_emails(user) do
 840     all_superusers()
 841     |> Enum.filter(fn user -> not is_nil(user.email) end)
 842     |> Enum.each(fn superuser ->
 843       superuser
 844       |> Pleroma.Emails.AdminEmail.new_unapproved_registration(user)
 845       |> Pleroma.Emails.Mailer.deliver_async()
 846     end)
 847
 848     {:ok, :enqueued}
 849   end
 850
 851   def send_welcome_message(user) do
 852     if User.WelcomeMessage.enabled?() do
 853       User.WelcomeMessage.post_message(user)
 854       {:ok, :enqueued}
 855     else
 856       {:ok, :noop}
 857     end
 858   end
 859
 860   def send_welcome_chat_message(user) do
 861     if User.WelcomeChatMessage.enabled?() do
 862       User.WelcomeChatMessage.post_message(user)
 863       {:ok, :enqueued}
 864     else
 865       {:ok, :noop}
 866     end
 867   end
 868
 869   def send_welcome_email(%User{email: email} = user) when is_binary(email) do
 870     if User.WelcomeEmail.enabled?() do
 871       User.WelcomeEmail.send_email(user)
 872       {:ok, :enqueued}
 873     else
 874       {:ok, :noop}
 875     end
 876   end
 877
 878   def send_welcome_email(_), do: {:ok, :noop}
 879
 880   @spec try_send_confirmation_email(User.t()) :: {:ok, :enqueued | :noop}
 881   def try_send_confirmation_email(%User{is_confirmed: false, email: email} = user)
 882       when is_binary(email) do
 883     if Config.get([:instance, :account_activation_required]) do
 884       send_confirmation_email(user)
 885       {:ok, :enqueued}
 886     else
 887       {:ok, :noop}
 888     end
 889   end
 890
 891   def try_send_confirmation_email(_), do: {:ok, :noop}
 892
 893   @spec send_confirmation_email(Uset.t()) :: User.t()
 894   def send_confirmation_email(%User{} = user) do
 895     user
 896     |> Pleroma.Emails.UserEmail.account_confirmation_email()
 897     |> Pleroma.Emails.Mailer.deliver_async()
 898
 899     user
 900   end
 901
 902   def needs_update?(%User{local: true}), do: false
 903
 904   def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
 905
 906   def needs_update?(%User{local: false} = user) do
 907     NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
 908   end
 909
 910   def needs_update?(_), do: true
 911
 912   @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
 913
 914   # "Locked" (self-locked) users demand explicit authorization of follow requests
 915   def maybe_direct_follow(%User{} = follower, %User{local: true, is_locked: true} = followed) do
 916     follow(follower, followed, :follow_pending)
 917   end
 918
 919   def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
 920     follow(follower, followed)
 921   end
 922
 923   def maybe_direct_follow(%User{} = follower, %User{} = followed) do
 924     if not ap_enabled?(followed) do
 925       follow(follower, followed)
 926     else
 927       {:ok, follower, followed}
 928     end
 929   end
 930
 931   @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
 932   @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
 933   def follow_all(follower, followeds) do
 934     followeds
 935     |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
 936     |> Enum.each(&follow(follower, &1, :follow_accept))
 937
 938     set_cache(follower)
 939   end
 940
 941   def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
 942     deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
 943
 944     cond do
 945       not followed.is_active ->
 946         {:error, "Could not follow user: #{followed.nickname} is deactivated."}
 947
 948       deny_follow_blocked and blocks?(followed, follower) ->
 949         {:error, "Could not follow user: #{followed.nickname} blocked you."}
 950
 951       true ->
 952         FollowingRelationship.follow(follower, followed, state)
 953     end
 954   end
 955
 956   def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
 957     {:error, "Not subscribed!"}
 958   end
 959
 960   @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
 961   def unfollow(%User{} = follower, %User{} = followed) do
 962     case do_unfollow(follower, followed) do
 963       {:ok, follower, followed} ->
 964         {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
 965
 966       error ->
 967         error
 968     end
 969   end
 970
 971   @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
 972   defp do_unfollow(%User{} = follower, %User{} = followed) do
 973     case get_follow_state(follower, followed) do
 974       state when state in [:follow_pending, :follow_accept] ->
 975         FollowingRelationship.unfollow(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, is_active: true})
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, is_active: true}
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, is_active: true})
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 set_activation_async(user, status \\ true) do
1587     BackgroundWorker.enqueue("user_activation", %{"user_id" => user.id, "status" => status})
1588   end
1589
1590   @spec set_activation([User.t()], boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
1591   def set_activation(users, status) when is_list(users) do
1592     Repo.transaction(fn ->
1593       for user <- users, do: set_activation(user, status)
1594     end)
1595   end
1596
1597   @spec set_activation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
1598   def set_activation(%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{is_approved: false} = user) do
1624     with chg <- change(user, is_approved: true),
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{is_confirmed: false} = user) do
1642     with chg <- confirmation_changeset(user, set_confirmation: true),
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       is_confirmed: true,
1682       password_reset_pending: false,
1683       is_approved: true,
1684       registration_reason: nil,
1685       confirmation_token: nil,
1686       domain_blocks: [],
1687       is_active: false,
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(:set_activation_async, user, status), do: set_activation(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, is_active: true})
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.is_active == ^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 set_confirmation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
2138   def set_confirmation(%User{} = user, bool) do
2139     user
2140     |> confirmation_changeset(set_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: Pleroma.Password.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, status) do
2218     user
2219     |> cast(%{is_active: status}, [:is_active])
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, set_confirmation: confirmed?) do
2309     params =
2310       if confirmed? do
2311         %{
2312           is_confirmed: true,
2313           confirmation_token: nil
2314         }
2315       else
2316         %{
2317           is_confirmed: false,
2318           confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2319         }
2320       end
2321
2322     cast(user, params, [:is_confirmed, :confirmation_token])
2323   end
2324
2325   @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
2326   def approval_changeset(user, set_approval: approved?) do
2327     cast(user, %{is_approved: approved?}, [:is_approved])
2328   end
2329
2330   def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2331     if id not in user.pinned_activities do
2332       max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2333       params = %{pinned_activities: user.pinned_activities ++ [id]}
2334
2335       # if pinned activity was scheduled for deletion, we remove job
2336       if expiration = Pleroma.Workers.PurgeExpiredActivity.get_expiration(id) do
2337         Oban.cancel_job(expiration.id)
2338       end
2339
2340       user
2341       |> cast(params, [:pinned_activities])
2342       |> validate_length(:pinned_activities,
2343         max: max_pinned_statuses,
2344         message: "You have already pinned the maximum number of statuses"
2345       )
2346     else
2347       change(user)
2348     end
2349     |> update_and_set_cache()
2350   end
2351
2352   def remove_pinnned_activity(user, %Pleroma.Activity{id: id, data: data}) do
2353     params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2354
2355     # if pinned activity was scheduled for deletion, we reschedule it for deletion
2356     if data["expires_at"] do
2357       # MRF.ActivityExpirationPolicy used UTC timestamps for expires_at in original implementation
2358       {:ok, expires_at} =
2359         data["expires_at"] |> Pleroma.EctoType.ActivityPub.ObjectValidators.DateTime.cast()
2360
2361       Pleroma.Workers.PurgeExpiredActivity.enqueue(%{
2362         activity_id: id,
2363         expires_at: expires_at
2364       })
2365     end
2366
2367     user
2368     |> cast(params, [:pinned_activities])
2369     |> update_and_set_cache()
2370   end
2371
2372   def update_email_notifications(user, settings) do
2373     email_notifications =
2374       user.email_notifications
2375       |> Map.merge(settings)
2376       |> Map.take(["digest"])
2377
2378     params = %{email_notifications: email_notifications}
2379     fields = [:email_notifications]
2380
2381     user
2382     |> cast(params, fields)
2383     |> validate_required(fields)
2384     |> update_and_set_cache()
2385   end
2386
2387   defp set_domain_blocks(user, domain_blocks) do
2388     params = %{domain_blocks: domain_blocks}
2389
2390     user
2391     |> cast(params, [:domain_blocks])
2392     |> validate_required([:domain_blocks])
2393     |> update_and_set_cache()
2394   end
2395
2396   def block_domain(user, domain_blocked) do
2397     set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2398   end
2399
2400   def unblock_domain(user, domain_blocked) do
2401     set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2402   end
2403
2404   @spec add_to_block(User.t(), User.t()) ::
2405           {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2406   defp add_to_block(%User{} = user, %User{} = blocked) do
2407     with {:ok, relationship} <- UserRelationship.create_block(user, blocked) do
2408       @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
2409       {:ok, relationship}
2410     end
2411   end
2412
2413   @spec add_to_block(User.t(), User.t()) ::
2414           {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2415   defp remove_from_block(%User{} = user, %User{} = blocked) do
2416     with {:ok, relationship} <- UserRelationship.delete_block(user, blocked) do
2417       @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
2418       {:ok, relationship}
2419     end
2420   end
2421
2422   def set_invisible(user, invisible) do
2423     params = %{invisible: invisible}
2424
2425     user
2426     |> cast(params, [:invisible])
2427     |> validate_required([:invisible])
2428     |> update_and_set_cache()
2429   end
2430
2431   def sanitize_html(%User{} = user) do
2432     sanitize_html(user, nil)
2433   end
2434
2435   # User data that mastodon isn't filtering (treated as plaintext):
2436   # - field name
2437   # - display name
2438   def sanitize_html(%User{} = user, filter) do
2439     fields =
2440       Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2441         %{
2442           "name" => name,
2443           "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2444         }
2445       end)
2446
2447     user
2448     |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2449     |> Map.put(:fields, fields)
2450   end
2451
2452   def get_host(%User{ap_id: ap_id} = _user) do
2453     URI.parse(ap_id).host
2454   end
2455 end