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