On branch main

modified: internal/domain/auth/dto.go modified: internal/domain/auth/handler.go modified: internal/domain/auth/router.go modified: internal/domain/auth/servcie.go modified: internal/middleware/auth.go modified: internal/router/router.go auth implemented without reset password
2026-03-31 04:22:54 +05:00
parent 659cd3584c
commit 8b40d1bfe5
6 changed files with 372 additions and 119 deletions
@@ -1,3 +1,4 @@
+// service.go
 package auth

 import (
@@ -16,25 +17,73 @@ import (
 // AuthService интерфейс сервиса аутентификации
 type AuthService interface {
 	Register(req RegisterRequest) (*AuthResponse, error)
-	Login(req LoginRequest) (*AuthResponse, error)
-	RefreshToken(refreshToken string) (*AuthResponse, error)
+	Login(req LoginRequest) (*AuthResponse, string, error) // Возвращает refresh token отдельно
+	RefreshToken(refreshToken string) (*RefreshTokenResponse, error)
 	Logout(userID uint) error
+	ValidateAccessToken(tokenString string) (*jwt.MapClaims, error)
+	GetUserFromToken(claims *jwt.MapClaims) (*models.Account, error)
+	GenerateNewRefreshToken(userID uint) (string, error)
 }

 // authServiceImpl реализация сервиса аутентификации
 type authServiceImpl struct {
-	accountRepo repository.AccountRepository
-	jwtSecret   []byte
+	accountRepo       repository.AccountRepository
+	jwtSecret         []byte
+	accessTokenTTL    time.Duration
+	refreshTokenTTL   time.Duration
+}
+
+// AuthServiceConfig конфигурация для сервиса аутентификации
+type AuthServiceConfig struct {
+	JWTSecret       string
+	AccessTokenTTL  time.Duration // Рекомендуется 15-30 минут
+	RefreshTokenTTL time.Duration // Рекомендуется 7-30 дней
 }

 // NewAuthService создает новый экземпляр сервиса аутентификации
-func NewAuthService(accountRepo repository.AccountRepository, jwtSecret string) AuthService {
+func NewAuthService(accountRepo repository.AccountRepository, config AuthServiceConfig) AuthService {
 	return &authServiceImpl{
-		accountRepo: accountRepo,
-		jwtSecret:   []byte(jwtSecret),
+		accountRepo:       accountRepo,
+		jwtSecret:         []byte(config.JWTSecret),
+		accessTokenTTL:    config.AccessTokenTTL,
+		refreshTokenTTL:   config.RefreshTokenTTL,
 	}
 }

+// GenerateNewRefreshToken генерирует новый refresh token для пользователя по ID
+func (s *authServiceImpl) GenerateNewRefreshToken(userID uint) (string, error) {
+	l := logger.Get()
+	l.Info("Генерация нового refresh token", zap.Uint("userID", userID))
+
+	// Получаем пользователя из базы данных
+	account, err := s.accountRepo.GetByID(userID)
+	if err != nil {
+		l.Error("Пользователь не найден при генерации refresh token", 
+			zap.Uint("userID", userID), 
+			zap.Error(err))
+		return "", ErrUserNotFound
+	}
+
+	// Проверяем, активен ли аккаунт
+	if !account.IsActive {
+		l.Error("Попытка генерации refresh token для деактивированного аккаунта", 
+			zap.Uint("userID", userID))
+		return "", errors.New("account is deactivated")
+	}
+
+	// Генерируем новый refresh token
+	refreshToken, err := s.generateRefreshToken(account)
+	if err != nil {
+		l.Error("Ошибка генерации refresh token", 
+			zap.Uint("userID", userID), 
+			zap.Error(err))
+		return "", err
+	}
+
+	l.Info("Refresh token успешно сгенерирован", zap.Uint("userID", userID))
+	return refreshToken, nil
+}
+
 // Register регистрирует нового пользователя
 func (s *authServiceImpl) Register(req RegisterRequest) (*AuthResponse, error) {
 	l := logger.Get()
@@ -74,17 +123,16 @@ func (s *authServiceImpl) Register(req RegisterRequest) (*AuthResponse, error) {
 		return nil, err
 	}

-	// Генерируем JWT токены
-	accessToken, refreshToken, expiresAt, err := s.generateTokens(newAcc)
+	// Генерируем access token
+	accessToken, expiresAt, err := s.generateAccessToken(newAcc)
 	if err != nil {
 		return nil, err
 	}

 	// Формируем ответ
 	response := &AuthResponse{
-		Token:        accessToken,
-		RefreshToken: refreshToken,
-		ExpiresAt:    expiresAt,
+		Token:     accessToken,
+		ExpiresAt: expiresAt,
 		User: UserInfo{
 			ID:        newAcc.Base.ID,
 			Email:     newAcc.Email,
@@ -99,8 +147,8 @@ func (s *authServiceImpl) Register(req RegisterRequest) (*AuthResponse, error) {
 	return response, nil
 }

-// Login аутентифицирует пользователя
-func (s *authServiceImpl) Login(req LoginRequest) (*AuthResponse, error) {
+// Login аутентифицирует пользователя и возвращает access и refresh токены
+func (s *authServiceImpl) Login(req LoginRequest) (*AuthResponse, string, error) {
 	l := logger.Get()
 	l.Info("Начало входа пользователя", zap.String("email", req.Email))

@@ -108,32 +156,36 @@ func (s *authServiceImpl) Login(req LoginRequest) (*AuthResponse, error) {
 	account, err := s.accountRepo.GetByEmail(req.Email)
 	if err != nil {
 		l.Error("Пользователь не найден", zap.String("email", req.Email), zap.Error(err))
-		return nil, ErrUserNotFound
+		return nil, "", ErrUserNotFound
 	}

 	// Проверяем, активен ли аккаунт
 	if !account.IsActive {
 		l.Error("Аккаунт деактивирован", zap.String("email", req.Email))
-		return nil, errors.New("account is deactivated")
+		return nil, "", errors.New("account is deactivated")
 	}

 	// Сравниваем пароли
 	if err := bcrypt.CompareHashAndPassword([]byte(account.PasswordHash), []byte(req.Password)); err != nil {
 		l.Error("Неверный пароль для пользователя", zap.String("email", req.Email))
-		return nil, ErrInvalidPassword
+		return nil, "", ErrInvalidPassword
 	}

-	// Генерируем JWT токены
-	accessToken, refreshToken, expiresAt, err := s.generateTokens(account)
+	// Генерируем токены
+	accessToken, expiresAt, err := s.generateAccessToken(account)
 	if err != nil {
-		return nil, err
+		return nil, "", err
+	}
+
+	refreshToken, err := s.generateRefreshToken(account)
+	if err != nil {
+		return nil, "", err
 	}

 	// Формируем ответ
 	response := &AuthResponse{
-		Token:        accessToken,
-		RefreshToken: refreshToken,
-		ExpiresAt:    expiresAt,
+		Token:     accessToken,
+		ExpiresAt: expiresAt,
 		User: UserInfo{
 			ID:        account.Base.ID,
 			Email:     account.Email,
@@ -145,53 +197,33 @@ func (s *authServiceImpl) Login(req LoginRequest) (*AuthResponse, error) {
 	}

 	l.Info("Пользователь успешно вошел", zap.String("email", req.Email))
-	return response, nil
+	return response, refreshToken, nil
 }

 // RefreshToken обновляет JWT токен по refresh token
-func (s *authServiceImpl) RefreshToken(refreshToken string) (*AuthResponse, error) {
+func (s *authServiceImpl) RefreshToken(refreshToken string) (*RefreshTokenResponse, error) {
 	l := logger.Get()
 	l.Info("Начало обновления токена")

 	// Парсим и валидируем refresh token
-	token, err := jwt.Parse(refreshToken, func(t *jwt.Token) (interface{}, error) {
-		// Проверяем метод подписи
-		if _, ok := t.Method.(*jwt.SigningMethodHMAC); !ok {
-			return nil, fmt.Errorf("unexpected signing method: %v", t.Header["alg"])
-		}
-		return s.jwtSecret, nil
-	})
-
-	if err != nil || !token.Valid {
-		l.Error("Невалидный refresh token", zap.Error(err))
-		return nil, errors.New("invalid refresh token")
-	}
-
-	// Получаем claims
-	claims, ok := token.Claims.(jwt.MapClaims)
-	if !ok {
-		l.Error("Не удалось получить claims из токена")
-		return nil, errors.New("invalid token claims")
-	}
-
-	// Проверяем тип токена (должен быть refresh)
-	if tokenType, exists := claims["type"]; !exists || tokenType != "refresh" {
-		l.Error("Токен не является refresh токеном")
-		return nil, errors.New("invalid token type")
+	claims, err := s.validateRefreshToken(refreshToken)
+	if err != nil {
+		l.Error("Ошибка валидации refresh token", zap.Error(err))
+		return nil, err
 	}

 	// Получаем ID пользователя из claims
-	userIDStr, ok := claims["sub"].(string)
+	userIDStr, ok := (*claims)["sub"].(string)
 	if !ok {
 		l.Error("Не удалось получить subject из токена")
-		return nil, errors.New("invalid token claims")
+		return nil, ErrInvalidToken
 	}

 	// Конвертируем string в uint
 	var userID uint
 	if _, err := fmt.Sscan(userIDStr, &userID); err != nil {
 		l.Error("Ошибка конвертации user ID", zap.Error(err))
-		return nil, errors.New("invalid user id in token")
+		return nil, ErrInvalidToken
 	}

 	// Получаем пользователя из базы по ID
@@ -207,18 +239,17 @@ func (s *authServiceImpl) RefreshToken(refreshToken string) (*AuthResponse, erro
 		return nil, errors.New("account is deactivated")
 	}

-	// Генерируем новую пару токенов
-	accessToken, newRefreshToken, expiresAt, err := s.generateTokens(account)
+	// Генерируем новый access token
+	accessToken, expiresAt, err := s.generateAccessToken(account)
 	if err != nil {
-		l.Error("Ошибка генерации токенов", zap.Error(err))
+		l.Error("Ошибка генерации access token", zap.Error(err))
 		return nil, err
 	}

 	l.Info("Обновление токена успешно завершено", zap.Uint("userID", userID))
-	return &AuthResponse{
-		Token:        accessToken,
-		RefreshToken: newRefreshToken,
-		ExpiresAt:    expiresAt,
+	return &RefreshTokenResponse{
+		Token:     accessToken,
+		ExpiresAt: expiresAt,
 		User: UserInfo{
 			ID:        account.Base.ID,
 			Email:     account.Email,
@@ -235,48 +266,132 @@ func (s *authServiceImpl) Logout(userID uint) error {
 	l := logger.Get()
 	l.Info("Выход пользователя", zap.Uint("userID", userID))
 	// Здесь можно добавить логику инвалидации токенов (например, в Redis)
+	// Для базовой реализации достаточно удалить cookie на клиенте
 	l.Info("Выход успешно завершен", zap.Uint("userID", userID))
 	return nil
 }

-// generateTokens генерирует пару токенов: access и refresh
-func (s *authServiceImpl) generateTokens(account *models.Account) (accessToken, refreshToken string, expiresAt time.Time, err error) {
-	// Access token expires in 15 minutes (более безопасно для access token)
-	accessExpiresAt := time.Now().Add(15 * time.Minute)
-	
-	// Refresh token expires in 7 days
-	refreshExpiresAt := time.Now().Add(7 * 24 * time.Hour)
+// ValidateAccessToken валидирует access token
+func (s *authServiceImpl) ValidateAccessToken(tokenString string) (*jwt.MapClaims, error) {
+	token, err := jwt.Parse(tokenString, func(t *jwt.Token) (interface{}, error) {
+		// Проверяем метод подписи
+		if _, ok := t.Method.(*jwt.SigningMethodHMAC); !ok {
+			return nil, fmt.Errorf("unexpected signing method: %v", t.Header["alg"])
+		}
+		return s.jwtSecret, nil
+	})

-	// Создаем access token
-	accessClaims := jwt.MapClaims{
+	if err != nil {
+		return nil, err
+	}
+
+	if !token.Valid {
+		return nil, ErrInvalidToken
+	}
+
+	claims, ok := token.Claims.(jwt.MapClaims)
+	if !ok {
+		return nil, ErrInvalidToken
+	}
+
+	// Проверяем тип токена
+	if tokenType, exists := claims["type"]; !exists || tokenType != "access" {
+		return nil, ErrInvalidToken
+	}
+
+	return &claims, nil
+}
+
+// GetUserFromToken получает пользователя из claims
+func (s *authServiceImpl) GetUserFromToken(claims *jwt.MapClaims) (*models.Account, error) {
+	userIDStr, ok := (*claims)["sub"].(string)
+	if !ok {
+		return nil, ErrInvalidToken
+	}
+
+	var userID uint
+	if _, err := fmt.Sscan(userIDStr, &userID); err != nil {
+		return nil, ErrInvalidToken
+	}
+
+	return s.accountRepo.GetByID(userID)
+}
+
+// generateAccessToken генерирует access token
+func (s *authServiceImpl) generateAccessToken(account *models.Account) (string, time.Time, error) {
+	expiresAt := time.Now().Add(s.accessTokenTTL)
+
+	claims := jwt.MapClaims{
 		"sub":   fmt.Sprintf("%d", account.Base.ID),
 		"email": account.Email,
 		"role":  account.Role,
-		"exp":   accessExpiresAt.Unix(),
+		"exp":   expiresAt.Unix(),
 		"iat":   time.Now().Unix(),
 		"type":  "access",
 	}

-	accessTokenObj := jwt.NewWithClaims(jwt.SigningMethodHS256, accessClaims)
-	accessToken, err = accessTokenObj.SignedString(s.jwtSecret)
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+	tokenString, err := token.SignedString(s.jwtSecret)
 	if err != nil {
-		return "", "", time.Time{}, err
+		return "", time.Time{}, err
 	}

-	// Создаем refresh token
-	refreshClaims := jwt.MapClaims{
+	return tokenString, expiresAt, nil
+}
+
+// generateRefreshToken генерирует refresh token
+func (s *authServiceImpl) generateRefreshToken(account *models.Account) (string, error) {
+	expiresAt := time.Now().Add(s.refreshTokenTTL)
+
+	claims := jwt.MapClaims{
 		"sub":   fmt.Sprintf("%d", account.Base.ID),
-		"exp":   refreshExpiresAt.Unix(),
+		"exp":   expiresAt.Unix(),
 		"iat":   time.Now().Unix(),
 		"type":  "refresh",
 		"jti":   fmt.Sprintf("refresh-%d-%d", account.Base.ID, time.Now().Unix()),
 	}

-	refreshTokenObj := jwt.NewWithClaims(jwt.SigningMethodHS256, refreshClaims)
-	refreshToken, err = refreshTokenObj.SignedString(s.jwtSecret)
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+	tokenString, err := token.SignedString(s.jwtSecret)
 	if err != nil {
-		return "", "", time.Time{}, err
+		return "", err
 	}

-	return accessToken, refreshToken, accessExpiresAt, nil
+	return tokenString, nil
+}
+
+// validateRefreshToken валидирует refresh token
+func (s *authServiceImpl) validateRefreshToken(tokenString string) (*jwt.MapClaims, error) {
+	token, err := jwt.Parse(tokenString, func(t *jwt.Token) (interface{}, error) {
+		if _, ok := t.Method.(*jwt.SigningMethodHMAC); !ok {
+			return nil, fmt.Errorf("unexpected signing method: %v", t.Header["alg"])
+		}
+		return s.jwtSecret, nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	if !token.Valid {
+		return nil, ErrInvalidToken
+	}
+
+	claims, ok := token.Claims.(jwt.MapClaims)
+	if !ok {
+		return nil, ErrInvalidToken
+	}
+
+	// Проверяем тип токена
+	if tokenType, exists := claims["type"]; !exists || tokenType != "refresh" {
+		return nil, ErrInvalidToken
+	}
+
+	// Проверяем время истечения
+	exp, ok := claims["exp"].(float64)
+	if ok && int64(exp) < time.Now().Unix() {
+		return nil, ErrTokenExpired
+	}
+
+	return &claims, nil
 }