valitovgaziz
8b40d1bfe5
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
397 lines
12 KiB
Go
397 lines
12 KiB
Go
// service.go
|
|
package auth
|
|
|
|
import (
|
|
"api_yal/internal/logger"
|
|
"api_yal/internal/models"
|
|
"api_yal/internal/repository"
|
|
"errors"
|
|
"fmt"
|
|
"time"
|
|
|
|
"github.com/golang-jwt/jwt/v5"
|
|
"go.uber.org/zap"
|
|
"golang.org/x/crypto/bcrypt"
|
|
)
|
|
|
|
// AuthService интерфейс сервиса аутентификации
|
|
type AuthService interface {
|
|
Register(req RegisterRequest) (*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
|
|
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, config AuthServiceConfig) AuthService {
|
|
return &authServiceImpl{
|
|
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()
|
|
l.Info("Начало регистрации нового пользователя", zap.String("email", req.Email))
|
|
|
|
// Проверяем, существует ли пользователь с таким email
|
|
existingUser, err := s.accountRepo.GetByEmail(req.Email)
|
|
if err == nil && existingUser != nil {
|
|
return nil, ErrUserAlreadyExists
|
|
}
|
|
|
|
// Хешируем пароль
|
|
hashedPassword, err := bcrypt.GenerateFromPassword([]byte(req.Password), bcrypt.DefaultCost)
|
|
if err != nil {
|
|
l.Error("Ошибка хеширования пароля", zap.Error(err))
|
|
return nil, err
|
|
}
|
|
|
|
// Формируем полное имя
|
|
fullName := req.FirstName + " " + req.LastName
|
|
|
|
// Создаем аккаунт
|
|
newAcc := &models.Account{
|
|
Email: req.Email,
|
|
PasswordHash: string(hashedPassword),
|
|
FirstName: req.FirstName,
|
|
LastName: req.LastName,
|
|
FullName: fullName,
|
|
IsActive: true,
|
|
IsVerified: false,
|
|
Role: "user",
|
|
}
|
|
|
|
// Сохраняем в базу данных
|
|
if err := s.accountRepo.Create(newAcc); err != nil {
|
|
l.Error("Ошибка создания аккаунта", zap.Error(err))
|
|
return nil, err
|
|
}
|
|
|
|
// Генерируем access token
|
|
accessToken, expiresAt, err := s.generateAccessToken(newAcc)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Формируем ответ
|
|
response := &AuthResponse{
|
|
Token: accessToken,
|
|
ExpiresAt: expiresAt,
|
|
User: UserInfo{
|
|
ID: newAcc.Base.ID,
|
|
Email: newAcc.Email,
|
|
FirstName: newAcc.FirstName,
|
|
LastName: newAcc.LastName,
|
|
FullName: newAcc.FullName,
|
|
Role: newAcc.Role,
|
|
},
|
|
}
|
|
|
|
l.Info("Пользователь успешно зарегистрирован", zap.String("email", req.Email))
|
|
return response, nil
|
|
}
|
|
|
|
// Login аутентифицирует пользователя и возвращает access и refresh токены
|
|
func (s *authServiceImpl) Login(req LoginRequest) (*AuthResponse, string, error) {
|
|
l := logger.Get()
|
|
l.Info("Начало входа пользователя", zap.String("email", req.Email))
|
|
|
|
// Ищем пользователя по email
|
|
account, err := s.accountRepo.GetByEmail(req.Email)
|
|
if err != nil {
|
|
l.Error("Пользователь не найден", zap.String("email", req.Email), zap.Error(err))
|
|
return nil, "", ErrUserNotFound
|
|
}
|
|
|
|
// Проверяем, активен ли аккаунт
|
|
if !account.IsActive {
|
|
l.Error("Аккаунт деактивирован", zap.String("email", req.Email))
|
|
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
|
|
}
|
|
|
|
// Генерируем токены
|
|
accessToken, expiresAt, err := s.generateAccessToken(account)
|
|
if err != nil {
|
|
return nil, "", err
|
|
}
|
|
|
|
refreshToken, err := s.generateRefreshToken(account)
|
|
if err != nil {
|
|
return nil, "", err
|
|
}
|
|
|
|
// Формируем ответ
|
|
response := &AuthResponse{
|
|
Token: accessToken,
|
|
ExpiresAt: expiresAt,
|
|
User: UserInfo{
|
|
ID: account.Base.ID,
|
|
Email: account.Email,
|
|
FirstName: account.FirstName,
|
|
LastName: account.LastName,
|
|
FullName: account.FullName,
|
|
Role: account.Role,
|
|
},
|
|
}
|
|
|
|
l.Info("Пользователь успешно вошел", zap.String("email", req.Email))
|
|
return response, refreshToken, nil
|
|
}
|
|
|
|
// RefreshToken обновляет JWT токен по refresh token
|
|
func (s *authServiceImpl) RefreshToken(refreshToken string) (*RefreshTokenResponse, error) {
|
|
l := logger.Get()
|
|
l.Info("Начало обновления токена")
|
|
|
|
// Парсим и валидируем refresh token
|
|
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)
|
|
if !ok {
|
|
l.Error("Не удалось получить subject из токена")
|
|
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, ErrInvalidToken
|
|
}
|
|
|
|
// Получаем пользователя из базы по ID
|
|
account, err := s.accountRepo.GetByID(userID)
|
|
if err != nil {
|
|
l.Error("Пользователь не найден", zap.Uint("userID", userID), zap.Error(err))
|
|
return nil, ErrUserNotFound
|
|
}
|
|
|
|
// Проверяем, активен ли аккаунт
|
|
if !account.IsActive {
|
|
l.Error("Аккаунт деактивирован", zap.Uint("userID", userID))
|
|
return nil, errors.New("account is deactivated")
|
|
}
|
|
|
|
// Генерируем новый access token
|
|
accessToken, expiresAt, err := s.generateAccessToken(account)
|
|
if err != nil {
|
|
l.Error("Ошибка генерации access token", zap.Error(err))
|
|
return nil, err
|
|
}
|
|
|
|
l.Info("Обновление токена успешно завершено", zap.Uint("userID", userID))
|
|
return &RefreshTokenResponse{
|
|
Token: accessToken,
|
|
ExpiresAt: expiresAt,
|
|
User: UserInfo{
|
|
ID: account.Base.ID,
|
|
Email: account.Email,
|
|
FirstName: account.FirstName,
|
|
LastName: account.LastName,
|
|
FullName: account.FullName,
|
|
Role: account.Role,
|
|
},
|
|
}, nil
|
|
}
|
|
|
|
// Logout выход пользователя
|
|
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
|
|
}
|
|
|
|
// 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
|
|
})
|
|
|
|
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": expiresAt.Unix(),
|
|
"iat": time.Now().Unix(),
|
|
"type": "access",
|
|
}
|
|
|
|
token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
|
|
tokenString, err := token.SignedString(s.jwtSecret)
|
|
if err != nil {
|
|
return "", time.Time{}, err
|
|
}
|
|
|
|
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": expiresAt.Unix(),
|
|
"iat": time.Now().Unix(),
|
|
"type": "refresh",
|
|
"jti": fmt.Sprintf("refresh-%d-%d", account.Base.ID, time.Now().Unix()),
|
|
}
|
|
|
|
token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
|
|
tokenString, err := token.SignedString(s.jwtSecret)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
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
|
|
} |