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

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