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   defp delete_and_invalidate_cache(%User{} = user) do
1435     invalidate_cache(user)
1436     Repo.delete(user)
1437   end
1438
1439   defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)
1440
1441   defp delete_or_deactivate(%User{local: true} = user) do
1442     status = account_status(user)
1443
1444     if status == :confirmation_pending do
1445       delete_and_invalidate_cache(user)
1446     else
1447       user
1448       |> change(%{deactivated: true, email: nil})
1449       |> update_and_set_cache()
1450     end
1451   end
1452
1453   def perform(:force_password_reset, user), do: force_password_reset(user)
1454
1455   @spec perform(atom(), User.t()) :: {:ok, User.t()}
1456   def perform(:delete, %User{} = user) do
1457     # Remove all relationships
1458     user
1459     |> get_followers()
1460     |> Enum.each(fn follower ->
1461       ActivityPub.unfollow(follower, user)
1462       unfollow(follower, user)
1463     end)
1464
1465     user
1466     |> get_friends()
1467     |> Enum.each(fn followed ->
1468       ActivityPub.unfollow(user, followed)
1469       unfollow(user, followed)
1470     end)
1471
1472     delete_user_activities(user)
1473
1474     delete_or_deactivate(user)
1475   end
1476
1477   def perform(:deactivate_async, user, status), do: deactivate(user, status)
1478
1479   @spec perform(atom(), User.t(), list()) :: list() | {:error, any()}
1480   def perform(:blocks_import, %User{} = blocker, blocked_identifiers)
1481       when is_list(blocked_identifiers) do
1482     Enum.map(
1483       blocked_identifiers,
1484       fn blocked_identifier ->
1485         with {:ok, %User{} = blocked} <- get_or_fetch(blocked_identifier),
1486              {:ok, _user_block} <- block(blocker, blocked),
1487              {:ok, _} <- ActivityPub.block(blocker, blocked) do
1488           blocked
1489         else
1490           err ->
1491             Logger.debug("blocks_import failed for #{blocked_identifier} with: #{inspect(err)}")
1492             err
1493         end
1494       end
1495     )
1496   end
1497
1498   def perform(:follow_import, %User{} = follower, followed_identifiers)
1499       when is_list(followed_identifiers) do
1500     Enum.map(
1501       followed_identifiers,
1502       fn followed_identifier ->
1503         with {:ok, %User{} = followed} <- get_or_fetch(followed_identifier),
1504              {:ok, follower} <- maybe_direct_follow(follower, followed),
1505              {:ok, _} <- ActivityPub.follow(follower, followed) do
1506           followed
1507         else
1508           err ->
1509             Logger.debug("follow_import failed for #{followed_identifier} with: #{inspect(err)}")
1510             err
1511         end
1512       end
1513     )
1514   end
1515
1516   @spec external_users_query() :: Ecto.Query.t()
1517   def external_users_query do
1518     User.Query.build(%{
1519       external: true,
1520       active: true,
1521       order_by: :id
1522     })
1523   end
1524
1525   @spec external_users(keyword()) :: [User.t()]
1526   def external_users(opts \\ []) do
1527     query =
1528       external_users_query()
1529       |> select([u], struct(u, [:id, :ap_id]))
1530
1531     query =
1532       if opts[:max_id],
1533         do: where(query, [u], u.id > ^opts[:max_id]),
1534         else: query
1535
1536     query =
1537       if opts[:limit],
1538         do: limit(query, ^opts[:limit]),
1539         else: query
1540
1541     Repo.all(query)
1542   end
1543
1544   def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers) do
1545     BackgroundWorker.enqueue("blocks_import", %{
1546       "blocker_id" => blocker.id,
1547       "blocked_identifiers" => blocked_identifiers
1548     })
1549   end
1550
1551   def follow_import(%User{} = follower, followed_identifiers)
1552       when is_list(followed_identifiers) do
1553     BackgroundWorker.enqueue("follow_import", %{
1554       "follower_id" => follower.id,
1555       "followed_identifiers" => followed_identifiers
1556     })
1557   end
1558
1559   def delete_user_activities(%User{ap_id: ap_id} = user) do
1560     ap_id
1561     |> Activity.Queries.by_actor()
1562     |> RepoStreamer.chunk_stream(50)
1563     |> Stream.each(fn activities ->
1564       Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1565     end)
1566     |> Stream.run()
1567   end
1568
1569   defp delete_activity(%{data: %{"type" => "Create", "object" => object}}, user) do
1570     {:ok, delete_data, _} = Builder.delete(user, object)
1571
1572     Pipeline.common_pipeline(delete_data, local: user.local)
1573   end
1574
1575   defp delete_activity(%{data: %{"type" => type}} = activity, user)
1576        when type in ["Like", "Announce"] do
1577     {:ok, undo, _} = Builder.undo(user, activity)
1578     Pipeline.common_pipeline(undo, local: user.local)
1579   end
1580
1581   defp delete_activity(_activity, _user), do: "Doing nothing"
1582
1583   def html_filter_policy(%User{no_rich_text: true}) do
1584     Pleroma.HTML.Scrubber.TwitterText
1585   end
1586
1587   def html_filter_policy(_), do: Pleroma.Config.get([:markup, :scrub_policy])
1588
1589   def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1590
1591   def get_or_fetch_by_ap_id(ap_id) do
1592     user = get_cached_by_ap_id(ap_id)
1593
1594     if !is_nil(user) and !needs_update?(user) do
1595       {:ok, user}
1596     else
1597       fetch_by_ap_id(ap_id)
1598     end
1599   end
1600
1601   @doc """
1602   Creates an internal service actor by URI if missing.
1603   Optionally takes nickname for addressing.
1604   """
1605   @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1606   def get_or_create_service_actor_by_ap_id(uri, nickname) do
1607     {_, user} =
1608       case get_cached_by_ap_id(uri) do
1609         nil ->
1610           with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1611             Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1612             {:error, nil}
1613           end
1614
1615         %User{invisible: false} = user ->
1616           set_invisible(user)
1617
1618         user ->
1619           {:ok, user}
1620       end
1621
1622     user
1623   end
1624
1625   @spec set_invisible(User.t()) :: {:ok, User.t()}
1626   defp set_invisible(user) do
1627     user
1628     |> change(%{invisible: true})
1629     |> update_and_set_cache()
1630   end
1631
1632   @spec create_service_actor(String.t(), String.t()) ::
1633           {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1634   defp create_service_actor(uri, nickname) do
1635     %User{
1636       invisible: true,
1637       local: true,
1638       ap_id: uri,
1639       nickname: nickname,
1640       follower_address: uri <> "/followers"
1641     }
1642     |> change
1643     |> unique_constraint(:nickname)
1644     |> Repo.insert()
1645     |> set_cache()
1646   end
1647
1648   def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1649     key =
1650       public_key_pem
1651       |> :public_key.pem_decode()
1652       |> hd()
1653       |> :public_key.pem_entry_decode()
1654
1655     {:ok, key}
1656   end
1657
1658   def public_key(_), do: {:error, "key not found"}
1659
1660   def get_public_key_for_ap_id(ap_id) do
1661     with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1662          {:ok, public_key} <- public_key(user) do
1663       {:ok, public_key}
1664     else
1665       _ -> :error
1666     end
1667   end
1668
1669   def ap_enabled?(%User{local: true}), do: true
1670   def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1671   def ap_enabled?(_), do: false
1672
1673   @doc "Gets or fetch a user by uri or nickname."
1674   @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1675   def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1676   def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1677
1678   # wait a period of time and return newest version of the User structs
1679   # this is because we have synchronous follow APIs and need to simulate them
1680   # with an async handshake
1681   def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1682     with %User{} = a <- get_cached_by_id(a.id),
1683          %User{} = b <- get_cached_by_id(b.id) do
1684       {:ok, a, b}
1685     else
1686       nil -> :error
1687     end
1688   end
1689
1690   def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1691     with :ok <- :timer.sleep(timeout),
1692          %User{} = a <- get_cached_by_id(a.id),
1693          %User{} = b <- get_cached_by_id(b.id) do
1694       {:ok, a, b}
1695     else
1696       nil -> :error
1697     end
1698   end
1699
1700   def parse_bio(bio) when is_binary(bio) and bio != "" do
1701     bio
1702     |> CommonUtils.format_input("text/plain", mentions_format: :full)
1703     |> elem(0)
1704   end
1705
1706   def parse_bio(_), do: ""
1707
1708   def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1709     # TODO: get profile URLs other than user.ap_id
1710     profile_urls = [user.ap_id]
1711
1712     bio
1713     |> CommonUtils.format_input("text/plain",
1714       mentions_format: :full,
1715       rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1716     )
1717     |> elem(0)
1718   end
1719
1720   def parse_bio(_, _), do: ""
1721
1722   def tag(user_identifiers, tags) when is_list(user_identifiers) do
1723     Repo.transaction(fn ->
1724       for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1725     end)
1726   end
1727
1728   def tag(nickname, tags) when is_binary(nickname),
1729     do: tag(get_by_nickname(nickname), tags)
1730
1731   def tag(%User{} = user, tags),
1732     do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1733
1734   def untag(user_identifiers, tags) when is_list(user_identifiers) do
1735     Repo.transaction(fn ->
1736       for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1737     end)
1738   end
1739
1740   def untag(nickname, tags) when is_binary(nickname),
1741     do: untag(get_by_nickname(nickname), tags)
1742
1743   def untag(%User{} = user, tags),
1744     do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1745
1746   defp update_tags(%User{} = user, new_tags) do
1747     {:ok, updated_user} =
1748       user
1749       |> change(%{tags: new_tags})
1750       |> update_and_set_cache()
1751
1752     updated_user
1753   end
1754
1755   defp normalize_tags(tags) do
1756     [tags]
1757     |> List.flatten()
1758     |> Enum.map(&String.downcase/1)
1759   end
1760
1761   defp local_nickname_regex do
1762     if Pleroma.Config.get([:instance, :extended_nickname_format]) do
1763       @extended_local_nickname_regex
1764     else
1765       @strict_local_nickname_regex
1766     end
1767   end
1768
1769   def local_nickname(nickname_or_mention) do
1770     nickname_or_mention
1771     |> full_nickname()
1772     |> String.split("@")
1773     |> hd()
1774   end
1775
1776   def full_nickname(nickname_or_mention),
1777     do: String.trim_leading(nickname_or_mention, "@")
1778
1779   def error_user(ap_id) do
1780     %User{
1781       name: ap_id,
1782       ap_id: ap_id,
1783       nickname: "erroruser@example.com",
1784       inserted_at: NaiveDateTime.utc_now()
1785     }
1786   end
1787
1788   @spec all_superusers() :: [User.t()]
1789   def all_superusers do
1790     User.Query.build(%{super_users: true, local: true, deactivated: false})
1791     |> Repo.all()
1792   end
1793
1794   def muting_reblogs?(%User{} = user, %User{} = target) do
1795     UserRelationship.reblog_mute_exists?(user, target)
1796   end
1797
1798   def showing_reblogs?(%User{} = user, %User{} = target) do
1799     not muting_reblogs?(user, target)
1800   end
1801
1802   @doc """
1803   The function returns a query to get users with no activity for given interval of days.
1804   Inactive users are those who didn't read any notification, or had any activity where
1805   the user is the activity's actor, during `inactivity_threshold` days.
1806   Deactivated users will not appear in this list.
1807
1808   ## Examples
1809
1810       iex> Pleroma.User.list_inactive_users()
1811       %Ecto.Query{}
1812   """
1813   @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
1814   def list_inactive_users_query(inactivity_threshold \\ 7) do
1815     negative_inactivity_threshold = -inactivity_threshold
1816     now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
1817     # Subqueries are not supported in `where` clauses, join gets too complicated.
1818     has_read_notifications =
1819       from(n in Pleroma.Notification,
1820         where: n.seen == true,
1821         group_by: n.id,
1822         having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
1823         select: n.user_id
1824       )
1825       |> Pleroma.Repo.all()
1826
1827     from(u in Pleroma.User,
1828       left_join: a in Pleroma.Activity,
1829       on: u.ap_id == a.actor,
1830       where: not is_nil(u.nickname),
1831       where: u.deactivated != ^true,
1832       where: u.id not in ^has_read_notifications,
1833       group_by: u.id,
1834       having:
1835         max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
1836           is_nil(max(a.inserted_at))
1837     )
1838   end
1839
1840   @doc """
1841   Enable or disable email notifications for user
1842
1843   ## Examples
1844
1845       iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
1846       Pleroma.User{email_notifications: %{"digest" => true}}
1847
1848       iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
1849       Pleroma.User{email_notifications: %{"digest" => false}}
1850   """
1851   @spec switch_email_notifications(t(), String.t(), boolean()) ::
1852           {:ok, t()} | {:error, Ecto.Changeset.t()}
1853   def switch_email_notifications(user, type, status) do
1854     User.update_email_notifications(user, %{type => status})
1855   end
1856
1857   @doc """
1858   Set `last_digest_emailed_at` value for the user to current time
1859   """
1860   @spec touch_last_digest_emailed_at(t()) :: t()
1861   def touch_last_digest_emailed_at(user) do
1862     now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
1863
1864     {:ok, updated_user} =
1865       user
1866       |> change(%{last_digest_emailed_at: now})
1867       |> update_and_set_cache()
1868
1869     updated_user
1870   end
1871
1872   @spec toggle_confirmation(User.t()) :: {:ok, User.t()} | {:error, Changeset.t()}
1873   def toggle_confirmation(%User{} = user) do
1874     user
1875     |> confirmation_changeset(need_confirmation: !user.confirmation_pending)
1876     |> update_and_set_cache()
1877   end
1878
1879   @spec toggle_confirmation([User.t()]) :: [{:ok, User.t()} | {:error, Changeset.t()}]
1880   def toggle_confirmation(users) do
1881     Enum.map(users, &toggle_confirmation/1)
1882   end
1883
1884   def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
1885     mascot
1886   end
1887
1888   def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
1889     # use instance-default
1890     config = Pleroma.Config.get([:assets, :mascots])
1891     default_mascot = Pleroma.Config.get([:assets, :default_mascot])
1892     mascot = Keyword.get(config, default_mascot)
1893
1894     %{
1895       "id" => "default-mascot",
1896       "url" => mascot[:url],
1897       "preview_url" => mascot[:url],
1898       "pleroma" => %{
1899         "mime_type" => mascot[:mime_type]
1900       }
1901     }
1902   end
1903
1904   def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
1905
1906   def ensure_keys_present(%User{} = user) do
1907     with {:ok, pem} <- Keys.generate_rsa_pem() do
1908       user
1909       |> cast(%{keys: pem}, [:keys])
1910       |> validate_required([:keys])
1911       |> update_and_set_cache()
1912     end
1913   end
1914
1915   def get_ap_ids_by_nicknames(nicknames) do
1916     from(u in User,
1917       where: u.nickname in ^nicknames,
1918       select: u.ap_id
1919     )
1920     |> Repo.all()
1921   end
1922
1923   defdelegate search(query, opts \\ []), to: User.Search
1924
1925   defp put_password_hash(
1926          %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
1927        ) do
1928     change(changeset, password_hash: Pbkdf2.hashpwsalt(password))
1929   end
1930
1931   defp put_password_hash(changeset), do: changeset
1932
1933   def is_internal_user?(%User{nickname: nil}), do: true
1934   def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
1935   def is_internal_user?(_), do: false
1936
1937   # A hack because user delete activities have a fake id for whatever reason
1938   # TODO: Get rid of this
1939   def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
1940
1941   def get_delivered_users_by_object_id(object_id) do
1942     from(u in User,
1943       inner_join: delivery in assoc(u, :deliveries),
1944       where: delivery.object_id == ^object_id
1945     )
1946     |> Repo.all()
1947   end
1948
1949   def change_email(user, email) do
1950     user
1951     |> cast(%{email: email}, [:email])
1952     |> validate_required([:email])
1953     |> unique_constraint(:email)
1954     |> validate_format(:email, @email_regex)
1955     |> update_and_set_cache()
1956   end
1957
1958   # Internal function; public one is `deactivate/2`
1959   defp set_activation_status(user, deactivated) do
1960     user
1961     |> cast(%{deactivated: deactivated}, [:deactivated])
1962     |> update_and_set_cache()
1963   end
1964
1965   def update_banner(user, banner) do
1966     user
1967     |> cast(%{banner: banner}, [:banner])
1968     |> update_and_set_cache()
1969   end
1970
1971   def update_background(user, background) do
1972     user
1973     |> cast(%{background: background}, [:background])
1974     |> update_and_set_cache()
1975   end
1976
1977   def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
1978     %{
1979       admin: is_admin,
1980       moderator: is_moderator
1981     }
1982   end
1983
1984   def validate_fields(changeset, remote? \\ false) do
1985     limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
1986     limit = Pleroma.Config.get([:instance, limit_name], 0)
1987
1988     changeset
1989     |> validate_length(:fields, max: limit)
1990     |> validate_change(:fields, fn :fields, fields ->
1991       if Enum.all?(fields, &valid_field?/1) do
1992         []
1993       else
1994         [fields: "invalid"]
1995       end
1996     end)
1997   end
1998
1999   defp valid_field?(%{"name" => name, "value" => value}) do
2000     name_limit = Pleroma.Config.get([:instance, :account_field_name_length], 255)
2001     value_limit = Pleroma.Config.get([:instance, :account_field_value_length], 255)
2002
2003     is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2004       String.length(value) <= value_limit
2005   end
2006
2007   defp valid_field?(_), do: false
2008
2009   defp truncate_field(%{"name" => name, "value" => value}) do
2010     {name, _chopped} =
2011       String.split_at(name, Pleroma.Config.get([:instance, :account_field_name_length], 255))
2012
2013     {value, _chopped} =
2014       String.split_at(value, Pleroma.Config.get([:instance, :account_field_value_length], 255))
2015
2016     %{"name" => name, "value" => value}
2017   end
2018
2019   def admin_api_update(user, params) do
2020     user
2021     |> cast(params, [
2022       :is_moderator,
2023       :is_admin,
2024       :show_role
2025     ])
2026     |> update_and_set_cache()
2027   end
2028
2029   @doc "Signs user out of all applications"
2030   def global_sign_out(user) do
2031     OAuth.Authorization.delete_user_authorizations(user)
2032     OAuth.Token.delete_user_tokens(user)
2033   end
2034
2035   def mascot_update(user, url) do
2036     user
2037     |> cast(%{mascot: url}, [:mascot])
2038     |> validate_required([:mascot])
2039     |> update_and_set_cache()
2040   end
2041
2042   def mastodon_settings_update(user, settings) do
2043     user
2044     |> cast(%{settings: settings}, [:settings])
2045     |> validate_required([:settings])
2046     |> update_and_set_cache()
2047   end
2048
2049   @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2050   def confirmation_changeset(user, need_confirmation: need_confirmation?) do
2051     params =
2052       if need_confirmation? do
2053         %{
2054           confirmation_pending: true,
2055           confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2056         }
2057       else
2058         %{
2059           confirmation_pending: false,
2060           confirmation_token: nil
2061         }
2062       end
2063
2064     cast(user, params, [:confirmation_pending, :confirmation_token])
2065   end
2066
2067   def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2068     if id not in user.pinned_activities do
2069       max_pinned_statuses = Pleroma.Config.get([:instance, :max_pinned_statuses], 0)
2070       params = %{pinned_activities: user.pinned_activities ++ [id]}
2071
2072       user
2073       |> cast(params, [:pinned_activities])
2074       |> validate_length(:pinned_activities,
2075         max: max_pinned_statuses,
2076         message: "You have already pinned the maximum number of statuses"
2077       )
2078     else
2079       change(user)
2080     end
2081     |> update_and_set_cache()
2082   end
2083
2084   def remove_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2085     params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2086
2087     user
2088     |> cast(params, [:pinned_activities])
2089     |> update_and_set_cache()
2090   end
2091
2092   def update_email_notifications(user, settings) do
2093     email_notifications =
2094       user.email_notifications
2095       |> Map.merge(settings)
2096       |> Map.take(["digest"])
2097
2098     params = %{email_notifications: email_notifications}
2099     fields = [:email_notifications]
2100
2101     user
2102     |> cast(params, fields)
2103     |> validate_required(fields)
2104     |> update_and_set_cache()
2105   end
2106
2107   defp set_domain_blocks(user, domain_blocks) do
2108     params = %{domain_blocks: domain_blocks}
2109
2110     user
2111     |> cast(params, [:domain_blocks])
2112     |> validate_required([:domain_blocks])
2113     |> update_and_set_cache()
2114   end
2115
2116   def block_domain(user, domain_blocked) do
2117     set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2118   end
2119
2120   def unblock_domain(user, domain_blocked) do
2121     set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2122   end
2123
2124   @spec add_to_block(User.t(), User.t()) ::
2125           {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2126   defp add_to_block(%User{} = user, %User{} = blocked) do
2127     UserRelationship.create_block(user, blocked)
2128   end
2129
2130   @spec add_to_block(User.t(), User.t()) ::
2131           {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2132   defp remove_from_block(%User{} = user, %User{} = blocked) do
2133     UserRelationship.delete_block(user, blocked)
2134   end
2135
2136   defp add_to_mutes(%User{} = user, %User{} = muted_user, notifications?) do
2137     with {:ok, user_mute} <- UserRelationship.create_mute(user, muted_user),
2138          {:ok, user_notification_mute} <-
2139            (notifications? && UserRelationship.create_notification_mute(user, muted_user)) ||
2140              {:ok, nil} do
2141       {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
2142     end
2143   end
2144
2145   defp remove_from_mutes(user, %User{} = muted_user) do
2146     with {:ok, user_mute} <- UserRelationship.delete_mute(user, muted_user),
2147          {:ok, user_notification_mute} <-
2148            UserRelationship.delete_notification_mute(user, muted_user) do
2149       {:ok, [user_mute, user_notification_mute]}
2150     end
2151   end
2152
2153   def set_invisible(user, invisible) do
2154     params = %{invisible: invisible}
2155
2156     user
2157     |> cast(params, [:invisible])
2158     |> validate_required([:invisible])
2159     |> update_and_set_cache()
2160   end
2161
2162   def sanitize_html(%User{} = user) do
2163     sanitize_html(user, nil)
2164   end
2165
2166   # User data that mastodon isn't filtering (treated as plaintext):
2167   # - field name
2168   # - display name
2169   def sanitize_html(%User{} = user, filter) do
2170     fields =
2171       Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2172         %{
2173           "name" => name,
2174           "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2175         }
2176       end)
2177
2178     user
2179     |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2180     |> Map.put(:fields, fields)
2181   end
2182 end