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