Fix submit query flow

app/main.py

@@ -10,6 +10,7 @@ from app.core.database import Base
 from app.routes.auth import router as auth_router
 from app.routes.admin import router as admin_router
 from app.routes.departments import router as departments_router
+from app.routes.queries import router as queries_router
 
 
 app = FastAPI(title=settings.app_name)
@@ -25,6 +26,7 @@ app.add_middleware(
 app.include_router(auth_router)
 app.include_router(admin_router)
 app.include_router(departments_router)
+app.include_router(queries_router)
 
 
 @app.on_event("startup")

app/models/__init__.py

@@ -1,4 +1,5 @@
 from app.models.user import User
 from app.models.department import Department
+from app.models.query import Query
 
-__all__ = ["User", "Department"]
+__all__ = ["User", "Department", "Query"]

app/models/department.py

@@ -16,3 +16,4 @@ class Department(Base):
     query = Column(Text, nullable=True)
     is_active = Column(Boolean, default=True, nullable=False)
     users = relationship("User", back_populates="department")
+    queries = relationship("Query", back_populates="department")

app/models/query.py

@@ -0,0 +1,59 @@
+from datetime import UTC, datetime
+
+from sqlalchemy import DateTime, Float, ForeignKey, Integer, String, Text
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from app.core.database import Base
+
+
+class Query(Base):
+    __tablename__ = "queries"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+    student_id: Mapped[int] = mapped_column(
+        ForeignKey("users.id", ondelete="CASCADE"),
+        nullable=False,
+        index=True,
+    )
+    sender_email: Mapped[str] = mapped_column(String(255), nullable=False, index=True)
+    message: Mapped[str] = mapped_column(Text, nullable=False)
+    department_id: Mapped[int | None] = mapped_column(
+        ForeignKey("departments.id", ondelete="SET NULL"),
+        nullable=True,
+        index=True,
+    )
+    status: Mapped[str] = mapped_column(String(32), default="Open", nullable=False)
+    priority: Mapped[str] = mapped_column(String(32), default="Normal", nullable=False)
+    confidence: Mapped[float] = mapped_column(Float, default=0.0, nullable=False)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime, default=lambda: datetime.now(UTC), nullable=False
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime, default=lambda: datetime.now(UTC), onupdate=lambda: datetime.now(UTC), nullable=False
+    )
+    responded_at: Mapped[datetime | None] = mapped_column(DateTime, nullable=True)
+
+    student = relationship("User", back_populates="queries")
+    department = relationship("Department", back_populates="queries")
+
+    @property
+    def subject(self) -> str:
+        first_line = self.message.strip().splitlines()[0] if self.message.strip() else ""
+        if not first_line:
+            return "New query"
+        if len(first_line) <= 72:
+            return first_line
+        return f"{first_line[:69].rstrip()}..."
+
+    @property
+    def snippet(self) -> str:
+        text = " ".join(self.message.split())
+        if len(text) <= 140:
+            return text
+        return f"{text[:137].rstrip()}..."
+
+    @property
+    def department_name(self) -> str | None:
+        if self.department is None:
+            return None
+        return self.department.name

app/models/user.py

@@ -22,6 +22,7 @@ class User(Base):
         DateTime, default=lambda: datetime.now(UTC), nullable=False
     )
     department = relationship("Department", back_populates="users")
+    queries = relationship("Query", back_populates="student")
 
     @property
     def department_name(self) -> str | None:

app/routes/departments.py

@@ -4,47 +4,10 @@ from sqlalchemy.orm import Session
 from app.core.database import get_db
 from app.models.department import Department
 from app.schemas.department import DepartmentCreate, DepartmentResponse
+from app.services.routing_service import score_department
 
 router = APIRouter(prefix="/departments", tags=["departments"])
 
-
-def _normalize_keywords(value: str | None) -> set[str]:
-    if not value:
-        return set()
-
-    return {
-        keyword.strip().lower()
-        for keyword in value.split(",")
-        if keyword.strip()
-    }
-
-
-def _score_department(department: Department, query: str) -> int:
-    query_value = query.lower().strip()
-    if not query_value:
-        return 0
-
-    score = 0
-    searchable_fields = [
-        department.name,
-        department.code,
-        department.description or "",
-        department.keywords or "",
-    ]
-
-    for field in searchable_fields:
-        field_value = field.lower()
-        if query_value in field_value:
-            score += 10
-
-    query_words = {word for word in query_value.split() if word}
-    department_keywords = _normalize_keywords(department.keywords)
-
-    score += len(query_words & department_keywords) * 5
-
-    return score
-
-
 @router.get("/", response_model=list[DepartmentResponse])
 def get_departments(db: Session = Depends(get_db)):
     return (
@@ -79,7 +42,7 @@ def search_departments(
     )
 
     ranked_departments = [
-        (department, _score_department(department, q))
+        (department, score_department(department, q))
         for department in departments
     ]
 
@@ -106,7 +69,7 @@ def match_department(
     best_score = 0
 
     for department in departments:
-        score = _score_department(department, q)
+        score = score_department(department, q)
         if score > best_score:
             best_department = department
             best_score = score

app/schemas/query.py

@@ -0,0 +1,26 @@
+from datetime import datetime
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class QueryCreate(BaseModel):
+    message: str = Field(min_length=1, max_length=5000)
+
+
+class QueryRead(BaseModel):
+    id: int
+    student_id: int
+    sender_email: str
+    message: str
+    subject: str
+    snippet: str
+    department_id: int | None
+    department_name: str | None
+    status: str
+    priority: str
+    confidence: float
+    created_at: datetime
+    updated_at: datetime
+    responded_at: datetime | None
+
+    model_config = ConfigDict(from_attributes=True)

app/services/query_service.py

@@ -0,0 +1,43 @@
+from sqlalchemy.orm import Session, selectinload
+
+from app.models.query import Query
+from app.models.user import User
+from app.schemas.query import QueryCreate
+from app.services.routing_service import match_department
+
+
+def _confidence_from_score(score: int) -> float:
+    if score <= 0:
+        return 0.5
+    return round(min(0.99, 0.55 + score / 20), 2)
+
+
+def create_query(db: Session, *, current_user: User, payload: QueryCreate) -> Query:
+    message = payload.message.strip()
+    if not message:
+        raise ValueError("Query message cannot be empty")
+
+    department, score = match_department(db, message)
+    query = Query(
+        student_id=current_user.id,
+        sender_email=current_user.email,
+        message=message,
+        department_id=department.id if department is not None else None,
+        status="Routed" if department is not None else "Open",
+        priority="Normal",
+        confidence=_confidence_from_score(score),
+    )
+    db.add(query)
+    db.commit()
+    db.refresh(query)
+    return query
+
+
+def list_queries_for_user(db: Session, *, current_user: User) -> list[Query]:
+    return (
+        db.query(Query)
+        .options(selectinload(Query.department))
+        .filter(Query.student_id == current_user.id)
+        .order_by(Query.created_at.desc(), Query.id.desc())
+        .all()
+    )

app/services/routing_service.py

@@ -0,0 +1,70 @@
+import re
+
+from sqlalchemy.orm import Session
+
+from app.models.department import Department
+
+
+def _normalize_words(value: str | None) -> set[str]:
+    if not value:
+        return set()
+
+    return {word for word in re.split(r"[^a-zA-Z0-9]+", value.lower()) if word}
+
+
+def score_department(department: Department, message: str) -> int:
+    query_value = message.lower().strip()
+    if not query_value:
+        return 0
+
+    score = 0
+    searchable_fields = [
+        department.name,
+        department.code,
+        department.description or "",
+        department.keywords or "",
+        department.query or "",
+    ]
+
+    for field in searchable_fields:
+        field_value = field.lower()
+        if query_value in field_value:
+            score += 10
+
+    message_words = _normalize_words(query_value)
+    department_keywords = _normalize_words(department.keywords)
+    department_prompt_words = _normalize_words(department.query)
+
+    score += len(message_words & department_keywords) * 5
+    score += len(message_words & department_prompt_words) * 3
+
+    return score
+
+
+def match_department(db: Session, message: str) -> tuple[Department | None, int]:
+    departments = (
+        db.query(Department)
+        .filter(Department.is_active.is_(True))
+        .all()
+    )
+
+    best_department = None
+    best_score = 0
+
+    for department in departments:
+        score = score_department(department, message)
+        if score > best_score:
+            best_department = department
+            best_score = score
+
+    if best_department is not None:
+        return best_department, best_score
+
+    fallback_department = next(
+        (department for department in departments if department.name.lower() == "admin"),
+        None,
+    )
+    if fallback_department is not None:
+        return fallback_department, 0
+
+    return (departments[0], 0) if departments else (None, 0)

tests/conftest.py

@@ -0,0 +1,7 @@
+from pathlib import Path
+import sys
+
+
+BACKEND_ROOT = Path(__file__).resolve().parents[1]
+if str(BACKEND_ROOT) not in sys.path:
+    sys.path.insert(0, str(BACKEND_ROOT))

tests/test_queries.py

@@ -0,0 +1,160 @@
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy.pool import StaticPool
+
+from app.core.database import Base
+from app.models.department import Department
+from app.schemas.auth import SignupRequest
+from app.schemas.query import QueryCreate
+from app.services.auth_service import create_user
+from app.services.query_service import create_query, list_queries_for_user
+
+
+def _make_session():
+    engine = create_engine(
+        "sqlite+pysqlite:///:memory:",
+        connect_args={"check_same_thread": False},
+        poolclass=StaticPool,
+    )
+    TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    Base.metadata.create_all(bind=engine)
+    return engine, TestingSessionLocal()
+
+
+def _create_student(db, email: str = "student@example.com"):
+    return create_user(
+        db,
+        SignupRequest(
+            email=email,
+            password="password123",
+            full_name="Student User",
+            department_name="Student",
+        ),
+    )
+
+
+def test_create_query_routes_to_best_matching_department():
+    engine, db = _make_session()
+    try:
+        finance = Department(
+            name="Finance Department",
+            code="FIN",
+            description="Handles fees, refunds, and payment plans",
+            keywords="fee, payment, tuition, refund",
+            query="Fee payment and tuition questions",
+        )
+        admin = Department(
+            name="Admin",
+            code="ADMIN",
+            description="Fallback team",
+            keywords="general, other",
+            query="Fallback for anything else",
+        )
+        db.add_all([finance, admin])
+        db.commit()
+        db.refresh(finance)
+        db.refresh(admin)
+
+        student = _create_student(db)
+
+        query = create_query(
+            db,
+            current_user=student,
+            payload=QueryCreate(message="I need help with my fee payment"),
+        )
+
+        assert query.student_id == student.id
+        assert query.sender_email == student.email
+        assert query.department_id == finance.id
+        assert query.status == "Routed"
+        assert query.subject == "I need help with my fee payment"
+        assert query.snippet == "I need help with my fee payment"
+    finally:
+        db.close()
+        Base.metadata.drop_all(bind=engine)
+
+
+def test_create_query_falls_back_to_admin_when_no_match_is_found():
+    engine, db = _make_session()
+    try:
+        admin = Department(
+            name="Admin",
+            code="ADMIN",
+            description="Fallback team",
+            keywords="general, other",
+            query="Fallback for anything else",
+        )
+        db.add(admin)
+        db.commit()
+        db.refresh(admin)
+
+        student = _create_student(db, email="fallback@example.com")
+
+        query = create_query(
+            db,
+            current_user=student,
+            payload=QueryCreate(message="Please route this unusual request"),
+        )
+
+        assert query.department_id == admin.id
+        assert query.status == "Routed"
+        assert query.confidence == 0.5
+    finally:
+        db.close()
+        Base.metadata.drop_all(bind=engine)
+
+
+def test_create_query_rejects_empty_message():
+    engine, db = _make_session()
+    try:
+        student = _create_student(db)
+
+        try:
+            create_query(
+                db,
+                current_user=student,
+                payload=QueryCreate(message="   "),
+            )
+            raise AssertionError("Expected empty query message to fail")
+        except ValueError as exc:
+            assert "cannot be empty" in str(exc)
+    finally:
+        db.close()
+        Base.metadata.drop_all(bind=engine)
+
+
+def test_list_queries_for_user_only_returns_that_users_queries():
+    engine, db = _make_session()
+    try:
+        finance = Department(
+            name="Finance Department",
+            code="FIN",
+            description="Handles fees, refunds, and payment plans",
+            keywords="fee, payment, tuition, refund",
+        )
+        db.add(finance)
+        db.commit()
+        db.refresh(finance)
+
+        student_one = _create_student(db, email="student1@example.com")
+        student_two = _create_student(db, email="student2@example.com")
+
+        first_query = create_query(
+            db,
+            current_user=student_one,
+            payload=QueryCreate(message="Question about tuition payment"),
+        )
+        create_query(
+            db,
+            current_user=student_two,
+            payload=QueryCreate(message="Different student's message"),
+        )
+
+        queries = list_queries_for_user(db, current_user=student_one)
+
+        assert len(queries) == 1
+        assert queries[0].id == first_query.id
+        assert queries[0].student_id == student_one.id
+    finally:
+        db.close()
+        Base.metadata.drop_all(bind=engine)