Skip to content

PostgreSQL backup tool with Point-In-Time-Recovery and restore verification

33.3 KB
Raw Blame
package users_services

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"log/slog"
	"net/http"
	"time"
	"unicode/utf8"

	"github.com/golang-jwt/jwt/v4"
	"github.com/google/uuid"
	"github.com/jackc/pgx/v5/pgconn"
	"golang.org/x/crypto/bcrypt"
	"golang.org/x/oauth2"
	"golang.org/x/oauth2/github"
	"golang.org/x/oauth2/google"

	"databasus-backend/internal/config"
	audit_logs_models "databasus-backend/internal/features/audit_logs/models"
	"databasus-backend/internal/features/encryption/secrets"
	users_dto "databasus-backend/internal/features/users/dto"
	users_enums "databasus-backend/internal/features/users/enums"
	users_errors "databasus-backend/internal/features/users/errors"
	users_interfaces "databasus-backend/internal/features/users/interfaces"
	users_models "databasus-backend/internal/features/users/models"
	users_repositories "databasus-backend/internal/features/users/repositories"
	"databasus-backend/internal/util/ratelimiter"
)

// bootstrapAdminIndexName is the partial unique index that admits a single
// bootstrap administrator. Naming it is what lets a lost race be told apart from
// a duplicate address, which must keep failing as it always has.
const bootstrapAdminIndexName = "idx_users_is_root_admin"

type UserService struct {
	userRepository          *users_repositories.UserRepository
	secretKeyService        *secrets.SecretKeyService
	settingsService         *SettingsService
	auditLogWriter          users_interfaces.AuditLogWriter
	emailSender             users_interfaces.EmailSender
	passwordResetRepository *users_repositories.PasswordResetRepository
	twoFactorRepository     *users_repositories.TwoFactorRepository
	rateLimiter             ratelimiter.Counter
	logger                  *slog.Logger
}

func (s *UserService) SetAuditLogWriter(writer users_interfaces.AuditLogWriter) {
	s.auditLogWriter = writer
}

func (s *UserService) SetEmailSender(sender users_interfaces.EmailSender) {
	s.emailSender = sender
}

func (s *UserService) SignUp(ctx context.Context, request *users_dto.SignUpRequestDTO) (*users_models.User, error) {
	existingUser, err := s.userRepository.GetUserByEmail(ctx, request.Email)
	if err != nil {
		return nil, fmt.Errorf("failed to check existing user: %w", err)
	}

	if existingUser != nil && existingUser.Status != users_enums.UserStatusInvited {
		return nil, errors.New("user with this email already exists")
	}

	hashedPassword, err := bcrypt.GenerateFromPassword([]byte(request.Password), bcrypt.DefaultCost)
	if err != nil {
		return nil, fmt.Errorf("failed to hash password: %w", err)
	}

	hashedPasswordStr := string(hashedPassword)

	// If user exists with INVITED status, activate them and set password
	if existingUser != nil && existingUser.Status == users_enums.UserStatusInvited {
		if err := s.userRepository.UpdateUserPassword(
			existingUser.ID,
			hashedPasswordStr,
		); err != nil {
			return nil, fmt.Errorf("failed to set password: %w", err)
		}

		if err := s.userRepository.UpdateUserStatus(
			existingUser.ID,
			users_enums.UserStatusActive,
		); err != nil {
			return nil, fmt.Errorf("failed to activate user: %w", err)
		}

		name := request.Name
		if err := s.userRepository.UpdateUserInfo(existingUser.ID, &name, nil); err != nil {
			return nil, fmt.Errorf("failed to update name: %w", err)
		}

		// Fetch updated user to ensure we have the latest data
		updatedUser, err := s.userRepository.GetUserByID(ctx, existingUser.ID)
		if err != nil {
			return nil, fmt.Errorf("failed to get updated user: %w", err)
		}

		s.writeAuditLog(ctx, audit_logs_models.AuditEntry{
			Message:     fmt.Sprintf("Invited user completed registration: %s", updatedUser.Email),
			UserID:      &updatedUser.ID,
			WorkspaceID: nil,
		})

		return updatedUser, nil
	}

	user, err := s.createAccountClaimingEmptyInstance(
		ctx,
		s.checkExternalRegistrationAllowed,
		func(isTakingTheInstance bool) *users_models.User {
			return buildRegisteredUser(request, hashedPasswordStr, isTakingTheInstance)
		},
	)
	if err != nil {
		return nil, err
	}

	s.writeAuditLog(ctx, audit_logs_models.AuditEntry{
		Message:     fmt.Sprintf("User registered with email: %s", user.Email),
		UserID:      &user.ID,
		WorkspaceID: nil,
	})

	s.writeInstanceClaimedAuditLog(ctx, user)

	return user, nil
}

// Counted in runes, as the min=8 binding on the request DTOs counts them.
func isPasswordLongEnough(password string) bool {
	return utf8.RuneCountInString(password) >= users_models.MinPasswordLength
}

func isBootstrapAdminTaken(err error) bool {
	var pgError *pgconn.PgError

	return errors.As(err, &pgError) && pgError.ConstraintName == bootstrapAdminIndexName
}

func (s *UserService) SignIn(
	ctx context.Context,
	request *users_dto.SignInRequestDTO,
) (*users_dto.SignInOutcome, error) {
	// Failed sign-ins are the only signal that someone is guessing credentials, so every branch that
	// refuses one is logged. The handler's addresses are masked centrally by the log handler.
	user, err := s.userRepository.GetUserByEmail(ctx, request.Email)
	if err != nil {
		s.logger.WarnContext(ctx, "sign-in refused: email lookup failed", "email", request.Email, "error", err)

		return nil, errors.New("user with this email does not exist")
	}

	if user == nil {
		s.logger.WarnContext(ctx, "sign-in refused: no user with this email", "email", request.Email)

		return nil, errors.New("user with this email does not exist")
	}

	if user.Status == users_enums.UserStatusInvited {
		s.logger.WarnContext(ctx, "sign-in refused: the account has not completed sign-up",
			"user_id", user.ID)

		return nil, errors.New("user account is not passed sign up yet")
	}

	if user.Status != users_enums.UserStatusActive {
		s.logger.WarnContext(ctx, "sign-in refused: the account is deactivated", "user_id", user.ID)

		return nil, errors.New("user account is deactivated")
	}

	// An account created through an external identity provider has no password
	// hash at all. Refuse it the way a wrong password is refused, rather than
	// dereferencing nil and taking the process down.
	if !user.HasPassword() {
		s.logger.WarnContext(ctx, "sign-in refused: the account has no password", "user_id", user.ID)

		return nil, errors.New("password is incorrect")
	}

	err = bcrypt.CompareHashAndPassword([]byte(*user.HashedPassword), []byte(request.Password))
	if err != nil {
		s.logger.WarnContext(ctx, "sign-in refused: incorrect password", "user_id", user.ID)

		return nil, errors.New("password is incorrect")
	}

	settings, err := s.settingsService.GetSettings(ctx)
	if err != nil {
		return nil, fmt.Errorf("failed to get settings: %w", err)
	}

	if settings.IsTwoFactorAuthRequired {
		pendingSignIn, err := s.StartTwoFactorSignIn(ctx, user)
		if err != nil {
			return nil, err
		}

		return &users_dto.SignInOutcome{PendingSignIn: pendingSignIn}, nil
	}

	response, err := s.completeSignIn(ctx, user)
	if err != nil {
		return nil, err
	}

	return &users_dto.SignInOutcome{CompletedSignIn: response}, nil
}

func (s *UserService) GetUserFromToken(ctx context.Context, token string) (*users_models.User, error) {
	secretKey, err := s.secretKeyService.GetSecretKey()
	if err != nil {
		return nil, fmt.Errorf("failed to get secret key: %w", err)
	}

	parsedToken, err := jwt.Parse(token, func(token *jwt.Token) (any, error) {
		if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
			return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
		}
		return []byte(secretKey), nil
	})
	if err != nil {
		return nil, fmt.Errorf("invalid token: %w", err)
	}

	if claims, ok := parsedToken.Claims.(jwt.MapClaims); ok && parsedToken.Valid {
		userIDStr, ok := claims["sub"].(string)
		if !ok {
			return nil, errors.New("invalid token claims")
		}

		userID, err := uuid.Parse(userIDStr)
		if err != nil {
			return nil, errors.New("invalid token claims")
		}

		user, err := s.userRepository.GetUserByID(ctx, userID)
		if err != nil {
			return nil, err
		}

		// Check if user is active
		if !user.IsActiveUser() {
			return nil, errors.New("user account is deactivated")
		}

		if passwordCreationTimeUnix, ok := claims["passwordCreationTime"].(float64); ok {
			tokenPasswordTime := time.Unix(int64(passwordCreationTimeUnix), 0)

			tokenTimeSeconds := tokenPasswordTime.Truncate(time.Second)
			userTimeSeconds := user.PasswordCreationTime.Truncate(time.Second)

			if !tokenTimeSeconds.Equal(userTimeSeconds) {
				return nil, errors.New("password has been changed, please sign in again")
			}
		} else {
			return nil, errors.New("invalid token claims: missing password creation time")
		}

		return user, nil
	}

	return nil, errors.New("invalid token")
}

func (s *UserService) GenerateAccessToken(
	ctx context.Context,
	user *users_models.User,
) (*users_dto.SignInResponseDTO, error) {
	secretKey, err := s.secretKeyService.GetSecretKey()
	if err != nil {
		return nil, fmt.Errorf("failed to get secret key: %w", err)
	}

	tenYearsExpiration := time.Now().UTC().Add(time.Hour * 24 * 365 * 10)

	token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
		"sub":                  user.ID.String(),
		"exp":                  tenYearsExpiration.Unix(),
		"iat":                  time.Now().UTC().Unix(),
		"role":                 string(user.Role),
		"passwordCreationTime": user.PasswordCreationTime.Unix(),
	})

	tokenString, err := token.SignedString([]byte(secretKey))
	if err != nil {
		return nil, fmt.Errorf("failed to generate token: %w", err)
	}

	return &users_dto.SignInResponseDTO{
		UserID: user.ID,
		Email:  user.Email,
		Token:  tokenString,
	}, nil
}

func (s *UserService) GetUsersCount() (int64, error) {
	return s.userRepository.GetUsersCount()
}

// The entry screen asks this to decide between offering a sign-in and offering
// the registration that claims the instance.
func (s *UserService) HasAnyUser() (bool, error) {
	isUnclaimed, err := s.isInstanceUnclaimed()
	if err != nil {
		return false, err
	}

	return !isUnclaimed, nil
}

func (s *UserService) ChangeUserPasswordByEmail(ctx context.Context, email, newPassword string) error {
	user, err := s.userRepository.GetUserByEmail(ctx, email)
	if err != nil {
		return fmt.Errorf("failed to get user: %w", err)
	}

	if user == nil {
		return errors.New("user with this email does not exist")
	}

	return s.ChangeUserPassword(ctx, user.ID, newPassword)
}

func (s *UserService) ChangeUserPassword(ctx context.Context, userID uuid.UUID, newPassword string) error {
	if !isPasswordLongEnough(newPassword) {
		return users_errors.ErrPasswordTooShort
	}

	hashedPassword, err := bcrypt.GenerateFromPassword([]byte(newPassword), bcrypt.DefaultCost)
	if err != nil {
		return fmt.Errorf("failed to hash new password: %w", err)
	}

	if err := s.userRepository.UpdateUserPassword(userID, string(hashedPassword)); err != nil {
		return fmt.Errorf("failed to update password: %w", err)
	}

	s.writeAuditLog(ctx, audit_logs_models.AuditEntry{
		Message:     "Password changed",
		UserID:      &userID,
		WorkspaceID: nil,
	})

	return nil
}

func (s *UserService) InviteUser(
	ctx context.Context,
	request *users_dto.InviteUserRequestDTO,
	invitedBy *users_models.User,
) (*users_dto.InviteUserResponseDTO, error) {
	// Get settings to check permissions
	settings, err := s.settingsService.GetSettings(ctx)
	if err != nil {
		return nil, fmt.Errorf("failed to get settings: %w", err)
	}

	// Check if user has permission to invite
	if !invitedBy.CanInviteUsers(settings) {
		return nil, users_errors.ErrInsufficientPermissionsToInviteUsers
	}

	// Check if user already exists
	existingUser, err := s.userRepository.GetUserByEmail(ctx, request.Email)
	if err != nil {
		return nil, fmt.Errorf("failed to check existing user: %w", err)
	}
	if existingUser != nil {
		return nil, errors.New("user with this email already exists")
	}

	user := &users_models.User{
		ID:                   uuid.New(),
		Email:                request.Email,
		Name:                 "User",
		HashedPassword:       nil,
		PasswordCreationTime: time.Now().UTC(),
		Role:                 users_enums.UserRoleMember,
		Status:               users_enums.UserStatusInvited,
		CreatedAt:            time.Now().UTC(),
	}

	if err := s.userRepository.CreateUser(user); err != nil {
		return nil, fmt.Errorf("failed to create invited user: %w", err)
	}

	message := fmt.Sprintf("User invited: %s", request.Email)
	if request.IntendedWorkspaceID != nil {
		message += " for workspace"
	}
	s.writeAuditLog(ctx, audit_logs_models.AuditEntry{
		Message:     message,
		UserID:      &invitedBy.ID,
		WorkspaceID: request.IntendedWorkspaceID,
	})

	return &users_dto.InviteUserResponseDTO{
		ID:                    user.ID,
		Email:                 user.Email,
		IntendedWorkspaceID:   request.IntendedWorkspaceID,
		IntendedWorkspaceRole: request.IntendedWorkspaceRole,
		CreatedAt:             user.CreatedAt,
	}, nil
}

func (s *UserService) GetUserByID(ctx context.Context, userID uuid.UUID) (*users_models.User, error) {
	return s.userRepository.GetUserByID(ctx, userID)
}

func (s *UserService) GetUserByEmail(ctx context.Context, email string) (*users_models.User, error) {
	return s.userRepository.GetUserByEmail(ctx, email)
}

func (s *UserService) GetCurrentUserProfile(
	ctx context.Context,
	user *users_models.User,
) *users_dto.UserProfileResponseDTO {
	return &users_dto.UserProfileResponseDTO{
		ID:        user.ID,
		Email:     user.Email,
		Name:      user.Name,
		Role:      user.Role,
		IsActive:  user.IsActiveUser(),
		CreatedAt: user.CreatedAt,
	}
}

func (s *UserService) UpdateUserInfo(
	ctx context.Context,
	userID uuid.UUID,
	request *users_dto.UpdateUserInfoRequestDTO,
) error {
	user, err := s.userRepository.GetUserByID(ctx, userID)
	if err != nil {
		return fmt.Errorf("failed to get user: %w", err)
	}

	oldEmail := user.Email
	oldName := user.Name

	if request.Email != nil && *request.Email != user.Email {
		existingUser, err := s.userRepository.GetUserByEmail(ctx, *request.Email)
		if err != nil {
			return fmt.Errorf("failed to check email: %w", err)
		}
		if existingUser != nil {
			return errors.New("email is already taken by another user")
		}
	}

	if err := s.userRepository.UpdateUserInfo(userID, request.Name, request.Email); err != nil {
		return fmt.Errorf("failed to update user info: %w", err)
	}

	var auditMessages []string
	if request.Email != nil && *request.Email != oldEmail {
		auditMessages = append(
			auditMessages,
			fmt.Sprintf("Email changed from '%s' to '%s'", oldEmail, *request.Email),
		)
	}
	if request.Name != nil && *request.Name != oldName {
		auditMessages = append(
			auditMessages,
			fmt.Sprintf("Name changed from '%s' to '%s'", oldName, *request.Name),
		)
	}

	if len(auditMessages) > 0 {
		for _, message := range auditMessages {
			s.writeAuditLog(ctx, audit_logs_models.AuditEntry{
				Message:     message,
				UserID:      &userID,
				WorkspaceID: nil,
			})
		}
	} else {
		s.writeAuditLog(ctx, audit_logs_models.AuditEntry{
			Message:     "User info updated",
			UserID:      &userID,
			WorkspaceID: nil,
		})
	}

	return nil
}

func (s *UserService) HandleGitHubOAuth(
	ctx context.Context,
	code, redirectUri string,
) (*users_dto.OAuthCallbackResponseDTO, error) {
	return s.handleGitHubOAuthWithEndpoint(
		ctx,
		code,
		redirectUri,
		github.Endpoint,
		"https://api.github.com/user",
	)
}

func (s *UserService) HandleGoogleOAuth(
	ctx context.Context,
	code, redirectUri string,
) (*users_dto.OAuthCallbackResponseDTO, error) {
	return s.handleGoogleOAuthWithEndpoint(
		ctx,
		code,
		redirectUri,
		google.Endpoint,
		"https://www.googleapis.com/oauth2/v2/userinfo",
	)
}

func (s *UserService) SendResetPasswordCode(ctx context.Context, email string) error {
	user, err := s.userRepository.GetUserByEmail(ctx, email)
	if err != nil {
		return fmt.Errorf("failed to get user: %w", err)
	}

	// Silently succeed for non-existent users to prevent enumeration attacks
	if user == nil {
		return nil
	}

	// Only active users can reset passwords
	if user.Status != users_enums.UserStatusActive {
		return errors.New("only active users can reset their password")
	}

	// Check rate limiting - max 3 codes per hour
	oneHourAgo := time.Now().UTC().Add(-1 * time.Hour)
	recentCount, err := s.passwordResetRepository.CountRecentCodesByUserID(user.ID, oneHourAgo)
	if err != nil {
		return fmt.Errorf("failed to check rate limit: %w", err)
	}

	if recentCount >= 3 {
		return errors.New("too many password reset attempts, please try again later")
	}

	code, err := generateSixDigitCode()
	if err != nil {
		return err
	}

	hashedCode, err := bcrypt.GenerateFromPassword([]byte(code), bcrypt.DefaultCost)
	if err != nil {
		return fmt.Errorf("failed to hash code: %w", err)
	}

	// Store in database with 1 hour expiration
	resetCode := &users_models.PasswordResetCode{
		ID:         uuid.New(),
		UserID:     user.ID,
		HashedCode: string(hashedCode),
		ExpiresAt:  time.Now().UTC().Add(1 * time.Hour),
		IsUsed:     false,
		CreatedAt:  time.Now().UTC(),
	}

	if err := s.passwordResetRepository.CreateResetCode(resetCode); err != nil {
		return fmt.Errorf("failed to create reset code: %w", err)
	}

	// Send email with code
	if s.emailSender != nil {
		subject := "Password Reset Code"
		body := fmt.Sprintf(`
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
</head>
<body style="margin: 0; padding: 0; font-family: Arial, sans-serif; background-color: #f4f4f4;">
    <div style="max-width: 600px; margin: 0 auto; background-color: #ffffff; padding: 20px;">
        <h2 style="color: #333333; margin-bottom: 20px;">Password Reset Request</h2>
        <p style="color: #666666; line-height: 1.6; margin-bottom: 20px;">
            You have requested to reset your password. Please use the following code to complete the password reset process:
        </p>
        <div style="background-color: #f8f9fa; border: 2px solid #e9ecef; border-radius: 8px; padding: 20px; text-align: center; margin: 30px 0;">
            <h1 style="color: #2c3e50; font-size: 36px; margin: 0; letter-spacing: 8px; font-family: monospace;">%s</h1>
        </div>
        <p style="color: #666666; line-height: 1.6; margin-bottom: 20px;">
            This code will expire in <strong>1 hour</strong>.
        </p>
        <p style="color: #666666; line-height: 1.6; margin-bottom: 20px;">
            If you did not request a password reset, please ignore this email. Your password will remain unchanged.
        </p>
        <hr style="border: none; border-top: 1px solid #e9ecef; margin: 30px 0;">
        <p style="color: #999999; font-size: 12px; line-height: 1.6;">
            This is an automated message. Please do not reply to this email.
        </p>
    </div>
</body>
</html>
`, code)

		if err := s.emailSender.SendEmail(ctx, user.Email, subject, body); err != nil {
			return fmt.Errorf("failed to send email: %w", err)
		}
	}

	// Audit log
	s.writeAuditLog(ctx, audit_logs_models.AuditEntry{
		Message:     fmt.Sprintf("Password reset code sent to: %s", user.Email),
		UserID:      &user.ID,
		WorkspaceID: nil,
	})

	return nil
}

func (s *UserService) ResetPassword(ctx context.Context, email, code, newPassword string) error {
	user, err := s.userRepository.GetUserByEmail(ctx, email)
	if err != nil {
		return fmt.Errorf("failed to get user: %w", err)
	}

	if user == nil {
		return errors.New("user with this email does not exist")
	}

	// Get valid reset code for user
	resetCode, err := s.passwordResetRepository.GetValidCodeByUserID(user.ID)
	if err != nil {
		return errors.New("invalid or expired reset code")
	}

	// Verify code matches
	err = bcrypt.CompareHashAndPassword([]byte(resetCode.HashedCode), []byte(code))
	if err != nil {
		return errors.New("invalid reset code")
	}

	// Mark code as used
	if err := s.passwordResetRepository.MarkCodeAsUsed(resetCode.ID); err != nil {
		return fmt.Errorf("failed to mark code as used: %w", err)
	}

	// Update user password
	if err := s.ChangeUserPassword(ctx, user.ID, newPassword); err != nil {
		return fmt.Errorf("failed to update password: %w", err)
	}

	// Audit log
	s.writeAuditLog(ctx, audit_logs_models.AuditEntry{
		Message:     "Password reset via email code",
		UserID:      &user.ID,
		WorkspaceID: nil,
	})

	return nil
}

// The audit trail records a sign-in where access is actually granted, which is
// the password step with one factor and the code step with two.
func (s *UserService) completeSignIn(
	ctx context.Context,
	user *users_models.User,
) (*users_dto.SignInResponseDTO, error) {
	s.logger.InfoContext(ctx, "user signed in", "user_id", user.ID)

	response, err := s.GenerateAccessToken(ctx, user)
	if err != nil {
		return nil, err
	}

	s.writeAuditLog(ctx, audit_logs_models.AuditEntry{
		Message:     fmt.Sprintf("User signed in with email: %s", user.Email),
		UserID:      &user.ID,
		WorkspaceID: nil,
	})

	return response, nil
}

// Every audit entry this service writes goes through here, because the console
// path reaches the service without installing a writer and a missing entry must
// not take the process down.
func (s *UserService) writeAuditLog(ctx context.Context, entry audit_logs_models.AuditEntry) {
	if s.auditLogWriter == nil {
		return
	}

	s.auditLogWriter.WriteAuditLog(ctx, entry)
}

func (s *UserService) isInstanceUnclaimed() (bool, error) {
	usersCount, err := s.userRepository.GetUsersCount()
	if err != nil {
		return false, fmt.Errorf("failed to get users count: %w", err)
	}

	return usersCount == 0, nil
}

func (s *UserService) checkExternalRegistrationAllowed(ctx context.Context) error {
	settings, err := s.settingsService.GetSettings(ctx)
	if err != nil {
		return fmt.Errorf("failed to get settings: %w", err)
	}

	if !settings.IsAllowExternalRegistrations {
		return errors.New("external registration is disabled")
	}

	return nil
}

// Every entry point that inserts a new account shares this path. An instance
// holding no account hands the account the administrator role and records it as
// the bootstrap administrator, and the question is asked before the ordinary-
// account check rather than inside the insert, because an empty instance whose
// policy forbids registration would otherwise never gain an administrator at all.
//
// Losing the race for that record is not a failure: the partial unique index
// admits one flagged account, so the loser is built again as an ordinary
// account - now under the check it was allowed to skip. Registration passes the
// registration policy as that check; the host console passes one that always
// allows.
func (s *UserService) createAccountClaimingEmptyInstance(
	ctx context.Context,
	checkOrdinaryAccountAllowed func(ctx context.Context) error,
	build func(isTakingTheInstance bool) *users_models.User,
) (*users_models.User, error) {
	isTakingTheInstance, err := s.isInstanceUnclaimed()
	if err != nil {
		return nil, err
	}

	if !isTakingTheInstance {
		if err := checkOrdinaryAccountAllowed(ctx); err != nil {
			return nil, err
		}
	}

	user := build(isTakingTheInstance)

	err = s.userRepository.CreateUser(user)
	if err == nil {
		return user, nil
	}

	// Anything but the contested bootstrap record - a duplicate address above all -
	// stays the failure it has always been.
	if !isTakingTheInstance || !isBootstrapAdminTaken(err) {
		return nil, fmt.Errorf("failed to create user: %w", err)
	}

	if err := checkOrdinaryAccountAllowed(ctx); err != nil {
		return nil, err
	}

	user = build(false)

	if err := s.userRepository.CreateUser(user); err != nil {
		return nil, fmt.Errorf("failed to create user: %w", err)
	}

	return user, nil
}

func buildRegisteredUser(
	request *users_dto.SignUpRequestDTO,
	hashedPassword string,
	isTakingTheInstance bool,
) *users_models.User {
	return &users_models.User{
		ID:                   uuid.New(),
		Email:                request.Email,
		Name:                 request.Name,
		HashedPassword:       &hashedPassword,
		PasswordCreationTime: time.Now().UTC(),
		Role:                 roleForNewAccount(isTakingTheInstance),
		Status:               users_enums.UserStatusActive,
		IsRootAdmin:          isTakingTheInstance,
		CreatedAt:            time.Now().UTC(),
	}
}

func buildOAuthUser(
	email, name string,
	githubOAuthID, googleOAuthID *string,
	isTakingTheInstance bool,
) *users_models.User {
	return &users_models.User{
		ID:                   uuid.New(),
		Email:                email,
		Name:                 name,
		HashedPassword:       nil,
		PasswordCreationTime: time.Now().UTC(),
		Role:                 roleForNewAccount(isTakingTheInstance),
		Status:               users_enums.UserStatusActive,
		GitHubOAuthID:        githubOAuthID,
		GoogleOAuthID:        googleOAuthID,
		IsRootAdmin:          isTakingTheInstance,
		CreatedAt:            time.Now().UTC(),
	}
}

func roleForNewAccount(isTakingTheInstance bool) users_enums.UserRole {
	if isTakingTheInstance {
		return users_enums.UserRoleAdmin
	}

	return users_enums.UserRoleMember
}

// The log has to explain an administrator nobody appointed.
func (s *UserService) writeInstanceClaimedAuditLog(ctx context.Context, user *users_models.User) {
	if !user.IsRootAdmin {
		return
	}

	s.writeAuditLog(ctx, audit_logs_models.AuditEntry{
		Message: fmt.Sprintf(
			"First account on the instance now administers it: %s",
			user.Email,
		),
		UserID:      &user.ID,
		WorkspaceID: nil,
	})
}

func (s *UserService) handleGitHubOAuthWithEndpoint(
	ctx context.Context,
	code, redirectUri string,
	endpoint oauth2.Endpoint,
	userAPIURL string,
) (*users_dto.OAuthCallbackResponseDTO, error) {
	env := config.GetEnv()

	oauthConfig := &oauth2.Config{
		ClientID:     env.GitHubClientID,
		ClientSecret: env.GitHubClientSecret,
		RedirectURL:  redirectUri,
		Endpoint:     endpoint,
		Scopes:       []string{"user:email"},
	}

	token, err := oauthConfig.Exchange(ctx, code)
	if err != nil {
		s.logger.ErrorContext(ctx, "oauth code exchange failed", "error", err)

		return nil, fmt.Errorf("failed to exchange code: %w", err)
	}

	client := oauthConfig.Client(ctx, token)
	githubReq, err := http.NewRequestWithContext(ctx, "GET", userAPIURL, nil)
	if err != nil {
		return nil, fmt.Errorf("failed to create user info request: %w", err)
	}
	resp, err := client.Do(githubReq)
	if err != nil {
		s.logger.ErrorContext(ctx, "oauth user info request failed", "error", err)

		return nil, fmt.Errorf("failed to get user info: %w", err)
	}
	defer func() {
		_ = resp.Body.Close()
	}()

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("github API returned status %d", resp.StatusCode)
	}

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, fmt.Errorf("failed to read response body: %w", err)
	}

	var githubUser struct {
		ID    int64  `json:"id"`
		Email string `json:"email"`
		Name  string `json:"name"`
		Login string `json:"login"`
	}

	if err := json.Unmarshal(body, &githubUser); err != nil {
		return nil, fmt.Errorf("failed to parse user info: %w", err)
	}

	email := githubUser.Email
	if email == "" {
		email, err = s.fetchGitHubPrimaryEmail(ctx, client, userAPIURL)
		if err != nil {
			return nil, err
		}
	}

	name := githubUser.Name
	if name == "" {
		name = githubUser.Login
	}

	oauthID := fmt.Sprintf("%d", githubUser.ID)
	return s.getOrCreateUserFromOAuth(ctx, oauthID, email, name, "github")
}

func (s *UserService) handleGoogleOAuthWithEndpoint(
	ctx context.Context,
	code, redirectUri string,
	endpoint oauth2.Endpoint,
	userAPIURL string,
) (*users_dto.OAuthCallbackResponseDTO, error) {
	env := config.GetEnv()

	oauthConfig := &oauth2.Config{
		ClientID:     env.GoogleClientID,
		ClientSecret: env.GoogleClientSecret,
		RedirectURL:  redirectUri,
		Endpoint:     endpoint,
		Scopes: []string{
			"https://www.googleapis.com/auth/userinfo.email",
			"https://www.googleapis.com/auth/userinfo.profile",
		},
	}

	token, err := oauthConfig.Exchange(ctx, code)
	if err != nil {
		s.logger.ErrorContext(ctx, "oauth code exchange failed", "error", err)

		return nil, fmt.Errorf("failed to exchange code: %w", err)
	}

	client := oauthConfig.Client(ctx, token)
	googleReq, err := http.NewRequestWithContext(ctx, "GET", userAPIURL, nil)
	if err != nil {
		return nil, fmt.Errorf("failed to create user info request: %w", err)
	}
	resp, err := client.Do(googleReq)
	if err != nil {
		s.logger.ErrorContext(ctx, "oauth user info request failed", "error", err)

		return nil, fmt.Errorf("failed to get user info: %w", err)
	}
	defer func() {
		_ = resp.Body.Close()
	}()

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("google API returned status %d", resp.StatusCode)
	}

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, fmt.Errorf("failed to read response body: %w", err)
	}

	var googleUser struct {
		ID    string `json:"id"`
		Email string `json:"email"`
		Name  string `json:"name"`
	}

	if err := json.Unmarshal(body, &googleUser); err != nil {
		return nil, fmt.Errorf("failed to parse user info: %w", err)
	}

	if googleUser.Email == "" {
		return nil, errors.New("google account has no email")
	}

	name := googleUser.Name
	if name == "" {
		name = "User"
	}

	return s.getOrCreateUserFromOAuth(ctx, googleUser.ID, googleUser.Email, name, "google")
}

func (s *UserService) getOrCreateUserFromOAuth(
	ctx context.Context,
	oauthID, email, name, provider string,
) (*users_dto.OAuthCallbackResponseDTO, error) {
	var existingUser *users_models.User
	var err error

	if provider == "github" {
		existingUser, err = s.userRepository.GetUserByGitHubOAuthID(oauthID)
	} else {
		existingUser, err = s.userRepository.GetUserByGoogleOAuthID(oauthID)
	}

	if err != nil {
		return nil, fmt.Errorf("failed to check OAuth ID: %w", err)
	}

	if existingUser != nil {
		tokenResponse, err := s.GenerateAccessToken(ctx, existingUser)
		if err != nil {
			return nil, err
		}

		s.writeAuditLog(ctx, audit_logs_models.AuditEntry{
			Message:     fmt.Sprintf("User signed in via %s", provider),
			UserID:      &existingUser.ID,
			WorkspaceID: nil,
		})

		return &users_dto.OAuthCallbackResponseDTO{
			UserID:    tokenResponse.UserID,
			Email:     existingUser.Email,
			Token:     tokenResponse.Token,
			IsNewUser: false,
		}, nil
	}

	userByEmail, err := s.userRepository.GetUserByEmail(ctx, email)
	if err != nil {
		return nil, fmt.Errorf("failed to check email: %w", err)
	}

	if userByEmail != nil {
		if userByEmail.Status == users_enums.UserStatusInvited {
			if err := s.userRepository.UpdateUserStatus(
				userByEmail.ID,
				users_enums.UserStatusActive,
			); err != nil {
				return nil, fmt.Errorf("failed to activate user: %w", err)
			}

			if err := s.userRepository.UpdateUserInfo(userByEmail.ID, &name, nil); err != nil {
				return nil, fmt.Errorf("failed to update name: %w", err)
			}
		}

		oauthColumn := "github_oauth_id"
		if provider == "google" {
			oauthColumn = "google_oauth_id"
		}

		if err := s.userRepository.LinkOAuthID(userByEmail.ID, oauthColumn, oauthID); err != nil {
			return nil, fmt.Errorf("failed to link OAuth ID: %w", err)
		}

		user, err := s.userRepository.GetUserByID(ctx, userByEmail.ID)
		if err != nil {
			return nil, fmt.Errorf("failed to get updated user: %w", err)
		}

		tokenResponse, err := s.GenerateAccessToken(ctx, user)
		if err != nil {
			return nil, err
		}

		s.writeAuditLog(ctx, audit_logs_models.AuditEntry{
			Message:     fmt.Sprintf("%s OAuth linked to existing account", provider),
			UserID:      &user.ID,
			WorkspaceID: nil,
		})

		return &users_dto.OAuthCallbackResponseDTO{
			UserID:    tokenResponse.UserID,
			Email:     user.Email,
			Token:     tokenResponse.Token,
			IsNewUser: false,
		}, nil
	}

	var githubOAuthID *string
	var googleOAuthID *string
	if provider == "github" {
		githubOAuthID = &oauthID
	} else {
		googleOAuthID = &oauthID
	}

	newUser, err := s.createAccountClaimingEmptyInstance(
		ctx,
		s.checkExternalRegistrationAllowed,
		func(isTakingTheInstance bool) *users_models.User {
			return buildOAuthUser(email, name, githubOAuthID, googleOAuthID, isTakingTheInstance)
		},
	)
	if err != nil {
		return nil, err
	}

	tokenResponse, err := s.GenerateAccessToken(ctx, newUser)
	if err != nil {
		return nil, err
	}

	s.writeAuditLog(ctx, audit_logs_models.AuditEntry{
		Message:     fmt.Sprintf("User registered via %s OAuth: %s", provider, email),
		UserID:      &newUser.ID,
		WorkspaceID: nil,
	})

	s.writeInstanceClaimedAuditLog(ctx, newUser)

	return &users_dto.OAuthCallbackResponseDTO{
		UserID:    tokenResponse.UserID,
		Email:     newUser.Email,
		Token:     tokenResponse.Token,
		IsNewUser: true,
	}, nil
}

func (s *UserService) fetchGitHubPrimaryEmail(
	ctx context.Context,
	client *http.Client,
	userAPIURL string,
) (string, error) {
	emailsURL := "https://api.github.com/user/emails"
	if userAPIURL != "https://api.github.com/user" {
		baseURL := userAPIURL[:len(userAPIURL)-len("/user")]
		emailsURL = baseURL + "/user/emails"
	}

	emailsReq, err := http.NewRequestWithContext(ctx, "GET", emailsURL, nil)
	if err != nil {
		return "", fmt.Errorf("failed to create user emails request: %w", err)
	}
	resp, err := client.Do(emailsReq)
	if err != nil {
		return "", fmt.Errorf("failed to get user emails: %w", err)
	}
	defer func() {
		_ = resp.Body.Close()
	}()

	if resp.StatusCode != http.StatusOK {
		return "", errors.New("github account has no accessible email")
	}

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return "", fmt.Errorf("failed to read emails response: %w", err)
	}

	var emails []struct {
		Email    string `json:"email"`
		Primary  bool   `json:"primary"`
		Verified bool   `json:"verified"`
	}

	if err := json.Unmarshal(body, &emails); err != nil {
		return "", fmt.Errorf("failed to parse emails: %w", err)
	}

	for _, email := range emails {
		if email.Primary && email.Verified {
			return email.Email, nil
		}
	}

	for _, email := range emails {
		if email.Verified {
			return email.Email, nil
		}
	}

	if len(emails) > 0 {
		return emails[0].Email, nil
	}

	return "", errors.New("github account has no accessible email")
}