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