add database code

multi_llm_chatbot_backend/app/core/auth.py

@@ -0,0 +1,116 @@
+import os
+from datetime import datetime, timedelta
+from typing import Optional
+from fastapi import HTTPException, Depends, status
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from passlib.context import CryptContext
+from jose import JWTError, jwt
+from bson import ObjectId
+from app.core.database import get_database
+from app.models.user import User, UserResponse
+
+# Password hashing
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+# JWT settings
+SECRET_KEY = os.getenv("JWT_SECRET_KEY", "your-secret-key-change-this-in-production")
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 30 * 24 * 60  # 30 days
+
+# Security scheme
+security = HTTPBearer()
+
+def verify_password(plain_password: str, hashed_password: str) -> bool:
+    """Verify a password against its hash"""
+    return pwd_context.verify(plain_password, hashed_password)
+
+def get_password_hash(password: str) -> str:
+    """Hash a password"""
+    return pwd_context.hash(password)
+
+def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
+    """Create a JWT access token"""
+    to_encode = data.copy()
+    if expires_delta:
+        expire = datetime.utcnow() + expires_delta
+    else:
+        expire = datetime.utcnow() + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+    
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+    return encoded_jwt
+
+async def get_user_by_email(email: str) -> Optional[User]:
+    """Get user by email from database"""
+    db = get_database()
+    user_data = await db.users.find_one({"email": email})
+    if user_data:
+        return User(**user_data)
+    return None
+
+async def get_user_by_id(user_id: str) -> Optional[User]:
+    """Get user by ID from database"""
+    try:
+        db = get_database()
+        user_data = await db.users.find_one({"_id": ObjectId(user_id)})
+        if user_data:
+            return User(**user_data)
+        return None
+    except Exception:
+        return None
+
+async def authenticate_user(email: str, password: str) -> Optional[User]:
+    """Authenticate user with email and password"""
+    user = await get_user_by_email(email)
+    if not user:
+        return None
+    if not verify_password(password, user.hashed_password):
+        return None
+    return user
+
+async def get_current_user(credentials: HTTPAuthorizationCredentials = Depends(security)) -> User:
+    """Get current user from JWT token"""
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    
+    try:
+        payload = jwt.decode(credentials.credentials, SECRET_KEY, algorithms=[ALGORITHM])
+        user_id: str = payload.get("sub")
+        if user_id is None:
+            raise credentials_exception
+    except JWTError:
+        raise credentials_exception
+    
+    user = await get_user_by_id(user_id)
+    if user is None:
+        raise credentials_exception
+    
+    if not user.is_active:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Inactive user"
+        )
+    
+    return user
+
+async def get_current_active_user(current_user: User = Depends(get_current_user)) -> User:
+    """Get current active user"""
+    if not current_user.is_active:
+        raise HTTPException(status_code=400, detail="Inactive user")
+    return current_user
+
+def create_user_response(user: User) -> UserResponse:
+    """Create user response model"""
+    return UserResponse(
+        id=str(user.id),
+        firstName=user.firstName,
+        lastName=user.lastName,
+        email=user.email,
+        academicStage=user.academicStage,
+        researchArea=user.researchArea,
+        created_at=user.created_at,
+        last_login=user.last_login
+    )

multi_llm_chatbot_backend/app/core/database.py

@@ -0,0 +1,66 @@
+import os
+from motor.motor_asyncio import AsyncIOMotorClient
+from pymongo.errors import ConnectionFailure
+import logging
+
+logger = logging.getLogger(__name__)
+
+class Database:
+    client: AsyncIOMotorClient = None
+    database = None
+
+db = Database()
+
+async def connect_to_mongo():
+    """Create database connection"""
+    try:
+        # Get MongoDB connection string from environment
+        mongo_url = os.getenv("MONGODB_CONNECTION_STRING")
+        if not mongo_url:
+            raise ValueError("MONGODB_CONNECTION_STRING environment variable not set")
+        
+        # Get database name from environment or use default
+        db_name = os.getenv("MONGODB_DATABASE_NAME", "phd_advisor")
+        
+        db.client = AsyncIOMotorClient(mongo_url)
+        db.database = db.client[db_name]
+        
+        # Test connection
+        await db.client.admin.command('ping')
+        logger.info(f"Successfully connected to MongoDB database: {db_name}")
+        
+        # Create indexes for better performance
+        await create_indexes()
+        
+    except ConnectionFailure as e:
+        logger.error(f"Failed to connect to MongoDB: {e}")
+        raise
+    except Exception as e:
+        logger.error(f"Unexpected error connecting to MongoDB: {e}")
+        raise
+
+async def close_mongo_connection():
+    """Close database connection"""
+    if db.client:
+        db.client.close()
+        logger.info("Disconnected from MongoDB")
+
+async def create_indexes():
+    """Create database indexes for performance"""
+    try:
+        # Index for users collection
+        await db.database.users.create_index("email", unique=True)
+        await db.database.users.create_index("created_at")
+        
+        # Indexes for chat_sessions collection
+        await db.database.chat_sessions.create_index("user_id")
+        await db.database.chat_sessions.create_index("created_at")
+        await db.database.chat_sessions.create_index([("user_id", 1), ("created_at", -1)])
+        
+        logger.info("Database indexes created successfully")
+    except Exception as e:
+        logger.warning(f"Error creating indexes: {e}")
+
+def get_database():
+    """Get database instance"""
+    return db.database

multi_llm_chatbot_backend/app/models/user.py

@@ -0,0 +1,89 @@
+from pydantic import BaseModel, EmailStr, Field, ConfigDict
+from typing import Optional, List, Any
+from datetime import datetime
+from bson import ObjectId
+
+class PyObjectId(ObjectId):
+    @classmethod
+    def __get_validators__(cls):
+        yield cls.validate
+
+    @classmethod
+    def validate(cls, v, handler=None):
+        if isinstance(v, ObjectId):
+            return v
+        if isinstance(v, str):
+            if ObjectId.is_valid(v):
+                return ObjectId(v)
+        raise ValueError("Invalid ObjectId")
+
+    @classmethod
+    def __get_pydantic_json_schema__(cls, field_schema):
+        field_schema.update(type="string")
+
+class UserCreate(BaseModel):
+    firstName: str
+    lastName: str
+    email: EmailStr
+    password: str
+    academicStage: Optional[str] = None
+    researchArea: Optional[str] = None
+
+class UserLogin(BaseModel):
+    email: EmailStr
+    password: str
+
+class User(BaseModel):
+    model_config = ConfigDict(
+        populate_by_name=True,
+        arbitrary_types_allowed=True,
+        json_encoders={ObjectId: str}
+    )
+    
+    id: PyObjectId = Field(default_factory=PyObjectId, alias="_id")
+    firstName: str
+    lastName: str
+    email: EmailStr
+    hashed_password: str
+    academicStage: Optional[str] = None
+    researchArea: Optional[str] = None
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+    last_login: Optional[datetime] = None
+    is_active: bool = True
+
+class UserResponse(BaseModel):
+    id: str
+    firstName: str
+    lastName: str
+    email: str
+    academicStage: Optional[str] = None
+    researchArea: Optional[str] = None
+    created_at: datetime
+    last_login: Optional[datetime] = None
+
+class ChatSession(BaseModel):
+    model_config = ConfigDict(
+        populate_by_name=True,
+        arbitrary_types_allowed=True,
+        json_encoders={ObjectId: str}
+    )
+    
+    id: PyObjectId = Field(default_factory=PyObjectId, alias="_id")
+    user_id: PyObjectId
+    title: str
+    messages: List[dict] = []
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+    updated_at: datetime = Field(default_factory=datetime.utcnow)
+    is_active: bool = True
+
+class ChatSessionResponse(BaseModel):
+    id: str
+    title: str
+    created_at: datetime
+    updated_at: datetime
+    message_count: int
+
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+    user: UserResponse