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

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.User do
   6   use Ecto.Schema
   7
   8   import Ecto.Changeset
   9   import Ecto.Query
  10   import Ecto, only: [assoc: 2]
  11
  12   alias Ecto.Multi
  13   alias Pleroma.Activity
  14   alias Pleroma.Config
  15   alias Pleroma.Conversation.Participation
  16   alias Pleroma.Delivery
  17   alias Pleroma.EctoType.ActivityPub.ObjectValidators
  18   alias Pleroma.Emoji
  19   alias Pleroma.FollowingRelationship
  20   alias Pleroma.Formatter
  21   alias Pleroma.HTML
  22   alias Pleroma.Keys
  23   alias Pleroma.MFA
  24   alias Pleroma.Notification
  25   alias Pleroma.Object
  26   alias Pleroma.Registration
  27   alias Pleroma.Repo
  28   alias Pleroma.RepoStreamer
  29   alias Pleroma.User
  30   alias Pleroma.UserRelationship
  31   alias Pleroma.Web
  32   alias Pleroma.Web.ActivityPub.ActivityPub
  33   alias Pleroma.Web.ActivityPub.Builder
  34   alias Pleroma.Web.ActivityPub.Pipeline
  35   alias Pleroma.Web.ActivityPub.Utils
  36   alias Pleroma.Web.CommonAPI
  37   alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
  38   alias Pleroma.Web.OAuth
  39   alias Pleroma.Web.RelMe
  40   alias Pleroma.Workers.BackgroundWorker
  41
  42   require Logger
  43
  44   @type t :: %__MODULE__{}
  45   @type account_status :: :active | :deactivated | :password_reset_pending | :confirmation_pending
  46   @primary_key {:id, FlakeId.Ecto.CompatType, autogenerate: true}
  47
  48   # credo:disable-for-next-line Credo.Check.Readability.MaxLineLength
  49   @email_regex ~r/^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/
  50
  51   @strict_local_nickname_regex ~r/^[a-zA-Z\d]+$/
  52   @extended_local_nickname_regex ~r/^[a-zA-Z\d_-]+$/
  53
  54   # AP ID user relationships (blocks, mutes etc.)
  55   # Format: [rel_type: [outgoing_rel: :outgoing_rel_target, incoming_rel: :incoming_rel_source]]
  56   @user_relationships_config [
  57     block: [
  58       blocker_blocks: :blocked_users,
  59       blockee_blocks: :blocker_users
  60     ],
  61     mute: [
  62       muter_mutes: :muted_users,
  63       mutee_mutes: :muter_users
  64     ],
  65     reblog_mute: [
  66       reblog_muter_mutes: :reblog_muted_users,
  67       reblog_mutee_mutes: :reblog_muter_users
  68     ],
  69     notification_mute: [
  70       notification_muter_mutes: :notification_muted_users,
  71       notification_mutee_mutes: :notification_muter_users
  72     ],
  73     # Note: `inverse_subscription` relationship is inverse: subscriber acts as relationship target
  74     inverse_subscription: [
  75       subscribee_subscriptions: :subscriber_users,
  76       subscriber_subscriptions: :subscribee_users
  77     ]
  78   ]
  79
  80   schema "users" do
  81     field(:bio, :string)
  82     field(:raw_bio, :string)
  83     field(:email, :string)
  84     field(:name, :string)
  85     field(:nickname, :string)
  86     field(:password_hash, :string)
  87     field(:password, :string, virtual: true)
  88     field(:password_confirmation, :string, virtual: true)
  89     field(:keys, :string)
  90     field(:public_key, :string)
  91     field(:ap_id, :string)
  92     field(:avatar, :map, default: %{})
  93     field(:local, :boolean, default: true)
  94     field(:follower_address, :string)
  95     field(:following_address, :string)
  96     field(:search_rank, :float, virtual: true)
  97     field(:search_type, :integer, virtual: true)
  98     field(:tags, {:array, :string}, default: [])
  99     field(:last_refreshed_at, :naive_datetime_usec)
 100     field(:last_digest_emailed_at, :naive_datetime)
 101     field(:banner, :map, default: %{})
 102     field(:background, :map, default: %{})
 103     field(:note_count, :integer, default: 0)
 104     field(:follower_count, :integer, default: 0)
 105     field(:following_count, :integer, default: 0)
 106     field(:locked, :boolean, default: false)
 107     field(:confirmation_pending, :boolean, default: false)
 108     field(:password_reset_pending, :boolean, default: false)
 109     field(:approval_pending, :boolean, default: false)
 110     field(:confirmation_token, :string, default: nil)
 111     field(:default_scope, :string, default: "public")
 112     field(:domain_blocks, {:array, :string}, default: [])
 113     field(:deactivated, :boolean, default: false)
 114     field(:no_rich_text, :boolean, default: false)
 115     field(:ap_enabled, :boolean, default: false)
 116     field(:is_moderator, :boolean, default: false)
 117     field(:is_admin, :boolean, default: false)
 118     field(:show_role, :boolean, default: true)
 119     field(:mastofe_settings, :map, default: nil)
 120     field(:uri, ObjectValidators.Uri, default: nil)
 121     field(:hide_followers_count, :boolean, default: false)
 122     field(:hide_follows_count, :boolean, default: false)
 123     field(:hide_followers, :boolean, default: false)
 124     field(:hide_follows, :boolean, default: false)
 125     field(:hide_favorites, :boolean, default: true)
 126     field(:unread_conversation_count, :integer, default: 0)
 127     field(:pinned_activities, {:array, :string}, default: [])
 128     field(:email_notifications, :map, default: %{"digest" => false})
 129     field(:mascot, :map, default: nil)
 130     field(:emoji, :map, default: %{})
 131     field(:pleroma_settings_store, :map, default: %{})
 132     field(:fields, {:array, :map}, default: [])
 133     field(:raw_fields, {:array, :map}, default: [])
 134     field(:discoverable, :boolean, default: false)
 135     field(:invisible, :boolean, default: false)
 136     field(:allow_following_move, :boolean, default: true)
 137     field(:skip_thread_containment, :boolean, default: false)
 138     field(:actor_type, :string, default: "Person")
 139     field(:also_known_as, {:array, :string}, default: [])
 140     field(:inbox, :string)
 141     field(:shared_inbox, :string)
 142     field(:accepts_chat_messages, :boolean, default: nil)
 143
 144     embeds_one(
 145       :notification_settings,
 146       Pleroma.User.NotificationSetting,
 147       on_replace: :update
 148     )
 149
 150     has_many(:notifications, Notification)
 151     has_many(:registrations, Registration)
 152     has_many(:deliveries, Delivery)
 153
 154     has_many(:outgoing_relationships, UserRelationship, foreign_key: :source_id)
 155     has_many(:incoming_relationships, UserRelationship, foreign_key: :target_id)
 156
 157     for {relationship_type,
 158          [
 159            {outgoing_relation, outgoing_relation_target},
 160            {incoming_relation, incoming_relation_source}
 161          ]} <- @user_relationships_config do
 162       # Definitions of `has_many` relations: :blocker_blocks, :muter_mutes, :reblog_muter_mutes,
 163       #   :notification_muter_mutes, :subscribee_subscriptions
 164       has_many(outgoing_relation, UserRelationship,
 165         foreign_key: :source_id,
 166         where: [relationship_type: relationship_type]
 167       )
 168
 169       # Definitions of `has_many` relations: :blockee_blocks, :mutee_mutes, :reblog_mutee_mutes,
 170       #   :notification_mutee_mutes, :subscriber_subscriptions
 171       has_many(incoming_relation, UserRelationship,
 172         foreign_key: :target_id,
 173         where: [relationship_type: relationship_type]
 174       )
 175
 176       # Definitions of `has_many` relations: :blocked_users, :muted_users, :reblog_muted_users,
 177       #   :notification_muted_users, :subscriber_users
 178       has_many(outgoing_relation_target, through: [outgoing_relation, :target])
 179
 180       # Definitions of `has_many` relations: :blocker_users, :muter_users, :reblog_muter_users,
 181       #   :notification_muter_users, :subscribee_users
 182       has_many(incoming_relation_source, through: [incoming_relation, :source])
 183     end
 184
 185     # `:blocks` is deprecated (replaced with `blocked_users` relation)
 186     field(:blocks, {:array, :string}, default: [])
 187     # `:mutes` is deprecated (replaced with `muted_users` relation)
 188     field(:mutes, {:array, :string}, default: [])
 189     # `:muted_reblogs` is deprecated (replaced with `reblog_muted_users` relation)
 190     field(:muted_reblogs, {:array, :string}, default: [])
 191     # `:muted_notifications` is deprecated (replaced with `notification_muted_users` relation)
 192     field(:muted_notifications, {:array, :string}, default: [])
 193     # `:subscribers` is deprecated (replaced with `subscriber_users` relation)
 194     field(:subscribers, {:array, :string}, default: [])
 195
 196     embeds_one(
 197       :multi_factor_authentication_settings,
 198       MFA.Settings,
 199       on_replace: :delete
 200     )
 201
 202     timestamps()
 203   end
 204
 205   for {_relationship_type, [{_outgoing_relation, outgoing_relation_target}, _]} <-
 206         @user_relationships_config do
 207     # `def blocked_users_relation/2`, `def muted_users_relation/2`,
 208     #   `def reblog_muted_users_relation/2`, `def notification_muted_users/2`,
 209     #   `def subscriber_users/2`
 210     def unquote(:"#{outgoing_relation_target}_relation")(user, restrict_deactivated? \\ false) do
 211       target_users_query = assoc(user, unquote(outgoing_relation_target))
 212
 213       if restrict_deactivated? do
 214         restrict_deactivated(target_users_query)
 215       else
 216         target_users_query
 217       end
 218     end
 219
 220     # `def blocked_users/2`, `def muted_users/2`, `def reblog_muted_users/2`,
 221     #   `def notification_muted_users/2`, `def subscriber_users/2`
 222     def unquote(outgoing_relation_target)(user, restrict_deactivated? \\ false) do
 223       __MODULE__
 224       |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
 225         user,
 226         restrict_deactivated?
 227       ])
 228       |> Repo.all()
 229     end
 230
 231     # `def blocked_users_ap_ids/2`, `def muted_users_ap_ids/2`, `def reblog_muted_users_ap_ids/2`,
 232     #   `def notification_muted_users_ap_ids/2`, `def subscriber_users_ap_ids/2`
 233     def unquote(:"#{outgoing_relation_target}_ap_ids")(user, restrict_deactivated? \\ false) do
 234       __MODULE__
 235       |> apply(unquote(:"#{outgoing_relation_target}_relation"), [
 236         user,
 237         restrict_deactivated?
 238       ])
 239       |> select([u], u.ap_id)
 240       |> Repo.all()
 241     end
 242   end
 243
 244   @doc """
 245   Dumps Flake Id to SQL-compatible format (16-byte UUID).
 246   E.g. "9pQtDGXuq4p3VlcJEm" -> <<0, 0, 1, 110, 179, 218, 42, 92, 213, 41, 44, 227, 95, 213, 0, 0>>
 247   """
 248   def binary_id(source_id) when is_binary(source_id) do
 249     with {:ok, dumped_id} <- FlakeId.Ecto.CompatType.dump(source_id) do
 250       dumped_id
 251     else
 252       _ -> source_id
 253     end
 254   end
 255
 256   def binary_id(source_ids) when is_list(source_ids) do
 257     Enum.map(source_ids, &binary_id/1)
 258   end
 259
 260   def binary_id(%User{} = user), do: binary_id(user.id)
 261
 262   @doc "Returns status account"
 263   @spec account_status(User.t()) :: account_status()
 264   def account_status(%User{deactivated: true}), do: :deactivated
 265   def account_status(%User{password_reset_pending: true}), do: :password_reset_pending
 266   def account_status(%User{approval_pending: true}), do: :approval_pending
 267
 268   def account_status(%User{confirmation_pending: true}) do
 269     if Config.get([:instance, :account_activation_required]) do
 270       :confirmation_pending
 271     else
 272       :active
 273     end
 274   end
 275
 276   def account_status(%User{}), do: :active
 277
 278   @spec visible_for(User.t(), User.t() | nil) ::
 279           :visible
 280           | :invisible
 281           | :restricted_unauthenticated
 282           | :deactivated
 283           | :confirmation_pending
 284   def visible_for(user, for_user \\ nil)
 285
 286   def visible_for(%User{invisible: true}, _), do: :invisible
 287
 288   def visible_for(%User{id: user_id}, %User{id: user_id}), do: :visible
 289
 290   def visible_for(%User{} = user, nil) do
 291     if restrict_unauthenticated?(user) do
 292       :restrict_unauthenticated
 293     else
 294       visible_account_status(user)
 295     end
 296   end
 297
 298   def visible_for(%User{} = user, for_user) do
 299     if superuser?(for_user) do
 300       :visible
 301     else
 302       visible_account_status(user)
 303     end
 304   end
 305
 306   def visible_for(_, _), do: :invisible
 307
 308   defp restrict_unauthenticated?(%User{local: local}) do
 309     config_key = if local, do: :local, else: :remote
 310
 311     Config.get([:restrict_unauthenticated, :profiles, config_key], false)
 312   end
 313
 314   defp visible_account_status(user) do
 315     status = account_status(user)
 316
 317     if status in [:active, :password_reset_pending] do
 318       :visible
 319     else
 320       status
 321     end
 322   end
 323
 324   @spec superuser?(User.t()) :: boolean()
 325   def superuser?(%User{local: true, is_admin: true}), do: true
 326   def superuser?(%User{local: true, is_moderator: true}), do: true
 327   def superuser?(_), do: false
 328
 329   @spec invisible?(User.t()) :: boolean()
 330   def invisible?(%User{invisible: true}), do: true
 331   def invisible?(_), do: false
 332
 333   def avatar_url(user, options \\ []) do
 334     case user.avatar do
 335       %{"url" => [%{"href" => href} | _]} ->
 336         href
 337
 338       _ ->
 339         unless options[:no_default] do
 340           Config.get([:assets, :default_user_avatar], "#{Web.base_url()}/images/avi.png")
 341         end
 342     end
 343   end
 344
 345   def banner_url(user, options \\ []) do
 346     case user.banner do
 347       %{"url" => [%{"href" => href} | _]} -> href
 348       _ -> !options[:no_default] && "#{Web.base_url()}/images/banner.png"
 349     end
 350   end
 351
 352   # Should probably be renamed or removed
 353   def ap_id(%User{nickname: nickname}), do: "#{Web.base_url()}/users/#{nickname}"
 354
 355   def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
 356   def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"
 357
 358   @spec ap_following(User.t()) :: String.t()
 359   def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
 360   def ap_following(%User{} = user), do: "#{ap_id(user)}/following"
 361
 362   @spec restrict_deactivated(Ecto.Query.t()) :: Ecto.Query.t()
 363   def restrict_deactivated(query) do
 364     from(u in query, where: u.deactivated != ^true)
 365   end
 366
 367   defdelegate following_count(user), to: FollowingRelationship
 368
 369   defp truncate_fields_param(params) do
 370     if Map.has_key?(params, :fields) do
 371       Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
 372     else
 373       params
 374     end
 375   end
 376
 377   defp truncate_if_exists(params, key, max_length) do
 378     if Map.has_key?(params, key) and is_binary(params[key]) do
 379       {value, _chopped} = String.split_at(params[key], max_length)
 380       Map.put(params, key, value)
 381     else
 382       params
 383     end
 384   end
 385
 386   defp fix_follower_address(%{follower_address: _, following_address: _} = params), do: params
 387
 388   defp fix_follower_address(%{nickname: nickname} = params),
 389     do: Map.put(params, :follower_address, ap_followers(%User{nickname: nickname}))
 390
 391   defp fix_follower_address(params), do: params
 392
 393   def remote_user_changeset(struct \\ %User{local: false}, params) do
 394     bio_limit = Config.get([:instance, :user_bio_length], 5000)
 395     name_limit = Config.get([:instance, :user_name_length], 100)
 396
 397     name =
 398       case params[:name] do
 399         name when is_binary(name) and byte_size(name) > 0 -> name
 400         _ -> params[:nickname]
 401       end
 402
 403     params =
 404       params
 405       |> Map.put(:name, name)
 406       |> Map.put_new(:last_refreshed_at, NaiveDateTime.utc_now())
 407       |> truncate_if_exists(:name, name_limit)
 408       |> truncate_if_exists(:bio, bio_limit)
 409       |> truncate_fields_param()
 410       |> fix_follower_address()
 411
 412     struct
 413     |> cast(
 414       params,
 415       [
 416         :bio,
 417         :name,
 418         :emoji,
 419         :ap_id,
 420         :inbox,
 421         :shared_inbox,
 422         :nickname,
 423         :public_key,
 424         :avatar,
 425         :ap_enabled,
 426         :banner,
 427         :locked,
 428         :last_refreshed_at,
 429         :uri,
 430         :follower_address,
 431         :following_address,
 432         :hide_followers,
 433         :hide_follows,
 434         :hide_followers_count,
 435         :hide_follows_count,
 436         :follower_count,
 437         :fields,
 438         :following_count,
 439         :discoverable,
 440         :invisible,
 441         :actor_type,
 442         :also_known_as,
 443         :accepts_chat_messages
 444       ]
 445     )
 446     |> validate_required([:name, :ap_id])
 447     |> unique_constraint(:nickname)
 448     |> validate_format(:nickname, @email_regex)
 449     |> validate_length(:bio, max: bio_limit)
 450     |> validate_length(:name, max: name_limit)
 451     |> validate_fields(true)
 452   end
 453
 454   def update_changeset(struct, params \\ %{}) do
 455     bio_limit = Config.get([:instance, :user_bio_length], 5000)
 456     name_limit = Config.get([:instance, :user_name_length], 100)
 457
 458     struct
 459     |> cast(
 460       params,
 461       [
 462         :bio,
 463         :raw_bio,
 464         :name,
 465         :emoji,
 466         :avatar,
 467         :public_key,
 468         :inbox,
 469         :shared_inbox,
 470         :locked,
 471         :no_rich_text,
 472         :default_scope,
 473         :banner,
 474         :hide_follows,
 475         :hide_followers,
 476         :hide_followers_count,
 477         :hide_follows_count,
 478         :hide_favorites,
 479         :allow_following_move,
 480         :background,
 481         :show_role,
 482         :skip_thread_containment,
 483         :fields,
 484         :raw_fields,
 485         :pleroma_settings_store,
 486         :discoverable,
 487         :actor_type,
 488         :also_known_as,
 489         :accepts_chat_messages
 490       ]
 491     )
 492     |> unique_constraint(:nickname)
 493     |> validate_format(:nickname, local_nickname_regex())
 494     |> validate_length(:bio, max: bio_limit)
 495     |> validate_length(:name, min: 1, max: name_limit)
 496     |> validate_inclusion(:actor_type, ["Person", "Service"])
 497     |> put_fields()
 498     |> put_emoji()
 499     |> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
 500     |> put_change_if_present(:avatar, &put_upload(&1, :avatar))
 501     |> put_change_if_present(:banner, &put_upload(&1, :banner))
 502     |> put_change_if_present(:background, &put_upload(&1, :background))
 503     |> put_change_if_present(
 504       :pleroma_settings_store,
 505       &{:ok, Map.merge(struct.pleroma_settings_store, &1)}
 506     )
 507     |> validate_fields(false)
 508   end
 509
 510   defp put_fields(changeset) do
 511     if raw_fields = get_change(changeset, :raw_fields) do
 512       raw_fields =
 513         raw_fields
 514         |> Enum.filter(fn %{"name" => n} -> n != "" end)
 515
 516       fields =
 517         raw_fields
 518         |> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)
 519
 520       changeset
 521       |> put_change(:raw_fields, raw_fields)
 522       |> put_change(:fields, fields)
 523     else
 524       changeset
 525     end
 526   end
 527
 528   defp parse_fields(value) do
 529     value
 530     |> Formatter.linkify(mentions_format: :full)
 531     |> elem(0)
 532   end
 533
 534   defp put_emoji(changeset) do
 535     bio = get_change(changeset, :bio)
 536     name = get_change(changeset, :name)
 537
 538     if bio || name do
 539       emoji = Map.merge(Emoji.Formatter.get_emoji_map(bio), Emoji.Formatter.get_emoji_map(name))
 540       put_change(changeset, :emoji, emoji)
 541     else
 542       changeset
 543     end
 544   end
 545
 546   defp put_change_if_present(changeset, map_field, value_function) do
 547     with {:ok, value} <- fetch_change(changeset, map_field),
 548          {:ok, new_value} <- value_function.(value) do
 549       put_change(changeset, map_field, new_value)
 550     else
 551       _ -> changeset
 552     end
 553   end
 554
 555   defp put_upload(value, type) do
 556     with %Plug.Upload{} <- value,
 557          {:ok, object} <- ActivityPub.upload(value, type: type) do
 558       {:ok, object.data}
 559     end
 560   end
 561
 562   def update_as_admin_changeset(struct, params) do
 563     struct
 564     |> update_changeset(params)
 565     |> cast(params, [:email])
 566     |> delete_change(:also_known_as)
 567     |> unique_constraint(:email)
 568     |> validate_format(:email, @email_regex)
 569     |> validate_inclusion(:actor_type, ["Person", "Service"])
 570   end
 571
 572   @spec update_as_admin(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
 573   def update_as_admin(user, params) do
 574     params = Map.put(params, "password_confirmation", params["password"])
 575     changeset = update_as_admin_changeset(user, params)
 576
 577     if params["password"] do
 578       reset_password(user, changeset, params)
 579     else
 580       User.update_and_set_cache(changeset)
 581     end
 582   end
 583
 584   def password_update_changeset(struct, params) do
 585     struct
 586     |> cast(params, [:password, :password_confirmation])
 587     |> validate_required([:password, :password_confirmation])
 588     |> validate_confirmation(:password)
 589     |> put_password_hash()
 590     |> put_change(:password_reset_pending, false)
 591   end
 592
 593   @spec reset_password(User.t(), map()) :: {:ok, User.t()} | {:error, Changeset.t()}
 594   def reset_password(%User{} = user, params) do
 595     reset_password(user, user, params)
 596   end
 597
 598   def reset_password(%User{id: user_id} = user, struct, params) do
 599     multi =
 600       Multi.new()
 601       |> Multi.update(:user, password_update_changeset(struct, params))
 602       |> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
 603       |> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))
 604
 605     case Repo.transaction(multi) do
 606       {:ok, %{user: user} = _} -> set_cache(user)
 607       {:error, _, changeset, _} -> {:error, changeset}
 608     end
 609   end
 610
 611   def update_password_reset_pending(user, value) do
 612     user
 613     |> change()
 614     |> put_change(:password_reset_pending, value)
 615     |> update_and_set_cache()
 616   end
 617
 618   def force_password_reset_async(user) do
 619     BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
 620   end
 621
 622   @spec force_password_reset(User.t()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
 623   def force_password_reset(user), do: update_password_reset_pending(user, true)
 624
 625   def register_changeset(struct, params \\ %{}, opts \\ []) do
 626     bio_limit = Config.get([:instance, :user_bio_length], 5000)
 627     name_limit = Config.get([:instance, :user_name_length], 100)
 628     params = Map.put_new(params, :accepts_chat_messages, true)
 629
 630     need_confirmation? =
 631       if is_nil(opts[:need_confirmation]) do
 632         Config.get([:instance, :account_activation_required])
 633       else
 634         opts[:need_confirmation]
 635       end
 636
 637     need_approval? =
 638       if is_nil(opts[:need_approval]) do
 639         Config.get([:instance, :account_approval_required])
 640       else
 641         opts[:need_approval]
 642       end
 643
 644     struct
 645     |> confirmation_changeset(need_confirmation: need_confirmation?)
 646     |> approval_changeset(need_approval: need_approval?)
 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   @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
2157   def approval_changeset(user, need_approval: need_approval?) do
2158     params = if need_approval?, do: %{approval_pending: true}, else: %{approval_pending: false}
2159     cast(user, params, [:approval_pending])
2160   end
2161
2162   def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2163     if id not in user.pinned_activities do
2164       max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
2165       params = %{pinned_activities: user.pinned_activities ++ [id]}
2166
2167       user
2168       |> cast(params, [:pinned_activities])
2169       |> validate_length(:pinned_activities,
2170         max: max_pinned_statuses,
2171         message: "You have already pinned the maximum number of statuses"
2172       )
2173     else
2174       change(user)
2175     end
2176     |> update_and_set_cache()
2177   end
2178
2179   def remove_pinnned_activity(user, %Pleroma.Activity{id: id}) do
2180     params = %{pinned_activities: List.delete(user.pinned_activities, id)}
2181
2182     user
2183     |> cast(params, [:pinned_activities])
2184     |> update_and_set_cache()
2185   end
2186
2187   def update_email_notifications(user, settings) do
2188     email_notifications =
2189       user.email_notifications
2190       |> Map.merge(settings)
2191       |> Map.take(["digest"])
2192
2193     params = %{email_notifications: email_notifications}
2194     fields = [:email_notifications]
2195
2196     user
2197     |> cast(params, fields)
2198     |> validate_required(fields)
2199     |> update_and_set_cache()
2200   end
2201
2202   defp set_domain_blocks(user, domain_blocks) do
2203     params = %{domain_blocks: domain_blocks}
2204
2205     user
2206     |> cast(params, [:domain_blocks])
2207     |> validate_required([:domain_blocks])
2208     |> update_and_set_cache()
2209   end
2210
2211   def block_domain(user, domain_blocked) do
2212     set_domain_blocks(user, Enum.uniq([domain_blocked | user.domain_blocks]))
2213   end
2214
2215   def unblock_domain(user, domain_blocked) do
2216     set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
2217   end
2218
2219   @spec add_to_block(User.t(), User.t()) ::
2220           {:ok, UserRelationship.t()} | {:error, Ecto.Changeset.t()}
2221   defp add_to_block(%User{} = user, %User{} = blocked) do
2222     UserRelationship.create_block(user, blocked)
2223   end
2224
2225   @spec add_to_block(User.t(), User.t()) ::
2226           {:ok, UserRelationship.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
2227   defp remove_from_block(%User{} = user, %User{} = blocked) do
2228     UserRelationship.delete_block(user, blocked)
2229   end
2230
2231   defp add_to_mutes(%User{} = user, %User{} = muted_user, notifications?) do
2232     with {:ok, user_mute} <- UserRelationship.create_mute(user, muted_user),
2233          {:ok, user_notification_mute} <-
2234            (notifications? && UserRelationship.create_notification_mute(user, muted_user)) ||
2235              {:ok, nil} do
2236       {:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
2237     end
2238   end
2239
2240   defp remove_from_mutes(user, %User{} = muted_user) do
2241     with {:ok, user_mute} <- UserRelationship.delete_mute(user, muted_user),
2242          {:ok, user_notification_mute} <-
2243            UserRelationship.delete_notification_mute(user, muted_user) do
2244       {:ok, [user_mute, user_notification_mute]}
2245     end
2246   end
2247
2248   def set_invisible(user, invisible) do
2249     params = %{invisible: invisible}
2250
2251     user
2252     |> cast(params, [:invisible])
2253     |> validate_required([:invisible])
2254     |> update_and_set_cache()
2255   end
2256
2257   def sanitize_html(%User{} = user) do
2258     sanitize_html(user, nil)
2259   end
2260
2261   # User data that mastodon isn't filtering (treated as plaintext):
2262   # - field name
2263   # - display name
2264   def sanitize_html(%User{} = user, filter) do
2265     fields =
2266       Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
2267         %{
2268           "name" => name,
2269           "value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
2270         }
2271       end)
2272
2273     user
2274     |> Map.put(:bio, HTML.filter_tags(user.bio, filter))
2275     |> Map.put(:fields, fields)
2276   end
2277 end