git.squeep.com Git - akkoma/blob - lib/pleroma/user.ex

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