Python Shopping Cart —
Domain-Driven Design
in Action.

from __future__ import annotations
from dataclasses import dataclass, field
from decimal import Decimal
from datetime import datetime
from typing import Dict, Union
import uuid


@dataclass(frozen=True)
class Money:
    amount: Decimal
    currency: str = "PHP"

    def __add__(self, other: 'Money') -> 'Money':
        if not isinstance(other, Money):
            return NotImplemented
        if self.currency != other.currency:
            raise ValueError("Cannot add different currencies")
        return Money(self.amount + other.amount, self.currency)

    def __mul__(self, quantity: Union[int, float, Decimal]) -> 'Money':
        if isinstance(quantity, float):
            quantity = Decimal(str(quantity))
        elif isinstance(quantity, int):
            quantity = Decimal(quantity)
        return Money(self.amount * quantity, self.currency)

    def __str__(self) -> str:
        if self.currency == "PHP":
            return f"₱{self.amount:,.2f}"
        return f"{self.amount:,.2f} {self.currency}"


@dataclass
class Product:
    id: str
    name: str
    description: str
    price: Money
    sku: str
    stock_quantity: int = 0

    def has_stock(self, qty: int = 1) -> bool:
        return self.stock_quantity >= qty

    def reduce_stock(self, qty: int) -> None:
        if qty <= 0:
            raise ValueError("Quantity to reduce must be positive")
        if not self.has_stock(qty):
            raise ValueError(f"Insufficient stock for {self.name}")
        self.stock_quantity -= qty


@dataclass
class CartItem:
    product: Product
    quantity: int
    added_at: datetime = field(default_factory=datetime.now)

    @property
    def subtotal(self) -> Money:
        return self.product.price * self.quantity


class ShoppingCart:
    def __init__(self, cart_id: str = None):
        self.id = cart_id or str(uuid.uuid4())
        self.items: Dict[str, CartItem] = {}
        self.created_at = datetime.now()
        self.updated_at = self.created_at

    def add_item(self, product: Product, quantity: int = 1) -> None:
        if quantity <= 0:
            return
        if not product.has_stock(quantity):
            raise ValueError(f"Not enough stock for {product.name}")
        if product.id in self.items:
            current = self.items[product.id]
            new_qty = current.quantity + quantity
            if not product.has_stock(new_qty):
                raise ValueError(f"Not enough stock for {product.name}")
            self.items[product.id] = CartItem(
                product=product,
                quantity=new_qty,
                added_at=current.added_at
            )
        else:
            self.items[product.id] = CartItem(
                product=product,
                quantity=quantity,
                added_at=datetime.now()
            )
        self.updated_at = datetime.now()

    def remove_item(self, product_id: str) -> None:
        if product_id in self.items:
            del self.items[product_id]
            self.updated_at = datetime.now()

    def clear(self) -> None:
        self.items.clear()
        self.updated_at = datetime.now()

    @property
    def total(self) -> Money:
        if not self.items:
            return Money(Decimal(0))
        total = Money(Decimal(0))
        for item in self.items.values():
            total += item.subtotal
        return total

    def __repr__(self) -> str:
        return f"ShoppingCart(id={self.id!r}, items={len(self.items)}, total={self.total})"


class InMemoryCartRepository:
    def __init__(self):
        self._store: Dict[str, ShoppingCart] = {}

    def save(self, cart: ShoppingCart) -> None:
        self._store[cart.id] = cart

    def find_by_id(self, cart_id: str) -> ShoppingCart | None:
        return self._store.get(cart_id)

    def delete(self, cart_id: str) -> None:
        self._store.pop(cart_id, None)


if __name__ == "__main__":
    print("=" * 50)
    print("  Python Shopping Cart — DDD Demo")
    print("=" * 50)

    laptop = Product(
        id="p1",
        name="Laptop Pro 15",
        description="High-performance laptop",
        price=Money(Decimal("59999.00")),
        sku="LAP-PRO-15",
        stock_quantity=5
    )

    mouse = Product(
        id="p2",
        name="Wireless Mouse",
        description="Ergonomic wireless mouse",
        price=Money(Decimal("899.00")),
        sku="MSE-WRL-01",
        stock_quantity=20
    )

    bag = Product(
        id="p3",
        name="Laptop Bag",
        description="Padded 15-inch laptop bag",
        price=Money(Decimal("1299.00")),
        sku="BAG-LAP-15",
        stock_quantity=10
    )

    cart = ShoppingCart()
    repo = InMemoryCartRepository()

    print(f"\nCart ID : {cart.id}")
    print(f"Total   : {cart.total}  (empty cart)\n")

    print("Adding items...")
    cart.add_item(laptop, 1)
    cart.add_item(mouse, 2)
    cart.add_item(bag, 1)

    print(f"{'Product':<20} {'Qty':>5} {'Unit Price':>14} {'Subtotal':>14}")
    print("-" * 57)
    for item in cart.items.values():
        print(f"{item.product.name:<20} {item.quantity:>5} {str(item.product.price):>14} {str(item.subtotal):>14}")

    print("-" * 57)
    print(f"{'TOTAL':<20} {'':>5} {'':>14} {str(cart.total):>14}\n")

    print("Reducing stock after checkout...")
    for item in cart.items.values():
        item.product.reduce_stock(item.quantity)
        print(f"  {item.product.name}: stock remaining = {item.product.stock_quantity}")

    repo.save(cart)
    loaded = repo.find_by_id(cart.id)
    print(f"\nRepository round-trip OK: {loaded is cart}")

    print("\nTesting domain invariants...")
    try:
        cart.add_item(laptop, 999)
    except ValueError as e:
        print(f"  ✅ Caught expected error: {e}")

    try:
        laptop.reduce_stock(-1)
    except ValueError as e:
        print(f"  ✅ Caught expected error: {e}")

    print("\nDone.")