[hw-3] loms service

loms/internal/domain/service/service.go

@@ -0,0 +1,186 @@
+package service
+
+import (
+	"context"
+	"fmt"
+	"slices"
+
+	"route256/loms/internal/domain/entity"
+	"route256/loms/internal/domain/model"
+
+	pb "route256/pkg/api/loms/v1"
+
+	"github.com/rs/zerolog/log"
+)
+
+//go:generate minimock -i OrderRepository -o ./mock -s _mock.go
+type OrderRepository interface {
+	OrderCreate(ctx context.Context, order *entity.Order) (entity.ID, error)
+	OrderSetStatus(ctx context.Context, orderID entity.ID, newStatus string) error
+	OrderGetByID(ctx context.Context, orderID entity.ID) (*entity.Order, error)
+}
+
+//go:generate minimock -i StockRepository -o ./mock -s _mock.go
+type StockRepository interface {
+	StockReserve(ctx context.Context, stock *entity.Stock) error
+	StockReserveRemove(ctx context.Context, stock *entity.Stock) error
+	StockCancel(ctx context.Context, stock *entity.Stock) error
+	StockGetByID(ctx context.Context, sku entity.Sku) (*entity.Stock, error)
+}
+
+type LomsService struct {
+	orders OrderRepository
+	stocks StockRepository
+}
+
+func NewLomsService(orderRepo OrderRepository, stockRepo StockRepository) *LomsService {
+	return &LomsService{
+		orders: orderRepo,
+		stocks: stockRepo,
+	}
+}
+
+func (s *LomsService) rollbackStocks(ctx context.Context, stocks []*entity.Stock) {
+	for _, stock := range stocks {
+		if err := s.stocks.StockCancel(ctx, stock); err != nil {
+			log.Error().Err(err).Msg("failed to rollback stock")
+		}
+	}
+}
+
+func (s *LomsService) OrderCreate(ctx context.Context, orderReq *pb.OrderCreateRequest) (entity.ID, error) {
+	if orderReq == nil || orderReq.UserId <= 0 || len(orderReq.Items) == 0 {
+		return 0, model.ErrInvalidInput
+	}
+
+	for _, item := range orderReq.Items {
+		if item.Sku <= 0 || item.Count == 0 {
+			return 0, model.ErrInvalidInput
+		}
+	}
+
+	order := &entity.Order{
+		OrderID: 0,
+		Status:  pb.OrderStatus_ORDER_STATUS_NEW.String(),
+		UserID:  entity.ID(orderReq.UserId),
+		Items:   make([]entity.OrderItem, len(orderReq.Items)),
+	}
+
+	for i, item := range orderReq.Items {
+		order.Items[i] = entity.OrderItem{
+			ID:    entity.Sku(item.Sku),
+			Count: item.Count,
+		}
+	}
+
+	slices.SortStableFunc(order.Items, func(a, b entity.OrderItem) int {
+		return int(a.ID - b.ID)
+	})
+
+	id, err := s.orders.OrderCreate(ctx, order)
+	if err != nil {
+		return 0, fmt.Errorf("orders.OrderCreate: %w", err)
+	}
+
+	order.OrderID = id
+
+	commitedStocks := make([]*entity.Stock, 0, len(order.Items))
+	for _, item := range order.Items {
+		stock := &entity.Stock{
+			Item:     item,
+			Reserved: item.Count,
+		}
+
+		if err := s.stocks.StockReserve(ctx, stock); err != nil {
+			s.rollbackStocks(ctx, commitedStocks)
+
+			if statusErr := s.orders.OrderSetStatus(ctx, order.OrderID, pb.OrderStatus_ORDER_STATUS_FAILED.String()); statusErr != nil {
+				log.Error().Err(statusErr).Msg("failed to update status on stock reserve fail")
+			}
+
+			return 0, fmt.Errorf("stocks.StockReserve: %w", err)
+		}
+
+		commitedStocks = append(commitedStocks, stock)
+	}
+
+	if err := s.orders.OrderSetStatus(ctx, order.OrderID, pb.OrderStatus_ORDER_STATUS_AWAITING_PAYMENT.String()); err != nil {
+		s.rollbackStocks(ctx, commitedStocks)
+
+		return 0, err
+	}
+
+	return order.OrderID, nil
+}
+
+func (s *LomsService) OrderInfo(ctx context.Context, orderID entity.ID) (*entity.Order, error) {
+	if orderID <= 0 {
+		return nil, model.ErrInvalidInput
+	}
+
+	return s.orders.OrderGetByID(ctx, orderID)
+}
+
+func (s *LomsService) OrderPay(ctx context.Context, orderID entity.ID) error {
+	order, err := s.OrderInfo(ctx, orderID)
+	if err != nil {
+		return err
+	}
+
+	switch order.Status {
+	case pb.OrderStatus_ORDER_STATUS_PAYED.String():
+		return nil
+	case pb.OrderStatus_ORDER_STATUS_AWAITING_PAYMENT.String():
+		for _, item := range order.Items {
+			if err := s.stocks.StockReserveRemove(ctx, &entity.Stock{
+				Item:     item,
+				Reserved: item.Count,
+			}); err != nil {
+				log.Error().Err(err).Msg("failed to free stock reservation")
+			}
+		}
+
+		return s.orders.OrderSetStatus(ctx, orderID, pb.OrderStatus_ORDER_STATUS_PAYED.String())
+	default:
+		return model.ErrOrderInvalidStatus
+	}
+}
+
+func (s *LomsService) OrderCancel(ctx context.Context, orderID entity.ID) error {
+	order, err := s.OrderInfo(ctx, orderID)
+	if err != nil {
+		return err
+	}
+
+	switch order.Status {
+	case pb.OrderStatus_ORDER_STATUS_CANCELLED.String():
+		return nil
+	case pb.OrderStatus_ORDER_STATUS_FAILED.String(), pb.OrderStatus_ORDER_STATUS_PAYED.String():
+		return model.ErrOrderInvalidStatus
+	}
+
+	stocks := make([]*entity.Stock, len(order.Items))
+	for i, item := range order.Items {
+		stocks[i] = &entity.Stock{
+			Item:     item,
+			Reserved: item.Count,
+		}
+	}
+
+	s.rollbackStocks(ctx, stocks)
+
+	return s.orders.OrderSetStatus(ctx, orderID, pb.OrderStatus_ORDER_STATUS_CANCELLED.String())
+}
+
+func (s *LomsService) StocksInfo(ctx context.Context, sku entity.Sku) (uint32, error) {
+	if sku <= 0 {
+		return 0, model.ErrInvalidInput
+	}
+
+	stock, err := s.stocks.StockGetByID(ctx, sku)
+	if err != nil {
+		return 0, err
+	}
+
+	return stock.Item.Count, nil
+}