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   def try_send_confirmation_email(%User{} = user) do
 723     if user.confirmation_pending &&
 724          Config.get([:instance, :account_activation_required]) do
 725       user
 726       |> Pleroma.Emails.UserEmail.account_confirmation_email()
 727       |> Pleroma.Emails.Mailer.deliver_async()
 728
 729       {:ok, :enqueued}
 730     else
 731       {:ok, :noop}
 732     end
 733   end
 734
 735   def try_send_confirmation_email(users) do
 736     Enum.each(users, &try_send_confirmation_email/1)
 737   end
 738
 739   def needs_update?(%User{local: true}), do: false
 740
 741   def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
 742
 743   def needs_update?(%User{local: false} = user) do
 744     NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
 745   end
 746
 747   def needs_update?(_), do: true
 748
 749   @spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()}
 750
 751   # "Locked" (self-locked) users demand explicit authorization of follow requests
 752   def maybe_direct_follow(%User{} = follower, %User{local: true, locked: true} = followed) do
 753     follow(follower, followed, :follow_pending)
 754   end
 755
 756   def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
 757     follow(follower, followed)
 758   end
 759
 760   def maybe_direct_follow(%User{} = follower, %User{} = followed) do
 761     if not ap_enabled?(followed) do
 762       follow(follower, followed)
 763     else
 764       {:ok, follower}
 765     end
 766   end
 767
 768   @doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
 769   @spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
 770   def follow_all(follower, followeds) do
 771     followeds
 772     |> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end)
 773     |> Enum.each(&follow(follower, &1, :follow_accept))
 774
 775     set_cache(follower)
 776   end
 777
 778   defdelegate following(user), to: FollowingRelationship
 779
 780   def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
 781     deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
 782
 783     cond do
 784       followed.deactivated ->
 785         {:error, "Could not follow user: #{followed.nickname} is deactivated."}
 786
 787       deny_follow_blocked and blocks?(followed, follower) ->
 788         {:error, "Could not follow user: #{followed.nickname} blocked you."}
 789
 790       true ->
 791         FollowingRelationship.follow(follower, followed, state)
 792
 793         {:ok, _} = update_follower_count(followed)
 794
 795         follower
 796         |> update_following_count()
 797     end
 798   end
 799
 800   def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
 801     {:error, "Not subscribed!"}
 802   end
 803
 804   @spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} | {:error, String.t()}
 805   def unfollow(%User{} = follower, %User{} = followed) do
 806     case do_unfollow(follower, followed) do
 807       {:ok, follower, followed} ->
 808         {:ok, follower, Utils.fetch_latest_follow(follower, followed)}
 809
 810       error ->
 811         error
 812     end
 813   end
 814
 815   @spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} | {:error, String.t()}
 816   defp do_unfollow(%User{} = follower, %User{} = followed) do
 817     case get_follow_state(follower, followed) do
 818       state when state in [:follow_pending, :follow_accept] ->
 819         FollowingRelationship.unfollow(follower, followed)
 820         {:ok, followed} = update_follower_count(followed)
 821
 822         {:ok, follower} =
 823           follower
 824           |> update_following_count()
 825
 826         {:ok, follower, followed}
 827
 828       nil ->
 829         {:error, "Not subscribed!"}
 830     end
 831   end
 832
 833   defdelegate following?(follower, followed), to: FollowingRelationship
 834
 835   @doc "Returns follow state as Pleroma.FollowingRelationship.State value"
 836   def get_follow_state(%User{} = follower, %User{} = following) do
 837     following_relationship = FollowingRelationship.get(follower, following)
 838     get_follow_state(follower, following, following_relationship)
 839   end
 840
 841   def get_follow_state(
 842         %User{} = follower,
 843         %User{} = following,
 844         following_relationship
 845       ) do
 846     case {following_relationship, following.local} do
 847       {nil, false} ->
 848         case Utils.fetch_latest_follow(follower, following) do
 849           %Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
 850             FollowingRelationship.state_to_enum(state)
 851
 852           _ ->
 853             nil
 854         end
 855
 856       {%{state: state}, _} ->
 857         state
 858
 859       {nil, _} ->
 860         nil
 861     end
 862   end
 863
 864   def locked?(%User{} = user) do
 865     user.locked || false
 866   end
 867
 868   def get_by_id(id) do
 869     Repo.get_by(User, id: id)
 870   end
 871
 872   def get_by_ap_id(ap_id) do
 873     Repo.get_by(User, ap_id: ap_id)
 874   end
 875
 876   def get_all_by_ap_id(ap_ids) do
 877     from(u in __MODULE__,
 878       where: u.ap_id in ^ap_ids
 879     )
 880     |> Repo.all()
 881   end
 882
 883   def get_all_by_ids(ids) do
 884     from(u in __MODULE__, where: u.id in ^ids)
 885     |> Repo.all()
 886   end
 887
 888   # This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
 889   # of the ap_id and the domain and tries to get that user
 890   def get_by_guessed_nickname(ap_id) do
 891     domain = URI.parse(ap_id).host
 892     name = List.last(String.split(ap_id, "/"))
 893     nickname = "#{name}@#{domain}"
 894
 895     get_cached_by_nickname(nickname)
 896   end
 897
 898   def set_cache({:ok, user}), do: set_cache(user)
 899   def set_cache({:error, err}), do: {:error, err}
 900
 901   def set_cache(%User{} = user) do
 902     Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
 903     Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
 904     Cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
 905     {:ok, user}
 906   end
 907
 908   def update_and_set_cache(struct, params) do
 909     struct
 910     |> update_changeset(params)
 911     |> update_and_set_cache()
 912   end
 913
 914   def update_and_set_cache(changeset) do
 915     with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
 916       set_cache(user)
 917     end
 918   end
 919
 920   def get_user_friends_ap_ids(user) do
 921     from(u in User.get_friends_query(user), select: u.ap_id)
 922     |> Repo.all()
 923   end
 924
 925   @spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
 926   def get_cached_user_friends_ap_ids(user) do
 927     Cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
 928       get_user_friends_ap_ids(user)
 929     end)
 930   end
 931
 932   def invalidate_cache(user) do
 933     Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
 934     Cachex.del(:user_cache, "nickname:#{user.nickname}")
 935     Cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
 936   end
 937
 938   @spec get_cached_by_ap_id(String.t()) :: User.t() | nil
 939   def get_cached_by_ap_id(ap_id) do
 940     key = "ap_id:#{ap_id}"
 941
 942     with {:ok, nil} <- Cachex.get(:user_cache, key),
 943          user when not is_nil(user) <- get_by_ap_id(ap_id),
 944          {:ok, true} <- Cachex.put(:user_cache, key, user) do
 945       user
 946     else
 947       {:ok, user} -> user
 948       nil -> nil
 949     end
 950   end
 951
 952   def get_cached_by_id(id) do
 953     key = "id:#{id}"
 954
 955     ap_id =
 956       Cachex.fetch!(:user_cache, key, fn _ ->
 957         user = get_by_id(id)
 958
 959         if user do
 960           Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
 961           {:commit, user.ap_id}
 962         else
 963           {:ignore, ""}
 964         end
 965       end)
 966
 967     get_cached_by_ap_id(ap_id)
 968   end
 969
 970   def get_cached_by_nickname(nickname) do
 971     key = "nickname:#{nickname}"
 972
 973     Cachex.fetch!(:user_cache, key, fn ->
 974       case get_or_fetch_by_nickname(nickname) do
 975         {:ok, user} -> {:commit, user}
 976         {:error, _error} -> {:ignore, nil}
 977       end
 978     end)
 979   end
 980
 981   def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
 982     restrict_to_local = Config.get([:instance, :limit_to_local_content])
 983
 984     cond do
 985       is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
 986         get_cached_by_id(nickname_or_id) || get_cached_by_nickname(nickname_or_id)
 987
 988       restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
 989         get_cached_by_nickname(nickname_or_id)
 990
 991       restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
 992         get_cached_by_nickname(nickname_or_id)
 993
 994       true ->
 995         nil
 996     end
 997   end
 998
 999   @spec get_by_nickname(String.t()) :: User.t() | nil
1000   def get_by_nickname(nickname) do
1001     Repo.get_by(User, nickname: nickname) ||
1002       if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
1003         Repo.get_by(User, nickname: local_nickname(nickname))
1004       end
1005   end
1006
1007   def get_by_email(email), do: Repo.get_by(User, email: email)
1008
1009   def get_by_nickname_or_email(nickname_or_email) do
1010     get_by_nickname(nickname_or_email) || get_by_email(nickname_or_email)
1011   end
1012
1013   def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)
1014
1015   def get_or_fetch_by_nickname(nickname) do
1016     with %User{} = user <- get_by_nickname(nickname) do
1017       {:ok, user}
1018     else
1019       _e ->
1020         with [_nick, _domain] <- String.split(nickname, "@"),
1021              {:ok, user} <- fetch_by_nickname(nickname) do
1022           {:ok, user}
1023         else
1024           _e -> {:error, "not found " <> nickname}
1025         end
1026     end
1027   end
1028
1029   @spec get_followers_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1030   def get_followers_query(%User{} = user, nil) do
1031     User.Query.build(%{followers: user, deactivated: false})
1032   end
1033
1034   def get_followers_query(user, page) do
1035     user
1036     |> get_followers_query(nil)
1037     |> User.Query.paginate(page, 20)
1038   end
1039
1040   @spec get_followers_query(User.t()) :: Ecto.Query.t()
1041   def get_followers_query(user), do: get_followers_query(user, nil)
1042
1043   @spec get_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1044   def get_followers(user, page \\ nil) do
1045     user
1046     |> get_followers_query(page)
1047     |> Repo.all()
1048   end
1049
1050   @spec get_external_followers(User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
1051   def get_external_followers(user, page \\ nil) do
1052     user
1053     |> get_followers_query(page)
1054     |> User.Query.build(%{external: true})
1055     |> Repo.all()
1056   end
1057
1058   def get_followers_ids(user, page \\ nil) do
1059     user
1060     |> get_followers_query(page)
1061     |> select([u], u.id)
1062     |> Repo.all()
1063   end
1064
1065   @spec get_friends_query(User.t(), pos_integer() | nil) :: Ecto.Query.t()
1066   def get_friends_query(%User{} = user, nil) do
1067     User.Query.build(%{friends: user, deactivated: false})
1068   end
1069
1070   def get_friends_query(user, page) do
1071     user
1072     |> get_friends_query(nil)
1073     |> User.Query.paginate(page, 20)
1074   end
1075
1076   @spec get_friends_query(User.t()) :: Ecto.Query.t()
1077   def get_friends_query(user), do: get_friends_query(user, nil)
1078
1079   def get_friends(user, page \\ nil) do
1080     user
1081     |> get_friends_query(page)
1082     |> Repo.all()
1083   end
1084
1085   def get_friends_ap_ids(user) do
1086     user
1087     |> get_friends_query(nil)
1088     |> select([u], u.ap_id)
1089     |> Repo.all()
1090   end
1091
1092   def get_friends_ids(user, page \\ nil) do
1093     user
1094     |> get_friends_query(page)
1095     |> select([u], u.id)
1096     |> Repo.all()
1097   end
1098
1099   defdelegate get_follow_requests(user), to: FollowingRelationship
1100
1101   def increase_note_count(%User{} = user) do
1102     User
1103     |> where(id: ^user.id)
1104     |> update([u], inc: [note_count: 1])
1105     |> select([u], u)
1106     |> Repo.update_all([])
1107     |> case do
1108       {1, [user]} -> set_cache(user)
1109       _ -> {:error, user}
1110     end
1111   end
1112
1113   def decrease_note_count(%User{} = user) do
1114     User
1115     |> where(id: ^user.id)
1116     |> update([u],
1117       set: [
1118         note_count: fragment("greatest(0, note_count - 1)")
1119       ]
1120     )
1121     |> select([u], u)
1122     |> Repo.update_all([])
1123     |> case do
1124       {1, [user]} -> set_cache(user)
1125       _ -> {:error, user}
1126     end
1127   end
1128
1129   def update_note_count(%User{} = user, note_count \\ nil) do
1130     note_count =
1131       note_count ||
1132         from(
1133           a in Object,
1134           where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
1135           select: count(a.id)
1136         )
1137         |> Repo.one()
1138
1139     user
1140     |> cast(%{note_count: note_count}, [:note_count])
1141     |> update_and_set_cache()
1142   end
1143
1144   @spec maybe_fetch_follow_information(User.t()) :: User.t()
1145   def maybe_fetch_follow_information(user) do
1146     with {:ok, user} <- fetch_follow_information(user) do
1147       user
1148     else
1149       e ->
1150         Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")
1151
1152         user
1153     end
1154   end
1155
1156   def fetch_follow_information(user) do
1157     with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
1158       user
1159       |> follow_information_changeset(info)
1160       |> update_and_set_cache()
1161     end
1162   end
1163
1164   defp follow_information_changeset(user, params) do
1165     user
1166     |> cast(params, [
1167       :hide_followers,
1168       :hide_follows,
1169       :follower_count,
1170       :following_count,
1171       :hide_followers_count,
1172       :hide_follows_count
1173     ])
1174   end
1175
1176   @spec update_follower_count(User.t()) :: {:ok, User.t()}
1177   def update_follower_count(%User{} = user) do
1178     if user.local or !Config.get([:instance, :external_user_synchronization]) do
1179       follower_count = FollowingRelationship.follower_count(user)
1180
1181       user
1182       |> follow_information_changeset(%{follower_count: follower_count})
1183       |> update_and_set_cache
1184     else
1185       {:ok, maybe_fetch_follow_information(user)}
1186     end
1187   end
1188
1189   @spec update_following_count(User.t()) :: {:ok, User.t()}
1190   def update_following_count(%User{local: false} = user) do
1191     if Config.get([:instance, :external_user_synchronization]) do
1192       {:ok, maybe_fetch_follow_information(user)}
1193     else
1194       {:ok, user}
1195     end
1196   end
1197
1198   def update_following_count(%User{local: true} = user) do
1199     following_count = FollowingRelationship.following_count(user)
1200
1201     user
1202     |> follow_information_changeset(%{following_count: following_count})
1203     |> update_and_set_cache()
1204   end
1205
1206   def set_unread_conversation_count(%User{local: true} = user) do
1207     unread_query = Participation.unread_conversation_count_for_user(user)
1208
1209     User
1210     |> join(:inner, [u], p in subquery(unread_query))
1211     |> update([u, p],
1212       set: [unread_conversation_count: p.count]
1213     )
1214     |> where([u], u.id == ^user.id)
1215     |> select([u], u)
1216     |> Repo.update_all([])
1217     |> case do
1218       {1, [user]} -> set_cache(user)
1219       _ -> {:error, user}
1220     end
1221   end
1222
1223   def set_unread_conversation_count(user), do: {:ok, user}
1224
1225   def increment_unread_conversation_count(conversation, %User{local: true} = user) do
1226     unread_query =
1227       Participation.unread_conversation_count_for_user(user)
1228       |> where([p], p.conversation_id == ^conversation.id)
1229
1230     User
1231     |> join(:inner, [u], p in subquery(unread_query))
1232     |> update([u, p],
1233       inc: [unread_conversation_count: 1]
1234     )
1235     |> where([u], u.id == ^user.id)
1236     |> where([u, p], p.count == 0)
1237     |> select([u], u)
1238     |> Repo.update_all([])
1239     |> case do
1240       {1, [user]} -> set_cache(user)
1241       _ -> {:error, user}
1242     end
1243   end
1244
1245   def increment_unread_conversation_count(_, user), do: {:ok, user}
1246
1247   @spec get_users_from_set([String.t()], keyword()) :: [User.t()]
1248   def get_users_from_set(ap_ids, opts \\ []) do
1249     local_only = Keyword.get(opts, :local_only, true)
1250     criteria = %{ap_id: ap_ids, deactivated: false}
1251     criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria
1252
1253     User.Query.build(criteria)
1254     |> Repo.all()
1255   end
1256
1257   @spec get_recipients_from_activity(Activity.t()) :: [User.t()]
1258   def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
1259     to = [actor | to]
1260
1261     query = User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
1262
1263     query
1264     |> Repo.all()
1265   end
1266
1267   @spec mute(User.t(), User.t(), boolean()) ::
1268           {:ok, list(UserRelationship.t())} | {:error, String.t()}
1269   def mute(%User{} = muter, %User{} = mutee, notifications? \\ true) do
1270     add_to_mutes(muter, mutee, notifications?)
1271   end
1272
1273   def unmute(%User{} = muter, %User{} = mutee) do
1274     remove_from_mutes(muter, mutee)
1275   end
1276
1277   def subscribe(%User{} = subscriber, %User{} = target) do
1278     deny_follow_blocked = Config.get([:user, :deny_follow_blocked])
1279
1280     if blocks?(target, subscriber) and deny_follow_blocked do
1281       {:error, "Could not subscribe: #{target.nickname} is blocking you"}
1282     else
1283       # Note: the relationship is inverse: subscriber acts as relationship target
1284       UserRelationship.create_inverse_subscription(target, subscriber)
1285     end
1286   end
1287
1288   def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
1289     with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
1290       subscribe(subscriber, subscribee)
1291     end
1292   end
1293
1294   def unsubscribe(%User{} = unsubscriber, %User{} = target) do
1295     # Note: the relationship is inverse: subscriber acts as relationship target
1296     UserRelationship.delete_inverse_subscription(target, unsubscriber)
1297   end
1298
1299   def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
1300     with %User{} = user <- get_cached_by_ap_id(ap_id) do
1301       unsubscribe(unsubscriber, user)
1302     end
1303   end
1304
1305   def block(%User{} = blocker, %User{} = blocked) do
1306     # sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
1307     blocker =
1308       if following?(blocker, blocked) do
1309         {:ok, blocker, _} = unfollow(blocker, blocked)
1310         blocker
1311       else
1312         blocker
1313       end
1314
1315     # clear any requested follows as well
1316     blocked =
1317       case CommonAPI.reject_follow_request(blocked, blocker) do
1318         {:ok, %User{} = updated_blocked} -> updated_blocked
1319         nil -> blocked
1320       end
1321
1322     unsubscribe(blocked, blocker)
1323
1324     unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
1325     if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)
1326
1327     {:ok, blocker} = update_follower_count(blocker)
1328     {:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
1329     add_to_block(blocker, blocked)
1330   end
1331
1332   # helper to handle the block given only an actor's AP id
1333   def block(%User{} = blocker, %{ap_id: ap_id}) do
1334     block(blocker, get_cached_by_ap_id(ap_id))
1335   end
1336
1337   def unblock(%User{} = blocker, %User{} = blocked) do
1338     remove_from_block(blocker, blocked)
1339   end
1340
1341   # helper to handle the block given only an actor's AP id
1342   def unblock(%User{} = blocker, %{ap_id: ap_id}) do
1343     unblock(blocker, get_cached_by_ap_id(ap_id))
1344   end
1345
1346   def mutes?(nil, _), do: false
1347   def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)
1348
1349   def mutes_user?(%User{} = user, %User{} = target) do
1350     UserRelationship.mute_exists?(user, target)
1351   end
1352
1353   @spec muted_notifications?(User.t() | nil, User.t() | map()) :: boolean()
1354   def muted_notifications?(nil, _), do: false
1355
1356   def muted_notifications?(%User{} = user, %User{} = target),
1357     do: UserRelationship.notification_mute_exists?(user, target)
1358
1359   def blocks?(nil, _), do: false
1360
1361   def blocks?(%User{} = user, %User{} = target) do
1362     blocks_user?(user, target) ||
1363       (blocks_domain?(user, target) and not User.following?(user, target))
1364   end
1365
1366   def blocks_user?(%User{} = user, %User{} = target) do
1367     UserRelationship.block_exists?(user, target)
1368   end
1369
1370   def blocks_user?(_, _), do: false
1371
1372   def blocks_domain?(%User{} = user, %User{} = target) do
1373     domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
1374     %{host: host} = URI.parse(target.ap_id)
1375     Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
1376   end
1377
1378   def blocks_domain?(_, _), do: false
1379
1380   def subscribed_to?(%User{} = user, %User{} = target) do
1381     # Note: the relationship is inverse: subscriber acts as relationship target
1382     UserRelationship.inverse_subscription_exists?(target, user)
1383   end
1384
1385   def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
1386     with %User{} = target <- get_cached_by_ap_id(ap_id) do
1387       subscribed_to?(user, target)
1388     end
1389   end
1390
1391   @doc """
1392   Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
1393   E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
1394   """
1395   @spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
1396   def outgoing_relationships_ap_ids(_user, []), do: %{}
1397
1398   def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}
1399
1400   def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
1401       when is_list(relationship_types) do
1402     db_result =
1403       user
1404       |> assoc(:outgoing_relationships)
1405       |> join(:inner, [user_rel], u in assoc(user_rel, :target))
1406       |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1407       |> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
1408       |> group_by([user_rel, u], user_rel.relationship_type)
1409       |> Repo.all()
1410       |> Enum.into(%{}, fn [k, v] -> {k, v} end)
1411
1412     Enum.into(
1413       relationship_types,
1414       %{},
1415       fn rel_type -> {rel_type, db_result[rel_type] || []} end
1416     )
1417   end
1418
1419   def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)
1420
1421   def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []
1422
1423   def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []
1424
1425   def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
1426       when is_list(relationship_types) do
1427     user
1428     |> assoc(:incoming_relationships)
1429     |> join(:inner, [user_rel], u in assoc(user_rel, :source))
1430     |> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
1431     |> maybe_filter_on_ap_id(ap_ids)
1432     |> select([user_rel, u], u.ap_id)
1433     |> distinct(true)
1434     |> Repo.all()
1435   end
1436
1437   defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
1438     where(query, [user_rel, u], u.ap_id in ^ap_ids)
1439   end
1440
1441   defp maybe_filter_on_ap_id(query, _ap_ids), do: query
1442
1443   def deactivate_async(user, status \\ true) do
1444     BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
1445   end
1446
1447   def deactivate(user, status \\ true)
1448
1449   def deactivate(users, status) when is_list(users) do
1450     Repo.transaction(fn ->
1451       for user <- users, do: deactivate(user, status)
1452     end)
1453   end
1454
1455   def deactivate(%User{} = user, status) do
1456     with {:ok, user} <- set_activation_status(user, status) do
1457       user
1458       |> get_followers()
1459       |> Enum.filter(& &1.local)
1460       |> Enum.each(&set_cache(update_following_count(&1)))
1461
1462       # Only update local user counts, remote will be update during the next pull.
1463       user
1464       |> get_friends()
1465       |> Enum.filter(& &1.local)
1466       |> Enum.each(&do_unfollow(user, &1))
1467
1468       {:ok, user}
1469     end
1470   end
1471
1472   def update_notification_settings(%User{} = user, settings) do
1473     user
1474     |> cast(%{notification_settings: settings}, [])
1475     |> cast_embed(:notification_settings)
1476     |> validate_required([:notification_settings])
1477     |> update_and_set_cache()
1478   end
1479
1480   def delete(users) when is_list(users) do
1481     for user <- users, do: delete(user)
1482   end
1483
1484   def delete(%User{} = user) do
1485     BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
1486   end
1487
1488   defp delete_and_invalidate_cache(%User{} = user) do
1489     invalidate_cache(user)
1490     Repo.delete(user)
1491   end
1492
1493   defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)
1494
1495   defp delete_or_deactivate(%User{local: true} = user) do
1496     status = account_status(user)
1497
1498     if status == :confirmation_pending do
1499       delete_and_invalidate_cache(user)
1500     else
1501       user
1502       |> change(%{deactivated: true, email: nil})
1503       |> update_and_set_cache()
1504     end
1505   end
1506
1507   def perform(:force_password_reset, user), do: force_password_reset(user)
1508
1509   @spec perform(atom(), User.t()) :: {:ok, User.t()}
1510   def perform(:delete, %User{} = user) do
1511     # Remove all relationships
1512     user
1513     |> get_followers()
1514     |> Enum.each(fn follower ->
1515       ActivityPub.unfollow(follower, user)
1516       unfollow(follower, user)
1517     end)
1518
1519     user
1520     |> get_friends()
1521     |> Enum.each(fn followed ->
1522       ActivityPub.unfollow(user, followed)
1523       unfollow(user, followed)
1524     end)
1525
1526     delete_user_activities(user)
1527     delete_notifications_from_user_activities(user)
1528
1529     delete_outgoing_pending_follow_requests(user)
1530
1531     delete_or_deactivate(user)
1532   end
1533
1534   def perform(:deactivate_async, user, status), do: deactivate(user, status)
1535
1536   @spec perform(atom(), User.t(), list()) :: list() | {:error, any()}
1537   def perform(:blocks_import, %User{} = blocker, blocked_identifiers)
1538       when is_list(blocked_identifiers) do
1539     Enum.map(
1540       blocked_identifiers,
1541       fn blocked_identifier ->
1542         with {:ok, %User{} = blocked} <- get_or_fetch(blocked_identifier),
1543              {:ok, _block} <- CommonAPI.block(blocker, blocked) do
1544           blocked
1545         else
1546           err ->
1547             Logger.debug("blocks_import failed for #{blocked_identifier} with: #{inspect(err)}")
1548             err
1549         end
1550       end
1551     )
1552   end
1553
1554   def perform(:follow_import, %User{} = follower, followed_identifiers)
1555       when is_list(followed_identifiers) do
1556     Enum.map(
1557       followed_identifiers,
1558       fn followed_identifier ->
1559         with {:ok, %User{} = followed} <- get_or_fetch(followed_identifier),
1560              {:ok, follower} <- maybe_direct_follow(follower, followed),
1561              {:ok, _, _, _} <- CommonAPI.follow(follower, followed) do
1562           followed
1563         else
1564           err ->
1565             Logger.debug("follow_import failed for #{followed_identifier} with: #{inspect(err)}")
1566             err
1567         end
1568       end
1569     )
1570   end
1571
1572   @spec external_users_query() :: Ecto.Query.t()
1573   def external_users_query do
1574     User.Query.build(%{
1575       external: true,
1576       active: true,
1577       order_by: :id
1578     })
1579   end
1580
1581   @spec external_users(keyword()) :: [User.t()]
1582   def external_users(opts \\ []) do
1583     query =
1584       external_users_query()
1585       |> select([u], struct(u, [:id, :ap_id]))
1586
1587     query =
1588       if opts[:max_id],
1589         do: where(query, [u], u.id > ^opts[:max_id]),
1590         else: query
1591
1592     query =
1593       if opts[:limit],
1594         do: limit(query, ^opts[:limit]),
1595         else: query
1596
1597     Repo.all(query)
1598   end
1599
1600   def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers) do
1601     BackgroundWorker.enqueue("blocks_import", %{
1602       "blocker_id" => blocker.id,
1603       "blocked_identifiers" => blocked_identifiers
1604     })
1605   end
1606
1607   def follow_import(%User{} = follower, followed_identifiers)
1608       when is_list(followed_identifiers) do
1609     BackgroundWorker.enqueue("follow_import", %{
1610       "follower_id" => follower.id,
1611       "followed_identifiers" => followed_identifiers
1612     })
1613   end
1614
1615   def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
1616     Notification
1617     |> join(:inner, [n], activity in assoc(n, :activity))
1618     |> where([n, a], fragment("? = ?", a.actor, ^ap_id))
1619     |> Repo.delete_all()
1620   end
1621
1622   def delete_user_activities(%User{ap_id: ap_id} = user) do
1623     ap_id
1624     |> Activity.Queries.by_actor()
1625     |> RepoStreamer.chunk_stream(50)
1626     |> Stream.each(fn activities ->
1627       Enum.each(activities, fn activity -> delete_activity(activity, user) end)
1628     end)
1629     |> Stream.run()
1630   end
1631
1632   defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
1633     with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
1634          {:ok, delete_data, _} <- Builder.delete(user, object) do
1635       Pipeline.common_pipeline(delete_data, local: user.local)
1636     else
1637       {:find_object, nil} ->
1638         # We have the create activity, but not the object, it was probably pruned.
1639         # Insert a tombstone and try again
1640         with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
1641              {:ok, _tombstone} <- Object.create(tombstone_data) do
1642           delete_activity(activity, user)
1643         end
1644
1645       e ->
1646         Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
1647         Logger.error("Error: #{inspect(e)}")
1648     end
1649   end
1650
1651   defp delete_activity(%{data: %{"type" => type}} = activity, user)
1652        when type in ["Like", "Announce"] do
1653     {:ok, undo, _} = Builder.undo(user, activity)
1654     Pipeline.common_pipeline(undo, local: user.local)
1655   end
1656
1657   defp delete_activity(_activity, _user), do: "Doing nothing"
1658
1659   defp delete_outgoing_pending_follow_requests(user) do
1660     user
1661     |> FollowingRelationship.outgoing_pending_follow_requests_query()
1662     |> Repo.delete_all()
1663   end
1664
1665   def html_filter_policy(%User{no_rich_text: true}) do
1666     Pleroma.HTML.Scrubber.TwitterText
1667   end
1668
1669   def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])
1670
1671   def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)
1672
1673   def get_or_fetch_by_ap_id(ap_id) do
1674     cached_user = get_cached_by_ap_id(ap_id)
1675
1676     maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)
1677
1678     case {cached_user, maybe_fetched_user} do
1679       {_, {:ok, %User{} = user}} ->
1680         {:ok, user}
1681
1682       {%User{} = user, _} ->
1683         {:ok, user}
1684
1685       _ ->
1686         {:error, :not_found}
1687     end
1688   end
1689
1690   @doc """
1691   Creates an internal service actor by URI if missing.
1692   Optionally takes nickname for addressing.
1693   """
1694   @spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() | nil
1695   def get_or_create_service_actor_by_ap_id(uri, nickname) do
1696     {_, user} =
1697       case get_cached_by_ap_id(uri) do
1698         nil ->
1699           with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
1700             Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
1701             {:error, nil}
1702           end
1703
1704         %User{invisible: false} = user ->
1705           set_invisible(user)
1706
1707         user ->
1708           {:ok, user}
1709       end
1710
1711     user
1712   end
1713
1714   @spec set_invisible(User.t()) :: {:ok, User.t()}
1715   defp set_invisible(user) do
1716     user
1717     |> change(%{invisible: true})
1718     |> update_and_set_cache()
1719   end
1720
1721   @spec create_service_actor(String.t(), String.t()) ::
1722           {:ok, User.t()} | {:error, Ecto.Changeset.t()}
1723   defp create_service_actor(uri, nickname) do
1724     %User{
1725       invisible: true,
1726       local: true,
1727       ap_id: uri,
1728       nickname: nickname,
1729       follower_address: uri <> "/followers"
1730     }
1731     |> change
1732     |> unique_constraint(:nickname)
1733     |> Repo.insert()
1734     |> set_cache()
1735   end
1736
1737   def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
1738     key =
1739       public_key_pem
1740       |> :public_key.pem_decode()
1741       |> hd()
1742       |> :public_key.pem_entry_decode()
1743
1744     {:ok, key}
1745   end
1746
1747   def public_key(_), do: {:error, "key not found"}
1748
1749   def get_public_key_for_ap_id(ap_id) do
1750     with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
1751          {:ok, public_key} <- public_key(user) do
1752       {:ok, public_key}
1753     else
1754       _ -> :error
1755     end
1756   end
1757
1758   def ap_enabled?(%User{local: true}), do: true
1759   def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
1760   def ap_enabled?(_), do: false
1761
1762   @doc "Gets or fetch a user by uri or nickname."
1763   @spec get_or_fetch(String.t()) :: {:ok, User.t()} | {:error, String.t()}
1764   def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
1765   def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)
1766
1767   # wait a period of time and return newest version of the User structs
1768   # this is because we have synchronous follow APIs and need to simulate them
1769   # with an async handshake
1770   def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
1771     with %User{} = a <- get_cached_by_id(a.id),
1772          %User{} = b <- get_cached_by_id(b.id) do
1773       {:ok, a, b}
1774     else
1775       nil -> :error
1776     end
1777   end
1778
1779   def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
1780     with :ok <- :timer.sleep(timeout),
1781          %User{} = a <- get_cached_by_id(a.id),
1782          %User{} = b <- get_cached_by_id(b.id) do
1783       {:ok, a, b}
1784     else
1785       nil -> :error
1786     end
1787   end
1788
1789   def parse_bio(bio) when is_binary(bio) and bio != "" do
1790     bio
1791     |> CommonUtils.format_input("text/plain", mentions_format: :full)
1792     |> elem(0)
1793   end
1794
1795   def parse_bio(_), do: ""
1796
1797   def parse_bio(bio, user) when is_binary(bio) and bio != "" do
1798     # TODO: get profile URLs other than user.ap_id
1799     profile_urls = [user.ap_id]
1800
1801     bio
1802     |> CommonUtils.format_input("text/plain",
1803       mentions_format: :full,
1804       rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
1805     )
1806     |> elem(0)
1807   end
1808
1809   def parse_bio(_, _), do: ""
1810
1811   def tag(user_identifiers, tags) when is_list(user_identifiers) do
1812     Repo.transaction(fn ->
1813       for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
1814     end)
1815   end
1816
1817   def tag(nickname, tags) when is_binary(nickname),
1818     do: tag(get_by_nickname(nickname), tags)
1819
1820   def tag(%User{} = user, tags),
1821     do: update_tags(user, Enum.uniq((user.tags || []) ++ normalize_tags(tags)))
1822
1823   def untag(user_identifiers, tags) when is_list(user_identifiers) do
1824     Repo.transaction(fn ->
1825       for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
1826     end)
1827   end
1828
1829   def untag(nickname, tags) when is_binary(nickname),
1830     do: untag(get_by_nickname(nickname), tags)
1831
1832   def untag(%User{} = user, tags),
1833     do: update_tags(user, (user.tags || []) -- normalize_tags(tags))
1834
1835   defp update_tags(%User{} = user, new_tags) do
1836     {:ok, updated_user} =
1837       user
1838       |> change(%{tags: new_tags})
1839       |> update_and_set_cache()
1840
1841     updated_user
1842   end
1843
1844   defp normalize_tags(tags) do
1845     [tags]
1846     |> List.flatten()
1847     |> Enum.map(&String.downcase/1)
1848   end
1849
1850   defp local_nickname_regex do
1851     if Config.get([:instance, :extended_nickname_format]) do
1852       @extended_local_nickname_regex
1853     else
1854       @strict_local_nickname_regex
1855     end
1856   end
1857
1858   def local_nickname(nickname_or_mention) do
1859     nickname_or_mention
1860     |> full_nickname()
1861     |> String.split("@")
1862     |> hd()
1863   end
1864
1865   def full_nickname(nickname_or_mention),
1866     do: String.trim_leading(nickname_or_mention, "@")
1867
1868   def error_user(ap_id) do
1869     %User{
1870       name: ap_id,
1871       ap_id: ap_id,
1872       nickname: "erroruser@example.com",
1873       inserted_at: NaiveDateTime.utc_now()
1874     }
1875   end
1876
1877   @spec all_superusers() :: [User.t()]
1878   def all_superusers do
1879     User.Query.build(%{super_users: true, local: true, deactivated: false})
1880     |> Repo.all()
1881   end
1882
1883   def muting_reblogs?(%User{} = user, %User{} = target) do
1884     UserRelationship.reblog_mute_exists?(user, target)
1885   end
1886
1887   def showing_reblogs?(%User{} = user, %User{} = target) do
1888     not muting_reblogs?(user, target)
1889   end
1890
1891   @doc """
1892   The function returns a query to get users with no activity for given interval of days.
1893   Inactive users are those who didn't read any notification, or had any activity where
1894   the user is the activity's actor, during `inactivity_threshold` days.
1895   Deactivated users will not appear in this list.
1896
1897   ## Examples
1898
1899       iex> Pleroma.User.list_inactive_users()
1900       %Ecto.Query{}
1901   """
1902   @spec list_inactive_users_query(integer()) :: Ecto.Query.t()
1903   def list_inactive_users_query(inactivity_threshold \\ 7) do
1904     negative_inactivity_threshold = -inactivity_threshold
1905     now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
1906     # Subqueries are not supported in `where` clauses, join gets too complicated.
1907     has_read_notifications =
1908       from(n in Pleroma.Notification,
1909         where: n.seen == true,
1910         group_by: n.id,
1911         having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
1912         select: n.user_id
1913       )
1914       |> Pleroma.Repo.all()
1915
1916     from(u in Pleroma.User,
1917       left_join: a in Pleroma.Activity,
1918       on: u.ap_id == a.actor,
1919       where: not is_nil(u.nickname),
1920       where: u.deactivated != ^true,
1921       where: u.id not in ^has_read_notifications,
1922       group_by: u.id,
1923       having:
1924         max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
1925           is_nil(max(a.inserted_at))
1926     )
1927   end
1928
1929   @doc """
1930   Enable or disable email notifications for user
1931
1932   ## Examples
1933
1934       iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
1935       Pleroma.User{email_notifications: %{"digest" => true}}
1936
1937       iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
1938       Pleroma.User{email_notifications: %{"digest" => false}}
1939   """
1940   @spec switch_email_notifications(t(), String.t(), boolean()) ::
1941           {:ok, t()} | {:error, Ecto.Changeset.t()}
1942   def switch_email_notifications(user, type, status) do
1943     User.update_email_notifications(user, %{type => status})
1944   end
1945
1946   @doc """
1947   Set `last_digest_emailed_at` value for the user to current time
1948   """
1949   @spec touch_last_digest_emailed_at(t()) :: t()
1950   def touch_last_digest_emailed_at(user) do
1951     now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
1952
1953     {:ok, updated_user} =
1954       user
1955       |> change(%{last_digest_emailed_at: now})
1956       |> update_and_set_cache()
1957
1958     updated_user
1959   end
1960
1961   @spec toggle_confirmation(User.t()) :: {:ok, User.t()} | {:error, Changeset.t()}
1962   def toggle_confirmation(%User{} = user) do
1963     user
1964     |> confirmation_changeset(need_confirmation: !user.confirmation_pending)
1965     |> update_and_set_cache()
1966   end
1967
1968   @spec toggle_confirmation([User.t()]) :: [{:ok, User.t()} | {:error, Changeset.t()}]
1969   def toggle_confirmation(users) do
1970     Enum.map(users, &toggle_confirmation/1)
1971   end
1972
1973   def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
1974     mascot
1975   end
1976
1977   def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
1978     # use instance-default
1979     config = Config.get([:assets, :mascots])
1980     default_mascot = Config.get([:assets, :default_mascot])
1981     mascot = Keyword.get(config, default_mascot)
1982
1983     %{
1984       "id" => "default-mascot",
1985       "url" => mascot[:url],
1986       "preview_url" => mascot[:url],
1987       "pleroma" => %{
1988         "mime_type" => mascot[:mime_type]
1989       }
1990     }
1991   end
1992
1993   def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}
1994
1995   def ensure_keys_present(%User{} = user) do
1996     with {:ok, pem} <- Keys.generate_rsa_pem() do
1997       user
1998       |> cast(%{keys: pem}, [:keys])
1999       |> validate_required([:keys])
2000       |> update_and_set_cache()
2001     end
2002   end
2003
2004   def get_ap_ids_by_nicknames(nicknames) do
2005     from(u in User,
2006       where: u.nickname in ^nicknames,
2007       select: u.ap_id
2008     )
2009     |> Repo.all()
2010   end
2011
2012   defdelegate search(query, opts \\ []), to: User.Search
2013
2014   defp put_password_hash(
2015          %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
2016        ) do
2017     change(changeset, password_hash: Pbkdf2.hash_pwd_salt(password))
2018   end
2019
2020   defp put_password_hash(changeset), do: changeset
2021
2022   def is_internal_user?(%User{nickname: nil}), do: true
2023   def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
2024   def is_internal_user?(_), do: false
2025
2026   # A hack because user delete activities have a fake id for whatever reason
2027   # TODO: Get rid of this
2028   def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []
2029
2030   def get_delivered_users_by_object_id(object_id) do
2031     from(u in User,
2032       inner_join: delivery in assoc(u, :deliveries),
2033       where: delivery.object_id == ^object_id
2034     )
2035     |> Repo.all()
2036   end
2037
2038   def change_email(user, email) do
2039     user
2040     |> cast(%{email: email}, [:email])
2041     |> validate_required([:email])
2042     |> unique_constraint(:email)
2043     |> validate_format(:email, @email_regex)
2044     |> update_and_set_cache()
2045   end
2046
2047   # Internal function; public one is `deactivate/2`
2048   defp set_activation_status(user, deactivated) do
2049     user
2050     |> cast(%{deactivated: deactivated}, [:deactivated])
2051     |> update_and_set_cache()
2052   end
2053
2054   def update_banner(user, banner) do
2055     user
2056     |> cast(%{banner: banner}, [:banner])
2057     |> update_and_set_cache()
2058   end
2059
2060   def update_background(user, background) do
2061     user
2062     |> cast(%{background: background}, [:background])
2063     |> update_and_set_cache()
2064   end
2065
2066   def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
2067     %{
2068       admin: is_admin,
2069       moderator: is_moderator
2070     }
2071   end
2072
2073   def validate_fields(changeset, remote? \\ false) do
2074     limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
2075     limit = Config.get([:instance, limit_name], 0)
2076
2077     changeset
2078     |> validate_length(:fields, max: limit)
2079     |> validate_change(:fields, fn :fields, fields ->
2080       if Enum.all?(fields, &valid_field?/1) do
2081         []
2082       else
2083         [fields: "invalid"]
2084       end
2085     end)
2086   end
2087
2088   defp valid_field?(%{"name" => name, "value" => value}) do
2089     name_limit = Config.get([:instance, :account_field_name_length], 255)
2090     value_limit = Config.get([:instance, :account_field_value_length], 255)
2091
2092     is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
2093       String.length(value) <= value_limit
2094   end
2095
2096   defp valid_field?(_), do: false
2097
2098   defp truncate_field(%{"name" => name, "value" => value}) do
2099     {name, _chopped} =
2100       String.split_at(name, Config.get([:instance, :account_field_name_length], 255))
2101
2102     {value, _chopped} =
2103       String.split_at(value, Config.get([:instance, :account_field_value_length], 255))
2104
2105     %{"name" => name, "value" => value}
2106   end
2107
2108   def admin_api_update(user, params) do
2109     user
2110     |> cast(params, [
2111       :is_moderator,
2112       :is_admin,
2113       :show_role
2114     ])
2115     |> update_and_set_cache()
2116   end
2117
2118   @doc "Signs user out of all applications"
2119   def global_sign_out(user) do
2120     OAuth.Authorization.delete_user_authorizations(user)
2121     OAuth.Token.delete_user_tokens(user)
2122   end
2123
2124   def mascot_update(user, url) do
2125     user
2126     |> cast(%{mascot: url}, [:mascot])
2127     |> validate_required([:mascot])
2128     |> update_and_set_cache()
2129   end
2130
2131   def mastodon_settings_update(user, settings) do
2132     user
2133     |> cast(%{mastofe_settings: settings}, [:mastofe_settings])
2134     |> validate_required([:mastofe_settings])
2135     |> update_and_set_cache()
2136   end
2137
2138   @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
2139   def confirmation_changeset(user, need_confirmation: need_confirmation?) do
2140     params =
2141       if need_confirmation? do
2142         %{
2143           confirmation_pending: true,
2144           confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
2145         }
2146       else
2147         %{
2148           confirmation_pending: false,
2149           confirmation_token: nil
2150         }
2151       end
2152
2153     cast(user, params, [:confirmation_pending, :confirmation_token])
2154   end
2155
2156   def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2157     if id not in user.pinned_activities do
2158       max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2159       params = %{pinned_activities: user.pinned_activities ++ [id]}
2160
2161       user
2162       |> cast(params, [:pinned_activities])
2163       |> validate_length(:pinned_activities,
2164         max: max_pinned_statuses,
2165         message: "You have already pinned the maximum number of statuses"
2166       )
2167     else
2168       change(user)
2169     end
2170     |> update_and_set_cache()
2171   end
2172
2173   def remove_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2174     params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2175
2176     user
2177     |> cast(params, [:pinned_activities])
2178     |> update_and_set_cache()
2179   end
2180
2181   def update_email_notifications(user, settings) do
2182     email_notifications =
2183       user.email_notifications
2184       |> Map.merge(settings)
2185       |> Map.take(["digest"])
2186
2187     params = %{email_notifications: email_notifications}
2188     fields = [:email_notifications]
2189
2190     user
2191     |> cast(params, fields)
2192     |> validate_required(fields)
2193     |> update_and_set_cache()
2194   end
2195
2196   defp set_domain_blocks(user, domain_blocks) do
2197     params = %{domain_blocks: domain_blocks}
2198
2199     user
2200     |> cast(params, [:domain_blocks])
2201     |> validate_required([:domain_blocks])
2202     |> update_and_set_cache()
2203   end
2204
2205   def block_domain(user, domain_blocked) do
2206     set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2207   end
2208
2209   def unblock_domain(user, domain_blocked) do
2210     set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2211   end
2212
2213   @spec add_to_block(User.t(), User.t()) ::
2214           {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2215   defp add_to_block(%User{} = user, %User{} = blocked) do
2216     UserRelationship.create_block(user, blocked)
2217   end
2218
2219   @spec add_to_block(User.t(), User.t()) ::
2220           {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2221   defp remove_from_block(%User{} = user, %User{} = blocked) do
2222     UserRelationship.delete_block(user, blocked)
2223   end
2224
2225   defp add_to_mutes(%User{} = user, %User{} = muted_user, notifications?) do
2226     with {:ok, user_mute} <- UserRelationship.create_mute(user, muted_user),
2227          {:ok, user_notification_mute} <-
2228            (notifications? && UserRelationship.create_notification_mute(user, muted_user)) ||
2229              {:ok, nil} do
2230       {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
2231     end
2232   end
2233
2234   defp remove_from_mutes(user, %User{} = muted_user) do
2235     with {:ok, user_mute} <- UserRelationship.delete_mute(user, muted_user),
2236          {:ok, user_notification_mute} <-
2237            UserRelationship.delete_notification_mute(user, muted_user) do
2238       {:ok, [user_mute, user_notification_mute]}
2239     end
2240   end
2241
2242   def set_invisible(user, invisible) do
2243     params = %{invisible: invisible}
2244
2245     user
2246     |> cast(params, [:invisible])
2247     |> validate_required([:invisible])
2248     |> update_and_set_cache()
2249   end
2250
2251   def sanitize_html(%User{} = user) do
2252     sanitize_html(user, nil)
2253   end
2254
2255   # User data that mastodon isn't filtering (treated as plaintext):
2256   # - field name
2257   # - display name
2258   def sanitize_html(%User{} = user, filter) do
2259     fields =
2260       Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2261         %{
2262           "name" => name,
2263           "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2264         }
2265       end)
2266
2267     user
2268     |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2269     |> Map.put(:fields, fields)
2270   end
2271 end