Update app/main.py

app/main.py

@@ -0,0 +1,166 @@
+# app/main.py
+from fastapi import FastAPI, Depends, HTTPException, status
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from sqlalchemy.orm import Session
+from app.db.database import Base, engine, SessionLocal
+from app.db import crud
+from app.models.request_models import GenerateRequest, ChatRequest, AuthRequest
+from app.services.orchestrator.build_question_set import build_question_set
+from app.services.scheduler import start_scheduler
+from app.services.chatbot_service import ask_chatbot
+from app.utils import auth as auth_utils
+from app.db import models as dbmodels
+import json, datetime, os
+
+# create DB tables
+Base.metadata.create_all(bind=engine)
+
+app = FastAPI(title="GATE Chemical Engineering Multi-Model")
+
+# serve frontend static
+app.mount("/static", StaticFiles(directory="frontend"), name="static")
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+bearer = HTTPBearer()
+
+def get_current_user(creds: HTTPAuthorizationCredentials = Depends(bearer), db: Session = Depends(get_db)):
+    token = creds.credentials
+    payload = auth_utils.decode_access_token(token)
+    if not payload:
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid token")
+    username = payload.get("username")
+    uid = payload.get("user_id")
+    user = crud.get_user_by_username(db, username)
+    if not user or user.id != uid:
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="User not found")
+    return user
+
+@app.get("/")
+def ui():
+    return FileResponse("frontend/index.html")
+
+# Auth
+@app.post("/register")
+def register(payload: dict, db: Session = Depends(get_db)):
+    username = payload.get("username")
+    email = payload.get("email")
+    password = payload.get("password")
+    if not username or not email or not password:
+        raise HTTPException(status_code=400, detail="username/email/password required")
+    if crud.get_user_by_username(db, username):
+        raise HTTPException(status_code=400, detail="username taken")
+    if crud.get_user_by_email(db, email):
+        raise HTTPException(status_code=400, detail="email taken")
+    user = crud.create_user(db, username, email, password)
+    token = auth_utils.create_access_token({"user_id": user.id, "username": user.username})
+    return {"access_token": token, "token_type": "bearer", "user": {"id": user.id, "username": user.username}}
+
+@app.post("/login")
+def login(payload: dict, db: Session = Depends(get_db)):
+    username = payload.get("username")
+    password = payload.get("password")
+    if not username or not password:
+        raise HTTPException(status_code=400, detail="username/password required")
+    user = crud.get_user_by_username(db, username)
+    if not user or not crud.verify_password(password, user.hashed_password):
+        raise HTTPException(status_code=401, detail="invalid credentials")
+    token = auth_utils.create_access_token({"user_id": user.id, "username": user.username})
+    return {"access_token": token, "token_type": "bearer", "user": {"id": user.id, "username": user.username}}
+
+# Generate questions (multi-model orchestrator)
+@app.post("/generate")
+async def generate(req: GenerateRequest):
+    topic = getattr(req, "topic", "General")
+    num = getattr(req, "num_questions", 10)
+    qset = await build_question_set(topic=topic, num=num)
+    return qset
+
+@app.get("/daily")
+def get_daily():
+    path = "app/data/daily_questions.json"
+    if os.path.exists(path):
+        with open(path, "r") as f:
+            return json.load(f)
+    return {"error": "Daily not ready"}
+
+# Save quiz (auth required)
+@app.post("/save-quiz")
+def save_quiz(payload: dict, user: dbmodels.User = Depends(get_current_user), db: Session = Depends(get_db)):
+    attempt_id = crud.save_quiz_attempt(db, user.id, payload)
+    return {"status": "saved", "attempt_id": attempt_id}
+
+@app.get("/attempts")
+def list_attempts(subject: str = None, start: str = None, end: str = None, db: Session = Depends(get_db), user: dbmodels.User = Depends(get_current_user)):
+    s, e = None, None
+    if start:
+        s = datetime.datetime.fromisoformat(start)
+    if end:
+        e = datetime.datetime.fromisoformat(end)
+    rows = crud.get_user_attempts(db, user.id, subject=subject, start=s, end=e)
+    out = []
+    for r in rows:
+        out.append({
+            "id": r.id,
+            "subject": r.subject,
+            "topic": r.topic,
+            "total_questions": r.total_questions,
+            "correct_answers": r.correct_answers,
+            "percentage": r.percentage,
+            "timestamp": r.timestamp.isoformat()
+        })
+    return out
+
+@app.get("/attempts/{attempt_id}")
+def attempt_details(attempt_id: int, db: Session = Depends(get_db), user: dbmodels.User = Depends(get_current_user)):
+    att = db.query(dbmodels.QuizAttempt).filter(dbmodels.QuizAttempt.id == attempt_id, dbmodels.QuizAttempt.user_id == user.id).first()
+    if not att:
+        raise HTTPException(status_code=404, detail="Attempt not found")
+    answers = crud.get_attempt_details(db, attempt_id)
+    out = []
+    for a in answers:
+        out.append({
+            "question_number": a.question_number,
+            "question_text": a.question_text,
+            "user_answer": a.user_answer,
+            "correct_answer": a.correct_answer,
+            "explanation": a.explanation,
+            "detailed_solution": a.detailed_solution,
+            "is_correct": bool(a.is_correct)
+        })
+    return {"attempt": {
+        "id": att.id,
+        "subject": att.subject,
+        "topic": att.topic,
+        "total_questions": att.total_questions,
+        "correct_answers": att.correct_answers,
+        "percentage": att.percentage,
+        "timestamp": att.timestamp.isoformat()
+    }, "answers": out}
+
+# Analytics
+@app.get("/analytics/score-trend")
+def score_trend(subject: str = None, limit: int = 100, db: Session = Depends(get_db), user: dbmodels.User = Depends(get_current_user)):
+    rows = crud.get_score_trend(db, user.id, subject=subject, limit=limit)
+    return [{"timestamp": r.timestamp.isoformat(), "percentage": r.percentage, "topic": r.topic} for r in rows]
+
+# Chatbot
+@app.post("/chat")
+async def chat(req: ChatRequest):
+    ans = await ask_chatbot(req.question)
+    return {"answer": ans}
+
+# Start scheduler on startup (best-effort)
+@app.on_event("startup")
+def startup_event():
+    try:
+        start_scheduler()
+    except Exception:
+        pass