Revert "Cycles: refactor Pleroma.User, Pleroma.User.Registration"

This reverts commit 6124cfe9ae3eeb91fba9ecd1c8d5558fcc16c1c8.

11 files changed, 332 insertions, 347 deletions

diff --git a/lib/mix/tasks/pleroma/email.ex b/lib/mix/tasks/pleroma/email.ex
index 7a05d7b93..4ce8c9b05 100644
--- a/lib/mix/tasks/pleroma/email.ex
+++ b/lib/mix/tasks/pleroma/email.ex
@@ -38,7 +38,7 @@ defmodule Mix.Tasks.Pleroma.Email do
       invisible: false
     })
     |> Pleroma.Repo.chunk_stream(500)
-    |> Stream.each(&Pleroma.User.Registration.maybe_send_confirmation_email(&1))
+    |> Stream.each(&Pleroma.User.maybe_send_confirmation_email(&1))
     |> Stream.run()
   end
 end
diff --git a/lib/mix/tasks/pleroma/user.ex b/lib/mix/tasks/pleroma/user.ex
index 1e75a39ca..53d5fc6d9 100644
--- a/lib/mix/tasks/pleroma/user.ex
+++ b/lib/mix/tasks/pleroma/user.ex
@@ -7,7 +7,6 @@ defmodule Mix.Tasks.Pleroma.User do
   import Mix.Pleroma
   alias Ecto.Changeset
   alias Pleroma.User
-  alias Pleroma.User.Registration
   alias Pleroma.UserInviteToken
   alias Pleroma.Web.ActivityPub.Builder
   alias Pleroma.Web.ActivityPub.Pipeline
@@ -75,8 +74,8 @@ defmodule Mix.Tasks.Pleroma.User do
         bio: bio
       }
 
-      changeset = Registration.register_changeset(%User{}, params, is_confirmed: true)
-      {:ok, _user} = Registration.register(changeset)
+      changeset = User.register_changeset(%User{}, params, is_confirmed: true)
+      {:ok, _user} = User.register(changeset)
 
       shell_info("User #{nickname} created")
 
@@ -356,7 +355,7 @@ defmodule Mix.Tasks.Pleroma.User do
     start_pleroma()
 
     with %User{} = user <- User.get_cached_by_nickname(nickname) do
-      {:ok, user} = Registration.confirm(user)
+      {:ok, user} = User.confirm(user)
 
       message = if !user.is_confirmed, do: "needs", else: "doesn't need"
 
@@ -380,7 +379,7 @@ defmodule Mix.Tasks.Pleroma.User do
     |> Pleroma.Repo.chunk_stream(500, :batches)
     |> Stream.each(fn users ->
       users
-      |> Enum.each(fn user -> Registration.set_confirmation(user, true) end)
+      |> Enum.each(fn user -> User.set_confirmation(user, true) end)
     end)
     |> Stream.run()
   end
@@ -398,7 +397,7 @@ defmodule Mix.Tasks.Pleroma.User do
     |> Pleroma.Repo.chunk_stream(500, :batches)
     |> Stream.each(fn users ->
       users
-      |> Enum.each(fn user -> Registration.set_confirmation(user, false) end)
+      |> Enum.each(fn user -> User.set_confirmation(user, false) end)
     end)
     |> Stream.run()
   end
@@ -462,7 +461,7 @@ defmodule Mix.Tasks.Pleroma.User do
   end
 
   defp set_confirmation(user, value) do
-    {:ok, user} = Registration.set_confirmation(user, value)
+    {:ok, user} = User.set_confirmation(user, value)
 
     shell_info("Confirmation status of #{user.nickname}: #{user.is_confirmed}")
     user
diff --git a/lib/pleroma/user.ex b/lib/pleroma/user.ex
index 710303fe3..a7c930dee 100644
--- a/lib/pleroma/user.ex
+++ b/lib/pleroma/user.ex
@@ -645,6 +645,95 @@ defmodule Pleroma.User do
   @spec force_password_reset(User.t()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
   def force_password_reset(user), do: update_password_reset_pending(user, true)
 
+  # Used to auto-register LDAP accounts which won't have a password hash stored locally
+  def register_changeset_ldap(struct, params = %{password: password})
+      when is_nil(password) do
+    params = Map.put_new(params, :accepts_chat_messages, true)
+
+    params =
+      if Map.has_key?(params, :email) do
+        Map.put_new(params, :email, params[:email])
+      else
+        params
+      end
+
+    struct
+    |> cast(params, [
+      :name,
+      :nickname,
+      :email,
+      :accepts_chat_messages
+    ])
+    |> validate_required([:name, :nickname])
+    |> unique_constraint(:nickname)
+    |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
+    |> validate_format(:nickname, local_nickname_regex())
+    |> put_ap_id()
+    |> unique_constraint(:ap_id)
+    |> put_following_and_follower_address()
+  end
+
+  def register_changeset(struct, params \\ %{}, opts \\ []) do
+    bio_limit = Config.get([:instance, :user_bio_length], 5000)
+    name_limit = Config.get([:instance, :user_name_length], 100)
+    reason_limit = Config.get([:instance, :registration_reason_length], 500)
+    params = Map.put_new(params, :accepts_chat_messages, true)
+
+    confirmed? =
+      if is_nil(opts[:confirmed]) do
+        !Config.get([:instance, :account_activation_required])
+      else
+        opts[:confirmed]
+      end
+
+    approved? =
+      if is_nil(opts[:approved]) do
+        !Config.get([:instance, :account_approval_required])
+      else
+        opts[:approved]
+      end
+
+    struct
+    |> confirmation_changeset(set_confirmation: confirmed?)
+    |> approval_changeset(set_approval: approved?)
+    |> cast(params, [
+      :bio,
+      :raw_bio,
+      :email,
+      :name,
+      :nickname,
+      :password,
+      :password_confirmation,
+      :emoji,
+      :accepts_chat_messages,
+      :registration_reason
+    ])
+    |> validate_required([:name, :nickname, :password, :password_confirmation])
+    |> validate_confirmation(:password)
+    |> unique_constraint(:email)
+    |> validate_format(:email, @email_regex)
+    |> validate_change(:email, fn :email, email ->
+      valid? =
+        Config.get([User, :email_blacklist])
+        |> Enum.all?(fn blacklisted_domain ->
+          !String.ends_with?(email, ["@" <> blacklisted_domain, "." <> blacklisted_domain])
+        end)
+
+      if valid?, do: [], else: [email: "Invalid email"]
+    end)
+    |> unique_constraint(:nickname)
+    |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
+    |> validate_format(:nickname, local_nickname_regex())
+    |> validate_length(:bio, max: bio_limit)
+    |> validate_length(:name, min: 1, max: name_limit)
+    |> validate_length(:registration_reason, max: reason_limit)
+    |> maybe_validate_required_email(opts[:external])
+    |> put_password_hash
+    |> put_ap_id()
+    |> unique_constraint(:ap_id)
+    |> put_following_and_follower_address()
+  end
+
   def maybe_validate_required_email(changeset, true), do: changeset
 
   def maybe_validate_required_email(changeset, _) do
@@ -655,6 +744,159 @@ defmodule Pleroma.User do
     end
   end
 
+  defp put_ap_id(changeset) do
+    ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
+    put_change(changeset, :ap_id, ap_id)
+  end
+
+  defp put_following_and_follower_address(changeset) do
+    followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
+
+    changeset
+    |> put_change(:follower_address, followers)
+  end
+
+  defp autofollow_users(user) do
+    candidates = Config.get([:instance, :autofollowed_nicknames])
+
+    autofollowed_users =
+      User.Query.build(%{nickname: candidates, local: true, is_active: true})
+      |> Repo.all()
+
+    follow_all(user, autofollowed_users)
+  end
+
+  defp autofollowing_users(user) do
+    candidates = Config.get([:instance, :autofollowing_nicknames])
+
+    User.Query.build(%{nickname: candidates, local: true, deactivated: false})
+    |> Repo.all()
+    |> Enum.each(&follow(&1, user, :follow_accept))
+
+    {:ok, :success}
+  end
+
+  @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
+  def register(%Ecto.Changeset{} = changeset) do
+    with {:ok, user} <- Repo.insert(changeset) do
+      post_register_action(user)
+    end
+  end
+
+  def post_register_action(%User{is_confirmed: false} = user) do
+    with {:ok, _} <- maybe_send_confirmation_email(user) do
+      {:ok, user}
+    end
+  end
+
+  def post_register_action(%User{is_approved: false} = user) do
+    with {:ok, _} <- send_user_approval_email(user),
+         {:ok, _} <- send_admin_approval_emails(user) do
+      {:ok, user}
+    end
+  end
+
+  def post_register_action(%User{is_approved: true, is_confirmed: true} = user) do
+    with {:ok, user} <- autofollow_users(user),
+         {:ok, _} <- autofollowing_users(user),
+         {:ok, user} <- set_cache(user),
+         {:ok, _} <- maybe_send_registration_email(user),
+         {:ok, _} <- maybe_send_welcome_email(user),
+         {:ok, _} <- maybe_send_welcome_message(user),
+         {:ok, _} <- maybe_send_welcome_chat_message(user) do
+      {:ok, user}
+    end
+  end
+
+  defp send_user_approval_email(user) do
+    user
+    |> Pleroma.Emails.UserEmail.approval_pending_email()
+    |> Pleroma.Emails.Mailer.deliver_async()
+
+    {:ok, :enqueued}
+  end
+
+  defp send_admin_approval_emails(user) do
+    all_superusers()
+    |> Enum.filter(fn user -> not is_nil(user.email) end)
+    |> Enum.each(fn superuser ->
+      superuser
+      |> Pleroma.Emails.AdminEmail.new_unapproved_registration(user)
+      |> Pleroma.Emails.Mailer.deliver_async()
+    end)
+
+    {:ok, :enqueued}
+  end
+
+  defp maybe_send_welcome_message(user) do
+    if User.WelcomeMessage.enabled?() do
+      User.WelcomeMessage.post_message(user)
+      {:ok, :enqueued}
+    else
+      {:ok, :noop}
+    end
+  end
+
+  defp maybe_send_welcome_chat_message(user) do
+    if User.WelcomeChatMessage.enabled?() do
+      User.WelcomeChatMessage.post_message(user)
+      {:ok, :enqueued}
+    else
+      {:ok, :noop}
+    end
+  end
+
+  defp maybe_send_welcome_email(%User{email: email} = user) when is_binary(email) do
+    if User.WelcomeEmail.enabled?() do
+      User.WelcomeEmail.send_email(user)
+      {:ok, :enqueued}
+    else
+      {:ok, :noop}
+    end
+  end
+
+  defp maybe_send_welcome_email(_), do: {:ok, :noop}
+
+  @spec maybe_send_confirmation_email(User.t()) :: {:ok, :enqueued | :noop}
+  def maybe_send_confirmation_email(%User{is_confirmed: false, email: email} = user)
+      when is_binary(email) do
+    if Config.get([:instance, :account_activation_required]) do
+      send_confirmation_email(user)
+      {:ok, :enqueued}
+    else
+      {:ok, :noop}
+    end
+  end
+
+  def maybe_send_confirmation_email(_), do: {:ok, :noop}
+
+  @spec send_confirmation_email(Uset.t()) :: User.t()
+  def send_confirmation_email(%User{} = user) do
+    user
+    |> Pleroma.Emails.UserEmail.account_confirmation_email()
+    |> Pleroma.Emails.Mailer.deliver_async()
+
+    user
+  end
+
+  @spec maybe_send_registration_email(User.t()) :: {:ok, :enqueued | :noop}
+  defp maybe_send_registration_email(%User{email: email} = user) when is_binary(email) do
+    with false <- User.WelcomeEmail.enabled?(),
+         false <- Config.get([:instance, :account_activation_required], false),
+         false <- Config.get([:instance, :account_approval_required], false) do
+      user
+      |> Pleroma.Emails.UserEmail.successful_registration_email()
+      |> Pleroma.Emails.Mailer.deliver_async()
+
+      {:ok, :enqueued}
+    else
+      _ ->
+        {:ok, :noop}
+    end
+  end
+
+  defp maybe_send_registration_email(_), do: {:ok, :noop}
+
   def needs_update?(%User{local: true}), do: false
 
   def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true
@@ -1368,6 +1610,42 @@ defmodule Pleroma.User do
     end
   end
 
+  def approve(users) when is_list(users) do
+    Repo.transaction(fn ->
+      Enum.map(users, fn user ->
+        with {:ok, user} <- approve(user), do: user
+      end)
+    end)
+  end
+
+  def approve(%User{is_approved: false} = user) do
+    with chg <- change(user, is_approved: true),
+         {:ok, user} <- update_and_set_cache(chg) do
+      post_register_action(user)
+      {:ok, user}
+    end
+  end
+
+  def approve(%User{} = user), do: {:ok, user}
+
+  def confirm(users) when is_list(users) do
+    Repo.transaction(fn ->
+      Enum.map(users, fn user ->
+        with {:ok, user} <- confirm(user), do: user
+      end)
+    end)
+  end
+
+  def confirm(%User{is_confirmed: false} = user) do
+    with chg <- confirmation_changeset(user, set_confirmation: true),
+         {:ok, user} <- update_and_set_cache(chg) do
+      post_register_action(user)
+      {:ok, user}
+    end
+  end
+
+  def confirm(%User{} = user), do: {:ok, user}
+
   def update_notification_settings(%User{} = user, settings) do
     user
     |> cast(%{notification_settings: settings}, [])
@@ -1743,7 +2021,7 @@ defmodule Pleroma.User do
     |> Enum.map(&String.downcase/1)
   end
 
-  def local_nickname_regex do
+  defp local_nickname_regex do
     if Config.get([:instance, :extended_nickname_format]) do
       @extended_local_nickname_regex
     else
@@ -1863,6 +2141,13 @@ defmodule Pleroma.User do
     updated_user
   end
 
+  @spec set_confirmation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
+  def set_confirmation(%User{} = user, bool) do
+    user
+    |> confirmation_changeset(set_confirmation: bool)
+    |> update_and_set_cache()
+  end
+
   def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
     mascot
   end
@@ -1902,11 +2187,13 @@ defmodule Pleroma.User do
     |> Repo.all()
   end
 
-  def put_password_hash(%Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset) do
+  defp put_password_hash(
+         %Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
+       ) do
     change(changeset, password_hash: Pleroma.Password.Pbkdf2.hash_pwd_salt(password))
   end
 
-  def put_password_hash(changeset), do: changeset
+  defp put_password_hash(changeset), do: changeset
 
   def is_internal_user?(%User{nickname: nil}), do: true
   def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
@@ -2024,6 +2311,29 @@ defmodule Pleroma.User do
     |> update_and_set_cache()
   end
 
+  @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
+  def confirmation_changeset(user, set_confirmation: confirmed?) do
+    params =
+      if confirmed? do
+        %{
+          is_confirmed: true,
+          confirmation_token: nil
+        }
+      else
+        %{
+          is_confirmed: false,
+          confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
+        }
+      end
+
+    cast(user, params, [:is_confirmed, :confirmation_token])
+  end
+
+  @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
+  def approval_changeset(user, set_approval: approved?) do
+    cast(user, %{is_approved: approved?}, [:is_approved])
+  end
+
   def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
     if id not in user.pinned_activities do
       max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
@@ -2164,6 +2474,4 @@ defmodule Pleroma.User do
     |> where([u], u.local == true)
     |> Repo.aggregate(:count)
   end
-
-  def email_regex, do: @email_regex
 end
diff --git a/lib/pleroma/user/registration.ex b/lib/pleroma/user/registration.ex
deleted file mode 100644
index 45a9efbcf..000000000
--- a/lib/pleroma/user/registration.ex
+++ /dev/null
@@ -1,321 +0,0 @@
-defmodule Pleroma.User.Registration do
-  alias Pleroma.Config
-  alias Pleroma.Emails.AdminEmail
-  alias Pleroma.Emails.Mailer
-  alias Pleroma.Emails.UserEmail
-  alias Pleroma.Repo
-  alias Pleroma.User
-  alias Pleroma.User.WelcomeChatMessage
-  alias Pleroma.User.WelcomeEmail
-  alias Pleroma.User.WelcomeMessage
-
-  import Ecto.Changeset
-
-  @doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
-  def register(%Ecto.Changeset{} = changeset) do
-    with {:ok, user} <- Repo.insert(changeset) do
-      post_register_action(user)
-    end
-  end
-
-  def post_register_action(%User{is_confirmed: false} = user) do
-    with {:ok, _} <- maybe_send_confirmation_email(user) do
-      {:ok, user}
-    end
-  end
-
-  def post_register_action(%User{is_approved: false} = user) do
-    with {:ok, _} <- send_user_approval_email(user),
-         {:ok, _} <- send_admin_approval_emails(user) do
-      {:ok, user}
-    end
-  end
-
-  def post_register_action(%User{is_approved: true, is_confirmed: true} = user) do
-    with {:ok, user} <- autofollow_users(user),
-         {:ok, _} <- autofollowing_users(user),
-         {:ok, user} <- User.set_cache(user),
-         {:ok, _} <- maybe_send_registration_email(user),
-         {:ok, _} <- maybe_send_welcome_email(user),
-         {:ok, _} <- maybe_send_welcome_message(user),
-         {:ok, _} <- maybe_send_welcome_chat_message(user) do
-      {:ok, user}
-    end
-  end
-
-  defp send_user_approval_email(user) do
-    user
-    |> UserEmail.approval_pending_email()
-    |> Mailer.deliver_async()
-
-    {:ok, :enqueued}
-  end
-
-  defp send_admin_approval_emails(user) do
-    User.all_superusers()
-    |> Enum.filter(fn user -> not is_nil(user.email) end)
-    |> Enum.each(fn superuser ->
-      superuser
-      |> AdminEmail.new_unapproved_registration(user)
-      |> Mailer.deliver_async()
-    end)
-
-    {:ok, :enqueued}
-  end
-
-  defp maybe_send_welcome_message(user) do
-    if WelcomeMessage.enabled?() do
-      WelcomeMessage.post_message(user)
-      {:ok, :enqueued}
-    else
-      {:ok, :noop}
-    end
-  end
-
-  defp maybe_send_welcome_chat_message(user) do
-    if WelcomeChatMessage.enabled?() do
-      WelcomeChatMessage.post_message(user)
-      {:ok, :enqueued}
-    else
-      {:ok, :noop}
-    end
-  end
-
-  defp maybe_send_welcome_email(%User{email: email} = user) when is_binary(email) do
-    if WelcomeEmail.enabled?() do
-      WelcomeEmail.send_email(user)
-      {:ok, :enqueued}
-    else
-      {:ok, :noop}
-    end
-  end
-
-  defp maybe_send_welcome_email(_), do: {:ok, :noop}
-
-  @spec maybe_send_confirmation_email(User.t()) :: {:ok, :enqueued | :noop}
-  def maybe_send_confirmation_email(%User{is_confirmed: false, email: email} = user)
-      when is_binary(email) do
-    if Config.get([:instance, :account_activation_required]) do
-      send_confirmation_email(user)
-      {:ok, :enqueued}
-    else
-      {:ok, :noop}
-    end
-  end
-
-  def maybe_send_confirmation_email(_), do: {:ok, :noop}
-
-  @spec send_confirmation_email(User.t()) :: User.t()
-  def send_confirmation_email(%User{} = user) do
-    user
-    |> UserEmail.account_confirmation_email()
-    |> Mailer.deliver_async()
-
-    user
-  end
-
-  @spec maybe_send_registration_email(User.t()) :: {:ok, :enqueued | :noop}
-  defp maybe_send_registration_email(%User{email: email} = user) when is_binary(email) do
-    with false <- WelcomeEmail.enabled?(),
-         false <- Config.get([:instance, :account_activation_required], false),
-         false <- Config.get([:instance, :account_approval_required], false) do
-      user
-      |> UserEmail.successful_registration_email()
-      |> Mailer.deliver_async()
-
-      {:ok, :enqueued}
-    else
-      _ ->
-        {:ok, :noop}
-    end
-  end
-
-  defp maybe_send_registration_email(_), do: {:ok, :noop}
-
-  def approve(users) when is_list(users) do
-    Repo.transaction(fn ->
-      Enum.map(users, fn user ->
-        with {:ok, user} <- approve(user), do: user
-      end)
-    end)
-  end
-
-  def approve(%User{is_approved: false} = user) do
-    with chg <- change(user, is_approved: true),
-         {:ok, user} <- User.update_and_set_cache(chg) do
-      post_register_action(user)
-      {:ok, user}
-    end
-  end
-
-  def approve(%User{} = user), do: {:ok, user}
-
-  def confirm(users) when is_list(users) do
-    Repo.transaction(fn ->
-      Enum.map(users, fn user ->
-        with {:ok, user} <- confirm(user), do: user
-      end)
-    end)
-  end
-
-  def confirm(%User{is_confirmed: false} = user) do
-    with chg <- confirmation_changeset(user, set_confirmation: true),
-         {:ok, user} <- User.update_and_set_cache(chg) do
-      post_register_action(user)
-      {:ok, user}
-    end
-  end
-
-  def confirm(%User{} = user), do: {:ok, user}
-
-  # Used to auto-register LDAP accounts which won't have a password hash stored locally
-  def register_changeset_ldap(struct, params = %{password: password})
-      when is_nil(password) do
-    params = Map.put_new(params, :accepts_chat_messages, true)
-
-    params =
-      if Map.has_key?(params, :email) do
-        Map.put_new(params, :email, params[:email])
-      else
-        params
-      end
-
-    struct
-    |> cast(params, [
-      :name,
-      :nickname,
-      :email,
-      :accepts_chat_messages
-    ])
-    |> validate_required([:name, :nickname])
-    |> unique_constraint(:nickname)
-    |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
-    |> validate_format(:nickname, User.local_nickname_regex())
-    |> put_ap_id()
-    |> unique_constraint(:ap_id)
-    |> put_following_and_follower_address()
-  end
-
-  def register_changeset(struct, params \\ %{}, opts \\ []) do
-    bio_limit = Config.get([:instance, :user_bio_length], 5000)
-    name_limit = Config.get([:instance, :user_name_length], 100)
-    reason_limit = Config.get([:instance, :registration_reason_length], 500)
-    params = Map.put_new(params, :accepts_chat_messages, true)
-
-    confirmed? =
-      if is_nil(opts[:confirmed]) do
-        !Config.get([:instance, :account_activation_required])
-      else
-        opts[:confirmed]
-      end
-
-    approved? =
-      if is_nil(opts[:approved]) do
-        !Config.get([:instance, :account_approval_required])
-      else
-        opts[:approved]
-      end
-
-    struct
-    |> confirmation_changeset(set_confirmation: confirmed?)
-    |> approval_changeset(set_approval: approved?)
-    |> cast(params, [
-      :bio,
-      :raw_bio,
-      :email,
-      :name,
-      :nickname,
-      :password,
-      :password_confirmation,
-      :emoji,
-      :accepts_chat_messages,
-      :registration_reason
-    ])
-    |> validate_required([:name, :nickname, :password, :password_confirmation])
-    |> validate_confirmation(:password)
-    |> unique_constraint(:email)
-    |> validate_format(:email, User.email_regex())
-    |> validate_change(:email, fn :email, email ->
-      valid? =
-        Config.get([User, :email_blacklist])
-        |> Enum.all?(fn blacklisted_domain ->
-          !String.ends_with?(email, ["@" <> blacklisted_domain, "." <> blacklisted_domain])
-        end)
-
-      if valid?, do: [], else: [email: "Invalid email"]
-    end)
-    |> unique_constraint(:nickname)
-    |> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
-    |> validate_format(:nickname, User.local_nickname_regex())
-    |> validate_length(:bio, max: bio_limit)
-    |> validate_length(:name, min: 1, max: name_limit)
-    |> validate_length(:registration_reason, max: reason_limit)
-    |> User.maybe_validate_required_email(opts[:external])
-    |> User.put_password_hash()
-    |> put_ap_id()
-    |> unique_constraint(:ap_id)
-    |> put_following_and_follower_address()
-  end
-
-  @spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
-  def confirmation_changeset(user, set_confirmation: confirmed?) do
-    params =
-      if confirmed? do
-        %{
-          is_confirmed: true,
-          confirmation_token: nil
-        }
-      else
-        %{
-          is_confirmed: false,
-          confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
-        }
-      end
-
-    cast(user, params, [:is_confirmed, :confirmation_token])
-  end
-
-  @spec approval_changeset(User.t(), keyword()) :: Changeset.t()
-  def approval_changeset(user, set_approval: approved?) do
-    cast(user, %{is_approved: approved?}, [:is_approved])
-  end
-
-  @spec set_confirmation(User.t(), boolean()) :: {:ok, User.t()} | {:error, Changeset.t()}
-  def set_confirmation(%User{} = user, bool) do
-    user
-    |> confirmation_changeset(set_confirmation: bool)
-    |> User.update_and_set_cache()
-  end
-
-  defp put_ap_id(changeset) do
-    ap_id = User.ap_id(%User{nickname: get_field(changeset, :nickname)})
-    put_change(changeset, :ap_id, ap_id)
-  end
-
-  defp put_following_and_follower_address(changeset) do
-    followers = User.ap_followers(%User{nickname: get_field(changeset, :nickname)})
-
-    changeset
-    |> put_change(:follower_address, followers)
-  end
-
-  defp autofollow_users(user) do
-    candidates = Config.get([:instance, :autofollowed_nicknames])
-
-    autofollowed_users =
-      User.Query.build(%{nickname: candidates, local: true, is_active: true})
-      |> Repo.all()
-
-    User.follow_all(user, autofollowed_users)
-  end
-
-  defp autofollowing_users(user) do
-    candidates = Config.get([:instance, :autofollowing_nicknames])
-
-    User.Query.build(%{nickname: candidates, local: true, deactivated: false})
-    |> Repo.all()
-    |> Enum.each(&User.follow(&1, user, :follow_accept))
-
-    {:ok, :success}
-  end
-end
diff --git a/lib/pleroma/web/admin_api/controllers/admin_api_controller.ex b/lib/pleroma/web/admin_api/controllers/admin_api_controller.ex
index ef1058123..839ac1a8d 100644
--- a/lib/pleroma/web/admin_api/controllers/admin_api_controller.ex
+++ b/lib/pleroma/web/admin_api/controllers/admin_api_controller.ex
@@ -419,7 +419,7 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIController do
   def confirm_email(%{assigns: %{user: admin}} = conn, %{"nicknames" => nicknames}) do
     users = Enum.map(nicknames, &User.get_cached_by_nickname/1)
 
-    User.Registration.confirm(users)
+    User.confirm(users)
 
     ModerationLog.insert_log(%{actor: admin, subject: users, action: "confirm_email"})
 
@@ -431,7 +431,7 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIController do
       Enum.map(nicknames, fn nickname ->
         nickname
         |> User.get_cached_by_nickname()
-        |> User.Registration.send_confirmation_email()
+        |> User.send_confirmation_email()
       end)
 
     ModerationLog.insert_log(%{actor: admin, subject: users, action: "resend_confirmation_email"})
diff --git a/lib/pleroma/web/admin_api/controllers/user_controller.ex b/lib/pleroma/web/admin_api/controllers/user_controller.ex
index 9d3b32f39..65bc63cb9 100644
--- a/lib/pleroma/web/admin_api/controllers/user_controller.ex
+++ b/lib/pleroma/web/admin_api/controllers/user_controller.ex
@@ -117,7 +117,7 @@ defmodule Pleroma.Web.AdminAPI.UserController do
           bio: "."
         }
 
-        User.Registration.register_changeset(%User{}, user_data, need_confirmation: false)
+        User.register_changeset(%User{}, user_data, need_confirmation: false)
       end)
       |> Enum.reduce(Ecto.Multi.new(), fn changeset, multi ->
         Ecto.Multi.insert(multi, Ecto.UUID.generate(), changeset)
@@ -129,7 +129,7 @@ defmodule Pleroma.Web.AdminAPI.UserController do
           users
           |> Map.values()
           |> Enum.map(fn user ->
-            {:ok, user} = User.Registration.post_register_action(user)
+            {:ok, user} = User.post_register_action(user)
 
             user
           end)
@@ -219,7 +219,7 @@ defmodule Pleroma.Web.AdminAPI.UserController do
 
   def approve(%{assigns: %{user: admin}} = conn, %{"nicknames" => nicknames}) do
     users = Enum.map(nicknames, &User.get_cached_by_nickname/1)
-    {:ok, updated_users} = User.Registration.approve(users)
+    {:ok, updated_users} = User.approve(users)
 
     ModerationLog.insert_log(%{
       actor: admin,
diff --git a/lib/pleroma/web/auth/ldap_authenticator.ex b/lib/pleroma/web/auth/ldap_authenticator.ex
index d0513263c..17e08a2a6 100644
--- a/lib/pleroma/web/auth/ldap_authenticator.ex
+++ b/lib/pleroma/web/auth/ldap_authenticator.ex
@@ -4,7 +4,6 @@
 
 defmodule Pleroma.Web.Auth.LDAPAuthenticator do
   alias Pleroma.User
-  alias Pleroma.User.Registration
 
   require Logger
 
@@ -117,9 +116,9 @@ defmodule Pleroma.Web.Auth.LDAPAuthenticator do
             _ -> params
           end
 
-        changeset = Registration.register_changeset_ldap(%User{}, params)
+        changeset = User.register_changeset_ldap(%User{}, params)
 
-        case Registration.register(changeset) do
+        case User.register(changeset) do
           {:ok, user} -> user
           error -> error
         end
diff --git a/lib/pleroma/web/auth/pleroma_authenticator.ex b/lib/pleroma/web/auth/pleroma_authenticator.ex
index ff7dd7034..401f23c9f 100644
--- a/lib/pleroma/web/auth/pleroma_authenticator.ex
+++ b/lib/pleroma/web/auth/pleroma_authenticator.ex
@@ -73,7 +73,7 @@ defmodule Pleroma.Web.Auth.PleromaAuthenticator do
     random_password = :crypto.strong_rand_bytes(64) |> Base.encode64()
 
     with {:ok, new_user} <-
-           User.Registration.register_changeset(
+           User.register_changeset(
              %User{},
              %{
                email: email,
diff --git a/lib/pleroma/web/pleroma_api/controllers/account_controller.ex b/lib/pleroma/web/pleroma_api/controllers/account_controller.ex
index 518d7d542..6e01c5497 100644
--- a/lib/pleroma/web/pleroma_api/controllers/account_controller.ex
+++ b/lib/pleroma/web/pleroma_api/controllers/account_controller.ex
@@ -55,7 +55,7 @@ defmodule Pleroma.Web.PleromaAPI.AccountController do
     nickname_or_email = params[:email] || params[:nickname]
 
     with %User{} = user <- User.get_by_nickname_or_email(nickname_or_email),
-         {:ok, _} <- User.Registration.maybe_send_confirmation_email(user) do
+         {:ok, _} <- User.maybe_send_confirmation_email(user) do
       json_response(conn, :no_content, "")
     end
   end
diff --git a/lib/pleroma/web/twitter_api/controller.ex b/lib/pleroma/web/twitter_api/controller.ex
index 852af9d30..077bfa70d 100644
--- a/lib/pleroma/web/twitter_api/controller.ex
+++ b/lib/pleroma/web/twitter_api/controller.ex
@@ -31,7 +31,7 @@ defmodule Pleroma.Web.TwitterAPI.Controller do
   def confirm_email(conn, %{"user_id" => uid, "token" => token}) do
     with %User{} = user <- User.get_cached_by_id(uid),
          true <- user.local and !user.is_confirmed and user.confirmation_token == token,
-         {:ok, _} <- User.Registration.confirm(user) do
+         {:ok, _} <- User.confirm(user) do
       redirect(conn, to: "/")
     end
   end
diff --git a/lib/pleroma/web/twitter_api/twitter_api.ex b/lib/pleroma/web/twitter_api/twitter_api.ex
index c581fc622..76ca82d20 100644
--- a/lib/pleroma/web/twitter_api/twitter_api.ex
+++ b/lib/pleroma/web/twitter_api/twitter_api.ex
@@ -41,9 +41,9 @@ defmodule Pleroma.Web.TwitterAPI.TwitterAPI do
   end
 
   defp create_user(params, opts) do
-    changeset = User.Registration.register_changeset(%User{}, params, opts)
+    changeset = User.register_changeset(%User{}, params, opts)
 
-    case User.Registration.register(changeset) do
+    case User.register(changeset) do
       {:ok, user} ->
         {:ok, user}