Upload 13 files

main.py

@@ -0,0 +1,33 @@
+import os
+from fastapi import FastAPI
+from pydantic import BaseModel
+from src.core.config import settings
+from src.services.user_router import router as user_router
+from src.services.cv_router import router as cv_router
+from src.services.interview_history_router import router as interview_history_router
+from src.services.feedback_router import router as feedback_router
+
+app = FastAPI(
+    title="Data Access API",
+    description="API for accessing data from MongoDB and PostgreSQL.",
+    version="1.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc"
+)
+
+app.include_router(user_router, prefix="/api/v1", tags=["Users"])
+app.include_router(cv_router, prefix="/api/v1", tags=["CVs"])
+app.include_router(interview_history_router, prefix="/api/v1", tags=["Interview Histories"])
+app.include_router(feedback_router, prefix="/api/v1", tags=["Feedbacks"])
+
+class HealthCheck(BaseModel):
+    status: str = "ok"
+
+@app.get("/", response_model=HealthCheck, tags=["Status"])
+async def health_check():
+    return HealthCheck()
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.getenv("PORT", 8003)) # Use PORT environment variable, default to 8003
+    uvicorn.run(app, host="0.0.0.0", port=port)

requirements.txt

@@ -0,0 +1,8 @@
+fastapi
+uvicorn[standard]
+pydantic
+pydantic-settings
+motor
+sqlalchemy
+psycopg2-binary
+python-dotenv

src/core/config.py

@@ -0,0 +1,20 @@
+from pydantic_settings import BaseSettings
+from dotenv import load_dotenv
+
+class Settings(BaseSettings):
+    # MongoDB 
+    MONGO_URI: str
+    MONGO_DB_NAME: str
+    MONGO_CV_COLLECTION: str
+    MONGO_INTERVIEW_COLLECTION: str
+    MONGO_FEEDBACK_COLLECTION: str
+
+    # PostgreSQL 
+    DATABASE_URL: str
+    ASYNC_DATABASE_URL: str
+
+    class Config:
+        env_file = ".env"
+
+load_dotenv()
+settings = Settings()

src/core/database.py

@@ -0,0 +1,31 @@
+from motor.motor_asyncio import AsyncIOMotorClient
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
+from sqlalchemy.orm import sessionmaker
+from src.core.config import settings
+from sqlalchemy.pool import NullPool
+
+# MongoDB client
+mongo_client = AsyncIOMotorClient(settings.MONGO_URI)
+mongo_db = mongo_client[settings.MONGO_DB_NAME]
+
+
+connect_args = {"statement_cache_size": 0}
+
+engine = create_async_engine(
+    str(settings.ASYNC_DATABASE_URL),
+    poolclass=NullPool,
+    connect_args=connect_args,  
+    execution_options={"compiled_cache": None},
+)
+
+SessionLocal = sessionmaker(
+    autocommit=False,
+    autoflush=False,
+    bind=engine,
+    class_=AsyncSession,
+    expire_on_commit=False,
+)
+
+async def get_db():
+    async with SessionLocal() as session:
+        yield session

src/models/mongo/base.py

@@ -0,0 +1,27 @@
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from pydantic import BaseModel
+from bson import ObjectId
+
+class BaseMongoModel(BaseModel):
+    id: str | None = None
+
+    @classmethod
+    async def get(cls, db: AsyncIOMotorDatabase, collection: str, query: dict):
+        return await db[collection].find_one(query)
+
+    @classmethod
+    async def get_all(cls, db: AsyncIOMotorDatabase, collection: str, query: dict = {}):
+        return await db[collection].find(query).to_list(1000)
+
+    @classmethod
+    async def create(cls, db: AsyncIOMotorDatabase, collection: str, data: dict):
+        result = await db[collection].insert_one(data)
+        return str(result.inserted_id)
+
+    @classmethod
+    async def update(cls, db: AsyncIOMotorDatabase, collection: str, query: dict, data: dict):
+        await db[collection].update_one(query, {"$set": data})
+
+    @classmethod
+    async def delete(cls, db: AsyncIOMotorDatabase, collection: str, query: dict):
+        await db[collection].delete_one(query)

src/models/mongo/cv_model.py

@@ -0,0 +1,11 @@
+from pydantic import Field
+from app.models.mongo.base import BaseMongoModel
+from app.config import settings
+
+class CVModel(BaseMongoModel):
+    collection_name: str = settings.MONGO_CV_COLLECTION
+
+    user_id: str | None = None
+    parsed_data: dict = Field(default_factory=dict)
+    raw_text: str | None = None
+    upload_date: str | None = None # ISO format string

src/models/mongo/feedback_model.py

@@ -0,0 +1,11 @@
+from pydantic import Field
+from app.models.mongo.base import BaseMongoModel
+from app.config import settings
+
+class FeedbackModel(BaseMongoModel):
+    collection_name: str = settings.MONGO_FEEDBACK_COLLECTION
+
+    user_id: str | None = None
+    interview_id: str | None = None
+    feedback_content: dict = Field(default_factory=dict)
+    feedback_date: str | None = None # ISO format string

src/models/mongo/interview_history_model.py

@@ -0,0 +1,12 @@
+from pydantic import Field
+from app.models.mongo.base import BaseMongoModel
+from app.config import settings
+
+class InterviewHistoryModel(BaseMongoModel):
+    collection_name: str = settings.MONGO_INTERVIEW_COLLECTION
+
+    user_id: str | None = None
+    cv_id: str | None = None
+    conversation: list[dict] = Field(default_factory=list) # List of {role: str, content: str}
+    start_time: str | None = None # ISO format string
+    end_time: str | None = None # ISO format string

src/models/postgres/user_model.py

@@ -0,0 +1,21 @@
+from sqlalchemy import Column, Integer, String, DateTime, Boolean, JSON
+from sqlalchemy.ext.declarative import declarative_base
+from datetime import datetime
+
+Base = declarative_base()
+
+class User(Base):
+    __tablename__ = "user"  
+
+    id = Column(Integer, primary_key=True, index=True, autoincrement=True)
+    google_id = Column(String, unique=True, nullable=True, index=True)
+    email = Column(String, unique=True, index=True, nullable=False)
+    name = Column(String, nullable=True)
+    picture_url = Column(String, nullable=True)
+    candidate_mongo_id = Column(String, nullable=True)
+    created_at = Column(DateTime, nullable=True)
+    auth_providers = Column(JSON, default=list)
+    hashed_password = Column(String, nullable=True)
+    is_active = Column(Boolean, default=True)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+    last_login = Column(DateTime, nullable=True)

src/services/cv_router.py

@@ -0,0 +1,40 @@
+from fastapi import APIRouter, Depends, HTTPException
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from src.core.database import mongo_db
+from src.models.mongo.cv_model import CVModel
+from pydantic import BaseModel
+from typing import Optional, Dict, Any
+from bson import ObjectId
+
+router = APIRouter()
+
+class CVCreate(BaseModel):
+    user_id: str
+    parsed_data: Dict[str, Any]
+    raw_text: Optional[str] = None
+    upload_date: str
+
+class CVResponse(BaseModel):
+    id: str = Field(alias="_id")
+    user_id: str
+    parsed_data: Dict[str, Any]
+    raw_text: Optional[str] = None
+    upload_date: str
+
+    class Config:
+        populate_by_name = True
+        json_encoders = {ObjectId: str}
+
+@router.post("/cvs", response_model=CVResponse)
+async def create_cv(cv: CVCreate, db: AsyncIOMotorDatabase = Depends(lambda: mongo_db)):
+    cv_entry = CVModel(**cv.model_dump(by_alias=True))
+    cv_id = await CVModel.create(db, CVModel.collection_name, cv_entry.model_dump(exclude_unset=True))
+    cv_entry.id = cv_id
+    return cv_entry
+
+@router.get("/cvs/{cv_id}", response_model=CVResponse)
+async def get_cv_by_id(cv_id: str, db: AsyncIOMotorDatabase = Depends(lambda: mongo_db)):
+    cv = await CVModel.get(db, CVModel.collection_name, {"_id": cv_id})
+    if cv is None:
+        raise HTTPException(status_code=404, detail="CV not found")
+    return cv

src/services/feedback_router.py

@@ -0,0 +1,40 @@
+from fastapi import APIRouter, Depends, HTTPException
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from src.core.database import mongo_db
+from src.models.mongo.feedback_model import FeedbackModel
+from pydantic import BaseModel, Field
+from typing import Optional, Dict, Any
+from bson import ObjectId
+
+router = APIRouter()
+
+class FeedbackCreate(BaseModel):
+    user_id: str
+    interview_id: str
+    feedback_content: Dict[str, Any]
+    feedback_date: str
+
+class FeedbackResponse(BaseModel):
+    id: str = Field(alias="_id")
+    user_id: str
+    interview_id: str
+    feedback_content: Dict[str, Any]
+    feedback_date: str
+
+    class Config:
+        populate_by_name = True
+        json_encoders = {ObjectId: str}
+
+@router.post("/feedbacks", response_model=FeedbackResponse)
+async def create_feedback(feedback: FeedbackCreate, db: AsyncIOMotorDatabase = Depends(lambda: mongo_db)):
+    feedback_entry = FeedbackModel(**feedback.model_dump(by_alias=True))
+    feedback_id = await FeedbackModel.create(db, FeedbackModel.collection_name, feedback_entry.model_dump(exclude_unset=True))
+    feedback_entry.id = feedback_id
+    return feedback_entry
+
+@router.get("/feedbacks/{feedback_id}", response_model=FeedbackResponse)
+async def get_feedback_by_id(feedback_id: str, db: AsyncIOMotorDatabase = Depends(lambda: mongo_db)):
+    feedback = await FeedbackModel.get(db, FeedbackModel.collection_name, {"_id": feedback_id})
+    if feedback is None:
+        raise HTTPException(status_code=404, detail="Feedback not found")
+    return feedback

src/services/interview_history_router.py

@@ -0,0 +1,53 @@
+from fastapi import APIRouter, Depends, HTTPException
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from src.core.database import mongo_db
+from src.models.mongo.interview_history_model import InterviewHistoryModel
+from pydantic import BaseModel, Field
+from typing import Optional, List, Dict, Any
+from bson import ObjectId
+
+router = APIRouter()
+
+class InterviewHistoryCreate(BaseModel):
+    user_id: str
+    cv_id: str
+    job_offer_id: str
+    conversation: List[Dict[str, Any]]
+    start_time: str
+    end_time: Optional[str] = None
+
+class InterviewHistoryUpdate(BaseModel):
+    conversation: Optional[List[Dict[str, Any]]] = None
+    end_time: Optional[str] = None
+
+class InterviewHistoryResponse(BaseModel):
+    id: str = Field(alias="_id")
+    user_id: str
+    cv_id: str
+    job_offer_id: str
+    conversation: List[Dict[str, Any]]
+    start_time: str
+    end_time: Optional[str] = None
+
+    class Config:
+        populate_by_name = True
+        json_encoders = {ObjectId: str}
+
+@router.post("/interview-histories", response_model=InterviewHistoryResponse)
+async def create_interview_history(history: InterviewHistoryCreate, db: AsyncIOMotorDatabase = Depends(lambda: mongo_db)):
+    history_entry = InterviewHistoryModel(**history.model_dump(by_alias=True))
+    history_id = await InterviewHistoryModel.create(db, InterviewHistoryModel.collection_name, history_entry.model_dump(exclude_unset=True))
+    history_entry.id = history_id
+    return history_entry
+
+@router.get("/interview-histories/{history_id}", response_model=InterviewHistoryResponse)
+async def get_interview_history_by_id(history_id: str, db: AsyncIOMotorDatabase = Depends(lambda: mongo_db)):
+    history = await InterviewHistoryModel.get(db, InterviewHistoryModel.collection_name, {"_id": history_id})
+    if history is None:
+        raise HTTPException(status_code=404, detail="Interview history not found")
+    return history
+
+@router.put("/interview-histories/{history_id}", response_model=InterviewHistoryResponse)
+async def update_interview_history(history_id: str, history: InterviewHistoryUpdate, db: AsyncIOMotorDatabase = Depends(lambda: mongo_db)):
+    await InterviewHistoryModel.update(db, InterviewHistoryModel.collection_name, {"_id": history_id}, history.model_dump(exclude_unset=True))
+    return await get_interview_history_by_id(history_id, db)

src/services/user_router.py

@@ -0,0 +1,67 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, update
+from src.core.database import get_db
+from src.models.postgres.user_model import User
+from pydantic import BaseModel
+from typing import Optional
+
+router = APIRouter()
+
+class UserCreate(BaseModel):
+    email: str
+    hashed_password: str
+    name: Optional[str] = None
+    picture_url: Optional[str] = None
+    google_id: Optional[str] = None
+    candidate_mongo_id: Optional[str] = None
+
+class UserUpdate(BaseModel):
+    email: Optional[str] = None
+    hashed_password: Optional[str] = None
+    name: Optional[str] = None
+    picture_url: Optional[str] = None
+    google_id: Optional[str] = None
+    candidate_mongo_id: Optional[str] = None
+
+class UserResponse(BaseModel):
+    id: int
+    email: str
+    name: Optional[str] = None
+    picture_url: Optional[str] = None
+    google_id: Optional[str] = None
+    candidate_mongo_id: Optional[str] = None
+
+    class Config:
+        from_attributes = True
+
+@router.post("/users", response_model=UserResponse)
+async def create_user(user: UserCreate, db: AsyncSession = Depends(get_db)):
+    db_user = User(**user.model_dump())
+    db.add(db_user)
+    await db.commit()
+    await db.refresh(db_user)
+    return db_user
+
+@router.get("/users/{user_id}", response_model=UserResponse)
+async def get_user_by_id(user_id: int, db: AsyncSession = Depends(get_db)):
+    result = await db.execute(select(User).where(User.id == user_id))
+    user = result.scalar_one_or_none()
+    if user is None:
+        raise HTTPException(status_code=404, detail="User not found")
+    return user
+
+@router.get("/users/email/{email}", response_model=UserResponse)
+async def get_user_by_email(email: str, db: AsyncSession = Depends(get_db)):
+    result = await db.execute(select(User).where(User.email == email))
+    user = result.scalar_one_or_none()
+    if user is None:
+        raise HTTPException(status_code=404, detail="User not found")
+    return user
+
+@router.put("/users/{user_id}", response_model=UserResponse)
+async def update_user(user_id: int, user: UserUpdate, db: AsyncSession = Depends(get_db)):
+    query = update(User).where(User.id == user_id).values(**user.model_dump(exclude_unset=True))
+    await db.execute(query)
+    await db.commit()
+    return await get_user_by_id(user_id, db)