Update models.py

models.py

@@ -1,195 +1,195 @@
-from flask_sqlalchemy import SQLAlchemy
-from datetime import datetime
-import json
-from werkzeug.security import generate_password_hash, check_password_hash
-
-db = SQLAlchemy()
-
-class User(db.Model):
-    """User model for authentication - supports both students and lecturers"""
-    __tablename__ = 'users'
-    
-    id = db.Column(db.Integer, primary_key=True)
-    matric_no = db.Column(db.String(50), unique=True, nullable=False)  # A/B for students, L for lecturers
-    name = db.Column(db.String(100), nullable=False)
-    email = db.Column(db.String(100), unique=True)
-    password_hash = db.Column(db.String(255), nullable=False)
-    role = db.Column(db.String(20), nullable=False)  # 'student' or 'lecturer'
-    is_active = db.Column(db.Boolean, default=True)
-    created_at = db.Column(db.DateTime, default=datetime.utcnow)
-    
-    def set_password(self, password):
-        """Hash and set password"""
-        self.password_hash = generate_password_hash(password)
-    
-    def check_password(self, password):
-        """Verify password"""
-        return check_password_hash(self.password_hash, password)
-    
-    @staticmethod
-    def validate_matric_no(matric_no, role):
-        """Validate matric number format based on role"""
-        if not matric_no:
-            return False, "Matric number is required"
-        
-        matric_no = matric_no.upper().strip()
-        
-        if role == 'student':
-            # Students must start with A or B
-            if not (matric_no.startswith('A') or matric_no.startswith('B')):
-                return False, "Student matric number must start with 'A' or 'B'"
-        elif role == 'lecturer':
-            # Lecturers must start with L
-            if not matric_no.startswith('L'):
-                return False, "Lecturer matric number must start with 'L'"
-        else:
-            return False, "Invalid role"
-        
-        return True, None
-    
-    def to_dict(self):
-        return {
-            'id': self.id,
-            'matric_no': self.matric_no,
-            'name': self.name,
-            'email': self.email,
-            'role': self.role,
-            'is_active': self.is_active,
-            'created_at': self.created_at.isoformat() if self.created_at else None
-        }
-
-
-class Student(db.Model):
-    """Student model - stores student information and face encodings"""
-    __tablename__ = 'students'
-    
-    id = db.Column(db.Integer, primary_key=True)
-    user_id = db.Column(db.Integer, db.ForeignKey('users.id'), unique=True)  # Link to User
-    student_id = db.Column(db.String(50), unique=True, nullable=False)
-    name = db.Column(db.String(100), nullable=False)
-    email = db.Column(db.String(100), unique=True)
-    face_encoding = db.Column(db.Text)  # Stored as JSON string
-    registered_at = db.Column(db.DateTime, default=datetime.utcnow)
-    is_active = db.Column(db.Boolean, default=True)
-    
-    # Relationships
-    attendance_records = db.relationship('AttendanceRecord', backref='student', lazy=True)
-    user = db.relationship('User', backref='student_profile', uselist=False)
-    
-    def get_face_encoding(self):
-        """Deserialize face encoding from JSON"""
-        if self.face_encoding:
-            return json.loads(self.face_encoding)
-        return None
-    
-    def set_face_encoding(self, encoding):
-        """Serialize face encoding to JSON"""
-        if encoding is not None:
-            self.face_encoding = json.dumps(encoding.tolist())
-    
-    def to_dict(self):
-        return {
-            'id': self.id,
-            'student_id': self.student_id,
-            'name': self.name,
-            'email': self.email,
-            'registered_at': self.registered_at.isoformat() if self.registered_at else None,
-            'is_active': self.is_active
-        }
-
-
-class Classroom(db.Model):
-    """Classroom model - stores classroom locations with GPS coordinates"""
-    __tablename__ = 'classrooms'
-    
-    id = db.Column(db.Integer, primary_key=True)
-    name = db.Column(db.String(100), nullable=False)
-    building = db.Column(db.String(100))
-    latitude = db.Column(db.Float, nullable=False)
-    longitude = db.Column(db.Float, nullable=False)
-    radius_meters = db.Column(db.Integer, default=50)  # Geofencing radius
-    
-    # Relationships
-    sessions = db.relationship('AttendanceSession', backref='classroom', lazy=True)
-    
-    def to_dict(self):
-        return {
-            'id': self.id,
-            'name': self.name,
-            'building': self.building,
-            'latitude': self.latitude,
-            'longitude': self.longitude,
-            'radius_meters': self.radius_meters
-        }
-
-
-class AttendanceSession(db.Model):
-    """Attendance session - represents a class session with auto-refresh codes"""
-    __tablename__ = 'attendance_sessions'
-    
-    id = db.Column(db.Integer, primary_key=True)
-    course_name = db.Column(db.String(100), nullable=False)
-    classroom_id = db.Column(db.Integer, db.ForeignKey('classrooms.id'), nullable=False)
-    lecturer_name = db.Column(db.String(100), nullable=False)
-    
-    # Session timing
-    start_time = db.Column(db.DateTime, default=datetime.utcnow)
-    end_time = db.Column(db.DateTime)
-    is_active = db.Column(db.Boolean, default=True)
-    
-    # Auto-refresh attendance code
-    current_code = db.Column(db.String(10))
-    code_generated_at = db.Column(db.DateTime)
-    
-    # Relationships
-    attendance_records = db.relationship('AttendanceRecord', backref='session', lazy=True)
-    
-    def to_dict(self):
-        return {
-            'id': self.id,
-            'course_name': self.course_name,
-            'classroom_id': self.classroom_id,
-            'classroom': self.classroom.to_dict() if self.classroom else None,
-            'lecturer_name': self.lecturer_name,
-            'start_time': self.start_time.isoformat() if self.start_time else None,
-            'end_time': self.end_time.isoformat() if self.end_time else None,
-            'is_active': self.is_active,
-            'current_code': self.current_code,
-            'code_generated_at': self.code_generated_at.isoformat() if self.code_generated_at else None
-        }
-
-
-class AttendanceRecord(db.Model):
-    """Attendance record - individual student attendance for a session"""
-    __tablename__ = 'attendance_records'
-    
-    id = db.Column(db.Integer, primary_key=True)
-    session_id = db.Column(db.Integer, db.ForeignKey('attendance_sessions.id'), nullable=False)
-    student_id = db.Column(db.Integer, db.ForeignKey('students.id'), nullable=False)
-    
-    # Verification details
-    marked_at = db.Column(db.DateTime, default=datetime.utcnow)
-    face_verified = db.Column(db.Boolean, default=False)
-    location_verified = db.Column(db.Boolean, default=False)
-    code_verified = db.Column(db.Boolean, default=False)
-    
-    # Location data
-    student_latitude = db.Column(db.Float)
-    student_longitude = db.Column(db.Float)
-    distance_from_classroom = db.Column(db.Float)  # In meters
-    
-    # Status
-    status = db.Column(db.String(20), default='present')  # present, late, absent
-    
-    def to_dict(self):
-        return {
-            'id': self.id,
-            'session_id': self.session_id,
-            'student': self.student.to_dict() if self.student else None,
-            'marked_at': self.marked_at.isoformat() if self.marked_at else None,
-            'face_verified': self.face_verified,
-            'location_verified': self.location_verified,
-            'code_verified': self.code_verified,
-            'distance_from_classroom': self.distance_from_classroom,
-            'status': self.status
-        }
+from flask_sqlalchemy import SQLAlchemy
+from datetime import datetime
+import json
+from werkzeug.security import generate_password_hash, check_password_hash
+
+db = SQLAlchemy()
+
+class User(db.Model):
+    """User model for authentication - supports both students and lecturers"""
+    __tablename__ = 'users'
+    
+    id = db.Column(db.Integer, primary_key=True)
+    matric_no = db.Column(db.String(50), unique=True, nullable=False)  # A/B for students, L for lecturers
+    name = db.Column(db.String(100), nullable=False)
+    email = db.Column(db.String(100), unique=True)
+    password_hash = db.Column(db.String(255), nullable=False)
+    role = db.Column(db.String(20), nullable=False)  # 'student' or 'lecturer'
+    is_active = db.Column(db.Boolean, default=True)
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)
+    
+    def set_password(self, password):
+        """Hash and set password"""
+        self.password_hash = generate_password_hash(password)
+    
+    def check_password(self, password):
+        """Verify password"""
+        return check_password_hash(self.password_hash, password)
+    
+    @staticmethod
+    def validate_matric_no(matric_no, role):
+        """Validate matric number format based on role"""
+        if not matric_no:
+            return False, "Matric number is required"
+        
+        matric_no = matric_no.upper().strip()
+        
+        if role == 'student':
+            # Students must start with A or B
+            if not (matric_no.startswith('A') or matric_no.startswith('B')):
+                return False, "Student matric number must start with 'A' or 'B'"
+        elif role == 'lecturer':
+            # Lecturers must start with L
+            if not matric_no.startswith('L'):
+                return False, "Lecturer matric number must start with 'L'"
+        else:
+            return False, "Invalid role"
+        
+        return True, None
+    
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'matric_no': self.matric_no,
+            'name': self.name,
+            'email': self.email,
+            'role': self.role,
+            'is_active': self.is_active,
+            'created_at': self.created_at.isoformat() + 'Z' if self.created_at else None
+        }
+
+
+class Student(db.Model):
+    """Student model - stores student information and face encodings"""
+    __tablename__ = 'students'
+    
+    id = db.Column(db.Integer, primary_key=True)
+    user_id = db.Column(db.Integer, db.ForeignKey('users.id'), unique=True)  # Link to User
+    student_id = db.Column(db.String(50), unique=True, nullable=False)
+    name = db.Column(db.String(100), nullable=False)
+    email = db.Column(db.String(100), unique=True)
+    face_encoding = db.Column(db.Text)  # Stored as JSON string
+    registered_at = db.Column(db.DateTime, default=datetime.utcnow)
+    is_active = db.Column(db.Boolean, default=True)
+    
+    # Relationships
+    attendance_records = db.relationship('AttendanceRecord', backref='student', lazy=True)
+    user = db.relationship('User', backref='student_profile', uselist=False)
+    
+    def get_face_encoding(self):
+        """Deserialize face encoding from JSON"""
+        if self.face_encoding:
+            return json.loads(self.face_encoding)
+        return None
+    
+    def set_face_encoding(self, encoding):
+        """Serialize face encoding to JSON"""
+        if encoding is not None:
+            self.face_encoding = json.dumps(encoding.tolist())
+    
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'student_id': self.student_id,
+            'name': self.name,
+            'email': self.email,
+            'registered_at': self.registered_at.isoformat() + 'Z' if self.registered_at else None,
+            'is_active': self.is_active
+        }
+
+
+class Classroom(db.Model):
+    """Classroom model - stores classroom locations with GPS coordinates"""
+    __tablename__ = 'classrooms'
+    
+    id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String(100), nullable=False)
+    building = db.Column(db.String(100))
+    latitude = db.Column(db.Float, nullable=False)
+    longitude = db.Column(db.Float, nullable=False)
+    radius_meters = db.Column(db.Integer, default=50)  # Geofencing radius
+    
+    # Relationships
+    sessions = db.relationship('AttendanceSession', backref='classroom', lazy=True)
+    
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'name': self.name,
+            'building': self.building,
+            'latitude': self.latitude,
+            'longitude': self.longitude,
+            'radius_meters': self.radius_meters
+        }
+
+
+class AttendanceSession(db.Model):
+    """Attendance session - represents a class session with auto-refresh codes"""
+    __tablename__ = 'attendance_sessions'
+    
+    id = db.Column(db.Integer, primary_key=True)
+    course_name = db.Column(db.String(100), nullable=False)
+    classroom_id = db.Column(db.Integer, db.ForeignKey('classrooms.id'), nullable=False)
+    lecturer_name = db.Column(db.String(100), nullable=False)
+    
+    # Session timing
+    start_time = db.Column(db.DateTime, default=datetime.utcnow)
+    end_time = db.Column(db.DateTime)
+    is_active = db.Column(db.Boolean, default=True)
+    
+    # Auto-refresh attendance code
+    current_code = db.Column(db.String(10))
+    code_generated_at = db.Column(db.DateTime)
+    
+    # Relationships
+    attendance_records = db.relationship('AttendanceRecord', backref='session', lazy=True)
+    
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'course_name': self.course_name,
+            'classroom_id': self.classroom_id,
+            'classroom': self.classroom.to_dict() if self.classroom else None,
+            'lecturer_name': self.lecturer_name,
+            'start_time': self.start_time.isoformat() + 'Z' if self.start_time else None,
+            'end_time': self.end_time.isoformat() + 'Z' if self.end_time else None,
+            'is_active': self.is_active,
+            'current_code': self.current_code,
+            'code_generated_at': self.code_generated_at.isoformat() + 'Z' if self.code_generated_at else None
+        }
+
+
+class AttendanceRecord(db.Model):
+    """Attendance record - individual student attendance for a session"""
+    __tablename__ = 'attendance_records'
+    
+    id = db.Column(db.Integer, primary_key=True)
+    session_id = db.Column(db.Integer, db.ForeignKey('attendance_sessions.id'), nullable=False)
+    student_id = db.Column(db.Integer, db.ForeignKey('students.id'), nullable=False)
+    
+    # Verification details
+    marked_at = db.Column(db.DateTime, default=datetime.utcnow)
+    face_verified = db.Column(db.Boolean, default=False)
+    location_verified = db.Column(db.Boolean, default=False)
+    code_verified = db.Column(db.Boolean, default=False)
+    
+    # Location data
+    student_latitude = db.Column(db.Float)
+    student_longitude = db.Column(db.Float)
+    distance_from_classroom = db.Column(db.Float)  # In meters
+    
+    # Status
+    status = db.Column(db.String(20), default='present')  # present, late, absent
+    
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'session_id': self.session_id,
+            'student': self.student.to_dict() if self.student else None,
+            'marked_at': self.marked_at.isoformat() + 'Z' if self.marked_at else None,
+            'face_verified': self.face_verified,
+            'location_verified': self.location_verified,
+            'code_verified': self.code_verified,
+            'distance_from_classroom': self.distance_from_classroom,
+            'status': self.status
+        }