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