treasurer/internal/service/payment/payment.go

package payment

import (
	"context"
	"fmt"
	"gitea.pena/PenaSide/treasurer/internal/repository"

	"gitea.pena/PenaSide/treasurer/internal/errors"
	"gitea.pena/PenaSide/treasurer/internal/models"
	"gitea.pena/PenaSide/treasurer/internal/models/yandex"
	"gitea.pena/PenaSide/treasurer/internal/utils"
	"go.uber.org/zap"
)

type Deps struct {
	Logger                 *zap.Logger
	PaymentStrategyService *Yandex
	PaymentRepository      *repository.PaymentRepository
}

type Service struct {
	logger                 *zap.Logger
	paymentStrategyService *Yandex
	paymentRepository      *repository.PaymentRepository
}

func New(deps Deps) (*Service, errors.Error) {
	if deps.Logger == nil {
		return nil, errors.NewWithMessage("logger is nil on <NewCallbackClient>", errors.ErrInvalidArgs)
	}

	if deps.PaymentStrategyService == nil {
		return nil, errors.NewWithMessage("PaymentStrategyService is nil on <NewCallbackClient>", errors.ErrInvalidArgs)
	}

	if deps.PaymentRepository == nil {
		return nil, errors.NewWithMessage("PaymentRepository is nil on <NewCallbackClient>", errors.ErrInvalidArgs)
	}

	return &Service{
		logger:                 deps.Logger,
		paymentStrategyService: deps.PaymentStrategyService,
		paymentRepository:      deps.PaymentRepository,
	}, nil
}

func (s *Service) CreatePaymentBankCard(ctx context.Context, request *models.CreatePayment[yandex.Receipt]) (string, errors.Error) {
	s.logger.Info("f<CreatePaymentBankCard> of <YandexPaymentService>", zap.Any("Customer", request.Requisites.Customer), zap.Any("Items", request.Requisites.Items))
	paymentUUID, generateErr := utils.GenerateUUID()
	if generateErr != nil {
		s.logger.Error("failed to generate uuid on <CreatePaymentBankCard> of <PaymentService>", zap.Error(generateErr))
		return "", errors.NewWithError(fmt.Errorf("failed to generate uuid: %w", generateErr), errors.ErrInternalError)
	}

	response, err := s.paymentStrategyService.CreatePaymentBankCard(ctx, paymentUUID, request)
	if err != nil {
		s.logger.Error("failed to create payment on <CreatePaymentBankCard> of <PaymentService>", zap.Error(err))
		return "", err
	}

	if _, err := s.paymentRepository.Insert(ctx, response.Payment); err != nil {
		s.logger.Error("failed to insert payment on <CreatePaymentBankCard> of <PaymentService>", zap.Error(err))
		return "", err
	}

	return response.RedirectURL, nil
}

func (s *Service) CreatePayment(ctx context.Context, request *models.CreatePayment[yandex.Receipt]) (string, errors.Error) {
	paymentUUID, generateErr := utils.GenerateUUID()
	if generateErr != nil {
		s.logger.Error("failed to generate uuid on <CreatePayment> of <PaymentService>", zap.Error(generateErr))
		return "", errors.NewWithError(fmt.Errorf("failed to generate uuid: %w", generateErr), errors.ErrInternalError)
	}

	response, err := s.paymentStrategyService.CreatePayment(ctx, paymentUUID, request)
	if err != nil {
		s.logger.Error("failed to create payment on <CreatePayment> of <PaymentService>", zap.Error(err))
		return "", err
	}

	if _, err := s.paymentRepository.Insert(ctx, response.Payment); err != nil {
		s.logger.Error("failed to insert payment on <CreatePayment> of <PaymentService>", zap.Error(err))
		return "", err
	}

	return response.RedirectURL, nil
}