REFACTOR ALL APIs

services/production/app/api/analytics.py

@@ -0,0 +1,428 @@
+# services/production/app/api/analytics.py
+"""
+Analytics API endpoints for Production Service
+Following standardized URL structure: /api/v1/tenants/{tenant_id}/production/analytics/{operation}
+Requires: Professional or Enterprise subscription tier
+"""
+
+from datetime import date, datetime, timedelta
+from typing import Optional
+from uuid import UUID
+from fastapi import APIRouter, Depends, HTTPException, Path, Query
+import structlog
+
+from shared.auth.decorators import get_current_user_dep
+from shared.auth.access_control import analytics_tier_required
+from app.services.production_service import ProductionService
+from app.core.config import settings
+from shared.routing import RouteBuilder
+
+logger = structlog.get_logger()
+
+# Create route builder for consistent URL structure
+route_builder = RouteBuilder('production')
+
+router = APIRouter(tags=["production-analytics"])
+
+
+def get_production_service() -> ProductionService:
+    """Dependency injection for production service"""
+    from app.core.database import database_manager
+    return ProductionService(database_manager, settings)
+
+
+# ===== ANALYTICS ENDPOINTS (Professional/Enterprise Only) =====
+
+@router.get(
+    route_builder.build_analytics_route("equipment-efficiency"),
+    response_model=dict
+)
+@analytics_tier_required
+async def get_equipment_efficiency(
+    tenant_id: UUID = Path(...),
+    start_date: Optional[date] = Query(None, description="Start date for analysis"),
+    end_date: Optional[date] = Query(None, description="End date for analysis"),
+    equipment_id: Optional[UUID] = Query(None, description="Filter by equipment"),
+    current_user: dict = Depends(get_current_user_dep),
+    production_service: ProductionService = Depends(get_production_service)
+):
+    """
+    Analyze equipment efficiency (Professional/Enterprise only)
+
+    Metrics:
+    - Overall Equipment Effectiveness (OEE)
+    - Availability rate
+    - Performance rate
+    - Quality rate
+    - Downtime analysis
+    """
+    try:
+        # Set default dates
+        if not end_date:
+            end_date = datetime.now().date()
+        if not start_date:
+            start_date = end_date - timedelta(days=30)
+
+        # Use existing method: get_equipment_efficiency_analytics
+        efficiency_data = await production_service.get_equipment_efficiency_analytics(tenant_id)
+
+        logger.info("Equipment efficiency analyzed",
+                   tenant_id=str(tenant_id),
+                   equipment_id=str(equipment_id) if equipment_id else "all",
+                   user_id=current_user.get('user_id'))
+
+        return efficiency_data
+
+    except Exception as e:
+        logger.error("Error analyzing equipment efficiency",
+                    tenant_id=str(tenant_id),
+                    error=str(e))
+        raise HTTPException(
+            status_code=500,
+            detail="Failed to analyze equipment efficiency"
+        )
+
+
+@router.get(
+    route_builder.build_analytics_route("production-trends"),
+    response_model=dict
+)
+@analytics_tier_required
+async def get_production_trends(
+    tenant_id: UUID = Path(...),
+    days_back: int = Query(90, ge=7, le=365, description="Days to analyze"),
+    product_id: Optional[UUID] = Query(None, description="Filter by product"),
+    current_user: dict = Depends(get_current_user_dep),
+    production_service: ProductionService = Depends(get_production_service)
+):
+    """
+    Analyze production trends (Professional/Enterprise only)
+
+    Provides:
+    - Production volume trends
+    - Batch completion rates
+    - Cycle time analysis
+    - Quality trends
+    - Seasonal patterns
+    """
+    try:
+        # Use existing methods: get_performance_analytics + get_yield_trends_analytics
+        end_date_calc = datetime.now().date()
+        start_date_calc = end_date_calc - timedelta(days=days_back)
+
+        performance = await production_service.get_performance_analytics(
+            tenant_id, start_date_calc, end_date_calc
+        )
+
+        # Map days_back to period string for yield trends
+        period = "weekly" if days_back <= 30 else "monthly"
+        yield_trends = await production_service.get_yield_trends_analytics(tenant_id, period)
+
+        trends = {
+            "performance_metrics": performance,
+            "yield_trends": yield_trends,
+            "days_analyzed": days_back,
+            "product_filter": str(product_id) if product_id else None
+        }
+
+        logger.info("Production trends analyzed",
+                   tenant_id=str(tenant_id),
+                   days_analyzed=days_back,
+                   user_id=current_user.get('user_id'))
+
+        return trends
+
+    except Exception as e:
+        logger.error("Error analyzing production trends",
+                    tenant_id=str(tenant_id),
+                    error=str(e))
+        raise HTTPException(
+            status_code=500,
+            detail="Failed to analyze production trends"
+        )
+
+
+@router.get(
+    route_builder.build_analytics_route("capacity-utilization"),
+    response_model=dict
+)
+@analytics_tier_required
+async def get_capacity_utilization(
+    tenant_id: UUID = Path(...),
+    start_date: Optional[date] = Query(None),
+    end_date: Optional[date] = Query(None),
+    current_user: dict = Depends(get_current_user_dep),
+    production_service: ProductionService = Depends(get_production_service)
+):
+    """
+    Analyze production capacity utilization (Professional/Enterprise only)
+
+    Metrics:
+    - Capacity utilization percentage
+    - Bottleneck identification
+    - Resource allocation efficiency
+    - Optimization recommendations
+    """
+    try:
+        if not end_date:
+            end_date = datetime.now().date()
+        if not start_date:
+            start_date = end_date - timedelta(days=30)
+
+        # Use existing method: get_capacity_usage_report
+        utilization = await production_service.get_capacity_usage_report(
+            tenant_id, start_date, end_date
+        )
+
+        logger.info("Capacity utilization analyzed",
+                   tenant_id=str(tenant_id),
+                   user_id=current_user.get('user_id'))
+
+        return utilization
+
+    except Exception as e:
+        logger.error("Error analyzing capacity utilization",
+                    tenant_id=str(tenant_id),
+                    error=str(e))
+        raise HTTPException(
+            status_code=500,
+            detail="Failed to analyze capacity utilization"
+        )
+
+
+@router.get(
+    route_builder.build_analytics_route("quality-metrics"),
+    response_model=dict
+)
+@analytics_tier_required
+async def get_quality_metrics(
+    tenant_id: UUID = Path(...),
+    start_date: Optional[date] = Query(None),
+    end_date: Optional[date] = Query(None),
+    product_id: Optional[UUID] = Query(None),
+    current_user: dict = Depends(get_current_user_dep),
+    production_service: ProductionService = Depends(get_production_service)
+):
+    """
+    Analyze quality control metrics (Professional/Enterprise only)
+
+    Metrics:
+    - First pass yield
+    - Defect rates by type
+    - Quality trends over time
+    - Root cause analysis
+    """
+    try:
+        if not end_date:
+            end_date = datetime.now().date()
+        if not start_date:
+            start_date = end_date - timedelta(days=30)
+
+        # Use existing methods: get_quality_trends + get_top_defects_analytics
+        quality_trends = await production_service.get_quality_trends(
+            tenant_id, start_date, end_date
+        )
+        top_defects = await production_service.get_top_defects_analytics(tenant_id)
+
+        quality_data = {
+            "quality_trends": quality_trends,
+            "top_defects": top_defects,
+            "period": {
+                "start_date": start_date.isoformat(),
+                "end_date": end_date.isoformat()
+            },
+            "product_filter": str(product_id) if product_id else None
+        }
+
+        logger.info("Quality metrics analyzed",
+                   tenant_id=str(tenant_id),
+                   user_id=current_user.get('user_id'))
+
+        return quality_data
+
+    except Exception as e:
+        logger.error("Error analyzing quality metrics",
+                    tenant_id=str(tenant_id),
+                    error=str(e))
+        raise HTTPException(
+            status_code=500,
+            detail="Failed to analyze quality metrics"
+        )
+
+
+@router.get(
+    route_builder.build_analytics_route("waste-analysis"),
+    response_model=dict
+)
+@analytics_tier_required
+async def get_production_waste_analysis(
+    tenant_id: UUID = Path(...),
+    start_date: Optional[date] = Query(None),
+    end_date: Optional[date] = Query(None),
+    current_user: dict = Depends(get_current_user_dep),
+    production_service: ProductionService = Depends(get_production_service)
+):
+    """
+    Analyze production waste (Professional/Enterprise only)
+
+    Provides:
+    - Material waste percentages
+    - Waste by category/product
+    - Cost impact analysis
+    - Reduction recommendations
+    """
+    try:
+        if not end_date:
+            end_date = datetime.now().date()
+        if not start_date:
+            start_date = end_date - timedelta(days=30)
+
+        # Use existing method: get_batch_statistics to calculate waste from yield data
+        batch_stats = await production_service.get_batch_statistics(
+            tenant_id, start_date, end_date
+        )
+
+        # Calculate waste metrics from batch statistics
+        waste_analysis = {
+            "batch_statistics": batch_stats,
+            "waste_metrics": {
+                "calculated_from": "yield_variance",
+                "note": "Waste derived from planned vs actual quantity differences"
+            },
+            "period": {
+                "start_date": start_date.isoformat(),
+                "end_date": end_date.isoformat()
+            }
+        }
+
+        logger.info("Production waste analyzed",
+                   tenant_id=str(tenant_id),
+                   user_id=current_user.get('user_id'))
+
+        return waste_analysis
+
+    except Exception as e:
+        logger.error("Error analyzing production waste",
+                    tenant_id=str(tenant_id),
+                    error=str(e))
+        raise HTTPException(
+            status_code=500,
+            detail="Failed to analyze production waste"
+        )
+
+
+@router.get(
+    route_builder.build_analytics_route("cost-analysis"),
+    response_model=dict
+)
+@analytics_tier_required
+async def get_production_cost_analysis(
+    tenant_id: UUID = Path(...),
+    start_date: Optional[date] = Query(None),
+    end_date: Optional[date] = Query(None),
+    product_id: Optional[UUID] = Query(None),
+    current_user: dict = Depends(get_current_user_dep),
+    production_service: ProductionService = Depends(get_production_service)
+):
+    """
+    Analyze production costs (Professional/Enterprise only)
+
+    Metrics:
+    - Cost per unit
+    - Direct vs indirect costs
+    - Cost trends over time
+    - Cost variance analysis
+    - Profitability insights
+    """
+    try:
+        if not end_date:
+            end_date = datetime.now().date()
+        if not start_date:
+            start_date = end_date - timedelta(days=30)
+
+        # Use existing method: get_batch_statistics for cost-related data
+        batch_stats = await production_service.get_batch_statistics(
+            tenant_id, start_date, end_date
+        )
+
+        cost_analysis = {
+            "batch_statistics": batch_stats,
+            "cost_metrics": {
+                "note": "Cost analysis requires additional cost tracking data",
+                "available_metrics": ["batch_count", "production_volume", "efficiency"]
+            },
+            "period": {
+                "start_date": start_date.isoformat(),
+                "end_date": end_date.isoformat()
+            },
+            "product_filter": str(product_id) if product_id else None
+        }
+
+        logger.info("Production cost analyzed",
+                   tenant_id=str(tenant_id),
+                   product_id=str(product_id) if product_id else "all",
+                   user_id=current_user.get('user_id'))
+
+        return cost_analysis
+
+    except Exception as e:
+        logger.error("Error analyzing production costs",
+                    tenant_id=str(tenant_id),
+                    error=str(e))
+        raise HTTPException(
+            status_code=500,
+            detail="Failed to analyze production costs"
+        )
+
+
+@router.get(
+    route_builder.build_analytics_route("predictive-maintenance"),
+    response_model=dict
+)
+@analytics_tier_required
+async def get_predictive_maintenance_insights(
+    tenant_id: UUID = Path(...),
+    equipment_id: Optional[UUID] = Query(None),
+    current_user: dict = Depends(get_current_user_dep),
+    production_service: ProductionService = Depends(get_production_service)
+):
+    """
+    Get predictive maintenance insights (Professional/Enterprise only)
+
+    Provides:
+    - Equipment failure predictions
+    - Maintenance schedule recommendations
+    - Parts replacement forecasts
+    - Downtime risk assessment
+    """
+    try:
+        # Use existing method: predict_capacity_bottlenecks as proxy for maintenance insights
+        days_ahead = 7  # Predict one week ahead
+        bottlenecks = await production_service.predict_capacity_bottlenecks(
+            tenant_id, days_ahead
+        )
+
+        maintenance_insights = {
+            "capacity_bottlenecks": bottlenecks,
+            "maintenance_recommendations": {
+                "note": "Derived from capacity predictions and bottleneck analysis",
+                "days_predicted": days_ahead
+            },
+            "equipment_filter": str(equipment_id) if equipment_id else None
+        }
+
+        logger.info("Predictive maintenance insights generated",
+                   tenant_id=str(tenant_id),
+                   equipment_id=str(equipment_id) if equipment_id else "all",
+                   user_id=current_user.get('user_id'))
+
+        return maintenance_insights
+
+    except Exception as e:
+        logger.error("Error generating predictive maintenance insights",
+                    tenant_id=str(tenant_id),
+                    error=str(e))
+        raise HTTPException(
+            status_code=500,
+            detail="Failed to generate predictive maintenance insights"
+        )

services/production/app/api/production_batches.py

@@ -0,0 +1,253 @@
+# services/production/app/api/production_batches.py
+"""
+Production Batches API - ATOMIC CRUD operations on ProductionBatch model
+"""
+
+from fastapi import APIRouter, Depends, HTTPException, Path, Query
+from typing import Optional
+from datetime import date
+from uuid import UUID
+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.production_service import ProductionService
+from app.schemas.production import (
+    ProductionBatchCreate,
+    ProductionBatchUpdate,
+    ProductionBatchStatusUpdate,
+    ProductionBatchResponse,
+    ProductionBatchListResponse,
+    ProductionStatusEnum
+)
+from app.core.config import settings
+
+logger = structlog.get_logger()
+route_builder = RouteBuilder('production')
+router = APIRouter(tags=["production-batches"])
+
+
+def get_production_service() -> ProductionService:
+    """Dependency injection for production service"""
+    from app.core.database import database_manager
+    return ProductionService(database_manager, settings)
+
+
+@router.get(
+    route_builder.build_base_route("batches"),
+    response_model=ProductionBatchListResponse
+)
+async def list_production_batches(
+    tenant_id: UUID = Path(...),
+    status: Optional[ProductionStatusEnum] = Query(None, description="Filter by status"),
+    product_id: Optional[UUID] = Query(None, description="Filter by product"),
+    order_id: Optional[UUID] = Query(None, description="Filter by order"),
+    start_date: Optional[date] = Query(None, description="Filter from date"),
+    end_date: Optional[date] = Query(None, description="Filter to date"),
+    page: int = Query(1, ge=1, description="Page number"),
+    page_size: int = Query(50, ge=1, le=100, description="Page size"),
+    current_user: dict = Depends(get_current_user_dep),
+    production_service: ProductionService = Depends(get_production_service)
+):
+    """List batches with filters: date, status, product, order_id"""
+    try:
+        filters = {
+            "status": status,
+            "product_id": str(product_id) if product_id else None,
+            "order_id": str(order_id) if order_id else None,
+            "start_date": start_date,
+            "end_date": end_date
+        }
+
+        batch_list = await production_service.get_production_batches_list(tenant_id, filters, page, page_size)
+
+        logger.info("Retrieved production batches list",
+                   tenant_id=str(tenant_id), filters=filters)
+
+        return batch_list
+
+    except Exception as e:
+        logger.error("Error listing production batches",
+                    error=str(e), tenant_id=str(tenant_id))
+        raise HTTPException(status_code=500, detail="Failed to list production batches")
+
+
+@router.post(
+    route_builder.build_base_route("batches"),
+    response_model=ProductionBatchResponse
+)
+async def create_production_batch(
+    batch_data: ProductionBatchCreate,
+    tenant_id: UUID = Path(...),
+    current_user: dict = Depends(get_current_user_dep),
+    production_service: ProductionService = Depends(get_production_service)
+):
+    """Create a new production batch"""
+    try:
+        batch = await production_service.create_production_batch(tenant_id, batch_data)
+
+        logger.info("Created production batch",
+                   batch_id=str(batch.id), tenant_id=str(tenant_id))
+
+        return ProductionBatchResponse.model_validate(batch)
+
+    except ValueError as e:
+        logger.warning("Invalid batch data", error=str(e), tenant_id=str(tenant_id))
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.error("Error creating production batch",
+                    error=str(e), tenant_id=str(tenant_id))
+        raise HTTPException(status_code=500, detail="Failed to create production batch")
+
+
+@router.get(
+    route_builder.build_base_route("batches/active"),
+    response_model=ProductionBatchListResponse
+)
+async def get_active_batches(
+    tenant_id: UUID = Path(...),
+    current_user: dict = Depends(get_current_user_dep),
+    db=Depends(get_db)
+):
+    """Get currently active production batches"""
+    try:
+        from app.repositories.production_batch_repository import ProductionBatchRepository
+        batch_repo = ProductionBatchRepository(db)
+
+        batches = await batch_repo.get_active_batches(str(tenant_id))
+        batch_responses = [ProductionBatchResponse.model_validate(batch) for batch in batches]
+
+        logger.info("Retrieved active production batches",
+                   count=len(batches), tenant_id=str(tenant_id))
+
+        return ProductionBatchListResponse(
+            batches=batch_responses,
+            total_count=len(batches),
+            page=1,
+            page_size=len(batches)
+        )
+
+    except Exception as e:
+        logger.error("Error getting active batches",
+                    error=str(e), tenant_id=str(tenant_id))
+        raise HTTPException(status_code=500, detail="Failed to get active batches")
+
+
+@router.get(
+    route_builder.build_resource_detail_route("batches", "batch_id"),
+    response_model=ProductionBatchResponse
+)
+async def get_batch_details(
+    tenant_id: UUID = Path(...),
+    batch_id: UUID = Path(...),
+    current_user: dict = Depends(get_current_user_dep),
+    db=Depends(get_db)
+):
+    """Get detailed information about a production batch"""
+    try:
+        from app.repositories.production_batch_repository import ProductionBatchRepository
+        batch_repo = ProductionBatchRepository(db)
+
+        batch = await batch_repo.get(batch_id)
+        if not batch or str(batch.tenant_id) != str(tenant_id):
+            raise HTTPException(status_code=404, detail="Production batch not found")
+
+        logger.info("Retrieved production batch details",
+                   batch_id=str(batch_id), tenant_id=str(tenant_id))
+
+        return ProductionBatchResponse.model_validate(batch)
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error("Error getting batch details",
+                    error=str(e), batch_id=str(batch_id), tenant_id=str(tenant_id))
+        raise HTTPException(status_code=500, detail="Failed to get batch details")
+
+
+@router.put(
+    route_builder.build_nested_resource_route("batches", "batch_id", "status"),
+    response_model=ProductionBatchResponse
+)
+async def update_batch_status(
+    status_update: ProductionBatchStatusUpdate,
+    tenant_id: UUID = Path(...),
+    batch_id: UUID = Path(...),
+    current_user: dict = Depends(get_current_user_dep),
+    production_service: ProductionService = Depends(get_production_service)
+):
+    """Update production batch status"""
+    try:
+        batch = await production_service.update_batch_status(tenant_id, batch_id, status_update)
+
+        logger.info("Updated production batch status",
+                   batch_id=str(batch_id),
+                   new_status=status_update.status.value,
+                   tenant_id=str(tenant_id))
+
+        return ProductionBatchResponse.model_validate(batch)
+
+    except ValueError as e:
+        logger.warning("Invalid status update", error=str(e), batch_id=str(batch_id))
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.error("Error updating batch status",
+                    error=str(e), batch_id=str(batch_id), tenant_id=str(tenant_id))
+        raise HTTPException(status_code=500, detail="Failed to update batch status")
+
+
+@router.put(
+    route_builder.build_resource_detail_route("batches", "batch_id"),
+    response_model=ProductionBatchResponse
+)
+async def update_production_batch(
+    batch_update: ProductionBatchUpdate,
+    tenant_id: UUID = Path(...),
+    batch_id: UUID = Path(...),
+    current_user: dict = Depends(get_current_user_dep),
+    production_service: ProductionService = Depends(get_production_service)
+):
+    """Update batch (e.g., start time, notes, status)"""
+    try:
+        batch = await production_service.update_production_batch(tenant_id, batch_id, batch_update)
+
+        logger.info("Updated production batch",
+                   batch_id=str(batch_id), tenant_id=str(tenant_id))
+
+        return ProductionBatchResponse.model_validate(batch)
+
+    except ValueError as e:
+        logger.warning("Invalid batch update", error=str(e), batch_id=str(batch_id))
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.error("Error updating production batch",
+                    error=str(e), batch_id=str(batch_id), tenant_id=str(tenant_id))
+        raise HTTPException(status_code=500, detail="Failed to update production batch")
+
+
+@router.delete(
+    route_builder.build_resource_detail_route("batches", "batch_id")
+)
+async def delete_production_batch(
+    tenant_id: UUID = Path(...),
+    batch_id: UUID = Path(...),
+    current_user: dict = Depends(get_current_user_dep),
+    production_service: ProductionService = Depends(get_production_service)
+):
+    """Cancel/delete draft batch (soft delete preferred)"""
+    try:
+        await production_service.delete_production_batch(tenant_id, batch_id)
+
+        logger.info("Deleted production batch",
+                   batch_id=str(batch_id), tenant_id=str(tenant_id))
+
+        return {"message": "Production batch deleted successfully"}
+
+    except ValueError as e:
+        logger.warning("Cannot delete batch", error=str(e), batch_id=str(batch_id))
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.error("Error deleting production batch",
+                    error=str(e), batch_id=str(batch_id), tenant_id=str(tenant_id))
+        raise HTTPException(status_code=500, detail="Failed to delete production batch")

services/production/app/api/production_dashboard.py

@@ -0,0 +1,76 @@
+# services/production/app/api/production_dashboard.py
+"""
+Production Dashboard API - Dashboard endpoints for production overview
+"""
+
+from fastapi import APIRouter, Depends, HTTPException, Path, Query
+from typing import Optional
+from datetime import date, datetime
+from uuid import UUID
+import structlog
+
+from shared.auth.decorators import get_current_user_dep
+from shared.routing import RouteBuilder
+from app.services.production_service import ProductionService
+from app.schemas.production import ProductionDashboardSummary
+from app.core.config import settings
+
+logger = structlog.get_logger()
+route_builder = RouteBuilder('production')
+router = APIRouter(tags=["production-dashboard"])
+
+
+def get_production_service() -> ProductionService:
+    """Dependency injection for production service"""
+    from app.core.database import database_manager
+    return ProductionService(database_manager, settings)
+
+
+@router.get(
+    route_builder.build_dashboard_route("summary"),
+    response_model=ProductionDashboardSummary
+)
+async def get_dashboard_summary(
+    tenant_id: UUID = Path(...),
+    current_user: dict = Depends(get_current_user_dep),
+    production_service: ProductionService = Depends(get_production_service)
+):
+    """Get production dashboard summary"""
+    try:
+        summary = await production_service.get_dashboard_summary(tenant_id)
+
+        logger.info("Retrieved production dashboard summary",
+                   tenant_id=str(tenant_id))
+
+        return summary
+
+    except Exception as e:
+        logger.error("Error getting dashboard summary",
+                    error=str(e), tenant_id=str(tenant_id))
+        raise HTTPException(status_code=500, detail="Failed to get dashboard summary")
+
+
+@router.get(
+    route_builder.build_dashboard_route("requirements"),
+    response_model=dict
+)
+async def get_production_requirements(
+    tenant_id: UUID = Path(...),
+    date: Optional[date] = Query(None, description="Target date for production requirements"),
+    current_user: dict = Depends(get_current_user_dep),
+    production_service: ProductionService = Depends(get_production_service)
+):
+    """Get production requirements for procurement planning"""
+    try:
+        target_date = date or datetime.now().date()
+        requirements = await production_service.get_production_requirements(tenant_id, target_date)
+
+        logger.info("Retrieved production requirements for procurement",
+                   tenant_id=str(tenant_id), date=target_date.isoformat())
+
+        return requirements
+
+    except Exception as e:
+        logger.error("Error getting production requirements",
+                    error=str(e), tenant_id=str(tenant_id))
+        raise HTTPException(status_code=500, detail="Failed to get production requirements")

services/production/app/api/production_operations.py

@@ -0,0 +1,396 @@
+# services/production/app/api/production_operations.py
+"""
+Production Operations API - Business operations for production management
+Includes: batch start/complete, schedule finalize/optimize, capacity management, transformations, stats
+"""
+
+from fastapi import APIRouter, Depends, HTTPException, Path, Query
+from typing import Optional
+from datetime import date, datetime, timedelta
+from uuid import UUID
+import structlog
+
+from shared.auth.decorators import get_current_user_dep
+from shared.routing import RouteBuilder
+from app.services.production_service import ProductionService
+from app.schemas.production import (
+    ProductionBatchResponse,
+    ProductionScheduleResponse
+)
+from app.core.config import settings
+
+logger = structlog.get_logger()
+route_builder = RouteBuilder('production')
+router = APIRouter(tags=["production-operations"])
+
+
+def get_production_service() -> ProductionService:
+    """Dependency injection for production service"""
+    from app.core.database import database_manager
+    return ProductionService(database_manager, settings)
+
+
+# ===== BATCH OPERATIONS =====
+
+@router.post(
+    route_builder.build_nested_resource_route("batches", "batch_id", "start"),
+    response_model=ProductionBatchResponse
+)
+async def start_production_batch(
+    tenant_id: UUID = Path(...),
+    batch_id: UUID = Path(...),
+    current_user: dict = Depends(get_current_user_dep),
+    production_service: ProductionService = Depends(get_production_service)
+):
+    """Mark batch as started (updates actual_start_time)"""
+    try:
+        batch = await production_service.start_production_batch(tenant_id, batch_id)
+
+        logger.info("Started production batch",
+                   batch_id=str(batch_id), tenant_id=str(tenant_id))
+
+        return ProductionBatchResponse.model_validate(batch)
+
+    except ValueError as e:
+        logger.warning("Cannot start batch", error=str(e), batch_id=str(batch_id))
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.error("Error starting production batch",
+                    error=str(e), batch_id=str(batch_id), tenant_id=str(tenant_id))
+        raise HTTPException(status_code=500, detail="Failed to start production batch")
+
+
+@router.post(
+    route_builder.build_nested_resource_route("batches", "batch_id", "complete"),
+    response_model=ProductionBatchResponse
+)
+async def complete_production_batch(
+    tenant_id: UUID = Path(...),
+    batch_id: UUID = Path(...),
+    completion_data: Optional[dict] = None,
+    current_user: dict = Depends(get_current_user_dep),
+    production_service: ProductionService = Depends(get_production_service)
+):
+    """Complete batch — auto-calculates yield, duration, cost summary"""
+    try:
+        batch = await production_service.complete_production_batch(tenant_id, batch_id, completion_data)
+
+        logger.info("Completed production batch",
+                   batch_id=str(batch_id), tenant_id=str(tenant_id))
+
+        return ProductionBatchResponse.model_validate(batch)
+
+    except ValueError as e:
+        logger.warning("Cannot complete batch", error=str(e), batch_id=str(batch_id))
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.error("Error completing production batch",
+                    error=str(e), batch_id=str(batch_id), tenant_id=str(tenant_id))
+        raise HTTPException(status_code=500, detail="Failed to complete production batch")
+
+
+@router.get(
+    route_builder.build_operations_route("batches/stats"),
+    response_model=dict
+)
+async def get_production_batch_stats(
+    tenant_id: UUID = Path(...),
+    start_date: Optional[date] = Query(None, description="Start date for stats"),
+    end_date: Optional[date] = Query(None, description="End date for stats"),
+    current_user: dict = Depends(get_current_user_dep),
+    production_service: ProductionService = Depends(get_production_service)
+):
+    """Aggregated stats: completed vs failed, avg yield, on-time rate"""
+    try:
+        # Default to last 30 days if no dates provided
+        if not start_date:
+            start_date = (datetime.now() - timedelta(days=30)).date()
+        if not end_date:
+            end_date = datetime.now().date()
+
+        stats = await production_service.get_batch_statistics(tenant_id, start_date, end_date)
+
+        logger.info("Retrieved production batch statistics",
+                   tenant_id=str(tenant_id), start_date=start_date.isoformat(), end_date=end_date.isoformat())
+
+        return stats
+
+    except Exception as e:
+        logger.error("Error getting production batch stats",
+                    error=str(e), tenant_id=str(tenant_id))
+        raise HTTPException(status_code=500, detail="Failed to get production batch stats")
+
+
+# ===== SCHEDULE OPERATIONS =====
+
+@router.post(
+    route_builder.build_nested_resource_route("schedules", "schedule_id", "finalize"),
+    response_model=ProductionScheduleResponse
+)
+async def finalize_production_schedule(
+    tenant_id: UUID = Path(...),
+    schedule_id: UUID = Path(...),
+    current_user: dict = Depends(get_current_user_dep),
+    production_service: ProductionService = Depends(get_production_service)
+):
+    """Lock schedule; prevents further changes"""
+    try:
+        schedule = await production_service.finalize_production_schedule(tenant_id, schedule_id)
+
+        logger.info("Finalized production schedule",
+                   schedule_id=str(schedule_id), tenant_id=str(tenant_id))
+
+        return ProductionScheduleResponse.model_validate(schedule)
+
+    except ValueError as e:
+        logger.warning("Cannot finalize schedule", error=str(e), schedule_id=str(schedule_id))
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.error("Error finalizing production schedule",
+                    error=str(e), schedule_id=str(schedule_id), tenant_id=str(tenant_id))
+        raise HTTPException(status_code=500, detail="Failed to finalize production schedule")
+
+
+@router.get(
+    route_builder.build_operations_route("schedules/optimize"),
+    response_model=dict
+)
+async def optimize_production_schedule(
+    tenant_id: UUID = Path(...),
+    target_date: date = Query(..., description="Date to optimize"),
+    current_user: dict = Depends(get_current_user_dep),
+    production_service: ProductionService = Depends(get_production_service)
+):
+    """Trigger AI-based rescheduling suggestion based on demand/capacity"""
+    try:
+        optimization_result = await production_service.optimize_schedule(tenant_id, target_date)
+
+        logger.info("Generated schedule optimization suggestions",
+                   tenant_id=str(tenant_id), date=target_date.isoformat())
+
+        return optimization_result
+
+    except Exception as e:
+        logger.error("Error optimizing production schedule",
+                    error=str(e), tenant_id=str(tenant_id), date=target_date.isoformat())
+        raise HTTPException(status_code=500, detail="Failed to optimize production schedule")
+
+
+@router.get(
+    route_builder.build_operations_route("schedules/capacity-usage"),
+    response_model=dict
+)
+async def get_schedule_capacity_usage(
+    tenant_id: UUID = Path(...),
+    start_date: Optional[date] = Query(None),
+    end_date: Optional[date] = Query(None),
+    current_user: dict = Depends(get_current_user_dep),
+    production_service: ProductionService = Depends(get_production_service)
+):
+    """Get capacity usage report for scheduling period"""
+    try:
+        if not start_date:
+            start_date = datetime.now().date()
+        if not end_date:
+            end_date = start_date + timedelta(days=7)
+
+        usage_report = await production_service.get_capacity_usage_report(tenant_id, start_date, end_date)
+
+        logger.info("Retrieved capacity usage report",
+                   tenant_id=str(tenant_id),
+                   start_date=start_date.isoformat(),
+                   end_date=end_date.isoformat())
+
+        return usage_report
+
+    except Exception as e:
+        logger.error("Error getting capacity usage",
+                    error=str(e), tenant_id=str(tenant_id))
+        raise HTTPException(status_code=500, detail="Failed to get capacity usage")
+
+
+# ===== CAPACITY MANAGEMENT =====
+
+@router.get(
+    route_builder.build_operations_route("capacity/status"),
+    response_model=dict
+)
+async def get_capacity_status(
+    tenant_id: UUID = Path(...),
+    target_date: Optional[date] = Query(None),
+    current_user: dict = Depends(get_current_user_dep),
+    production_service: ProductionService = Depends(get_production_service)
+):
+    """Get real-time capacity status"""
+    try:
+        if not target_date:
+            target_date = datetime.now().date()
+
+        status = await production_service.get_capacity_status(tenant_id, target_date)
+
+        logger.info("Retrieved capacity status",
+                   tenant_id=str(tenant_id), date=target_date.isoformat())
+
+        return status
+
+    except Exception as e:
+        logger.error("Error getting capacity status",
+                    error=str(e), tenant_id=str(tenant_id))
+        raise HTTPException(status_code=500, detail="Failed to get capacity status")
+
+
+@router.get(
+    route_builder.build_operations_route("capacity/availability"),
+    response_model=dict
+)
+async def check_resource_availability(
+    tenant_id: UUID = Path(...),
+    target_date: date = Query(...),
+    required_capacity: float = Query(..., gt=0),
+    current_user: dict = Depends(get_current_user_dep),
+    production_service: ProductionService = Depends(get_production_service)
+):
+    """Check if capacity is available for scheduling"""
+    try:
+        availability = await production_service.check_resource_availability(
+            tenant_id, target_date, required_capacity
+        )
+
+        logger.info("Checked resource availability",
+                   tenant_id=str(tenant_id),
+                   date=target_date.isoformat(),
+                   required=required_capacity)
+
+        return availability
+
+    except Exception as e:
+        logger.error("Error checking resource availability",
+                    error=str(e), tenant_id=str(tenant_id))
+        raise HTTPException(status_code=500, detail="Failed to check resource availability")
+
+
+@router.post(
+    route_builder.build_operations_route("capacity/reserve"),
+    response_model=dict
+)
+async def reserve_capacity(
+    tenant_id: UUID = Path(...),
+    target_date: date = Query(...),
+    capacity_amount: float = Query(..., gt=0),
+    batch_id: UUID = Query(...),
+    current_user: dict = Depends(get_current_user_dep),
+    production_service: ProductionService = Depends(get_production_service)
+):
+    """Reserve capacity for a batch"""
+    try:
+        reservation = await production_service.reserve_capacity(
+            tenant_id, target_date, capacity_amount, batch_id
+        )
+
+        logger.info("Reserved production capacity",
+                   tenant_id=str(tenant_id),
+                   date=target_date.isoformat(),
+                   amount=capacity_amount,
+                   batch_id=str(batch_id))
+
+        return reservation
+
+    except ValueError as e:
+        logger.warning("Cannot reserve capacity", error=str(e))
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.error("Error reserving capacity",
+                    error=str(e), tenant_id=str(tenant_id))
+        raise HTTPException(status_code=500, detail="Failed to reserve capacity")
+
+
+@router.get(
+    route_builder.build_operations_route("capacity/bottlenecks"),
+    response_model=dict
+)
+async def get_capacity_bottlenecks(
+    tenant_id: UUID = Path(...),
+    days_ahead: int = Query(7, ge=1, le=30),
+    current_user: dict = Depends(get_current_user_dep),
+    production_service: ProductionService = Depends(get_production_service)
+):
+    """Identify capacity bottlenecks in upcoming period"""
+    try:
+        bottlenecks = await production_service.predict_capacity_bottlenecks(tenant_id, days_ahead)
+
+        logger.info("Retrieved capacity bottlenecks prediction",
+                   tenant_id=str(tenant_id), days_ahead=days_ahead)
+
+        return bottlenecks
+
+    except Exception as e:
+        logger.error("Error getting capacity bottlenecks",
+                    error=str(e), tenant_id=str(tenant_id))
+        raise HTTPException(status_code=500, detail="Failed to get capacity bottlenecks")
+
+
+# ===== TRANSFORMATION OPERATIONS =====
+
+@router.post(
+    route_builder.build_operations_route("batches/complete-with-transformation"),
+    response_model=dict
+)
+async def complete_batch_with_transformation(
+    tenant_id: UUID = Path(...),
+    batch_id: UUID = Query(...),
+    transformation_data: dict = None,
+    current_user: dict = Depends(get_current_user_dep),
+    production_service: ProductionService = Depends(get_production_service)
+):
+    """Complete batch and create product transformation record"""
+    try:
+        result = await production_service.complete_batch_with_transformation(
+            tenant_id, batch_id, transformation_data
+        )
+
+        logger.info("Completed batch with transformation",
+                   tenant_id=str(tenant_id),
+                   batch_id=str(batch_id))
+
+        return result
+
+    except ValueError as e:
+        logger.warning("Cannot complete batch with transformation", error=str(e))
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.error("Error completing batch with transformation",
+                    error=str(e), tenant_id=str(tenant_id))
+        raise HTTPException(status_code=500, detail="Failed to complete batch with transformation")
+
+
+@router.post(
+    route_builder.build_operations_route("transform-par-baked"),
+    response_model=dict
+)
+async def transform_par_baked_products(
+    tenant_id: UUID = Path(...),
+    source_batch_id: UUID = Query(...),
+    target_quantity: float = Query(..., gt=0),
+    current_user: dict = Depends(get_current_user_dep),
+    production_service: ProductionService = Depends(get_production_service)
+):
+    """Transform par-baked products to fully baked"""
+    try:
+        result = await production_service.transform_par_baked_to_fresh(
+            tenant_id, source_batch_id, target_quantity
+        )
+
+        logger.info("Transformed par-baked products",
+                   tenant_id=str(tenant_id),
+                   source_batch_id=str(source_batch_id),
+                   quantity=target_quantity)
+
+        return result
+
+    except ValueError as e:
+        logger.warning("Cannot transform products", error=str(e))
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.error("Error transforming products",
+                    error=str(e), tenant_id=str(tenant_id))
+        raise HTTPException(status_code=500, detail="Failed to transform products")

services/production/app/api/production_schedules.py

@@ -0,0 +1,214 @@
+# services/production/app/api/production_schedules.py
+"""
+Production Schedules API - ATOMIC CRUD operations on ProductionSchedule model
+"""
+
+from fastapi import APIRouter, Depends, HTTPException, Path, Query
+from typing import Optional
+from datetime import date, datetime, timedelta
+from uuid import UUID
+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.production_service import ProductionService
+from app.schemas.production import (
+    ProductionScheduleCreate,
+    ProductionScheduleUpdate,
+    ProductionScheduleResponse
+)
+from app.core.config import settings
+
+logger = structlog.get_logger()
+route_builder = RouteBuilder('production')
+router = APIRouter(tags=["production-schedules"])
+
+
+def get_production_service() -> ProductionService:
+    """Dependency injection for production service"""
+    from app.core.database import database_manager
+    return ProductionService(database_manager, settings)
+
+
+@router.get(
+    route_builder.build_base_route("schedules"),
+    response_model=dict
+)
+async def get_production_schedule(
+    tenant_id: UUID = Path(...),
+    start_date: Optional[date] = Query(None, description="Start date for schedule"),
+    end_date: Optional[date] = Query(None, description="End date for schedule"),
+    current_user: dict = Depends(get_current_user_dep),
+    db=Depends(get_db)
+):
+    """Get production schedule for a date range"""
+    try:
+        # Default to next 7 days if no dates provided
+        if not start_date:
+            start_date = datetime.now().date()
+        if not end_date:
+            end_date = start_date + timedelta(days=7)
+
+        from app.repositories.production_schedule_repository import ProductionScheduleRepository
+        schedule_repo = ProductionScheduleRepository(db)
+
+        schedules = await schedule_repo.get_schedules_by_date_range(
+            str(tenant_id), start_date, end_date
+        )
+
+        schedule_data = {
+            "start_date": start_date.isoformat(),
+            "end_date": end_date.isoformat(),
+            "schedules": [
+                {
+                    "id": str(schedule.id),
+                    "date": schedule.schedule_date.isoformat(),
+                    "shift_start": schedule.shift_start.isoformat(),
+                    "shift_end": schedule.shift_end.isoformat(),
+                    "capacity_utilization": schedule.utilization_percentage,
+                    "batches_planned": schedule.total_batches_planned,
+                    "is_finalized": schedule.is_finalized
+                }
+                for schedule in schedules
+            ],
+            "total_schedules": len(schedules)
+        }
+
+        logger.info("Retrieved production schedule",
+                   tenant_id=str(tenant_id),
+                   start_date=start_date.isoformat(),
+                   end_date=end_date.isoformat(),
+                   schedules_count=len(schedules))
+
+        return schedule_data
+
+    except Exception as e:
+        logger.error("Error getting production schedule",
+                    error=str(e), tenant_id=str(tenant_id))
+        raise HTTPException(status_code=500, detail="Failed to get production schedule")
+
+
+@router.get(
+    route_builder.build_resource_detail_route("schedules", "schedule_id"),
+    response_model=ProductionScheduleResponse
+)
+async def get_production_schedule_details(
+    tenant_id: UUID = Path(...),
+    schedule_id: UUID = Path(...),
+    current_user: dict = Depends(get_current_user_dep),
+    db=Depends(get_db)
+):
+    """Retrieve full schedule details including assignments"""
+    try:
+        from app.repositories.production_schedule_repository import ProductionScheduleRepository
+        schedule_repo = ProductionScheduleRepository(db)
+
+        schedule = await schedule_repo.get(schedule_id)
+        if not schedule or str(schedule.tenant_id) != str(tenant_id):
+            raise HTTPException(status_code=404, detail="Production schedule not found")
+
+        logger.info("Retrieved production schedule details",
+                   schedule_id=str(schedule_id), tenant_id=str(tenant_id))
+
+        return ProductionScheduleResponse.model_validate(schedule)
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error("Error getting production schedule details",
+                    error=str(e), schedule_id=str(schedule_id), tenant_id=str(tenant_id))
+        raise HTTPException(status_code=500, detail="Failed to get production schedule details")
+
+
+@router.post(
+    route_builder.build_base_route("schedules"),
+    response_model=ProductionScheduleResponse
+)
+async def create_production_schedule(
+    schedule_data: ProductionScheduleCreate,
+    tenant_id: UUID = Path(...),
+    current_user: dict = Depends(get_current_user_dep),
+    production_service: ProductionService = Depends(get_production_service)
+):
+    """Generate or manually create a daily/shift schedule"""
+    try:
+        schedule = await production_service.create_production_schedule(tenant_id, schedule_data)
+
+        logger.info("Created production schedule",
+                   schedule_id=str(schedule.id), tenant_id=str(tenant_id))
+
+        return ProductionScheduleResponse.model_validate(schedule)
+
+    except ValueError as e:
+        logger.warning("Invalid schedule data", error=str(e), tenant_id=str(tenant_id))
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.error("Error creating production schedule",
+                    error=str(e), tenant_id=str(tenant_id))
+        raise HTTPException(status_code=500, detail="Failed to create production schedule")
+
+
+@router.put(
+    route_builder.build_resource_detail_route("schedules", "schedule_id"),
+    response_model=ProductionScheduleResponse
+)
+async def update_production_schedule(
+    schedule_update: ProductionScheduleUpdate,
+    tenant_id: UUID = Path(...),
+    schedule_id: UUID = Path(...),
+    current_user: dict = Depends(get_current_user_dep),
+    production_service: ProductionService = Depends(get_production_service)
+):
+    """Edit schedule before finalizing"""
+    try:
+        schedule = await production_service.update_production_schedule(tenant_id, schedule_id, schedule_update)
+
+        logger.info("Updated production schedule",
+                   schedule_id=str(schedule_id), tenant_id=str(tenant_id))
+
+        return ProductionScheduleResponse.model_validate(schedule)
+
+    except ValueError as e:
+        logger.warning("Invalid schedule update", error=str(e), schedule_id=str(schedule_id))
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.error("Error updating production schedule",
+                    error=str(e), schedule_id=str(schedule_id), tenant_id=str(tenant_id))
+        raise HTTPException(status_code=500, detail="Failed to update production schedule")
+
+
+@router.delete(
+    route_builder.build_resource_detail_route("schedules", "schedule_id")
+)
+async def delete_production_schedule(
+    tenant_id: UUID = Path(...),
+    schedule_id: UUID = Path(...),
+    current_user: dict = Depends(get_current_user_dep),
+    db=Depends(get_db)
+):
+    """Delete a production schedule (if not finalized)"""
+    try:
+        from app.repositories.production_schedule_repository import ProductionScheduleRepository
+        schedule_repo = ProductionScheduleRepository(db)
+
+        schedule = await schedule_repo.get(schedule_id)
+        if not schedule or str(schedule.tenant_id) != str(tenant_id):
+            raise HTTPException(status_code=404, detail="Production schedule not found")
+
+        if schedule.is_finalized:
+            raise HTTPException(status_code=400, detail="Cannot delete finalized schedule")
+
+        await schedule_repo.delete(schedule_id)
+
+        logger.info("Deleted production schedule",
+                   schedule_id=str(schedule_id), tenant_id=str(tenant_id))
+
+        return {"message": "Production schedule deleted successfully"}
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error("Error deleting production schedule",
+                    error=str(e), schedule_id=str(schedule_id), tenant_id=str(tenant_id))
+        raise HTTPException(status_code=500, detail="Failed to delete production schedule")

services/production/app/main.py

@@ -11,10 +11,18 @@ from fastapi import FastAPI, Request
 from sqlalchemy import text
 from app.core.config import settings
 from app.core.database import database_manager
-from app.api.production import router as production_router
 from app.services.production_alert_service import ProductionAlertService
 from shared.service_base import StandardFastAPIService
 
+# Import standardized routers
+from app.api import (
+    production_batches,
+    production_schedules,
+    production_operations,
+    production_dashboard,
+    analytics
+)
+
 
 class ProductionService(StandardFastAPIService):
     """Production Service with standardized setup"""
@@ -63,7 +71,7 @@ class ProductionService(StandardFastAPIService):
             app_name=settings.APP_NAME,
             description=settings.DESCRIPTION,
             version=settings.VERSION,
-            api_prefix="/api/v1",
+            api_prefix="",  # Empty because RouteBuilder already includes /api/v1
             database_manager=database_manager,
             expected_tables=production_expected_tables,
             custom_health_checks={"alert_service": check_alert_service}
@@ -128,8 +136,12 @@ service.setup_standard_endpoints()
 # Setup custom middleware
 service.setup_custom_middleware()
 
-# Include routers
-service.add_router(production_router)
+# Include standardized routers
+service.add_router(production_batches.router)
+service.add_router(production_schedules.router)
+service.add_router(production_operations.router)
+service.add_router(production_dashboard.router)
+service.add_router(analytics.router)
 
 
 if __name__ == "__main__":