Upload 33 files

.dockerignore

@@ -0,0 +1,30 @@
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.db
+.sqlite
+.env
+.git
+.gitignore
+.vscode
+.gemini
+node_modules
+venv
+env
+uploads/*
+!uploads/.gitkeep
+README.md
+*.sql
+*.ipynb
+*.log
+add_custom_venue.py
+add_home_venue.py
+add_utm_venues.py
+clear_database.py
+dump_db_to_sql.py
+init_db.py
+update_utm_coordinates.py
+fix_sql_quotes.py
+# Keep attendr.db if you want pre-loaded data, but usually better to start fresh
+# attendr.db 

Dockerfile

@@ -1,27 +1,54 @@
-# Use a Conda-based image (much faster for AI libraries)
-FROM continuumio/miniconda3:latest
-
-# Install basic system dependencies
-RUN apt-get update && apt-get install -y \
-    libgl1 \
-    libglx-mesa0 \
-    libglib2.0-0 \
-    && rm -rf /var/lib/apt/lists/*
-
-# Set working directory
-WORKDIR /app
-
-# Step 1: Install AI libraries via Conda (Downloads pre-built files)
-RUN conda install -c conda-forge dlib face_recognition numpy -y
-
-# Step 2: Install Web libraries via pip
-RUN pip install Flask==3.0.0 Flask-SQLAlchemy==3.1.1 opencv-python-headless Pillow python-dotenv werkzeug pymysql
-
-# Step 3: Copy your project files
-COPY . .
-
-# Hugging Face mandatory port
-EXPOSE 7860
-
-# Run the app
-CMD ["python", "app.py"]
+# Use an official Python runtime as a parent image
+FROM python:3.10-slim
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE 1
+ENV PYTHONUNBUFFERED 1
+ENV PORT 7860
+
+# Install system dependencies for OpenCV and face_recognition
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    cmake \
+    libopenblas-dev \
+    liblapack-dev \
+    libx11-dev \
+    libgtk-3-dev \
+    libboost-python-dev \
+    python3-dev \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    && apt-get clean && rm -rf /var/lib/apt/lists/*
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the requirements file into the container
+COPY requirements.txt .
+
+# Install gunicorn for production
+RUN pip install --no-cache-dir gunicorn
+
+# Install any needed packages specified in requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application code into the container
+COPY . .
+
+# Ensure upload directory exists and has permissions
+RUN mkdir -p uploads/face_encodings && chmod -R 777 uploads
+
+# Create a non-root user (Hugging Face requirement)
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+WORKDIR $HOME/app
+COPY --chown=user . $HOME/app
+
+# Expose the port the app runs on
+EXPOSE 7860
+
+# Define the command to run the application
+CMD ["gunicorn", "--bind", "0.0.0.0:7860", "app:app", "--timeout", "120"]

README.md

@@ -1,18 +1,338 @@
----
-title: Attendr
-emoji: ✨
-colorFrom: red
-colorTo: yellow
-sdk: docker
-app_port: 7860
-pinned: false
----
+# 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
 
-# Attendr - Smart Attendance System
+# Attendance code settings
+CODE_REFRESH_INTERVAL_SECONDS = 120 # Code refresh interval (2 minutes)
+CODE_LENGTH = 6                     # Length of attendance code
+```
 
-AI-powered attendance verification using facial recognition, geolocation, and auto-refresh codes.
+## 🌐 API Endpoints
 
-## Setup
+### 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
+
+---
 
-This project runs on Docker in Hugging Face Spaces.
-Port: 7860
+**Made with ❤️ for UTM Students and Lecturers**

_navbar.html

@@ -2,48 +2,52 @@
 <!-- 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>
+  <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>
+      <li><a href="/lecturer/history" class="navbar-link">History</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;
+  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' }
-            });
+    try {
+      const response = await fetch("/api/auth/logout", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+      });
 
-            const data = await response.json();
+      const data = await response.json();
 
-            if (data.success) {
-                alert(data.message);
-                window.location.href = '/';
-            } else {
-                alert('Logout failed');
-            }
-        } catch (error) {
-            alert('Logout failed');
-        }
+      if (data.success) {
+        alert(data.message);
+        window.location.href = "/";
+      } else {
+        alert("Logout failed");
+      }
+    } catch (error) {
+      alert("Logout failed");
     }
-</script>
+  }
+</script>

add_custom_venue.py

@@ -0,0 +1,37 @@
+from app import app, db
+from models import Classroom
+
+def add_custom_venue():
+    with app.app_context():
+        # Define the new venue
+        venue_name = "Pejabat Pos UTM (KDSE)"
+        venue_building = "W1, Kolej Datin Seri Endon, 81110 Johor Bahru"
+        lat = 1.560662
+        lon = 103.638421
+        radius = 2000 # Increased as requested to allow location verification
+
+        # Check if already exists (searching for "Pejabat Pos" to handle renaming)
+        existing = Classroom.query.filter(Classroom.name.like("%Pejabat Pos%")).first()
+        if existing:
+            print(f"Updating existing venue: {existing.name} -> {venue_name}")
+            existing.name = venue_name
+            existing.building = venue_building
+            existing.latitude = lat
+            existing.longitude = lon
+            existing.radius_meters = radius
+        else:
+            new_venue = Classroom(
+                name=venue_name,
+                building=venue_building,
+                latitude=lat,
+                longitude=lon,
+                radius_meters=radius
+            )
+            db.session.add(new_venue)
+            print(f"Adding new venue: {venue_name}")
+        
+        db.session.commit()
+        print("Database updated successfully.")
+
+if __name__ == "__main__":
+    add_custom_venue()

app.py

@@ -1,805 +1,813 @@
-"""
-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()
-        # Seed classrooms if empty
-        if Classroom.query.count() == 0:
-            logger.info("Seeding default classrooms...")
-            default_classrooms = [
-                Classroom(name="N28-01-01", building="N28 (Faculty of Computing)", latitude=1.5586, 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 c in default_classrooms:
-                db.session.add(c)
-            db.session.commit()
-            logger.info("Database seeded successfully")
-        
-        logger.info("Database tables verified")
-    
-    app.run(debug=True, host='0.0.0.0', port=7860)
+"""
+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__)
+
+
+@app.after_request
+def add_header(response):
+    """
+    Add headers to prevent caching of dynamic pages.
+    This ensures that when a user logs out, they cannot click 'Back' 
+    to see protected content from the browser cache.
+    """
+    if 'Cache-Control' not in response.headers:
+        response.headers['Cache-Control'] = 'no-store, no-cache, must-revalidate, post-check=0, pre-check=0, max-age=0'
+        response.headers['Pragma'] = 'no-cache'
+        response.headers['Expires'] = '-1'
+    return response
+
+
+# ==================== 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 - redirect if already logged in"""
+    if 'user_id' in session:
+        return redirect(url_for('student_page' if session.get('role') == 'student' else 'lecturer_page'))
+    return render_template('register.html')
+
+
+@app.route('/login')
+def login_page():
+    """Login page - redirect if already logged in"""
+    if 'user_id' in session:
+        return redirect(url_for('student_page' if session.get('role') == 'student' else 'lecturer_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 (case-insensitive match by name)
+        from sqlalchemy import func
+        sessions = AttendanceSession.query.filter(
+            func.lower(AttendanceSession.lecturer_name) == func.lower(current_user.name)
+        ).order_by(AttendanceSession.start_time.desc()).all()
+        
+        logger.info(f"Fetched {len(sessions)} sessions for lecturer: {current_user.name}")
+        
+        # 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)

attendr.sql

@@ -53,52 +53,53 @@ CREATE TABLE classrooms (
 	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(1,'N28-105-01','N28 - Faculty of Computing',1.5638,103.6388,2000);
+INSERT INTO `classrooms` VALUES(2,'N28-116-02','N28 - Faculty of Computing',1.5639,103.6388,2000);
+INSERT INTO `classrooms` VALUES(3,'N28-112-02','N28 - Faculty of Computing',1.564,103.6388,2000);
+INSERT INTO `classrooms` VALUES(4,'N28-111-01','N28 - Faculty of Computing',1.5641,103.6388,2000);
+INSERT INTO `classrooms` VALUES(5,'N28-106-01','N28 - Faculty of Computing',1.5642,103.6388,2000);
+INSERT INTO `classrooms` VALUES(6,'N28-107-01','N28 - Faculty of Computing',1.5643,103.6388,2000);
+INSERT INTO `classrooms` VALUES(7,'N28-108-01','N28 - Faculty of Computing',1.5644,103.6388,2000);
+INSERT INTO `classrooms` VALUES(8,'N28-351-02','N28 - Level 3',1.5645,103.6388,2000);
+INSERT INTO `classrooms` VALUES(9,'N28-301-01','N28 - Level 3',1.5646,103.6388,2000);
+INSERT INTO `classrooms` VALUES(10,'N28-301-01B','N28 - Level 3',1.5647,103.6388,2000);
+INSERT INTO `classrooms` VALUES(11,'N28A-BT1','N28A - Tutorial Block',1.5638,103.6389,2000);
+INSERT INTO `classrooms` VALUES(12,'N28A-BT2','N28A - Tutorial Block',1.5639,103.6389,2000);
+INSERT INTO `classrooms` VALUES(13,'N28A-BT3','N28A - Tutorial Block',1.564,103.6389,2000);
+INSERT INTO `classrooms` VALUES(14,'N28A-BT4','N28A - Tutorial Block',1.5641,103.6389,2000);
+INSERT INTO `classrooms` VALUES(15,'N28A-BK1','N28A - Tutorial Block',1.5642,103.6389,2000);
+INSERT INTO `classrooms` VALUES(16,'N28A-BK2','N28A - Tutorial Block',1.5643,103.6389,2000);
+INSERT INTO `classrooms` VALUES(17,'N28A-BK5','N28A - Tutorial Block',1.5644,103.6389,2000);
+INSERT INTO `classrooms` VALUES(18,'N28A-BK6','N28A - Tutorial Block',1.5645,103.6389,2000);
+INSERT INTO `classrooms` VALUES(19,'N28-502-01','N28 - Level 5',1.5646,103.6389,2000);
+INSERT INTO `classrooms` VALUES(20,'N28-505-01','N28 - Level 5',1.5647,103.6389,2000);
+INSERT INTO `classrooms` VALUES(21,'N28-506-01','N28 - Level 5',1.5638,1.036390000000000101e+02,2000);
+INSERT INTO `classrooms` VALUES(22,'N28-512-01','N28 - Level 5',1.5639,1.036390000000000101e+02,2000);
+INSERT INTO `classrooms` VALUES(23,'N28-516-01','N28 - Level 5',1.564,1.036390000000000101e+02,2000);
+INSERT INTO `classrooms` VALUES(24,'N28-517-02','N28 - Level 5',1.5641,1.036390000000000101e+02,2000);
+INSERT INTO `classrooms` VALUES(25,'N28-518-02','N28 - Level 5',1.5642,1.036390000000000101e+02,2000);
+INSERT INTO `classrooms` VALUES(26,'N28-524-02','N28 - Level 5',1.5643,1.036390000000000101e+02,2000);
+INSERT INTO `classrooms` VALUES(27,'N28-525-01','N28 - Level 5',1.5644,1.036390000000000101e+02,2000);
+INSERT INTO `classrooms` VALUES(28,'N28-527-02','N28 - Level 5',1.5645,1.036390000000000101e+02,2000);
+INSERT INTO `classrooms` VALUES(29,'N28A-02-33','N28A - Level 2',1.5646,1.036390000000000101e+02,2000);
+INSERT INTO `classrooms` VALUES(30,'N28A-02-34','N28A - Level 2',1.5647,1.036390000000000101e+02,2000);
+INSERT INTO `classrooms` VALUES(31,'N28-223-02','N28 - Level 2',1.5638,103.6391,2000);
+INSERT INTO `classrooms` VALUES(32,'N28-204-01','N28 - Level 2',1.5639,103.6391,2000);
+INSERT INTO `classrooms` VALUES(33,'N28-203-01','N28 - Level 2',1.564,103.6391,2000);
+INSERT INTO `classrooms` VALUES(34,'N28-202-01','N28 - Level 2',1.5641,103.6391,2000);
+INSERT INTO `classrooms` VALUES(35,'N28-330-01','N28 - Level 3',1.5642,103.6391,2000);
+INSERT INTO `classrooms` VALUES(36,'N28-352-01','N28 - Level 3',1.5643,103.6391,2000);
+INSERT INTO `classrooms` VALUES(37,'N28-321-02','N28 - Level 3',1.5644,103.6391,2000);
+INSERT INTO `classrooms` VALUES(38,'N28-329-01','N28 - Level 3',1.5645,103.6391,2000);
+INSERT INTO `classrooms` VALUES(39,'N28-350-03','N28 - Level 3',1.5646,103.6391,2000);
+INSERT INTO `classrooms` VALUES(40,'N28-422-01','N28 - Level 4',1.5647,103.6391,2000);
+INSERT INTO `classrooms` VALUES(41,'N28-423-01','N28 - Level 4',1.5638,103.6392,2000);
+INSERT INTO `classrooms` VALUES(42,'L50-DK3','Block L50 - Centre Point',1.5639,103.6392,2000);
+INSERT INTO `classrooms` VALUES(43,'P19-DK4','Block P19 - FKE',1.564,103.6392,2000);
+INSERT INTO `classrooms` VALUES(44,'P19-DK5','Block P19 - FKE',1.5641,103.6392,2000);
+INSERT INTO `classrooms` VALUES(45,'P19-DK6','Block P19 - FKE',1.5642,103.6392,2000);
 INSERT INTO `classrooms` VALUES(46,'PUTERI-COURT','Puteri Court Condominium (Home Demo)',3.128024,101.765479,1000);
+INSERT INTO `classrooms` VALUES(47,'Pejabat Pos UTM (KDSE)','W1, Kolej Datin Seri Endon, 81110 Johor Bahru',1.560662,103.638421,2000);
 CREATE TABLE students (
 	id INTEGER NOT NULL, 
 	user_id INTEGER, 

config.py

@@ -22,7 +22,7 @@ class Config:
     FACE_DETECTION_MODEL = 'hog'  # 'hog' is faster, 'cnn' is more accurate
     
     # Geolocation settings
-    GEOLOCATION_RADIUS_METERS = 50  # Classroom detection radius
+    GEOLOCATION_RADIUS_METERS = 2000  # Increased to 2000m as requested for testing
     
     # Attendance Code Settings
     CODE_LENGTH = 6  # Length of attendance code

face_recognition_module.py

@@ -1,120 +1,160 @@
-"""
-Face Recognition Module for Attendr
-Automatically switches between production (face_recognition) and mock mode.
-"""
-
-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__)
-
-# Try to import face_recognition
-try:
-    import face_recognition
-    HAS_FACE_RECOGNITION = True
-    logger.info("PRODUCTION face_recognition library loaded successfully")
-except ImportError:
-    HAS_FACE_RECOGNITION = False
-    logger.warning("Using MOCK face recognition module - for testing only!")
-    logger.warning("Install face_recognition library for production use")
-
-
-class FaceRecognitionModule:
-    """Handles all face recognition operations"""
-    
-    def __init__(self, tolerance=None, model='hog'):
-        self.tolerance = tolerance or Config.FACE_RECOGNITION_TOLERANCE
-        self.model = model or Config.FACE_DETECTION_MODEL
-        if HAS_FACE_RECOGNITION:
-            logger.info(f"PRODUCTION Face Detection initialized (model={self.model})")
-        else:
-            logger.info("MOCK Face Recognition initialized")
-    
-    def detect_faces(self, image_array):
-        """Detect faces in an image"""
-        try:
-            if HAS_FACE_RECOGNITION:
-                return face_recognition.face_locations(image_array, model=self.model)
-            else:
-                # Mock face detection using OpenCV Haar Cascades
-                gray = cv2.cvtColor(image_array, cv2.COLOR_RGB2GRAY)
-                face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
-                faces = face_cascade.detectMultiScale(gray, 1.3, 5)
-                return [(y, x+w, y+h, x) for (x, y, w, h) in faces]
-        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"""
-        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."
-            
-            if HAS_FACE_RECOGNITION:
-                encodings = face_recognition.face_encodings(image_array, face_locations)
-                if len(encodings) == 0:
-                    return False, "Failed to generate face encoding. Try better lighting."
-                return True, encodings[0]
-            else:
-                # Mock encoding generation
-                top, right, bottom, left = face_locations[0]
-                face_region = image_array[top:bottom, left:right]
-                face_resized = cv2.resize(face_region, (100, 100))
-                face_bytes = face_resized.tobytes()
-                hash_digest = hashlib.sha256(face_bytes).digest()
-                encoding = np.array([float(b) for b in hash_digest[:128]] + [0.0] * (128 - len(hash_digest[:128])))
-                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"""
-        try:
-            if captured_encoding is None or stored_encoding is None:
-                return False, 0.0
-            
-            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)
-            
-            if HAS_FACE_RECOGNITION:
-                face_distance = face_recognition.face_distance([stored_encoding], captured_encoding)[0]
-                confidence = (1 - face_distance) * 100
-                is_match = face_distance <= self.tolerance
-            else:
-                # Mock similarity check
-                correlation = np.corrcoef(captured_encoding, stored_encoding)[0, 1]
-                distance = 1 - abs(correlation)
-                confidence = (1 - distance) * 100
-                is_match = distance <= self.tolerance
-                
-            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"""
-        success, result = self.generate_face_encoding(image_array)
-        if success:
-            face_locations = self.detect_faces(image_array)
-            return True, result, face_locations[0]
-        return False, result, None
-
-# Singleton instance
-face_recognition_module = FaceRecognitionModule()
+"""
+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()

lecturer.html

@@ -206,6 +206,10 @@
                         <div id="sessionsList" class="mt-2">
                             <p class="text-muted">No active sessions</p>
                         </div>
+                        <div class="mt-3" style="border-top: 1px solid var(--color-border); padding-top: 1rem;">
+                            <a href="/lecturer/history" class="btn btn-outline" style="width: 100%;">📊 View All Session
+                                History</a>
+                        </div>
                     </div>
                 </div>
 

requirements.txt

@@ -1,5 +1,8 @@
-Flask==3.0.0
-Flask-SQLAlchemy==3.1.1
-Pillow==10.1.0
-python-dotenv==1.0.0
-werkzeug==3.0.1
+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