codeword/internal/services/recovery_service.go

package services

import (
	"codeword/internal/models"
	"codeword/internal/utils/encrypt"
	"context"
	"encoding/base64"
	"go.uber.org/zap"
)

type CodewordRepository interface {
	StoreRecoveryRecord(ctx context.Context, userID, email, key, signUrl string) (string, error)
	InsertToQueue(ctx context.Context, userID string, email string, key []byte, id string) error
	Ping(ctx context.Context) error
	GetRecoveryRecord(ctx context.Context, key string) (*models.RestoreRequest, error)
}

type UserRepository interface {
	FindByEmail(ctx context.Context, email string) (*models.User, error)
}

type Deps struct {
	Logger             *zap.Logger
	CodewordRepository CodewordRepository
	UserRepository     UserRepository
	Encrypt            *encrypt.Encrypt
}

type RecoveryService struct {
	logger             *zap.Logger
	repositoryCodeword CodewordRepository
	repositoryUser     UserRepository
	encrypt            *encrypt.Encrypt
}

func NewRecoveryService(deps Deps) *RecoveryService {
	return &RecoveryService{
		logger:             deps.Logger,
		repositoryCodeword: deps.CodewordRepository,
		repositoryUser:     deps.UserRepository,
		encrypt:            deps.Encrypt,
	}
}

// GenerateKey генерирует ключ, используя шифрование на основе эллиптической кривой
func (s *RecoveryService) GenerateKey() ([]byte, error) {
	key, err := s.encrypt.SignCommonSecret()
	if err != nil {
		s.logger.Error("Failed to generate unique key for user", zap.Error(err))
		return nil, err
	}
	return key, nil
}

func (s *RecoveryService) Ping(ctx context.Context) error {
	err := s.repositoryCodeword.Ping(ctx)
	if err != nil {
		s.logger.Error("Failed to ping database", zap.Error(err))
		return err
	}
	return nil
}

// FindUserByEmail ищет пользователя по электронной почте
func (s *RecoveryService) FindUserByEmail(ctx context.Context, email string) (*models.User, error) {
	user, err := s.repositoryUser.FindByEmail(ctx, email)
	if err != nil {
		s.logger.Error("Failed to find user by email", zap.String("email", email), zap.Error(err))
		return nil, err
	}
	if user == nil {
		s.logger.Info("No user found with email", zap.String("email", email))
		return nil, nil
	}
	return user, nil
}

// StoreRecoveryRecord сохраняет запись восстановления в базе данных
func (s *RecoveryService) StoreRecoveryRecord(ctx context.Context, userID, email, key, signUrl string) (string, error) {
	id, err := s.repositoryCodeword.StoreRecoveryRecord(ctx, userID, email, key, signUrl)
	if err != nil {
		s.logger.Error("Failed save data in mongoDB for email", zap.String("email", email), zap.Error(err))
		return "", err
	}
	return id, nil
}

// SendRecoveryEmail посылает письмо для восстановления доступа пользователю
func (s *RecoveryService) RecoveryEmailTask(ctx context.Context, userID string, email string, key []byte, id string) error {
	err := s.repositoryCodeword.InsertToQueue(ctx, userID, email, key, id)
	if err != nil {
		s.logger.Error("Failed creating a task to send a worker by email", zap.String("email", email), zap.Error(err))
		return err
	}
	return nil
}

// GetRecoveryRecord получает запись восстановления из базы данных
func (s *RecoveryService) GetRecoveryRecord(ctx context.Context, key string) (*models.RestoreRequest, error) {
	byteKey, err := base64.URLEncoding.DecodeString(key)
	if err != nil {
		s.logger.Error("Failed to decode string signature to []byte format", zap.String("signature", key), zap.Error(err))
		return nil, err
	}

	result, err := s.encrypt.VerifySignature(byteKey)
	if err != nil {
		s.logger.Error("Failed to verify signature", zap.String("signature", key), zap.Error(err))
		return nil, err
	}

	if result {
		req, err := s.repositoryCodeword.GetRecoveryRecord(ctx, key)
		if err != nil {
			s.logger.Error("Failed to obtain signature recovery data", zap.String("signature", key), zap.Error(err))
			return nil, err
		}
		return req, nil
	}
	return nil, nil
}

// ExchangeForTokens обменивает ссылку восстановления на токены используя сервис аутентификации.
func (s *RecoveryService) ExchangeForTokens(userID string) (map[string]string, error) {
	// TODO
	return nil, nil
}