Initial Commit

mvp-platform-services/vehicles/api/routes/vehicles.py

@@ -0,0 +1,116 @@
+from fastapi import APIRouter, Depends, Query, HTTPException
+import asyncpg
+from ..dependencies import get_db, get_cache
+# DropdownService deprecated; using normalized schema service
+from ..services.vehicles_service import VehiclesService
+from ..repositories.vehicles_repository import VehiclesRepository
+from ..services.cache_service import CacheService
+from ..models.responses import (
+    MakesResponse, ModelsResponse, TrimsResponse,
+    EnginesResponse,
+    MakeItem, ModelItem, TrimItem, EngineItem
+)
+import logging
+
+logger = logging.getLogger(__name__)
+router = APIRouter(prefix="/vehicles", tags=["Vehicles"])
+
+@router.get("/years", response_model=list[int])
+async def get_years(
+    db: asyncpg.Connection = Depends(get_db),
+    cache: CacheService = Depends(get_cache),
+):
+    """Get available model years (distinct, desc)"""
+    service = VehiclesService(cache, VehiclesRepository())
+    return await service.get_years(db)
+
+@router.get("/makes", response_model=MakesResponse)
+async def get_makes(
+    year: int = Query(..., description="Model year", ge=1980, le=2050),
+    db: asyncpg.Connection = Depends(get_db),
+    cache: CacheService = Depends(get_cache)
+):
+    """Get makes for a specific year
+    
+    Hierarchical API: First level - requires year parameter only
+    """
+    try:
+        service = VehiclesService(cache, VehiclesRepository())
+        makes = await service.get_makes(db, year)
+        return MakesResponse(makes=[MakeItem(**m) for m in makes])
+    except Exception as e:
+        logger.error(f"Failed to get makes for year {year}: {e}")
+        raise HTTPException(
+            status_code=500, 
+            detail=f"Failed to retrieve makes for year {year}"
+        )
+
+@router.get("/models", response_model=ModelsResponse)
+async def get_models(
+    year: int = Query(..., description="Model year", ge=1980, le=2050),
+    make_id: int = Query(..., description="Make ID", ge=1),
+    db: asyncpg.Connection = Depends(get_db),
+    cache: CacheService = Depends(get_cache)
+):
+    """Get models for year and make
+    
+    Hierarchical API: Second level - requires year and make_id parameters
+    """
+    try:
+        service = VehiclesService(cache, VehiclesRepository())
+        models = await service.get_models(db, year, make_id)
+        return ModelsResponse(models=[ModelItem(**m) for m in models])
+    except Exception as e:
+        logger.error(f"Failed to get models for year {year}, make {make_id}: {e}")
+        raise HTTPException(
+            status_code=500, 
+            detail=f"Failed to retrieve models for year {year}, make {make_id}"
+        )
+
+@router.get("/trims", response_model=TrimsResponse)
+async def get_trims(
+    year: int = Query(..., description="Model year", ge=1980, le=2050),
+    make_id: int = Query(..., description="Make ID", ge=1),
+    model_id: int = Query(..., description="Model ID", ge=1),
+    db: asyncpg.Connection = Depends(get_db),
+    cache: CacheService = Depends(get_cache)
+):
+    """Get trims for year, make, and model
+    
+    Hierarchical API: Third level - requires year, make_id, and model_id parameters
+    """
+    try:
+        service = VehiclesService(cache, VehiclesRepository())
+        trims = await service.get_trims(db, year, model_id)
+        return TrimsResponse(trims=[TrimItem(**t) for t in trims])
+    except Exception as e:
+        logger.error(f"Failed to get trims for year {year}, make {make_id}, model {model_id}: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to retrieve trims for year {year}, make {make_id}, model {model_id}"
+        )
+
+@router.get("/engines", response_model=EnginesResponse)
+async def get_engines(
+    year: int = Query(..., description="Model year", ge=1980, le=2050),
+    make_id: int = Query(..., description="Make ID", ge=1),
+    model_id: int = Query(..., description="Model ID", ge=1),
+    trim_id: int = Query(..., description="Trim ID", ge=1),
+    db: asyncpg.Connection = Depends(get_db),
+    cache: CacheService = Depends(get_cache)
+):
+    """Get engines for year, make, model, and trim"""
+    try:
+        service = VehiclesService(cache, VehiclesRepository())
+        engines = await service.get_engines(db, year, model_id, trim_id)
+        return EnginesResponse(engines=[EngineItem(**e) for e in engines])
+    except Exception as e:
+        logger.error(
+            f"Failed to get engines for year {year}, make {make_id}, model {model_id}, trim {trim_id}: {e}"
+        )
+        raise HTTPException(
+            status_code=500,
+            detail=(
+                f"Failed to retrieve engines for year {year}, make {make_id}, model {model_id}, trim {trim_id}"
+            )
+        )