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