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