FEAT:Updated Main.py file

main.py

@@ -1,109 +1,100 @@
 from fastapi import FastAPI
 from fastapi.responses import JSONResponse
 from datetime import datetime
-from fastapi.middleware.cors import CORSMiddleware # Keep if CORS is needed
+from fastapi.middleware.cors import CORSMiddleware
 import uvicorn
 from contextlib import asynccontextmanager
 
-
-from src.database import create_db_and_tables, get_db 
+# Correctly import the database table creation function
+from src.database import create_db_and_tables
+# Import all the necessary routers for the application
 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...")
+    """
+    Handles application startup and shutdown events.
+    - On startup, it ensures that all necessary database tables are created.
+    - On shutdown, it can be used for cleanup tasks.
+    """
+    print("Application startup: Initializing...")
+    # Correctly call the function to create database tables
     create_db_and_tables()
-    print("Database tables checked/created.")
+    print("Application startup: Database tables checked/created.")
     yield
-    print("Application shutdown...")
+    print("Application shutdown: Cleaning up.")
 
 
-# FastAPI app instance
+# Initialize the FastAPI application instance with metadata for documentation
 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
+    * **RFID Authentication**: Students and staff use RFID tags for quick access.
+    * **Multi-Department Clearance**: Support for Library, Bursary, Alumni, and Departmental clearances.
+    * **Device Management**: Secure management of ESP32 RFID readers via API keys.
+    * **Role-Based Access Control**: Differentiated permissions for Students, Staff, and Administrators.
+    * **Real-Time Tracking**: Live updates on clearance status with 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
+    * **JWT Tokens**: For web interfaces and administrative API access.
+    * **RFID Tags**: For quick, on-premise authentication of students and staff.
+    * **Device API Keys**: For secure communication with hardware like ESP32 RFID readers.
     """,
-    version="2.0.0",
+    version="2.0.1",
     lifespan=lifespan,
     docs_url="/docs",
     redoc_url="/redoc",
     openapi_url="/openapi.json",
-    )
+)
 
+# Configure CORS (Cross-Origin Resource Sharing) middleware
+# This allows the frontend (like the Streamlit app) to communicate with the API
 app.add_middleware(
     CORSMiddleware,
-    allow_origins= ['*'],
+    allow_origins=['*'],  # Allows all origins, consider restricting in production
     allow_credentials=True,
-    allow_methods=["*"], # Allows all methods
-    allow_headers=["*"], # Allows all headers
+    allow_methods=["*"],  # Allows all HTTP methods
+    allow_headers=["*"],  # Allows all headers
 )
 
-# Include routers
+# Include all the API routers into the main application
+# Each router handles a specific domain of the application (e.g., students, devices)
+print("Including API routers...")
+app.include_router(admin.router)
+app.include_router(clearance.router)
 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"}
+print("All API routers included.")
 
+# --- Default and System Endpoints ---
 
-@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"
-        ]
-    }
+@app.get("/", summary="Root Endpoint", tags=["System"])
+async def read_root():
+    """
+    A simple root endpoint to confirm that the API is running and accessible.
+    """
+    return {"message": "Welcome to the Undergraduate Clearance System API. See /docs for details."}
 
-# Health check endpoints
 @app.get("/health", summary="Health Check", tags=["System"])
 async def health_check():
-    """Comprehensive health check endpoint."""
+    """
+    Provides a health status check for the API, useful for monitoring and uptime checks.
+    """
     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
+        "status": "healthy",
+        "timestamp": datetime.utcnow().isoformat(),
+        "version": app.version,
+    }
+    return JSONResponse(status_code=200, content=health_status)
+
+# This block allows the script to be run directly using `python main.py`
+# It will start the Uvicorn server, which is ideal for development.
 if __name__ == "__main__":
+    print("Starting Uvicorn server for development...")
     uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)
+