Improve the frontend and fix TODOs

services/production/app/api/internal_demo.py

@@ -5,7 +5,7 @@ Service-to-service endpoint for cloning production data
 
 from fastapi import APIRouter, Depends, HTTPException, Header
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import select
+from sqlalchemy import select, delete, func
 import structlog
 import uuid
 from datetime import datetime, timezone, timedelta
@@ -493,3 +493,53 @@ async def clone_health_check(_: bool = Depends(verify_internal_api_key)):
         "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),
+    _: bool = Depends(verify_internal_api_key)
+):
+    """Delete all production data for a virtual demo tenant"""
+    logger.info("Deleting production 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
+        batch_count = await db.scalar(select(func.count(ProductionBatch.id)).where(ProductionBatch.tenant_id == virtual_uuid))
+        schedule_count = await db.scalar(select(func.count(ProductionSchedule.id)).where(ProductionSchedule.tenant_id == virtual_uuid))
+        quality_count = await db.scalar(select(func.count(QualityCheck.id)).where(QualityCheck.tenant_id == virtual_uuid))
+        equipment_count = await db.scalar(select(func.count(Equipment.id)).where(Equipment.tenant_id == virtual_uuid))
+
+        # Delete in order
+        await db.execute(delete(QualityCheck).where(QualityCheck.tenant_id == virtual_uuid))
+        await db.execute(delete(ProductionBatch).where(ProductionBatch.tenant_id == virtual_uuid))
+        await db.execute(delete(ProductionSchedule).where(ProductionSchedule.tenant_id == virtual_uuid))
+        await db.execute(delete(QualityCheckTemplate).where(QualityCheckTemplate.tenant_id == virtual_uuid))
+        await db.execute(delete(Equipment).where(Equipment.tenant_id == virtual_uuid))
+        await db.execute(delete(ProductionCapacity).where(ProductionCapacity.tenant_id == virtual_uuid))
+        await db.commit()
+
+        duration_ms = int((datetime.now(timezone.utc) - start_time).total_seconds() * 1000)
+        logger.info("Production data deleted successfully", virtual_tenant_id=virtual_tenant_id, duration_ms=duration_ms)
+
+        return {
+            "service": "production",
+            "status": "deleted",
+            "virtual_tenant_id": virtual_tenant_id,
+            "records_deleted": {
+                "batches": batch_count,
+                "schedules": schedule_count,
+                "quality_checks": quality_count,
+                "equipment": equipment_count,
+                "total": batch_count + schedule_count + quality_count + equipment_count
+            },
+            "duration_ms": duration_ms
+        }
+    except Exception as e:
+        logger.error("Failed to delete production data", error=str(e), exc_info=True)
+        await db.rollback()
+        raise HTTPException(status_code=500, detail=str(e))

services/production/app/api/production_operations.py

@@ -4,7 +4,7 @@ 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 fastapi import APIRouter, Depends, HTTPException, Path, Query, Request, status
 from typing import Optional
 from datetime import date, datetime, timedelta
 from uuid import UUID
@@ -12,6 +12,7 @@ import structlog
 
 from shared.auth.decorators import get_current_user_dep
 from shared.routing import RouteBuilder
+from shared.monitoring.decorators import monitor_performance
 from app.services.production_service import ProductionService
 from app.schemas.production import (
     ProductionBatchResponse,
@@ -394,3 +395,50 @@ async def transform_par_baked_products(
         logger.error("Error transforming products",
                     error=str(e), tenant_id=str(tenant_id))
         raise HTTPException(status_code=500, detail="Failed to transform products")
+
+
+# ===== SCHEDULER OPERATIONS =====
+
+@router.post(
+    route_builder.build_operations_route("scheduler/trigger")
+)
+@monitor_performance("trigger_production_scheduler")
+async def trigger_production_scheduler(
+    tenant_id: UUID = Path(...),
+    request: Request = None
+):
+    """
+    Manually trigger the production scheduler for the current tenant
+
+    This endpoint is primarily for testing and development purposes.
+    Triggers the production schedule generation process manually.
+    """
+    try:
+        # Get the scheduler service from app state
+        if hasattr(request.app.state, 'scheduler_service'):
+            scheduler_service = request.app.state.scheduler_service
+            await scheduler_service.test_production_schedule_generation()
+
+            logger.info("Production scheduler triggered manually",
+                       tenant_id=str(tenant_id))
+
+            return {
+                "success": True,
+                "message": "Production scheduler executed successfully",
+                "tenant_id": str(tenant_id)
+            }
+        else:
+            raise HTTPException(
+                status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+                detail="Scheduler service is not available"
+            )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error("Error triggering production scheduler",
+                    error=str(e), tenant_id=str(tenant_id))
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Error triggering production scheduler: {str(e)}"
+        )