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