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 approve(users) when is_list(users) do
1475     Repo.transaction(fn ->
1476       Enum.map(users, fn user ->
1477         with {:ok, user} <- approve(user), do: user
1478       end)
1479     end)
1480   end
1481
1482   def approve(%User{} = user) do
1483     change(user, approval_pending: false)
1484     |> update_and_set_cache()
1485   end
1486
1487   def update_notification_settings(%User{} = user, settings) do
1488     user
1489     |> cast(%{notification_settings: settings}, [])
1490     |> cast_embed(:notification_settings)
1491     |> validate_required([:notification_settings])
1492     |> update_and_set_cache()
1493   end
1494
1495   def delete(users) when is_list(users) do
1496     for user <- users, do: delete(user)
1497   end
1498
1499   def delete(%User{} = user) do
1500     BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1501   end
1502
1503   defp delete_and_invalidate_cache(%User{} = user) do
1504     invalidate_cache(user)
1505     Repo.delete(user)
1506   end
1507
1508   defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)
1509
1510   defp delete_or_deactivate(%User{local: true} = user) do
1511     status = account_status(user)
1512
1513     if status == :confirmation_pending do
1514       delete_and_invalidate_cache(user)
1515     else
1516       user
1517       |> change(%{deactivated: true, email: nil})
1518       |> update_and_set_cache()
1519     end
1520   end
1521
1522   def perform(:force_password_reset, user), do: force_password_reset(user)
1523
1524   @spec perform(atom(), User.t()) :: {:ok, User.t()}
1525   def perform(:delete, %User{} = user) do
1526     # Remove all relationships
1527     user
1528     |> get_followers()
1529     |> Enum.each(fn follower ->
1530       ActivityPub.unfollow(follower, user)
1531       unfollow(follower, user)
1532     end)
1533
1534     user
1535     |> get_friends()
1536     |> Enum.each(fn followed ->
1537       ActivityPub.unfollow(user, followed)
1538       unfollow(user, followed)
1539     end)
1540
1541     delete_user_activities(user)
1542     delete_notifications_from_user_activities(user)
1543
1544     delete_outgoing_pending_follow_requests(user)
1545
1546     delete_or_deactivate(user)
1547   end
1548
1549   def perform(:deactivate_async, user, status), do: deactivate(user, status)
1550
1551   @spec perform(atom(), User.t(), list()) :: list() | {:error, any()}
1552   def perform(:blocks_import, %User{} = blocker, blocked_identifiers)
1553       when is_list(blocked_identifiers) do
1554     Enum.map(
1555       blocked_identifiers,
1556       fn blocked_identifier ->
1557         with {:ok, %User{} = blocked} <- get_or_fetch(blocked_identifier),
1558              {:ok, _block} <- CommonAPI.block(blocker, blocked) do
1559           blocked
1560         else
1561           err ->
1562             Logger.debug("blocks_import failed for #{blocked_identifier} with: #{inspect(err)}")
1563             err
1564         end
1565       end
1566     )
1567   end
1568
1569   def perform(:follow_import, %User{} = follower, followed_identifiers)
1570       when is_list(followed_identifiers) do
1571     Enum.map(
1572       followed_identifiers,
1573       fn followed_identifier ->
1574         with {:ok, %User{} = followed} <- get_or_fetch(followed_identifier),
1575              {:ok, follower} <- maybe_direct_follow(follower, followed),
1576              {:ok, _, _, _} <- CommonAPI.follow(follower, followed) do
1577           followed
1578         else
1579           err ->
1580             Logger.debug("follow_import failed for #{followed_identifier} with: #{inspect(err)}")
1581             err
1582         end
1583       end
1584     )
1585   end
1586
1587   @spec external_users_query() :: Ecto.Query.t()
1588   def external_users_query do
1589     User.Query.build(%{
1590       external: true,
1591       active: true,
1592       order_by: :id
1593     })
1594   end
1595
1596   @spec external_users(keyword()) :: [User.t()]
1597   def external_users(opts \\ []) do
1598     query =
1599       external_users_query()
1600       |> select([u], struct(u, [:id, :ap_id]))
1601
1602     query =
1603       if opts[:max_id],
1604         do: where(query, [u], u.id > ^opts[:max_id]),
1605         else: query
1606
1607     query =
1608       if opts[:limit],
1609         do: limit(query, ^opts[:limit]),
1610         else: query
1611
1612     Repo.all(query)
1613   end
1614
1615   def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers) do
1616     BackgroundWorker.enqueue("blocks_import", %{
1617       "blocker_id" => blocker.id,
1618       "blocked_identifiers" => blocked_identifiers
1619     })
1620   end
1621
1622   def follow_import(%User{} = follower, followed_identifiers)
1623       when is_list(followed_identifiers) do
1624     BackgroundWorker.enqueue("follow_import", %{
1625       "follower_id" => follower.id,
1626       "followed_identifiers" => followed_identifiers
1627     })
1628   end
1629
1630   def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1631     Notification
1632     |> join(:inner, [n], activity in assoc(n, :activity))
1633     |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1634     |> Repo.delete_all()
1635   end
1636
1637   def delete_user_activities(%User{ap_id: ap_id} = user) do
1638     ap_id
1639     |> Activity.Queries.by_actor()
1640     |> RepoStreamer.chunk_stream(50)
1641     |> Stream.each(fn activities ->
1642       Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1643     end)
1644     |> Stream.run()
1645   end
1646
1647   defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1648     with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1649          {:ok, delete_data, _} <- Builder.delete(user, object) do
1650       Pipeline.common_pipeline(delete_data, local: user.local)
1651     else
1652       {:find_object, nil} ->
1653         # We have the create activity, but not the object, it was probably pruned.
1654         # Insert a tombstone and try again
1655         with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1656              {:ok, _tombstone} <- Object.create(tombstone_data) do
1657           delete_activity(activity, user)
1658         end
1659
1660       e ->
1661         Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1662         Logger.error("Error: #{inspect(e)}")
1663     end
1664   end
1665
1666   defp delete_activity(%{data: %{"type" => type}} = activity, user)
1667        when type in ["Like", "Announce"] do
1668     {:ok, undo, _} = Builder.undo(user, activity)
1669     Pipeline.common_pipeline(undo, local: user.local)
1670   end
1671
1672   defp delete_activity(_activity, _user), do: "Doing nothing"
1673
1674   defp delete_outgoing_pending_follow_requests(user) do
1675     user
1676     |> FollowingRelationship.outgoing_pending_follow_requests_query()
1677     |> Repo.delete_all()
1678   end
1679
1680   def html_filter_policy(%User{no_rich_text: true}) do
1681     Pleroma.HTML.Scrubber.TwitterText
1682   end
1683
1684   def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])
1685
1686   def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1687
1688   def get_or_fetch_by_ap_id(ap_id) do
1689     cached_user = get_cached_by_ap_id(ap_id)
1690
1691     maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)
1692
1693     case {cached_user, maybe_fetched_user} do
1694       {_, {:ok, %User{} = user}} ->
1695         {:ok, user}
1696
1697       {%User{} = user, _} ->
1698         {:ok, user}
1699
1700       _ ->
1701         {:error, :not_found}
1702     end
1703   end
1704
1705   @doc """
1706   Creates an internal service actor by URI if missing.
1707   Optionally takes nickname for addressing.
1708   """
1709   @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1710   def get_or_create_service_actor_by_ap_id(uri, nickname) do
1711     {_, user} =
1712       case get_cached_by_ap_id(uri) do
1713         nil ->
1714           with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1715             Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1716             {:error, nil}
1717           end
1718
1719         %User{invisible: false} = user ->
1720           set_invisible(user)
1721
1722         user ->
1723           {:ok, user}
1724       end
1725
1726     user
1727   end
1728
1729   @spec set_invisible(User.t()) :: {:ok, User.t()}
1730   defp set_invisible(user) do
1731     user
1732     |> change(%{invisible: true})
1733     |> update_and_set_cache()
1734   end
1735
1736   @spec create_service_actor(String.t(), String.t()) ::
1737           {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1738   defp create_service_actor(uri, nickname) do
1739     %User{
1740       invisible: true,
1741       local: true,
1742       ap_id: uri,
1743       nickname: nickname,
1744       follower_address: uri <> "/followers"
1745     }
1746     |> change
1747     |> unique_constraint(:nickname)
1748     |> Repo.insert()
1749     |> set_cache()
1750   end
1751
1752   def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1753     key =
1754       public_key_pem
1755       |> :public_key.pem_decode()
1756       |> hd()
1757       |> :public_key.pem_entry_decode()
1758
1759     {:ok, key}
1760   end
1761
1762   def public_key(_), do: {:error, "key not found"}
1763
1764   def get_public_key_for_ap_id(ap_id) do
1765     with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1766          {:ok, public_key} <- public_key(user) do
1767       {:ok, public_key}
1768     else
1769       _ -> :error
1770     end
1771   end
1772
1773   def ap_enabled?(%User{local: true}), do: true
1774   def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1775   def ap_enabled?(_), do: false
1776
1777   @doc "Gets or fetch a user by uri or nickname."
1778   @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1779   def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1780   def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1781
1782   # wait a period of time and return newest version of the User structs
1783   # this is because we have synchronous follow APIs and need to simulate them
1784   # with an async handshake
1785   def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1786     with %User{} = a <- get_cached_by_id(a.id),
1787          %User{} = b <- get_cached_by_id(b.id) do
1788       {:ok, a, b}
1789     else
1790       nil -> :error
1791     end
1792   end
1793
1794   def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1795     with :ok <- :timer.sleep(timeout),
1796          %User{} = a <- get_cached_by_id(a.id),
1797          %User{} = b <- get_cached_by_id(b.id) do
1798       {:ok, a, b}
1799     else
1800       nil -> :error
1801     end
1802   end
1803
1804   def parse_bio(bio) when is_binary(bio) and bio != "" do
1805     bio
1806     |> CommonUtils.format_input("text/plain", mentions_format: :full)
1807     |> elem(0)
1808   end
1809
1810   def parse_bio(_), do: ""
1811
1812   def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1813     # TODO: get profile URLs other than user.ap_id
1814     profile_urls = [user.ap_id]
1815
1816     bio
1817     |> CommonUtils.format_input("text/plain",
1818       mentions_format: :full,
1819       rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1820     )
1821     |> elem(0)
1822   end
1823
1824   def parse_bio(_, _), do: ""
1825
1826   def tag(user_identifiers, tags) when is_list(user_identifiers) do
1827     Repo.transaction(fn ->
1828       for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1829     end)
1830   end
1831
1832   def tag(nickname, tags) when is_binary(nickname),
1833     do: tag(get_by_nickname(nickname), tags)
1834
1835   def tag(%User{} = user, tags),
1836     do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1837
1838   def untag(user_identifiers, tags) when is_list(user_identifiers) do
1839     Repo.transaction(fn ->
1840       for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1841     end)
1842   end
1843
1844   def untag(nickname, tags) when is_binary(nickname),
1845     do: untag(get_by_nickname(nickname), tags)
1846
1847   def untag(%User{} = user, tags),
1848     do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1849
1850   defp update_tags(%User{} = user, new_tags) do
1851     {:ok, updated_user} =
1852       user
1853       |> change(%{tags: new_tags})
1854       |> update_and_set_cache()
1855
1856     updated_user
1857   end
1858
1859   defp normalize_tags(tags) do
1860     [tags]
1861     |> List.flatten()
1862     |> Enum.map(&String.downcase/1)
1863   end
1864
1865   defp local_nickname_regex do
1866     if Config.get([:instance, :extended_nickname_format]) do
1867       @extended_local_nickname_regex
1868     else
1869       @strict_local_nickname_regex
1870     end
1871   end
1872
1873   def local_nickname(nickname_or_mention) do
1874     nickname_or_mention
1875     |> full_nickname()
1876     |> String.split("@")
1877     |> hd()
1878   end
1879
1880   def full_nickname(nickname_or_mention),
1881     do: String.trim_leading(nickname_or_mention, "@")
1882
1883   def error_user(ap_id) do
1884     %User{
1885       name: ap_id,
1886       ap_id: ap_id,
1887       nickname: "erroruser@example.com",
1888       inserted_at: NaiveDateTime.utc_now()
1889     }
1890   end
1891
1892   @spec all_superusers() :: [User.t()]
1893   def all_superusers do
1894     User.Query.build(%{super_users: true, local: true, deactivated: false})
1895     |> Repo.all()
1896   end
1897
1898   def muting_reblogs?(%User{} = user, %User{} = target) do
1899     UserRelationship.reblog_mute_exists?(user, target)
1900   end
1901
1902   def showing_reblogs?(%User{} = user, %User{} = target) do
1903     not muting_reblogs?(user, target)
1904   end
1905
1906   @doc """
1907   The function returns a query to get users with no activity for given interval of days.
1908   Inactive users are those who didn't read any notification, or had any activity where
1909   the user is the activity's actor, during `inactivity_threshold` days.
1910   Deactivated users will not appear in this list.
1911
1912   ## Examples
1913
1914       iex> Pleroma.User.list_inactive_users()
1915       %Ecto.Query{}
1916   """
1917   @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
1918   def list_inactive_users_query(inactivity_threshold \\ 7) do
1919     negative_inactivity_threshold = -inactivity_threshold
1920     now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
1921     # Subqueries are not supported in `where` clauses, join gets too complicated.
1922     has_read_notifications =
1923       from(n in Pleroma.Notification,
1924         where: n.seen == true,
1925         group_by: n.id,
1926         having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
1927         select: n.user_id
1928       )
1929       |> Pleroma.Repo.all()
1930
1931     from(u in Pleroma.User,
1932       left_join: a in Pleroma.Activity,
1933       on: u.ap_id == a.actor,
1934       where: not is_nil(u.nickname),
1935       where: u.deactivated != ^true,
1936       where: u.id not in ^has_read_notifications,
1937       group_by: u.id,
1938       having:
1939         max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
1940           is_nil(max(a.inserted_at))
1941     )
1942   end
1943
1944   @doc """
1945   Enable or disable email notifications for user
1946
1947   ## Examples
1948
1949       iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
1950       Pleroma.User{email_notifications: %{"digest" => true}}
1951
1952       iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
1953       Pleroma.User{email_notifications: %{"digest" => false}}
1954   """
1955   @spec switch_email_notifications(t(), String.t(), boolean()) ::
1956           {:ok, t()} | {:error, Ecto.Changeset.t()}
1957   def switch_email_notifications(user, type, status) do
1958     User.update_email_notifications(user, %{type => status})
1959   end
1960
1961   @doc """
1962   Set `last_digest_emailed_at` value for the user to current time
1963   """
1964   @spec touch_last_digest_emailed_at(t()) :: t()
1965   def touch_last_digest_emailed_at(user) do
1966     now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
1967
1968     {:ok, updated_user} =
1969       user
1970       |> change(%{last_digest_emailed_at: now})
1971       |> update_and_set_cache()
1972
1973     updated_user
1974   end
1975
1976   @spec toggle_confirmation(User.t()) :: {:ok, User.t()} | {:error, Changeset.t()}
1977   def toggle_confirmation(%User{} = user) do
1978     user
1979     |> confirmation_changeset(need_confirmation: !user.confirmation_pending)
1980     |> update_and_set_cache()
1981   end
1982
1983   @spec toggle_confirmation([User.t()]) :: [{:ok, User.t()} | {:error, Changeset.t()}]
1984   def toggle_confirmation(users) do
1985     Enum.map(users, &toggle_confirmation/1)
1986   end
1987
1988   def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
1989     mascot
1990   end
1991
1992   def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
1993     # use instance-default
1994     config = Config.get([:assets, :mascots])
1995     default_mascot = Config.get([:assets, :default_mascot])
1996     mascot = Keyword.get(config, default_mascot)
1997
1998     %{
1999       "id" => "default-mascot",
2000       "url" => mascot[:url],
2001       "preview_url" => mascot[:url],
2002       "pleroma" => %{
2003         "mime_type" => mascot[:mime_type]
2004       }
2005     }
2006   end
2007
2008   def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
2009
2010   def ensure_keys_present(%User{} = user) do
2011     with {:ok, pem} <- Keys.generate_rsa_pem() do
2012       user
2013       |> cast(%{keys: pem}, [:keys])
2014       |> validate_required([:keys])
2015       |> update_and_set_cache()
2016     end
2017   end
2018
2019   def get_ap_ids_by_nicknames(nicknames) do
2020     from(u in User,
2021       where: u.nickname in ^nicknames,
2022       select: u.ap_id
2023     )
2024     |> Repo.all()
2025   end
2026
2027   defdelegate search(query, opts \\ []), to: User.Search
2028
2029   defp put_password_hash(
2030          %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2031        ) do
2032     change(changeset, password_hash: Pbkdf2.hash_pwd_salt(password))
2033   end
2034
2035   defp put_password_hash(changeset), do: changeset
2036
2037   def is_internal_user?(%User{nickname: nil}), do: true
2038   def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2039   def is_internal_user?(_), do: false
2040
2041   # A hack because user delete activities have a fake id for whatever reason
2042   # TODO: Get rid of this
2043   def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2044
2045   def get_delivered_users_by_object_id(object_id) do
2046     from(u in User,
2047       inner_join: delivery in assoc(u, :deliveries),
2048       where: delivery.object_id == ^object_id
2049     )
2050     |> Repo.all()
2051   end
2052
2053   def change_email(user, email) do
2054     user
2055     |> cast(%{email: email}, [:email])
2056     |> validate_required([:email])
2057     |> unique_constraint(:email)
2058     |> validate_format(:email, @email_regex)
2059     |> update_and_set_cache()
2060   end
2061
2062   # Internal function; public one is `deactivate/2`
2063   defp set_activation_status(user, deactivated) do
2064     user
2065     |> cast(%{deactivated: deactivated}, [:deactivated])
2066     |> update_and_set_cache()
2067   end
2068
2069   def update_banner(user, banner) do
2070     user
2071     |> cast(%{banner: banner}, [:banner])
2072     |> update_and_set_cache()
2073   end
2074
2075   def update_background(user, background) do
2076     user
2077     |> cast(%{background: background}, [:background])
2078     |> update_and_set_cache()
2079   end
2080
2081   def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
2082     %{
2083       admin: is_admin,
2084       moderator: is_moderator
2085     }
2086   end
2087
2088   def validate_fields(changeset, remote? \\ false) do
2089     limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2090     limit = Config.get([:instance, limit_name], 0)
2091
2092     changeset
2093     |> validate_length(:fields, max: limit)
2094     |> validate_change(:fields, fn :fields, fields ->
2095       if Enum.all?(fields, &valid_field?/1) do
2096         []
2097       else
2098         [fields: "invalid"]
2099       end
2100     end)
2101   end
2102
2103   defp valid_field?(%{"name" => name, "value" => value}) do
2104     name_limit = Config.get([:instance, :account_field_name_length], 255)
2105     value_limit = Config.get([:instance, :account_field_value_length], 255)
2106
2107     is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2108       String.length(value) <= value_limit
2109   end
2110
2111   defp valid_field?(_), do: false
2112
2113   defp truncate_field(%{"name" => name, "value" => value}) do
2114     {name, _chopped} =
2115       String.split_at(name, Config.get([:instance, :account_field_name_length], 255))
2116
2117     {value, _chopped} =
2118       String.split_at(value, Config.get([:instance, :account_field_value_length], 255))
2119
2120     %{"name" => name, "value" => value}
2121   end
2122
2123   def admin_api_update(user, params) do
2124     user
2125     |> cast(params, [
2126       :is_moderator,
2127       :is_admin,
2128       :show_role
2129     ])
2130     |> update_and_set_cache()
2131   end
2132
2133   @doc "Signs user out of all applications"
2134   def global_sign_out(user) do
2135     OAuth.Authorization.delete_user_authorizations(user)
2136     OAuth.Token.delete_user_tokens(user)
2137   end
2138
2139   def mascot_update(user, url) do
2140     user
2141     |> cast(%{mascot: url}, [:mascot])
2142     |> validate_required([:mascot])
2143     |> update_and_set_cache()
2144   end
2145
2146   def mastodon_settings_update(user, settings) do
2147     user
2148     |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
2149     |> validate_required([:mastofe_settings])
2150     |> update_and_set_cache()
2151   end
2152
2153   @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2154   def confirmation_changeset(user, need_confirmation: need_confirmation?) do
2155     params =
2156       if need_confirmation? do
2157         %{
2158           confirmation_pending: true,
2159           confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2160         }
2161       else
2162         %{
2163           confirmation_pending: false,
2164           confirmation_token: nil
2165         }
2166       end
2167
2168     cast(user, params, [:confirmation_pending, :confirmation_token])
2169   end
2170
2171   @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
2172   def approval_changeset(user, need_approval: need_approval?) do
2173     params = if need_approval?, do: %{approval_pending: true}, else: %{approval_pending: false}
2174     cast(user, params, [:approval_pending])
2175   end
2176
2177   def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2178     if id not in user.pinned_activities do
2179       max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2180       params = %{pinned_activities: user.pinned_activities ++ [id]}
2181
2182       user
2183       |> cast(params, [:pinned_activities])
2184       |> validate_length(:pinned_activities,
2185         max: max_pinned_statuses,
2186         message: "You have already pinned the maximum number of statuses"
2187       )
2188     else
2189       change(user)
2190     end
2191     |> update_and_set_cache()
2192   end
2193
2194   def remove_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2195     params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2196
2197     user
2198     |> cast(params, [:pinned_activities])
2199     |> update_and_set_cache()
2200   end
2201
2202   def update_email_notifications(user, settings) do
2203     email_notifications =
2204       user.email_notifications
2205       |> Map.merge(settings)
2206       |> Map.take(["digest"])
2207
2208     params = %{email_notifications: email_notifications}
2209     fields = [:email_notifications]
2210
2211     user
2212     |> cast(params, fields)
2213     |> validate_required(fields)
2214     |> update_and_set_cache()
2215   end
2216
2217   defp set_domain_blocks(user, domain_blocks) do
2218     params = %{domain_blocks: domain_blocks}
2219
2220     user
2221     |> cast(params, [:domain_blocks])
2222     |> validate_required([:domain_blocks])
2223     |> update_and_set_cache()
2224   end
2225
2226   def block_domain(user, domain_blocked) do
2227     set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2228   end
2229
2230   def unblock_domain(user, domain_blocked) do
2231     set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2232   end
2233
2234   @spec add_to_block(User.t(), User.t()) ::
2235           {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2236   defp add_to_block(%User{} = user, %User{} = blocked) do
2237     UserRelationship.create_block(user, blocked)
2238   end
2239
2240   @spec add_to_block(User.t(), User.t()) ::
2241           {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2242   defp remove_from_block(%User{} = user, %User{} = blocked) do
2243     UserRelationship.delete_block(user, blocked)
2244   end
2245
2246   defp add_to_mutes(%User{} = user, %User{} = muted_user, notifications?) do
2247     with {:ok, user_mute} <- UserRelationship.create_mute(user, muted_user),
2248          {:ok, user_notification_mute} <-
2249            (notifications? && UserRelationship.create_notification_mute(user, muted_user)) ||
2250              {:ok, nil} do
2251       {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
2252     end
2253   end
2254
2255   defp remove_from_mutes(user, %User{} = muted_user) do
2256     with {:ok, user_mute} <- UserRelationship.delete_mute(user, muted_user),
2257          {:ok, user_notification_mute} <-
2258            UserRelationship.delete_notification_mute(user, muted_user) do
2259       {:ok, [user_mute, user_notification_mute]}
2260     end
2261   end
2262
2263   def set_invisible(user, invisible) do
2264     params = %{invisible: invisible}
2265
2266     user
2267     |> cast(params, [:invisible])
2268     |> validate_required([:invisible])
2269     |> update_and_set_cache()
2270   end
2271
2272   def sanitize_html(%User{} = user) do
2273     sanitize_html(user, nil)
2274   end
2275
2276   # User data that mastodon isn't filtering (treated as plaintext):
2277   # - field name
2278   # - display name
2279   def sanitize_html(%User{} = user, filter) do
2280     fields =
2281       Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2282         %{
2283           "name" => name,
2284           "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2285         }
2286       end)
2287
2288     user
2289     |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2290     |> Map.put(:fields, fields)
2291   end
2292 end