traditional_implementation.py

# traditional/main.py
import asyncio
import json
import logging
import time
from datetime import datetime
from typing import Dict, Optional
from dataclasses import dataclass, asdict
from enum import Enum

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class OrderStatus(Enum):
    PENDING = "pending"
    INVENTORY_CHECKED = "inventory_checked"
    PAYMENT_PROCESSED = "payment_processed"
    INVENTORY_RESERVED = "inventory_reserved"
    SHIPPED = "shipped"
    COMPLETED = "completed"
    FAILED = "failed"

@dataclass
class OrderDetails:
    order_id: str
    customer_id: str
    items: list
    total_amount: float
    status: OrderStatus = OrderStatus.PENDING
    created_at: datetime = None
    updated_at: datetime = None
    failure_reason: Optional[str] = None

class SimpleDatabase:
    """Simple in-memory database simulation"""
    def __init__(self):
        self.orders = {}
        self.inventory = {
            "laptop": 5,
            "mouse": 20,
            "keyboard": 15
        }
    
    def save_order(self, order: OrderDetails):
        order.updated_at = datetime.now()
        self.orders[order.order_id] = order
        logger.info(f"Order {order.order_id} saved with status {order.status.value}")
    
    def get_order(self, order_id: str) -> Optional[OrderDetails]:
        return self.orders.get(order_id)
    
    def check_inventory(self, item: str, quantity: int) -> bool:
        return self.inventory.get(item, 0) >= quantity
    
    def reserve_inventory(self, item: str, quantity: int) -> bool:
        if self.check_inventory(item, quantity):
            self.inventory[item] -= quantity
            logger.info(f"Reserved {quantity} {item}(s). Remaining: {self.inventory[item]}")
            return True
        return False

class TraditionalOrderProcessor:
    def __init__(self):
        self.db = SimpleDatabase()
        self.max_retries = 3
        self.retry_delay = 1.0
    
    async def process_order(self, order_details: Dict) -> bool:
        """Process order with manual state management and error handling"""
        order = OrderDetails(
            order_id=order_details["order_id"],
            customer_id=order_details["customer_id"],
            items=order_details["items"],
            total_amount=order_details["total_amount"],
            created_at=datetime.now()
        )
        
        try:
            # Step 1: Check Inventory
            if not await self._check_inventory_with_retry(order):
                order.status = OrderStatus.FAILED
                order.failure_reason = "Insufficient inventory"
                self.db.save_order(order)
                return False
            
            order.status = OrderStatus.INVENTORY_CHECKED
            self.db.save_order(order)
            
            # Step 2: Process Payment
            if not await self._process_payment_with_retry(order):
                order.status = OrderStatus.FAILED
                order.failure_reason = "Payment processing failed"
                self.db.save_order(order)
                return False
            
            order.status = OrderStatus.PAYMENT_PROCESSED
            self.db.save_order(order)
            
            # Step 3: Reserve Inventory
            if not await self._reserve_inventory_with_retry(order):
                order.status = OrderStatus.FAILED
                order.failure_reason = "Inventory reservation failed"
                self.db.save_order(order)
                # Should rollback payment here - complex compensation logic needed
                await self._rollback_payment(order)
                return False
            
            order.status = OrderStatus.INVENTORY_RESERVED
            self.db.save_order(order)
            
            # Step 4: Ship Order
            if not await self._ship_order_with_retry(order):
                order.status = OrderStatus.FAILED
                order.failure_reason = "Shipping failed"
                self.db.save_order(order)
                # Complex rollback needed for payment and inventory
                await self._rollback_payment(order)
                await self._rollback_inventory(order)
                return False
            
            order.status = OrderStatus.SHIPPED
            self.db.save_order(order)
            
            # Step 5: Send Notification
            await self._send_notification_with_retry(order)
            
            order.status = OrderStatus.COMPLETED
            self.db.save_order(order)
            
            logger.info(f"Order {order.order_id} completed successfully")
            return True
            
        except Exception as e:
            order.status = OrderStatus.FAILED
            order.failure_reason = str(e)
            self.db.save_order(order)
            logger.error(f"Order {order.order_id} failed: {e}")
            return False
    
    async def _check_inventory_with_retry(self, order: OrderDetails) -> bool:
        """Check inventory with manual retry logic"""
        for attempt in range(self.max_retries):
            try:
                logger.info(f"Checking inventory for order {order.order_id} (attempt {attempt + 1})")
                
                # Simulate potential failure
                if attempt == 0:
                    raise Exception("Inventory service temporarily unavailable")
                
                for item_data in order.items:
                    if not self.db.check_inventory(item_data["name"], item_data["quantity"]):
                        return False
                
                return True
                
            except Exception as e:
                logger.warning(f"Inventory check failed (attempt {attempt + 1}): {e}")
                if attempt < self.max_retries - 1:
                    await asyncio.sleep(self.retry_delay * (2 ** attempt))  # Exponential backoff
                else:
                    raise
    
    async def _process_payment_with_retry(self, order: OrderDetails) -> bool:
        """Process payment with manual retry logic"""
        for attempt in range(self.max_retries):
            try:
                logger.info(f"Processing payment for order {order.order_id} (attempt {attempt + 1})")
                
                # Simulate payment processing
                await asyncio.sleep(0.5)
                
                # Simulate occasional failure
                import random
                if random.random() < 0.3:  # 30% failure rate
                    raise Exception("Payment gateway timeout")
                
                logger.info(f"Payment of ${order.total_amount} processed successfully")
                return True
                
            except Exception as e:
                logger.warning(f"Payment processing failed (attempt {attempt + 1}): {e}")
                if attempt < self.max_retries - 1:
                    await asyncio.sleep(self.retry_delay * (2 ** attempt))
                else:
                    raise
    
    async def _reserve_inventory_with_retry(self, order: OrderDetails) -> bool:
        """Reserve inventory with manual retry logic"""
        for attempt in range(self.max_retries):
            try:
                logger.info(f"Reserving inventory for order {order.order_id} (attempt {attempt + 1})")
                
                for item_data in order.items:
                    if not self.db.reserve_inventory(item_data["name"], item_data["quantity"]):
                        raise Exception(f"Failed to reserve {item_data['name']}")
                
                return True
                
            except Exception as e:
                logger.warning(f"Inventory reservation failed (attempt {attempt + 1}): {e}")
                if attempt < self.max_retries - 1:
                    await asyncio.sleep(self.retry_delay)
                else:
                    raise
    
    async def _ship_order_with_retry(self, order: OrderDetails) -> bool:
        """Ship order with manual retry logic"""
        for attempt in range(self.max_retries):
            try:
                logger.info(f"Shipping order {order.order_id} (attempt {attempt + 1})")
                
                # Simulate shipping process
                await asyncio.sleep(0.3)
                
                # Simulate potential shipping failure
                import random
                if random.random() < 0.2:  # 20% failure rate
                    raise Exception("Shipping label generation failed")
                
                logger.info(f"Order {order.order_id} shipped successfully")
                return True
                
            except Exception as e:
                logger.warning(f"Shipping failed (attempt {attempt + 1}): {e}")
                if attempt < self.max_retries - 1:
                    await asyncio.sleep(self.retry_delay)
                else:
                    raise
    
    async def _send_notification_with_retry(self, order: OrderDetails) -> bool:
        """Send notification with manual retry logic"""
        for attempt in range(self.max_retries):
            try:
                logger.info(f"Sending notification for order {order.order_id} (attempt {attempt + 1})")
                
                # Simulate notification sending
                await asyncio.sleep(0.2)
                
                logger.info(f"Notification sent for order {order.order_id}")
                return True
                
            except Exception as e:
                logger.warning(f"Notification failed (attempt {attempt + 1}): {e}")
                if attempt < self.max_retries - 1:
                    await asyncio.sleep(self.retry_delay)
                # Don't fail the entire order for notification failure
                
        return False
    
    async def _rollback_payment(self, order: OrderDetails):
        """Rollback payment - complex compensation logic"""
        logger.info(f"Rolling back payment for order {order.order_id}")
        # Implement payment rollback logic
        pass
    
    async def _rollback_inventory(self, order: OrderDetails):
        """Rollback inventory reservation"""
        logger.info(f"Rolling back inventory for order {order.order_id}")
        for item_data in order.items:
            self.db.inventory[item_data["name"]] += item_data["quantity"]

# Demo execution
async def main():
    processor = TraditionalOrderProcessor()
    
    sample_order = {
        "order_id": "order_123",
        "customer_id": "customer_456",
        "items": [
            {"name": "laptop", "quantity": 1},
            {"name": "mouse", "quantity": 2}
        ],
        "total_amount": 1299.99
    }
    
    print("=== Traditional Order Processing Demo ===")
    print(f"Processing order: {sample_order['order_id']}")
    print(f"Items: {sample_order['items']}")
    print(f"Total: ${sample_order['total_amount']}")
    print()
    
    success = await processor.process_order(sample_order)
    
    if success:
        print("✅ Order processed successfully!")
    else:
        print("❌ Order processing failed!")
    
    # Show final order state
    final_order = processor.db.get_order(sample_order["order_id"])
    print(f"\nFinal order status: {final_order.status.value}")
    if final_order.failure_reason:
        print(f"Failure reason: {final_order.failure_reason}")

if __name__ == "__main__":
    asyncio.run(main())