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