add new routes

multi_llm_chatbot_backend/app/api/routes/auth.py

@@ -0,0 +1,130 @@
+from fastapi import APIRouter, HTTPException, Depends, status
+from datetime import datetime, timedelta
+from bson import ObjectId
+from app.models.user import UserCreate, UserLogin, User, Token, UserResponse
+from app.core.auth import (
+    get_password_hash, 
+    authenticate_user, 
+    create_access_token, 
+    get_user_by_email,
+    get_current_active_user,
+    create_user_response,
+    ACCESS_TOKEN_EXPIRE_MINUTES
+)
+from app.core.database import get_database
+import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+@router.post("/signup", response_model=Token)
+async def signup(user_data: UserCreate):
+    """Create a new user account"""
+    try:
+        db = get_database()
+        
+        # Check if user already exists
+        existing_user = await get_user_by_email(user_data.email)
+        if existing_user:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Email already registered"
+            )
+        
+        # Create new user
+        hashed_password = get_password_hash(user_data.password)
+        user = User(
+            firstName=user_data.firstName,
+            lastName=user_data.lastName,
+            email=user_data.email,
+            hashed_password=hashed_password,
+            academicStage=user_data.academicStage,
+            researchArea=user_data.researchArea,
+            created_at=datetime.utcnow(),
+            is_active=True
+        )
+        
+        # Insert user into database
+        result = await db.users.insert_one(user.dict(by_alias=True))
+        user.id = result.inserted_id
+        
+        # Create access token
+        access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+        access_token = create_access_token(
+            data={"sub": str(user.id)}, 
+            expires_delta=access_token_expires
+        )
+        
+        return Token(
+            access_token=access_token,
+            token_type="bearer",
+            user=create_user_response(user)
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error during signup: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Could not create user account"
+        )
+
+@router.post("/login", response_model=Token)
+async def login(user_credentials: UserLogin):
+    """Login with email and password"""
+    try:
+        # Authenticate user
+        user = await authenticate_user(user_credentials.email, user_credentials.password)
+        if not user:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Incorrect email or password",
+                headers={"WWW-Authenticate": "Bearer"},
+            )
+        
+        # Update last login time
+        db = get_database()
+        await db.users.update_one(
+            {"_id": user.id},
+            {"$set": {"last_login": datetime.utcnow()}}
+        )
+        user.last_login = datetime.utcnow()
+        
+        # Create access token
+        access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+        access_token = create_access_token(
+            data={"sub": str(user.id)}, 
+            expires_delta=access_token_expires
+        )
+        
+        return Token(
+            access_token=access_token,
+            token_type="bearer",
+            user=create_user_response(user)
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error during login: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Login failed"
+        )
+
+@router.get("/me", response_model=UserResponse)
+async def get_current_user_profile(current_user: User = Depends(get_current_active_user)):
+    """Get current user profile"""
+    return create_user_response(current_user)
+
+@router.post("/logout")
+async def logout():
+    """Logout (client should discard token)"""
+    return {"message": "Successfully logged out"}
+
+@router.post("/verify-token", response_model=UserResponse)
+async def verify_token(current_user: User = Depends(get_current_active_user)):
+    """Verify token and return user info"""
+    return create_user_response(current_user)

multi_llm_chatbot_backend/app/api/routes/chat_sessions.py

@@ -0,0 +1,258 @@
+from fastapi import APIRouter, HTTPException, Depends, status
+from typing import List, Optional
+from datetime import datetime
+from bson import ObjectId
+from app.models.user import User, ChatSession, ChatSessionResponse
+from app.core.auth import get_current_active_user
+from app.core.database import get_database
+from pydantic import BaseModel
+import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+class CreateChatSessionRequest(BaseModel):
+    title: str
+
+class UpdateChatSessionRequest(BaseModel):
+    title: Optional[str] = None
+    messages: Optional[List[dict]] = None
+
+class SaveMessageRequest(BaseModel):
+    session_id: str
+    message: dict
+
+@router.post("/chat-sessions", response_model=dict)
+async def create_chat_session(
+    request: CreateChatSessionRequest,
+    current_user: User = Depends(get_current_active_user)
+):
+    """Create a new chat session for the user"""
+    try:
+        db = get_database()
+        
+        session = ChatSession(
+            user_id=current_user.id,
+            title=request.title,
+            messages=[],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+        
+        result = await db.chat_sessions.insert_one(session.dict(by_alias=True))
+        session.id = result.inserted_id
+        
+        return {
+            "id": str(session.id),
+            "title": session.title,
+            "created_at": session.created_at,
+            "updated_at": session.updated_at,
+            "message_count": 0
+        }
+        
+    except Exception as e:
+        logger.error(f"Error creating chat session: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Could not create chat session"
+        )
+
+@router.get("/chat-sessions", response_model=List[ChatSessionResponse])
+async def get_user_chat_sessions(
+    current_user: User = Depends(get_current_active_user),
+    limit: int = 50,
+    skip: int = 0
+):
+    """Get all chat sessions for the current user"""
+    try:
+        db = get_database()
+        
+        cursor = db.chat_sessions.find(
+            {"user_id": current_user.id, "is_active": True}
+        ).sort("updated_at", -1).skip(skip).limit(limit)
+        
+        sessions = []
+        async for session_data in cursor:
+            sessions.append(ChatSessionResponse(
+                id=str(session_data["_id"]),
+                title=session_data["title"],
+                created_at=session_data["created_at"],
+                updated_at=session_data["updated_at"],
+                message_count=len(session_data.get("messages", []))
+            ))
+        
+        return sessions
+        
+    except Exception as e:
+        logger.error(f"Error fetching chat sessions: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Could not fetch chat sessions"
+        )
+
+@router.get("/chat-sessions/{session_id}")
+async def get_chat_session(
+    session_id: str,
+    current_user: User = Depends(get_current_active_user)
+):
+    """Get a specific chat session with all messages"""
+    try:
+        db = get_database()
+        
+        session_data = await db.chat_sessions.find_one({
+            "_id": ObjectId(session_id),
+            "user_id": current_user.id,
+            "is_active": True
+        })
+        
+        if not session_data:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Chat session not found"
+            )
+        
+        return {
+            "id": str(session_data["_id"]),
+            "title": session_data["title"],
+            "messages": session_data.get("messages", []),
+            "created_at": session_data["created_at"],
+            "updated_at": session_data["updated_at"]
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error fetching chat session: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Could not fetch chat session"
+        )
+
+@router.put("/chat-sessions/{session_id}")
+async def update_chat_session(
+    session_id: str,
+    request: UpdateChatSessionRequest,
+    current_user: User = Depends(get_current_active_user)
+):
+    """Update a chat session (title or messages)"""
+    try:
+        db = get_database()
+        
+        # Verify session belongs to user
+        session_data = await db.chat_sessions.find_one({
+            "_id": ObjectId(session_id),
+            "user_id": current_user.id,
+            "is_active": True
+        })
+        
+        if not session_data:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Chat session not found"
+            )
+        
+        update_data = {"updated_at": datetime.utcnow()}
+        
+        if request.title is not None:
+            update_data["title"] = request.title
+        
+        if request.messages is not None:
+            update_data["messages"] = request.messages
+        
+        await db.chat_sessions.update_one(
+            {"_id": ObjectId(session_id)},
+            {"$set": update_data}
+        )
+        
+        return {"message": "Chat session updated successfully"}
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error updating chat session: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Could not update chat session"
+        )
+
+@router.post("/chat-sessions/{session_id}/messages")
+async def save_message_to_session(
+    session_id: str,
+    request: SaveMessageRequest,
+    current_user: User = Depends(get_current_active_user)
+):
+    """Add a message to a chat session"""
+    try:
+        db = get_database()
+        
+        # Verify session belongs to user
+        session_data = await db.chat_sessions.find_one({
+            "_id": ObjectId(session_id),
+            "user_id": current_user.id,
+            "is_active": True
+        })
+        
+        if not session_data:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Chat session not found"
+            )
+        
+        # Add timestamp to message if not present
+        message = request.message.copy()
+        if "timestamp" not in message:
+            message["timestamp"] = datetime.utcnow().isoformat()
+        
+        await db.chat_sessions.update_one(
+            {"_id": ObjectId(session_id)},
+            {
+                "$push": {"messages": message},
+                "$set": {"updated_at": datetime.utcnow()}
+            }
+        )
+        
+        return {"message": "Message saved successfully"}
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error saving message: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Could not save message"
+        )
+
+@router.delete("/chat-sessions/{session_id}")
+async def delete_chat_session(
+    session_id: str,
+    current_user: User = Depends(get_current_active_user)
+):
+    """Delete a chat session (soft delete)"""
+    try:
+        db = get_database()
+        
+        result = await db.chat_sessions.update_one(
+            {
+                "_id": ObjectId(session_id),
+                "user_id": current_user.id
+            },
+            {"$set": {"is_active": False, "updated_at": datetime.utcnow()}}
+        )
+        
+        if result.matched_count == 0:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Chat session not found"
+            )
+        
+        return {"message": "Chat session deleted successfully"}
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error deleting chat session: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Could not delete chat session"
+        )