Refactor all main.py

services/orders/app/core/database.py

@@ -76,4 +76,16 @@ async def get_db_health() -> bool:
         return True
     except Exception as e:
         logger.error("Database health check failed", error=str(e))
-        return False
+        return False
+
+
+# Database manager instance for service_base compatibility
+from shared.database.base import DatabaseManager
+
+database_manager = DatabaseManager(
+    database_url=settings.DATABASE_URL,
+    service_name="orders-service",
+    pool_size=10,
+    max_overflow=20,
+    echo=settings.DEBUG
+)

services/orders/app/main.py

@@ -7,113 +7,74 @@ Customer orders and procurement planning service
 """
 
 from fastapi import FastAPI, Request
-from fastapi.middleware.cors import CORSMiddleware
-from contextlib import asynccontextmanager
-import structlog
-
 from app.core.config import settings
-from app.core.database import init_database, get_db_health
+from app.core.database import database_manager
 from app.api.orders import router as orders_router
 from app.api.procurement import router as procurement_router
 from app.services.procurement_scheduler_service import ProcurementSchedulerService
-
-# Configure logging
-logger = structlog.get_logger()
+from shared.service_base import StandardFastAPIService
 
 
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    """Manage application lifespan events"""
-    # Startup
-    try:
-        await init_database()
-        logger.info("Database initialized successfully")
-        
+class OrdersService(StandardFastAPIService):
+    """Orders Service with standardized setup"""
+
+    def __init__(self):
+        # Define expected database tables for health checks
+        orders_expected_tables = [
+            'customers', 'customer_contacts', 'customer_orders', 'order_items',
+            'order_status_history', 'procurement_plans', 'procurement_requirements'
+        ]
+
+        super().__init__(
+            service_name="orders-service",
+            app_name=settings.APP_NAME,
+            description=settings.DESCRIPTION,
+            version=settings.VERSION,
+            api_prefix="/api/v1",
+            database_manager=database_manager,
+            expected_tables=orders_expected_tables
+        )
+
+    async def on_startup(self, app: FastAPI):
+        """Custom startup logic for orders service"""
         # Initialize procurement scheduler service
         scheduler_service = ProcurementSchedulerService(settings)
         await scheduler_service.start()
-        logger.info("Procurement scheduler service started")
-        
+        self.logger.info("Procurement scheduler service started")
+
         # Store scheduler service in app state
         app.state.scheduler_service = scheduler_service
-        
-        logger.info("Orders service started successfully")
-    except Exception as e:
-        logger.error("Failed to initialize orders service", error=str(e))
-        raise
-    
-    yield
-    
-    # Shutdown
-    logger.info("Orders service shutting down")
-    try:
+
+    async def on_shutdown(self, app: FastAPI):
+        """Custom shutdown logic for orders service"""
         # Stop scheduler service
         if hasattr(app.state, 'scheduler_service'):
             await app.state.scheduler_service.stop()
-            logger.info("Scheduler service stopped")
-    except Exception as e:
-        logger.error("Error stopping scheduler service", error=str(e))
+            self.logger.info("Scheduler service stopped")
+
+    def get_service_features(self):
+        """Return orders-specific features"""
+        return [
+            "customer_management",
+            "order_processing",
+            "procurement_planning",
+            "order_tracking",
+            "automated_scheduling"
+        ]
 
 
-# Create FastAPI application
-app = FastAPI(
-    title=settings.APP_NAME,
-    description=settings.DESCRIPTION,
-    version=settings.VERSION,
-    lifespan=lifespan
-)
+# Create service instance
+service = OrdersService()
 
-# Add CORS middleware
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],  # Configure based on environment
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
+# Create FastAPI app with standardized setup
+app = service.create_app()
+
+# Setup standard endpoints
+service.setup_standard_endpoints()
 
 # Include routers
-app.include_router(orders_router, prefix="/api/v1")
-app.include_router(procurement_router, prefix="/api/v1")
-
-
-@app.get("/health")
-async def health_check():
-    """Health check endpoint"""
-    try:
-        db_healthy = await get_db_health()
-        
-        health_status = {
-            "status": "healthy" if db_healthy else "unhealthy",
-            "service": settings.SERVICE_NAME,
-            "version": settings.VERSION,
-            "database": "connected" if db_healthy else "disconnected"
-        }
-        
-        if not db_healthy:
-            health_status["status"] = "unhealthy"
-        
-        return health_status
-        
-    except Exception as e:
-        logger.error("Health check failed", error=str(e))
-        return {
-            "status": "unhealthy",
-            "service": settings.SERVICE_NAME,
-            "version": settings.VERSION,
-            "error": str(e)
-        }
-
-
-@app.get("/")
-async def root():
-    """Root endpoint"""
-    return {
-        "service": settings.APP_NAME,
-        "version": settings.VERSION,
-        "description": settings.DESCRIPTION,
-        "status": "running"
-    }
+service.add_router(orders_router)
+service.add_router(procurement_router)
 
 
 @app.post("/test/procurement-scheduler")