FEAT: Hopefully last change for backend to stay running

.gitignore copy

@@ -1,186 +0,0 @@
-# Byte-compiled / optimized / DLL files
-__pycache__/
-*.py[cod]
-*$py.class
-
-# C extensions
-*.so
-
-# Distribution / packaging
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-share/python-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
-
-# PyInstaller
-#  Usually these files are written by a python script from a template
-#  before PyInstaller builds the exe, so as to inject date/other infos into it.
-*.manifest
-*.spec
-
-# Installer logs
-pip-log.txt
-pip-delete-this-directory.txt
-
-# Unit test / coverage reports
-htmlcov/
-.tox/
-.nox/
-.coverage
-.coverage.*
-.cache
-nosetests.xml
-coverage.xml
-*.cover
-*.py,cover
-.hypothesis/
-.pytest_cache/
-cover/
-
-# Translations
-*.mo
-*.pot
-
-# Django stuff:
-*.log
-local_settings.py
-db.sqlite3
-db.sqlite3-journal
-
-# Flask stuff:
-instance/
-.webassets-cache
-
-# Scrapy stuff:
-.scrapy
-
-# Sphinx documentation
-docs/_build/
-
-# PyBuilder
-.pybuilder/
-target/
-
-# Jupyter Notebook
-.ipynb_checkpoints
-
-# IPython
-profile_default/
-ipython_config.py
-
-# pyenv
-#   For a library or package, you might want to ignore these files since the code is
-#   intended to run in multiple environments; otherwise, check them in:
-# .python-version
-
-# pipenv
-#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
-#   However, in case of collaboration, if having platform-specific dependencies or dependencies
-#   having no cross-platform support, pipenv may install dependencies that don't work, or not
-#   install all needed dependencies.
-#Pipfile.lock
-
-# UV
-#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
-#   This is especially recommended for binary packages to ensure reproducibility, and is more
-#   commonly ignored for libraries.
-#uv.lock
-
-# poetry
-#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
-#   This is especially recommended for binary packages to ensure reproducibility, and is more
-#   commonly ignored for libraries.
-#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
-#poetry.lock
-
-# pdm
-#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
-#pdm.lock
-#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
-#   in version control.
-#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
-.pdm.toml
-.pdm-python
-.pdm-build/
-
-# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
-__pypackages__/
-
-# Celery stuff
-celerybeat-schedule
-celerybeat.pid
-
-# SageMath parsed files
-*.sage.py
-
-# Environments
-.env
-.venv
-env/
-venv/
-ENV/
-env.bak/
-venv.bak/
-
-# Spyder project settings
-.spyderproject
-.spyproject
-
-# Rope project settings
-.ropeproject
-
-# mkdocs documentation
-/site
-
-# mypy
-.mypy_cache/
-.dmypy.json
-dmypy.json
-
-# Pyre type checker
-.pyre/
-
-# pytype static type analyzer
-.pytype/
-
-# Cython debug symbols
-cython_debug/
-
-# PyCharm
-#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
-#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
-#  and can be added to the global gitignore or merged into this file.
-.idea/
-
-# Ruff stuff:
-.ruff_cache/
-
-# PyPI configuration file
-.pypirc
-
-# OS-generated files
-.DS_Store
-.DS_Store?
-._*
-Thumbs.db
-ehthumbs.db
-desktop.ini
-
-# Editor backup/swap files
-*~
-*.swp
-*.swo

main copy.py

@@ -1,51 +0,0 @@
-from fastapi import FastAPI
-from fastapi.middleware.cors import CORSMiddleware # Keep if CORS is needed
-import uvicorn
-from contextlib import asynccontextmanager
-
-from src.database import create_db_tables, get_db 
-from src.routers import students, devices, clearance, token, users, admin
-
-@asynccontextmanager
-async def lifespan(app_instance: FastAPI):
-    """Handles application startup and shutdown events."""
-    print("Application startup...")
-    create_db_tables()
-    print("Database tables checked/created.")
-    yield
-    print("Application shutdown...")
-
-
-# FastAPI app instance
-app = FastAPI(
-    title="Undergraduate Clearance System API (ORM)",
-    description="API for managing student clearance and RFID interactions.",
-    version="1.1.0", # Incremented version
-    lifespan=lifespan
-)
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins= ['*'],
-    allow_credentials=True,
-    allow_methods=["*"], # Allows all methods
-    allow_headers=["*"], # Allows all headers
-)
-
-# Include routers
-app.include_router(devices.router)
-app.include_router(students.router)
-app.include_router(clearance.router)
-app.include_router(token.router)
-app.include_router(users.router)
-app.include_router(admin.router)
-
-# Root endpoint
-@app.get("/", summary="Root endpoint", tags=["Default"])
-async def read_root():
-    """Basic root endpoint to confirm the API is running."""
-    return {"message": "Undergraduate Clearance System API is running"}
-
-# Run the FastAPI app using Uvicorn
-if __name__ == "__main__":
-    uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)

main.py

@@ -1,191 +1,108 @@
-from fastapi import FastAPI, HTTPException, Depends, status
-from fastapi.middleware.cors import CORSMiddleware
+from fastapi import FastAPI, JSONResponse
+from datetime import datetime
+from fastapi.middleware.cors import CORSMiddleware # Keep if CORS is needed
 import uvicorn
-from typing import List # Import List for type hinting
-from src.database import connect_db, disconnect_db, database # Also import database instance if needed directly in main
-from src.models import (
-    StudentCreate, Student, ClearanceStatusCreate,
-    ClearanceStatus, ClearanceDetail, DeviceRegister,
-    DeviceResponse, TagScan
-) # Pydantic models
-from src import crud # Database operations (now uses databases)
-from src.auth import verify_api_key # API key verification dependency (now uses databases)
+from contextlib import asynccontextmanager
+
+
+from src.database import create_db_tables, get_db 
+from src.routers import students, devices, clearance, token, users, admin
+
+@asynccontextmanager
+async def lifespan(app_instance: FastAPI):
+    """Handles application startup and shutdown events."""
+    print("Application startup...")
+    create_db_tables()
+    print("Database tables checked/created.")
+    yield
+    print("Application shutdown...")
+
 
 # FastAPI app instance
-app = FastAPI(title="Undergraduate Clearance System API", version="1.0.0")
+app = FastAPI(
+    title="Undergraduate Clearance System API",
+    description="""
+    A comprehensive API for managing student clearance processes with RFID authentication.
+    
+    ## Features
+    * **RFID Authentication** - Students and staff use RFID tags for quick access
+    * **Multi-Department Clearance** - Support for Library, Bursary, Alumni, and Departmental clearances
+    * **Device Management** - ESP32 RFID readers with secure API key authentication
+    * **Role-Based Access** - Different permissions for Students, Staff, and Administrators
+    * **Real-Time Tracking** - Live clearance status updates and comprehensive logging
+    
+    ## Authentication Methods
+    * **JWT Tokens** - For web interface and administrative access
+    * **RFID Tags** - For quick student and staff authentication
+    * **Device API Keys** - For ESP32 RFID reader authentication
+    """,
+    version="2.0.0",
+    lifespan=lifespan,
+    docs_url="/docs",
+    redoc_url="/redoc",
+    openapi_url="/openapi.json",
+    )
 
-# Enable CORS (Cross-Origin Resource Sharing)
-# This allows your frontend (running on a different origin) to access the API
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  # WARNING: Use specific origins in production (e.g., ["http://localhost:3000", "https://your-frontend-domain.com"])
+    allow_origins= ['*'],
     allow_credentials=True,
-    allow_methods=["*"],  # Allow all HTTP methods (GET, POST, PUT, DELETE, etc.)
-    allow_headers=["*"],  # Allow all headers
+    allow_methods=["*"], # Allows all methods
+    allow_headers=["*"], # Allows all headers
 )
 
-# --- Database Connection Lifecycle ---
-
-# Connect to the database when the application starts up
-@app.on_event("startup")
-async def startup_event():
-    await connect_db()
-
-# Disconnect from the database when the application shuts down
-@app.on_event("shutdown")
-async def shutdown_event():
-    await disconnect_db()
-
-
-# --- Routes for ESP32 Devices ---
-
-@app.post("/api/devices/register", response_model=DeviceResponse, summary="Register or re-register an ESP32 device")
-async def register_device(device: DeviceRegister):
-    """
-    Registers a new ESP32 device or updates an existing one using 'databases'.
-    Returns a unique API key for the device to use for subsequent requests.
-    """
-    # Call the crud function, which now uses 'databases'
-    return await crud.register_device(device)
-
-@app.post("/api/scan", summary="Receive tag scan data from an ESP32 device and return clearance details")
-async def scan_tag(scan_data: TagScan):
-    """
-    Receives a tag ID from an ESP32 device, verifies the device's API key
-    using 'databases', logs the scan event, retrieves the student's
-    clearance details based on the tag ID, and returns the details to the device.
-    """
-    # Verify API key using the dependency - this will raise HTTPException if invalid
-    # The verify_api_key function now uses 'databases'
-    device = await verify_api_key(scan_data.api_key)
-
-    # Update device last seen timestamp using the crud function (which uses databases)
-    await crud.update_device_last_seen(scan_data.device_id)
-
-    # Log the scan event using the crud function (which uses databases)
-    await crud.create_device_log(scan_data.device_id, scan_data.tag_id, "scan")
-
-    # Get student information by tag ID using the crud function (which uses databases)
-    student = await crud.get_student_by_tag_id(scan_data.tag_id)
-
-    if not student:
-        # Return a specific message to the device if student is not found
-        # The ESP32 firmware should handle this 404 response
-        raise HTTPException(status_code=404, detail="Student not found for this tag")
-
-    # Get clearance statuses for the student using the crud function (which uses databases)
-    statuses = await crud.get_clearance_statuses_by_student_id(student["student_id"])
-
-    # Format clearance items and determine overall status
-    clearance_items = []
-    overall_status = True
-
-    for status_item in statuses:
-        clearance_items.append({
-            "department": status_item["department"],
-            "status": status_item["status"],
-            "remarks": status_item["remarks"],
-            "updated_at": status_item["updated_at"].isoformat() # Format datetime to ISO string
-        })
-        if not status_item["status"]:
-            overall_status = False
-
-    # Return the formatted clearance details
-    return {
-        "student_id": student["student_id"],
-        "name": student["name"],
-        "department": student["department"],
-        "clearance_items": clearance_items,
-        "overall_status": overall_status
-    }
-
-# --- Student Management Routes (Likely for Frontend/Admin Use) ---
-
-@app.post("/api/students/", response_model=Student, status_code=status.HTTP_201_CREATED, summary="Create a new student")
-async def create_student(student: StudentCreate):
-    """Creates a new student record using 'databases'."""
-    # Check if student ID already exists using the crud function (which uses databases)
-    existing_student_by_id = await crud.get_student_by_student_id(student.student_id)
-    if existing_student_by_id:
-        raise HTTPException(status_code=400, detail="Student ID already registered")
-
-    # Check if tag ID already exists using the crud function (which uses databases)
-    existing_student_by_tag = await crud.get_student_by_tag_id(student.tag_id)
-    if existing_student_by_tag:
-        raise HTTPException(status_code=400, detail="Tag ID already assigned to another student")
-
-    # Create the student using the crud function (which uses databases)
-    return await crud.create_student(student)
-
-@app.get("/api/students/", response_model=List[Student], summary="Get all students")
-async def get_students():
-    """Retrieves a list of all students using 'databases'."""
-    # Get all students using the crud function (which uses databases)
-    return await crud.get_all_students()
-
-@app.get("/api/students/{student_id}", response_model=ClearanceDetail, summary="Get clearance details for a specific student")
-async def get_student_clearance(student_id: str):
-    """
-    Retrieves the full clearance details for a student based on their student ID
-    using 'databases'. This endpoint is likely used by the frontend/admin interface.
-    """
-    # Get student info using the crud function (which uses databases)
-    student = await crud.get_student_by_student_id(student_id)
-
-    if not student:
-        raise HTTPException(status_code=404, detail="Student not found")
-
-    # Get clearance status using the crud function (which uses databases)
-    statuses = await crud.get_clearance_statuses_by_student_id(student_id)
-
-    # Format clearance items and determine overall status
-    clearance_items = []
-    overall_status = True
-
-    for status_item in statuses:
-        clearance_items.append({
-            "department": status_item["department"],
-            "status": status_item["status"],
-            "remarks": status_item["remarks"],
-            "updated_at": status_item["updated_at"].isoformat() # Format datetime to ISO string
-        })
-        if not status_item["status"]:
-            overall_status = False
+# Include routers
+app.include_router(devices.router)
+app.include_router(students.router)
+app.include_router(clearance.router)
+app.include_router(token.router)
+app.include_router(users.router)
+app.include_router(admin.router)
 
-    # Return the formatted clearance details
-    return {
-        "student_id": student["student_id"],
-        "name": student["name"],
-        "department": student["department"],
-        "clearance_items": clearance_items,
-        "overall_status": overall_status
-    }
-
-# --- Clearance Management Routes (Likely for Frontend/Admin Use) ---
-
-@app.post("/api/clearance/", response_model=ClearanceStatus, summary="Create or update a student's clearance status for a department")
-async def update_clearance_status(status_data: ClearanceStatusCreate):
-    """
-    Creates a new clearance status entry for a student and department,
-    or updates an existing one using 'databases'.
-    """
-    # Check if student exists using the crud function (which uses databases)
-    student = await crud.get_student_by_student_id(status_data.student_id)
-    if not student:
-        raise HTTPException(status_code=404, detail="Student not found")
-
-    # Create or update the clearance status using the crud function (which uses databases)
-    return await crud.create_or_update_clearance_status(status_data)
-
-
-# --- Root Endpoint (Optional) ---
-@app.get("/", summary="Root endpoint")
+# Root endpoint
+@app.get("/", summary="Root endpoint", tags=["Default"])
 async def read_root():
     """Basic root endpoint to confirm the API is running."""
     return {"message": "Undergraduate Clearance System API is running"}
 
 
-# --- Run the FastAPI app ---
+@app.get("/version", summary="API Version Information", tags=["System"])
+async def get_version():
+    """Get detailed API version information."""
+    return {
+        "api_version": "2.0.0",
+        "last_updated": "2025-06-07",
+        "features": [
+            "RFID Authentication",
+            "Multi-Department Clearance",
+            "Device Management",
+            "Real-Time Tracking",
+            "Comprehensive Logging"
+        ],
+        "supported_authentication": [
+            "JWT Tokens",
+            "RFID Tags",
+            "Device API Keys"
+        ]
+    }
+
+# Health check endpoints
+@app.get("/health", summary="Health Check", tags=["System"])
+async def health_check():
+    """Comprehensive health check endpoint."""
+    health_status = {
+            "status": "healthy",
+            "timestamp": datetime.utcnow().isoformat(),
+            "version": "2.0.0",
+            "uptime": "calculated_if_needed"
+        }
+        
+    status_code = 200
+    return JSONResponse(
+            status_code=status_code,
+            content=health_status
+        )
+    
+# Run the FastAPI app using Uvicorn
 if __name__ == "__main__":
-    # Use uvicorn to run the FastAPI application
     uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)

src/models.py

@@ -9,9 +9,7 @@ import os
 
 Base = declarative_base()
 
-JWT_SECRET_KEY = os.getenv("JWT_SECRET_KEY", "your-default-secret-key-for-dev-only-CHANGE-ME")
-if JWT_SECRET_KEY == "your-default-secret-key-for-dev-only-CHANGE-ME":
-    print("WARNING: Using default JWT_SECRET_KEY. Please set a strong JWT_SECRET_KEY environment variable for production.")
+JWT_SECRET_KEY = os.getenv("JWT_SECRET_KEY")
 
 # Enums - Values must EXACTLY match the labels in the PostgreSQL ENUM types, case-sensitively.
 class UserRole(str, enum.Enum):