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