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