Initial commit for Smart Query Routing System

.env

@@ -0,0 +1,4 @@
+APP_NAME=QueryRoute Dashboard
+ENVIRONMENT=development
+DEBUG=true
+DATABASE_URL=postgresql://neondb_owner:npg_ltTPcqu1Q6oS@ep-damp-glade-ab350rcx.eu-west-2.aws.neon.tech/neondb?sslmode=require&channel_binding=require

app/config.py

@@ -0,0 +1,47 @@
+from dataclasses import dataclass
+from pathlib import Path
+import os
+
+
+def _load_env_file() -> None:
+    env_path = Path(__file__).resolve().parents[1] / ".env"
+    if not env_path.exists():
+        return
+
+    for raw_line in env_path.read_text(encoding="utf-8").splitlines():
+        line = raw_line.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+
+        key, value = line.split("=", 1)
+        key = key.strip()
+        value = value.strip().strip('"').strip("'")
+
+        if key and key not in os.environ:
+            os.environ[key] = value
+
+
+_load_env_file()
+
+
+def _as_bool(value: str | None, default: bool = False) -> bool:
+    if value is None:
+        return default
+    return value.strip().lower() in {"1", "true", "yes", "on"}
+
+
+@dataclass(frozen=True)
+class Settings:
+    app_name: str = os.getenv("APP_NAME", "QueryRoute Dashboard")
+    environment: str = os.getenv("ENVIRONMENT", "development")
+    debug: bool = _as_bool(os.getenv("DEBUG"), False)
+    database_url: str = os.getenv("DATABASE_URL", "")
+    database_url_direct: str = os.getenv("DATABASE_URL_DIRECT", "")
+    jwt_secret_key: str = os.getenv("JWT_SECRET_KEY", "change-me-in-production")
+    jwt_algorithm: str = os.getenv("JWT_ALGORITHM", "HS256")
+    access_token_expire_minutes: int = int(
+        os.getenv("ACCESS_TOKEN_EXPIRE_MINUTES", "60")
+    )
+
+
+settings = Settings()

app/core/database.py

@@ -0,0 +1,31 @@
+from collections.abc import Generator
+
+from sqlalchemy import create_engine
+from sqlalchemy.orm import declarative_base, sessionmaker
+
+from app.config import settings
+
+
+if not settings.database_url:
+    raise RuntimeError("DATABASE_URL is not set")
+
+engine = create_engine(
+    settings.database_url,
+    pool_pre_ping=True,
+)
+
+SessionLocal = sessionmaker(
+    autocommit=False,
+    autoflush=False,
+    bind=engine,
+)
+
+Base = declarative_base()
+
+
+def get_db() -> Generator:
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

app/core/security.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from datetime import UTC, datetime, timedelta
+
+import bcrypt
+import jwt
+
+from app.config import settings
+
+
+def hash_password(password: str) -> str:
+    salt = bcrypt.gensalt()
+    return bcrypt.hashpw(password.encode("utf-8"), salt).decode("utf-8")
+
+
+def verify_password(plain_password: str, hashed_password: str) -> bool:
+    try:
+        return bcrypt.checkpw(
+            plain_password.encode("utf-8"),
+            hashed_password.encode("utf-8"),
+        )
+    except ValueError:
+        return False
+
+
+def create_access_token(subject: str, expires_delta: timedelta | None = None) -> str:
+    expire = datetime.now(UTC) + (
+        expires_delta
+        if expires_delta is not None
+        else timedelta(minutes=settings.access_token_expire_minutes)
+    )
+    payload = {"sub": subject, "exp": expire}
+    return jwt.encode(payload, settings.jwt_secret_key, algorithm=settings.jwt_algorithm)
+
+
+def decode_access_token(token: str) -> dict:
+    return jwt.decode(
+        token,
+        settings.jwt_secret_key,
+        algorithms=[settings.jwt_algorithm],
+    )

app/dependencies.py

@@ -0,0 +1,60 @@
+from collections.abc import Generator
+
+from fastapi import Depends, HTTPException, status
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+from sqlalchemy.orm import Session
+import jwt
+
+from app.core.database import SessionLocal
+from app.core.security import decode_access_token
+from app.models.user import User
+
+
+bearer_scheme = HTTPBearer(auto_error=False)
+
+
+def get_db() -> Generator[Session, None, None]:
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+
+def get_current_user(
+    credentials: HTTPAuthorizationCredentials | None = Depends(bearer_scheme),
+    db: Session = Depends(get_db),
+) -> User:
+    if credentials is None:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Not authenticated",
+        )
+
+    try:
+        payload = decode_access_token(credentials.credentials)
+        user_id = int(payload["sub"])
+    except (KeyError, ValueError, TypeError, jwt.PyJWTError):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid token",
+        ) from None
+
+    user = db.get(User, user_id)
+    if user is None:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="User not found",
+        )
+    return user
+
+
+def get_current_admin_user(
+    current_user: User = Depends(get_current_user),
+) -> User:
+    if not current_user.is_admin:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Admin access required",
+        )
+    return current_user

app/main.py

@@ -0,0 +1,35 @@
+from fastapi import FastAPI
+from sqlalchemy import text
+
+
+from app.config import settings
+from app.core.database import engine
+from app.models import User  # noqa: F401
+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
+
+
+app = FastAPI(title=settings.app_name)
+
+app.include_router(auth_router)
+app.include_router(admin_router)
+app.include_router(departments_router)
+
+
+@app.on_event("startup")
+def startup() -> None:
+    Base.metadata.create_all(bind=engine)
+
+
+@app.get("/")
+def read_root() -> dict[str, str]:
+    return {"status": "ok", "app": settings.app_name}
+
+
+@app.get("/health/db")
+def health_db() -> dict[str, str]:
+    with engine.connect() as connection:
+        connection.execute(text("SELECT 1"))
+    return {"status": "ok", "database": "connected"}

app/models/__init__.py

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

app/models/department.py

@@ -0,0 +1,16 @@
+from sqlalchemy import Boolean, Column, Integer, String, Text
+from sqlalchemy.orm import relationship
+
+from app.core.database import Base
+
+
+class Department(Base):
+    __tablename__ = "departments"
+
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String(100), unique=True, nullable=False)
+    code = Column(String(20), unique=True, nullable=False)
+    description = Column(Text, nullable=True)
+    keywords = Column(Text, nullable=True)
+    is_active = Column(Boolean, default=True, nullable=False)
+    users = relationship("User", back_populates="department")

app/models/user.py

@@ -0,0 +1,30 @@
+from datetime import UTC, datetime
+from sqlalchemy import Boolean, DateTime, ForeignKey, Integer, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from app.core.database import Base
+
+
+class User(Base):
+    __tablename__ = "users"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+    email: Mapped[str] = mapped_column(String(255), unique=True, index=True, nullable=False)
+    full_name: Mapped[str | None] = mapped_column(String(255), nullable=True)
+    hashed_password: Mapped[str] = mapped_column(String(255), nullable=False)
+    role: Mapped[str] = mapped_column(String(255), nullable=False)
+    is_admin: Mapped[bool] = mapped_column(Boolean, default=False, nullable=False)
+    department_id: Mapped[int | None] = mapped_column(
+        ForeignKey("departments.id", ondelete="SET NULL"),
+        nullable=True,
+    )
+    is_active: Mapped[bool] = mapped_column(Boolean, default=True, nullable=False)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime, default=lambda: datetime.now(UTC), nullable=False
+    )
+    department = relationship("Department", back_populates="users")
+
+    @property
+    def department_name(self) -> str | None:
+        if self.department is None:
+            return None
+        return self.department.name

app/routes/admin.py

@@ -0,0 +1,135 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+
+from app.dependencies import get_current_admin_user, get_db
+from app.models.user import User
+from app.schemas.admin import AdminDepartmentUpdate, AdminUserUpdate
+from app.schemas.department import DepartmentCreate, DepartmentResponse
+from app.schemas.user import UserRead
+from app.services.admin_service import (
+    create_department,
+    deactivate_department,
+    deactivate_user,
+    get_department,
+    get_user,
+    list_departments,
+    list_users,
+    update_department,
+    update_user,
+)
+
+
+router = APIRouter(prefix="/admin", tags=["admin"])
+
+
+def _raise_not_found(entity: str) -> None:
+    raise HTTPException(
+        status_code=status.HTTP_404_NOT_FOUND,
+        detail=f"{entity} not found",
+    )
+
+
+@router.get("/departments", response_model=list[DepartmentResponse])
+def admin_list_departments(
+    db: Session = Depends(get_db),
+    current_admin: User = Depends(get_current_admin_user),
+):
+    _ = current_admin
+    return list_departments(db)
+
+
+@router.post("/departments", response_model=DepartmentResponse, status_code=status.HTTP_201_CREATED)
+def admin_create_department(
+    payload: DepartmentCreate,
+    db: Session = Depends(get_db),
+    current_admin: User = Depends(get_current_admin_user),
+):
+    _ = current_admin
+    try:
+        return create_department(db, **payload.model_dump())
+    except ValueError as exc:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(exc)) from exc
+
+
+@router.put("/departments/{department_id}", response_model=DepartmentResponse)
+def admin_update_department(
+    department_id: int,
+    payload: AdminDepartmentUpdate,
+    db: Session = Depends(get_db),
+    current_admin: User = Depends(get_current_admin_user),
+):
+    _ = current_admin
+    try:
+        department = update_department(db, department_id=department_id, payload=payload)
+    except ValueError as exc:
+        message = str(exc)
+        status_code = status.HTTP_404_NOT_FOUND if message == "Department not found" else status.HTTP_400_BAD_REQUEST
+        raise HTTPException(status_code=status_code, detail=message) from exc
+    return department
+
+
+@router.delete("/departments/{department_id}", response_model=DepartmentResponse)
+def admin_deactivate_department(
+    department_id: int,
+    db: Session = Depends(get_db),
+    current_admin: User = Depends(get_current_admin_user),
+):
+    _ = current_admin
+    try:
+        department = deactivate_department(db, department_id=department_id)
+    except ValueError as exc:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc
+    return department
+
+
+@router.get("/users", response_model=list[UserRead])
+def admin_list_users(
+    db: Session = Depends(get_db),
+    current_admin: User = Depends(get_current_admin_user),
+):
+    _ = current_admin
+    return list_users(db)
+
+
+@router.get("/users/{user_id}", response_model=UserRead)
+def admin_get_user(
+    user_id: int,
+    db: Session = Depends(get_db),
+    current_admin: User = Depends(get_current_admin_user),
+):
+    _ = current_admin
+    user = get_user(db, user_id=user_id)
+    if user is None:
+        _raise_not_found("User")
+    return user
+
+
+@router.put("/users/{user_id}", response_model=UserRead)
+def admin_update_user(
+    user_id: int,
+    payload: AdminUserUpdate,
+    db: Session = Depends(get_db),
+    current_admin: User = Depends(get_current_admin_user),
+):
+    _ = current_admin
+    try:
+        user = update_user(db, user_id=user_id, payload=payload)
+    except ValueError as exc:
+        message = str(exc)
+        status_code = status.HTTP_404_NOT_FOUND if message == "User not found" else status.HTTP_400_BAD_REQUEST
+        raise HTTPException(status_code=status_code, detail=message) from exc
+    return user
+
+
+@router.delete("/users/{user_id}", response_model=UserRead)
+def admin_deactivate_user(
+    user_id: int,
+    db: Session = Depends(get_db),
+    current_admin: User = Depends(get_current_admin_user),
+):
+    _ = current_admin
+    try:
+        user = deactivate_user(db, user_id=user_id)
+    except ValueError as exc:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc
+    return user