first

backend/internal/modules/orders/service.go

@@ -0,0 +1,171 @@
+package orders
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/google/uuid"
+
+	"backend/internal/modules/pricing"
+	"backend/internal/modules/products"
+	"backend/internal/modules/units"
+)
+
+var (
+	ErrEmptyOrder      = errors.New("order must contain at least one item")
+	ErrInvalidStatus   = errors.New("invalid order status")
+	ErrProductMismatch = errors.New("price tier does not belong to the requested product")
+)
+
+// The dependencies below are the minimal slices of other modules' services
+// this module needs, defined on the consumer side (Go idiom) so orders
+// never has to import their concrete handler/repository types.
+type ProductFinder interface {
+	Get(ctx context.Context, id uuid.UUID) (*products.Product, error)
+}
+
+type UnitFinder interface {
+	Get(ctx context.Context, id uuid.UUID) (*units.Unit, error)
+}
+
+type PriceResolver interface {
+	PriceForQuantity(ctx context.Context, tierID uuid.UUID, multiplier int64) (int64, *pricing.PriceTier, error)
+}
+
+// OrderNotifier is satisfied by the telegram module's Service (and, later,
+// any other notification channel) without orders ever depending on it
+// directly.
+type OrderNotifier interface {
+	NotifyNewOrder(ctx context.Context, summary string)
+	NotifyOrderStatusChange(ctx context.Context, summary string)
+}
+
+type Service struct {
+	repo     Repository
+	products ProductFinder
+	units    UnitFinder
+	prices   PriceResolver
+	notifier OrderNotifier
+}
+
+func NewService(repo Repository, products ProductFinder, units UnitFinder, prices PriceResolver, notifier OrderNotifier) *Service {
+	return &Service{repo: repo, products: products, units: units, prices: prices, notifier: notifier}
+}
+
+type ItemInput struct {
+	ProductID   uuid.UUID
+	PriceTierID uuid.UUID
+	Multiplier  int64
+}
+
+type CreateInput struct {
+	CustomerName  string
+	CustomerEmail string
+	CustomerPhone string
+	Notes         string
+	Items         []ItemInput
+}
+
+func (s *Service) Create(ctx context.Context, in CreateInput) (*Order, []*OrderItem, error) {
+	if len(in.Items) == 0 {
+		return nil, nil, ErrEmptyOrder
+	}
+
+	order := &Order{
+		ID:            uuid.New(),
+		CustomerName:  in.CustomerName,
+		CustomerEmail: in.CustomerEmail,
+		CustomerPhone: in.CustomerPhone,
+		Status:        StatusPending,
+		Notes:         in.Notes,
+	}
+
+	items := make([]*OrderItem, 0, len(in.Items))
+	var total int64
+
+	for _, in := range in.Items {
+		multiplier := in.Multiplier
+		if multiplier < 1 {
+			multiplier = 1
+		}
+
+		lineTotal, tier, err := s.prices.PriceForQuantity(ctx, in.PriceTierID, multiplier)
+		if err != nil {
+			return nil, nil, fmt.Errorf("resolve price tier %s: %w", in.PriceTierID, err)
+		}
+		if tier.ProductID != in.ProductID {
+			return nil, nil, ErrProductMismatch
+		}
+
+		product, err := s.products.Get(ctx, in.ProductID)
+		if err != nil {
+			return nil, nil, fmt.Errorf("resolve product %s: %w", in.ProductID, err)
+		}
+		unit, err := s.units.Get(ctx, tier.UnitID)
+		if err != nil {
+			return nil, nil, fmt.Errorf("resolve unit %s: %w", tier.UnitID, err)
+		}
+
+		items = append(items, &OrderItem{
+			ID:             uuid.New(),
+			ProductID:      &product.ID,
+			ProductName:    product.Name,
+			PriceTierID:    &tier.ID,
+			UnitSymbol:     unit.Symbol,
+			TierQuantity:   tier.Quantity,
+			Multiplier:     multiplier,
+			UnitPriceCents: tier.PriceCents,
+			TotalCents:     lineTotal,
+		})
+		total += lineTotal
+	}
+
+	order.TotalCents = total
+
+	if err := s.repo.Create(ctx, order, items); err != nil {
+		return nil, nil, err
+	}
+
+	s.notifier.NotifyNewOrder(context.Background(), summarizeNewOrder(order, items))
+
+	return order, items, nil
+}
+
+func (s *Service) Get(ctx context.Context, id uuid.UUID) (*Order, []*OrderItem, error) {
+	return s.repo.FindByID(ctx, id)
+}
+
+func (s *Service) List(ctx context.Context, status string) ([]*Order, error) {
+	return s.repo.List(ctx, status)
+}
+
+func (s *Service) UpdateStatus(ctx context.Context, id uuid.UUID, status string) (*Order, error) {
+	if !ValidStatuses[status] {
+		return nil, ErrInvalidStatus
+	}
+	order, err := s.repo.UpdateStatus(ctx, id, status)
+	if err != nil {
+		return nil, err
+	}
+	s.notifier.NotifyOrderStatusChange(context.Background(), fmt.Sprintf(
+		"Order %s status changed to %q (customer: %s)", order.ID, order.Status, order.CustomerName,
+	))
+	return order, nil
+}
+
+func summarizeNewOrder(order *Order, items []*OrderItem) string {
+	var b strings.Builder
+	fmt.Fprintf(&b, "New order from %s (%s)\n", order.CustomerName, order.CustomerEmail)
+	for _, item := range items {
+		fmt.Fprintf(&b, "- %dx %s (%.2f %s) = %.2f\n",
+			item.Multiplier, item.ProductName, item.TierQuantity, item.UnitSymbol, centsToUnits(item.TotalCents))
+	}
+	fmt.Fprintf(&b, "Total: %.2f", centsToUnits(order.TotalCents))
+	return b.String()
+}
+
+func centsToUnits(cents int64) float64 {
+	return float64(cents) / 100
+}