ALD Python Example

"""
Core domain contracts for order pricing and validation.
Framework-agnostic, immutable DTOs, role-based interfaces.
"""
from abc import ABC, abstractmethod
from dataclasses import dataclass
from decimal import Decimal
from enum import Enum
from typing import Optional


class CustomerSegment(Enum):
    """Customer tier classification."""
    STANDARD = "standard"
    PREMIUM = "premium"
    ENTERPRISE = "enterprise"


@dataclass(frozen=True)
class OrderLineItem:
    """Represents a single line item in an order."""
    product_id: str
    quantity: int
    unit_price: Decimal
    
    def __post_init__(self):
        if self.quantity <= 0:
            raise ValueError("Quantity must be positive")
        if self.unit_price < Decimal("0"):
            raise ValueError("Unit price cannot be negative")


@dataclass(frozen=True)
class OrderDraft:
    """
    An order before submission.
    Immutable snapshot for validation and pricing.
    """
    order_id: str
    customer_id: str
    customer_segment: CustomerSegment
    line_items: tuple[OrderLineItem, ...]
    promo_code: Optional[str] = None
    
    def __post_init__(self):
        if not self.line_items:
            raise ValueError("Order must have at least one line item")


@dataclass(frozen=True)
class PricingResult:
    """Output of pricing calculation."""
    subtotal: Decimal
    discount: Decimal
    tax: Decimal
    total: Decimal
    applied_promo: Optional[str] = None


@dataclass(frozen=True)
class ValidationResult:
    """Outcome of order validation."""
    is_valid: bool
    errors: tuple[str, ...] = ()


class OrderPricingStrategy(ABC):
    """
    Role: Calculate order pricing based on business rules.
    Pattern: Strategy
    Responsibility: Price calculation (single responsibility)
    """
    
    @abstractmethod
    def calculate_price(self, order: OrderDraft) -> PricingResult:
        """
        Calculate final pricing for an order draft.
        
        Args:
            order: The order to price
            
        Returns:
            Complete pricing breakdown
            
        Raises:
            ValueError: If order data is invalid for pricing
        """
        pass


class OrderSubmissionValidator(ABC):
    """
    Role: Validate order before submission.
    Pattern: Strategy/Policy
    Responsibility: Business rule validation (single responsibility)
    """
    
    @abstractmethod
    def validate(self, order: OrderDraft) -> ValidationResult:
        """
        Validate order meets business rules for submission.
        
        Args:
            order: The order to validate
            
        Returns:
            Validation result with any error messages
        """
        pass

"""
Concrete implementations of pricing and validation contracts.
Strategy pattern: different pricing strategies can be swapped.
"""
from decimal import Decimal
from typing import Optional
from contracts import (
    OrderDraft, OrderLineItem, CustomerSegment,
    PricingResult, ValidationResult,
    OrderPricingStrategy, OrderSubmissionValidator
)


class StandardPricingStrategy(OrderPricingStrategy):
    """
    Standard pricing implementation with segment-based discounts.
    
    Business rules:
    - Standard customers: no discount
    - Premium customers: 10% discount
    - Enterprise customers: 15% discount
    - Promo codes: additional fixed discount
    - Tax rate: 8%
    """
    
    # Configuration (could be injected via constructor for flexibility)
    SEGMENT_DISCOUNTS = {
        CustomerSegment.STANDARD: Decimal("0"),
        CustomerSegment.PREMIUM: Decimal("0.10"),
        CustomerSegment.ENTERPRISE: Decimal("0.15"),
    }
    
    PROMO_CODES = {
        "SAVE10": Decimal("10.00"),
        "SAVE20": Decimal("20.00"),
        "WELCOME": Decimal("5.00"),
    }
    
    TAX_RATE = Decimal("0.08")
    
    def calculate_price(self, order: OrderDraft) -> PricingResult:
        """Calculate pricing with discounts and tax."""
        # Calculate subtotal
        subtotal = sum(
            item.unit_price * item.quantity
            for item in order.line_items
        )
        
        # Apply segment discount
        segment_discount_rate = self.SEGMENT_DISCOUNTS[order.customer_segment]
        segment_discount = subtotal * segment_discount_rate
        
        # Apply promo code discount
        promo_discount = Decimal("0")
        applied_promo: Optional[str] = None
        
        if order.promo_code and order.promo_code in self.PROMO_CODES:
            promo_discount = self.PROMO_CODES[order.promo_code]
            applied_promo = order.promo_code
        
        total_discount = segment_discount + promo_discount
        
        # Calculate tax on discounted amount
        taxable_amount = subtotal - total_discount
        tax = taxable_amount * self.TAX_RATE
        
        # Calculate final total
        total = subtotal - total_discount + tax
        
        return PricingResult(
            subtotal=subtotal,
            discount=total_discount,
            tax=tax,
            total=total,
            applied_promo=applied_promo
        )


class StandardSubmissionValidator(OrderSubmissionValidator):
    """
    Validates orders against business rules before submission.
    
    Business rules:
    - Max quantity per line item: 1000 (standard/premium), 10000 (enterprise)
    - Max order total: $50,000 (standard/premium), unlimited (enterprise)
    - Must have at least one line item (enforced by DTO)
    """
    
    MAX_QUANTITY_STANDARD = 1000
    MAX_QUANTITY_ENTERPRISE = 10000
    MAX_ORDER_TOTAL_STANDARD = Decimal("50000.00")
    
    def validate(self, order: OrderDraft) -> ValidationResult:
        """Validate order against business rules."""
        errors = []
        
        # Check quantity limits
        max_quantity = (
            self.MAX_QUANTITY_ENTERPRISE
            if order.customer_segment == CustomerSegment.ENTERPRISE
            else self.MAX_QUANTITY_STANDARD
        )
        
        for item in order.line_items:
            if item.quantity > max_quantity:
                errors.append(
                    f"Line item {item.product_id} exceeds maximum quantity "
                    f"of {max_quantity}"
                )
        
        # Check order total limits (only for non-enterprise)
        if order.customer_segment != CustomerSegment.ENTERPRISE:
            order_subtotal = sum(
                item.unit_price * item.quantity
                for item in order.line_items
            )
            
            if order_subtotal > self.MAX_ORDER_TOTAL_STANDARD:
                errors.append(
                    f"Order total ${order_subtotal} exceeds limit of "
                    f"${self.MAX_ORDER_TOTAL_STANDARD} for {order.customer_segment.value} customers"
                )
        
        return ValidationResult(
            is_valid=len(errors) == 0,
            errors=tuple(errors)
        )

"""
FastAPI adapter layer.
Maps HTTP requests to domain contracts.
"""
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from decimal import Decimal
from typing import Optional

from contracts import (
    OrderDraft, OrderLineItem, CustomerSegment,
    OrderPricingStrategy, OrderSubmissionValidator
)
from implementations import StandardPricingStrategy, StandardSubmissionValidator


# Pydantic models for HTTP (separate from domain DTOs)
class LineItemRequest(BaseModel):
    product_id: str
    quantity: int
    unit_price: Decimal


class OrderRequest(BaseModel):
    order_id: str
    customer_id: str
    customer_segment: str
    line_items: list[LineItemRequest]
    promo_code: Optional[str] = None


class PriceResponse(BaseModel):
    subtotal: Decimal
    discount: Decimal
    tax: Decimal
    total: Decimal
    applied_promo: Optional[str] = None


# Dependency injection (could use FastAPI's Depends)
pricing_strategy: OrderPricingStrategy = StandardPricingStrategy()
validator: OrderSubmissionValidator = StandardSubmissionValidator()

app = FastAPI()


@app.post("/orders/calculate-price", response_model=PriceResponse)
def calculate_order_price(request: OrderRequest):
    """
    Calculate pricing for an order.
    Adapter: HTTP request → domain contract → HTTP response
    """
    # Map HTTP request to domain DTO
    try:
        order = OrderDraft(
            order_id=request.order_id,
            customer_id=request.customer_id,
            customer_segment=CustomerSegment(request.customer_segment),
            line_items=tuple(
                OrderLineItem(
                    product_id=item.product_id,
                    quantity=item.quantity,
                    unit_price=item.unit_price
                )
                for item in request.line_items
            ),
            promo_code=request.promo_code
        )
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))
    
    # Execute domain logic
    result = pricing_strategy.calculate_price(order)
    
    # Map domain result to HTTP response
    return PriceResponse(
        subtotal=result.subtotal,
        discount=result.discount,
        tax=result.tax,
        total=result.total,
        applied_promo=result.applied_promo
    )


@app.post("/orders/validate")
def validate_order(request: OrderRequest):
    """Validate order before submission."""
    try:
        order = OrderDraft(
            order_id=request.order_id,
            customer_id=request.customer_id,
            customer_segment=CustomerSegment(request.customer_segment),
            line_items=tuple(
                OrderLineItem(
                    product_id=item.product_id,
                    quantity=item.quantity,
                    unit_price=item.unit_price
                )
                for item in request.line_items
            ),
            promo_code=request.promo_code
        )
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))
    
    result = validator.validate(order)
    
    if not result.is_valid:
        raise HTTPException(
            status_code=422,
            detail={"errors": list(result.errors)}
        )
    
    return {"status": "valid"}