# services/external/app/api/traffic.py """Traffic data API endpoints with improved error handling""" from fastapi import APIRouter, Depends, HTTPException, Query, Path from typing import List, Dict, Any from datetime import datetime, timedelta import structlog from uuid import UUID from sqlalchemy.ext.asyncio import AsyncSession from app.core.database import get_db from app.services.traffic_service import TrafficService from app.services.messaging import publish_traffic_updated from app.schemas.traffic import ( TrafficDataResponse, HistoricalTrafficRequest, TrafficForecastRequest ) from shared.auth.decorators import ( get_current_user_dep ) router = APIRouter(tags=["traffic"]) traffic_service = TrafficService() logger = structlog.get_logger() @router.get("/tenants/{tenant_id}/traffic/current", response_model=TrafficDataResponse) async def get_current_traffic( latitude: float = Query(..., description="Latitude"), longitude: float = Query(..., description="Longitude"), tenant_id: UUID = Path(..., description="Tenant ID"), current_user: Dict[str, Any] = Depends(get_current_user_dep), ): """Get current traffic data for location""" try: logger.debug("API: Getting current traffic", lat=latitude, lon=longitude) traffic = await traffic_service.get_current_traffic(latitude, longitude) if not traffic: logger.warning("No traffic data available", lat=latitude, lon=longitude) raise HTTPException(status_code=404, detail="Traffic data not available") # Publish event (with error handling) try: await publish_traffic_updated({ "type": "current_requested", "latitude": latitude, "longitude": longitude, "timestamp": datetime.utcnow().isoformat() }) except Exception as pub_error: logger.warning("Failed to publish traffic event", error=str(pub_error)) # Continue processing - event publishing failure shouldn't break the API logger.debug("Successfully returning traffic data", volume=traffic.get('traffic_volume') if isinstance(traffic, dict) else getattr(traffic, 'traffic_volume', None), congestion=traffic.get('congestion_level') if isinstance(traffic, dict) else getattr(traffic, 'congestion_level', None)) return traffic except HTTPException: # Re-raise HTTP exceptions raise except Exception as e: logger.error("Unexpected error in traffic API", error=str(e)) import traceback logger.error("Traffic API traceback", traceback=traceback.format_exc()) raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}") @router.post("/tenants/{tenant_id}/traffic/historical") async def get_historical_traffic( request: HistoricalTrafficRequest, db: AsyncSession = Depends(get_db), tenant_id: UUID = Path(..., description="Tenant ID"), current_user: Dict[str, Any] = Depends(get_current_user_dep), ): """Get historical traffic data with date range in payload""" try: # Validate date range if request.end_date <= request.start_date: raise HTTPException(status_code=400, detail="End date must be after start date") if (request.end_date - request.start_date).days > 1000: raise HTTPException(status_code=400, detail="Date range cannot exceed 90 days") historical_data = await traffic_service.get_historical_traffic( request.latitude, request.longitude, request.start_date, request.end_date, str(tenant_id) ) # Publish event (with error handling) try: await publish_traffic_updated({ "type": "historical_requested", "latitude": request.latitude, "longitude": request.longitude, "start_date": request.start_date.isoformat(), "end_date": request.end_date.isoformat(), "records_count": len(historical_data), "timestamp": datetime.utcnow().isoformat() }) except Exception as pub_error: logger.warning("Failed to publish historical traffic event", error=str(pub_error)) # Continue processing return historical_data except HTTPException: raise except Exception as e: logger.error("Unexpected error in historical traffic API", error=str(e)) raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}") @router.post("/tenants/{tenant_id}/traffic/forecast") async def get_traffic_forecast( request: TrafficForecastRequest, tenant_id: UUID = Path(..., description="Tenant ID"), current_user: Dict[str, Any] = Depends(get_current_user_dep), ): """Get traffic forecast for location""" try: logger.debug("API: Getting traffic forecast", lat=request.latitude, lon=request.longitude, hours=request.hours) # For now, return mock forecast data since we don't have a real traffic forecast service # In a real implementation, this would call a traffic forecasting service # Generate mock forecast data for the requested hours forecast_data = [] from datetime import datetime, timedelta base_time = datetime.utcnow() for hour in range(request.hours): forecast_time = base_time + timedelta(hours=hour) # Mock traffic pattern (higher during rush hours) hour_of_day = forecast_time.hour if 7 <= hour_of_day <= 9 or 17 <= hour_of_day <= 19: # Rush hours traffic_volume = 120 pedestrian_count = 80 congestion_level = "high" average_speed = 15 elif 22 <= hour_of_day or hour_of_day <= 6: # Night hours traffic_volume = 20 pedestrian_count = 10 congestion_level = "low" average_speed = 50 else: # Regular hours traffic_volume = 60 pedestrian_count = 40 congestion_level = "medium" average_speed = 35 # Use consistent TrafficDataResponse format forecast_data.append({ "date": forecast_time.isoformat(), "traffic_volume": traffic_volume, "pedestrian_count": pedestrian_count, "congestion_level": congestion_level, "average_speed": average_speed, "source": "madrid_opendata_forecast" }) # Publish event (with error handling) try: await publish_traffic_updated({ "type": "forecast_requested", "latitude": request.latitude, "longitude": request.longitude, "hours": request.hours, "timestamp": datetime.utcnow().isoformat() }) except Exception as pub_error: logger.warning("Failed to publish traffic forecast event", error=str(pub_error)) # Continue processing logger.debug("Successfully returning traffic forecast", records=len(forecast_data)) return forecast_data except HTTPException: raise except Exception as e: logger.error("Unexpected error in traffic forecast API", error=str(e)) raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")