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