REFACTOR data service

services/external/app/api/__init__.py

@@ -0,0 +1 @@
+# services/external/app/api/__init__.py

services/external/app/api/traffic.py

@@ -0,0 +1,184 @@
+# 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.traffic_volume, 
+                    congestion=traffic.congestion_level)
+        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)}")

services/external/app/api/weather.py

@@ -0,0 +1,157 @@
+# services/external/app/api/weather.py
+"""
+Weather API Endpoints
+"""
+
+from fastapi import APIRouter, Depends, HTTPException, Query, BackgroundTasks, Path
+from typing import List, Optional, Dict, Any
+from datetime import datetime, date
+import structlog
+from uuid import UUID
+
+from app.schemas.weather import (
+    WeatherDataResponse,
+    WeatherForecastResponse,
+    WeatherForecastRequest,
+    HistoricalWeatherRequest
+)
+from app.services.weather_service import WeatherService
+from app.services.messaging import publish_weather_updated
+
+# Import unified authentication from shared library
+from shared.auth.decorators import (
+    get_current_user_dep,
+    get_current_tenant_id_dep
+)
+
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.core.database import get_db
+
+router = APIRouter(tags=["weather"])
+logger = structlog.get_logger()
+weather_service = WeatherService()
+
+@router.get("/tenants/{tenant_id}/weather/current", response_model=WeatherDataResponse)
+async def get_current_weather(
+    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 weather data for location"""
+    try:
+        logger.debug("Getting current weather", 
+                    lat=latitude, 
+                    lon=longitude,
+                    tenant_id=tenant_id,
+                    user_id=current_user["user_id"])
+        
+        weather = await weather_service.get_current_weather(latitude, longitude)
+        
+        if not weather:
+            raise HTTPException(status_code=404, detail="Weather data not available")
+        
+        # Publish event
+        try:
+            await publish_weather_updated({
+                "type": "current_weather_requested",
+                "tenant_id": tenant_id,
+                "latitude": latitude,
+                "longitude": longitude,
+                "requested_by": current_user["user_id"],
+                "timestamp": datetime.utcnow().isoformat()
+            })
+        except Exception as e:
+            logger.warning("Failed to publish weather event", error=str(e))
+        
+        return weather
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error("Failed to get current weather", error=str(e))
+        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+
+@router.post("/tenants/{tenant_id}/weather/historical")
+async def get_historical_weather(
+    request: HistoricalWeatherRequest,
+    db: AsyncSession = Depends(get_db),
+    tenant_id: UUID = Path(..., description="Tenant ID"),
+    current_user: Dict[str, Any] = Depends(get_current_user_dep),
+):
+    """Get historical weather 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 weather_service.get_historical_weather(
+            request.latitude, request.longitude, request.start_date, request.end_date)
+        
+        # Publish event (with error handling)
+        try:
+            await publish_weather_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 weather event", error=str(pub_error))
+            # Continue processing
+        
+        return historical_data
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error("Unexpected error in historical weather API", error=str(e))
+        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+
+
+@router.post("/tenants/{tenant_id}/weather/forecast", response_model=List[WeatherForecastResponse])
+async def get_weather_forecast(
+    request: WeatherForecastRequest,
+    tenant_id: UUID = Path(..., description="Tenant ID"),
+    current_user: Dict[str, Any] = Depends(get_current_user_dep),
+):
+    """Get weather forecast for location"""
+    try:
+        logger.debug("Getting weather forecast", 
+                    lat=request.latitude, 
+                    lon=request.longitude, 
+                    days=request.days,
+                    tenant_id=tenant_id)
+        
+        forecast = await weather_service.get_weather_forecast(request.latitude, request.longitude, request.days)
+        
+        if not forecast:
+            raise HTTPException(status_code=404, detail="Weather forecast not available")
+        
+        # Publish event
+        try:
+            await publish_weather_updated({
+                "type": "forecast_requested",
+                "tenant_id": tenant_id,
+                "latitude": request.latitude,
+                "longitude": request.longitude,
+                "days": request.days,
+                "requested_by": current_user["user_id"],
+                "timestamp": datetime.utcnow().isoformat()
+            })
+        except Exception as e:
+            logger.warning("Failed to publish forecast event", error=str(e))
+        
+        return forecast
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error("Failed to get weather forecast", error=str(e))
+        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")