Upload code backend lan dau

.env

@@ -0,0 +1,12 @@
+# Supabase Configuration
+    SUPABASE_URL=https://gtwatjmkyfweohhvpute.supabase.co
+    SUPABASE_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Imd0d2F0am1reWZ3ZW9oaHZwdXRlIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NjU4ODEyNzIsImV4cCI6MjA4MTQ1NzI3Mn0.vZjoP5dcnYJJGS23rFgg9KMZwpevJDf2Fk76J35RkZM
+    SUPABASE_SERVICE_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Imd0d2F0am1reWZ3ZW9oaHZwdXRlIiwicm9sZSI6InNlcnZpY2Vfcm9sZSIsImlhdCI6MTc2NTg4MTI3MiwiZXhwIjoyMDgxNDU3MjcyfQ.7_aMq3PHNJr_HeiWV6n8Lom2hEcOBBI2zsa7h_nzfRo
+   
+# JWT Configuration
+    SECRET_KEY=hoangtanthiendeptrai1209@
+    ALGORITHM=HS256
+    ACCESS_TOKEN_EXPIRE_MINUTES=30
+
+# CORS Configuration
+    CORS_ORIGINS=["http://localhost:3000"]

Dockerfile

@@ -0,0 +1,23 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    gcc \
+    g++ \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements and install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Expose port (Hugging Face Spaces uses port 7860)
+EXPOSE 7860
+
+# Run the application
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]
+

README.md

@@ -1,11 +1,66 @@
----
-title: Thoikhoabieu
-emoji: 📚
-colorFrom: pink
-colorTo: red
-sdk: docker
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# TKB Web Backend - Hugging Face Spaces
+
+Backend API cho hệ thống quản lý thời khóa biểu, được deploy trên Hugging Face Spaces.
+
+## Cấu trúc
+
+```
+web-backend/
+├── app/
+│   ├── __init__.py
+│   ├── main.py              # FastAPI application
+│   ├── config.py            # Configuration
+│   ├── database.py          # Supabase connection
+│   ├── models/              # Pydantic models
+│   ├── routers/             # API routes
+│   │   ├── auth.py
+│   │   ├── units.py
+│   │   ├── teachers.py
+│   │   ├── subjects.py
+│   │   ├── classes.py
+│   │   ├── timetable.py
+│   │   └── solver.py
+│   ├── services/            # Business logic
+│   │   ├── solver_service.py
+│   │   ├── timetable_service.py
+│   │   └── ai_service.py
+│   └── utils/               # Utilities
+├── requirements.txt
+├── Dockerfile
+└── README.md
+```
+
+## Setup
+
+1. Cài đặt dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+2. Cấu hình environment variables:
+```bash
+export SUPABASE_URL=your_supabase_url
+export SUPABASE_KEY=your_supabase_key
+export GEMINI_API_KEY=your_gemini_key
+```
+
+3. Chạy server:
+```bash
+uvicorn app.main:app --host 0.0.0.0 --port 7860
+```
+
+## Deploy lên Hugging Face Spaces
+
+1. Tạo Space mới trên Hugging Face
+2. Chọn SDK: Docker
+3. Push code lên repository
+4. Hugging Face sẽ tự động build và deploy
+
+## API Endpoints
+
+- `POST /api/auth/login` - Đăng nhập
+- `GET /api/units` - Lấy danh sách đơn vị
+- `GET /api/teachers` - Lấy danh sách giáo viên
+- `POST /api/timetable/solve` - Xếp thời khóa biểu
+- `GET /api/timetable/{session_id}` - Lấy thời khóa biểu
+

app/__init__.py

@@ -0,0 +1 @@
+# TKB Web Backend Application

app/config.py

@@ -0,0 +1,39 @@
+"""
+Configuration settings for the application
+"""
+from pydantic_settings import BaseSettings
+from typing import Optional
+
+
+class Settings(BaseSettings):
+    """Application settings loaded from environment variables"""
+    
+    # Supabase Configuration
+    supabase_url: str
+    supabase_key: str
+    supabase_service_key: Optional[str] = None
+    
+    # Gemini AI Configuration
+    gemini_api_key: Optional[str] = None
+    
+    # JWT Configuration
+    secret_key: str = "your-secret-key-change-in-production"
+    algorithm: str = "HS256"
+    access_token_expire_minutes: int = 30
+    
+    # CORS Configuration
+    cors_origins: list[str] = [
+        "http://localhost:3000",
+        "https://your-vercel-app.vercel.app"
+    ]
+    
+    # Hugging Face Spaces
+    space_id: Optional[str] = None
+    
+    class Config:
+        env_file = ".env"
+        case_sensitive = False
+
+
+settings = Settings()
+

app/database.py

@@ -0,0 +1,83 @@
+"""
+Supabase database connection and utilities
+"""
+from supabase import create_client, Client
+from app.config import settings
+from typing import Optional
+import logging
+
+logger = logging.getLogger(__name__)
+
+class DatabaseManager:
+    """Manages Supabase database connections"""
+    
+    def __init__(self):
+        self.supabase: Optional[Client] = None
+        self._initialize_client()
+    
+    def _initialize_client(self):
+        """Initialize Supabase client"""
+        try:
+            self.supabase = create_client(
+                settings.supabase_url,
+                settings.supabase_key
+            )
+            logger.info("Supabase client initialized successfully")
+        except Exception as e:
+            logger.error(f"Failed to initialize Supabase client: {e}")
+            raise
+    
+    def get_client(self) -> Client:
+        """Get Supabase client instance"""
+        if self.supabase is None:
+            self._initialize_client()
+        return self.supabase
+    
+    # Helper methods for common operations
+    def execute_query(self, table: str, operation: str = "select", **kwargs):
+        """Execute a query on a table"""
+        client = self.get_client()
+        
+        try:
+            if operation == "select":
+                query = client.table(table).select("*")
+                if "filters" in kwargs:
+                    for filter_item in kwargs["filters"]:
+                        query = query.eq(filter_item["column"], filter_item["value"])
+                if "limit" in kwargs:
+                    query = query.limit(kwargs["limit"])
+                if "order" in kwargs:
+                    order_col = kwargs["order"]["column"]
+                    order_desc = kwargs["order"].get("desc", False)
+                    query = query.order(order_col, desc=order_desc)
+                result = query.execute()
+                return result
+            
+            elif operation == "insert":
+                data = kwargs.get("data", {})
+                result = client.table(table).insert(data).execute()
+                return result
+            
+            elif operation == "update":
+                query = client.table(table).update(kwargs.get("data", {}))
+                if "filters" in kwargs:
+                    for filter_item in kwargs["filters"]:
+                        query = query.eq(filter_item["column"], filter_item["value"])
+                result = query.execute()
+                return result
+            
+            elif operation == "delete":
+                query = client.table(table).delete()
+                if "filters" in kwargs:
+                    for filter_item in kwargs["filters"]:
+                        query = query.eq(filter_item["column"], filter_item["value"])
+                result = query.execute()
+                return result
+        except Exception as e:
+            logger.error(f"Error executing query on {table}: {e}")
+            raise
+
+
+# Global database manager instance
+db_manager = DatabaseManager()
+

app/main.py

@@ -0,0 +1,68 @@
+"""
+FastAPI main application
+"""
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from app.config import settings
+from app.routers import auth, units, teachers, subjects, classes, timetable, solver
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(
+    title="TKB Web API",
+    description="API cho hệ thống quản lý thời khóa biểu",
+    version="2.0.0"
+)
+
+# CORS Middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.cors_origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include routers
+app.include_router(auth.router, prefix="/api/auth", tags=["Authentication"])
+app.include_router(units.router, prefix="/api/units", tags=["Units"])
+app.include_router(teachers.router, prefix="/api/teachers", tags=["Teachers"])
+app.include_router(subjects.router, prefix="/api/subjects", tags=["Subjects"])
+app.include_router(classes.router, prefix="/api/classes", tags=["Classes"])
+app.include_router(timetable.router, prefix="/api/timetable", tags=["Timetable"])
+app.include_router(solver.router, prefix="/api/solver", tags=["Solver"])
+
+
+@app.get("/")
+async def root():
+    """Root endpoint"""
+    return {
+        "message": "TKB Web API",
+        "version": "2.0.0",
+        "status": "running"
+    }
+
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {"status": "healthy"}
+
+
+@app.exception_handler(Exception)
+async def global_exception_handler(request: Request, exc: Exception):
+    """Global exception handler"""
+    logger.error(f"Unhandled exception: {exc}", exc_info=True)
+    return JSONResponse(
+        status_code=500,
+        content={"detail": "Internal server error"}
+    )
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)
+

app/models/__init__.py

@@ -0,0 +1,2 @@
+# Models package
+

app/models/schemas.py

@@ -0,0 +1,152 @@
+"""
+Pydantic models for request/response schemas
+"""
+from pydantic import BaseModel, EmailStr
+from typing import Optional, List, Dict, Any
+from datetime import datetime
+
+
+# Authentication Models
+class LoginRequest(BaseModel):
+    username: str
+    password: str
+
+
+class TokenResponse(BaseModel):
+    access_token: str
+    token_type: str = "bearer"
+
+
+# Unit Models
+class UnitCreate(BaseModel):
+    name: str
+
+
+class UnitResponse(BaseModel):
+    id: int
+    name: str
+    
+    class Config:
+        from_attributes = True
+
+
+# Teacher Models
+class TeacherCreate(BaseModel):
+    id: str
+    name: str
+    subjects: List[str] = []
+    secondary_subjects: List[str] = []
+    busy_slots: List[List[int]] = []  # [[day, period], ...]
+    is_locked: bool = False
+    work_days_preference: int = 0
+    role: Optional[str] = None
+    target_periods: Optional[int] = None
+    email: Optional[EmailStr] = None
+    professional_group_name: Optional[str] = None
+
+
+class TeacherResponse(BaseModel):
+    unit_id: int
+    school_year: str
+    id: str
+    name: str
+    subjects: List[str]
+    secondary_subjects: List[str]
+    busy_slots: List[List[int]]
+    is_locked: bool
+    work_days_preference: int
+    role: Optional[str]
+    target_periods: Optional[int]
+    email: Optional[str]
+    professional_group_name: Optional[str]
+    
+    class Config:
+        from_attributes = True
+
+
+# Subject Models
+class SubjectCreate(BaseModel):
+    name: str
+    periods_per_week: Dict[str, int] = {}  # {grade: periods}
+    is_double_period_only: bool = False
+
+
+class SubjectResponse(BaseModel):
+    unit_id: int
+    school_year: str
+    name: str
+    periods_per_week: Dict[str, int]
+    is_double_period_only: bool
+    
+    class Config:
+        from_attributes = True
+
+
+# Class Models
+class ClassCreate(BaseModel):
+    name: str
+    grade: Optional[int] = None
+    session: Optional[str] = None
+    homeroom_teacher_id: Optional[str] = None
+    fixed_off_slots: List[List[int]] = []
+    is_locked: bool = False
+
+
+class ClassResponse(BaseModel):
+    unit_id: int
+    school_year: str
+    name: str
+    grade: Optional[int]
+    session: Optional[str]
+    homeroom_teacher_id: Optional[str]
+    fixed_off_slots: List[List[int]]
+    is_locked: bool
+    
+    class Config:
+        from_attributes = True
+
+
+# Timetable Models
+class TimetableSessionCreate(BaseModel):
+    session_name: str
+    effective_date: Optional[str] = None
+
+
+class TimetableSessionResponse(BaseModel):
+    id: int
+    unit_id: int
+    school_year: str
+    session_name: str
+    is_locked: bool
+    created_at: str
+    effective_date: Optional[str]
+    
+    class Config:
+        from_attributes = True
+
+
+class TimetableData(BaseModel):
+    timetable: Dict[str, Any]  # Flexible structure for timetable data
+    unplaced_lessons: List[Dict[str, Any]] = []
+
+
+# Solver Models
+class SolverRequest(BaseModel):
+    unit_id: int
+    school_year: str
+    mode: str = "ortools_balanced"  # ortools_balanced, ortools_days_off
+    num_workers: int = 8
+    time_limit: float = 300.0
+    weights: Optional[Dict[str, float]] = None
+    priority_teacher_ids: Optional[List[str]] = None
+    phase: Optional[str] = None  # phase1, phase2, phase3
+
+
+class SolverResponse(BaseModel):
+    success: bool
+    timetable: Optional[Dict[str, Any]] = None
+    objective_value: Optional[float] = None
+    unplaced_lessons: List[Dict[str, Any]] = []
+    message: str
+    execution_time: Optional[float] = None
+

app/routers/__init__.py

@@ -0,0 +1,2 @@
+# Routers package
+

app/routers/auth.py

@@ -0,0 +1,152 @@
+"""
+Authentication routes - Debug Version (Using Logger)
+"""
+from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+from datetime import datetime, timedelta
+from typing import Optional
+from jose import JWTError, jwt
+from app.config import settings
+from app.models.schemas import LoginRequest, TokenResponse
+from app.database import db_manager
+import hashlib
+import logging
+
+# Cấu hình logger để đảm bảo hiện ra terminal
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("uvicorn.error") # Sử dụng logger của uvicorn để chắc chắn hiện
+
+router = APIRouter()
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/api/auth/login")
+
+
+def hash_password(password: str) -> str:
+    """Hash password using SHA-256 (compatible with original code)"""
+    return hashlib.sha256(password.encode('utf-8')).hexdigest()
+
+
+def verify_password(stored_hash: str, provided_password: str) -> bool:
+    """Verify password against stored hash (SHA-256)"""
+    calculated_hash = hash_password(provided_password)
+    # Log hash để so sánh
+    logger.warning(f"CHECK PASS: Hash trong DB  = {stored_hash}")
+    logger.warning(f"CHECK PASS: Hash nhập vào  = {calculated_hash}")
+    return stored_hash == calculated_hash
+
+
+def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
+    """Create JWT access token"""
+    to_encode = data.copy()
+    if expires_delta:
+        expire = datetime.utcnow() + expires_delta
+    else:
+        expire = datetime.utcnow() + timedelta(minutes=settings.access_token_expire_minutes)
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, settings.secret_key, algorithm=settings.algorithm)
+    return encoded_jwt
+
+
+async def get_current_user(token: str = Depends(oauth2_scheme)):
+    """Get current authenticated user"""
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    try:
+        payload = jwt.decode(token, settings.secret_key, algorithms=[settings.algorithm])
+        username: str = payload.get("sub")
+        if username is None:
+            raise credentials_exception
+    except JWTError:
+        raise credentials_exception
+    
+    # Verify user exists in database
+    try:
+        result = db_manager.execute_query(
+            "users",
+            "select",
+            filters=[{"column": "username", "value": username}]
+        )
+        if not result.data:
+            raise credentials_exception
+        return result.data[0]
+    except Exception as e:
+        logger.error(f"Error fetching user: {e}")
+        raise credentials_exception
+
+
+@router.post("/login", response_model=TokenResponse)
+async def login(form_data: OAuth2PasswordRequestForm = Depends()):
+    """Login endpoint with LOGGER WARNING"""
+    try:
+        logger.warning("\n" + "="*50)
+        logger.warning(f"DEBUG: Bắt đầu đăng nhập cho user: '{form_data.username}'")
+        
+        # 1. Get user from database
+        result = db_manager.execute_query(
+            "users",
+            "select",
+            filters=[{"column": "username", "value": form_data.username}]
+        )
+        
+        logger.warning(f"DEBUG: Kết quả tìm trong DB (Raw Data): {result.data}")
+        
+        if not result.data:
+            logger.warning("DEBUG: LỖI -> Không tìm thấy user hoặc bị RLS chặn. Danh sách trả về rỗng []")
+            logger.warning("="*50 + "\n")
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Incorrect username or password"
+            )
+        
+        user = result.data[0]
+        
+        # 2. Verify password
+        stored_hash = user.get("password_hash", "")
+        # Password verify sẽ tự log hash bên trong hàm verify_password
+        
+        is_valid = False
+        if not stored_hash:
+            logger.warning("DEBUG: LỖI -> User trong DB không có cột password_hash")
+        else:
+            is_valid = verify_password(stored_hash, form_data.password)
+            
+        if not is_valid:
+            logger.warning("DEBUG: KẾT QUẢ -> Mật khẩu KHÔNG khớp!")
+            logger.warning("="*50 + "\n")
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Incorrect username or password"
+            )
+        
+        logger.warning("DEBUG: KẾT QUẢ -> Đăng nhập THÀNH CÔNG!")
+        logger.warning("="*50 + "\n")
+
+        # 3. Create access token
+        access_token_expires = timedelta(minutes=settings.access_token_expire_minutes)
+        access_token = create_access_token(
+            data={"sub": user["username"], "role": user.get("role", "user")},
+            expires_delta=access_token_expires
+        )
+        
+        return {"access_token": access_token, "token_type": "bearer"}
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Login error: {e}")
+        logger.warning(f"DEBUG: LỖI HỆ THỐNG -> {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Internal server error"
+        )
+
+
+@router.get("/me")
+async def get_current_user_info(current_user: dict = Depends(get_current_user)):
+    """Get current user information"""
+    return {
+        "username": current_user.get("username"),
+        "role": current_user.get("role", "user")
+    }

app/routers/classes.py

@@ -0,0 +1,97 @@
+"""
+Classes management routes
+"""
+from fastapi import APIRouter, Depends, HTTPException, Query
+from app.models.schemas import ClassCreate, ClassResponse
+from app.routers.auth import get_current_user
+from app.database import db_manager
+import json
+import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+@router.get("", response_model=list[ClassResponse])
+async def get_classes(
+    unit_id: int = Query(...),
+    school_year: str = Query(...),
+    current_user: dict = Depends(get_current_user)
+):
+    """Get all classes for a unit and school year"""
+    try:
+        result = db_manager.execute_query(
+            "classes",
+            "select",
+            filters=[
+                {"column": "unit_id", "value": unit_id},
+                {"column": "school_year", "value": school_year}
+            ]
+        )
+        # Parse JSON fields
+        classes = []
+        for cls in result.data:
+            cls["fixed_off_slots"] = json.loads(cls.get("fixed_off_slots") or "[]")
+            classes.append(cls)
+        return classes
+    except Exception as e:
+        logger.error(f"Error fetching classes: {e}")
+        raise HTTPException(status_code=500, detail="Error fetching classes")
+
+
+@router.post("", response_model=ClassResponse)
+async def create_class(
+    unit_id: int,
+    school_year: str,
+    class_data: ClassCreate,
+    current_user: dict = Depends(get_current_user)
+):
+    """Create a new class"""
+    try:
+        data = {
+            "unit_id": unit_id,
+            "school_year": school_year,
+            "name": class_data.name,
+            "grade": class_data.grade,
+            "session": class_data.session,
+            "homeroom_teacher_id": class_data.homeroom_teacher_id,
+            "fixed_off_slots": json.dumps(class_data.fixed_off_slots),
+            "is_locked": class_data.is_locked
+        }
+        result = db_manager.execute_query("classes", "insert", data=data)
+        if result.data:
+            class_result = result.data[0]
+            class_result["fixed_off_slots"] = class_data.fixed_off_slots
+            return class_result
+        raise HTTPException(status_code=500, detail="Error creating class")
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error creating class: {e}")
+        raise HTTPException(status_code=500, detail="Error creating class")
+
+
+@router.delete("/{class_name}")
+async def delete_class(
+    unit_id: int,
+    school_year: str,
+    class_name: str,
+    current_user: dict = Depends(get_current_user)
+):
+    """Delete a class"""
+    try:
+        db_manager.execute_query(
+            "classes",
+            "delete",
+            filters=[
+                {"column": "unit_id", "value": unit_id},
+                {"column": "school_year", "value": school_year},
+                {"column": "name", "value": class_name}
+            ]
+        )
+        return {"message": "Class deleted successfully"}
+    except Exception as e:
+        logger.error(f"Error deleting class: {e}")
+        raise HTTPException(status_code=500, detail="Error deleting class")
+

app/routers/solver.py

@@ -0,0 +1,38 @@
+"""
+Timetable solver routes
+"""
+from fastapi import APIRouter, Depends, HTTPException, BackgroundTasks
+from app.models.schemas import SolverRequest, SolverResponse
+from app.routers.auth import get_current_user
+from app.services.solver_service import SolverService
+import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+@router.post("/solve", response_model=SolverResponse)
+async def solve_timetable(
+    request: SolverRequest,
+    background_tasks: BackgroundTasks,
+    current_user: dict = Depends(get_current_user)
+):
+    """Solve timetable scheduling problem"""
+    try:
+        solver_service = SolverService()
+        result = await solver_service.solve(
+            unit_id=request.unit_id,
+            school_year=request.school_year,
+            mode=request.mode,
+            num_workers=request.num_workers,
+            time_limit=request.time_limit,
+            weights=request.weights,
+            priority_teacher_ids=request.priority_teacher_ids,
+            phase=request.phase
+        )
+        return result
+    except Exception as e:
+        logger.error(f"Error solving timetable: {e}")
+        raise HTTPException(status_code=500, detail=f"Error solving timetable: {str(e)}")
+

app/routers/subjects.py

@@ -0,0 +1,94 @@
+"""
+Subjects management routes
+"""
+from fastapi import APIRouter, Depends, HTTPException, Query
+from app.models.schemas import SubjectCreate, SubjectResponse
+from app.routers.auth import get_current_user
+from app.database import db_manager
+import json
+import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+@router.get("", response_model=list[SubjectResponse])
+async def get_subjects(
+    unit_id: int = Query(...),
+    school_year: str = Query(...),
+    current_user: dict = Depends(get_current_user)
+):
+    """Get all subjects for a unit and school year"""
+    try:
+        result = db_manager.execute_query(
+            "subjects",
+            "select",
+            filters=[
+                {"column": "unit_id", "value": unit_id},
+                {"column": "school_year", "value": school_year}
+            ]
+        )
+        # Parse JSON fields
+        subjects = []
+        for subject in result.data:
+            subject["periods_per_week"] = json.loads(subject.get("periods_per_week") or "{}")
+            subjects.append(subject)
+        return subjects
+    except Exception as e:
+        logger.error(f"Error fetching subjects: {e}")
+        raise HTTPException(status_code=500, detail="Error fetching subjects")
+
+
+@router.post("", response_model=SubjectResponse)
+async def create_subject(
+    unit_id: int,
+    school_year: str,
+    subject: SubjectCreate,
+    current_user: dict = Depends(get_current_user)
+):
+    """Create a new subject"""
+    try:
+        data = {
+            "unit_id": unit_id,
+            "school_year": school_year,
+            "name": subject.name,
+            "periods_per_week": json.dumps(subject.periods_per_week),
+            "is_double_period_only": subject.is_double_period_only
+        }
+        result = db_manager.execute_query("subjects", "insert", data=data)
+        if result.data:
+            subject_data = result.data[0]
+            subject_data["periods_per_week"] = subject.periods_per_week
+            return subject_data
+        raise HTTPException(status_code=500, detail="Error creating subject")
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error creating subject: {e}")
+        raise HTTPException(status_code=500, detail="Error creating subject")
+
+
+@router.delete("/{subject_name}")
+async def delete_subject(
+    unit_id: int,
+    school_year: str,
+    subject_name: str,
+    current_user: dict = Depends(get_current_user)
+):
+    """Delete a subject"""
+    try:
+        db_manager.execute_query(
+            "subjects",
+            "delete",
+            filters=[
+                {"column": "unit_id", "value": unit_id},
+                {"column": "school_year", "value": school_year},
+                {"column": "name", "value": subject_name}
+            ]
+        )
+        return {"message": "Subject deleted successfully"}
+    except Exception as e:
+        logger.error(f"Error deleting subject: {e}")
+        raise HTTPException(status_code=500, detail="Error deleting subject")
+

app/routers/teachers.py

@@ -0,0 +1,152 @@
+"""
+Teachers management routes
+"""
+from fastapi import APIRouter, Depends, HTTPException, Query
+from app.models.schemas import TeacherCreate, TeacherResponse
+from app.routers.auth import get_current_user
+from app.database import db_manager
+import json
+import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+@router.get("", response_model=list[TeacherResponse])
+async def get_teachers(
+    unit_id: int = Query(...),
+    school_year: str = Query(...),
+    current_user: dict = Depends(get_current_user)
+):
+    """Get all teachers for a unit and school year"""
+    try:
+        result = db_manager.execute_query(
+            "teachers",
+            "select",
+            filters=[
+                {"column": "unit_id", "value": unit_id},
+                {"column": "school_year", "value": school_year}
+            ]
+        )
+        # Parse JSON fields
+        teachers = []
+        for teacher in result.data:
+            teacher["subjects"] = json.loads(teacher.get("subjects") or "[]")
+            teacher["secondary_subjects"] = json.loads(teacher.get("secondary_subjects") or "[]")
+            teacher["busy_slots"] = json.loads(teacher.get("busy_slots") or "[]")
+            teachers.append(teacher)
+        return teachers
+    except Exception as e:
+        logger.error(f"Error fetching teachers: {e}")
+        raise HTTPException(status_code=500, detail="Error fetching teachers")
+
+
+@router.post("", response_model=TeacherResponse)
+async def create_teacher(
+    unit_id: int,
+    school_year: str,
+    teacher: TeacherCreate,
+    current_user: dict = Depends(get_current_user)
+):
+    """Create a new teacher"""
+    try:
+        data = {
+            "unit_id": unit_id,
+            "school_year": school_year,
+            "id": teacher.id,
+            "name": teacher.name,
+            "subjects": json.dumps(teacher.subjects),
+            "secondary_subjects": json.dumps(teacher.secondary_subjects),
+            "busy_slots": json.dumps(teacher.busy_slots),
+            "is_locked": teacher.is_locked,
+            "work_days_preference": teacher.work_days_preference,
+            "role": teacher.role,
+            "target_periods": teacher.target_periods,
+            "email": teacher.email,
+            "professional_group_name": teacher.professional_group_name
+        }
+        result = db_manager.execute_query("teachers", "insert", data=data)
+        if result.data:
+            teacher_data = result.data[0]
+            teacher_data["subjects"] = teacher.subjects
+            teacher_data["secondary_subjects"] = teacher.secondary_subjects
+            teacher_data["busy_slots"] = teacher.busy_slots
+            return teacher_data
+        raise HTTPException(status_code=500, detail="Error creating teacher")
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error creating teacher: {e}")
+        raise HTTPException(status_code=500, detail="Error creating teacher")
+
+
+@router.put("/{teacher_id}", response_model=TeacherResponse)
+async def update_teacher(
+    unit_id: int,
+    school_year: str,
+    teacher_id: str,
+    teacher: TeacherCreate,
+    current_user: dict = Depends(get_current_user)
+):
+    """Update a teacher"""
+    try:
+        data = {
+            "name": teacher.name,
+            "subjects": json.dumps(teacher.subjects),
+            "secondary_subjects": json.dumps(teacher.secondary_subjects),
+            "busy_slots": json.dumps(teacher.busy_slots),
+            "is_locked": teacher.is_locked,
+            "work_days_preference": teacher.work_days_preference,
+            "role": teacher.role,
+            "target_periods": teacher.target_periods,
+            "email": teacher.email,
+            "professional_group_name": teacher.professional_group_name
+        }
+        result = db_manager.execute_query(
+            "teachers",
+            "update",
+            data=data,
+            filters=[
+                {"column": "unit_id", "value": unit_id},
+                {"column": "school_year", "value": school_year},
+                {"column": "id", "value": teacher_id}
+            ]
+        )
+        if not result.data:
+            raise HTTPException(status_code=404, detail="Teacher not found")
+        teacher_data = result.data[0]
+        teacher_data["subjects"] = teacher.subjects
+        teacher_data["secondary_subjects"] = teacher.secondary_subjects
+        teacher_data["busy_slots"] = teacher.busy_slots
+        return teacher_data
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error updating teacher: {e}")
+        raise HTTPException(status_code=500, detail="Error updating teacher")
+
+
+@router.delete("/{teacher_id}")
+async def delete_teacher(
+    unit_id: int,
+    school_year: str,
+    teacher_id: str,
+    current_user: dict = Depends(get_current_user)
+):
+    """Delete a teacher"""
+    try:
+        db_manager.execute_query(
+            "teachers",
+            "delete",
+            filters=[
+                {"column": "unit_id", "value": unit_id},
+                {"column": "school_year", "value": school_year},
+                {"column": "id", "value": teacher_id}
+            ]
+        )
+        return {"message": "Teacher deleted successfully"}
+    except Exception as e:
+        logger.error(f"Error deleting teacher: {e}")
+        raise HTTPException(status_code=500, detail="Error deleting teacher")
+

app/routers/timetable.py

@@ -0,0 +1,131 @@
+"""
+Timetable management routes
+"""
+from fastapi import APIRouter, Depends, HTTPException, Query
+from app.models.schemas import TimetableSessionCreate, TimetableSessionResponse, TimetableData
+from app.routers.auth import get_current_user
+from app.database import db_manager
+import json
+import logging
+from datetime import datetime
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+@router.get("/sessions", response_model=list[TimetableSessionResponse])
+async def get_timetable_sessions(
+    unit_id: int = Query(...),
+    school_year: str = Query(...),
+    current_user: dict = Depends(get_current_user)
+):
+    """Get all timetable sessions for a unit and school year"""
+    try:
+        result = db_manager.execute_query(
+            "timetable_sessions",
+            "select",
+            filters=[
+                {"column": "unit_id", "value": unit_id},
+                {"column": "school_year", "value": school_year}
+            ],
+            order={"column": "created_at", "desc": True}
+        )
+        return result.data
+    except Exception as e:
+        logger.error(f"Error fetching timetable sessions: {e}")
+        raise HTTPException(status_code=500, detail="Error fetching timetable sessions")
+
+
+@router.post("/sessions", response_model=TimetableSessionResponse)
+async def create_timetable_session(
+    unit_id: int,
+    school_year: str,
+    session: TimetableSessionCreate,
+    timetable_data: TimetableData,
+    current_user: dict = Depends(get_current_user)
+):
+    """Create a new timetable session"""
+    try:
+        data = {
+            "unit_id": unit_id,
+            "school_year": school_year,
+            "session_name": session.session_name,
+            "timetable_data": json.dumps(timetable_data.timetable),
+            "is_locked": False,
+            "created_at": datetime.now().isoformat(),
+            "effective_date": session.effective_date
+        }
+        result = db_manager.execute_query("timetable_sessions", "insert", data=data)
+        if result.data:
+            return result.data[0]
+        raise HTTPException(status_code=500, detail="Error creating timetable session")
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error creating timetable session: {e}")
+        raise HTTPException(status_code=500, detail="Error creating timetable session")
+
+
+@router.get("/sessions/{session_id}", response_model=TimetableData)
+async def get_timetable_data(
+    session_id: int,
+    current_user: dict = Depends(get_current_user)
+):
+    """Get timetable data for a session"""
+    try:
+        result = db_manager.execute_query(
+            "timetable_sessions",
+            "select",
+            filters=[{"column": "id", "value": session_id}]
+        )
+        if not result.data:
+            raise HTTPException(status_code=404, detail="Timetable session not found")
+        
+        session = result.data[0]
+        timetable_data = json.loads(session.get("timetable_data", "{}"))
+        return TimetableData(timetable=timetable_data)
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error fetching timetable data: {e}")
+        raise HTTPException(status_code=500, detail="Error fetching timetable data")
+
+
+@router.put("/sessions/{session_id}/lock")
+async def toggle_session_lock(
+    session_id: int,
+    is_locked: bool,
+    current_user: dict = Depends(get_current_user)
+):
+    """Toggle lock status of a timetable session"""
+    try:
+        db_manager.execute_query(
+            "timetable_sessions",
+            "update",
+            data={"is_locked": is_locked},
+            filters=[{"column": "id", "value": session_id}]
+        )
+        return {"message": "Session lock status updated"}
+    except Exception as e:
+        logger.error(f"Error updating session lock: {e}")
+        raise HTTPException(status_code=500, detail="Error updating session lock")
+
+
+@router.delete("/sessions/{session_id}")
+async def delete_timetable_session(
+    session_id: int,
+    current_user: dict = Depends(get_current_user)
+):
+    """Delete a timetable session"""
+    try:
+        db_manager.execute_query(
+            "timetable_sessions",
+            "delete",
+            filters=[{"column": "id", "value": session_id}]
+        )
+        return {"message": "Timetable session deleted successfully"}
+    except Exception as e:
+        logger.error(f"Error deleting timetable session: {e}")
+        raise HTTPException(status_code=500, detail="Error deleting timetable session")
+

app/routers/units.py

@@ -0,0 +1,74 @@
+"""
+Units management routes
+"""
+from fastapi import APIRouter, Depends, HTTPException
+from app.models.schemas import UnitCreate, UnitResponse
+from app.routers.auth import get_current_user
+from app.database import db_manager
+import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+@router.get("", response_model=list[UnitResponse])
+async def get_all_units(current_user: dict = Depends(get_current_user)):
+    """Get all units"""
+    try:
+        result = db_manager.execute_query("units", "select", order={"column": "name", "desc": False})
+        return result.data
+    except Exception as e:
+        logger.error(f"Error fetching units: {e}")
+        raise HTTPException(status_code=500, detail="Error fetching units")
+
+
+@router.post("", response_model=UnitResponse)
+async def create_unit(unit: UnitCreate, current_user: dict = Depends(get_current_user)):
+    """Create a new unit"""
+    try:
+        result = db_manager.execute_query(
+            "units",
+            "insert",
+            data={"name": unit.name}
+        )
+        return result.data[0] if result.data else None
+    except Exception as e:
+        logger.error(f"Error creating unit: {e}")
+        raise HTTPException(status_code=500, detail="Error creating unit")
+
+
+@router.put("/{unit_id}", response_model=UnitResponse)
+async def update_unit(unit_id: int, unit: UnitCreate, current_user: dict = Depends(get_current_user)):
+    """Update a unit"""
+    try:
+        result = db_manager.execute_query(
+            "units",
+            "update",
+            data={"name": unit.name},
+            filters=[{"column": "id", "value": unit_id}]
+        )
+        if not result.data:
+            raise HTTPException(status_code=404, detail="Unit not found")
+        return result.data[0]
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error updating unit: {e}")
+        raise HTTPException(status_code=500, detail="Error updating unit")
+
+
+@router.delete("/{unit_id}")
+async def delete_unit(unit_id: int, current_user: dict = Depends(get_current_user)):
+    """Delete a unit"""
+    try:
+        db_manager.execute_query(
+            "units",
+            "delete",
+            filters=[{"column": "id", "value": unit_id}]
+        )
+        return {"message": "Unit deleted successfully"}
+    except Exception as e:
+        logger.error(f"Error deleting unit: {e}")
+        raise HTTPException(status_code=500, detail="Error deleting unit")
+

app/services/__init__.py

@@ -0,0 +1,2 @@
+# Services package
+

app/services/solver_service.py

@@ -0,0 +1,124 @@
+"""
+Timetable solver service - adapts the existing solver logic for web API
+"""
+import time
+from typing import Optional, Dict, Any, List
+from app.models.schemas import SolverResponse
+from app.database import db_manager
+import json
+import logging
+
+logger = logging.getLogger(__name__)
+
+# Note: This is a simplified version. You'll need to adapt the actual solver
+# from TKB_V1.2/core/solver_ortools.py to work in this async context
+class SolverService:
+    """Service for solving timetable scheduling problems"""
+    
+    async def solve(
+        self,
+        unit_id: int,
+        school_year: str,
+        mode: str = "ortools_balanced",
+        num_workers: int = 8,
+        time_limit: float = 300.0,
+        weights: Optional[Dict[str, float]] = None,
+        priority_teacher_ids: Optional[List[str]] = None,
+        phase: Optional[str] = None
+    ) -> SolverResponse:
+        """
+        Solve timetable scheduling problem
+        
+        This is a placeholder that needs to be implemented with the actual
+        solver logic from TKB_V1.2/core/solver_ortools.py
+        """
+        start_time = time.time()
+        
+        try:
+            # Load school data
+            school_data = await self._load_school_data(unit_id, school_year)
+            
+            # TODO: Implement actual solver logic here
+            # This should call the OrToolsSolverWorker logic but adapted for async
+            
+            # Placeholder response
+            execution_time = time.time() - start_time
+            
+            return SolverResponse(
+                success=True,
+                timetable={},
+                objective_value=0.0,
+                unplaced_lessons=[],
+                message="Solver not yet fully implemented",
+                execution_time=execution_time
+            )
+            
+        except Exception as e:
+            logger.error(f"Solver error: {e}")
+            execution_time = time.time() - start_time
+            return SolverResponse(
+                success=False,
+                message=f"Error: {str(e)}",
+                execution_time=execution_time
+            )
+    
+    async def _load_school_data(self, unit_id: int, school_year: str) -> Dict[str, Any]:
+        """Load school data from database"""
+        try:
+            # Load teachers
+            teachers_result = db_manager.execute_query(
+                "teachers",
+                "select",
+                filters=[
+                    {"column": "unit_id", "value": unit_id},
+                    {"column": "school_year", "value": school_year}
+                ]
+            )
+            
+            # Load subjects
+            subjects_result = db_manager.execute_query(
+                "subjects",
+                "select",
+                filters=[
+                    {"column": "unit_id", "value": unit_id},
+                    {"column": "school_year", "value": school_year}
+                ]
+            )
+            
+            # Load classes
+            classes_result = db_manager.execute_query(
+                "classes",
+                "select",
+                filters=[
+                    {"column": "unit_id", "value": unit_id},
+                    {"column": "school_year", "value": school_year}
+                ]
+            )
+            
+            # Parse JSON fields
+            teachers = []
+            for teacher in teachers_result.data:
+                teacher["subjects"] = json.loads(teacher.get("subjects") or "[]")
+                teacher["secondary_subjects"] = json.loads(teacher.get("secondary_subjects") or "[]")
+                teacher["busy_slots"] = json.loads(teacher.get("busy_slots") or "[]")
+                teachers.append(teacher)
+            
+            subjects = []
+            for subject in subjects_result.data:
+                subject["periods_per_week"] = json.loads(subject.get("periods_per_week") or "{}")
+                subjects.append(subject)
+            
+            classes = []
+            for cls in classes_result.data:
+                cls["fixed_off_slots"] = json.loads(cls.get("fixed_off_slots") or "[]")
+                classes.append(cls)
+            
+            return {
+                "teachers": teachers,
+                "subjects": subjects,
+                "classes": classes
+            }
+        except Exception as e:
+            logger.error(f"Error loading school data: {e}")
+            raise
+

requirements.txt

@@ -0,0 +1,15 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+python-multipart==0.0.6
+pydantic==2.5.0
+pydantic-settings==2.1.0
+supabase==2.0.3
+postgrest==0.13.0
+python-jose[cryptography]==3.3.0
+passlib[bcrypt]==1.7.4
+python-dotenv==1.0.0
+ortools==9.9.3963
+google-generativeai==0.3.2
+httpx==0.25.2
+python-dateutil==2.8.2
+