Improve the demo feature of the project

services/inventory/app/api/internal_demo.py

@@ -0,0 +1,182 @@
+"""
+Internal Demo Cloning API for Inventory Service
+Service-to-service endpoint for cloning inventory data
+"""
+
+from fastapi import APIRouter, Depends, HTTPException, Header
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+import structlog
+import uuid
+from datetime import datetime, timezone
+from typing import Optional
+import os
+
+from app.core.database import get_db
+from app.models.inventory import Ingredient
+
+logger = structlog.get_logger()
+router = APIRouter(prefix="/internal/demo", tags=["internal"])
+
+# Internal API key for service-to-service auth
+INTERNAL_API_KEY = os.getenv("INTERNAL_API_KEY", "dev-internal-key-change-in-production")
+
+# Base demo tenant IDs
+DEMO_TENANT_SAN_PABLO = "a1b2c3d4-e5f6-47a8-b9c0-d1e2f3a4b5c6"
+DEMO_TENANT_LA_ESPIGA = "b2c3d4e5-f6a7-48b9-c0d1-e2f3a4b5c6d7"
+
+
+def verify_internal_api_key(x_internal_api_key: Optional[str] = Header(None)):
+    """Verify internal API key for service-to-service communication"""
+    if x_internal_api_key != INTERNAL_API_KEY:
+        logger.warning("Unauthorized internal API access attempted")
+        raise HTTPException(status_code=403, detail="Invalid internal API key")
+    return True
+
+
+@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,
+    db: AsyncSession = Depends(get_db),
+    _: bool = Depends(verify_internal_api_key)
+):
+    """
+    Clone inventory service data for a virtual demo tenant
+
+    Clones:
+    - Ingredients from template tenant
+    - (Future: recipes, stock data, etc.)
+
+    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)
+
+    logger.info(
+        "Starting inventory data cloning",
+        base_tenant_id=base_tenant_id,
+        virtual_tenant_id=virtual_tenant_id,
+        demo_account_type=demo_account_type,
+        session_id=session_id
+    )
+
+    try:
+        # Validate UUIDs
+        base_uuid = uuid.UUID(base_tenant_id)
+        virtual_uuid = uuid.UUID(virtual_tenant_id)
+
+        # Track cloning statistics
+        stats = {
+            "ingredients": 0,
+            # Add other entities here in future
+        }
+
+        # Clone Ingredients
+        result = await db.execute(
+            select(Ingredient).where(Ingredient.tenant_id == base_uuid)
+        )
+        base_ingredients = result.scalars().all()
+
+        logger.info(
+            "Found ingredients to clone",
+            count=len(base_ingredients),
+            base_tenant=str(base_uuid)
+        )
+
+        for ingredient in base_ingredients:
+            # Create new ingredient with same attributes but new ID and tenant
+            new_ingredient = Ingredient(
+                id=uuid.uuid4(),
+                tenant_id=virtual_uuid,
+                name=ingredient.name,
+                sku=ingredient.sku,
+                barcode=ingredient.barcode,
+                product_type=ingredient.product_type,
+                ingredient_category=ingredient.ingredient_category,
+                product_category=ingredient.product_category,
+                subcategory=ingredient.subcategory,
+                description=ingredient.description,
+                brand=ingredient.brand,
+                unit_of_measure=ingredient.unit_of_measure,
+                package_size=ingredient.package_size,
+                average_cost=ingredient.average_cost,
+                last_purchase_price=ingredient.last_purchase_price,
+                standard_cost=ingredient.standard_cost,
+                low_stock_threshold=ingredient.low_stock_threshold,
+                reorder_point=ingredient.reorder_point,
+                reorder_quantity=ingredient.reorder_quantity,
+                max_stock_level=ingredient.max_stock_level,
+                shelf_life_days=ingredient.shelf_life_days,
+                is_perishable=ingredient.is_perishable,
+                is_active=ingredient.is_active,
+                allergen_info=ingredient.allergen_info
+            )
+            db.add(new_ingredient)
+            stats["ingredients"] += 1
+
+        # Commit all changes
+        await db.commit()
+
+        total_records = sum(stats.values())
+        duration_ms = int((datetime.now(timezone.utc) - start_time).total_seconds() * 1000)
+
+        logger.info(
+            "Inventory data cloning completed",
+            virtual_tenant_id=virtual_tenant_id,
+            total_records=total_records,
+            stats=stats,
+            duration_ms=duration_ms
+        )
+
+        return {
+            "service": "inventory",
+            "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 inventory data",
+            error=str(e),
+            virtual_tenant_id=virtual_tenant_id,
+            exc_info=True
+        )
+
+        # Rollback on error
+        await db.rollback()
+
+        return {
+            "service": "inventory",
+            "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(_: bool = Depends(verify_internal_api_key)):
+    """
+    Health check for internal cloning endpoint
+    Used by orchestrator to verify service availability
+    """
+    return {
+        "service": "inventory",
+        "clone_endpoint": "available",
+        "version": "2.0.0"
+    }