# services/inventory/app/api/inventory_operations.py """ Inventory Operations API - Business operations for inventory management """ from typing import List, Optional, Dict, Any from uuid import UUID, uuid4 from fastapi import APIRouter, Depends, HTTPException, Query, Path, status from sqlalchemy.ext.asyncio import AsyncSession from pydantic import BaseModel, Field import structlog from app.core.database import get_db from app.services.inventory_service import InventoryService from app.services.product_classifier import ProductClassifierService, get_product_classifier from shared.auth.decorators import get_current_user_dep from shared.auth.access_control import require_user_role from shared.routing import RouteBuilder logger = structlog.get_logger() route_builder = RouteBuilder('inventory') router = APIRouter(tags=["inventory-operations"]) def get_current_user_id(current_user: dict = Depends(get_current_user_dep)) -> UUID: """Extract user ID from current user context""" user_id = current_user.get('user_id') if not user_id: if current_user.get('type') == 'service': return None raise HTTPException( status_code=status.HTTP_401_UNAUTHORIZED, detail="User ID not found in context" ) try: return UUID(user_id) except (ValueError, TypeError): return None # ===== Stock Operations ===== @router.post( route_builder.build_operations_route("consume-stock"), response_model=dict ) @require_user_role(['admin', 'owner', 'member']) async def consume_stock( tenant_id: UUID = Path(..., description="Tenant ID"), ingredient_id: UUID = Query(..., description="Ingredient ID to consume"), quantity: float = Query(..., gt=0, description="Quantity to consume"), reference_number: Optional[str] = Query(None, description="Reference number"), notes: Optional[str] = Query(None, description="Additional notes"), fifo: bool = Query(True, description="Use FIFO method"), current_user: dict = Depends(get_current_user_dep), db: AsyncSession = Depends(get_db) ): """Consume stock for production""" try: user_id = get_current_user_id(current_user) service = InventoryService() consumed_items = await service.consume_stock( ingredient_id, quantity, tenant_id, user_id, reference_number, notes, fifo ) return { "ingredient_id": str(ingredient_id), "total_quantity_consumed": quantity, "consumed_items": consumed_items, "method": "FIFO" if fifo else "LIFO" } except ValueError as e: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail=str(e) ) except Exception as e: raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Failed to consume stock" ) @router.get( route_builder.build_operations_route("stock/expiring"), response_model=List[dict] ) async def get_expiring_stock( tenant_id: UUID = Path(..., description="Tenant ID"), days_ahead: int = Query(7, ge=1, le=365, description="Days ahead to check"), current_user: dict = Depends(get_current_user_dep), db: AsyncSession = Depends(get_db) ): """Get stock items expiring within specified days""" try: service = InventoryService() expiring_items = await service.check_expiration_alerts(tenant_id, days_ahead) return expiring_items except Exception as e: raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Failed to get expiring stock" ) @router.get( route_builder.build_operations_route("stock/low-stock"), response_model=List[dict] ) async def get_low_stock( tenant_id: UUID = Path(..., description="Tenant ID"), current_user: dict = Depends(get_current_user_dep), db: AsyncSession = Depends(get_db) ): """Get ingredients with low stock levels""" try: service = InventoryService() low_stock_items = await service.check_low_stock_alerts(tenant_id) return low_stock_items except Exception as e: raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Failed to get low stock items" ) @router.get( route_builder.build_operations_route("stock/summary"), response_model=dict ) async def get_stock_summary( tenant_id: UUID = Path(..., description="Tenant ID"), current_user: dict = Depends(get_current_user_dep), db: AsyncSession = Depends(get_db) ): """Get stock summary for tenant""" try: service = InventoryService() summary = await service.get_inventory_summary(tenant_id) return summary.dict() except Exception as e: raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Failed to get stock summary" ) # ===== Product Classification Operations ===== class ProductClassificationRequest(BaseModel): """Request for single product classification""" product_name: str = Field(..., description="Product name to classify") sales_volume: float = Field(None, description="Total sales volume for context") sales_data: Dict[str, Any] = Field(default_factory=dict, description="Additional sales context") class BatchClassificationRequest(BaseModel): """Request for batch product classification""" products: List[ProductClassificationRequest] = Field(..., description="Products to classify") class ProductSuggestionResponse(BaseModel): """Response with product classification suggestion""" suggestion_id: str original_name: str suggested_name: str product_type: str category: str unit_of_measure: str confidence_score: float estimated_shelf_life_days: Optional[int] = None requires_refrigeration: bool = False requires_freezing: bool = False is_seasonal: bool = False suggested_supplier: Optional[str] = None notes: Optional[str] = None class BusinessModelAnalysisResponse(BaseModel): """Response with business model analysis""" model: str confidence: float ingredient_count: int finished_product_count: int ingredient_ratio: float recommendations: List[str] class BatchClassificationResponse(BaseModel): """Response for batch classification""" suggestions: List[ProductSuggestionResponse] business_model_analysis: BusinessModelAnalysisResponse total_products: int high_confidence_count: int low_confidence_count: int @router.post( route_builder.build_operations_route("classify-product"), response_model=ProductSuggestionResponse ) async def classify_single_product( request: ProductClassificationRequest, tenant_id: UUID = Path(..., description="Tenant ID"), current_user: Dict[str, Any] = Depends(get_current_user_dep), classifier: ProductClassifierService = Depends(get_product_classifier) ): """Classify a single product for inventory creation""" try: suggestion = classifier.classify_product( request.product_name, request.sales_volume ) response = ProductSuggestionResponse( suggestion_id=str(uuid4()), original_name=suggestion.original_name, suggested_name=suggestion.suggested_name, product_type=suggestion.product_type.value, category=suggestion.category, unit_of_measure=suggestion.unit_of_measure.value, confidence_score=suggestion.confidence_score, estimated_shelf_life_days=suggestion.estimated_shelf_life_days, requires_refrigeration=suggestion.requires_refrigeration, requires_freezing=suggestion.requires_freezing, is_seasonal=suggestion.is_seasonal, suggested_supplier=suggestion.suggested_supplier, notes=suggestion.notes ) logger.info("Classified single product", product=request.product_name, classification=suggestion.product_type.value, confidence=suggestion.confidence_score, tenant_id=tenant_id) return response except Exception as e: logger.error("Failed to classify product", error=str(e), product=request.product_name, tenant_id=tenant_id) raise HTTPException(status_code=500, detail=f"Classification failed: {str(e)}") @router.post( route_builder.build_operations_route("classify-products-batch"), response_model=BatchClassificationResponse ) async def classify_products_batch( request: BatchClassificationRequest, tenant_id: UUID = Path(..., description="Tenant ID"), current_user: Dict[str, Any] = Depends(get_current_user_dep), classifier: ProductClassifierService = Depends(get_product_classifier) ): """Classify multiple products for onboarding automation""" try: if not request.products: raise HTTPException(status_code=400, detail="No products provided for classification") product_names = [p.product_name for p in request.products] sales_volumes = {p.product_name: p.sales_volume for p in request.products if p.sales_volume} suggestions = classifier.classify_products_batch(product_names, sales_volumes) suggestion_responses = [] for suggestion in suggestions: suggestion_responses.append(ProductSuggestionResponse( suggestion_id=str(uuid4()), original_name=suggestion.original_name, suggested_name=suggestion.suggested_name, product_type=suggestion.product_type.value, category=suggestion.category, unit_of_measure=suggestion.unit_of_measure.value, confidence_score=suggestion.confidence_score, estimated_shelf_life_days=suggestion.estimated_shelf_life_days, requires_refrigeration=suggestion.requires_refrigeration, requires_freezing=suggestion.requires_freezing, is_seasonal=suggestion.is_seasonal, suggested_supplier=suggestion.suggested_supplier, notes=suggestion.notes )) # Analyze business model ingredient_count = sum(1 for s in suggestions if s.product_type.value == 'ingredient') finished_count = sum(1 for s in suggestions if s.product_type.value == 'finished_product') semi_finished_count = sum(1 for s in suggestions if 'semi' in s.suggested_name.lower() or 'frozen' in s.suggested_name.lower() or 'pre' in s.suggested_name.lower()) total = len(suggestions) ingredient_ratio = ingredient_count / total if total > 0 else 0 semi_finished_ratio = semi_finished_count / total if total > 0 else 0 if ingredient_ratio >= 0.7: model = 'individual_bakery' elif ingredient_ratio <= 0.2 and semi_finished_ratio >= 0.3: model = 'central_baker_satellite' elif ingredient_ratio <= 0.3: model = 'retail_bakery' else: model = 'hybrid_bakery' if model == 'individual_bakery': confidence = min(ingredient_ratio * 1.2, 0.95) elif model == 'central_baker_satellite': confidence = min((semi_finished_ratio + (1 - ingredient_ratio)) / 2 * 1.2, 0.95) else: confidence = max(abs(ingredient_ratio - 0.5) * 2, 0.1) recommendations = { 'individual_bakery': [ 'Set up raw ingredient inventory management', 'Configure recipe cost calculation and production planning', 'Enable supplier relationships for flour, yeast, sugar, etc.', 'Set up full production workflow with proofing and baking schedules', 'Enable waste tracking for overproduction' ], 'central_baker_satellite': [ 'Configure central baker delivery schedules', 'Set up semi-finished product inventory (frozen dough, par-baked items)', 'Enable finish-baking workflow and timing optimization', 'Track freshness and shelf-life for received products', 'Focus on customer demand forecasting for final products' ], 'retail_bakery': [ 'Set up finished product supplier relationships', 'Configure delivery schedule tracking', 'Enable freshness monitoring and expiration management', 'Focus on sales forecasting and customer preferences' ], 'hybrid_bakery': [ 'Configure both ingredient and semi-finished product management', 'Set up flexible production workflows', 'Enable both supplier and central baker relationships', 'Configure multi-tier inventory categories' ] } business_model_analysis = BusinessModelAnalysisResponse( model=model, confidence=confidence, ingredient_count=ingredient_count, finished_product_count=finished_count, ingredient_ratio=ingredient_ratio, recommendations=recommendations.get(model, []) ) high_confidence_count = sum(1 for s in suggestions if s.confidence_score >= 0.7) low_confidence_count = sum(1 for s in suggestions if s.confidence_score < 0.6) response = BatchClassificationResponse( suggestions=suggestion_responses, business_model_analysis=business_model_analysis, total_products=len(suggestions), high_confidence_count=high_confidence_count, low_confidence_count=low_confidence_count ) logger.info("Batch classification complete", total_products=len(suggestions), business_model=model, high_confidence=high_confidence_count, low_confidence=low_confidence_count, tenant_id=tenant_id) return response except Exception as e: logger.error("Failed batch classification", error=str(e), products_count=len(request.products), tenant_id=tenant_id) raise HTTPException(status_code=500, detail=f"Batch classification failed: {str(e)}")