602 lines
22 KiB
Python
602 lines
22 KiB
Python
# services/forecasting/app/api/forecasting_operations.py
|
|
"""
|
|
Forecasting Operations API - Business operations for forecast generation and predictions
|
|
"""
|
|
|
|
import structlog
|
|
from fastapi import APIRouter, Depends, HTTPException, status, Query, Path, Request
|
|
from typing import List, Dict, Any, Optional
|
|
from datetime import date, datetime, timezone
|
|
import uuid
|
|
|
|
from app.services.forecasting_service import EnhancedForecastingService
|
|
from app.services.prediction_service import PredictionService
|
|
from app.services.forecast_cache import get_forecast_cache_service
|
|
from app.schemas.forecasts import (
|
|
ForecastRequest, ForecastResponse, BatchForecastRequest,
|
|
BatchForecastResponse, MultiDayForecastResponse
|
|
)
|
|
from shared.auth.decorators import get_current_user_dep
|
|
from shared.database.base import create_database_manager
|
|
from shared.monitoring.decorators import track_execution_time
|
|
from shared.monitoring.metrics import get_metrics_collector
|
|
from app.core.config import settings
|
|
from app.models import AuditLog
|
|
from shared.routing import RouteBuilder
|
|
from shared.auth.access_control import require_user_role, service_only_access
|
|
from shared.security import create_audit_logger, create_rate_limiter, AuditSeverity, AuditAction
|
|
from shared.subscription.plans import get_forecast_quota, get_forecast_horizon_limit
|
|
from shared.redis_utils import get_redis_client
|
|
|
|
route_builder = RouteBuilder('forecasting')
|
|
logger = structlog.get_logger()
|
|
router = APIRouter(tags=["forecasting-operations"])
|
|
|
|
# Initialize audit logger
|
|
audit_logger = create_audit_logger("forecasting-service", AuditLog)
|
|
|
|
async def get_rate_limiter():
|
|
"""Dependency for rate limiter"""
|
|
redis_client = await get_redis_client()
|
|
return create_rate_limiter(redis_client)
|
|
|
|
|
|
def get_enhanced_forecasting_service():
|
|
"""Dependency injection for EnhancedForecastingService"""
|
|
database_manager = create_database_manager(settings.DATABASE_URL, "forecasting-service")
|
|
return EnhancedForecastingService(database_manager)
|
|
|
|
|
|
def get_enhanced_prediction_service():
|
|
"""Dependency injection for enhanced PredictionService"""
|
|
database_manager = create_database_manager(settings.DATABASE_URL, "forecasting-service")
|
|
return PredictionService(database_manager)
|
|
|
|
|
|
@router.post(
|
|
route_builder.build_operations_route("single"),
|
|
response_model=ForecastResponse
|
|
)
|
|
@require_user_role(['viewer', 'member', 'admin', 'owner'])
|
|
@track_execution_time("enhanced_single_forecast_duration_seconds", "forecasting-service")
|
|
async def generate_single_forecast(
|
|
request: ForecastRequest,
|
|
tenant_id: str = Path(..., description="Tenant ID"),
|
|
request_obj: Request = None,
|
|
current_user: dict = Depends(get_current_user_dep),
|
|
enhanced_forecasting_service: EnhancedForecastingService = Depends(get_enhanced_forecasting_service)
|
|
):
|
|
"""Generate a single product forecast with caching support"""
|
|
metrics = get_metrics_collector(request_obj)
|
|
|
|
try:
|
|
logger.info("Generating single forecast",
|
|
tenant_id=tenant_id,
|
|
inventory_product_id=request.inventory_product_id,
|
|
forecast_date=request.forecast_date.isoformat())
|
|
|
|
if metrics:
|
|
metrics.increment_counter("single_forecasts_total")
|
|
|
|
# Initialize cache service
|
|
cache_service = get_forecast_cache_service(settings.REDIS_URL)
|
|
|
|
# Check cache first
|
|
cached_forecast = await cache_service.get_cached_forecast(
|
|
tenant_id=uuid.UUID(tenant_id),
|
|
product_id=uuid.UUID(request.inventory_product_id),
|
|
forecast_date=request.forecast_date
|
|
)
|
|
|
|
if cached_forecast:
|
|
if metrics:
|
|
metrics.increment_counter("forecast_cache_hits_total")
|
|
logger.info("Returning cached forecast",
|
|
tenant_id=tenant_id,
|
|
forecast_id=cached_forecast.get('id'))
|
|
return ForecastResponse(**cached_forecast)
|
|
|
|
# Cache miss - generate forecast
|
|
if metrics:
|
|
metrics.increment_counter("forecast_cache_misses_total")
|
|
|
|
forecast = await enhanced_forecasting_service.generate_forecast(
|
|
tenant_id=tenant_id,
|
|
request=request
|
|
)
|
|
|
|
# Cache the result
|
|
await cache_service.cache_forecast(
|
|
tenant_id=uuid.UUID(tenant_id),
|
|
product_id=uuid.UUID(request.inventory_product_id),
|
|
forecast_date=request.forecast_date,
|
|
forecast_data=forecast.dict()
|
|
)
|
|
|
|
if metrics:
|
|
metrics.increment_counter("single_forecasts_success_total")
|
|
|
|
logger.info("Single forecast generated successfully",
|
|
tenant_id=tenant_id,
|
|
forecast_id=forecast.id)
|
|
|
|
return forecast
|
|
|
|
except ValueError as e:
|
|
if metrics:
|
|
metrics.increment_counter("forecast_validation_errors_total")
|
|
logger.error("Forecast validation error", error=str(e), tenant_id=tenant_id)
|
|
raise HTTPException(
|
|
status_code=status.HTTP_400_BAD_REQUEST,
|
|
detail=str(e)
|
|
)
|
|
except Exception as e:
|
|
if metrics:
|
|
metrics.increment_counter("single_forecasts_errors_total")
|
|
logger.error("Single forecast generation failed", error=str(e), tenant_id=tenant_id)
|
|
raise HTTPException(
|
|
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
|
detail="Forecast generation failed"
|
|
)
|
|
|
|
|
|
@router.post(
|
|
route_builder.build_operations_route("multi-day"),
|
|
response_model=MultiDayForecastResponse
|
|
)
|
|
@require_user_role(['viewer', 'member', 'admin', 'owner'])
|
|
@track_execution_time("enhanced_multi_day_forecast_duration_seconds", "forecasting-service")
|
|
async def generate_multi_day_forecast(
|
|
request: ForecastRequest,
|
|
tenant_id: str = Path(..., description="Tenant ID"),
|
|
request_obj: Request = None,
|
|
current_user: dict = Depends(get_current_user_dep),
|
|
enhanced_forecasting_service: EnhancedForecastingService = Depends(get_enhanced_forecasting_service)
|
|
):
|
|
"""Generate multiple daily forecasts for the specified period"""
|
|
metrics = get_metrics_collector(request_obj)
|
|
|
|
try:
|
|
logger.info("Generating multi-day forecast",
|
|
tenant_id=tenant_id,
|
|
inventory_product_id=request.inventory_product_id,
|
|
forecast_days=request.forecast_days,
|
|
forecast_date=request.forecast_date.isoformat())
|
|
|
|
if metrics:
|
|
metrics.increment_counter("multi_day_forecasts_total")
|
|
|
|
if request.forecast_days <= 0 or request.forecast_days > 30:
|
|
raise ValueError("forecast_days must be between 1 and 30")
|
|
|
|
forecast_result = await enhanced_forecasting_service.generate_multi_day_forecast(
|
|
tenant_id=tenant_id,
|
|
request=request
|
|
)
|
|
|
|
if metrics:
|
|
metrics.increment_counter("multi_day_forecasts_success_total")
|
|
|
|
logger.info("Multi-day forecast generated successfully",
|
|
tenant_id=tenant_id,
|
|
inventory_product_id=request.inventory_product_id,
|
|
forecast_days=len(forecast_result.get("forecasts", [])))
|
|
|
|
return forecast_result
|
|
|
|
except ValueError as e:
|
|
if metrics:
|
|
metrics.increment_counter("forecast_validation_errors_total")
|
|
logger.error("Multi-day forecast validation error", error=str(e), tenant_id=tenant_id)
|
|
raise HTTPException(
|
|
status_code=status.HTTP_400_BAD_REQUEST,
|
|
detail=str(e)
|
|
)
|
|
except Exception as e:
|
|
if metrics:
|
|
metrics.increment_counter("multi_day_forecasts_errors_total")
|
|
logger.error("Multi-day forecast generation failed", error=str(e), tenant_id=tenant_id)
|
|
raise HTTPException(
|
|
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
|
detail="Multi-day forecast generation failed"
|
|
)
|
|
|
|
|
|
@router.post(
|
|
route_builder.build_operations_route("batch"),
|
|
response_model=BatchForecastResponse
|
|
)
|
|
@require_user_role(['admin', 'owner'])
|
|
@track_execution_time("enhanced_batch_forecast_duration_seconds", "forecasting-service")
|
|
async def generate_batch_forecast(
|
|
request: BatchForecastRequest,
|
|
tenant_id: str = Path(..., description="Tenant ID"),
|
|
request_obj: Request = None,
|
|
current_user: dict = Depends(get_current_user_dep),
|
|
enhanced_forecasting_service: EnhancedForecastingService = Depends(get_enhanced_forecasting_service),
|
|
rate_limiter = Depends(get_rate_limiter)
|
|
):
|
|
"""Generate forecasts for multiple products in batch (Admin+ only, quota enforced)"""
|
|
metrics = get_metrics_collector(request_obj)
|
|
|
|
try:
|
|
logger.info("Generating batch forecast",
|
|
tenant_id=tenant_id,
|
|
product_count=len(request.inventory_product_ids))
|
|
|
|
if metrics:
|
|
metrics.increment_counter("batch_forecasts_total")
|
|
|
|
if not request.inventory_product_ids:
|
|
raise ValueError("inventory_product_ids cannot be empty")
|
|
|
|
# Get subscription tier and enforce quotas
|
|
tier = current_user.get('subscription_tier', 'starter')
|
|
|
|
# Check daily quota for forecast generation
|
|
quota_limit = get_forecast_quota(tier)
|
|
quota_result = await rate_limiter.check_and_increment_quota(
|
|
tenant_id,
|
|
"forecast_generation",
|
|
quota_limit,
|
|
period=86400 # 24 hours
|
|
)
|
|
|
|
# Validate forecast horizon if specified
|
|
if request.horizon_days:
|
|
await rate_limiter.validate_forecast_horizon(
|
|
tenant_id, request.horizon_days, tier
|
|
)
|
|
|
|
batch_result = await enhanced_forecasting_service.generate_batch_forecast(
|
|
tenant_id=tenant_id,
|
|
request=request
|
|
)
|
|
|
|
if metrics:
|
|
metrics.increment_counter("batch_forecasts_success_total")
|
|
|
|
logger.info("Batch forecast generated successfully",
|
|
tenant_id=tenant_id,
|
|
total_forecasts=batch_result.total_forecasts)
|
|
|
|
return batch_result
|
|
|
|
except ValueError as e:
|
|
if metrics:
|
|
metrics.increment_counter("forecast_validation_errors_total")
|
|
logger.error("Batch forecast validation error", error=str(e), tenant_id=tenant_id)
|
|
raise HTTPException(
|
|
status_code=status.HTTP_400_BAD_REQUEST,
|
|
detail=str(e)
|
|
)
|
|
except Exception as e:
|
|
if metrics:
|
|
metrics.increment_counter("batch_forecasts_errors_total")
|
|
logger.error("Batch forecast generation failed", error=str(e), tenant_id=tenant_id)
|
|
raise HTTPException(
|
|
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
|
detail="Batch forecast generation failed"
|
|
)
|
|
|
|
|
|
@router.post(
|
|
route_builder.build_operations_route("realtime")
|
|
)
|
|
@require_user_role(['viewer', 'member', 'admin', 'owner'])
|
|
@track_execution_time("enhanced_realtime_prediction_duration_seconds", "forecasting-service")
|
|
async def generate_realtime_prediction(
|
|
prediction_request: Dict[str, Any],
|
|
tenant_id: str = Path(..., description="Tenant ID"),
|
|
request_obj: Request = None,
|
|
current_user: dict = Depends(get_current_user_dep),
|
|
prediction_service: PredictionService = Depends(get_enhanced_prediction_service)
|
|
):
|
|
"""Generate real-time prediction"""
|
|
metrics = get_metrics_collector(request_obj)
|
|
|
|
try:
|
|
logger.info("Generating real-time prediction",
|
|
tenant_id=tenant_id,
|
|
inventory_product_id=prediction_request.get("inventory_product_id"))
|
|
|
|
if metrics:
|
|
metrics.increment_counter("realtime_predictions_total")
|
|
|
|
required_fields = ["inventory_product_id", "model_id", "features"]
|
|
missing_fields = [field for field in required_fields if field not in prediction_request]
|
|
if missing_fields:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_400_BAD_REQUEST,
|
|
detail=f"Missing required fields: {missing_fields}"
|
|
)
|
|
|
|
prediction_result = await prediction_service.predict_with_weather_forecast(
|
|
model_id=prediction_request["model_id"],
|
|
model_path=prediction_request.get("model_path", ""),
|
|
features=prediction_request["features"],
|
|
tenant_id=tenant_id,
|
|
days=prediction_request.get("days", 7),
|
|
confidence_level=prediction_request.get("confidence_level", 0.8)
|
|
)
|
|
|
|
if metrics:
|
|
metrics.increment_counter("realtime_predictions_success_total")
|
|
|
|
logger.info("Real-time prediction generated successfully",
|
|
tenant_id=tenant_id,
|
|
days=len(prediction_result))
|
|
|
|
return {
|
|
"tenant_id": tenant_id,
|
|
"inventory_product_id": prediction_request["inventory_product_id"],
|
|
"model_id": prediction_request["model_id"],
|
|
"predictions": prediction_result,
|
|
"days": len(prediction_result),
|
|
"timestamp": datetime.now(timezone.utc).isoformat()
|
|
}
|
|
|
|
except HTTPException:
|
|
raise
|
|
except ValueError as e:
|
|
if metrics:
|
|
metrics.increment_counter("prediction_validation_errors_total")
|
|
logger.error("Prediction validation error", error=str(e), tenant_id=tenant_id)
|
|
raise HTTPException(
|
|
status_code=status.HTTP_400_BAD_REQUEST,
|
|
detail=str(e)
|
|
)
|
|
except Exception as e:
|
|
if metrics:
|
|
metrics.increment_counter("realtime_predictions_errors_total")
|
|
logger.error("Real-time prediction failed", error=str(e), tenant_id=tenant_id)
|
|
raise HTTPException(
|
|
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
|
detail="Real-time prediction failed"
|
|
)
|
|
|
|
|
|
@router.post(
|
|
route_builder.build_operations_route("batch-predictions")
|
|
)
|
|
@require_user_role(['viewer', 'member', 'admin', 'owner'])
|
|
async def generate_batch_predictions(
|
|
predictions_request: List[Dict[str, Any]],
|
|
tenant_id: str = Path(..., description="Tenant ID"),
|
|
current_user: dict = Depends(get_current_user_dep),
|
|
prediction_service: PredictionService = Depends(get_enhanced_prediction_service)
|
|
):
|
|
"""Generate batch predictions"""
|
|
try:
|
|
logger.info("Generating batch predictions", tenant_id=tenant_id, count=len(predictions_request))
|
|
|
|
results = []
|
|
for pred_request in predictions_request:
|
|
try:
|
|
prediction_result = await prediction_service.predict_with_weather_forecast(
|
|
model_id=pred_request["model_id"],
|
|
model_path=pred_request.get("model_path", ""),
|
|
features=pred_request["features"],
|
|
tenant_id=tenant_id,
|
|
days=pred_request.get("days", 7),
|
|
confidence_level=pred_request.get("confidence_level", 0.8)
|
|
)
|
|
results.append({
|
|
"inventory_product_id": pred_request.get("inventory_product_id"),
|
|
"predictions": prediction_result,
|
|
"success": True
|
|
})
|
|
except Exception as e:
|
|
results.append({
|
|
"inventory_product_id": pred_request.get("inventory_product_id"),
|
|
"error": str(e),
|
|
"success": False
|
|
})
|
|
|
|
return {"predictions": results, "total": len(results)}
|
|
|
|
except Exception as e:
|
|
logger.error("Batch predictions failed", error=str(e), tenant_id=tenant_id)
|
|
raise HTTPException(
|
|
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
|
detail="Batch predictions failed"
|
|
)
|
|
|
|
|
|
@router.post(
|
|
route_builder.build_operations_route("validate-predictions")
|
|
)
|
|
async def validate_predictions(
|
|
tenant_id: str = Path(..., description="Tenant ID"),
|
|
start_date: date = Query(...),
|
|
end_date: date = Query(...),
|
|
enhanced_forecasting_service: EnhancedForecastingService = Depends(get_enhanced_forecasting_service)
|
|
):
|
|
"""Validate predictions against actual sales data"""
|
|
try:
|
|
logger.info("Validating predictions", tenant_id=tenant_id)
|
|
|
|
validation_results = await enhanced_forecasting_service.validate_predictions(
|
|
tenant_id=tenant_id,
|
|
start_date=start_date,
|
|
end_date=end_date
|
|
)
|
|
|
|
return validation_results
|
|
|
|
except Exception as e:
|
|
logger.error("Prediction validation failed", error=str(e), tenant_id=tenant_id)
|
|
raise HTTPException(
|
|
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
|
detail="Prediction validation failed"
|
|
)
|
|
|
|
|
|
@router.get(
|
|
route_builder.build_operations_route("statistics")
|
|
)
|
|
async def get_forecast_statistics(
|
|
tenant_id: str = Path(..., description="Tenant ID"),
|
|
start_date: Optional[date] = Query(None),
|
|
end_date: Optional[date] = Query(None),
|
|
enhanced_forecasting_service: EnhancedForecastingService = Depends(get_enhanced_forecasting_service)
|
|
):
|
|
"""Get forecast statistics"""
|
|
try:
|
|
logger.info("Getting forecast statistics", tenant_id=tenant_id)
|
|
|
|
stats = await enhanced_forecasting_service.get_forecast_statistics(
|
|
tenant_id=tenant_id,
|
|
start_date=start_date,
|
|
end_date=end_date
|
|
)
|
|
|
|
return stats
|
|
|
|
except Exception as e:
|
|
logger.error("Failed to get forecast statistics", error=str(e), tenant_id=tenant_id)
|
|
raise HTTPException(
|
|
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
|
detail="Failed to retrieve forecast statistics"
|
|
)
|
|
|
|
|
|
@router.delete(
|
|
route_builder.build_operations_route("cache")
|
|
)
|
|
async def clear_prediction_cache(
|
|
tenant_id: str = Path(..., description="Tenant ID"),
|
|
prediction_service: PredictionService = Depends(get_enhanced_prediction_service)
|
|
):
|
|
"""Clear prediction cache"""
|
|
try:
|
|
logger.info("Clearing prediction cache", tenant_id=tenant_id)
|
|
|
|
await prediction_service.clear_cache(tenant_id=tenant_id)
|
|
|
|
return {"message": "Prediction cache cleared successfully"}
|
|
|
|
except Exception as e:
|
|
logger.error("Failed to clear prediction cache", error=str(e), tenant_id=tenant_id)
|
|
raise HTTPException(
|
|
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
|
detail="Failed to clear prediction cache"
|
|
)
|
|
|
|
|
|
# ============================================================================
|
|
# Tenant Data Deletion Operations (Internal Service Only)
|
|
# ============================================================================
|
|
|
|
@router.delete(
|
|
route_builder.build_base_route("tenant/{tenant_id}", include_tenant_prefix=False),
|
|
response_model=dict
|
|
)
|
|
@service_only_access
|
|
async def delete_tenant_data(
|
|
tenant_id: str = Path(..., description="Tenant ID to delete data for"),
|
|
current_user: dict = Depends(get_current_user_dep)
|
|
):
|
|
"""
|
|
Delete all forecasting data for a tenant (Internal service only)
|
|
|
|
This endpoint is called by the orchestrator during tenant deletion.
|
|
It permanently deletes all forecasting-related data including:
|
|
- Forecasts (all time periods)
|
|
- Prediction batches
|
|
- Model performance metrics
|
|
- Prediction cache
|
|
- Audit logs
|
|
|
|
**WARNING**: This operation is irreversible!
|
|
|
|
Returns:
|
|
Deletion summary with counts of deleted records
|
|
"""
|
|
from app.services.tenant_deletion_service import ForecastingTenantDeletionService
|
|
|
|
try:
|
|
logger.info("forecasting.tenant_deletion.api_called", tenant_id=tenant_id)
|
|
|
|
db_manager = create_database_manager(settings.DATABASE_URL, "forecasting")
|
|
|
|
async with db_manager.get_session() as session:
|
|
deletion_service = ForecastingTenantDeletionService(session)
|
|
result = await deletion_service.safe_delete_tenant_data(tenant_id)
|
|
|
|
if not result.success:
|
|
raise HTTPException(
|
|
status_code=500,
|
|
detail=f"Tenant data deletion failed: {', '.join(result.errors)}"
|
|
)
|
|
|
|
return {
|
|
"message": "Tenant data deletion completed successfully",
|
|
"summary": result.to_dict()
|
|
}
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error("forecasting.tenant_deletion.api_error",
|
|
tenant_id=tenant_id,
|
|
error=str(e),
|
|
exc_info=True)
|
|
raise HTTPException(
|
|
status_code=500,
|
|
detail=f"Failed to delete tenant data: {str(e)}"
|
|
)
|
|
|
|
|
|
@router.get(
|
|
route_builder.build_base_route("tenant/{tenant_id}/deletion-preview", include_tenant_prefix=False),
|
|
response_model=dict
|
|
)
|
|
@service_only_access
|
|
async def preview_tenant_data_deletion(
|
|
tenant_id: str = Path(..., description="Tenant ID to preview deletion for"),
|
|
current_user: dict = Depends(get_current_user_dep)
|
|
):
|
|
"""
|
|
Preview what data would be deleted for a tenant (dry-run)
|
|
|
|
This endpoint shows counts of all data that would be deleted
|
|
without actually deleting anything. Useful for:
|
|
- Confirming deletion scope before execution
|
|
- Auditing and compliance
|
|
- Troubleshooting
|
|
|
|
Returns:
|
|
Dictionary with entity names and their counts
|
|
"""
|
|
from app.services.tenant_deletion_service import ForecastingTenantDeletionService
|
|
|
|
try:
|
|
logger.info("forecasting.tenant_deletion.preview_called", tenant_id=tenant_id)
|
|
|
|
db_manager = create_database_manager(settings.DATABASE_URL, "forecasting")
|
|
|
|
async with db_manager.get_session() as session:
|
|
deletion_service = ForecastingTenantDeletionService(session)
|
|
preview = await deletion_service.get_tenant_data_preview(tenant_id)
|
|
|
|
total_records = sum(preview.values())
|
|
|
|
return {
|
|
"tenant_id": tenant_id,
|
|
"service": "forecasting",
|
|
"preview": preview,
|
|
"total_records": total_records,
|
|
"warning": "These records will be permanently deleted and cannot be recovered"
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error("forecasting.tenant_deletion.preview_error",
|
|
tenant_id=tenant_id,
|
|
error=str(e),
|
|
exc_info=True)
|
|
raise HTTPException(
|
|
status_code=500,
|
|
detail=f"Failed to preview tenant data deletion: {str(e)}"
|
|
)
|