Merge pull request #43 from Commute-ai/copilot/connect-routing-with-preferences

Connect routing logic with user preferences (requires authentication)

Author: zlendo1

app/api/v1/endpoints/routes.py

@@ -6,12 +6,17 @@
 
 import logging
 from datetime import datetime, timezone
-from typing import Any
+from typing import Any, List
 
-from fastapi import APIRouter, HTTPException
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
 
+from app.db.database import get_db
+from app.models.user import User
 from app.schemas.routes import RouteSearchRequest, RouteSearchResponse
 from app.services.ai_agents_service import ai_agents_service
+from app.services.auth_service import auth_service
+from app.services.preference_service import preference_service
 from app.services.routing_service import (
     RoutingAPIError,
     RoutingDataError,
@@ -26,15 +31,21 @@
 
 
 @router.post("/search", response_model=RouteSearchResponse)
-async def search_routes(request: RouteSearchRequest) -> Any:
+async def search_routes(
+    request: RouteSearchRequest,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(auth_service.get_current_user),
+) -> Any:
     """
     Search for public transport routes between two locations.
 
     Queries the HSL (Helsinki Regional Transport) API to find route alternatives
-    between origin and destination coordinates.
+    between origin and destination coordinates. Requires authentication.
 
     Args:
         request: Route search parameters including origin, destination, and preferences
+        db: Database session
+        current_user: Authenticated user (required)
 
     Returns:
         RouteSearchResponse with list of available route itineraries
@@ -43,15 +54,32 @@ async def search_routes(request: RouteSearchRequest) -> Any:
         HTTPException: If the route search fails or returns invalid data
     """
     logger.info(
-        "Route search request: origin=%s, destination=%s, num_itineraries=%s",
+        "Route search request: origin=%s, destination=%s, num_itineraries=%s, user_id=%s",
         request.origin,
         request.destination,
         request.num_itineraries,
+        current_user.id,
     )
 
     # Use current time if earliest_departure not provided
     earliest_departure = request.earliest_departure or datetime.now(timezone.utc)
 
+    # Collect user preferences from multiple sources
+    user_preferences: List[str] = []
+
+    # 1. Add preferences from request (explicitly provided)
+    if request.preferences:
+        user_preferences.extend(request.preferences)
+
+    # 2. Add stored preferences from authenticated user
+    try:
+        stored_prefs = preference_service.get_user_preferences(db, int(current_user.id))
+        user_preferences.extend([str(pref.prompt) for pref in stored_prefs])
+    except Exception as e:  # pylint: disable=broad-except
+        logger.warning("Failed to fetch user preferences: %s", str(e))
+
+    logger.info("Using %d user preferences for route insights", len(user_preferences))
+
     try:
         # Call routing service to fetch itineraries from HSL API
         itineraries = await routing_service.get_itinaries(
@@ -64,7 +92,9 @@ async def search_routes(request: RouteSearchRequest) -> Any:
         # Enhance each itinerary with AI insights (with graceful degradation)
         for itinerary in itineraries:
             try:
-                await ai_agents_service.get_itinerary_insight(itinerary)
+                await ai_agents_service.get_itinerary_insight(
+                    itinerary, user_preferences if user_preferences else None
+                )
             except Exception as e:  # pylint: disable=broad-except
                 # Gracefully degrade - log warning but continue without AI insights
                 logger.warning("Failed to get AI insights for itinerary: %s", str(e))

app/schemas/routes.py

@@ -30,6 +30,12 @@ class RouteSearchRequest(BaseModel):
         le=10,
         description="Number of route alternatives to return (1-10, default: 3)",
     )
+    preferences: Optional[List[str]] = Field(
+        default=None,
+        description=(
+            "User preferences for route optimization " "(e.g., 'prefer walking', 'avoid buses')"
+        ),
+    )
 
 
 class RouteSearchResponse(BaseModel):

app/services/ai_agents_service.py

@@ -65,7 +65,9 @@ async def health_check(self) -> ServiceHealth:
                 message=f"AI-agents API check failed: {str(e)}",
             )
 
-    async def get_itinerary_insight(self, itinerary: Itinerary) -> None:
+    async def get_itinerary_insight(
+        self, itinerary: Itinerary, user_preferences: Optional[list] = None
+    ) -> None:
         """
         Get AI-generated insights for a complete itinerary and enrich it with AI data.
 
@@ -79,6 +81,7 @@ async def get_itinerary_insight(self, itinerary: Itinerary) -> None:
 
         Args:
             itinerary: The itinerary object containing the complete journey information
+            user_preferences: Optional list of user preference strings to consider
 
         Returns:
             None - modifies the itinerary object in place
@@ -116,6 +119,10 @@ async def get_itinerary_insight(self, itinerary: Itinerary) -> None:
                 ],
             }
 
+            # Add user preferences if provided
+            if user_preferences:
+                payload["user_preferences"] = user_preferences
+
             response = await client.post("/api/v1/insight/itinerary", json=payload)
 
             if response.status_code == 200:

app/services/auth_service.py

@@ -6,6 +6,7 @@
 from typing import Optional
 
 from fastapi import Depends, HTTPException, status
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
 from jose import jwt
 from passlib.context import CryptContext
 from pydantic import ValidationError
@@ -116,6 +117,43 @@ def get_current_user(
             raise HTTPException(status_code=404, detail="User not found")
         return user
 
+    @staticmethod
+    def get_current_user_optional(
+        db: Session = Depends(get_db),
+        credentials: Optional[HTTPAuthorizationCredentials] = Depends(HTTPBearer(auto_error=False)),
+    ) -> Optional[User]:
+        """
+        Decode JWT token and return the current user if authenticated.
+        Returns None if no token is provided (allowing anonymous access).
+
+        Args:
+            db: Database session
+            credentials: Optional HTTP Bearer credentials from request
+
+        Returns:
+            User object for the authenticated user, or None if not authenticated
+
+        Raises:
+            HTTPException: If token is provided but invalid
+        """
+        if credentials is None:
+            return None
+
+        token = credentials.credentials
+        try:
+            payload = jwt.decode(token, settings.SECRET_KEY, algorithms=[settings.ALGORITHM])
+            token_data = TokenPayload(**payload)
+        except (jwt.JWTError, ValidationError):
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="Could not validate credentials",
+            )
+
+        user = db.query(User).filter(User.id == int(token_data.sub)).first()  # type: ignore
+        if not user:
+            raise HTTPException(status_code=404, detail="User not found")
+        return user
+
 
 # Create a singleton instance
 auth_service = AuthService()