customer/internal/service/cart/cart.go

package cart

import (
	"context"
	"fmt"
	"log"
	"time"

	"go.uber.org/zap"
	"google.golang.org/protobuf/types/known/timestamppb"
	"penahub.gitlab.yandexcloud.net/pena-services/customer/internal/errors"
	"penahub.gitlab.yandexcloud.net/pena-services/customer/internal/models"
	"penahub.gitlab.yandexcloud.net/pena-services/customer/internal/proto/discount"
	"penahub.gitlab.yandexcloud.net/pena-services/customer/internal/utils"
	"penahub.gitlab.yandexcloud.net/pena-services/customer/internal/utils/transfer"
)

type accountRepository interface {
	FindByUserID(ctx context.Context, id string) (*models.Account, errors.Error)
	AddItemToCart(ctx context.Context, userID, itemID string) (*models.Account, errors.Error)
	RemoveItemFromCart(ctx context.Context, userID, itemID string) (*models.Account, errors.Error)
	ClearCart(ctx context.Context, userID string) (*models.Account, errors.Error)
}

type hubadminClient interface {
	GetTariff(ctx context.Context, tariffID string) (*models.Tariff, errors.Error)
	GetTariffs(ctx context.Context, tarriffIDs []string) ([]models.Tariff, errors.Error)
}

type discountClient interface {
	Apply(context.Context, *discount.ApplyDiscountRequest) (*discount.ApplyDiscountResponse, errors.Error)
}

type walletService interface {
	ReplenishAccountWallet(context.Context, *models.ReplenishAccountWallet) (*models.Account, errors.Error)
	WithdrawAccountWalletMoney(context.Context, *models.WithdrawAccountWallet) (*models.Account, errors.Error)
}

type historyService interface {
	CreateHistory(ctx context.Context, history *models.History) (*models.History, errors.Error)
}

type Deps struct {
	Logger         *zap.Logger
	Repository     accountRepository
	HubadminClient hubadminClient
	DiscountClient discountClient
	WalletService  walletService
	HistoryService historyService
}

type Service struct {
	logger         *zap.Logger
	repository     accountRepository
	hubadminClient hubadminClient
	discountClient discountClient
	walletService  walletService
	historyService historyService
}

func New(deps Deps) *Service {
	if deps.Logger == nil {
		log.Panicln("logger is nil on <New (cart service)>")
	}

	if deps.Repository == nil {
		log.Panicln("repository is nil on <New (cart service)>")
	}

	if deps.HubadminClient == nil {
		log.Panicln("HubadminClient is nil on <New (cart service)>")
	}

	if deps.DiscountClient == nil {
		log.Panicln("DiscountClient is nil on <New (cart service)>")
	}

	if deps.WalletService == nil {
		log.Panicln("WalletService is nil on <New (cart service)>")
	}

	if deps.HistoryService == nil {
		log.Panicln("HistoryService is nil on <New (cart service)>")
	}

	return &Service{
		logger:         deps.Logger,
		repository:     deps.Repository,
		hubadminClient: deps.HubadminClient,
		discountClient: deps.DiscountClient,
		walletService:  deps.WalletService,
		historyService: deps.HistoryService,
	}
}

func (receiver *Service) Remove(ctx context.Context, userID, itemID string) ([]string, errors.Error) {
	account, err := receiver.repository.RemoveItemFromCart(ctx, userID, itemID)
	if err != nil {
		receiver.logger.Error("failed to remove item from cart on <Remove> of <CartService>", zap.Error(err))
		return []string{}, err
	}

	return account.Cart, nil
}

func (receiver *Service) Add(ctx context.Context, userID, itemID string) ([]string, errors.Error) {
	tariff, err := receiver.hubadminClient.GetTariff(ctx, itemID)
	if err != nil {
		receiver.logger.Error("failed to get tariff on <Add> of <CartService>", zap.Error(err), zap.String("tariffID", itemID))
		return []string{}, err
	}

	if tariff == nil {
		return []string{}, errors.New(
			fmt.Errorf("failed to get tariff <%s> on <Add> of <CartService>: tariff not found", itemID),
			errors.ErrNotFound,
		)
	}

	account, err := receiver.repository.AddItemToCart(ctx, userID, itemID)
	if err != nil {
		receiver.logger.Error("failed to add item to cart on <Add> of <CartService>", zap.Error(err))
		return []string{}, err
	}

	return account.Cart, nil
}

func (receiver *Service) Pay(ctx context.Context, userID string) (string, errors.Error) {
	account, err := receiver.repository.FindByUserID(ctx, userID)
	if err != nil {
		receiver.logger.Error("failed to find account on <Pay> of <CartService>", zap.String("userID", userID), zap.Error(err))
		return "", err
	}

	tariffs, err := receiver.hubadminClient.GetTariffs(ctx, account.Cart)
	if err != nil {
		receiver.logger.Error("failed to get tarrifs on <Pay> of <CartService>", zap.Strings("cart", account.Cart), zap.Error(err))
		return "", err
	}

	tariffsAmount := utils.CalculateCartPurchasesAmount(tariffs)

	// TODO: убрать все конвертеры чисел: float64, int64

	response, err := receiver.discountClient.Apply(ctx, &discount.ApplyDiscountRequest{
		UserInformation: &discount.UserInformation{
			ID:                  account.UserID,
			Type:                string(account.Status),
			PurchasesAmount:     float64(account.Wallet.PurchasesAmount),
			CartPurchasesAmount: float64(tariffsAmount),
		},
		Products: transfer.TariffsToProductInformations(tariffs),
		Date:     timestamppb.New(time.Now()),
	})
	if err != nil {
		receiver.logger.Error("failed to discount on <Pay> of <CartService>", zap.Error(err))
		return "", err
	}

	if account.Wallet.Money < int64(response.Price) {
		receiver.logger.Error("insufficient funds on <Pay> of <CartService>")
		return "", errors.New(fmt.Errorf("insufficient funds: %d", int64(response.Price)-account.Wallet.Money), errors.ErrInsufficientFunds)
	}

	if _, err := receiver.walletService.WithdrawAccountWalletMoney(ctx, &models.WithdrawAccountWallet{
		Money:   int64(response.Price),
		Account: account,
	}); err != nil {
		receiver.logger.Error("failed to withdraw money on <Pay> of <CartService>", zap.Error(err))
		return "", err
	}

	if _, historyErr := receiver.historyService.CreateHistory(ctx, &models.History{
		Key:     models.CustomerHistoryKeyPayCart,
		UserID:  account.UserID,
		Comment: "Успешная оплата корзины",
	}); historyErr != nil {
		receiver.logger.Error("failed to insert history on <Pay> of <CartService>", zap.Error(historyErr))
	}

	if _, err := receiver.repository.ClearCart(ctx, account.UserID); err != nil {
		receiver.logger.Error("failed to clear cart on <Pay> of <CartService>", zap.Error(err))
		return "", err
	}

	return "", nil
}