184 lines
7.5 KiB
Python
184 lines
7.5 KiB
Python
# 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)}") |