Initial commit - production deployment

services/orders/app/api/audit.py

@@ -0,0 +1,237 @@
+# services/orders/app/api/audit.py
+"""
+Audit Logs API - Retrieve audit trail for orders service
+"""
+
+from fastapi import APIRouter, Depends, HTTPException, Query, Path, status
+from typing import Optional, Dict, Any
+from uuid import UUID
+from datetime import datetime
+import structlog
+from sqlalchemy import select, func, and_
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.models import AuditLog
+from shared.auth.decorators import get_current_user_dep
+from shared.auth.access_control import require_user_role
+from shared.routing import RouteBuilder
+from shared.models.audit_log_schemas import (
+    AuditLogResponse,
+    AuditLogListResponse,
+    AuditLogStatsResponse
+)
+from app.core.database import database_manager
+
+route_builder = RouteBuilder('orders')
+router = APIRouter(tags=["audit-logs"])
+logger = structlog.get_logger()
+
+
+async def get_db():
+    """Database session dependency"""
+    async with database_manager.get_session() as session:
+        yield session
+
+
+@router.get(
+    route_builder.build_base_route("audit-logs"),
+    response_model=AuditLogListResponse
+)
+@require_user_role(['admin', 'owner'])
+async def get_audit_logs(
+    tenant_id: UUID = Path(..., description="Tenant ID"),
+    start_date: Optional[datetime] = Query(None, description="Filter logs from this date"),
+    end_date: Optional[datetime] = Query(None, description="Filter logs until this date"),
+    user_id: Optional[UUID] = Query(None, description="Filter by user ID"),
+    action: Optional[str] = Query(None, description="Filter by action type"),
+    resource_type: Optional[str] = Query(None, description="Filter by resource type"),
+    severity: Optional[str] = Query(None, description="Filter by severity level"),
+    search: Optional[str] = Query(None, description="Search in description field"),
+    limit: int = Query(100, ge=1, le=1000, description="Number of records to return"),
+    offset: int = Query(0, ge=0, description="Number of records to skip"),
+    current_user: Dict[str, Any] = Depends(get_current_user_dep),
+    db: AsyncSession = Depends(get_db)
+):
+    """
+    Get audit logs for orders service.
+    Requires admin or owner role.
+    """
+    try:
+        logger.info(
+            "Retrieving audit logs",
+            tenant_id=tenant_id,
+            user_id=current_user.get("user_id"),
+            filters={
+                "start_date": start_date,
+                "end_date": end_date,
+                "action": action,
+                "resource_type": resource_type,
+                "severity": severity
+            }
+        )
+
+        # Build query filters
+        filters = [AuditLog.tenant_id == tenant_id]
+
+        if start_date:
+            filters.append(AuditLog.created_at >= start_date)
+        if end_date:
+            filters.append(AuditLog.created_at <= end_date)
+        if user_id:
+            filters.append(AuditLog.user_id == user_id)
+        if action:
+            filters.append(AuditLog.action == action)
+        if resource_type:
+            filters.append(AuditLog.resource_type == resource_type)
+        if severity:
+            filters.append(AuditLog.severity == severity)
+        if search:
+            filters.append(AuditLog.description.ilike(f"%{search}%"))
+
+        # Count total matching records
+        count_query = select(func.count()).select_from(AuditLog).where(and_(*filters))
+        total_result = await db.execute(count_query)
+        total = total_result.scalar() or 0
+
+        # Fetch paginated results
+        query = (
+            select(AuditLog)
+            .where(and_(*filters))
+            .order_by(AuditLog.created_at.desc())
+            .limit(limit)
+            .offset(offset)
+        )
+
+        result = await db.execute(query)
+        audit_logs = result.scalars().all()
+
+        # Convert to response models
+        items = [AuditLogResponse.from_orm(log) for log in audit_logs]
+
+        logger.info(
+            "Successfully retrieved audit logs",
+            tenant_id=tenant_id,
+            total=total,
+            returned=len(items)
+        )
+
+        return AuditLogListResponse(
+            items=items,
+            total=total,
+            limit=limit,
+            offset=offset,
+            has_more=(offset + len(items)) < total
+        )
+
+    except Exception as e:
+        logger.error(
+            "Failed to retrieve audit logs",
+            error=str(e),
+            tenant_id=tenant_id
+        )
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to retrieve audit logs: {str(e)}"
+        )
+
+
+@router.get(
+    route_builder.build_base_route("audit-logs/stats"),
+    response_model=AuditLogStatsResponse
+)
+@require_user_role(['admin', 'owner'])
+async def get_audit_log_stats(
+    tenant_id: UUID = Path(..., description="Tenant ID"),
+    start_date: Optional[datetime] = Query(None, description="Filter logs from this date"),
+    end_date: Optional[datetime] = Query(None, description="Filter logs until this date"),
+    current_user: Dict[str, Any] = Depends(get_current_user_dep),
+    db: AsyncSession = Depends(get_db)
+):
+    """
+    Get audit log statistics for orders service.
+    Requires admin or owner role.
+    """
+    try:
+        logger.info(
+            "Retrieving audit log statistics",
+            tenant_id=tenant_id,
+            user_id=current_user.get("user_id")
+        )
+
+        # Build base filters
+        filters = [AuditLog.tenant_id == tenant_id]
+        if start_date:
+            filters.append(AuditLog.created_at >= start_date)
+        if end_date:
+            filters.append(AuditLog.created_at <= end_date)
+
+        # Total events
+        count_query = select(func.count()).select_from(AuditLog).where(and_(*filters))
+        total_result = await db.execute(count_query)
+        total_events = total_result.scalar() or 0
+
+        # Events by action
+        action_query = (
+            select(AuditLog.action, func.count().label('count'))
+            .where(and_(*filters))
+            .group_by(AuditLog.action)
+        )
+        action_result = await db.execute(action_query)
+        events_by_action = {row.action: row.count for row in action_result}
+
+        # Events by severity
+        severity_query = (
+            select(AuditLog.severity, func.count().label('count'))
+            .where(and_(*filters))
+            .group_by(AuditLog.severity)
+        )
+        severity_result = await db.execute(severity_query)
+        events_by_severity = {row.severity: row.count for row in severity_result}
+
+        # Events by resource type
+        resource_query = (
+            select(AuditLog.resource_type, func.count().label('count'))
+            .where(and_(*filters))
+            .group_by(AuditLog.resource_type)
+        )
+        resource_result = await db.execute(resource_query)
+        events_by_resource_type = {row.resource_type: row.count for row in resource_result}
+
+        # Date range
+        date_range_query = (
+            select(
+                func.min(AuditLog.created_at).label('min_date'),
+                func.max(AuditLog.created_at).label('max_date')
+            )
+            .where(and_(*filters))
+        )
+        date_result = await db.execute(date_range_query)
+        date_row = date_result.one()
+
+        logger.info(
+            "Successfully retrieved audit log statistics",
+            tenant_id=tenant_id,
+            total_events=total_events
+        )
+
+        return AuditLogStatsResponse(
+            total_events=total_events,
+            events_by_action=events_by_action,
+            events_by_severity=events_by_severity,
+            events_by_resource_type=events_by_resource_type,
+            date_range={
+                "min": date_row.min_date,
+                "max": date_row.max_date
+            }
+        )
+
+    except Exception as e:
+        logger.error(
+            "Failed to retrieve audit log statistics",
+            error=str(e),
+            tenant_id=tenant_id
+        )
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to retrieve audit log statistics: {str(e)}"
+        )

services/orders/app/api/customers.py

@@ -0,0 +1,322 @@
+# ================================================================
+# services/orders/app/api/customers.py
+# ================================================================
+"""
+Customers API endpoints - ATOMIC CRUD operations
+"""
+
+from typing import List
+from uuid import UUID
+from fastapi import APIRouter, Depends, HTTPException, Path, Query, status
+import structlog
+
+from shared.auth.decorators import get_current_user_dep
+from shared.auth.access_control import require_user_role
+from shared.routing import RouteBuilder
+from shared.security import create_audit_logger, AuditSeverity, AuditAction
+from app.core.database import get_db
+from app.services.orders_service import OrdersService
+from app.models import AuditLog
+from app.schemas.order_schemas import (
+    CustomerCreate,
+    CustomerUpdate,
+    CustomerResponse
+)
+
+logger = structlog.get_logger()
+audit_logger = create_audit_logger("orders-service", AuditLog)
+
+# Create route builder for consistent URL structure
+route_builder = RouteBuilder('orders')
+
+router = APIRouter()
+
+
+# ===== Dependency Injection =====
+
+async def get_orders_service(db = Depends(get_db)) -> OrdersService:
+    """Get orders service with dependencies"""
+    from app.repositories.order_repository import (
+        OrderRepository,
+        CustomerRepository,
+        OrderItemRepository,
+        OrderStatusHistoryRepository
+    )
+    from shared.clients import (
+        get_inventory_client,
+        get_production_client,
+        get_sales_client
+    )
+
+    return OrdersService(
+        order_repo=OrderRepository(),
+        customer_repo=CustomerRepository(),
+        order_item_repo=OrderItemRepository(),
+        status_history_repo=OrderStatusHistoryRepository(),
+        inventory_client=get_inventory_client(),
+        production_client=get_production_client(),
+        sales_client=get_sales_client()
+    )
+
+
+# ===== Customer CRUD Endpoints =====
+
+@router.post(
+    route_builder.build_base_route("customers"),
+    response_model=CustomerResponse,
+    status_code=status.HTTP_201_CREATED
+)
+@require_user_role(['admin', 'owner', 'member'])
+async def create_customer(
+    customer_data: CustomerCreate,
+    tenant_id: UUID = Path(...),
+    current_user: dict = Depends(get_current_user_dep),
+    orders_service: OrdersService = Depends(get_orders_service),
+    db = Depends(get_db)
+):
+    """Create a new customer"""
+    try:
+        # Check if customer code already exists
+        existing_customer = await orders_service.customer_repo.get_by_customer_code(
+            db, customer_data.customer_code, tenant_id
+        )
+        if existing_customer:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Customer code already exists"
+            )
+
+        # Extract user ID safely
+        user_id = current_user.get("user_id")
+        if not user_id:
+            logger.error("User ID not found in current_user context", current_user_keys=list(current_user.keys()))
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="User authentication error"
+            )
+        
+        customer = await orders_service.customer_repo.create(
+            db,
+            obj_in=customer_data,
+            created_by=UUID(user_id),
+            tenant_id=tenant_id
+        )
+
+        # Commit the transaction to persist changes
+        await db.commit()
+
+        logger.info("Customer created successfully",
+                   customer_id=str(customer.id),
+                   customer_code=customer.customer_code)
+
+        return CustomerResponse.from_orm(customer)
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error("Error creating customer", error=str(e))
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to create customer"
+        )
+
+
+@router.get(
+    route_builder.build_base_route("customers"),
+    response_model=List[CustomerResponse]
+)
+async def get_customers(
+    tenant_id: UUID = Path(...),
+    active_only: bool = Query(True, description="Filter for active customers only"),
+    skip: int = Query(0, ge=0, description="Number of customers to skip"),
+    limit: int = Query(100, ge=1, le=1000, description="Number of customers to return"),
+    current_user: dict = Depends(get_current_user_dep),
+    orders_service: OrdersService = Depends(get_orders_service),
+    db = Depends(get_db)
+):
+    """Get customers with filtering and pagination"""
+    try:
+        if active_only:
+            customers = await orders_service.customer_repo.get_active_customers(
+                db, tenant_id, skip, limit
+            )
+        else:
+            customers = await orders_service.customer_repo.get_multi(
+                db, tenant_id, skip, limit, order_by="name"
+            )
+
+        return [CustomerResponse.from_orm(customer) for customer in customers]
+
+    except Exception as e:
+        logger.error("Error getting customers", error=str(e))
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to retrieve customers"
+        )
+
+
+@router.get(
+    route_builder.build_resource_detail_route("customers", "customer_id"),
+    response_model=CustomerResponse
+)
+async def get_customer(
+    tenant_id: UUID = Path(...),
+    customer_id: UUID = Path(...),
+    current_user: dict = Depends(get_current_user_dep),
+    orders_service: OrdersService = Depends(get_orders_service),
+    db = Depends(get_db)
+):
+    """Get customer details by ID"""
+    try:
+        customer = await orders_service.customer_repo.get(db, customer_id, tenant_id)
+        if not customer:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Customer not found"
+            )
+
+        return CustomerResponse.from_orm(customer)
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error("Error getting customer",
+                    customer_id=str(customer_id),
+                    error=str(e))
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to retrieve customer"
+        )
+
+
+@router.put(
+    route_builder.build_resource_detail_route("customers", "customer_id"),
+    response_model=CustomerResponse
+)
+@require_user_role(['admin', 'owner', 'member'])
+async def update_customer(
+    customer_data: CustomerUpdate,
+    tenant_id: UUID = Path(...),
+    customer_id: UUID = Path(...),
+    current_user: dict = Depends(get_current_user_dep),
+    orders_service: OrdersService = Depends(get_orders_service),
+    db = Depends(get_db)
+):
+    """Update customer information"""
+    try:
+        # Get existing customer
+        customer = await orders_service.customer_repo.get(db, customer_id, tenant_id)
+        if not customer:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Customer not found"
+            )
+
+        # Update customer
+        # Extract user ID safely for update
+        user_id = current_user.get("user_id")
+        if not user_id:
+            logger.error("User ID not found in current_user context for update", current_user_keys=list(current_user.keys()))
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="User authentication error"
+            )
+
+        updated_customer = await orders_service.customer_repo.update(
+            db,
+            db_obj=customer,
+            obj_in=customer_data.dict(exclude_unset=True),
+            updated_by=UUID(user_id)
+        )
+
+        # Commit the transaction to persist changes
+        await db.commit()
+
+        logger.info("Customer updated successfully",
+                   customer_id=str(customer_id))
+
+        return CustomerResponse.from_orm(updated_customer)
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error("Error updating customer",
+                    customer_id=str(customer_id),
+                    error=str(e))
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to update customer"
+        )
+
+
+@router.delete(
+    route_builder.build_resource_detail_route("customers", "customer_id"),
+    status_code=status.HTTP_204_NO_CONTENT
+)
+@require_user_role(['admin', 'owner'])
+async def delete_customer(
+    tenant_id: UUID = Path(...),
+    customer_id: UUID = Path(...),
+    current_user: dict = Depends(get_current_user_dep),
+    orders_service: OrdersService = Depends(get_orders_service),
+    db = Depends(get_db)
+):
+    """
+    Delete a customer (Admin+ only, GDPR-compliant soft delete)
+    Removes PII while maintaining referential integrity
+    """
+    try:
+        customer = await orders_service.customer_repo.get(db, customer_id, tenant_id)
+        if not customer:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Customer not found"
+            )
+
+        # Capture customer data before deletion (for audit trail)
+        # Note: This is anonymized after retention period in compliance with GDPR
+        customer_data = {
+            "customer_code": customer.customer_code,
+            "customer_name": customer.customer_name,
+            "email": customer.email,
+            "phone": customer.phone,
+            "business_type": customer.business_type if hasattr(customer, 'business_type') else None
+        }
+
+        await orders_service.customer_repo.delete(db, customer_id, tenant_id)
+
+        # Commit the transaction to persist deletion
+        await db.commit()
+
+        # Log HIGH severity audit event for customer deletion (GDPR compliance)
+        try:
+            await audit_logger.log_deletion(
+                db_session=db,
+                tenant_id=str(tenant_id),
+                user_id=current_user["user_id"],
+                resource_type="customer",
+                resource_id=str(customer_id),
+                resource_data=customer_data,
+                description=f"Admin {current_user.get('email', 'unknown')} deleted customer {customer_data['customer_code']} (GDPR-compliant soft delete)",
+                endpoint=f"/customers/{customer_id}",
+                method="DELETE",
+                severity=AuditSeverity.HIGH.value
+            )
+        except Exception as audit_error:
+            logger.warning("Failed to log audit event", error=str(audit_error))
+
+        logger.info("Customer deleted successfully (GDPR-compliant)",
+                   customer_id=str(customer_id),
+                   tenant_id=str(tenant_id),
+                   user_id=current_user["user_id"])
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error("Error deleting customer",
+                    customer_id=str(customer_id),
+                    error=str(e))
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to delete customer"
+        )

services/orders/app/api/internal_demo.py

@@ -0,0 +1,455 @@
+"""
+Internal Demo Cloning API for Orders Service
+Service-to-service endpoint for cloning order and customer data
+"""
+
+from fastapi import APIRouter, Depends, HTTPException, Header
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, delete, func
+import structlog
+import uuid
+from datetime import datetime, timezone, timedelta, date
+from typing import Optional
+import os
+from decimal import Decimal
+import json
+from pathlib import Path
+
+from app.core.database import get_db
+from app.models.order import CustomerOrder, OrderItem
+from app.models.customer import Customer
+from shared.utils.demo_dates import adjust_date_for_demo, resolve_time_marker, get_next_workday
+
+from app.core.config import settings
+
+logger = structlog.get_logger()
+router = APIRouter(prefix="/internal/demo", tags=["internal"])
+
+# Base demo tenant IDs
+DEMO_TENANT_PROFESSIONAL = "a1b2c3d4-e5f6-47a8-b9c0-d1e2f3a4b5c6"
+
+
+def parse_date_field(date_value, session_time: datetime, field_name: str = "date") -> Optional[datetime]:
+    """
+    Parse date field, handling both ISO strings and BASE_TS markers.
+
+    Supports:
+    - BASE_TS markers: "BASE_TS + 1h30m", "BASE_TS - 2d"
+    - ISO 8601 strings: "2025-01-15T06:00:00Z"
+    - None values (returns None)
+
+    Returns timezone-aware datetime or None.
+    """
+    if not date_value:
+        return None
+
+    # Check if it's a BASE_TS marker
+    if isinstance(date_value, str) and date_value.startswith("BASE_TS"):
+        try:
+            return resolve_time_marker(date_value, session_time)
+        except ValueError as e:
+            logger.warning(
+                f"Invalid BASE_TS marker in {field_name}",
+                marker=date_value,
+                error=str(e)
+            )
+            return None
+
+    # Handle regular ISO date strings
+    try:
+        if isinstance(date_value, str):
+            original_date = datetime.fromisoformat(date_value.replace('Z', '+00:00'))
+        elif hasattr(date_value, 'isoformat'):
+            original_date = date_value
+        else:
+            logger.warning(f"Unsupported date format in {field_name}", date_value=date_value)
+            return None
+
+        return adjust_date_for_demo(original_date, session_time)
+    except (ValueError, AttributeError) as e:
+        logger.warning(
+            f"Invalid date format in {field_name}",
+            date_value=date_value,
+            error=str(e)
+        )
+        return None
+
+
+def ensure_workday(target_date: datetime) -> datetime:
+    """Ensure delivery date falls on a workday (Monday-Friday)"""
+    if target_date and target_date.weekday() >= 5:  # Saturday or Sunday
+        return get_next_workday(target_date)
+    return target_date
+
+
+@router.post("/clone")
+async def clone_demo_data(
+    base_tenant_id: str,
+    virtual_tenant_id: str,
+    demo_account_type: str,
+    session_id: Optional[str] = None,
+    session_created_at: Optional[str] = None,
+    db: AsyncSession = Depends(get_db)
+):
+    """
+    Clone orders service data for a virtual demo tenant
+
+    Clones:
+    - Customers
+    - Customer orders with line items
+    - Adjusts dates to recent timeframe
+
+    Args:
+        base_tenant_id: Template tenant UUID to clone from
+        virtual_tenant_id: Target virtual tenant UUID
+        demo_account_type: Type of demo account
+        session_id: Originating session ID for tracing
+
+    Returns:
+        Cloning status and record counts
+    """
+    start_time = datetime.now(timezone.utc)
+
+    # Parse session creation time for date adjustment
+    if session_created_at:
+        try:
+            session_time = datetime.fromisoformat(session_created_at.replace('Z', '+00:00'))
+        except (ValueError, AttributeError):
+            session_time = start_time
+    else:
+        session_time = start_time
+
+    logger.info(
+        "Starting orders data cloning",
+        base_tenant_id=base_tenant_id,
+        virtual_tenant_id=virtual_tenant_id,
+        demo_account_type=demo_account_type,
+        session_id=session_id,
+        session_created_at=session_created_at
+    )
+
+    try:
+        # Validate UUIDs
+        base_uuid = uuid.UUID(base_tenant_id)
+        virtual_uuid = uuid.UUID(virtual_tenant_id)
+
+        # Track cloning statistics
+        stats = {
+            "customers": 0,
+            "customer_orders": 0,
+            "order_line_items": 0,
+            "alerts_generated": 0
+        }
+
+        # Customer ID mapping (old -> new)
+        customer_id_map = {}
+
+        # Load Customers from seed data
+        try:
+            from shared.utils.seed_data_paths import get_seed_data_path
+            
+            if demo_account_type == "professional":
+                json_file = get_seed_data_path("professional", "08-orders.json")
+            elif demo_account_type == "enterprise":
+                json_file = get_seed_data_path("enterprise", "08-orders.json")
+            elif demo_account_type == "enterprise_child":
+                json_file = get_seed_data_path("enterprise", "08-orders.json", child_id=base_tenant_id)
+            else:
+                raise ValueError(f"Invalid demo account type: {demo_account_type}")
+
+        except ImportError:
+            # Fallback to original path
+            seed_data_dir = Path(__file__).parent.parent.parent.parent / "infrastructure" / "seed-data"
+            if demo_account_type == "professional":
+                json_file = seed_data_dir / "professional" / "08-orders.json"
+            elif demo_account_type == "enterprise":
+                json_file = seed_data_dir / "enterprise" / "parent" / "08-orders.json"
+            elif demo_account_type == "enterprise_child":
+                json_file = seed_data_dir / "enterprise" / "children" / base_tenant_id / "08-orders.json"
+            else:
+                raise ValueError(f"Invalid demo account type: {demo_account_type}")
+
+        if not json_file.exists():
+            raise HTTPException(
+                status_code=404,
+                detail=f"Seed data file not found: {json_file}"
+            )
+
+        # Load JSON data
+        with open(json_file, 'r', encoding='utf-8') as f:
+            seed_data = json.load(f)
+
+        logger.info(
+            "Loaded orders seed data",
+            customers=len(seed_data.get('customers', [])),
+            orders=len(seed_data.get('customer_orders', []))
+        )
+
+        # Load Customers from seed data
+        for customer_data in seed_data.get('customers', []):
+            # Transform IDs using XOR
+            from shared.utils.demo_id_transformer import transform_id
+            try:
+                customer_uuid = uuid.UUID(customer_data['id'])
+                transformed_id = transform_id(customer_data['id'], virtual_uuid)
+            except ValueError as e:
+                logger.error("Failed to parse customer UUID",
+                            customer_id=customer_data['id'],
+                            error=str(e))
+                continue
+
+            customer_id_map[uuid.UUID(customer_data['id'])] = transformed_id
+
+            new_customer = Customer(
+                id=transformed_id,
+                tenant_id=virtual_uuid,
+                customer_code=customer_data.get('customer_code'),
+                name=customer_data.get('name'),
+                business_name=customer_data.get('business_name'),
+                customer_type=customer_data.get('customer_type'),
+                tax_id=customer_data.get('tax_id'),
+                email=customer_data.get('email'),
+                phone=customer_data.get('phone'),
+                address_line1=customer_data.get('address_line1'),
+                address_line2=customer_data.get('address_line2'),
+                city=customer_data.get('city'),
+                state=customer_data.get('state'),
+                postal_code=customer_data.get('postal_code'),
+                country=customer_data.get('country'),
+                business_license=customer_data.get('business_license'),
+                is_active=customer_data.get('is_active', True),
+                preferred_delivery_method=customer_data.get('preferred_delivery_method'),
+                payment_terms=customer_data.get('payment_terms'),
+                credit_limit=customer_data.get('credit_limit', 0.0),
+                discount_percentage=customer_data.get('discount_percentage', 0.0),
+                customer_segment=customer_data.get('customer_segment'),
+                priority_level=customer_data.get('priority_level'),
+                special_instructions=customer_data.get('special_instructions'),
+                delivery_preferences=customer_data.get('delivery_preferences'),
+                product_preferences=customer_data.get('product_preferences'),
+                total_orders=customer_data.get('total_orders', 0),
+                total_spent=customer_data.get('total_spent', 0.0),
+                average_order_value=customer_data.get('average_order_value', 0.0),
+                last_order_date=parse_date_field(
+                    customer_data.get('last_order_date'),
+                    session_time,
+                    "last_order_date"
+                ),
+                created_at=session_time,
+                updated_at=session_time
+            )
+            db.add(new_customer)
+            stats["customers"] += 1
+
+        # Load Customer Orders from seed data
+        order_id_map = {}
+
+        for order_data in seed_data.get('customer_orders', []):
+            # Transform IDs using XOR
+            from shared.utils.demo_id_transformer import transform_id
+            try:
+                order_uuid = uuid.UUID(order_data['id'])
+                transformed_id = transform_id(order_data['id'], virtual_uuid)
+            except ValueError as e:
+                logger.error("Failed to parse order UUID",
+                            order_id=order_data['id'],
+                            error=str(e))
+                continue
+
+            order_id_map[uuid.UUID(order_data['id'])] = transformed_id
+
+            # Map customer_id if it exists in our map
+            customer_id_value = order_data.get('customer_id')
+            if customer_id_value:
+                customer_id_value = customer_id_map.get(uuid.UUID(customer_id_value), uuid.UUID(customer_id_value))
+
+            # Parse date fields (supports BASE_TS markers and ISO timestamps)
+            adjusted_order_date = parse_date_field(
+                order_data.get('order_date'),
+                session_time,
+                "order_date"
+            ) or session_time
+
+            # Handle delivery date - JSON uses 'delivery_date', database uses 'requested_delivery_date'
+            # Fallback to order_date + 2 hours if no delivery date is provided
+            delivery_date_value = order_data.get('delivery_date') or order_data.get('requested_delivery_date')
+            adjusted_requested_delivery = parse_date_field(
+                delivery_date_value,
+                session_time,
+                "requested_delivery_date"
+            )
+            
+            # Ensure requested_delivery_date is never None - fallback to order_date + 2 hours
+            if adjusted_requested_delivery is None:
+                adjusted_requested_delivery = adjusted_order_date + timedelta(hours=2)
+
+            # Create new order from seed data
+            # Generate unique order number by appending tenant-specific suffix
+            base_order_number = order_data.get('order_number', f"ORD-{uuid.uuid4().hex[:8].upper()}")
+            # Add tenant-specific suffix to ensure global uniqueness
+            tenant_suffix = virtual_uuid.hex[:4].upper()  # Use first 4 chars of tenant ID
+            unique_order_number = f"{base_order_number}-{tenant_suffix}"
+            
+            new_order = CustomerOrder(
+                id=str(transformed_id),
+                tenant_id=virtual_uuid,
+                order_number=unique_order_number,
+                customer_id=str(customer_id_value) if customer_id_value else None,
+                status=order_data.get('status', 'pending'),
+                order_type=order_data.get('order_type', 'standard'),
+                priority=order_data.get('priority', 'normal'),
+                order_date=adjusted_order_date,
+                requested_delivery_date=adjusted_requested_delivery,
+                delivery_method=order_data.get('delivery_method'),
+                delivery_address=order_data.get('delivery_address'),
+                delivery_instructions=order_data.get('delivery_instructions'),
+                subtotal=order_data.get('subtotal', 0.0),
+                tax_amount=order_data.get('tax_amount', 0.0),
+                discount_amount=order_data.get('discount_amount', 0.0),
+                discount_percentage=order_data.get('discount_percentage', 0.0),
+                delivery_fee=order_data.get('delivery_fee', 0.0),
+                total_amount=order_data.get('total_amount', 0.0),
+                payment_status=order_data.get('payment_status', 'pending'),
+                payment_method=order_data.get('payment_method'),
+                payment_terms=order_data.get('payment_terms'),
+                special_instructions=order_data.get('special_instructions'),
+                order_source=order_data.get('order_source', 'manual'),
+                sales_channel=order_data.get('sales_channel', 'direct'),
+                created_at=session_time,
+                updated_at=session_time
+            )
+            db.add(new_order)
+            stats["customer_orders"] += 1
+
+        # Clone Order Items
+        for old_order_id, new_order_id in order_id_map.items():
+            result = await db.execute(
+                select(OrderItem).where(OrderItem.order_id == old_order_id)
+            )
+            order_items = result.scalars().all()
+
+            for item in order_items:
+                new_item = OrderItem(
+                    id=uuid.uuid4(),
+                    order_id=new_order_id,
+                    product_id=item.product_id,
+                    product_name=item.product_name,
+                    product_sku=item.product_sku,
+                    quantity=item.quantity,
+                    unit_of_measure=item.unit_of_measure,
+                    unit_price=item.unit_price,
+                    line_discount=item.line_discount,
+                    line_total=item.line_total,
+                    status=item.status
+                )
+                db.add(new_item)
+                stats["order_line_items"] += 1
+
+        # Commit cloned data
+        await db.commit()
+
+        # NOTE: Alert generation removed - alerts are now generated automatically by the
+        # respective alert services which run scheduled checks at appropriate intervals.
+        # This eliminates duplicate alerts and provides a more realistic demo experience.
+        stats["alerts_generated"] = 0
+
+        total_records = stats["customers"] + stats["customer_orders"] + stats["order_line_items"]
+        duration_ms = int((datetime.now(timezone.utc) - start_time).total_seconds() * 1000)
+
+        logger.info(
+            "Orders data cloning completed",
+            virtual_tenant_id=virtual_tenant_id,
+            total_records=total_records,
+            stats=stats,
+            duration_ms=duration_ms
+        )
+
+        return {
+            "service": "orders",
+            "status": "completed",
+            "records_cloned": total_records,
+            "duration_ms": duration_ms,
+            "details": stats
+        }
+
+    except ValueError as e:
+        logger.error("Invalid UUID format", error=str(e))
+        raise HTTPException(status_code=400, detail=f"Invalid UUID: {str(e)}")
+
+    except Exception as e:
+        logger.error(
+            "Failed to clone orders data",
+            error=str(e),
+            virtual_tenant_id=virtual_tenant_id,
+            exc_info=True
+        )
+
+        # Rollback on error
+        await db.rollback()
+
+        return {
+            "service": "orders",
+            "status": "failed",
+            "records_cloned": 0,
+            "duration_ms": int((datetime.now(timezone.utc) - start_time).total_seconds() * 1000),
+            "error": str(e)
+        }
+
+
+@router.get("/clone/health")
+async def clone_health_check():
+    """
+    Health check for internal cloning endpoint
+    Used by orchestrator to verify service availability
+    """
+    return {
+        "service": "orders",
+        "clone_endpoint": "available",
+        "version": "2.0.0"
+    }
+
+
+@router.delete("/tenant/{virtual_tenant_id}")
+async def delete_demo_data(
+    virtual_tenant_id: str,
+    db: AsyncSession = Depends(get_db)
+):
+    """Delete all order data for a virtual demo tenant"""
+    logger.info("Deleting order data for virtual tenant", virtual_tenant_id=virtual_tenant_id)
+    start_time = datetime.now(timezone.utc)
+
+    try:
+        virtual_uuid = uuid.UUID(virtual_tenant_id)
+
+        # Count records
+        order_count = await db.scalar(select(func.count(CustomerOrder.id)).where(CustomerOrder.tenant_id == virtual_uuid))
+        item_count = await db.scalar(select(func.count(OrderItem.id)).join(CustomerOrder).where(CustomerOrder.tenant_id == virtual_uuid))
+        customer_count = await db.scalar(select(func.count(Customer.id)).where(Customer.tenant_id == virtual_uuid))
+
+        # Delete in order
+        await db.execute(delete(OrderItem).where(OrderItem.order_id.in_(
+            select(CustomerOrder.id).where(CustomerOrder.tenant_id == virtual_uuid)
+        )))
+        await db.execute(delete(CustomerOrder).where(CustomerOrder.tenant_id == virtual_uuid))
+        await db.execute(delete(Customer).where(Customer.tenant_id == virtual_uuid))
+        await db.commit()
+
+        duration_ms = int((datetime.now(timezone.utc) - start_time).total_seconds() * 1000)
+        logger.info("Order data deleted successfully", virtual_tenant_id=virtual_tenant_id, duration_ms=duration_ms)
+
+        return {
+            "service": "orders",
+            "status": "deleted",
+            "virtual_tenant_id": virtual_tenant_id,
+            "records_deleted": {
+                "orders": order_count,
+                "items": item_count,
+                "customers": customer_count,
+                "total": order_count + item_count + customer_count
+            },
+            "duration_ms": duration_ms
+        }
+    except Exception as e:
+        logger.error("Failed to delete order data", error=str(e), exc_info=True)
+        await db.rollback()
+        raise HTTPException(status_code=500, detail=str(e))

services/orders/app/api/order_operations.py

@@ -0,0 +1,237 @@
+# ================================================================
+# services/orders/app/api/order_operations.py
+# ================================================================
+"""
+Order Operations API endpoints - BUSINESS logic operations
+Includes status updates, demand calculation, dashboard, and business intelligence
+"""
+
+from datetime import date, datetime
+from typing import List, Optional
+from uuid import UUID
+from fastapi import APIRouter, Depends, HTTPException, Path, Query, status
+import structlog
+
+from shared.auth.decorators import get_current_user_dep
+from shared.routing import RouteBuilder
+from app.core.database import get_db
+from app.services.orders_service import OrdersService
+from app.schemas.order_schemas import (
+    OrderResponse,
+    OrdersDashboardSummary,
+    DemandRequirements
+)
+
+logger = structlog.get_logger()
+
+# Create route builder for consistent URL structure
+route_builder = RouteBuilder('orders')
+
+router = APIRouter()
+
+
+# ===== Dependency Injection =====
+
+async def get_orders_service(db = Depends(get_db)) -> OrdersService:
+    """Get orders service with dependencies"""
+    from app.repositories.order_repository import (
+        OrderRepository,
+        CustomerRepository,
+        OrderItemRepository,
+        OrderStatusHistoryRepository
+    )
+    from shared.clients import (
+        get_inventory_client,
+        get_production_client,
+        get_sales_client
+    )
+
+    return OrdersService(
+        order_repo=OrderRepository(),
+        customer_repo=CustomerRepository(),
+        order_item_repo=OrderItemRepository(),
+        status_history_repo=OrderStatusHistoryRepository(),
+        inventory_client=get_inventory_client(),
+        production_client=get_production_client(),
+        sales_client=get_sales_client()
+    )
+
+
+# ===== Dashboard and Analytics Endpoints =====
+
+@router.get(
+    route_builder.build_operations_route("dashboard-summary"),
+    response_model=OrdersDashboardSummary
+)
+async def get_dashboard_summary(
+    tenant_id: UUID = Path(...),
+    current_user: dict = Depends(get_current_user_dep),
+    orders_service: OrdersService = Depends(get_orders_service),
+    db = Depends(get_db)
+):
+    """Get comprehensive dashboard summary for orders"""
+    try:
+        summary = await orders_service.get_dashboard_summary(db, tenant_id)
+
+        logger.info("Dashboard summary retrieved",
+                   tenant_id=str(tenant_id),
+                   total_orders=summary.total_orders_today)
+
+        return summary
+
+    except Exception as e:
+        logger.error("Error getting dashboard summary",
+                    tenant_id=str(tenant_id),
+                    error=str(e))
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to retrieve dashboard summary"
+        )
+
+
+@router.get(
+    route_builder.build_base_route("demand-requirements"),
+    response_model=DemandRequirements
+)
+async def get_demand_requirements(
+    tenant_id: UUID = Path(...),
+    target_date: date = Query(..., description="Date for demand analysis"),
+    current_user: dict = Depends(get_current_user_dep),
+    orders_service: OrdersService = Depends(get_orders_service),
+    db = Depends(get_db)
+):
+    """Get demand requirements for production planning"""
+    try:
+        requirements = await orders_service.get_demand_requirements(db, tenant_id, target_date)
+
+        logger.info("Demand requirements calculated",
+                   tenant_id=str(tenant_id),
+                   target_date=str(target_date),
+                   total_orders=requirements.total_orders)
+
+        return requirements
+
+    except Exception as e:
+        logger.error("Error getting demand requirements",
+                    tenant_id=str(tenant_id),
+                    error=str(e))
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to calculate demand requirements"
+        )
+
+
+# ===== Order Status Management =====
+
+@router.put(
+    route_builder.build_base_route("{order_id}/status"),
+    response_model=OrderResponse
+)
+async def update_order_status(
+    new_status: str,
+    tenant_id: UUID = Path(...),
+    order_id: UUID = Path(...),
+    reason: Optional[str] = Query(None, description="Reason for status change"),
+    current_user: dict = Depends(get_current_user_dep),
+    orders_service: OrdersService = Depends(get_orders_service),
+    db = Depends(get_db)
+):
+    """Update order status with validation and history tracking"""
+    try:
+        # Validate status
+        valid_statuses = [
+            "pending", "confirmed", "in_production", "ready",
+            "out_for_delivery", "delivered", "cancelled", "failed"
+        ]
+        if new_status not in valid_statuses:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=f"Invalid status. Must be one of: {', '.join(valid_statuses)}"
+            )
+
+        order = await orders_service.update_order_status(
+            db,
+            order_id,
+            tenant_id,
+            new_status,
+            user_id=UUID(current_user["user_id"]),
+            reason=reason
+        )
+
+        if not order:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Order not found"
+            )
+
+        logger.info("Order status updated",
+                   order_id=str(order_id),
+                   new_status=new_status)
+
+        return order
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error("Error updating order status",
+                    order_id=str(order_id),
+                    error=str(e))
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to update order status"
+        )
+
+
+# ===== Business Intelligence Endpoints =====
+
+@router.get(
+    route_builder.build_base_route("business-model")
+)
+async def detect_business_model(
+    tenant_id: UUID = Path(...),
+    current_user: dict = Depends(get_current_user_dep),
+    orders_service: OrdersService = Depends(get_orders_service),
+    db = Depends(get_db)
+):
+    """Detect business model based on order patterns"""
+    try:
+        business_model = await orders_service.detect_business_model(db, tenant_id)
+
+        return {
+            "business_model": business_model,
+            "confidence": "high" if business_model else "unknown",
+            "detected_at": datetime.now().isoformat()
+        }
+
+    except Exception as e:
+        logger.error("Error detecting business model", error=str(e))
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to detect business model"
+        )
+
+
+# ===== Health and Status Endpoints =====
+
+@router.get(
+    route_builder.build_base_route("status")
+)
+async def get_service_status(
+    tenant_id: UUID = Path(...),
+    current_user: dict = Depends(get_current_user_dep)
+):
+    """Get orders service status"""
+    try:
+        return {
+            "service": "orders-service",
+            "status": "healthy",
+            "timestamp": datetime.now().isoformat(),
+            "tenant_id": str(tenant_id)
+        }
+
+    except Exception as e:
+        logger.error("Error getting service status", error=str(e))
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to get service status"
+        )

services/orders/app/api/orders.py

@@ -0,0 +1,405 @@
+# ================================================================
+# services/orders/app/api/orders.py
+# ================================================================
+"""
+Orders API endpoints - ATOMIC CRUD operations only
+"""
+
+from datetime import date
+from typing import List, Optional
+from uuid import UUID
+from fastapi import APIRouter, Depends, HTTPException, Path, Query, status
+from sqlalchemy.ext.asyncio import AsyncSession
+import structlog
+
+from shared.auth.decorators import get_current_user_dep
+from shared.auth.access_control import require_user_role
+from shared.routing import RouteBuilder
+from shared.security import create_audit_logger, AuditSeverity, AuditAction
+from app.core.database import get_db
+from app.services.orders_service import OrdersService
+from app.models import AuditLog
+from app.schemas.order_schemas import (
+    OrderCreate,
+    OrderUpdate,
+    OrderResponse
+)
+
+logger = structlog.get_logger()
+audit_logger = create_audit_logger("orders-service", AuditLog)
+
+# Create route builder for consistent URL structure
+route_builder = RouteBuilder('orders')
+
+router = APIRouter()
+
+
+# ===== Dependency Injection =====
+
+async def get_orders_service(db = Depends(get_db)) -> OrdersService:
+    """Get orders service with dependencies"""
+    from app.repositories.order_repository import (
+        OrderRepository,
+        CustomerRepository,
+        OrderItemRepository,
+        OrderStatusHistoryRepository
+    )
+    from shared.clients import (
+        get_inventory_client,
+        get_production_client,
+        get_sales_client
+    )
+
+    return OrdersService(
+        order_repo=OrderRepository(),
+        customer_repo=CustomerRepository(),
+        order_item_repo=OrderItemRepository(),
+        status_history_repo=OrderStatusHistoryRepository(),
+        inventory_client=get_inventory_client(),
+        production_client=get_production_client(),
+        sales_client=get_sales_client()
+    )
+
+
+# ===== Order CRUD Endpoints =====
+
+@router.post(
+    route_builder.build_base_route("").rstrip("/"),
+    response_model=OrderResponse,
+    status_code=status.HTTP_201_CREATED
+)
+@require_user_role(['admin', 'owner', 'member'])
+async def create_order(
+    order_data: OrderCreate,
+    tenant_id: UUID = Path(...),
+    current_user: dict = Depends(get_current_user_dep),
+    orders_service: OrdersService = Depends(get_orders_service),
+    db = Depends(get_db)
+):
+    """Create a new customer order"""
+    try:
+        # Extract user ID safely
+        user_id = current_user.get("user_id")
+        if not user_id:
+            logger.error("User ID not found in current_user context", current_user_keys=list(current_user.keys()))
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="User authentication error"
+            )
+
+        order = await orders_service.create_order(
+            db,
+            order_data,
+            user_id=UUID(user_id)
+        )
+
+        # Commit the transaction to persist changes
+        await db.commit()
+
+        logger.info("Order created successfully",
+                   order_id=str(order.id),
+                   order_number=order.order_number)
+
+        return order
+
+    except ValueError as e:
+        logger.warning("Invalid order data", error=str(e))
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e)
+        )
+    except Exception as e:
+        logger.error("Error creating order", error=str(e))
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to create order"
+        )
+
+
+@router.get(
+    route_builder.build_base_route("").rstrip("/"),
+    response_model=List[OrderResponse]
+)
+async def get_orders(
+    tenant_id: UUID = Path(...),
+    status_filter: Optional[str] = Query(None, description="Filter by order status"),
+    start_date: Optional[date] = Query(None, description="Start date for date range filter"),
+    end_date: Optional[date] = Query(None, description="End date for date range filter"),
+    skip: int = Query(0, ge=0, description="Number of orders to skip"),
+    limit: int = Query(100, ge=1, le=1000, description="Number of orders to return"),
+    current_user: dict = Depends(get_current_user_dep),
+    orders_service: OrdersService = Depends(get_orders_service),
+    db = Depends(get_db)
+):
+    """Get orders with filtering and pagination"""
+    try:
+        # Determine which repository method to use based on filters
+        if status_filter:
+            orders = await orders_service.order_repo.get_orders_by_status(
+                db, tenant_id, status_filter, skip, limit
+            )
+        elif start_date and end_date:
+            orders = await orders_service.order_repo.get_orders_by_date_range(
+                db, tenant_id, start_date, end_date, skip, limit
+            )
+        else:
+            orders = await orders_service.order_repo.get_multi(
+                db, tenant_id, skip, limit, order_by="order_date", order_desc=True
+            )
+
+        return [OrderResponse.from_orm(order) for order in orders]
+
+    except Exception as e:
+        logger.error("Error getting orders", error=str(e))
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to retrieve orders"
+        )
+
+
+@router.get(
+    route_builder.build_base_route("{order_id}"),
+    response_model=OrderResponse
+)
+async def get_order(
+    tenant_id: UUID = Path(...),
+    order_id: UUID = Path(...),
+    current_user: dict = Depends(get_current_user_dep),
+    orders_service: OrdersService = Depends(get_orders_service),
+    db = Depends(get_db)
+):
+    """Get order details with items"""
+    try:
+        order = await orders_service.get_order_with_items(db, order_id, tenant_id)
+        if not order:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Order not found"
+            )
+
+        return order
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error("Error getting order",
+                    order_id=str(order_id),
+                    error=str(e))
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to retrieve order"
+        )
+
+
+@router.put(
+    route_builder.build_base_route("{order_id}"),
+    response_model=OrderResponse
+)
+@require_user_role(['admin', 'owner', 'member'])
+async def update_order(
+    order_data: OrderUpdate,
+    tenant_id: UUID = Path(...),
+    order_id: UUID = Path(...),
+    current_user: dict = Depends(get_current_user_dep),
+    orders_service: OrdersService = Depends(get_orders_service),
+    db = Depends(get_db)
+):
+    """Update order information"""
+    try:
+        # Get existing order
+        order = await orders_service.order_repo.get(db, order_id, tenant_id)
+        if not order:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Order not found"
+            )
+
+        # Update order
+        updated_order = await orders_service.order_repo.update(
+            db,
+            db_obj=order,
+            obj_in=order_data.dict(exclude_unset=True),
+            updated_by=UUID(current_user["user_id"])
+        )
+
+        # Commit the transaction to persist changes
+        await db.commit()
+
+        logger.info("Order updated successfully",
+                   order_id=str(order_id))
+
+        return OrderResponse.from_orm(updated_order)
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error("Error updating order",
+                    order_id=str(order_id),
+                    error=str(e))
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to update order"
+        )
+
+
+@router.delete(
+    route_builder.build_base_route("{order_id}"),
+    status_code=status.HTTP_204_NO_CONTENT
+)
+@require_user_role(['admin', 'owner'])
+async def delete_order(
+    tenant_id: UUID = Path(...),
+    order_id: UUID = Path(...),
+    current_user: dict = Depends(get_current_user_dep),
+    orders_service: OrdersService = Depends(get_orders_service),
+    db = Depends(get_db)
+):
+    """Delete an order (Admin+ only, soft delete)"""
+    try:
+        order = await orders_service.order_repo.get(db, order_id, tenant_id)
+        if not order:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Order not found"
+            )
+
+        # Capture order data before deletion
+        order_data = {
+            "order_number": order.order_number,
+            "customer_id": str(order.customer_id) if order.customer_id else None,
+            "order_status": order.order_status,
+            "total_amount": float(order.total_amount) if order.total_amount else 0.0,
+            "order_date": order.order_date.isoformat() if order.order_date else None
+        }
+
+        await orders_service.order_repo.delete(db, order_id, tenant_id)
+
+        # Commit the transaction to persist deletion
+        await db.commit()
+
+        # Log audit event for order deletion
+        try:
+            await audit_logger.log_deletion(
+                db_session=db,
+                tenant_id=str(tenant_id),
+                user_id=current_user["user_id"],
+                resource_type="order",
+                resource_id=str(order_id),
+                resource_data=order_data,
+                description=f"Admin {current_user.get('email', 'unknown')} deleted order {order_data['order_number']}",
+                endpoint=f"/orders/{order_id}",
+                method="DELETE"
+            )
+        except Exception as audit_error:
+            logger.warning("Failed to log audit event", error=str(audit_error))
+
+        logger.info("Order deleted successfully",
+                   order_id=str(order_id),
+                   tenant_id=str(tenant_id),
+                   user_id=current_user["user_id"])
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error("Error deleting order",
+                    order_id=str(order_id),
+                    error=str(e))
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to delete order"
+        )
+
+
+# ===== Tenant Data Deletion Endpoint =====
+
+@router.delete(
+    route_builder.build_base_route("tenant/{tenant_id}", include_tenant_prefix=False),
+    status_code=status.HTTP_200_OK
+)
+async def delete_tenant_data(
+    tenant_id: str = Path(..., description="Tenant ID"),
+    current_user: dict = Depends(get_current_user_dep),
+    db: AsyncSession = Depends(get_db)
+):
+    """
+    Delete all order-related data for a tenant
+    Only accessible by internal services (called during tenant deletion)
+    """
+
+    logger.info("Tenant data deletion request received",
+               tenant_id=tenant_id,
+               requesting_service=current_user.get("service", "unknown"))
+
+    # Only allow internal service calls
+    if current_user.get("type") != "service":
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="This endpoint is only accessible to internal services"
+        )
+
+    try:
+        from app.services.tenant_deletion_service import OrdersTenantDeletionService
+
+        deletion_service = OrdersTenantDeletionService(db)
+        result = await deletion_service.safe_delete_tenant_data(tenant_id)
+
+        return {
+            "message": "Tenant data deletion completed in orders-service",
+            "summary": result.to_dict()
+        }
+
+    except Exception as e:
+        logger.error("Tenant data deletion failed",
+                    tenant_id=tenant_id,
+                    error=str(e))
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to delete tenant data: {str(e)}"
+        )
+
+
+@router.get(
+    route_builder.build_base_route("tenant/{tenant_id}/deletion-preview", include_tenant_prefix=False),
+    status_code=status.HTTP_200_OK
+)
+async def preview_tenant_data_deletion(
+    tenant_id: str = Path(..., description="Tenant ID"),
+    current_user: dict = Depends(get_current_user_dep),
+    db: AsyncSession = Depends(get_db)
+):
+    """
+    Preview what data would be deleted for a tenant (dry-run)
+    Accessible by internal services and tenant admins
+    """
+
+    # Allow internal services and admins
+    is_service = current_user.get("type") == "service"
+    is_admin = current_user.get("role") in ["owner", "admin"]
+
+    if not (is_service or is_admin):
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Insufficient permissions"
+        )
+
+    try:
+        from app.services.tenant_deletion_service import OrdersTenantDeletionService
+
+        deletion_service = OrdersTenantDeletionService(db)
+        preview = await deletion_service.get_tenant_data_preview(tenant_id)
+
+        return {
+            "tenant_id": tenant_id,
+            "service": "orders-service",
+            "data_counts": preview,
+            "total_items": sum(preview.values())
+        }
+
+    except Exception as e:
+        logger.error("Deletion preview failed",
+                    tenant_id=tenant_id,
+                    error=str(e))
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to get deletion preview: {str(e)}"
+        )