Upload 30 files

.gitignore

@@ -0,0 +1,65 @@
+# .gitignore for Attendr Smart Attendance System
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+ENV/
+env/
+
+# Database
+*.db
+*.sqlite
+*.sqlite3
+attendr.db
+
+# Uploads and User Data
+uploads/
+face_encodings/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Environment variables
+.env
+.env.local
+
+# Logs
+*.log
+
+# Flask
+instance/
+.webassets-cache
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/

README.md

@@ -1,10 +1,338 @@
----
-title: Attender
-emoji: 🦀
-colorFrom: red
-colorTo: yellow
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Attendr - Smart Attendance System 🎓
+
+An AI-powered smart attendance system for Universiti Teknologi Malaysia (UTM) that combines **facial recognition**, **geolocation verification**, and **auto-refresh attendance codes** to eliminate proxy attendance and streamline the attendance process.
+
+![Python](https://img.shields.io/badge/Python-3.8+-blue.svg)
+![Flask](https://img.shields.io/badge/Flask-3.0-green.svg)
+![License](https://img.shields.io/badge/License-MIT-yellow.svg)
+
+## ✨ Features
+
+### For Students
+- 🎭 **Biometric Face Recognition** - Secure identity verification using AI
+- 📍 **GPS Location Validation** - Confirms physical presence in classroom
+- 🔐 **Auto-Refresh Codes** - Time-limited codes prevent sharing
+- ⚡ **Real-time Feedback** - Instant attendance confirmation
+- 📱 **Mobile Friendly** - Works on smartphones and tablets
+
+### For Lecturers
+- 🎯 **One-Click Session Creation** - Quick setup for any class
+- 🔄 **Auto-Refreshing Codes** - New code every 2 minutes
+- 📊 **Real-time Monitoring** - Live attendance updates
+- 📥 **Export Reports** - Download CSV for record-keeping
+- 📈 **Attendance Analytics** - View statistics at a glance
+
+### Security Features
+- ✅ Prevents proxy attendance through face + location verification
+- ✅ Time-limited codes expire automatically
+- ✅ All verifications logged with timestamps
+- ✅ Distance tracking from classroom center
+
+## 🧠 AI Logic & Knowledge Representation
+
+Attendr implements **5 Knowledge Representation (KR) rules** using First-Order Logic:
+
+1. **Face Recognition**: `∀x ((CapturedFace(x) ∧ MatchStored(x)) → FaceMatch(x))`
+2. **Location Verification**: `∀x[(Student(x) ∧ IsWithinAllowedArea(x)) → VerifiedLocation(x)]`
+3. **Device Readiness**: `∀d ((CameraOn(d) ∧ GPSOn(d)) → StartVerification(d))`
+4. **Attendance Validation**: `∀x ((FaceMatch(x) ∧ LocationValid(x)) → GrantCodeAccess(x))`
+5. **Code Confirmation**: `∀x ((ValidCodeEntry(User,x) ∧ WithinCycle(Code,x)) → MarkPresent(System,x))`
+
+## 🚀 Installation
+
+### Prerequisites
+- Python 3.8 or higher
+- Webcam for face capture
+- GPS-enabled device (or browser location services)
+
+### Step 1: Clone Repository
+```bash
+git clone <repository-url>
+cd smartAttandence
+```
+
+### Step 2: Install Dependencies
+
+#### Windows (Recommended Method)
+```powershell
+# Install Visual C++ Build Tools first (required for dlib)
+# Download from: https://visualstudio.microsoft.com/visual-cpp-build-tools/
+
+# Create virtual environment
+python -m venv venv
+venv\Scripts\activate
+
+# Install dependencies
+pip install -r requirements.txt
+```
+
+#### Alternative: Use Pre-compiled Wheels
+If you encounter issues installing `face_recognition`, use pre-compiled wheels:
+```powershell
+pip install https://github.com/jloh02/dlib/releases/download/v19.22/dlib-19.22.99-cp38-cp38-win_amd64.whl
+pip install face_recognition
+```
+
+### Step 3: Initialize Database
+```bash
+python init_db.py
+```
+
+This creates:
+- SQLite database with all tables
+- Sample UTM classrooms (N28, V01, C22)
+- Test student account
+
+### Step 4: Run Application
+```bash
+python app.py
+```
+
+The application will be available at: **http://localhost:5000**
+
+## 📖 Usage Guide
+
+### For Students
+
+1. **Register Your Face**
+   - Visit `/register`
+   - Enter Student ID and Name
+   - Capture your face using webcam
+   - System stores your biometric encoding
+
+2. **Mark Attendance**
+   - Visit `/student`
+   - Enter Student ID and select active session
+   - Enable camera and GPS permissions
+   - System verifies your face and location
+   - Enter attendance code displayed by lecturer
+   - Attendance marked instantly!
+
+### For Lecturers
+
+1. **Create Session**
+   - Visit `/lecturer`
+   - Enter course name and your name
+   - Select classroom location
+   - Click "Create Session"
+
+2. **Display Code**
+   - Large attendance code appears on screen
+   - Code auto-refreshes every 2 minutes
+   - Show this code to students in class
+
+3. **Monitor Attendance**
+   - View real-time attendance list
+   - See verification details (distance, time)
+   - Export CSV report when done
+
+## 🗂️ Project Structure
+
+```
+smartAttandence/
+├── app.py                          # Main Flask application
+├── config.py                       # Configuration settings
+├── models.py                       # Database models
+├── init_db.py                      # Database initialization
+├── requirements.txt                # Python dependencies
+│
+├── face_recognition_module.py      # Face recognition logic (KR Rule #1)
+├── geolocation_module.py           # GPS verification (KR Rule #2)
+├── attendance_code_module.py       # Auto-refresh codes (KR Rule #5)
+├── utils.py                        # Helper functions
+│
+├── static/
+│   ├── css/
+│   │   └── style.css              # Premium design system
+│   └── js/
+│       ├── student.js             # Student portal logic
+│       └── lecturer.js            # Lecturer dashboard logic
+│
+└── templates/
+    ├── index.html                 # Landing page
+    ├── student.html               # Student portal
+    ├── lecturer.html              # Lecturer dashboard
+    └── register.html              # Face registration
+```
+
+## 🔧 Configuration
+
+Edit `config.py` to customize:
+
+```python
+# Face recognition settings
+FACE_RECOGNITION_TOLERANCE = 0.6    # Lower = more strict (0.4-0.6 recommended)
+
+# Geolocation settings
+GEOLOCATION_RADIUS_METERS = 50      # Classroom detection radius
+
+# Attendance code settings
+CODE_REFRESH_INTERVAL_SECONDS = 120 # Code refresh interval (2 minutes)
+CODE_LENGTH = 6                     # Length of attendance code
+```
+
+## 🌐 API Endpoints
+
+### Student Endpoints
+- `POST /api/register_face` - Register student face encoding
+- `POST /api/verify_face` - Verify face against stored encoding
+- `POST /api/verify_location` - Validate GPS location
+- `POST /api/mark_attendance` - Mark attendance with code
+
+### Lecturer Endpoints
+- `POST /api/create_session` - Create attendance session
+- `GET /api/get_session/<id>` - Get session details with current code
+- `GET /api/get_attendance/<id>` - Get attendance records
+- `POST /api/end_session/<id>` - End session
+
+### General Endpoints
+- `GET /api/get_active_sessions` - List all active sessions
+- `GET /api/classrooms` - Get all classrooms
+
+## 🧪 Testing
+
+### Manual Testing Checklist
+
+**Face Recognition:**
+- [ ] Register new student face
+- [ ] Verify with same person (should succeed)
+- [ ] Verify with different person (should fail)
+- [ ] Test with poor lighting
+- [ ] Test with glasses/mask
+
+**Geolocation:**
+- [ ] Mark attendance from inside classroom (should succeed)
+- [ ] Mark attendance from outside radius (should fail)
+- [ ] Verify distance calculation accuracy
+
+**Auto-Refresh Codes:**
+- [ ] Code refreshes every 2 minutes
+- [ ] Expired code rejected
+- [ ] Valid code accepted
+- [ ] Code sharing prevented
+
+**End-to-End Flow:**
+- [ ] Complete student registration
+- [ ] Lecturer creates session
+- [ ] Student marks attendance successfully
+- [ ] Attendance appears in real-time
+- [ ] Export CSV works
+
+## 🐛 Troubleshooting
+
+### Face Recognition Issues
+
+**Problem:** `dlib` installation fails on Windows
+**Solution:** 
+1. Install Visual C++ Build Tools
+2. Or use pre-compiled wheel: `pip install dlib-19.22.99-cp38-cp38-win_amd64.whl`
+
+**Problem:** "No face detected"
+**Solution:**
+- Ensure good lighting
+- Face camera directly
+- Remove glasses/mask if possible
+- Move closer to camera
+
+### GPS Issues
+
+**Problem:** Location permission denied
+**Solution:**
+- Enable location services in browser settings
+- Use HTTPS (required for geolocation API)
+- Check device GPS is enabled
+
+**Problem:** "Location unavailable"
+**Solution:**
+- Ensure GPS is enabled on device
+- Try outdoors for better signal
+- Check browser location permissions
+
+### Code Validation Issues
+
+**Problem:** "Code has expired"
+**Solution:**
+- Enter code within 2-minute window
+- Check lecturer's displayed code
+- Ensure system clocks are synchronized
+
+## 📊 Database Schema
+
+### Students Table
+- `id` - Primary key
+- `student_id` - Unique student identifier
+- `name` - Student name
+- `email` - Email address
+- `face_encoding` - Biometric data (JSON)
+- `registered_at` - Registration timestamp
+
+### Classrooms Table
+- `id` - Primary key
+- `name` - Classroom name (e.g., N28-01-01)
+- `building` - Building name
+- `latitude` - GPS latitude
+- `longitude` - GPS longitude
+- `radius_meters` - Geofencing radius
+
+### AttendanceSessions Table
+- `id` - Primary key
+- `course_name` - Course name
+- `lecturer_name` - Lecturer name
+- `classroom_id` - Foreign key to Classrooms
+- `current_code` - Active attendance code
+- `code_generated_at` - Code generation time
+- `is_active` - Session status
+
+### AttendanceRecords Table
+- `id` - Primary key
+- `session_id` - Foreign key to AttendanceSessions
+- `student_id` - Foreign key to Students
+- `marked_at` - Attendance timestamp
+- `face_verified` - Face verification status
+- `location_verified` - Location verification status
+- `code_verified` - Code verification status
+- `distance_from_classroom` - Distance in meters
+
+## 🎨 Design Philosophy
+
+Attendr features a **premium dark mode design** with:
+- 🌈 Vibrant gradient accents
+- ✨ Glassmorphism effects
+- 🎭 Smooth micro-animations
+- 📱 Fully responsive layout
+- 🎯 Modern typography (Inter + Outfit fonts)
+
+## 🤝 Contributing
+
+Contributions are welcome! Please follow these steps:
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Test thoroughly
+5. Submit a pull request
+
+## 📄 License
+
+This project is licensed under the MIT License.
+
+## 👥 Authors
+
+Developed for Universiti Teknologi Malaysia (UTM) as part of an AI Smart Attendance System project.
+
+## 🙏 Acknowledgments
+
+- **OpenCV** - Computer vision library
+- **face_recognition** - Face recognition library by Adam Geitgey
+- **Flask** - Web framework
+- **UTM** - Project inspiration and requirements
+
+## 📞 Support
+
+For issues or questions:
+1. Check the Troubleshooting section
+2. Review API documentation
+3. Open an issue on GitHub
+
+---
+
+**Made with ❤️ for UTM Students and Lecturers**

_navbar.html

@@ -0,0 +1,49 @@
+<!-- Unified Navigation Bar Component -->
+<!-- Copy this to all pages: index.html, login.html, register.html, student.html, student_history.html, lecturer.html -->
+
+<nav class="navbar">
+    <div class="container navbar-content">
+        <a href="/" class="navbar-brand">✨ Attendr</a>
+        <ul class="navbar-nav">
+            <li><a href="/" class="navbar-link">Home</a></li>
+            {% if current_user %}
+            {% if current_user.role == 'student' %}
+            <li><a href="/student" class="navbar-link">Mark Attendance</a></li>
+            <li><a href="/student/history" class="navbar-link">History</a></li>
+            {% elif current_user.role == 'lecturer' %}
+            <li><a href="/lecturer" class="navbar-link">Dashboard</a></li>
+            {% endif %}
+            <li><span class="navbar-link" style="color: var(--color-primary);">👤 {{ current_user.name }}</span></li>
+            <li><a href="#" onclick="logout()" class="navbar-link">Logout</a></li>
+            {% else %}
+            <li><a href="/login" class="navbar-link">Login</a></li>
+            <li><a href="/register" class="navbar-link">Register</a></li>
+            {% endif %}
+        </ul>
+    </div>
+</nav>
+
+<!-- Logout Script (add to pages that need it) -->
+<script>
+    async function logout() {
+        if (!confirm('Are you sure you want to logout?')) return;
+
+        try {
+            const response = await fetch('/api/auth/logout', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' }
+            });
+
+            const data = await response.json();
+
+            if (data.success) {
+                alert(data.message);
+                window.location.href = '/';
+            } else {
+                alert('Logout failed');
+            }
+        } catch (error) {
+            alert('Logout failed');
+        }
+    }
+</script>

add_home_venue.py

@@ -0,0 +1,67 @@
+"""
+Add Puteri Court Condominium as a test venue for home demo
+Run this script to add your home location to the database
+"""
+
+from app import app, db
+from models import Classroom
+
+def add_puteri_court():
+    """Add Puteri Court Condominium as a test venue"""
+    
+    with app.app_context():
+        print("Adding Puteri Court Condominium as test venue...")
+        
+        # Check if already exists
+        existing = Classroom.query.filter_by(name='PUTERI-COURT').first()
+        
+        if existing:
+            print(f"Puteri Court already exists. Updating coordinates...")
+            # Updated to correct Puteri Court location (Ampang/Pandan Mewah)
+            # Address: Jalan Pandan Mewah, Taman Pandan Mewah, 68000 Kuala Lumpur
+            existing.latitude = 3.128024
+            existing.longitude = 101.765479
+            existing.radius_meters = 1000  # 1km radius for easier testing
+            db.session.commit()
+            print(f"[OK] Updated Puteri Court")
+        else:
+            # Create new venue with correct Puteri Court location
+            puteri_court = Classroom(
+                name='PUTERI-COURT',
+                building='Puteri Court Condominium (Home Demo)',
+                latitude=3.128024,  # Taman Pandan Mewah, Ampang
+                longitude=101.765479,  # Taman Pandan Mewah, Ampang
+                radius_meters=1000  # 1km radius for easier testing
+            )
+            
+            db.session.add(puteri_court)
+            db.session.commit()
+            print(f"[OK] Added Puteri Court Condominium")
+        
+        # Display the venue details
+        venue = Classroom.query.filter_by(name='PUTERI-COURT').first()
+        print("\n" + "="*70)
+        print("Test Venue Added Successfully!")
+        print("="*70)
+        print(f"Venue Code: {venue.name}")
+        print(f"Building: {venue.building}")
+        print(f"Latitude: {venue.latitude}")
+        print(f"Longitude: {venue.longitude}")
+        print(f"Radius: {venue.radius_meters} meters")
+        print("="*70)
+        print("\nIMPORTANT: To get your exact GPS coordinates:")
+        print("1. Open Google Maps on your phone")
+        print("2. Long-press on your location")
+        print("3. Copy the coordinates (e.g., 1.4927, 103.7414)")
+        print("4. Update this script with your actual coordinates")
+        print("5. Run this script again to update")
+        print("\nOr you can update directly in the database:")
+        print(f"UPDATE classrooms SET latitude=YOUR_LAT, longitude=YOUR_LON WHERE name='PUTERI-COURT';")
+        print("="*70)
+        
+        # Show total venues
+        total = Classroom.query.count()
+        print(f"\nTotal venues in database: {total}")
+
+if __name__ == '__main__':
+    add_puteri_court()

add_utm_venues.py

@@ -0,0 +1,132 @@
+"""
+Add UTM Faculty of Computing Venues to Database
+This script adds all FC classrooms and labs with their GPS coordinates
+"""
+
+from app import app, db
+from models import Classroom
+
+# UTM Skudai approximate coordinates for Faculty of Computing (N28)
+# Base coordinates: 1.5586°N, 103.6376°E
+# Each classroom will have slightly different coordinates
+
+def add_utm_venues():
+    """Add all UTM FC venues to the database"""
+    
+    with app.app_context():
+        print("Adding UTM Faculty of Computing venues...")
+        
+        # Define all venues with their details
+        venues = [
+            # N28 Main Building - Lecture Halls (Bilik Kuliah)
+            {"code": "N28-105-01", "name": "Bilik Kuliah 1 (BK1)", "building": "N28 - Faculty of Computing", "lat": 1.5586, "lon": 103.6376, "capacity": 120},
+            {"code": "N28-116-02", "name": "Bilik Kuliah 2 (BK2)", "building": "N28 - Faculty of Computing", "lat": 1.5587, "lon": 103.6377, "capacity": 120},
+            {"code": "N28-112-02", "name": "Bilik Kuliah 3 (BK3)", "building": "N28 - Faculty of Computing", "lat": 1.5588, "lon": 103.6378, "capacity": 120},
+            {"code": "N28-111-01", "name": "Bilik Kuliah 4 (BK4)", "building": "N28 - Faculty of Computing", "lat": 1.5589, "lon": 103.6379, "capacity": 120},
+            {"code": "N28-106-01", "name": "Bilik Kuliah 5 (BK5)", "building": "N28 - Faculty of Computing", "lat": 1.5590, "lon": 103.6380, "capacity": 60},
+            {"code": "N28-107-01", "name": "Bilik Kuliah 6 (BK6)", "building": "N28 - Faculty of Computing", "lat": 1.5591, "lon": 103.6381, "capacity": 120},
+            {"code": "N28-108-01", "name": "Bilik Kuliah 7 (BK7)", "building": "N28 - Faculty of Computing", "lat": 1.5592, "lon": 103.6382, "capacity": 120},
+            
+            # N28 Level 3 - Special Labs
+            {"code": "N28-351-02", "name": "Active Learning Lab (ALL)", "building": "N28 - Level 3", "lat": 1.5593, "lon": 103.6383, "capacity": 36},
+            {"code": "N28-301-01", "name": "PMO", "building": "N28 - Level 3", "lat": 1.5594, "lon": 103.6384, "capacity": 36},
+            {"code": "N28-301-01B", "name": "Bilik Mesyuarat PMO (BMPMO)", "building": "N28 - Level 3", "lat": 1.5595, "lon": 103.6385, "capacity": 30},
+            
+            # N28A Building - Tutorial Rooms
+            {"code": "N28A-BT1", "name": "Bilik Tutorial 1 (BT1)", "building": "N28A - Tutorial Block", "lat": 1.5596, "lon": 103.6386, "capacity": 24},
+            {"code": "N28A-BT2", "name": "Bilik Tutorial 2 (BT2)", "building": "N28A - Tutorial Block", "lat": 1.5597, "lon": 103.6387, "capacity": 27},
+            {"code": "N28A-BT3", "name": "Bilik Tutorial 3 (BT3)", "building": "N28A - Tutorial Block", "lat": 1.5598, "lon": 103.6388, "capacity": 24},
+            {"code": "N28A-BT4", "name": "Bilik Tutorial 4 (BT4)", "building": "N28A - Tutorial Block", "lat": 1.5599, "lon": 103.6389, "capacity": 40},
+            {"code": "N28A-BK1", "name": "Bilik Kuliah 1 (BK1)", "building": "N28A - Tutorial Block", "lat": 1.5600, "lon": 103.6390, "capacity": 28},
+            {"code": "N28A-BK2", "name": "Bilik Kuliah 2 (BK2)", "building": "N28A - Tutorial Block", "lat": 1.5601, "lon": 103.6391, "capacity": 36},
+            {"code": "N28A-BK5", "name": "Bilik Kuliah 5 (BK5)", "building": "N28A - Tutorial Block", "lat": 1.5602, "lon": 103.6392, "capacity": 28},
+            {"code": "N28A-BK6", "name": "Bilik Kuliah 6 (BK6)", "building": "N28A - Tutorial Block", "lat": 1.5603, "lon": 103.6393, "capacity": 36},
+            
+            # N28 Level 5 - Computer Programming Labs (Makmal Pengaturcaraan Komputer)
+            {"code": "N28-502-01", "name": "Makmal Pengaturcaraan Komputer 1 (MPK 1)", "building": "N28 - Level 5", "lat": 1.5604, "lon": 103.6394, "capacity": 60},
+            {"code": "N28-505-01", "name": "Makmal Pengaturcaraan Komputer 2 (MPK 2)", "building": "N28 - Level 5", "lat": 1.5605, "lon": 103.6395, "capacity": 60},
+            {"code": "N28-506-01", "name": "Makmal Pengaturcaraan Komputer 3 (MPK 3)", "building": "N28 - Level 5", "lat": 1.5606, "lon": 103.6396, "capacity": 60},
+            {"code": "N28-512-01", "name": "Makmal Pengaturcaraan Komputer 4 (MPK 4)", "building": "N28 - Level 5", "lat": 1.5607, "lon": 103.6397, "capacity": 60},
+            {"code": "N28-516-01", "name": "Makmal Pengaturcaraan Komputer 5 (MPK 5)", "building": "N28 - Level 5", "lat": 1.5608, "lon": 103.6398, "capacity": 25},
+            {"code": "N28-517-02", "name": "Makmal Pengaturcaraan Komputer 6 (MPK 6)", "building": "N28 - Level 5", "lat": 1.5609, "lon": 103.6399, "capacity": 60},
+            {"code": "N28-518-02", "name": "Makmal Pengaturcaraan Komputer 7 (MPK 7)", "building": "N28 - Level 5", "lat": 1.5610, "lon": 103.6400, "capacity": 60},
+            {"code": "N28-524-02", "name": "Makmal Pengaturcaraan Komputer 8 (MPK 8)", "building": "N28 - Level 5", "lat": 1.5611, "lon": 103.6401, "capacity": 60},
+            {"code": "N28-525-01", "name": "Makmal Pengaturcaraan Komputer 9 (MPK 9)", "building": "N28 - Level 5", "lat": 1.5612, "lon": 103.6402, "capacity": 60},
+            {"code": "N28-527-02", "name": "Makmal Pengaturcaraan Komputer 10 (MPK 10)", "building": "N28 - Level 5", "lat": 1.5613, "lon": 103.6403, "capacity": 60},
+            
+            # N28A Level 2 - Teaching Labs
+            {"code": "N28A-02-33", "name": "Makmal Pengajaran 1 (MP1-N28A)", "building": "N28A - Level 2", "lat": 1.5614, "lon": 103.6404, "capacity": 48},
+            {"code": "N28A-02-34", "name": "Makmal Pengajaran 2 (MP2-N28A)", "building": "N28A - Level 2", "lat": 1.5615, "lon": 103.6405, "capacity": 48},
+            
+            # N28 Level 2 - Specialized Labs
+            {"code": "N28-223-02", "name": "Computer Graphic & Multimedia Teaching Lab (CGMTL)", "building": "N28 - Level 2", "lat": 1.5616, "lon": 103.6406, "capacity": 40},
+            {"code": "N28-204-01", "name": "Computer Vision Lab (CVL)", "building": "N28 - Level 2", "lat": 1.5617, "lon": 103.6407, "capacity": 30},
+            {"code": "N28-203-01", "name": "Computer Vision Teaching Lab (CVTL)", "building": "N28 - Level 2", "lat": 1.5618, "lon": 103.6408, "capacity": 30},
+            {"code": "N28-202-01", "name": "Virtual Environment Teaching Lab (VETL)", "building": "N28 - Level 2", "lat": 1.5619, "lon": 103.6409, "capacity": 25},
+            
+            # N28 Level 3 - Research Labs
+            {"code": "N28-330-01", "name": "Computer Security Lab (CSL)", "building": "N28 - Level 3", "lat": 1.5620, "lon": 103.6410, "capacity": 35},
+            {"code": "N28-352-01", "name": "CCNA Teaching Lab (CCNA)", "building": "N28 - Level 3", "lat": 1.5621, "lon": 103.6411, "capacity": 30},
+            {"code": "N28-321-02", "name": "Makmal CASE (MCASE)", "building": "N28 - Level 3", "lat": 1.5622, "lon": 103.6412, "capacity": 28},
+            {"code": "N28-329-01", "name": "Information System Teaching Lab (ISTL)", "building": "N28 - Level 3", "lat": 1.5623, "lon": 103.6413, "capacity": 26},
+            {"code": "N28-350-03", "name": "Data-Analytics Lab (DAL)", "building": "N28 - Level 3", "lat": 1.5624, "lon": 103.6414, "capacity": 23},
+            
+            # N28 Level 4 - Advanced Labs
+            {"code": "N28-422-01", "name": "CCNP Lab (CCNP)", "building": "N28 - Level 4", "lat": 1.5625, "lon": 103.6415, "capacity": 36},
+            {"code": "N28-423-01", "name": "Makmal IDAL (IDAL)", "building": "N28 - Level 4", "lat": 1.5626, "lon": 103.6416, "capacity": 32},
+            
+            # Other Campus Buildings - Large Lecture Halls
+            {"code": "L50-DK3", "name": "Dewan Kuliah 3 (L50-DK3)", "building": "Block L50 - Centre Point", "lat": 1.5580, "lon": 103.6370, "capacity": 250},
+            {"code": "P19-DK4", "name": "Dewan Kuliah 4 (P19-DK4)", "building": "Block P19 - FKE", "lat": 1.5575, "lon": 103.6365, "capacity": 250},
+            {"code": "P19-DK5", "name": "Dewan Kuliah 5 (P19-DK5)", "building": "Block P19 - FKE", "lat": 1.5574, "lon": 103.6364, "capacity": 250},
+            {"code": "P19-DK6", "name": "Dewan Kuliah 6 (P19-DK6)", "building": "Block P19 - FKE", "lat": 1.5573, "lon": 103.6363, "capacity": 250},
+        ]
+        
+        # Add all venues to database
+        added_count = 0
+        updated_count = 0
+        
+        for venue in venues:
+            # Check if venue already exists
+            existing = Classroom.query.filter_by(name=venue['code']).first()
+            
+            if existing:
+                # Update existing venue
+                existing.building = venue['building']
+                existing.latitude = venue['lat']
+                existing.longitude = venue['lon']
+                existing.radius_meters = 50  # Default 50m radius
+                updated_count += 1
+                print(f"Updated: {venue['code']} - {venue['name']}")
+            else:
+                # Add new venue
+                classroom = Classroom(
+                    name=venue['code'],
+                    building=venue['building'],
+                    latitude=venue['lat'],
+                    longitude=venue['lon'],
+                    radius_meters=50  # Default 50m radius for all classrooms
+                )
+                db.session.add(classroom)
+                added_count += 1
+                print(f"Added: {venue['code']} - {venue['name']}")
+        
+        # Commit all changes
+        db.session.commit()
+        
+        print("\n" + "="*70)
+        print(f"Venue import complete!")
+        print(f"Added: {added_count} new venues")
+        print(f"Updated: {updated_count} existing venues")
+        print(f"Total venues in database: {Classroom.query.count()}")
+        print("="*70)
+        
+        # Display summary by building
+        print("\nVenues by Building:")
+        buildings = db.session.query(Classroom.building).distinct().all()
+        for (building,) in buildings:
+            count = Classroom.query.filter_by(building=building).count()
+            print(f"  - {building}: {count} venues")
+
+if __name__ == '__main__':
+    add_utm_venues()

app.py

@@ -0,0 +1,791 @@
+"""
+Attendr - Smart Attendance System
+Main Flask Application
+"""
+
+from flask import Flask, render_template, request, jsonify, session, redirect, url_for, flash, send_from_directory
+from flask_sqlalchemy import SQLAlchemy
+from config import Config
+from models import db, User, Student, Classroom, AttendanceSession, AttendanceRecord
+from face_recognition_module import face_recognition_module
+from geolocation_module import geolocation_module
+from attendance_code_module import attendance_code_module
+from utils import base64_to_image, image_to_numpy, format_error_response, format_success_response
+from auth import login_required, role_required, get_current_user
+from datetime import datetime
+import logging
+
+# Initialize Flask app
+app = Flask(__name__, template_folder='.')
+app.config.from_object(Config)
+Config.init_app(app)
+
+# Initialize database
+db.init_app(app)
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+# ==================== ROUTES ====================
+
+@app.route('/style.css')
+def style():
+    return send_from_directory('.', 'style.css')
+
+
+@app.route('/')
+def index():
+    """Landing page"""
+    current_user = get_current_user()
+    return render_template('index.html', current_user=current_user)
+
+
+@app.route('/student')
+@login_required
+@role_required('student')
+def student_page():
+    """Student attendance interface - requires student login"""
+    return render_template('student.html', current_user=get_current_user())
+
+
+@app.route('/student/history')
+@login_required
+@role_required('student')
+def student_history():
+    """Student attendance history page"""
+    return render_template('student_history.html', current_user=get_current_user())
+
+
+@app.route('/lecturer')
+@login_required
+@role_required('lecturer')
+def lecturer_page():
+    """Lecturer dashboard - requires lecturer login"""
+    return render_template('lecturer.html', current_user=get_current_user())
+
+
+@app.route('/lecturer/history')
+@login_required
+@role_required('lecturer')
+def lecturer_history():
+    """Lecturer session history page"""
+    return render_template('lecturer_history.html', current_user=get_current_user())
+
+
+@app.route('/register')
+def register_page():
+    """User registration page"""
+    return render_template('register.html')
+
+
+@app.route('/login')
+def login_page():
+    """Login page"""
+    return render_template('login.html')
+
+
+# ==================== AUTHENTICATION API ====================
+
+@app.route('/api/auth/register', methods=['POST'])
+def register_user():
+    """
+    Register new user (student or lecturer)
+    Validates matric number format based on role
+    """
+    try:
+        data = request.get_json()
+        
+        required_fields = ['matric_no', 'name', 'password', 'role']
+        if not all(k in data for k in required_fields):
+            return format_error_response(f"Missing required fields: {', '.join(required_fields)}")
+        
+        matric_no = data['matric_no'].upper().strip()
+        name = data['name']
+        password = data['password']
+        role = data['role'].lower()
+        email = data.get('email')
+        
+        # Validate role
+        if role not in ['student', 'lecturer']:
+            return format_error_response("Role must be 'student' or 'lecturer'")
+        
+        # Validate matric number format
+        is_valid, error_msg = User.validate_matric_no(matric_no, role)
+        if not is_valid:
+            return format_error_response(error_msg, 400)
+        
+        # Check if user already exists
+        existing_user = User.query.filter_by(matric_no=matric_no).first()
+        if existing_user:
+            return format_error_response("Matric number already registered", 409)
+        
+        if email:
+            existing_email = User.query.filter_by(email=email).first()
+            if existing_email:
+                return format_error_response("Email already registered", 409)
+        
+        # Create user
+        user = User(
+            matric_no=matric_no,
+            name=name,
+            email=email,
+            role=role
+        )
+        user.set_password(password)
+        
+        db.session.add(user)
+        db.session.commit()
+        
+        logger.info(f"User registered: {matric_no} ({role})")
+        
+        return format_success_response(
+            data=user.to_dict(),
+            message=f"{role.capitalize()} account created successfully!"
+        )
+        
+    except Exception as e:
+        db.session.rollback()
+        logger.error(f"User registration error: {str(e)}")
+        return format_error_response(f"Registration failed: {str(e)}", 500)
+
+
+@app.route('/api/auth/login', methods=['POST'])
+def login():
+    """Login user and create session"""
+    try:
+        data = request.get_json()
+        
+        if not all(k in data for k in ['matric_no', 'password']):
+            return format_error_response("Missing required fields: matric_no, password")
+        
+        matric_no = data['matric_no'].upper().strip()
+        password = data['password']
+        
+        # Find user
+        user = User.query.filter_by(matric_no=matric_no).first()
+        
+        if not user or not user.check_password(password):
+            return format_error_response("Invalid matric number or password", 401)
+        
+        if not user.is_active:
+            return format_error_response("Account is inactive. Please contact admin.", 403)
+        
+        # Create session
+        session['user_id'] = user.id
+        session['matric_no'] = user.matric_no
+        session['role'] = user.role
+        session['name'] = user.name
+        
+        logger.info(f"User logged in: {matric_no} ({user.role})")
+        
+        return format_success_response(
+            data={
+                'user': user.to_dict(),
+                'redirect': '/student' if user.role == 'student' else '/lecturer'
+            },
+            message=f"Welcome back, {user.name}!"
+        )
+        
+    except Exception as e:
+        logger.error(f"Login error: {str(e)}")
+        return format_error_response(f"Login failed: {str(e)}", 500)
+
+
+@app.route('/api/auth/logout', methods=['POST'])
+@login_required
+def logout():
+    """Logout user and destroy session"""
+    try:
+        user_name = session.get('name', 'User')
+        matric_no = session.get('matric_no', 'Unknown')
+        
+        # Clear all session data
+        session.clear()
+        
+        logger.info(f"User logged out: {matric_no}")
+        
+        return format_success_response(
+            message=f"Goodbye, {user_name}! You have been logged out successfully."
+        )
+        
+    except Exception as e:
+        logger.error(f"Logout error: {str(e)}")
+        return format_error_response(f"Logout failed: {str(e)}", 500)
+
+
+@app.route('/api/auth/current_user', methods=['GET'])
+def get_current_user_api():
+    """Get current logged in user"""
+    user = get_current_user()
+    if user:
+        return format_success_response(data=user.to_dict())
+    return format_error_response("Not logged in", 401)
+
+
+# ==================== API ENDPOINTS ====================
+
+@app.route('/api/register_face', methods=['POST'])
+def register_face():
+    """
+    Register student face encoding
+    Implements: PB-1 (Register Student Face Data)
+    """
+    try:
+        data = request.get_json()
+        
+        # Validate input
+        if not all(k in data for k in ['student_id', 'name', 'image']):
+            return format_error_response("Missing required fields: student_id, name, image")
+        
+        student_id = data['student_id']
+        name = data['name']
+        email = data.get('email')
+        image_base64 = data['image']
+        
+        # Check if student already exists
+        existing_student = Student.query.filter_by(student_id=student_id).first()
+        if existing_student:
+            return format_error_response("Student ID already registered", 409)
+        
+        # Get user account (if exists)
+        user = User.query.filter_by(matric_no=student_id).first()
+        
+        # Convert base64 to image
+        try:
+            image = base64_to_image(image_base64)
+            image_array = image_to_numpy(image)
+        except Exception as e:
+            return format_error_response(f"Invalid image data: {str(e)}")
+        
+        # Generate face encoding
+        success, result, face_location = face_recognition_module.register_face(image_array)
+        
+        if not success:
+            return format_error_response(result)
+        
+        # Create student record
+        student = Student(
+            student_id=student_id,
+            name=name,
+            email=email,
+            user_id=user.id if user else None  # Link to user account if exists
+        )
+        student.set_face_encoding(result)
+        
+        db.session.add(student)
+        db.session.commit()
+        
+        logger.info(f"Student registered: {student_id} - {name}")
+        
+        return format_success_response(
+            data=student.to_dict(),
+            message="Face registered successfully!"
+        )
+        
+    except Exception as e:
+        db.session.rollback()
+        logger.error(f"Registration error: {str(e)}")
+        return format_error_response(f"Registration failed: {str(e)}", 500)
+
+
+@app.route('/api/verify_face', methods=['POST'])
+def verify_face():
+    """
+    Verify student face against stored encoding
+    Implements: PB-3 (Face Recognition Matching)
+    Implements KR Rule #1: ∀x ((CapturedFace(x) ∧ MatchStored(x)) → FaceMatch(x))
+    """
+    try:
+        data = request.get_json()
+        
+        if not all(k in data for k in ['student_id', 'image']):
+            return format_error_response("Missing required fields: student_id, image")
+        
+        student_id = data['student_id']
+        image_base64 = data['image']
+        
+        # Get student record
+        student = Student.query.filter_by(student_id=student_id).first()
+        if not student:
+            return format_error_response("Student not found. Please register first.", 404)
+        
+        if not student.is_active:
+            return format_error_response("Student account is inactive", 403)
+        
+        # Get stored encoding
+        stored_encoding = student.get_face_encoding()
+        if not stored_encoding:
+            return format_error_response("No face encoding found. Please register your face.", 404)
+        
+        # Convert base64 to image
+        try:
+            image = base64_to_image(image_base64)
+            image_array = image_to_numpy(image)
+        except Exception as e:
+            return format_error_response(f"Invalid image data: {str(e)}")
+        
+        # Generate encoding from captured image
+        success, result = face_recognition_module.generate_face_encoding(image_array)
+        
+        if not success:
+            return format_error_response(result)
+        
+        captured_encoding = result
+        
+        # Verify face match
+        is_match, confidence = face_recognition_module.verify_face(captured_encoding, stored_encoding)
+        
+        if is_match:
+            logger.info(f"Face verified for student {student_id}: confidence={confidence:.2f}%")
+            return format_success_response(
+                data={
+                    'verified': True,
+                    'confidence': round(confidence, 2),
+                    'student': student.to_dict()
+                },
+                message=f"Face verified! Confidence: {confidence:.1f}%"
+            )
+        else:
+            logger.warning(f"Face verification failed for {student_id}: confidence={confidence:.2f}%")
+            return format_error_response(
+                f"Face verification failed. Confidence too low: {confidence:.1f}%",
+                401
+            )
+        
+    except Exception as e:
+        logger.error(f"Face verification error: {str(e)}")
+        return format_error_response(f"Verification failed: {str(e)}", 500)
+
+
+@app.route('/api/verify_location', methods=['POST'])
+def verify_location():
+    """
+    Verify student location against classroom boundaries
+    Implements: PB-5 (Geofencing Logic – Classroom Detection)
+    Implements KR Rule #2: ∀x[(Student(x) ∧ IsWithinAllowedArea(x)) → VerifiedLocation(x)]
+    """
+    try:
+        data = request.get_json()
+        
+        if not all(k in data for k in ['latitude', 'longitude', 'session_id']):
+            return format_error_response("Missing required fields: latitude, longitude, session_id")
+        
+        latitude = data['latitude']
+        longitude = data['longitude']
+        session_id = data['session_id']
+        
+        # Get session
+        session_obj = AttendanceSession.query.get(session_id)
+        if not session_obj:
+            return format_error_response("Session not found", 404)
+        
+        if not session_obj.is_active:
+            return format_error_response("Session is not active", 403)
+        
+        # Verify location
+        result = geolocation_module.verify_location(
+            latitude,
+            longitude,
+            session_obj.classroom_id
+        )
+        
+        if result['verified']:
+            logger.info(f"Location verified: distance={result['distance']:.2f}m")
+            return format_success_response(
+                data={
+                    'verified': True,
+                    'distance': round(result['distance'], 2),
+                    'classroom': session_obj.classroom.to_dict()
+                },
+                message=result['message']
+            )
+        else:
+            logger.warning(f"Location verification failed: {result['error']}")
+            return format_error_response(result['error'] or result['message'], 403)
+        
+    except Exception as e:
+        logger.error(f"Location verification error: {str(e)}")
+        return format_error_response(f"Location verification failed: {str(e)}", 500)
+
+
+@app.route('/api/mark_attendance', methods=['POST'])
+def mark_attendance():
+    """
+    Mark student attendance after all verifications
+    Implements: PB-12 (Mark Attendance in Database)
+    Implements KR Rule #4: ∀x ((FaceMatch(x) ∧ LocationValid(x)) → GrantCodeAccess(x))
+    Implements KR Rule #5: ∀x ((ValidCodeEntry(User,x) ∧ WithinCycle(Code,x)) → MarkPresent(System,x))
+    """
+    try:
+        data = request.get_json()
+        
+        required_fields = ['student_id', 'session_id', 'code', 'latitude', 'longitude']
+        if not all(k in data for k in required_fields):
+            return format_error_response(f"Missing required fields: {', '.join(required_fields)}")
+        
+        student_id = data['student_id']
+        session_id = data['session_id']
+        code = data['code']
+        latitude = data['latitude']
+        longitude = data['longitude']
+        
+        # Get student
+        student = Student.query.filter_by(student_id=student_id).first()
+        if not student:
+            return format_error_response("Student not found", 404)
+        
+        # Get session
+        session_obj = AttendanceSession.query.get(session_id)
+        if not session_obj:
+            return format_error_response("Session not found", 404)
+        
+        if not session_obj.is_active:
+            return format_error_response("Session is not active", 403)
+        
+        # Check if already marked
+        existing_record = AttendanceRecord.query.filter_by(
+            session_id=session_id,
+            student_id=student.id
+        ).first()
+        
+        if existing_record:
+            return format_error_response("Attendance already marked for this session", 409)
+        
+        # Validate code
+        is_valid, message = attendance_code_module.is_code_valid(session_id, code)
+        
+        if not is_valid:
+            return format_error_response(message, 401)
+        
+        # Verify location one more time
+        location_result = geolocation_module.verify_location(
+            latitude,
+            longitude,
+            session_obj.classroom_id
+        )
+        
+        if not location_result['verified']:
+            return format_error_response(location_result['error'] or "Location verification failed", 403)
+        
+        # Create attendance record
+        attendance = AttendanceRecord(
+            session_id=session_id,
+            student_id=student.id,
+            face_verified=True,  # Assumed verified before reaching this endpoint
+            location_verified=True,
+            code_verified=True,
+            student_latitude=float(latitude),
+            student_longitude=float(longitude),
+            distance_from_classroom=location_result['distance'],
+            status='present'
+        )
+        
+        db.session.add(attendance)
+        db.session.commit()
+        
+        logger.info(f"Attendance marked: {student.name} for session {session_id}")
+        
+        return format_success_response(
+            data=attendance.to_dict(),
+            message="Attendance marked successfully! ✓"
+        )
+        
+    except Exception as e:
+        db.session.rollback()
+        logger.error(f"Mark attendance error: {str(e)}")
+        return format_error_response(f"Failed to mark attendance: {str(e)}", 500)
+
+
+@app.route('/api/create_session', methods=['POST'])
+def create_session():
+    """
+    Create new attendance session
+    Implements: US-06 (Generate Auto-Refresh Codes)
+    """
+    try:
+        data = request.get_json()
+        
+        if not all(k in data for k in ['course_name', 'classroom_id', 'lecturer_name']):
+            return format_error_response("Missing required fields: course_name, classroom_id, lecturer_name")
+        
+        course_name = data['course_name']
+        classroom_id = data['classroom_id']
+        lecturer_name = data['lecturer_name']
+        
+        # Verify classroom exists
+        classroom = Classroom.query.get(classroom_id)
+        if not classroom:
+            return format_error_response("Classroom not found", 404)
+        
+        # Create session
+        session_obj = AttendanceSession(
+            course_name=course_name,
+            classroom_id=classroom_id,
+            lecturer_name=lecturer_name,
+            is_active=True
+        )
+        
+        db.session.add(session_obj)
+        db.session.commit()
+        
+        # Generate initial code
+        success, code = attendance_code_module.create_session_code(session_obj.id)
+        
+        if not success:
+            return format_error_response(f"Session created but code generation failed: {code}")
+        
+        logger.info(f"Session created: {course_name} by {lecturer_name}")
+        
+        return format_success_response(
+            data=session_obj.to_dict(),
+            message="Session created successfully!"
+        )
+        
+    except Exception as e:
+        db.session.rollback()
+        logger.error(f"Create session error: {str(e)}")
+        return format_error_response(f"Failed to create session: {str(e)}", 500)
+
+
+@app.route('/api/get_session/<int:session_id>', methods=['GET'])
+def get_session(session_id):
+    """Get session details including current code"""
+    try:
+        session_obj = AttendanceSession.query.get(session_id)
+        
+        if not session_obj:
+            return format_error_response("Session not found", 404)
+        
+        # Get code status
+        code_status = attendance_code_module.get_code_status(session_id)
+        
+        # Auto-refresh if needed
+        if code_status.get('needs_refresh'):
+            attendance_code_module.auto_refresh_code(session_id)
+            code_status = attendance_code_module.get_code_status(session_id)
+        
+        session_data = session_obj.to_dict()
+        session_data['code_status'] = code_status
+        
+        return format_success_response(data=session_data)
+        
+    except Exception as e:
+        logger.error(f"Get session error: {str(e)}")
+        return format_error_response(f"Failed to get session: {str(e)}", 500)
+
+
+@app.route('/api/get_active_sessions', methods=['GET'])
+def get_active_sessions():
+    """Get all active sessions"""
+    try:
+        sessions = AttendanceSession.query.filter_by(is_active=True).all()
+        return format_success_response(
+            data=[session.to_dict() for session in sessions]
+        )
+    except Exception as e:
+        logger.error(f"Get active sessions error: {str(e)}")
+        return format_error_response(f"Failed to get sessions: {str(e)}", 500)
+
+
+@app.route('/api/get_attendance/<int:session_id>', methods=['GET'])
+def get_attendance(session_id):
+    """
+    Get attendance records for a session
+    Implements: US-07 (View Real-time Attendance)
+    """
+    try:
+        session_obj = AttendanceSession.query.get(session_id)
+        
+        if not session_obj:
+            return format_error_response("Session not found", 404)
+        
+        records = AttendanceRecord.query.filter_by(session_id=session_id).all()
+        
+        return format_success_response(
+            data={
+                'session': session_obj.to_dict(),
+                'records': [record.to_dict() for record in records],
+                'total_present': len(records)
+            }
+        )
+        
+    except Exception as e:
+        logger.error(f"Get attendance error: {str(e)}")
+        return format_error_response(f"Failed to get attendance: {str(e)}", 500)
+
+
+@app.route('/api/end_session/<int:session_id>', methods=['POST'])
+def end_session(session_id):
+    """End an attendance session"""
+    try:
+        session_obj = AttendanceSession.query.get(session_id)
+        
+        if not session_obj:
+            return format_error_response("Session not found", 404)
+        
+        session_obj.is_active = False
+        session_obj.end_time = datetime.utcnow()
+        
+        db.session.commit()
+        
+        logger.info(f"Session ended: {session_id}")
+        
+        return format_success_response(message="Session ended successfully")
+        
+    except Exception as e:
+        db.session.rollback()
+        logger.error(f"End session error: {str(e)}")
+        return format_error_response(f"Failed to end session: {str(e)}", 500)
+
+
+@app.route('/api/student/history', methods=['GET'])
+@login_required
+@role_required('student')
+def get_student_history():
+    """Get attendance history for logged-in student"""
+    try:
+        # Get current user's student profile
+        current_user = get_current_user()
+        student = Student.query.filter_by(student_id=current_user.matric_no).first()
+        
+        if not student:
+            return format_error_response("Student profile not found", 404)
+        
+        # Get all attendance records for this student
+        records = AttendanceRecord.query.filter_by(student_id=student.id)\
+            .order_by(AttendanceRecord.marked_at.desc()).all()
+        
+        # Format response with session details
+        history = []
+        for record in records:
+            session = record.session
+            history.append({
+                'id': record.id,
+                'course_name': session.course_name,
+                'lecturer_name': session.lecturer_name,
+                'classroom': session.classroom.name,
+                'building': session.classroom.building,
+                'status': record.status,
+                'marked_at': record.marked_at.isoformat() if record.marked_at else None,
+                'session_date': session.start_time.isoformat() if session.start_time else None,
+                'face_verified': record.face_verified,
+                'location_verified': record.location_verified,
+                'code_verified': record.code_verified,
+                'distance_from_classroom': round(record.distance_from_classroom, 2) if record.distance_from_classroom else None
+            })
+        
+        return format_success_response(
+            data={
+                'student': student.to_dict(),
+                'total_records': len(history),
+                'history': history
+            }
+        )
+        
+    except Exception as e:
+        logger.error(f"Get student history error: {str(e)}")
+        return format_error_response(f"Failed to get history: {str(e)}", 500)
+
+
+@app.route('/api/lecturer/history', methods=['GET'])
+@login_required
+@role_required('lecturer')
+def get_lecturer_history():
+    """Get session history for logged-in lecturer"""
+    try:
+        current_user = get_current_user()
+        
+        # Get all sessions created by this lecturer (match by name)
+        sessions = AttendanceSession.query.filter_by(lecturer_name=current_user.name)\
+            .order_by(AttendanceSession.start_time.desc()).all()
+        
+        # Format response with attendance statistics
+        history = []
+        for session in sessions:
+            # Count attendance records
+            total_attendance = len(session.attendance_records)
+            present_count = sum(1 for r in session.attendance_records if r.status == 'present')
+            
+            # Calculate session duration
+            if session.end_time and session.start_time:
+                duration_minutes = int((session.end_time - session.start_time).total_seconds() / 60)
+            elif session.is_active and session.start_time:
+                duration_minutes = int((datetime.utcnow() - session.start_time).total_seconds() / 60)
+            else:
+                duration_minutes = 0
+            
+            history.append({
+                'id': session.id,
+                'course_name': session.course_name,
+                'lecturer_name': session.lecturer_name,
+                'classroom': session.classroom.name,
+                'building': session.classroom.building,
+                'start_time': session.start_time.isoformat() if session.start_time else None,
+                'end_time': session.end_time.isoformat() if session.end_time else None,
+                'is_active': session.is_active,
+                'duration_minutes': duration_minutes,
+                'total_attendance': total_attendance,
+                'present_count': present_count,
+                'attendance_records': [
+                    {
+                        'student_id': r.student.student_id if r.student else 'Unknown',
+                        'student_name': r.student.name if r.student else 'Unknown',
+                        'status': r.status,
+                        'marked_at': r.marked_at.isoformat() if r.marked_at else None,
+                        'face_verified': r.face_verified,
+                        'location_verified': r.location_verified,
+                        'code_verified': r.code_verified
+                    } for r in session.attendance_records
+                ]
+            })
+        
+        return format_success_response(
+            data={
+                'lecturer': {
+                    'name': current_user.name,
+                    'matric_no': current_user.matric_no
+                },
+                'total_sessions': len(history),
+                'history': history
+            }
+        )
+        
+    except Exception as e:
+        logger.error(f"Get lecturer history error: {str(e)}")
+        return format_error_response(f"Failed to get history: {str(e)}", 500)
+
+
+@app.route('/api/classrooms', methods=['GET'])
+def get_classrooms():
+    """Get all classrooms"""
+    try:
+        classrooms = geolocation_module.get_all_classrooms()
+        return format_success_response(data=classrooms)
+    except Exception as e:
+        logger.error(f"Get classrooms error: {str(e)}")
+        return format_error_response(f"Failed to get classrooms: {str(e)}", 500)
+
+
+# ==================== ERROR HANDLERS ====================
+
+@app.errorhandler(404)
+def not_found(error):
+    return format_error_response("Resource not found", 404)
+
+
+@app.errorhandler(500)
+def internal_error(error):
+    db.session.rollback()
+    return format_error_response("Internal server error", 500)
+
+
+# ==================== MAIN ====================
+
+if __name__ == '__main__':
+    with app.app_context():
+        db.create_all()
+        logger.info("Database tables created")
+    
+    app.run(debug=True, host='0.0.0.0', port=5000)

attendance_code_module.py

@@ -0,0 +1,232 @@
+"""
+Attendance Code Module for Attendr
+Implements KR Rule #5: Auto-Refresh Code Confirmation
+∀x ((ValidCodeEntry(User,x) ∧ WithinCycle(Code,x)) → MarkPresent(System,x))
+"""
+
+import random
+import string
+from datetime import datetime, timedelta
+from models import AttendanceSession, db
+from config import Config
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class AttendanceCodeModule:
+    """Handles attendance code generation, validation, and auto-refresh"""
+    
+    def __init__(self, code_length=None, refresh_interval=None):
+        """
+        Initialize attendance code module
+        
+        Args:
+            code_length: Length of the code (default from config)
+            refresh_interval: Code refresh interval in seconds (default from config)
+        """
+        self.code_length = code_length or Config.CODE_LENGTH
+        self.refresh_interval = refresh_interval or Config.CODE_REFRESH_INTERVAL
+        logger.info(f"Attendance Code Module initialized: length={self.code_length}, refresh={self.refresh_interval}s")
+    
+    def generate_code(self):
+        """
+        Generate a random attendance code
+        
+        Returns:
+            String code (e.g., "A3X9K2")
+        """
+        # Use uppercase letters and digits for clarity
+        characters = string.ascii_uppercase + string.digits
+        code = ''.join(random.choice(characters) for _ in range(self.code_length))
+        logger.info(f"Generated new code: {code}")
+        return code
+    
+    def create_session_code(self, session_id):
+        """
+        Create and store a new code for a session
+        
+        Args:
+            session_id: ID of the attendance session
+            
+        Returns:
+            tuple: (success, code or error_message)
+        """
+        try:
+            session = AttendanceSession.query.get(session_id)
+            
+            if not session:
+                return False, "Session not found"
+            
+            if not session.is_active:
+                return False, "Session is not active"
+            
+            # Generate new code
+            new_code = self.generate_code()
+            
+            # Update session
+            session.current_code = new_code
+            session.code_generated_at = datetime.utcnow()
+            
+            db.session.commit()
+            
+            logger.info(f"Session {session_id} code updated to: {new_code}")
+            return True, new_code
+            
+        except Exception as e:
+            db.session.rollback()
+            logger.error(f"Error creating session code: {str(e)}")
+            return False, f"Failed to create code: {str(e)}"
+    
+    def is_code_valid(self, session_id, entered_code):
+        """
+        Validate if entered code matches current session code and is within refresh cycle
+        Implements: ValidCodeEntry(User,x) ∧ WithinCycle(Code,x)
+        
+        Args:
+            session_id: ID of the attendance session
+            entered_code: Code entered by student
+            
+        Returns:
+            tuple: (is_valid: bool, message: str)
+        """
+        try:
+            session = AttendanceSession.query.get(session_id)
+            
+            if not session:
+                return False, "Session not found"
+            
+            if not session.is_active:
+                return False, "Session is no longer active"
+            
+            if not session.current_code:
+                return False, "No active code for this session"
+            
+            # Check if code matches (case-insensitive)
+            if session.current_code.upper() != entered_code.upper():
+                logger.warning(f"Code mismatch: expected {session.current_code}, got {entered_code}")
+                return False, "Invalid code. Please check and try again."
+            
+            # Check if code is within refresh cycle
+            if not session.code_generated_at:
+                return False, "Code timestamp not found"
+            
+            time_elapsed = (datetime.utcnow() - session.code_generated_at).total_seconds()
+            
+            if time_elapsed > self.refresh_interval:
+                logger.warning(f"Code expired: {time_elapsed:.0f}s elapsed (max: {self.refresh_interval}s)")
+                return False, f"Code has expired. Please use the current code displayed by your lecturer."
+            
+            # Code is valid
+            time_remaining = self.refresh_interval - time_elapsed
+            logger.info(f"Code validated successfully. Time remaining: {time_remaining:.0f}s")
+            return True, "Code verified successfully"
+            
+        except Exception as e:
+            logger.error(f"Code validation error: {str(e)}")
+            return False, f"Validation failed: {str(e)}"
+    
+    def should_refresh_code(self, session_id):
+        """
+        Check if code should be refreshed based on time elapsed
+        
+        Args:
+            session_id: ID of the attendance session
+            
+        Returns:
+            bool: True if code should be refreshed
+        """
+        try:
+            session = AttendanceSession.query.get(session_id)
+            
+            if not session or not session.is_active:
+                return False
+            
+            if not session.code_generated_at:
+                return True  # No code generated yet
+            
+            time_elapsed = (datetime.utcnow() - session.code_generated_at).total_seconds()
+            
+            return time_elapsed >= self.refresh_interval
+            
+        except Exception as e:
+            logger.error(f"Error checking refresh status: {str(e)}")
+            return False
+    
+    def auto_refresh_code(self, session_id):
+        """
+        Automatically refresh code if needed
+        
+        Args:
+            session_id: ID of the attendance session
+            
+        Returns:
+            tuple: (refreshed: bool, code or None)
+        """
+        try:
+            if self.should_refresh_code(session_id):
+                success, code = self.create_session_code(session_id)
+                if success:
+                    logger.info(f"Code auto-refreshed for session {session_id}")
+                    return True, code
+                else:
+                    return False, None
+            else:
+                # Return current code
+                session = AttendanceSession.query.get(session_id)
+                if session and session.current_code:
+                    return False, session.current_code
+                return False, None
+                
+        except Exception as e:
+            logger.error(f"Auto-refresh error: {str(e)}")
+            return False, None
+    
+    def get_code_status(self, session_id):
+        """
+        Get current code status including time remaining
+        
+        Args:
+            session_id: ID of the attendance session
+            
+        Returns:
+            dict: Code status information
+        """
+        try:
+            session = AttendanceSession.query.get(session_id)
+            
+            if not session:
+                return {'error': 'Session not found'}
+            
+            if not session.is_active:
+                return {'error': 'Session is not active'}
+            
+            if not session.current_code or not session.code_generated_at:
+                return {
+                    'code': None,
+                    'time_remaining': 0,
+                    'needs_refresh': True
+                }
+            
+            time_elapsed = (datetime.utcnow() - session.code_generated_at).total_seconds()
+            time_remaining = max(0, self.refresh_interval - time_elapsed)
+            needs_refresh = time_elapsed >= self.refresh_interval
+            
+            return {
+                'code': session.current_code,
+                'time_remaining': int(time_remaining),
+                'time_elapsed': int(time_elapsed),
+                'refresh_interval': self.refresh_interval,
+                'needs_refresh': needs_refresh,
+                'generated_at': session.code_generated_at.isoformat()
+            }
+            
+        except Exception as e:
+            logger.error(f"Error getting code status: {str(e)}")
+            return {'error': str(e)}
+
+
+# Singleton instance
+attendance_code_module = AttendanceCodeModule()

attendr.sql

@@ -0,0 +1,134 @@
+CREATE DATABASE IF NOT EXISTS attendr;
+USE attendr;
+
+START TRANSACTION;
+CREATE TABLE attendance_records (
+	id INTEGER NOT NULL, 
+	session_id INTEGER NOT NULL, 
+	student_id INTEGER NOT NULL, 
+	marked_at DATETIME, 
+	face_verified BOOLEAN, 
+	location_verified BOOLEAN, 
+	code_verified BOOLEAN, 
+	student_latitude FLOAT, 
+	student_longitude FLOAT, 
+	distance_from_classroom FLOAT, 
+	status VARCHAR(20), 
+	PRIMARY KEY (id), 
+	FOREIGN KEY(session_id) REFERENCES attendance_sessions (id), 
+	FOREIGN KEY(student_id) REFERENCES students (id)
+);
+INSERT INTO `attendance_records` VALUES(1,2,1,'2025-11-22 16:39:17.926194',1,1,1,3.1222562,101.7636743,6.719226959803195314e+02,'present');
+INSERT INTO `attendance_records` VALUES(2,3,1,'2025-11-22 16:46:07.075823',1,1,1,3.1222616,101.7636711,6.714557167968994236e+02,'present');
+INSERT INTO `attendance_records` VALUES(3,6,1,'2025-11-22 17:12:17.627831',1,1,1,3.122261,101.7636698,6.715625427798626106e+02,'present');
+INSERT INTO `attendance_records` VALUES(4,7,1,'2025-11-22 15:50:16.138101',1,1,1,0.0,0.0,10.0,'present');
+INSERT INTO `attendance_records` VALUES(5,8,1,'2025-11-22 17:31:19.262173',1,1,1,3.1222586,101.7636816,6.714266242365291645e+02,'present');
+CREATE TABLE attendance_sessions (
+	id INTEGER NOT NULL, 
+	course_name VARCHAR(100) NOT NULL, 
+	classroom_id INTEGER NOT NULL, 
+	lecturer_name VARCHAR(100) NOT NULL, 
+	start_time DATETIME, 
+	end_time DATETIME, 
+	is_active BOOLEAN, 
+	current_code VARCHAR(10), 
+	code_generated_at DATETIME, 
+	PRIMARY KEY (id), 
+	FOREIGN KEY(classroom_id) REFERENCES classrooms (id)
+);
+INSERT INTO `attendance_sessions` VALUES(1,'AI',46,'ZHANG LING HE','2025-11-22 16:34:53.967623','2025-11-22 16:35:22.483428',0,'EAB1FQ','2025-11-22 16:34:53.977748');
+INSERT INTO `attendance_sessions` VALUES(2,'AI',46,'ZHANG LING HE','2025-11-22 16:35:34.223978','2025-11-22 16:45:32.132931',0,'87JFTB','2025-11-22 16:45:23.271856');
+INSERT INTO `attendance_sessions` VALUES(3,'AD',46,'ZHANG LING HE','2025-11-22 16:45:46.604739','2025-11-22 16:50:30.716018',0,'RJII20','2025-11-22 16:50:22.204453');
+INSERT INTO `attendance_sessions` VALUES(4,'SECR3104 - Applications Development',46,'ZHANG LING HE','2025-11-22 17:04:10.912458','2025-11-22 17:04:36.114555',0,'86SONH','2025-11-22 17:04:32.116897');
+INSERT INTO `attendance_sessions` VALUES(5,'SECR3104 - Applications Development',46,'ZHANG LING HE','2025-11-22 17:04:54.989793','2025-11-22 17:09:42.210274',0,'L8D01H','2025-11-22 17:09:33.982659');
+INSERT INTO `attendance_sessions` VALUES(6,'SECJ3553 - Artificial Intelligence',46,'ZHANG LING HE','2025-11-22 17:12:01.124969','2025-11-22 17:26:36.046635',0,'446MC7','2025-11-22 17:26:33.821599');
+INSERT INTO `attendance_sessions` VALUES(7,'TEST101 - Testing',1,'Test Lecturer','2025-11-22 15:20:16.131518','2025-11-22 16:20:16.131518',0,NULL,NULL);
+INSERT INTO `attendance_sessions` VALUES(8,'SECR1013 - Digital Logic',46,'ZHANG LING HE','2025-11-22 17:30:15.307311','2025-11-22 17:31:23.154043',0,'D5DYN5','2025-11-22 17:31:15.654521');
+CREATE TABLE classrooms (
+	id INTEGER NOT NULL, 
+	name VARCHAR(100) NOT NULL, 
+	building VARCHAR(100), 
+	latitude FLOAT NOT NULL, 
+	longitude FLOAT NOT NULL, 
+	radius_meters INTEGER, 
+	PRIMARY KEY (id)
+);
+INSERT INTO `classrooms` VALUES(1,'N28-105-01','N28 - Faculty of Computing',1.5638,103.6388,50);
+INSERT INTO `classrooms` VALUES(2,'N28-116-02','N28 - Faculty of Computing',1.5639,103.6388,50);
+INSERT INTO `classrooms` VALUES(3,'N28-112-02','N28 - Faculty of Computing',1.564,103.6388,50);
+INSERT INTO `classrooms` VALUES(4,'N28-111-01','N28 - Faculty of Computing',1.5641,103.6388,50);
+INSERT INTO `classrooms` VALUES(5,'N28-106-01','N28 - Faculty of Computing',1.5642,103.6388,50);
+INSERT INTO `classrooms` VALUES(6,'N28-107-01','N28 - Faculty of Computing',1.5643,103.6388,50);
+INSERT INTO `classrooms` VALUES(7,'N28-108-01','N28 - Faculty of Computing',1.5644,103.6388,50);
+INSERT INTO `classrooms` VALUES(8,'N28-351-02','N28 - Level 3',1.5645,103.6388,50);
+INSERT INTO `classrooms` VALUES(9,'N28-301-01','N28 - Level 3',1.5646,103.6388,50);
+INSERT INTO `classrooms` VALUES(10,'N28-301-01B','N28 - Level 3',1.5647,103.6388,50);
+INSERT INTO `classrooms` VALUES(11,'N28A-BT1','N28A - Tutorial Block',1.5638,103.6389,50);
+INSERT INTO `classrooms` VALUES(12,'N28A-BT2','N28A - Tutorial Block',1.5639,103.6389,50);
+INSERT INTO `classrooms` VALUES(13,'N28A-BT3','N28A - Tutorial Block',1.564,103.6389,50);
+INSERT INTO `classrooms` VALUES(14,'N28A-BT4','N28A - Tutorial Block',1.5641,103.6389,50);
+INSERT INTO `classrooms` VALUES(15,'N28A-BK1','N28A - Tutorial Block',1.5642,103.6389,50);
+INSERT INTO `classrooms` VALUES(16,'N28A-BK2','N28A - Tutorial Block',1.5643,103.6389,50);
+INSERT INTO `classrooms` VALUES(17,'N28A-BK5','N28A - Tutorial Block',1.5644,103.6389,50);
+INSERT INTO `classrooms` VALUES(18,'N28A-BK6','N28A - Tutorial Block',1.5645,103.6389,50);
+INSERT INTO `classrooms` VALUES(19,'N28-502-01','N28 - Level 5',1.5646,103.6389,50);
+INSERT INTO `classrooms` VALUES(20,'N28-505-01','N28 - Level 5',1.5647,103.6389,50);
+INSERT INTO `classrooms` VALUES(21,'N28-506-01','N28 - Level 5',1.5638,1.036390000000000101e+02,50);
+INSERT INTO `classrooms` VALUES(22,'N28-512-01','N28 - Level 5',1.5639,1.036390000000000101e+02,50);
+INSERT INTO `classrooms` VALUES(23,'N28-516-01','N28 - Level 5',1.564,1.036390000000000101e+02,50);
+INSERT INTO `classrooms` VALUES(24,'N28-517-02','N28 - Level 5',1.5641,1.036390000000000101e+02,50);
+INSERT INTO `classrooms` VALUES(25,'N28-518-02','N28 - Level 5',1.5642,1.036390000000000101e+02,50);
+INSERT INTO `classrooms` VALUES(26,'N28-524-02','N28 - Level 5',1.5643,1.036390000000000101e+02,50);
+INSERT INTO `classrooms` VALUES(27,'N28-525-01','N28 - Level 5',1.5644,1.036390000000000101e+02,50);
+INSERT INTO `classrooms` VALUES(28,'N28-527-02','N28 - Level 5',1.5645,1.036390000000000101e+02,50);
+INSERT INTO `classrooms` VALUES(29,'N28A-02-33','N28A - Level 2',1.5646,1.036390000000000101e+02,50);
+INSERT INTO `classrooms` VALUES(30,'N28A-02-34','N28A - Level 2',1.5647,1.036390000000000101e+02,50);
+INSERT INTO `classrooms` VALUES(31,'N28-223-02','N28 - Level 2',1.5638,103.6391,50);
+INSERT INTO `classrooms` VALUES(32,'N28-204-01','N28 - Level 2',1.5639,103.6391,50);
+INSERT INTO `classrooms` VALUES(33,'N28-203-01','N28 - Level 2',1.564,103.6391,50);
+INSERT INTO `classrooms` VALUES(34,'N28-202-01','N28 - Level 2',1.5641,103.6391,50);
+INSERT INTO `classrooms` VALUES(35,'N28-330-01','N28 - Level 3',1.5642,103.6391,50);
+INSERT INTO `classrooms` VALUES(36,'N28-352-01','N28 - Level 3',1.5643,103.6391,50);
+INSERT INTO `classrooms` VALUES(37,'N28-321-02','N28 - Level 3',1.5644,103.6391,50);
+INSERT INTO `classrooms` VALUES(38,'N28-329-01','N28 - Level 3',1.5645,103.6391,50);
+INSERT INTO `classrooms` VALUES(39,'N28-350-03','N28 - Level 3',1.5646,103.6391,50);
+INSERT INTO `classrooms` VALUES(40,'N28-422-01','N28 - Level 4',1.5647,103.6391,50);
+INSERT INTO `classrooms` VALUES(41,'N28-423-01','N28 - Level 4',1.5638,103.6392,50);
+INSERT INTO `classrooms` VALUES(42,'L50-DK3','Block L50 - Centre Point',1.5639,103.6392,50);
+INSERT INTO `classrooms` VALUES(43,'P19-DK4','Block P19 - FKE',1.564,103.6392,50);
+INSERT INTO `classrooms` VALUES(44,'P19-DK5','Block P19 - FKE',1.5641,103.6392,50);
+INSERT INTO `classrooms` VALUES(45,'P19-DK6','Block P19 - FKE',1.5642,103.6392,50);
+INSERT INTO `classrooms` VALUES(46,'PUTERI-COURT','Puteri Court Condominium (Home Demo)',3.128024,101.765479,1000);
+CREATE TABLE students (
+	id INTEGER NOT NULL, 
+	user_id INTEGER, 
+	student_id VARCHAR(50) NOT NULL, 
+	name VARCHAR(100) NOT NULL, 
+	email VARCHAR(100), 
+	face_encoding TEXT, 
+	registered_at DATETIME, 
+	is_active BOOLEAN, 
+	PRIMARY KEY (id), 
+	UNIQUE (user_id), 
+	FOREIGN KEY(user_id) REFERENCES users (id), 
+	UNIQUE (student_id), 
+	UNIQUE (email)
+);
+INSERT INTO `students` VALUES(1,1,'B24CS0011','CHUA LIN WEI','chuawei@graduate.utm.my','[15.0, 180.0, 15.0, 242.0, 74.0, 75.0, 180.0, 242.0, 127.0, 136.0, 138.0, 179.0, 93.0, 68.0, 122.0, 148.0, 34.0, 224.0, 223.0, 39.0, 58.0, 228.0, 180.0, 183.0, 91.0, 67.0, 219.0, 4.0, 131.0, 147.0, 136.0, 58.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]','2025-11-22 16:33:50.673821',1);
+CREATE TABLE users (
+	id INTEGER NOT NULL, 
+	matric_no VARCHAR(50) NOT NULL, 
+	name VARCHAR(100) NOT NULL, 
+	email VARCHAR(100), 
+	password_hash VARCHAR(255) NOT NULL, 
+	role VARCHAR(20) NOT NULL, 
+	is_active BOOLEAN, 
+	created_at DATETIME, 
+	PRIMARY KEY (id), 
+	UNIQUE (matric_no), 
+	UNIQUE (email)
+);
+INSERT INTO `users` VALUES(1,'B24CS0011','CHUA LIN WEI','chuawei@graduate.utm.my','scrypt:32768:8:1$hE1y6RkAGBX68GXd$0f613cc449e9b0f9bf2be44cc9914af63d03bc6af78c96baf25081d085e8e64fdd001d01b286afe3cde65fba0ce980d5666c4a233057c7937f6924302e38cd84','student',1,'2025-11-22 16:33:49.914535');
+INSERT INTO `users` VALUES(2,'L001','ZHANG LING HE','miaofifi146@gmail.com','scrypt:32768:8:1$0Lde9MkTKZHggMvp$fd98cbd8955f87ffc01b1e383429b350d50ff4c3e5b05ac7f39bf25dac99aa1f0858f8c5c562decc81c297fd5b1f98bbce7ec69027875bd9882eb052e07d777a','lecturer',1,'2025-11-22 16:34:27.215798');
+INSERT INTO `users` VALUES(3,'L9999','Test Lecturer',NULL,'scrypt:32768:8:1$mVC87j8AGr8uHDsu$4b3a45675a2731d350460403556460e2ebbdd85fcdb204cc9ad81695a0f573f20c36405be345ead28baedc30f21f4cf3fc8e32c14bfc3b83f89d2d4a0edf74bf','lecturer',1,'2025-11-22 17:20:16.122417');
+COMMIT;

auth.py

@@ -0,0 +1,41 @@
+"""
+Authentication helper functions and decorators
+"""
+
+from functools import wraps
+from flask import session, redirect, url_for, flash
+from models import User
+
+def login_required(f):
+    """Decorator to require login for a route"""
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        if 'user_id' not in session:
+            flash('Please login to access this page', 'error')
+            return redirect(url_for('login_page'))
+        return f(*args, **kwargs)
+    return decorated_function
+
+def role_required(role):
+    """Decorator to require specific role for a route"""
+    def decorator(f):
+        @wraps(f)
+        def decorated_function(*args, **kwargs):
+            if 'user_id' not in session:
+                flash('Please login to access this page', 'error')
+                return redirect(url_for('login_page'))
+            
+            user = User.query.get(session['user_id'])
+            if not user or user.role != role:
+                flash(f'Access denied. This page is for {role}s only.', 'error')
+                return redirect(url_for('index'))
+            
+            return f(*args, **kwargs)
+        return decorated_function
+    return decorator
+
+def get_current_user():
+    """Get currently logged in user"""
+    if 'user_id' in session:
+        return User.query.get(session['user_id'])
+    return None

clear_database.py

@@ -0,0 +1,39 @@
+"""
+Clear all database data and reinitialize with fresh tables
+"""
+
+from app import app, db
+from models import User, Student, Classroom, AttendanceSession, AttendanceRecord
+
+def clear_database():
+    """Drop all tables and recreate them"""
+    
+    with app.app_context():
+        print("Clearing database...")
+        print("="*70)
+        
+        # Drop all tables
+        db.drop_all()
+        print("[OK] Dropped all tables")
+        
+        # Recreate all tables
+        db.create_all()
+        print("[OK] Created fresh tables")
+        
+        print("="*70)
+        print("Database cleared successfully!")
+        print("\nAll data has been removed:")
+        print("  - Users: 0")
+        print("  - Students: 0")
+        print("  - Classrooms: 0")
+        print("  - Attendance Sessions: 0")
+        print("  - Attendance Records: 0")
+        print("="*70)
+        print("\nNext steps:")
+        print("1. Run: python add_utm_venues.py (to add classrooms)")
+        print("2. Run: python add_home_venue.py (to add Puteri Court)")
+        print("3. Register new accounts at: http://localhost:5000/register")
+        print("="*70)
+
+if __name__ == '__main__':
+    clear_database()

config.py

@@ -0,0 +1,39 @@
+import os
+
+class Config:
+    """Configuration settings for Attendr Smart Attendance System"""
+    
+    # Flask settings
+    SECRET_KEY = os.environ.get('SECRET_KEY') or 'dev-secret-key-change-in-production'
+    
+    # Database settings
+    BASE_DIR = os.path.abspath(os.path.dirname(__file__))
+    SQLALCHEMY_DATABASE_URI = os.environ.get('DATABASE_URL') or \
+        'sqlite:///' + os.path.join(BASE_DIR, 'attendr.db')
+    SQLALCHEMY_TRACK_MODIFICATIONS = False
+    
+    # Upload folder settings
+    UPLOAD_FOLDER = os.path.join(BASE_DIR, 'uploads')
+    FACE_ENCODINGS_FOLDER = os.path.join(UPLOAD_FOLDER, 'face_encodings')
+    MAX_CONTENT_LENGTH = 16 * 1024 * 1024  # 16MB max file size
+    
+    # Face recognition settings
+    FACE_RECOGNITION_TOLERANCE = 0.6  # Lower = more strict (0.6 is default)
+    FACE_DETECTION_MODEL = 'hog'  # 'hog' is faster, 'cnn' is more accurate
+    
+    # Geolocation settings
+    GEOLOCATION_RADIUS_METERS = 50  # Classroom detection radius
+    
+    # Attendance Code Settings
+    CODE_LENGTH = 6  # Length of attendance code
+    CODE_REFRESH_INTERVAL = 10  # Code refresh interval in seconds (10 seconds for demo)
+    
+    # Session Settings
+    SESSION_DURATION_HOURS = 3  # Default session duration
+    
+    @staticmethod
+    def init_app(app):
+        """Initialize application with config"""
+        # Create upload folders if they don't exist
+        os.makedirs(Config.UPLOAD_FOLDER, exist_ok=True)
+        os.makedirs(Config.FACE_ENCODINGS_FOLDER, exist_ok=True)

dump_db_to_sql.py

@@ -0,0 +1,37 @@
+
+import sqlite3
+import os
+
+def dump_sqlite_to_sql(db_path, output_path):
+    # Check if DB exists
+    if not os.path.exists(db_path):
+        print(f"Error: Database file '{db_path}' not found.")
+        return
+
+    try:
+        # Connect to the database
+        conn = sqlite3.connect(db_path)
+        
+        # Open the output file
+        with open(output_path, 'w', encoding='utf-8') as f:
+            # Iterate through the dump and write to file
+            for line in conn.iterdump():
+                f.write('%s\n' % line)
+        
+        print(f"Successfully dumped '{db_path}' to '{output_path}'.")
+        
+        conn.close()
+    except Exception as e:
+        print(f"An error occurred: {e}")
+
+if __name__ == "__main__":
+    db_file = "attendr.db"
+    sql_file = "attendr.sql"
+    
+    # Get absolute paths
+    current_dir = os.getcwd()
+    db_path = os.path.join(current_dir, db_file)
+    output_path = os.path.join(current_dir, sql_file)
+    
+    print(f"Dumping {db_path}...")
+    dump_sqlite_to_sql(db_path, output_path)

face_recognition_module.py

@@ -0,0 +1,160 @@
+"""
+Mock Face Recognition Module for Testing (Windows-friendly)
+This is a simplified version that doesn't require dlib/face_recognition
+For production, install the full face_recognition library
+"""
+
+import numpy as np
+import cv2
+from config import Config
+import logging
+import hashlib
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+logger.warning("Using MOCK face recognition module - for testing only!")
+logger.warning("Install face_recognition library for production use")
+
+
+class FaceRecognitionModule:
+    """Mock face recognition for testing without dlib dependencies"""
+    
+    def __init__(self, tolerance=None, model='hog'):
+        self.tolerance = tolerance or Config.FACE_RECOGNITION_TOLERANCE
+        self.model = model
+        logger.info(f"Mock Face Recognition Module initialized")
+    
+    def detect_faces(self, image_array):
+        """Mock face detection using OpenCV Haar Cascades"""
+        try:
+            # Convert to grayscale
+            gray = cv2.cvtColor(image_array, cv2.COLOR_RGB2GRAY)
+            
+            # Load Haar cascade for face detection
+            face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+            
+            # Detect faces
+            faces = face_cascade.detectMultiScale(gray, 1.3, 5)
+            
+            # Convert to format similar to face_recognition library
+            face_locations = [(y, x+w, y+h, x) for (x, y, w, h) in faces]
+            
+            logger.info(f"Detected {len(face_locations)} face(s)")
+            return face_locations
+        except Exception as e:
+            logger.error(f"Face detection error: {str(e)}")
+            return []
+    
+    def generate_face_encoding(self, image_array):
+        """
+        Mock encoding generation using image hash
+        In production, this would use deep learning-based face encodings
+        """
+        try:
+            face_locations = self.detect_faces(image_array)
+            
+            if len(face_locations) == 0:
+                return False, "No face detected in the image. Please ensure your face is clearly visible."
+            
+            if len(face_locations) > 1:
+                return False, "Multiple faces detected. Please ensure only one person is in the frame."
+            
+            # Create a simple "encoding" using image hash (for testing only)
+            # In production, this would be a 128-dimensional face encoding
+            top, right, bottom, left = face_locations[0]
+            face_region = image_array[top:bottom, left:right]
+            
+            # Resize to standard size
+            face_resized = cv2.resize(face_region, (100, 100))
+            
+            # Create hash-based encoding (mock)
+            face_bytes = face_resized.tobytes()
+            hash_obj = hashlib.sha256(face_bytes)
+            hash_digest = hash_obj.digest()  # Get bytes directly
+            
+            # Convert to numpy array (128 dimensions to match real encodings)
+            # Use hash bytes to create 128-dimensional vector
+            encoding = np.array([float(b) for b in hash_digest[:128]] + [0.0] * (128 - len(hash_digest[:128])))
+            
+            logger.info("Mock face encoding generated")
+            return True, encoding
+            
+        except Exception as e:
+            logger.error(f"Face encoding error: {str(e)}")
+            return False, f"Face encoding failed: {str(e)}"
+    
+    def verify_face(self, captured_encoding, stored_encoding):
+        """
+        Mock face verification using encoding similarity
+        In production, this would use Euclidean distance between face encodings
+        """
+        try:
+            if captured_encoding is None or stored_encoding is None:
+                return False, 0.0
+            
+            # Convert to numpy arrays
+            if not isinstance(captured_encoding, np.ndarray):
+                captured_encoding = np.array(captured_encoding)
+            if not isinstance(stored_encoding, np.ndarray):
+                stored_encoding = np.array(stored_encoding)
+            
+            # Calculate similarity (mock - using correlation)
+            # In production, this would be face_recognition.face_distance()
+            correlation = np.corrcoef(captured_encoding, stored_encoding)[0, 1]
+            
+            # Convert to distance (0 = identical, 1 = completely different)
+            distance = 1 - abs(correlation)
+            
+            # Calculate confidence
+            confidence = (1 - distance) * 100
+            
+            # Check if match
+            is_match = distance <= self.tolerance
+            
+            logger.info(f"Mock verification: match={is_match}, confidence={confidence:.2f}%")
+            
+            return is_match, confidence
+            
+        except Exception as e:
+            logger.error(f"Face verification error: {str(e)}")
+            return False, 0.0
+    
+    def register_face(self, image_array):
+        """Complete face registration"""
+        try:
+            face_locations = self.detect_faces(image_array)
+            
+            if len(face_locations) == 0:
+                return False, "No face detected. Please ensure your face is clearly visible and well-lit.", None
+            
+            if len(face_locations) > 1:
+                return False, "Multiple faces detected. Please ensure only one person is in the frame.", None
+            
+            success, result = self.generate_face_encoding(image_array)
+            
+            if success:
+                return True, result, face_locations[0]
+            else:
+                return False, result, None
+                
+        except Exception as e:
+            logger.error(f"Face registration error: {str(e)}")
+            return False, f"Registration failed: {str(e)}", None
+    
+    def compare_faces_batch(self, known_encodings, face_encoding_to_check):
+        """Compare against multiple encodings"""
+        try:
+            matches = []
+            for known_encoding in known_encodings:
+                is_match, _ = self.verify_face(face_encoding_to_check, known_encoding)
+                matches.append(is_match)
+            return matches
+        except Exception as e:
+            logger.error(f"Batch comparison error: {str(e)}")
+            return []
+
+
+# Singleton instance
+face_recognition_module = FaceRecognitionModule()

face_recognition_module_PRODUCTION.py

@@ -0,0 +1,193 @@
+"""
+Production Face Recognition Module for Attendr
+This is the REAL implementation using the face_recognition library
+Use this file after installing dlib and face_recognition
+
+To activate:
+1. Install dlib and face_recognition
+2. Rename face_recognition_module.py to face_recognition_module_MOCK.py
+3. Rename this file to face_recognition_module.py
+4. Restart the Flask application
+"""
+
+import face_recognition
+import numpy as np
+from config import Config
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class FaceRecognitionModule:
+    """Handles all face recognition operations using production library"""
+    
+    def __init__(self, tolerance=None, model='hog'):
+        """
+        Initialize face recognition module
+        
+        Args:
+            tolerance: Face matching tolerance (lower = more strict)
+            model: Detection model ('hog' or 'cnn')
+        """
+        self.tolerance = tolerance or Config.FACE_RECOGNITION_TOLERANCE
+        self.model = model or Config.FACE_DETECTION_MODEL
+        logger.info(f"PRODUCTION Face Recognition Module initialized with tolerance={self.tolerance}, model={self.model}")
+    
+    def detect_faces(self, image_array):
+        """
+        Detect faces in an image
+        
+        Args:
+            image_array: numpy array of the image
+            
+        Returns:
+            List of face locations [(top, right, bottom, left), ...]
+        """
+        try:
+            face_locations = face_recognition.face_locations(image_array, model=self.model)
+            logger.info(f"Detected {len(face_locations)} face(s) in image")
+            return face_locations
+        except Exception as e:
+            logger.error(f"Face detection error: {str(e)}")
+            return []
+    
+    def generate_face_encoding(self, image_array):
+        """
+        Generate face encoding from an image
+        Implements: CapturedFace(x) - captures and encodes the face
+        
+        Args:
+            image_array: numpy array of the image
+            
+        Returns:
+            tuple: (success, encoding or error_message)
+        """
+        try:
+            # Detect faces first
+            face_locations = self.detect_faces(image_array)
+            
+            if len(face_locations) == 0:
+                return False, "No face detected in the image. Please ensure your face is clearly visible."
+            
+            if len(face_locations) > 1:
+                return False, "Multiple faces detected. Please ensure only one person is in the frame."
+            
+            # Generate encoding
+            encodings = face_recognition.face_encodings(image_array, face_locations)
+            
+            if len(encodings) == 0:
+                return False, "Failed to generate face encoding. Please try again with better lighting."
+            
+            encoding = encodings[0]
+            logger.info("Face encoding generated successfully")
+            return True, encoding
+            
+        except Exception as e:
+            logger.error(f"Face encoding error: {str(e)}")
+            return False, f"Face encoding failed: {str(e)}"
+    
+    def verify_face(self, captured_encoding, stored_encoding):
+        """
+        Verify if captured face matches stored encoding
+        Implements: MatchStored(x) → FaceMatch(x)
+        
+        Args:
+            captured_encoding: Face encoding from live capture
+            stored_encoding: Stored face encoding from database
+            
+        Returns:
+            tuple: (is_match: bool, confidence: float)
+        """
+        try:
+            if captured_encoding is None or stored_encoding is None:
+                logger.warning("One or both encodings are None")
+                return False, 0.0
+            
+            # Convert to numpy arrays if needed
+            if not isinstance(captured_encoding, np.ndarray):
+                captured_encoding = np.array(captured_encoding)
+            if not isinstance(stored_encoding, np.ndarray):
+                stored_encoding = np.array(stored_encoding)
+            
+            # Calculate face distance (lower = more similar)
+            face_distance = face_recognition.face_distance([stored_encoding], captured_encoding)[0]
+            
+            # Convert distance to confidence percentage
+            confidence = (1 - face_distance) * 100
+            
+            # Check if match is within tolerance
+            is_match = face_distance <= self.tolerance
+            
+            logger.info(f"Face verification: match={is_match}, confidence={confidence:.2f}%, distance={face_distance:.4f}")
+            
+            return is_match, confidence
+            
+        except Exception as e:
+            logger.error(f"Face verification error: {str(e)}")
+            return False, 0.0
+    
+    def register_face(self, image_array):
+        """
+        Complete face registration process
+        
+        Args:
+            image_array: numpy array of the image
+            
+        Returns:
+            tuple: (success, encoding or error_message, face_location)
+        """
+        try:
+            # Detect faces
+            face_locations = self.detect_faces(image_array)
+            
+            if len(face_locations) == 0:
+                return False, "No face detected. Please ensure your face is clearly visible and well-lit.", None
+            
+            if len(face_locations) > 1:
+                return False, "Multiple faces detected. Please ensure only one person is in the frame.", None
+            
+            # Generate encoding
+            success, result = self.generate_face_encoding(image_array)
+            
+            if success:
+                return True, result, face_locations[0]
+            else:
+                return False, result, None
+                
+        except Exception as e:
+            logger.error(f"Face registration error: {str(e)}")
+            return False, f"Registration failed: {str(e)}", None
+    
+    def compare_faces_batch(self, known_encodings, face_encoding_to_check):
+        """
+        Compare a face encoding against multiple known encodings
+        Useful for identifying which student from a list
+        
+        Args:
+            known_encodings: List of known face encodings
+            face_encoding_to_check: Face encoding to compare
+            
+        Returns:
+            List of boolean matches
+        """
+        try:
+            if not isinstance(face_encoding_to_check, np.ndarray):
+                face_encoding_to_check = np.array(face_encoding_to_check)
+            
+            matches = face_recognition.compare_faces(
+                known_encodings, 
+                face_encoding_to_check, 
+                tolerance=self.tolerance
+            )
+            
+            return matches
+            
+        except Exception as e:
+            logger.error(f"Batch face comparison error: {str(e)}")
+            return []
+
+
+# Singleton instance
+face_recognition_module = FaceRecognitionModule()

fix_sql_quotes.py

@@ -0,0 +1,23 @@
+
+import re
+
+file_path = 'attendr.sql'
+
+with open(file_path, 'r', encoding='utf-8') as f:
+    content = f.read()
+
+# Replace "table_name" with `table_name` in INSERT INTO statements
+# Regex looks for: INSERT INTO "word"
+# Replaces with: INSERT INTO `word`
+# Or I can just remove the quotes since table names are safe. Let's remove them to be safe across different modes if possible, but backticks are safer for MySQL.
+# Let's use backticks.
+
+def replace_quotes(match):
+    return f'INSERT INTO `{match.group(1)}`'
+
+new_content = re.sub(r'INSERT INTO "([^"]+)"', replace_quotes, content)
+
+with open(file_path, 'w', encoding='utf-8') as f:
+    f.write(new_content)
+
+print("Fixed quotes in attendr.sql")

geolocation_module.py

@@ -0,0 +1,215 @@
+"""
+Geolocation Verification Module for Attendr
+Implements KR Rule #2: Geolocation Verification
+∀x[(Student(x) ∧ IsWithinAllowedArea(x)) → VerifiedLocation(x)]
+"""
+
+from utils import haversine_distance, validate_coordinates
+from models import Classroom, db
+from config import Config
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class GeolocationModule:
+    """Handles all geolocation verification operations"""
+    
+    def __init__(self, default_radius=None):
+        """
+        Initialize geolocation module
+        
+        Args:
+            default_radius: Default radius in meters for geofencing
+        """
+        self.default_radius = default_radius or Config.GEOLOCATION_RADIUS_METERS
+        logger.info(f"Geolocation Module initialized with default radius={self.default_radius}m")
+    
+    def get_classroom_location(self, classroom_id):
+        """
+        Get classroom GPS coordinates and radius
+        
+        Args:
+            classroom_id: ID of the classroom
+            
+        Returns:
+            tuple: (latitude, longitude, radius) or (None, None, None) if not found
+        """
+        try:
+            classroom = Classroom.query.get(classroom_id)
+            
+            if not classroom:
+                logger.warning(f"Classroom {classroom_id} not found")
+                return None, None, None
+            
+            radius = classroom.radius_meters or self.default_radius
+            logger.info(f"Classroom {classroom.name}: lat={classroom.latitude}, lon={classroom.longitude}, radius={radius}m")
+            
+            return classroom.latitude, classroom.longitude, radius
+            
+        except Exception as e:
+            logger.error(f"Error fetching classroom location: {str(e)}")
+            return None, None, None
+    
+    def calculate_distance(self, lat1, lon1, lat2, lon2):
+        """
+        Calculate distance between two GPS coordinates
+        
+        Args:
+            lat1, lon1: First coordinate
+            lat2, lon2: Second coordinate
+            
+        Returns:
+            Distance in meters
+        """
+        try:
+            distance = haversine_distance(lat1, lon1, lat2, lon2)
+            logger.info(f"Distance calculated: {distance:.2f} meters")
+            return distance
+        except Exception as e:
+            logger.error(f"Distance calculation error: {str(e)}")
+            return None
+    
+    def is_within_allowed_area(self, student_lat, student_lon, classroom_id):
+        """
+        Check if student is within allowed classroom area
+        Implements: IsWithinAllowedArea(x)
+        
+        Args:
+            student_lat: Student's latitude
+            student_lon: Student's longitude
+            classroom_id: ID of the classroom
+            
+        Returns:
+            tuple: (is_within: bool, distance: float, error_message: str or None)
+        """
+        try:
+            # Validate student coordinates
+            valid, error = validate_coordinates(student_lat, student_lon)
+            if not valid:
+                logger.warning(f"Invalid student coordinates: {error}")
+                return False, None, error
+            
+            # Get classroom location
+            class_lat, class_lon, radius = self.get_classroom_location(classroom_id)
+            
+            if class_lat is None:
+                return False, None, "Classroom location not found"
+            
+            # Calculate distance
+            distance = self.calculate_distance(
+                float(student_lat), 
+                float(student_lon),
+                class_lat, 
+                class_lon
+            )
+            
+            if distance is None:
+                return False, None, "Failed to calculate distance"
+            
+            # Check if within radius
+            is_within = distance <= radius
+            
+            logger.info(f"Location verification: within_area={is_within}, distance={distance:.2f}m, allowed_radius={radius}m")
+            
+            if is_within:
+                return True, distance, None
+            else:
+                return False, distance, f"You are {distance:.0f}m away from the classroom (max allowed: {radius}m)"
+                
+        except Exception as e:
+            logger.error(f"Location verification error: {str(e)}")
+            return False, None, f"Location verification failed: {str(e)}"
+    
+    def verify_location(self, student_lat, student_lon, classroom_id):
+        """
+        Complete location verification process
+        Implements: Student(x) ∧ IsWithinAllowedArea(x) → VerifiedLocation(x)
+        
+        Args:
+            student_lat: Student's latitude
+            student_lon: Student's longitude
+            classroom_id: ID of the classroom
+            
+        Returns:
+            dict: Verification result with status, distance, and message
+        """
+        is_within, distance, error = self.is_within_allowed_area(
+            student_lat, 
+            student_lon, 
+            classroom_id
+        )
+        
+        result = {
+            'verified': is_within,
+            'distance': distance,
+            'message': None,
+            'error': error
+        }
+        
+        if is_within:
+            result['message'] = f"Location verified! You are {distance:.0f}m from the classroom."
+        elif error:
+            result['message'] = error
+        
+        return result
+    
+    def get_all_classrooms(self):
+        """
+        Get all available classrooms
+        
+        Returns:
+            List of classroom dictionaries
+        """
+        try:
+            classrooms = Classroom.query.all()
+            return [classroom.to_dict() for classroom in classrooms]
+        except Exception as e:
+            logger.error(f"Error fetching classrooms: {str(e)}")
+            return []
+    
+    def add_classroom(self, name, building, latitude, longitude, radius_meters=None):
+        """
+        Add a new classroom to the system
+        
+        Args:
+            name: Classroom name
+            building: Building name
+            latitude: GPS latitude
+            longitude: GPS longitude
+            radius_meters: Geofencing radius (optional)
+            
+        Returns:
+            tuple: (success, classroom_dict or error_message)
+        """
+        try:
+            # Validate coordinates
+            valid, error = validate_coordinates(latitude, longitude)
+            if not valid:
+                return False, error
+            
+            # Create classroom
+            classroom = Classroom(
+                name=name,
+                building=building,
+                latitude=float(latitude),
+                longitude=float(longitude),
+                radius_meters=radius_meters or self.default_radius
+            )
+            
+            db.session.add(classroom)
+            db.session.commit()
+            
+            logger.info(f"Classroom added: {name} in {building}")
+            return True, classroom.to_dict()
+            
+        except Exception as e:
+            db.session.rollback()
+            logger.error(f"Error adding classroom: {str(e)}")
+            return False, f"Failed to add classroom: {str(e)}"
+
+
+# Singleton instance
+geolocation_module = GeolocationModule()

index.html

@@ -0,0 +1,172 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Attendr - Smart Attendance System</title>
+    <link rel="stylesheet" href="style.css">
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link
+        href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=Outfit:wght@700;800&display=swap"
+        rel="stylesheet">
+</head>
+
+<body>
+    <!-- Navigation -->
+    <!-- Navigation -->
+    {% include '_navbar.html' %}
+
+    <!-- Hero Section -->
+    <section class="section">
+        <div class="container">
+            <div class="text-center" style="max-width: 900px; margin: 0 auto;">
+                <h1 class="fade-in">Smart Attendance System</h1>
+                <p class="fade-in" style="font-size: 1.25rem; margin-bottom: 2rem; color: var(--color-text-secondary);">
+                    AI-powered attendance verification using facial recognition, geolocation, and auto-refresh codes
+                </p>
+
+                <!-- Feature Highlights -->
+                <div class="grid grid-3 mt-3 mb-3">
+                    <div class="glass-card fade-in" style="animation-delay: 0.1s;">
+                        <div style="font-size: 3rem; margin-bottom: 1rem;">🎭</div>
+                        <h3>Face Recognition</h3>
+                        <p>Biometric verification ensures only registered students can mark attendance</p>
+                    </div>
+
+                    <div class="glass-card fade-in" style="animation-delay: 0.2s;">
+                        <div style="font-size: 3rem; margin-bottom: 1rem;">📍</div>
+                        <h3>GPS Verification</h3>
+                        <p>Location-based validation confirms physical presence in the classroom</p>
+                    </div>
+
+                    <div class="glass-card fade-in" style="animation-delay: 0.3s;">
+                        <div style="font-size: 3rem; margin-bottom: 1rem;">🔄</div>
+                        <h3>Auto-Refresh Codes</h3>
+                        <p>Time-limited codes prevent sharing and proxy attendance</p>
+                    </div>
+                </div>
+
+                <!-- CTA Buttons -->
+                <div class="flex-center gap-2 mt-3">
+                    <a href="/student" class="btn btn-primary">
+                        <span>👤</span>
+                        <span>Student Portal</span>
+                    </a>
+                    <a href="/lecturer" class="btn btn-secondary">
+                        <span>👨‍🏫</span>
+                        <span>Lecturer Dashboard</span>
+                    </a>
+                    <a href="/register" class="btn btn-outline">
+                        <span>📝</span>
+                        <span>Register</span>
+                    </a>
+                </div>
+
+                <!-- System Overview -->
+                <div class="glass-card mt-3 text-left">
+                    <h2 class="mb-2">How It Works</h2>
+                    <div class="grid grid-2 gap-2">
+                        <div>
+                            <h3 style="color: var(--color-primary-light);">For Students</h3>
+                            <ol style="padding-left: 1.5rem; color: var(--color-text-secondary);">
+                                <li style="margin-bottom: 0.5rem;">Register your account and face</li>
+                                <li style="margin-bottom: 0.5rem;">Login and enable camera/GPS permissions</li>
+                                <li style="margin-bottom: 0.5rem;">System verifies your face and location</li>
+                                <li style="margin-bottom: 0.5rem;">Enter the attendance code from lecturer</li>
+                                <li style="margin-bottom: 0.5rem;">Attendance marked instantly!</li>
+                            </ol>
+                        </div>
+                        <div>
+                            <h3 style="color: var(--color-secondary);">For Lecturers</h3>
+                            <ol style="padding-left: 1.5rem; color: var(--color-text-secondary);">
+                                <li style="margin-bottom: 0.5rem;">Register lecturer account</li>
+                                <li style="margin-bottom: 0.5rem;">Login and create attendance session</li>
+                                <li style="margin-bottom: 0.5rem;">Display auto-refreshing code to students</li>
+                                <li style="margin-bottom: 0.5rem;">Monitor real-time attendance updates</li>
+                                <li style="margin-bottom: 0.5rem;">Export reports for record-keeping</li>
+                            </ol>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- Knowledge Representation -->
+                <div class="glass-card mt-3 text-left">
+                    <h2 class="mb-2">AI Logic & Security</h2>
+                    <p style="color: var(--color-text-secondary); margin-bottom: 1.5rem;">
+                        Attendr implements five Knowledge Representation (KR) rules using First-Order Logic to ensure
+                        secure, fraud-proof attendance:
+                    </p>
+                    <div class="grid grid-2 gap-2">
+                        <div class="alert alert-info">
+                            <div>
+                                <strong>KR Rule #1: Face Recognition</strong><br>
+                                <small>∀x ((CapturedFace(x) ∧ MatchStored(x)) → FaceMatch(x))</small>
+                            </div>
+                        </div>
+                        <div class="alert alert-info">
+                            <div>
+                                <strong>KR Rule #2: Location Verification</strong><br>
+                                <small>∀x[(Student(x) ∧ IsWithinAllowedArea(x)) → VerifiedLocation(x)]</small>
+                            </div>
+                        </div>
+                        <div class="alert alert-info">
+                            <div>
+                                <strong>KR Rule #3: Device Readiness</strong><br>
+                                <small>∀d ((CameraOn(d) ∧ GPSOn(d)) → StartVerification(d))</small>
+                            </div>
+                        </div>
+                        <div class="alert alert-info">
+                            <div>
+                                <strong>KR Rule #4: Attendance Validation</strong><br>
+                                <small>∀x ((FaceMatch(x) ∧ LocationValid(x)) → GrantCodeAccess(x))</small>
+                            </div>
+                        </div>
+                    </div>
+                    <div class="alert alert-success mt-2">
+                        <div>
+                            <strong>KR Rule #5: Auto-Refresh Code Confirmation</strong><br>
+                            <small>∀x ((ValidCodeEntry(User,x) ∧ WithinCycle(Code,x)) → MarkPresent(System,x))</small>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </section>
+
+    <script>
+        // Add stagger animation to cards
+        document.addEventListener('DOMContentLoaded', () => {
+            const cards = document.querySelectorAll('.fade-in');
+            cards.forEach((card, index) => {
+                card.style.animationDelay = `${index * 0.1}s`;
+            });
+        });
+
+        // Logout function
+        async function logout() {
+            if (!confirm('Are you sure you want to logout?')) return;
+
+            try {
+                const response = await fetch('/api/auth/logout', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' }
+                });
+
+                const data = await response.json();
+
+                if (data.success) {
+                    alert(data.message);
+                    window.location.href = '/';
+                } else {
+                    alert('Logout failed');
+                }
+            } catch (error) {
+                alert('Logout failed');
+            }
+        }
+    </script>
+</body>
+
+</html>

init_db.py

@@ -0,0 +1,89 @@
+"""
+Database initialization script for Attendr
+Creates tables and seeds sample data
+"""
+
+from app import app, db
+from models import Student, Classroom, AttendanceSession, AttendanceRecord
+from datetime import datetime
+
+def init_database():
+    """Initialize database with tables and sample data"""
+    
+    with app.app_context():
+        # Drop all tables (use with caution in production!)
+        print("Dropping existing tables...")
+        db.drop_all()
+        
+        # Create all tables
+        print("Creating tables...")
+        db.create_all()
+        
+        # Seed sample classrooms (UTM locations)
+        print("Seeding sample classrooms...")
+        
+        classrooms = [
+            Classroom(
+                name="N28-01-01",
+                building="N28 (Faculty of Computing)",
+                latitude=1.5586,  # UTM Skudai approximate coordinates
+                longitude=103.6376,
+                radius_meters=50
+            ),
+            Classroom(
+                name="N28-02-03",
+                building="N28 (Faculty of Computing)",
+                latitude=1.5588,
+                longitude=103.6378,
+                radius_meters=50
+            ),
+            Classroom(
+                name="V01-LT1",
+                building="V01 (Lecture Hall)",
+                latitude=1.5590,
+                longitude=103.6380,
+                radius_meters=75
+            ),
+            Classroom(
+                name="C22-Lab A",
+                building="C22 (Computer Lab)",
+                latitude=1.5584,
+                longitude=103.6374,
+                radius_meters=40
+            )
+        ]
+        
+        for classroom in classrooms:
+            db.session.add(classroom)
+        
+        db.session.commit()
+        print(f"[OK] Created {len(classrooms)} classrooms")
+        
+        # Create a sample student for testing (without face encoding)
+        print("Creating sample student...")
+        sample_student = Student(
+            student_id="A20EC0001",
+            name="Test Student",
+            email="test@graduate.utm.my",
+            is_active=True
+        )
+        db.session.add(sample_student)
+        db.session.commit()
+        print("[OK] Created sample student (face registration required)")
+        
+        print("\n" + "="*50)
+        print("Database initialization complete!")
+        print("="*50)
+        print("\nSample Classrooms:")
+        for classroom in classrooms:
+            print(f"  - {classroom.name} ({classroom.building})")
+        print(f"\nSample Student: {sample_student.student_id} - {sample_student.name}")
+        print("\nNext steps:")
+        print("1. Run the Flask app: python app.py")
+        print("2. Register student faces at: http://localhost:5000/register")
+        print("3. Create attendance session at: http://localhost:5000/lecturer")
+        print("4. Mark attendance at: http://localhost:5000/student")
+        print("="*50)
+
+if __name__ == '__main__':
+    init_database()

lecturer.html

@@ -0,0 +1,298 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Lecturer Dashboard - Attendr</title>
+    <link rel="stylesheet" href="style.css">
+    <link
+        href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=Outfit:wght@700;800&display=swap"
+        rel="stylesheet">
+</head>
+
+<body>
+    <!-- Navigation -->
+    <!-- Navigation -->
+    {% include '_navbar.html' %}
+
+    <!-- Main Content -->
+    <section class="section">
+        <div class="container">
+            <h1 class="text-center mb-3">Lecturer Dashboard</h1>
+
+            <div class="grid grid-2 gap-2">
+                <!-- Left Column: Session Management -->
+                <div>
+                    <!-- Create Session -->
+                    <div id="createSessionCard" class="glass-card mb-2">
+                        <h2>Create Attendance Session</h2>
+
+                        <div class="form-group">
+                            <label class="form-label">Course Name</label>
+                            <select id="courseName" class="form-select">
+                                <option value="">Select a course...</option>
+
+                                <optgroup label="CORE COURSES">
+                                    <option value="SECI1013 - Discrete Structure">SECI1013 - Discrete Structure
+                                    </option>
+                                    <option value="SECJ1013 - Programming Technique I">SECJ1013 - Programming
+                                        Technique
+                                        I</option>
+                                    <option value="SECR1013 - Digital Logic">SECR1013 - Digital Logic</option>
+                                    <option value="SECP1513 - Technology & Information System">SECP1513 - Technology
+                                        &
+                                        Information System</option>
+                                    <option value="SECI1113 - Computational Mathematics">SECI1113 - Computational
+                                        Mathematics</option>
+                                    <option value="SECI2143 - Probability & Statistical Data Analysis">SECI2143 -
+                                        Probability & Statistical Data Analysis</option>
+                                    <option value="SECJ1023 - Programming Technique II">SECJ1023 - Programming
+                                        Technique
+                                        II</option>
+                                    <option value="SECR1033 - Computer Organisation and Architecture">SECR1033 -
+                                        Computer Organisation and Architecture</option>
+                                    <option value="SECD2523 - Database">SECD2523 - Database</option>
+                                    <option value="SECD2613 - System Analysis and Design">SECD2613 - System Analysis
+                                        and
+                                        Design</option>
+                                    <option value="SECJ2013 - Data Structure and Algorithm">SECJ2013 - Data
+                                        Structure
+                                        and Algorithm</option>
+                                    <option value="SECR1213 - Network Communications">SECR1213 - Network
+                                        Communications
+                                    </option>
+                                    <option value="SECV2113 - Human Computer Interaction">SECV2113 - Human Computer
+                                        Interaction</option>
+                                    <option value="SECJ2203 - Software Engineering">SECJ2203 - Software Engineering
+                                    </option>
+                                    <option value="SECV1223 - Web Programming">SECV1223 - Web Programming</option>
+                                    <option value="SECR2043 - Operating Systems">SECR2043 - Operating Systems
+                                    </option>
+                                    <option value="SECJ2154 - Object Oriented Programming">SECJ2154 - Object
+                                        Oriented
+                                        Programming</option>
+                                    <option value="SECR3032 - Computer Networks and Security Project I">SECR3032 -
+                                        Computer Networks and Security Project I</option>
+                                    <option value="SECJ3203 - Theory of Computer Science">SECJ3203 - Theory of
+                                        Computer
+                                        Science</option>
+                                    <option value="SECR4118 - Industrial Training">SECR4118 - Industrial Training
+                                    </option>
+                                    <option value="SECR4114 - Industrial Training Report">SECR4114 - Industrial
+                                        Training
+                                        Report</option>
+                                    <option value="SECR4134 - Computer Networks and Security Project II">SECR4134 -
+                                        Computer Networks and Security Project II</option>
+                                    <option value="SCSD3761 - Technopreneurship Seminar">SCSD3761 -
+                                        Technopreneurship
+                                        Seminar</option>
+                                </optgroup>
+
+                                <optgroup label="ELECTIVES - SECRH">
+                                    <option value="SECR3104 - Applications Development">SECR3104 - Applications
+                                        Development</option>
+                                    <option value="SECJ3553 - Artificial Intelligence">SECJ3553 - Artificial
+                                        Intelligence</option>
+                                    <option value="SECR2242 - Computer Networks">SECR2242 - Computer Networks
+                                    </option>
+                                    <option value="SECR2941 - Computer Networks Lab">SECR2941 - Computer Networks
+                                        Lab
+                                    </option>
+                                    <option value="SECR3241 - Internetworking Technology">SECR3241 - Internetworking
+                                        Technology</option>
+                                    <option value="SECR3941 - Internetworking Technology Lab">SECR3941 -
+                                        Internetworking
+                                        Technology Lab</option>
+                                    <option value="SECR3413 - Computer Security">SECR3413 - Computer Security
+                                    </option>
+                                    <option value="SECR3443 - Cryptography">SECR3443 - Cryptography</option>
+                                    <option value="SECR3223 - High Performance & Parallel Computing">SECR3223 - High
+                                        Performance & Parallel Computing</option>
+                                    <option value="SECR3253 - Network Programming">SECR3253 - Network Programming
+                                    </option>
+                                    <option value="SECR3263 - Wireless Sensor Network">SECR3263 - Wireless Sensor
+                                        Network</option>
+                                    <option value="SECR4453 - Network Security">SECR4453 - Network Security</option>
+                                    <option value="SECR4483 - Secure Programming">SECR4483 - Secure Programming
+                                    </option>
+                                    <option value="SECR4973 - Special Topics on Computer Network & Security">
+                                        SECR4973 -
+                                        Special Topics on Computer Network & Security</option>
+                                </optgroup>
+
+                                <optgroup label="ELECTIVES - PRISMS">
+                                    <option value="SECR5013 - Cryptographic Engineering">SECR5013 - Cryptographic
+                                        Engineering</option>
+                                    <option value="SECR5023 - Digital Forensics">SECR5023 - Digital Forensics
+                                    </option>
+                                    <option value="SECR5033 - Information Security Governance and Risk Management">
+                                        SECR5033 - Information Security Governance and Risk Management</option>
+                                    <option value="SECR5043 - Cloud Computing Security">SECR5043 - Cloud Computing
+                                        Security</option>
+                                    <option value="SECR5053 - Penetration Testing">SECR5053 - Penetration Testing
+                                    </option>
+                                    <option value="SECJ5013 - Secure Software Engineering">SECJ5013 - Secure
+                                        Software
+                                        Engineering</option>
+                                    <option value="SECJ5023 - Advanced Theory of Computer Science">SECJ5023 -
+                                        Advanced
+                                        Theory of Computer Science</option>
+                                    <option value="SECJ5033 - Advanced Data Structure and Algorithms">SECJ5033 -
+                                        Advanced Data Structure and Algorithms</option>
+                                    <option value="SECJ5043 - Advanced Artificial Intelligence">SECJ5043 - Advanced
+                                        Artificial Intelligence</option>
+                                    <option value="SECP5013 - Advanced Analytics for Data Science">SECP5013 -
+                                        Advanced
+                                        Analytics for Data Science</option>
+                                    <option value="SECP5023 - Big Data Management">SECP5023 - Big Data Management
+                                    </option>
+                                    <option value="SECP5033 - Business Intelligence and Analytics">SECP5033 -
+                                        Business
+                                        Intelligence and Analytics</option>
+                                    <option value="SECP5043 - Data Science Governance">SECP5043 - Data Science
+                                        Governance</option>
+                                    <option value="SECP5053 - Massive Mining and Streaming">SECP5053 - Massive
+                                        Mining
+                                        and Streaming</option>
+                                    <option value="SECP5063 - Statistics for Data Science">SECP5063 - Statistics for
+                                        Data Science</option>
+                                </optgroup>
+
+                                <optgroup label="UNIVERSITY GENERAL COURSES">
+                                    <option value="UHIS1022 - Philosophy and Current Issues">UHIS1022 - Philosophy
+                                        and
+                                        Current Issues</option>
+                                    <option value="UHMS1182 - Appreciation of Ethics and Civilisation">UHMS1182 -
+                                        Appreciation of Ethics and Civilisation</option>
+                                    <option value="UHLM1012 - Malaysia Language for Communication">UHLM1012 -
+                                        Malaysia
+                                        Language for Communication</option>
+                                    <option value="ULRS3032 - Entrepreneurship and Innovation">ULRS3032 -
+                                        Entrepreneurship and Innovation</option>
+                                    <option value="ULRS1012 - Value and Identity">ULRS1012 - Value and Identity
+                                    </option>
+                                    <option value="UKQF2xx2 - Service Learning Co-curriculum Elective">UKQF2xx2 -
+                                        Service Learning Co-curriculum Elective</option>
+                                    <option value="UHLB2122 - Academic Communication Skills">UHLB2122 - Academic
+                                        Communication Skills</option>
+                                    <option value="UHLB3132 - Professional Communication Skills">UHLB3132 -
+                                        Professional
+                                        Communication Skills</option>
+                                    <option value="UHLx1112 - Foreign Language Elective">UHLx1112 - Foreign Language
+                                        Elective</option>
+                                </optgroup>
+                            </select>
+                        </div>
+
+                        <div class="form-group">
+                            <label class="form-label">Lecturer Name</label>
+                            <input type="text" id="lecturerName" class="form-input" placeholder="Your name">
+                        </div>
+
+                        <div class="form-group">
+                            <label class="form-label">Classroom</label>
+                            <select id="classroomSelect" class="form-select">
+                                <option value="">Loading classrooms...</option>
+                            </select>
+                        </div>
+
+                        <button id="createSessionBtn" class="btn btn-primary">Create Session</button>
+                    </div>
+
+                    <!-- Active Sessions List -->
+                    <div class="glass-card">
+                        <h3>Active Sessions</h3>
+                        <div id="sessionsList" class="mt-2">
+                            <p class="text-muted">No active sessions</p>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- Right Column: Current Session Display -->
+                <div>
+                    <!-- Attendance Code Display -->
+                    <div id="codeDisplayCard" class="glass-card mb-2 hidden">
+                        <h2 class="text-center">Attendance Code</h2>
+                        <div class="code-display" id="attendanceCodeDisplay">------</div>
+                        <div class="text-center">
+                            <p class="text-muted" id="codeTimer">Refreshes in: --s</p>
+                            <p class="text-muted" style="font-size: 0.875rem;">Code refreshes every 10 seconds</p>
+                        </div>
+                        <button id="endSessionBtn" class="btn btn-outline mt-2" style="width: 100%;">End
+                            Session</button>
+                    </div>
+
+                    <!-- Attendance Statistics -->
+                    <div id="statsCard" class="glass-card mb-2 hidden">
+                        <h3>Attendance Statistics</h3>
+                        <div class="grid grid-2 gap-2 mt-2">
+                            <div class="text-center">
+                                <div style="font-size: 2.5rem; font-weight: 700; color: var(--color-success);"
+                                    id="presentCount">0</div>
+                                <p class="text-muted">Present</p>
+                            </div>
+                            <div class="text-center">
+                                <div style="font-size: 2.5rem; font-weight: 700; color: var(--color-primary);"
+                                    id="sessionDuration">0m</div>
+                                <p class="text-muted">Duration</p>
+                            </div>
+                        </div>
+                    </div>
+
+                    <!-- Real-time Attendance List -->
+                    <div id="attendanceListCard" class="glass-card hidden">
+                        <div
+                            style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 1rem;">
+                            <h3 style="margin: 0;">Attendance Records</h3>
+                            <button id="exportBtn" class="btn btn-secondary"
+                                style="padding: 0.5rem 1rem; font-size: 0.875rem;">📥 Export</button>
+                        </div>
+                        <div id="attendanceList" style="max-height: 400px; overflow-y: auto;">
+                            <p class="text-muted">No attendance records yet</p>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </section>
+
+    <!-- Loading Overlay -->
+    <div id="loadingOverlay" class="loading-overlay hidden">
+        <div class="text-center">
+            <div class="spinner"></div>
+            <p class="mt-2" id="loadingText">Processing...</p>
+        </div>
+    </div>
+
+    <!-- Error/Success Messages -->
+    <div id="messageDisplay" class="hidden"
+        style="position: fixed; top: 100px; right: 20px; z-index: 9999; max-width: 400px;"></div>
+
+    <script src="{{ url_for('static', filename='js/lecturer.js') }}"></script>
+    <script>
+        async function logout() {
+            if (!confirm('Are you sure you want to logout?')) return;
+
+            try {
+                const response = await fetch('/api/auth/logout', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' }
+                });
+
+                const data = await response.json();
+
+                if (data.success) {
+                    alert(data.message);
+                    window.location.href = '/';
+                } else {
+                    alert('Logout failed');
+                }
+            } catch (error) {
+                alert('Logout failed');
+            }
+        }
+    </script>
+</body>
+
+</html>

lecturer_history.html

@@ -0,0 +1,248 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Session History - Attendr</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}">
+    <link
+        href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=Outfit:wght@700;800&display=swap"
+        rel="stylesheet">
+</head>
+
+<body>
+    <!-- Navigation -->
+    <!-- Navigation -->
+    {% include '_navbar.html' %}
+
+    <!-- Main Content -->
+    <section class="section">
+        <div class="container">
+            <h1 class="text-center mb-3">📊 Session History</h1>
+
+            <!-- Lecturer Info Card -->
+            <div class="glass-card mb-2">
+                <div class="flex-between">
+                    <div>
+                        <h3 id="lecturerName">Loading...</h3>
+                        <p class="text-muted" id="lecturerId"></p>
+                    </div>
+                    <div class="text-right">
+                        <div style="font-size: 3rem; color: var(--color-primary);" id="totalSessions">0</div>
+                        <p class="text-muted">Total Sessions</p>
+                    </div>
+                </div>
+            </div>
+
+            <!-- Session Records -->
+            <div id="historyContainer">
+                <div class="text-center mt-3">
+                    <div class="spinner"></div>
+                    <p class="text-muted mt-2">Loading session history...</p>
+                </div>
+            </div>
+
+            <!-- Empty State -->
+            <div id="emptyState" class="glass-card text-center hidden" style="padding: 3rem;">
+                <div style="font-size: 4rem; margin-bottom: 1rem;">📭</div>
+                <h2>No Sessions Yet</h2>
+                <p class="text-muted mt-2">You haven't created any attendance sessions yet. Go to the dashboard to
+                    create your first session!</p>
+                <a href="/lecturer" class="btn btn-primary mt-2">Create Session</a>
+            </div>
+        </div>
+    </section>
+
+    <script>
+        // Load session history on page load
+        document.addEventListener('DOMContentLoaded', loadHistory);
+
+        async function loadHistory() {
+            try {
+                const response = await fetch('/api/lecturer/history');
+                const data = await response.json();
+
+                if (data.success) {
+                    displayHistory(data.data);
+                } else {
+                    showError(data.error);
+                }
+            } catch (error) {
+                showError('Failed to load session history');
+            }
+        }
+
+        function displayHistory(data) {
+            // Update lecturer info
+            document.getElementById('lecturerName').textContent = data.lecturer.name;
+            document.getElementById('lecturerId').textContent = `Matric: ${data.lecturer.matric_no}`;
+            document.getElementById('totalSessions').textContent = data.total_sessions;
+
+            const container = document.getElementById('historyContainer');
+
+            if (data.history.length === 0) {
+                container.innerHTML = '';
+                document.getElementById('emptyState').classList.remove('hidden');
+                return;
+            }
+
+            // Store history data globally for export function
+            window.sessionHistory = data.history;
+
+            // Build history cards
+            let html = '<div class="grid grid-1 gap-2">';
+
+            data.history.forEach(session => {
+                const startDate = new Date(session.start_time);
+                const endDate = session.end_time ? new Date(session.end_time) : null;
+                const statusBadge = session.is_active
+                    ? '<span class="badge badge-success">🟢 Active</span>'
+                    : '<span class="badge" style="background: rgba(100,100,100,0.2);">⚫ Ended</span>';
+
+                html += `
+                <div class="glass-card">
+                    <div class="flex-between mb-1">
+                        <div>
+                            <h3>${session.course_name}</h3>
+                            <p class="text-muted">${session.classroom} - ${session.building}</p>
+                        </div>
+                        ${statusBadge}
+                    </div>
+                    
+                    <div class="grid grid-3 gap-1 mt-2" style="font-size: 0.9rem;">
+                        <div>
+                            <strong>📅 Started:</strong><br>
+                            ${startDate.toLocaleDateString()} ${startDate.toLocaleTimeString()}
+                        </div>
+                        <div>
+                            <strong>⏱️ Duration:</strong><br>
+                            ${session.duration_minutes} minutes
+                        </div>
+                        <div>
+                            <strong>👥 Attendance:</strong><br>
+                            ${session.present_count} / ${session.total_attendance} students
+                        </div>
+                    </div>
+
+                    ${session.attendance_records.length > 0 ? `
+                        <div class="mt-2">
+                            <div class="grid grid-2 gap-1">
+                                <button class="btn btn-outline" onclick="toggleDetails(${session.id})">
+                                    📋 View Details (${session.attendance_records.length})
+                                </button>
+                                <button class="btn btn-secondary" onclick="exportSession(${session.id})">
+                                    📥 Export CSV
+                                </button>
+                            </div>
+                            <div id="details-${session.id}" class="hidden mt-2" style="max-height: 300px; overflow-y: auto;">
+                                <table style="width: 100%; font-size: 0.875rem;">
+                                    <thead>
+                                        <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);">
+                                            <th style="padding: 0.5rem; text-align: left;">Student ID</th>
+                                            <th style="padding: 0.5rem; text-align: left;">Name</th>
+                                            <th style="padding: 0.5rem; text-align: center;">Time</th>
+                                            <th style="padding: 0.5rem; text-align: center;">Verification</th>
+                                        </tr>
+                                    </thead>
+                                    <tbody>
+                                        ${session.attendance_records.map(record => {
+                    const markedTime = new Date(record.marked_at);
+                    return `
+                                                <tr style="border-bottom: 1px solid rgba(255,255,255,0.05);">
+                                                    <td style="padding: 0.5rem;">${record.student_id}</td>
+                                                    <td style="padding: 0.5rem;">${record.student_name}</td>
+                                                    <td style="padding: 0.5rem; text-align: center;">${markedTime.toLocaleTimeString()}</td>
+                                                    <td style="padding: 0.5rem; text-align: center;">
+                                                        <span class="badge ${record.face_verified ? 'badge-success' : 'badge-error'}" style="font-size: 0.7rem;">Face</span>
+                                                        <span class="badge ${record.location_verified ? 'badge-success' : 'badge-error'}" style="font-size: 0.7rem;">GPS</span>
+                                                        <span class="badge ${record.code_verified ? 'badge-success' : 'badge-error'}" style="font-size: 0.7rem;">Code</span>
+                                                    </td>
+                                                </tr>
+                                            `;
+                }).join('')}
+                                    </tbody>
+                                </table>
+                            </div>
+                        </div>
+                    ` : '<p class="text-muted mt-2">No attendance records</p>'}
+                </div>
+            `;
+            });
+
+            html += '</div>';
+            container.innerHTML = html;
+        }
+
+        function toggleDetails(sessionId) {
+            const details = document.getElementById(`details-${sessionId}`);
+            details.classList.toggle('hidden');
+        }
+
+        function exportSession(sessionId) {
+            const session = window.sessionHistory.find(s => s.id === sessionId);
+            if (!session) return;
+
+            const rows = [
+                ['Student ID', 'Name', 'Time', 'Face Verified', 'Location Verified', 'Code Verified']
+            ];
+
+            session.attendance_records.forEach(record => {
+                const dateObj = new Date(record.marked_at);
+                const time = `${dateObj.toLocaleDateString()} ${dateObj.toLocaleTimeString()}`;
+                rows.push([
+                    record.student_id,
+                    record.student_name,
+                    time,
+                    record.face_verified ? 'Yes' : 'No',
+                    record.location_verified ? 'Yes' : 'No',
+                    record.code_verified ? 'Yes' : 'No'
+                ]);
+            });
+
+            let csvContent = "data:text/csv;charset=utf-8,"
+                + rows.map(e => e.map(cell => `"${cell}"`).join(",")).join("\n");
+
+            const encodedUri = encodeURI(csvContent);
+            const link = document.createElement("a");
+            link.setAttribute("href", encodedUri);
+            link.setAttribute("download", `attendance_${session.course_name}_${new Date().toISOString().slice(0, 10)}.csv`);
+            document.body.appendChild(link);
+            link.click();
+            document.body.removeChild(link);
+        }
+
+        function showError(message) {
+            const container = document.getElementById('historyContainer');
+            container.innerHTML = `
+            <div class="alert alert-error">
+                ${message}
+            </div>
+        `;
+        }
+
+        async function logout() {
+            if (!confirm('Are you sure you want to logout?')) return;
+
+            try {
+                const response = await fetch('/api/auth/logout', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' }
+                });
+
+                const data = await response.json();
+
+                if (data.success) {
+                    alert(data.message);
+                    window.location.href = '/';
+                } else {
+                    alert('Logout failed');
+                }
+            } catch (error) {
+                alert('Logout failed');
+            }
+        }
+    </script>
+</body>
+
+</html>

login.html

@@ -0,0 +1,141 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Login - Attendr</title>
+    <link rel="stylesheet" href="style.css">
+    <link
+        href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=Outfit:wght@700;800&display=swap"
+        rel="stylesheet">
+</head>
+
+<body>
+    <!-- Navigation -->
+    <!-- Navigation -->
+    {% include '_navbar.html' %}
+
+    <!-- Main Content -->
+    <section class="section">
+        <div class="container" style="max-width: 500px;">
+            <h1 class="text-center mb-3">Login to Attendr</h1>
+            <p class="text-center text-muted mb-3">
+                Access your student or lecturer account
+            </p>
+
+            <!-- Login Form -->
+            <div class="glass-card">
+                <div class="form-group">
+                    <label class="form-label">Matric Number</label>
+                    <input type="text" id="matricNo" class="form-input" placeholder="e.g., A20EC0001 or L001"
+                        style="text-transform: uppercase;">
+                    <small class="text-muted" style="font-size: 0.875rem;">
+                        Students: Start with A or B | Lecturers: Start with L
+                    </small>
+                </div>
+
+                <div class="form-group">
+                    <label class="form-label">Password</label>
+                    <input type="password" id="password" class="form-input" placeholder="Enter your password">
+                </div>
+
+                <!-- Status Messages -->
+                <div id="statusMessage" class="mt-2"></div>
+
+                <!-- Login Button -->
+                <button id="loginBtn" class="btn btn-primary mt-2" style="width: 100%;">
+                    🔐 Login
+                </button>
+
+                <div class="text-center mt-2">
+                    <p class="text-muted">
+                        Don't have an account? <a href="/register" style="color: var(--color-primary);">Register
+                            here</a>
+                    </p>
+                </div>
+            </div>
+        </div>
+    </section>
+
+    <!-- Loading Overlay -->
+    <div id="loadingOverlay" class="loading-overlay hidden">
+        <div class="text-center">
+            <div class="spinner"></div>
+            <p class="mt-2" id="loadingText">Logging in...</p>
+        </div>
+    </div>
+
+    <script>
+        // Handle Enter key
+        document.getElementById('password').addEventListener('keypress', (e) => {
+            if (e.key === 'Enter') {
+                document.getElementById('loginBtn').click();
+            }
+        });
+
+        // Login function
+        document.getElementById('loginBtn').addEventListener('click', async () => {
+            const matricNo = document.getElementById('matricNo').value.trim().toUpperCase();
+            const password = document.getElementById('password').value;
+
+            if (!matricNo || !password) {
+                showStatus('Please fill in all fields', 'error');
+                return;
+            }
+
+            showLoading('Logging in...');
+
+            try {
+                const response = await fetch('/api/auth/login', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        matric_no: matricNo,
+                        password: password
+                    })
+                });
+
+                const data = await response.json();
+                hideLoading();
+
+                if (data.success) {
+                    showStatus(data.message, 'success');
+
+                    // Redirect after 1 second
+                    setTimeout(() => {
+                        window.location.href = data.data.redirect;
+                    }, 1000);
+                } else {
+                    showStatus(data.error, 'error');
+                }
+            } catch (error) {
+                hideLoading();
+                showStatus('Login failed. Please try again.', 'error');
+            }
+        });
+
+        function showLoading(text) {
+            document.getElementById('loadingText').textContent = text;
+            document.getElementById('loadingOverlay').classList.remove('hidden');
+        }
+
+        function hideLoading() {
+            document.getElementById('loadingOverlay').classList.add('hidden');
+        }
+
+        function showStatus(message, type) {
+            const statusDiv = document.getElementById('statusMessage');
+            const alertClass = type === 'success' ? 'alert-success' : 'alert-error';
+            statusDiv.innerHTML = `<div class="alert ${alertClass}">${message}</div>`;
+
+            if (type === 'error') {
+                setTimeout(() => {
+                    statusDiv.innerHTML = '';
+                }, 5000);
+            }
+        }
+    </script>
+</body>
+
+</html>

models.py

@@ -0,0 +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
+        }

register.html

@@ -0,0 +1,366 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Register - Attendr</title>
+    <link rel="stylesheet" href="style.css">
+    <link
+        href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=Outfit:wght@700;800&display=swap"
+        rel="stylesheet">
+</head>
+
+<body>
+    <!-- Navigation -->
+    <!-- Navigation -->
+    {% include '_navbar.html' %}
+
+    <!-- Main Content -->
+    <section class="section">
+        <div class="container" style="max-width: 800px;">
+            <h1 class="text-center mb-3">Register Account</h1>
+            <p class="text-center text-muted mb-3">
+                Create your student or lecturer account
+            </p>
+
+            <!-- Step 1: Account Details -->
+            <div id="step1Card" class="glass-card">
+                <h2 class="mb-2">Step 1: Account Information</h2>
+
+                <div class="form-group">
+                    <label class="form-label">I am a...</label>
+                    <select id="roleSelect" class="form-select">
+                        <option value="">Select your role</option>
+                        <option value="student">Student</option>
+                        <option value="lecturer">Lecturer</option>
+                    </select>
+                </div>
+
+                <div class="form-group">
+                    <label class="form-label">Matric Number</label>
+                    <input type="text" id="matricNo" class="form-input" placeholder="e.g., A20EC0001 or L001"
+                        style="text-transform: uppercase;">
+                    <small class="text-muted" id="matricHelp" style="font-size: 0.875rem;">
+                        Select your role first
+                    </small>
+                </div>
+
+                <div class="form-group">
+                    <label class="form-label">Full Name</label>
+                    <input type="text" id="fullName" class="form-input" placeholder="Your full name">
+                </div>
+
+                <div class="form-group">
+                    <label class="form-label">Email (Optional)</label>
+                    <input type="email" id="email" class="form-input" placeholder="your.email@graduate.utm.my">
+                </div>
+
+                <div class="form-group">
+                    <label class="form-label">Password</label>
+                    <input type="password" id="password" class="form-input" placeholder="Create a strong password">
+                </div>
+
+                <div class="form-group">
+                    <label class="form-label">Confirm Password</label>
+                    <input type="password" id="confirmPassword" class="form-input" placeholder="Re-enter your password">
+                </div>
+
+                <div id="statusMessage" class="mt-2"></div>
+
+                <button id="nextBtn" class="btn btn-primary mt-2" style="width: 100%;">
+                    Next: Face Registration →
+                </button>
+
+                <div class="text-center mt-2">
+                    <p class="text-muted">
+                        Already have an account? <a href="/login" style="color: var(--color-primary);">Login here</a>
+                    </p>
+                </div>
+            </div>
+
+            <!-- Step 2: Face Registration (Students Only) -->
+            <div id="step2Card" class="glass-card mt-2 hidden">
+                <h2 class="mb-2">Step 2: Face Registration</h2>
+                <p class="text-muted mb-2">Capture your face for biometric verification</p>
+
+                <div class="text-center">
+                    <video id="video" width="400" height="300" autoplay
+                        style="border-radius: 12px; border: 2px solid var(--color-primary);"></video>
+                    <canvas id="canvas" width="400" height="300" style="display: none;"></canvas>
+
+                    <div id="preview" class="mt-2 hidden">
+                        <img id="capturedImage"
+                            style="max-width: 400px; border-radius: 12px; border: 2px solid var(--color-success);">
+                    </div>
+                </div>
+
+                <div id="faceStatusMessage" class="mt-2"></div>
+
+                <div class="flex-center gap-2 mt-2">
+                    <button id="startCameraBtn" class="btn btn-secondary">
+                        📷 Start Camera
+                    </button>
+                    <button id="captureBtn" class="btn btn-primary hidden">
+                        📸 Capture Face
+                    </button>
+                    <button id="retakeBtn" class="btn btn-outline hidden">
+                        🔄 Retake
+                    </button>
+                    <button id="registerBtn" class="btn btn-success hidden">
+                        ✅ Complete Registration
+                    </button>
+                </div>
+
+                <div class="text-center mt-2">
+                    <button id="backBtn" class="btn btn-outline">
+                        ← Back to Account Details
+                    </button>
+                </div>
+            </div>
+
+            <!-- Success Message -->
+            <div id="successCard" class="glass-card mt-2 hidden"
+                style="background: rgba(34, 197, 94, 0.1); border: 2px solid var(--color-success);">
+                <div class="text-center">
+                    <div style="font-size: 4rem; margin-bottom: 1rem;">✅</div>
+                    <h2 style="color: var(--color-success);">Registration Successful!</h2>
+                    <p class="text-muted mt-2" id="successMessage">Your account has been created successfully.</p>
+                    <div class="flex-center gap-2 mt-2">
+                        <a href="/login" class="btn btn-primary">Go to Login</a>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </section>
+
+    <!-- Loading Overlay -->
+    <div id="loadingOverlay" class="loading-overlay hidden">
+        <div class="text-center">
+            <div class="spinner"></div>
+            <p class="mt-2" id="loadingText">Processing...</p>
+        </div>
+    </div>
+
+    <script>
+        let videoStream = null;
+        let capturedImageData = null;
+        let userRole = null;
+
+        // Update matric number help text based on role
+        document.getElementById('roleSelect').addEventListener('change', (e) => {
+            userRole = e.target.value;
+            const helpText = document.getElementById('matricHelp');
+
+            if (userRole === 'student') {
+                helpText.textContent = 'Student matric number must start with A or B (e.g., A20EC0001)';
+                helpText.style.color = 'var(--color-primary)';
+            } else if (userRole === 'lecturer') {
+                helpText.textContent = 'Lecturer matric number must start with L (e.g., L001)';
+                helpText.style.color = 'var(--color-primary)';
+            } else {
+                helpText.textContent = 'Select your role first';
+                helpText.style.color = 'var(--color-text-muted)';
+            }
+        });
+
+        // Next button - validate and move to face registration
+        document.getElementById('nextBtn').addEventListener('click', async () => {
+            const role = document.getElementById('roleSelect').value;
+            const matricNo = document.getElementById('matricNo').value.trim().toUpperCase();
+            const fullName = document.getElementById('fullName').value.trim();
+            const password = document.getElementById('password').value;
+            const confirmPassword = document.getElementById('confirmPassword').value;
+
+            // Validation
+            if (!role) {
+                showStatus('Please select your role', 'error');
+                return;
+            }
+
+            if (!matricNo || !fullName || !password) {
+                showStatus('Please fill in all required fields', 'error');
+                return;
+            }
+
+            if (password !== confirmPassword) {
+                showStatus('Passwords do not match', 'error');
+                return;
+            }
+
+            if (password.length < 6) {
+                showStatus('Password must be at least 6 characters long', 'error');
+                return;
+            }
+
+            // If lecturer, register directly (no face needed)
+            if (role === 'lecturer') {
+                await registerUser(false);
+            } else {
+                // Student - go to face registration
+                document.getElementById('step1Card').classList.add('hidden');
+                document.getElementById('step2Card').classList.remove('hidden');
+            }
+        });
+
+        // Back button
+        document.getElementById('backBtn').addEventListener('click', () => {
+            stopCamera();
+            document.getElementById('step2Card').classList.add('hidden');
+            document.getElementById('step1Card').classList.remove('hidden');
+        });
+
+        // Camera controls
+        document.getElementById('startCameraBtn').addEventListener('click', startCamera);
+        document.getElementById('captureBtn').addEventListener('click', captureFace);
+        document.getElementById('retakeBtn').addEventListener('click', retake);
+        document.getElementById('registerBtn').addEventListener('click', () => registerUser(true));
+
+        async function startCamera() {
+            try {
+                videoStream = await navigator.mediaDevices.getUserMedia({ video: true });
+                document.getElementById('video').srcObject = videoStream;
+                document.getElementById('startCameraBtn').classList.add('hidden');
+                document.getElementById('captureBtn').classList.remove('hidden');
+                showFaceStatus('Camera ready! Position your face in the frame', 'success');
+            } catch (error) {
+                showFaceStatus('Camera access denied. Please allow camera access.', 'error');
+            }
+        }
+
+        function stopCamera() {
+            if (videoStream) {
+                videoStream.getTracks().forEach(track => track.stop());
+                videoStream = null;
+            }
+        }
+
+        function captureFace() {
+            const video = document.getElementById('video');
+            const canvas = document.getElementById('canvas');
+            const context = canvas.getContext('2d');
+
+            context.drawImage(video, 0, 0, 400, 300);
+            capturedImageData = canvas.toDataURL('image/jpeg');
+
+            document.getElementById('capturedImage').src = capturedImageData;
+            document.getElementById('preview').classList.remove('hidden');
+            document.getElementById('video').style.display = 'none';
+            document.getElementById('captureBtn').classList.add('hidden');
+            document.getElementById('retakeBtn').classList.remove('hidden');
+            document.getElementById('registerBtn').classList.remove('hidden');
+
+            stopCamera();
+            showFaceStatus('Face captured! Click "Complete Registration" to finish', 'success');
+        }
+
+        function retake() {
+            document.getElementById('preview').classList.add('hidden');
+            document.getElementById('video').style.display = 'block';
+            document.getElementById('retakeBtn').classList.add('hidden');
+            document.getElementById('registerBtn').classList.add('hidden');
+            capturedImageData = null;
+            startCamera();
+        }
+
+        async function registerUser(includeFace) {
+            const role = document.getElementById('roleSelect').value;
+            const matricNo = document.getElementById('matricNo').value.trim().toUpperCase();
+            const fullName = document.getElementById('fullName').value.trim();
+            const email = document.getElementById('email').value.trim();
+            const password = document.getElementById('password').value;
+
+            if (includeFace && !capturedImageData) {
+                showFaceStatus('Please capture your face first', 'error');
+                return;
+            }
+
+            showLoading('Creating your account...');
+
+            try {
+                // Step 1: Create user account
+                const userResponse = await fetch('/api/auth/register', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        role: role,
+                        matric_no: matricNo,
+                        name: fullName,
+                        email: email || null,
+                        password: password
+                    })
+                });
+
+                const userData = await userResponse.json();
+
+                if (!userData.success) {
+                    hideLoading();
+                    showStatus(userData.error, 'error');
+                    return;
+                }
+
+                // Step 2: Register face if student
+                if (includeFace) {
+                    const faceResponse = await fetch('/api/register_face', {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({
+                            student_id: matricNo,
+                            name: fullName,
+                            email: email || null,
+                            image: capturedImageData
+                        })
+                    });
+
+                    const faceData = await faceResponse.json();
+                    hideLoading();
+
+                    if (!faceData.success) {
+                        showFaceStatus(faceData.error, 'error');
+                        return;
+                    }
+                }
+
+                hideLoading();
+
+                // Show success
+                document.getElementById('step1Card').classList.add('hidden');
+                document.getElementById('step2Card').classList.add('hidden');
+                document.getElementById('successCard').classList.remove('hidden');
+                document.getElementById('successMessage').textContent =
+                    `Your ${role} account has been created successfully${includeFace ? ' with face registration' : ''}. You can now login to access the system.`;
+
+            } catch (error) {
+                hideLoading();
+                showStatus('Registration failed. Please try again.', 'error');
+            }
+        }
+
+        function showLoading(text) {
+            document.getElementById('loadingText').textContent = text;
+            document.getElementById('loadingOverlay').classList.remove('hidden');
+        }
+
+        function hideLoading() {
+            document.getElementById('loadingOverlay').classList.add('hidden');
+        }
+
+        function showStatus(message, type) {
+            const statusDiv = document.getElementById('statusMessage');
+            const alertClass = type === 'success' ? 'alert-success' : 'alert-error';
+            statusDiv.innerHTML = `<div class="alert ${alertClass}">${message}</div>`;
+
+            setTimeout(() => {
+                statusDiv.innerHTML = '';
+            }, 5000);
+        }
+
+        function showFaceStatus(message, type) {
+            const statusDiv = document.getElementById('faceStatusMessage');
+            const alertClass = type === 'success' ? 'alert-success' : 'alert-error';
+            statusDiv.innerHTML = `<div class="alert ${alertClass}">${message}</div>`;
+        }
+    </script>
+</body>
+
+</html>

requirements.txt

@@ -0,0 +1,8 @@
+Flask==3.0.0
+Flask-SQLAlchemy==3.1.1
+opencv-python==4.8.1.78
+face-recognition==1.3.0
+numpy==1.24.3
+Pillow==10.1.0
+python-dotenv==1.0.0
+werkzeug==3.0.1

student.html

@@ -0,0 +1,149 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Student Portal - Attendr</title>
+    <link rel="stylesheet" href="style.css">
+    <link
+        href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=Outfit:wght@700;800&display=swap"
+        rel="stylesheet">
+</head>
+
+<body>
+    <!-- Navigation -->
+    <!-- Navigation -->
+    {% include '_navbar.html' %}
+
+    <!-- Main Content -->
+    <section class="section">
+        <div class="container" style="max-width: 800px;">
+            <h1 class="text-center mb-3">Student Attendance Portal</h1>
+
+            <!-- Step 1: Student ID Input -->
+            <div id="step1" class="glass-card mb-2">
+                <h2>Step 1: Enter Student ID</h2>
+                <div class="form-group">
+                    <label class="form-label">Student ID</label>
+                    <input type="text" id="studentId" class="form-input" placeholder="e.g., A20EC0001">
+                </div>
+                <div class="form-group">
+                    <label class="form-label">Select Session</label>
+                    <select id="sessionSelect" class="form-select">
+                        <option value="">Loading sessions...</option>
+                    </select>
+                </div>
+                <button id="startBtn" class="btn btn-primary" disabled>Start Verification</button>
+            </div>
+
+            <!-- Step 2: Device Permissions -->
+            <div id="step2" class="glass-card mb-2 hidden">
+                <h2>Step 2: Enable Permissions</h2>
+                <p class="text-muted">We need access to your camera and location to verify your attendance.</p>
+
+                <div class="grid grid-2 gap-2 mt-2">
+                    <div class="status-badge status-info" id="cameraStatus">
+                        <span>📷</span>
+                        <span>Camera: Waiting...</span>
+                    </div>
+                    <div class="status-badge status-info" id="gpsStatus">
+                        <span>📍</span>
+                        <span>GPS: Waiting...</span>
+                    </div>
+                </div>
+
+                <button id="enablePermissionsBtn" class="btn btn-primary mt-2">Enable Camera & GPS</button>
+            </div>
+
+            <!-- Step 3: Face Verification -->
+            <div id="step3" class="glass-card mb-2 hidden">
+                <h2>Step 3: Face Verification</h2>
+                <p class="text-muted">Position your face in the frame for verification.</p>
+
+                <div class="video-container mt-2">
+                    <video id="videoPreview" class="video-preview" autoplay playsinline></video>
+                    <canvas id="canvas" style="display: none;"></canvas>
+                </div>
+
+                <div id="faceStatus" class="mt-2"></div>
+
+                <button id="verifyFaceBtn" class="btn btn-primary mt-2">Verify My Face</button>
+            </div>
+
+            <!-- Step 4: Location Verification -->
+            <div id="step4" class="glass-card mb-2 hidden">
+                <h2>Step 4: Location Verification</h2>
+                <p class="text-muted">Verifying you are in the classroom...</p>
+
+                <div id="locationStatus" class="mt-2"></div>
+
+                <button id="verifyLocationBtn" class="btn btn-primary mt-2">Verify Location</button>
+            </div>
+
+            <!-- Step 5: Attendance Code -->
+            <div id="step5" class="glass-card mb-2 hidden">
+                <h2>Step 5: Enter Attendance Code</h2>
+                <p class="text-muted">Enter the code displayed by your lecturer.</p>
+
+                <div class="form-group mt-2">
+                    <label class="form-label">Attendance Code</label>
+                    <input type="text" id="attendanceCode" class="form-input" placeholder="Enter 6-digit code"
+                        maxlength="6"
+                        style="text-transform: uppercase; font-size: 1.5rem; text-align: center; letter-spacing: 0.5rem;">
+                </div>
+
+                <button id="submitAttendanceBtn" class="btn btn-success mt-2">Mark Attendance</button>
+            </div>
+
+            <!-- Success Message -->
+            <div id="successMessage" class="glass-card hidden"
+                style="background: rgba(34, 197, 94, 0.1); border: 2px solid var(--color-success);">
+                <div class="text-center">
+                    <div style="font-size: 4rem; margin-bottom: 1rem;">✅</div>
+                    <h2 style="color: var(--color-success);">Attendance Marked Successfully!</h2>
+                    <p id="successDetails" class="text-muted mt-2"></p>
+                    <button onclick="location.reload()" class="btn btn-primary mt-2">Mark Another Attendance</button>
+                </div>
+            </div>
+
+            <!-- Error Display -->
+            <div id="errorDisplay" class="hidden"></div>
+        </div>
+    </section>
+
+    <!-- Loading Overlay -->
+    <div id="loadingOverlay" class="loading-overlay hidden">
+        <div class="text-center">
+            <div class="spinner"></div>
+            <p class="mt-2" id="loadingText">Processing...</p>
+        </div>
+    </div>
+
+    <script src="{{ url_for('static', filename='js/student.js') }}"></script>
+    <script>
+        async function logout() {
+            if (!confirm('Are you sure you want to logout?')) return;
+
+            try {
+                const response = await fetch('/api/auth/logout', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' }
+                });
+
+                const data = await response.json();
+
+                if (data.success) {
+                    alert(data.message);
+                    window.location.href = '/';
+                } else {
+                    alert('Logout failed');
+                }
+            } catch (error) {
+                alert('Logout failed');
+            }
+        }
+    </script>
+</body>
+
+</html>

student_history.html

@@ -0,0 +1,177 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Attendance History - Attendr</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}">
+    <link
+        href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=Outfit:wght@700;800&display=swap"
+        rel="stylesheet">
+</head>
+
+<body>
+    <!-- Navigation -->
+    <!-- Navigation -->
+    {% include '_navbar.html' %}
+
+    <!-- Main Content -->
+    <section class="section">
+        <div class="container">
+            <h1 class="text-center mb-3">📚 My Attendance History</h1>
+
+            <!-- Student Info Card -->
+            <div class="glass-card mb-2">
+                <div class="flex-between">
+                    <div>
+                        <h3 id="studentName">Loading...</h3>
+                        <p class="text-muted" id="studentId"></p>
+                    </div>
+                    <div class="text-right">
+                        <div style="font-size: 3rem; color: var(--color-primary);" id="totalCount">0</div>
+                        <p class="text-muted">Total Attendance</p>
+                    </div>
+                </div>
+            </div>
+
+            <!-- Attendance Records -->
+            <div id="historyContainer">
+                <div class="text-center mt-3">
+                    <div class="spinner"></div>
+                    <p class="text-muted mt-2">Loading your attendance history...</p>
+                </div>
+            </div>
+
+            <!-- Empty State -->
+            <div id="emptyState" class="glass-card text-center hidden" style="padding: 3rem;">
+                <div style="font-size: 4rem; margin-bottom: 1rem;">📭</div>
+                <h2>No Attendance Records Yet</h2>
+                <p class="text-muted mt-2">You haven't marked any attendance yet. Go to the student portal to mark your
+                    first attendance!</p>
+                <a href="/student" class="btn btn-primary mt-2">Mark Attendance</a>
+            </div>
+        </div>
+    </section>
+
+    <script>
+        document.addEventListener('DOMContentLoaded', loadHistory);
+
+        async function loadHistory() {
+            try {
+                const response = await fetch('/api/student/history');
+                const data = await response.json();
+
+                if (data.success) {
+                    displayHistory(data.data);
+                } else {
+                    showError(data.error);
+                }
+            } catch (error) {
+                showError('Failed to load attendance history');
+            }
+        }
+
+        function displayHistory(data) {
+            document.getElementById('studentName').textContent = data.student.name;
+            document.getElementById('studentId').textContent = `Matric: ${data.student.student_id}`;
+            document.getElementById('totalCount').textContent = data.total_records;
+
+            const container = document.getElementById('historyContainer');
+
+            if (data.history.length === 0) {
+                container.innerHTML = '';
+                document.getElementById('emptyState').classList.remove('hidden');
+                return;
+            }
+
+            let html = '<div class="grid grid-1 gap-2">';
+
+            data.history.forEach(record => {
+                const date = new Date(record.marked_at);
+                const sessionDate = new Date(record.session_date);
+
+                html += `
+                    <div class="glass-card">
+                        <div class="flex-between mb-1">
+                            <div>
+                                <h3>${record.course_name}</h3>
+                                <p class="text-muted">Lecturer: ${record.lecturer_name}</p>
+                            </div>
+                            <div class="badge badge-success">
+                                ✓ ${record.status.toUpperCase()}
+                            </div>
+                        </div>
+                        
+                        <div class="grid grid-2 gap-1 mt-2" style="font-size: 0.9rem;">
+                            <div>
+                                <strong>📍 Location:</strong><br>
+                                ${record.classroom} - ${record.building}
+                            </div>
+                            <div>
+                                <strong>📅 Date:</strong><br>
+                                ${sessionDate.toLocaleDateString()} ${sessionDate.toLocaleTimeString()}
+                            </div>
+                            <div>
+                                <strong>⏰ Marked At:</strong><br>
+                                ${date.toLocaleDateString()} ${date.toLocaleTimeString()}
+                            </div>
+                            <div>
+                                <strong>📏 Distance:</strong><br>
+                                ${record.distance_from_classroom ? record.distance_from_classroom + 'm' : 'N/A'}
+                            </div>
+                        </div>
+
+                        <div class="flex-center gap-1 mt-2">
+                            <span class="badge ${record.face_verified ? 'badge-success' : 'badge-error'}">
+                                ${record.face_verified ? '✓' : '✗'} Face
+                            </span>
+                            <span class="badge ${record.location_verified ? 'badge-success' : 'badge-error'}">
+                                ${record.location_verified ? '✓' : '✗'} Location
+                            </span>
+                            <span class="badge ${record.code_verified ? 'badge-success' : 'badge-error'}">
+                                ${record.code_verified ? '✓' : '✗'} Code
+                            </span>
+                        </div>
+                    </div>
+                `;
+            });
+
+            html += '</div>';
+            container.innerHTML = html;
+        }
+
+        function showError(message) {
+            const container = document.getElementById('historyContainer');
+            container.innerHTML = `
+                <div class="alert alert-error">
+                    ${message}
+                </div>
+            `;
+        }
+
+        async function logout() {
+            if (!confirm('Are you sure you want to logout?')) return;
+
+            try {
+                const response = await fetch('/api/auth/logout', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' }
+                });
+
+                const data = await response.json();
+
+                if (data.success) {
+                    alert(data.message);
+                    window.location.href = '/';
+                } else {
+                    alert('Logout failed');
+                }
+            } catch (error) {
+                alert('Logout failed');
+            }
+        }
+    </script>
+</body>
+
+</html>

style.css

@@ -0,0 +1,593 @@
+/* 
+ * Attendr - UTM Smart Attendance System
+ * Design Theme: UTM Universiti Teknologi Malaysia
+ * Primary Colors: Maroon (#8B1538) and Gold (#F4A900)
+ */
+
+/* ==================== IMPORTS ==================== */
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=Outfit:wght@700;800&display=swap');
+
+/* ==================== CSS VARIABLES ==================== */
+:root {
+  /* UTM Brand Colors */
+  --color-utm-maroon: #8B1538;
+  --color-utm-maroon-dark: #6B0F2A;
+  --color-utm-maroon-light: #A01D45;
+  --color-utm-gold: #F4A900;
+  --color-utm-gold-dark: #D49000;
+  --color-utm-gold-light: #FFB820;
+
+  /* Semantic Colors */
+  --color-primary: var(--color-utm-maroon);
+  --color-primary-dark: var(--color-utm-maroon-dark);
+  --color-primary-light: var(--color-utm-maroon-light);
+  --color-accent: var(--color-utm-gold);
+  --color-accent-dark: var(--color-utm-gold-dark);
+  --color-accent-light: var(--color-utm-gold-light);
+
+  /* UI Colors */
+  --color-success: #10B981;
+  --color-error: #EF4444;
+  --color-warning: #F59E0B;
+  --color-info: #3B82F6;
+
+  /* Neutral Colors */
+  --color-bg: #0F0A15;
+  --color-bg-secondary: #1A1425;
+  --color-surface: rgba(139, 21, 56, 0.1);
+  --color-surface-hover: rgba(139, 21, 56, 0.2);
+  --color-text: #F9FAFB;
+  --color-text-muted: #D1D5DB;
+  --color-border: rgba(244, 169, 0, 0.2);
+
+  /* Spacing */
+  --spacing-xs: 0.25rem;
+  --spacing-sm: 0.5rem;
+  --spacing-md: 1rem;
+  --spacing-lg: 1.5rem;
+  --spacing-xl: 2rem;
+  --spacing-2xl: 3rem;
+
+  /* Border Radius */
+  --radius-sm: 0.375rem;
+  --radius-md: 0.5rem;
+  --radius-lg: 0.75rem;
+  --radius-xl: 1rem;
+
+  /* Shadows */
+  --shadow-sm: 0 1px 2px 0 rgba(0, 0, 0, 0.05);
+  --shadow-md: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
+  --shadow-lg: 0 10px 15px -3px rgba(0, 0, 0, 0.1);
+  --shadow-xl: 0 20px 25px -5px rgba(0, 0, 0, 0.1);
+
+  /* Transitions */
+  --transition-fast: 150ms ease-in-out;
+  --transition-base: 300ms ease-in-out;
+  --transition-slow: 500ms ease-in-out;
+}
+
+/* ==================== RESET & BASE ==================== */
+* {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+
+body {
+  font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+  background: linear-gradient(135deg, #0F0A15 0%, #1A1425 50%, #0F0A15 100%);
+  background-attachment: fixed;
+  color: var(--color-text);
+  line-height: 1.6;
+  min-height: 100vh;
+  overflow-x: hidden;
+}
+
+/* UTM Pattern Background */
+body::before {
+  content: '';
+  position: fixed;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  background-image:
+    radial-gradient(circle at 20% 50%, rgba(139, 21, 56, 0.1) 0%, transparent 50%),
+    radial-gradient(circle at 80% 80%, rgba(244, 169, 0, 0.1) 0%, transparent 50%);
+  pointer-events: none;
+  z-index: 0;
+}
+
+/* ==================== TYPOGRAPHY ==================== */
+h1,
+h2,
+h3,
+h4,
+h5,
+h6 {
+  font-family: 'Outfit', 'Inter', sans-serif;
+  font-weight: 700;
+  line-height: 1.2;
+  color: var(--color-text);
+}
+
+h1 {
+  font-size: 2.5rem;
+  background: linear-gradient(135deg, var(--color-utm-maroon) 0%, var(--color-utm-gold) 100%);
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+  background-clip: text;
+}
+
+h2 {
+  font-size: 2rem;
+}
+
+h3 {
+  font-size: 1.5rem;
+}
+
+/* ==================== LAYOUT ==================== */
+.container {
+  max-width: 1200px;
+  margin: 0 auto;
+  padding: 0 var(--spacing-lg);
+  position: relative;
+  z-index: 1;
+}
+
+.section {
+  padding: var(--spacing-2xl) 0;
+  position: relative;
+}
+
+/* ==================== NAVIGATION ==================== */
+.navbar {
+  background: rgba(15, 10, 21, 0.95);
+  backdrop-filter: blur(10px);
+  border-bottom: 2px solid var(--color-utm-gold);
+  padding: var(--spacing-md) 0;
+  position: sticky;
+  top: 0;
+  z-index: 1000;
+  box-shadow: 0 4px 20px rgba(139, 21, 56, 0.3);
+}
+
+.navbar-content {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+}
+
+.navbar-brand {
+  font-family: 'Outfit', sans-serif;
+  font-size: 1.75rem;
+  font-weight: 800;
+  background: linear-gradient(135deg, var(--color-utm-maroon) 0%, var(--color-utm-gold) 100%);
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+  background-clip: text;
+  text-decoration: none;
+  transition: transform var(--transition-fast);
+}
+
+.navbar-brand:hover {
+  transform: scale(1.05);
+}
+
+.navbar-nav {
+  display: flex;
+  list-style: none;
+  gap: var(--spacing-lg);
+  align-items: center;
+}
+
+.navbar-link {
+  color: var(--color-text);
+  text-decoration: none;
+  font-weight: 500;
+  padding: var(--spacing-sm) var(--spacing-md);
+  border-radius: var(--radius-md);
+  transition: all var(--transition-fast);
+  position: relative;
+}
+
+.navbar-link::after {
+  content: '';
+  position: absolute;
+  bottom: 0;
+  left: 50%;
+  transform: translateX(-50%);
+  width: 0;
+  height: 2px;
+  background: var(--color-utm-gold);
+  transition: width var(--transition-fast);
+}
+
+.navbar-link:hover {
+  color: var(--color-utm-gold);
+}
+
+.navbar-link:hover::after {
+  width: 80%;
+}
+
+/* ==================== GLASS CARD ==================== */
+.glass-card {
+  background: rgba(26, 20, 37, 0.7);
+  backdrop-filter: blur(10px);
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-xl);
+  padding: var(--spacing-xl);
+  box-shadow:
+    0 8px 32px rgba(139, 21, 56, 0.2),
+    inset 0 1px 0 rgba(244, 169, 0, 0.1);
+  transition: all var(--transition-base);
+}
+
+.glass-card:hover {
+  transform: translateY(-2px);
+  box-shadow:
+    0 12px 40px rgba(139, 21, 56, 0.3),
+    inset 0 1px 0 rgba(244, 169, 0, 0.2);
+  border-color: rgba(244, 169, 0, 0.4);
+}
+
+/* ==================== BUTTONS ==================== */
+.btn {
+  display: inline-block;
+  padding: 0.75rem 1.5rem;
+  font-size: 1rem;
+  font-weight: 600;
+  text-align: center;
+  text-decoration: none;
+  border: none;
+  border-radius: var(--radius-md);
+  cursor: pointer;
+  transition: all var(--transition-fast);
+  position: relative;
+  overflow: hidden;
+}
+
+.btn::before {
+  content: '';
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  width: 0;
+  height: 0;
+  border-radius: 50%;
+  background: rgba(255, 255, 255, 0.1);
+  transform: translate(-50%, -50%);
+  transition: width 0.6s, height 0.6s;
+}
+
+.btn:hover::before {
+  width: 300px;
+  height: 300px;
+}
+
+.btn-primary {
+  background: linear-gradient(135deg, var(--color-utm-maroon) 0%, var(--color-utm-maroon-dark) 100%);
+  color: white;
+  box-shadow: 0 4px 15px rgba(139, 21, 56, 0.4);
+}
+
+.btn-primary:hover {
+  background: linear-gradient(135deg, var(--color-utm-maroon-light) 0%, var(--color-utm-maroon) 100%);
+  box-shadow: 0 6px 20px rgba(139, 21, 56, 0.6);
+  transform: translateY(-2px);
+}
+
+.btn-secondary {
+  background: linear-gradient(135deg, var(--color-utm-gold) 0%, var(--color-utm-gold-dark) 100%);
+  color: var(--color-utm-maroon-dark);
+  box-shadow: 0 4px 15px rgba(244, 169, 0, 0.4);
+}
+
+.btn-secondary:hover {
+  background: linear-gradient(135deg, var(--color-utm-gold-light) 0%, var(--color-utm-gold) 100%);
+  box-shadow: 0 6px 20px rgba(244, 169, 0, 0.6);
+  transform: translateY(-2px);
+}
+
+.btn-success {
+  background: linear-gradient(135deg, var(--color-success) 0%, #059669 100%);
+  color: white;
+  box-shadow: 0 4px 15px rgba(16, 185, 129, 0.4);
+}
+
+.btn-success:hover {
+  background: linear-gradient(135deg, #10B981 0%, var(--color-success) 100%);
+  transform: translateY(-2px);
+}
+
+.btn-outline {
+  background: transparent;
+  color: var(--color-utm-gold);
+  border: 2px solid var(--color-utm-gold);
+}
+
+.btn-outline:hover {
+  background: var(--color-utm-gold);
+  color: var(--color-utm-maroon-dark);
+}
+
+.btn:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+/* ==================== FORMS ==================== */
+.form-group {
+  margin-bottom: var(--spacing-lg);
+}
+
+.form-label {
+  display: block;
+  margin-bottom: var(--spacing-sm);
+  font-weight: 600;
+  color: var(--color-utm-gold);
+}
+
+.form-input,
+.form-select {
+  width: 100%;
+  padding: 0.75rem 1rem;
+  background: rgba(26, 20, 37, 0.6);
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-md);
+  color: var(--color-text);
+  font-size: 1rem;
+  transition: all var(--transition-fast);
+}
+
+.form-input:focus,
+.form-select:focus {
+  outline: none;
+  border-color: var(--color-utm-gold);
+  box-shadow: 0 0 0 3px rgba(244, 169, 0, 0.1);
+  background: rgba(26, 20, 37, 0.8);
+}
+
+.form-select option {
+  background: #1A1425;
+  color: var(--color-text);
+}
+
+/* ==================== BADGES ==================== */
+.badge {
+  display: inline-block;
+  padding: 0.25rem 0.75rem;
+  font-size: 0.875rem;
+  font-weight: 600;
+  border-radius: var(--radius-sm);
+  background: rgba(139, 21, 56, 0.2);
+  color: var(--color-utm-gold);
+  border: 1px solid var(--color-utm-gold);
+}
+
+.badge-success {
+  background: rgba(16, 185, 129, 0.2);
+  color: var(--color-success);
+  border-color: var(--color-success);
+}
+
+.badge-error {
+  background: rgba(239, 68, 68, 0.2);
+  color: var(--color-error);
+  border-color: var(--color-error);
+}
+
+/* ==================== CODE DISPLAY ==================== */
+.code-display {
+  font-family: 'Courier New', monospace;
+  font-size: 4rem;
+  font-weight: 800;
+  text-align: center;
+  padding: var(--spacing-xl);
+  background: linear-gradient(135deg, var(--color-utm-maroon) 0%, var(--color-utm-gold) 100%);
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+  background-clip: text;
+  letter-spacing: 1rem;
+  text-shadow: 0 0 30px rgba(244, 169, 0, 0.5);
+}
+
+/* ==================== UTILITIES ==================== */
+.text-center {
+  text-align: center;
+}
+
+.text-right {
+  text-align: right;
+}
+
+.text-muted {
+  color: var(--color-text-muted);
+}
+
+.mt-1 {
+  margin-top: var(--spacing-sm);
+}
+
+.mt-2 {
+  margin-top: var(--spacing-md);
+}
+
+.mt-3 {
+  margin-top: var(--spacing-lg);
+}
+
+.mb-1 {
+  margin-bottom: var(--spacing-sm);
+}
+
+.mb-2 {
+  margin-bottom: var(--spacing-md);
+}
+
+.mb-3 {
+  margin-bottom: var(--spacing-lg);
+}
+
+.hidden {
+  display: none !important;
+}
+
+.grid {
+  display: grid;
+  gap: var(--spacing-lg);
+}
+
+.grid-1 {
+  grid-template-columns: 1fr;
+}
+
+.grid-2 {
+  grid-template-columns: repeat(2, 1fr);
+}
+
+.grid-3 {
+  grid-template-columns: repeat(3, 1fr);
+}
+
+.gap-1 {
+  gap: var(--spacing-sm);
+}
+
+.gap-2 {
+  gap: var(--spacing-md);
+}
+
+.flex-between {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+}
+
+.flex-center {
+  display: flex;
+  justify-content: center;
+  align-items: center;
+}
+
+/* ==================== LOADING & OVERLAYS ==================== */
+.loading-overlay {
+  position: fixed;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  background: rgba(15, 10, 21, 0.9);
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  z-index: 9999;
+}
+
+.spinner {
+  width: 50px;
+  height: 50px;
+  border: 4px solid rgba(244, 169, 0, 0.2);
+  border-top-color: var(--color-utm-gold);
+  border-radius: 50%;
+  animation: spin 1s linear infinite;
+}
+
+@keyframes spin {
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+/* ==================== ALERTS ==================== */
+.alert {
+  padding: var(--spacing-md);
+  border-radius: var(--radius-md);
+  margin-bottom: var(--spacing-md);
+  border-left: 4px solid;
+}
+
+.alert-error {
+  background: rgba(239, 68, 68, 0.1);
+  border-color: var(--color-error);
+  color: #FCA5A5;
+}
+
+.alert-success {
+  background: rgba(16, 185, 129, 0.1);
+  border-color: var(--color-success);
+  color: #6EE7B7;
+}
+
+/* ==================== VIDEO & MEDIA ==================== */
+.video-container {
+  position: relative;
+  border-radius: var(--radius-lg);
+  overflow: hidden;
+  border: 2px solid var(--color-utm-gold);
+}
+
+.video-preview {
+  width: 100%;
+  height: auto;
+  display: block;
+}
+
+/* ==================== STATUS BADGES ==================== */
+.status-badge {
+  padding: var(--spacing-md);
+  border-radius: var(--radius-md);
+  border: 1px solid var(--color-border);
+  background: rgba(26, 20, 37, 0.6);
+}
+
+.status-info {
+  border-color: var(--color-utm-gold);
+  background: rgba(244, 169, 0, 0.1);
+}
+
+/* ==================== RESPONSIVE ==================== */
+@media (max-width: 768px) {
+
+  .grid-2,
+  .grid-3 {
+    grid-template-columns: 1fr;
+  }
+
+  .navbar-nav {
+    gap: var(--spacing-sm);
+    font-size: 0.875rem;
+  }
+
+  h1 {
+    font-size: 2rem;
+  }
+
+  h2 {
+    font-size: 1.5rem;
+  }
+
+  .code-display {
+    font-size: 2.5rem;
+    letter-spacing: 0.5rem;
+  }
+}
+
+/* ==================== ANIMATIONS ==================== */
+@keyframes fadeIn {
+  from {
+    opacity: 0;
+    transform: translateY(20px);
+  }
+
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+.glass-card {
+  animation: fadeIn 0.5s ease-out;
+}

update_utm_coordinates.py

@@ -0,0 +1,65 @@
+"""
+Update all UTM Faculty of Computing venues to correct GPS coordinates
+Based on Plus Code: HJ7Q+F5 Johor Bahru (UTM Skudai Campus)
+Coordinates: 1.5638°N, 103.6388°E
+"""
+
+from app import app, db
+from models import Classroom
+
+def update_utm_coordinates():
+    """Update all UTM venues to correct coordinates, except PUTERI-COURT"""
+    
+    with app.app_context():
+        print("Updating UTM Faculty of Computing venue coordinates...")
+        print("Base location: HJ7Q+F5 Johor Bahru (UTM Skudai)")
+        print("=" * 70)
+        
+        # Base coordinates for UTM FC (from Plus Code HJ7Q+F5)
+        BASE_LAT = 1.5638
+        BASE_LON = 103.6388
+        
+        # Get all venues except PUTERI-COURT
+        utm_venues = Classroom.query.filter(Classroom.name != 'PUTERI-COURT').all()
+        
+        if not utm_venues:
+            print("No UTM venues found to update!")
+            return
+        
+        updated_count = 0
+        
+        # Update each venue with slight offset from base coordinates
+        for idx, venue in enumerate(utm_venues):
+            # Create slight variations for each venue (small offsets)
+            # This simulates different rooms being in slightly different locations
+            lat_offset = (idx % 10) * 0.0001  # Small latitude variation
+            lon_offset = (idx // 10) * 0.0001  # Small longitude variation
+            
+            venue.latitude = BASE_LAT + lat_offset
+            venue.longitude = BASE_LON + lon_offset
+            venue.radius_meters = 50  # Keep 50m radius for classrooms
+            
+            updated_count += 1
+            print(f"Updated: {venue.name} -> ({venue.latitude:.6f}, {venue.longitude:.6f})")
+        
+        # Commit all changes
+        db.session.commit()
+        
+        print("=" * 70)
+        print(f"[OK] Successfully updated {updated_count} UTM venues")
+        print(f"Base coordinates: {BASE_LAT}N, {BASE_LON}E")
+        print(f"PUTERI-COURT was NOT updated (kept separate)")
+        print("=" * 70)
+        
+        # Verify PUTERI-COURT wasn't changed
+        puteri = Classroom.query.filter_by(name='PUTERI-COURT').first()
+        if puteri:
+            print(f"\n[OK] PUTERI-COURT location verified:")
+            print(f"  Latitude: {puteri.latitude}")
+            print(f"  Longitude: {puteri.longitude}")
+            print(f"  (Jalan Raja Chulan, KL - unchanged)")
+        
+        print(f"\nTotal venues in database: {Classroom.query.count()}")
+
+if __name__ == '__main__':
+    update_utm_coordinates()

utils.py

@@ -0,0 +1,84 @@
+import base64
+import numpy as np
+from PIL import Image
+import io
+from math import radians, cos, sin, asin, sqrt
+
+def base64_to_image(base64_string):
+    """Convert base64 string to PIL Image"""
+    try:
+        # Remove data URL prefix if present
+        if ',' in base64_string:
+            base64_string = base64_string.split(',')[1]
+        
+        # Decode base64
+        image_data = base64.b64decode(base64_string)
+        image = Image.open(io.BytesIO(image_data))
+        
+        # Convert to RGB if necessary
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+        
+        return image
+    except Exception as e:
+        raise ValueError(f"Failed to decode base64 image: {str(e)}")
+
+
+def image_to_numpy(image):
+    """Convert PIL Image to numpy array"""
+    return np.array(image)
+
+
+def haversine_distance(lat1, lon1, lat2, lon2):
+    """
+    Calculate the great circle distance between two points 
+    on the earth (specified in decimal degrees)
+    Returns distance in meters
+    """
+    # Convert decimal degrees to radians
+    lat1, lon1, lat2, lon2 = map(radians, [lat1, lon1, lat2, lon2])
+    
+    # Haversine formula
+    dlat = lat2 - lat1
+    dlon = lon2 - lon1
+    a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2
+    c = 2 * asin(sqrt(a))
+    
+    # Radius of earth in meters
+    r = 6371000
+    
+    return c * r
+
+
+def format_error_response(message, code=400):
+    """Format error response"""
+    return {
+        'success': False,
+        'error': message
+    }, code
+
+
+def format_success_response(data=None, message=None):
+    """Format success response"""
+    response = {'success': True}
+    if message:
+        response['message'] = message
+    if data:
+        response['data'] = data
+    return response, 200
+
+
+def validate_coordinates(latitude, longitude):
+    """Validate GPS coordinates"""
+    try:
+        lat = float(latitude)
+        lon = float(longitude)
+        
+        if not (-90 <= lat <= 90):
+            return False, "Latitude must be between -90 and 90"
+        if not (-180 <= lon <= 180):
+            return False, "Longitude must be between -180 and 180"
+        
+        return True, None
+    except (ValueError, TypeError):
+        return False, "Invalid coordinate format"