WIP: Fixing bug

src/database.py

@@ -1,99 +1,93 @@
+"""
+This module handles database connection, session management, table creation,
+and initial data seeding.
+"""
 import sqlalchemy
-import os
-from dotenv import load_dotenv
+from sqlalchemy.orm import sessionmaker, Session as SQLAlchemySessionType
 from datetime import datetime
 
+# Import the centralized settings object
+from src.config import settings 
+
 # Import Enums, Base, and specific ORM models needed for initialization
 from src.models import (
-    UserRole, ClearanceDepartment, ClearanceStatusEnum, Base, TargetUserType,
-    Student as StudentORM, # Alias to avoid confusion if Student Pydantic model is also imported
-    ClearanceStatus as ClearanceStatusORM, # Alias for ORM model
-    User as UserORM,
-    Device as DeviceORM
+    Base,
+    ClearanceDepartment,
+    ClearanceStatusEnum,
+    Student as StudentORM,
+    ClearanceStatus as ClearanceStatusORM
 )
-from sqlalchemy.orm import Session as SQLAlchemySessionType
-
-# Load environment variables from a .env file
-load_dotenv()
 
-# Database setup
-DATABASE_URL = os.getenv("POSTGRES_URI") or os.getenv("DATABASE_URL")
+# --- Database Engine Setup ---
+# Create the SQLAlchemy engine using the URI from our secure settings.
+engine = sqlalchemy.create_engine(
+    settings.POSTGRES_URI,
+    pool_pre_ping=True  # Helps prevent errors from stale connections
+)
 
-# Check if DATABASE_URL is set
-if not DATABASE_URL:
-    raise ValueError("DATABASE_URL environment variable not set!")
+# --- Session Management ---
+# Create a configured "Session" class. This is our session factory.
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
 
-# SQLAlchemy engine
-engine = sqlalchemy.create_engine(DATABASE_URL)
+def get_db():
+    """
+    FastAPI dependency that creates and yields a new database session
+    for each request, and ensures it's closed afterward.
+    """
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
 
-metadata = Base.metadata
+# --- Database Initialization Functions ---
 
-def create_db_tables():
-    """Creates database tables based on SQLAlchemy ORM metadata."""
+def create_db_and_tables():
+    """
+    Creates all database tables defined in `src/models.py` if they do not exist.
+    This function should be called once on application startup.
+    """
     try:
         print("Attempting to create database tables (if they don't exist)...")
-        metadata.create_all(bind=engine) # Use Base.metadata from models.py
-        print("Database tables creation attempt finished.")
+        Base.metadata.create_all(bind=engine)
+        print("Database tables are ready.")
     except Exception as e:
-        print(f"Error during database table creation: {e}")
-        print("Please ensure your database is accessible and the connection string is correct.")
+        print(f"FATAL: Error during database table creation: {e}")
+        print("Please ensure your database is accessible and the POSTGRES_URI is correct.")
+        # In a real production app, you might want to exit here if the DB is critical
+        raise
 
-
-# Initialize default clearance statuses for new students (Synchronous ORM version)
-def initialize_student_clearance_statuses_orm(db: SQLAlchemySessionType, student_id_str: str):
+def initialize_student_clearance_statuses(db: SQLAlchemySessionType, student_id_str: str):
     """
-    Creates default clearance status entries for all departments for a new student.
-    Uses SQLAlchemy ORM session.
+    Creates default 'NOT_COMPLETED' clearance status entries for all required
+    departments for a newly created student. This ensures every student's
+    clearance record is complete from the start.
     """
-    created_rows_info = []
     student = db.query(StudentORM).filter(StudentORM.student_id == student_id_str).first()
     if not student:
-        print(f"Warning: Student {student_id_str} not found when trying to initialize clearance statuses.")
+        print(f"Warning: Student '{student_id_str}' not found when trying to initialize clearance statuses.")
         return
 
-    for dept_enum_member in ClearanceDepartment: # Iterate through centralized Enum
-        # Check if status already exists for this student and department
-        existing_status = db.query(ClearanceStatusORM).filter(
+    for dept in ClearanceDepartment:
+        # Check if a status for this department already exists
+        exists = db.query(ClearanceStatusORM).filter(
             ClearanceStatusORM.student_id == student_id_str,
-            ClearanceStatusORM.department == dept_enum_member
+            ClearanceStatusORM.department == dept
         ).first()
 
-        if not existing_status:
+        if not exists:
+            # If it doesn't exist, create the default record
             new_status = ClearanceStatusORM(
                 student_id=student_id_str,
-                department=dept_enum_member,
-                status=ClearanceStatusEnum.NOT_COMPLETED,
-                created_at=datetime.utcnow(),
-                updated_at=datetime.utcnow()
+                department=dept,
+                status=ClearanceStatusEnum.NOT_COMPLETED
             )
             db.add(new_status)
-            created_rows_info.append({"department": dept_enum_member.value, "status": "initialized"})
-        else:
-            created_rows_info.append({"department": dept_enum_member.value, "status": "already_exists"})
     
-    if created_rows_info:
-        try:
-            db.commit()
-            print(f"Committed clearance statuses for student {student_id_str}: {created_rows_info}")
-        except Exception as e:
-            db.rollback()
-            print(f"Error committing clearance statuses for student {student_id_str}: {e}")
-            raise
-    else:
-        print(f"No new clearance statuses to initialize or commit for student {student_id_str}.")
-
-
-from sqlalchemy.orm import sessionmaker
-
-SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
-
-def get_db():
-    """
-    FastAPI dependency to get a SQLAlchemy database session.
-    Ensures the session is closed after the request.
-    """
-    db = SessionLocal()
+    # Commit all the new statuses at once
     try:
-        yield db
-    finally:
-        db.close()
+        db.commit()
+    except Exception as e:
+        print(f"Error committing initial clearance statuses for student {student_id_str}: {e}")
+        db.rollback()
+        raise

src/models.py

@@ -120,6 +120,12 @@ class ClearanceStatusEnum(str, Enum):
     COMPLETED = "COMPLETED"
     REJECTED = "REJECTED"
 
+class ClearanceDepartment(str, Enum):
+    DEPARTMENT = "DEPARTMENT"
+    BURSARY = "BURSARY"
+    LIBRARY = "LIBRARY"
+    ALUMNI = "ALUMNI"
+
 class OverallClearanceStatusEnum(str, Enum):
     PENDING = "PENDING"
     COMPLETED = "COMPLETED"