Complete app.py with all routes and error fixes

app.py

@@ -26,7 +26,7 @@ except ImportError as e:
     print(f"⚠️ ONNX Runtime not available: {e}")
     print("🔄 Falling back to OpenCV-based alternatives")
 
-# --- Evaluation Metrics Counters (legacy, kept for compatibility display) ---
+# --- Evaluation Metrics Counters ---
 total_attempts = 0
 correct_recognitions = 0
 false_accepts = 0
@@ -35,14 +35,12 @@ unauthorized_attempts = 0
 inference_times = []
 
 def get_client_ip():
-    # Handles proxy headers if any (like when using nginx or cloud services)
     if request.headers.get('X-Forwarded-For'):
         ip = request.headers.get('X-Forwarded-For').split(',')[0]
     else:
         ip = request.remote_addr
     return ip
 
-# ---------------------------------------------------
 # Load environment variables
 load_dotenv()
 
@@ -50,16 +48,14 @@ load_dotenv()
 app = Flask(__name__, static_folder='app/static', template_folder='app/templates')
 app.secret_key = os.getenv('SECRET_KEY', os.urandom(24))
 
-# MongoDB Connection - Updated for production
+# MongoDB Connection with robust error handling
 def init_mongodb():
     try:
-        # For Hugging Face Spaces, use the environment variable
         mongo_uri = os.getenv('MONGO_URI', 'mongodb://localhost:27017/')
         print(f"Connecting to MongoDB...")
         
         client = MongoClient(mongo_uri, serverSelectionTimeoutMS=5000)
-        # Test the connection
-        client.server_info()
+        client.server_info()  # Test connection
         
         db = client['face_attendance_system']
         students_collection = db['students']
@@ -89,22 +85,18 @@ def init_mongodb():
 # Initialize MongoDB
 client, db, students_collection, teachers_collection, attendance_collection, metrics_events = init_mongodb()
 
-# ---------------- ONNX Runtime Provider Configuration ----------------
+# ONNX Runtime Provider Configuration
 def _get_providers():
-    """Get ONNX Runtime providers with CPU-only fallback"""
     if not ONNX_AVAILABLE:
         return []
-    
     try:
-        # Force CPU-only to avoid executable stack issues
         return ["CPUExecutionProvider"]
     except Exception as e:
         print(f"Error getting ONNX providers: {e}")
         return []
 
-# ---------------- Fallback Face Detection with OpenCV ----------------
+# OpenCV Fallback Functions
 def detect_faces_opencv(image):
-    """OpenCV-based face detection fallback"""
     try:
         face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
         gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
@@ -114,7 +106,7 @@ def detect_faces_opencv(image):
         for (x, y, w, h) in faces:
             detections.append({
                 "bbox": [x, y, x+w, y+h],
-                "score": 0.9  # Default confidence
+                "score": 0.9
             })
         return detections
     except Exception as e:
@@ -122,33 +114,23 @@ def detect_faces_opencv(image):
         return []
 
 def simple_liveness_check(face_crop):
-    """Simple liveness check without ONNX Runtime"""
     try:
         gray = cv2.cvtColor(face_crop, cv2.COLOR_BGR2GRAY)
-        
-        # Check image sharpness (blurry might indicate photo of photo)
         laplacian_var = cv2.Laplacian(gray, cv2.CV_64F).var()
-        
-        # Check brightness distribution
         mean_brightness = np.mean(gray)
         
-        # Simple heuristic scoring
         sharpness_score = min(1.0, laplacian_var / 100.0)
         brightness_score = 1.0 if 50 < mean_brightness < 200 else 0.5
-        
-        # Combine scores
         live_score = (sharpness_score + brightness_score) / 2.0
         
-        # Return a value between 0.3 and 0.9
         return 0.3 + (live_score * 0.6)
-        
     except Exception as e:
         print(f"Fallback liveness check error: {e}")
-        return 0.7  # Default to "probably live"
+        return 0.7
 
-# ---------------- YOLOv5s-face + AntiSpoof (BINARY) FOR ATTENDANCE ONLY ----------------
+# YOLO and Anti-Spoofing Helper Functions
 def _letterbox(image, new_shape=(640, 640), color=(114, 114, 114), auto=False, scaleFill=False, scaleup=True):
-    shape = image.shape[:2]  # h, w
+    shape = image.shape[:2]
     if isinstance(new_shape, int):
         new_shape = (new_shape, new_shape)
     r = min(new_shape[0] / shape[0], new_shape[1] / shape[1])
@@ -198,6 +180,7 @@ def _nms(boxes: np.ndarray, scores: np.ndarray, iou_threshold: float):
         order = order[inds + 1]
     return keep
 
+# YOLO Face Detector Class
 class YoloV5FaceDetector:
     def __init__(self, model_path: str, input_size: int = 640, conf_threshold: float = 0.3, iou_threshold: float = 0.45):
         self.input_size = int(input_size)
@@ -220,10 +203,9 @@ class YoloV5FaceDetector:
                     print("⚠️ No ONNX providers available for YOLOv5")
             except Exception as e:
                 print(f"⚠️ Failed to initialize YOLOv5 with ONNX Runtime: {e}")
-                print("🔄 Will use OpenCV fallback for face detection")
                 self.session = None
         else:
-            print("⚠️ ONNX Runtime not available - using OpenCV fallback for face detection")
+            print("⚠️ ONNX Runtime not available - using OpenCV fallback")
 
     @staticmethod
     def _xywh2xyxy(x: np.ndarray) -> np.ndarray:
@@ -236,7 +218,6 @@ class YoloV5FaceDetector:
 
     def detect(self, image_bgr: np.ndarray, max_det: int = 20):
         if self.session is None:
-            # Fallback to OpenCV face detection
             return detect_faces_opencv(image_bgr)
         
         try:
@@ -247,13 +228,16 @@ class YoloV5FaceDetector:
             img = np.transpose(img, (2, 0, 1))
             img = np.expand_dims(img, 0)
             preds = self.session.run(self.output_names, {self.input_name: img})[0]
+            
             if preds.ndim == 3 and preds.shape[0] == 1:
                 preds = preds[0]
             if preds.ndim != 2:
                 raise RuntimeError(f"Unexpected YOLO output shape: {preds.shape}")
+            
             num_attrs = preds.shape[1]
             has_landmarks = num_attrs >= 15
             boxes_xywh = preds[:, 0:4]
+            
             if has_landmarks:
                 scores = preds[:, 4]
             else:
@@ -264,11 +248,14 @@ class YoloV5FaceDetector:
                 else:
                     class_conf = cls_scores.max(axis=1, keepdims=True)
                     scores = (obj * class_conf).squeeze(-1)
+            
             keep = scores > self.conf_threshold
             boxes_xywh = boxes_xywh[keep]
             scores = scores[keep]
+            
             if boxes_xywh.shape[0] == 0:
                 return []
+            
             boxes_xyxy = self._xywh2xyxy(boxes_xywh)
             boxes_xyxy[:, [0, 2]] -= dwdh[0]
             boxes_xyxy[:, [1, 3]] -= dwdh[1]
@@ -277,9 +264,11 @@ class YoloV5FaceDetector:
             boxes_xyxy[:, 1] = np.clip(boxes_xyxy[:, 1], 0, h0 - 1)
             boxes_xyxy[:, 2] = np.clip(boxes_xyxy[:, 2], 0, w0 - 1)
             boxes_xyxy[:, 3] = np.clip(boxes_xyxy[:, 3], 0, h0 - 1)
+            
             keep_inds = _nms(boxes_xyxy, scores, self.iou_threshold)
             if len(keep_inds) > max_det:
                 keep_inds = keep_inds[:max_det]
+            
             dets = []
             for i in keep_inds:
                 dets.append({"bbox": boxes_xyxy[i].tolist(), "score": float(scores[i])})
@@ -291,11 +280,8 @@ class YoloV5FaceDetector:
 def _sigmoid(x: np.ndarray) -> np.ndarray:
     return 1.0 / (1.0 + np.exp(-x))
 
+# Anti-Spoofing Binary Class
 class AntiSpoofBinary:
-    """
-    Binary anti-spoof model wrapper (AntiSpoofing_bin_1.5_128.onnx).
-    Returns live probability in [0,1].
-    """
     def __init__(self, model_path: str, input_size: int = 128, rgb: bool = True, normalize: bool = True,
                  mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5), live_index: int = 1):
         self.input_size = int(input_size)
@@ -318,7 +304,6 @@ class AntiSpoofBinary:
                     print("⚠️ No ONNX providers available for anti-spoofing")
             except Exception as e:
                 print(f"⚠️ Failed to initialize anti-spoofing with ONNX Runtime: {e}")
-                print("🔄 Will use simple liveness check fallback")
                 self.session = None
         else:
             print("⚠️ ONNX Runtime not available - using simple liveness check fallback")
@@ -336,7 +321,6 @@ class AntiSpoofBinary:
 
     def predict_live_prob(self, face_bgr: np.ndarray) -> float:
         if self.session is None:
-            # Use simple fallback liveness check
             return simple_liveness_check(face_bgr)
         
         try:
@@ -357,6 +341,7 @@ class AntiSpoofBinary:
             print(f"ONNX anti-spoofing error, using fallback: {e}")
             return simple_liveness_check(face_bgr)
 
+# Helper Functions
 def expand_and_clip_box(bbox_xyxy, scale: float, w: int, h: int):
     x1, y1, x2, y2 = bbox_xyxy
     bw = x2 - x1
@@ -395,11 +380,9 @@ YOLO_FACE_MODEL_PATH = "models/yolov5s-face.onnx"
 ANTI_SPOOF_BIN_MODEL_PATH = "models/anti_spoofing/AntiSpoofing_bin_1.5_128.onnx"
 
 def ensure_models_exist():
-    """Download and verify all required models"""
     os.makedirs(DLIB_MODELS_DIR, exist_ok=True)
     os.makedirs("models/anti_spoofing", exist_ok=True)
     
-    # Download dlib face recognition model if not present
     if not os.path.exists(FACE_RECOGNITION_MODEL_PATH):
         print("Downloading dlib_face_recognition_resnet_model_v1.dat.bz2...")
         try:
@@ -416,7 +399,6 @@ def ensure_models_exist():
         except Exception as e:
             print(f"Failed to download dlib face recognition model: {e}")
     
-    # Check required models
     required_models = [SHAPE_PREDICTOR_PATH, FACE_RECOGNITION_MODEL_PATH]
     optional_models = [YOLO_FACE_MODEL_PATH, ANTI_SPOOF_BIN_MODEL_PATH]
     
@@ -434,9 +416,7 @@ def ensure_models_exist():
     print("✅ All critical models are available!")
     return True
 
-# Initialize models
 def init_models():
-    """Initialize all ML models with robust error handling"""
     global yolo_face, anti_spoof_bin, detector, shape_predictor, face_recognition_model
     
     try:
@@ -444,21 +424,18 @@ def init_models():
             print("❌ Cannot initialize critical models - some files are missing")
             return False
         
-        # Initialize dlib models (required)
         print("Loading dlib models...")
         detector = dlib.get_frontal_face_detector()
         shape_predictor = dlib.shape_predictor(SHAPE_PREDICTOR_PATH)
         face_recognition_model = dlib.face_recognition_model_v1(FACE_RECOGNITION_MODEL_PATH)
         print("✅ Dlib models loaded successfully!")
         
-        # Initialize ONNX models (with fallback)
         print("Loading ONNX models...")
         try:
             yolo_face = YoloV5FaceDetector(YOLO_FACE_MODEL_PATH, input_size=640, conf_threshold=0.3, iou_threshold=0.45)
             anti_spoof_bin = AntiSpoofBinary(ANTI_SPOOF_BIN_MODEL_PATH, input_size=128, rgb=True, normalize=True, live_index=1)
         except Exception as e:
             print(f"⚠️ ONNX models initialization had issues: {e}")
-            print("🔄 Fallback methods will be used")
         
         print("✅ Model initialization complete!")
         return True
@@ -467,10 +444,9 @@ def init_models():
         print(f"❌ Error initializing models: {e}")
         return False
 
-# Initialize models
 models_loaded = init_models()
 
-# Face processing functions (keeping all your existing functions)
+# Face processing functions
 def decode_image(base64_image):
     if ',' in base64_image:
         base64_image = base64_image.split(',')[1]
@@ -480,7 +456,6 @@ def decode_image(base64_image):
     return image
 
 def align_face(image, shape):
-    """Align the face using eye landmarks"""
     left_eye = (shape.part(36).x, shape.part(36).y)
     right_eye = (shape.part(45).x, shape.part(45).y)
     dx = right_eye[0] - left_eye[0]
@@ -492,7 +467,6 @@ def align_face(image, shape):
     return aligned_image
 
 def get_face_features(image):
-    """Extract aligned face features using ResNet model"""
     if not models_loaded:
         return None
         
@@ -512,7 +486,6 @@ def get_face_features(image):
     return np.array(face_descriptor)
 
 def recognize_face(image, user_id, user_type='student'):
-    """Face recognition function"""
     global total_attempts, correct_recognitions, false_accepts, false_rejects, inference_times, unauthorized_attempts
     
     if not models_loaded:
@@ -559,7 +532,7 @@ def recognize_face(image, user_id, user_type='student'):
     except Exception as e:
         return False, f"Error in face recognition: {str(e)}"
 
-# Metrics functions (keeping all your existing metrics functions)
+# Metrics functions
 def log_metrics_event(event: dict):
     if not metrics_events:
         return
@@ -568,42 +541,30 @@ def log_metrics_event(event: dict):
     except Exception as e:
         print("Failed to log metrics event:", e)
 
-def log_metrics_event_normalized(
-    *,
-    event: str,
-    attempt_type: str,
-    claimed_id: Optional[str],
-    recognized_id: Optional[str],
-    liveness_pass: bool,
-    distance: Optional[float],
-    live_prob: Optional[float],
-    latency_ms: Optional[float],
-    client_ip: Optional[str],
-    reason: Optional[str] = None
-):
-    if not liveness_pass:
+def log_metrics_event_normalized(**kwargs):
+    event = kwargs.get('event')
+    if not kwargs.get('liveness_pass'):
         decision = "spoof_blocked"
     else:
-        decision = "recognized" if event.startswith("accept") else "not_recognized"
+        decision = "recognized" if event and event.startswith("accept") else "not_recognized"
 
     doc = {
         "ts": datetime.now(timezone.utc),
         "event": event,
-        "attempt_type": attempt_type,
-        "claimed_id": claimed_id,
-        "recognized_id": recognized_id,
-        "liveness_pass": bool(liveness_pass),
-        "distance": distance,
-        "live_prob": live_prob,
-        "latency_ms": latency_ms,
-        "client_ip": client_ip,
-        "reason": reason,
+        "attempt_type": kwargs.get('attempt_type'),
+        "claimed_id": kwargs.get('claimed_id'),
+        "recognized_id": kwargs.get('recognized_id'),
+        "liveness_pass": bool(kwargs.get('liveness_pass')),
+        "distance": kwargs.get('distance'),
+        "live_prob": kwargs.get('live_prob'),
+        "latency_ms": kwargs.get('latency_ms'),
+        "client_ip": kwargs.get('client_ip'),
+        "reason": kwargs.get('reason'),
         "decision": decision,
     }
     log_metrics_event(doc)
 
 def classify_event(ev: Dict[str, Any]) -> Tuple[Optional[str], Optional[str]]:
-    """Returns (event, attempt_type)"""
     if ev.get("event"):
         e = ev.get("event")
         at = ev.get("attempt_type")
@@ -634,7 +595,6 @@ def classify_event(ev: Dict[str, Any]) -> Tuple[Optional[str], Optional[str]]:
     return None, None
 
 def compute_metrics(limit: int = 10000):
-    """Compute system metrics"""
     if not metrics_events:
         return {
             "counts": {"trueAccepts": 0, "falseAccepts": 0, "trueRejects": 0, "falseRejects": 0,
@@ -696,7 +656,7 @@ def compute_latency_avg(limit: int = 300) -> Optional[float]:
         return None
     return sum(vals) / len(vals)
 
-# Flask Routes (keeping all your existing routes)
+# Flask Routes
 @app.route('/')
 def home():
     return render_template('home.html')
@@ -713,6 +673,7 @@ def register_page():
 def metrics_dashboard():
     return render_template('metrics.html')
 
+# Student Routes
 @app.route('/register', methods=['POST'])
 def register():
     if not students_collection:
@@ -834,6 +795,62 @@ def face_login():
     flash('Face not recognized. Please try again or contact admin.', 'danger')
     return redirect(url_for('login_page'))
 
+@app.route('/auto-face-login', methods=['POST'])
+def auto_face_login():
+    try:
+        data = request.json
+        face_image = data.get('face_image')
+        face_role = data.get('face_role', 'student')
+        
+        if not face_image:
+            return jsonify({'success': False, 'message': 'No image received'})
+        
+        image = decode_image(face_image)
+        test_features = get_face_features(image)
+        if test_features is None:
+            return jsonify({'success': False, 'message': 'No face detected'})
+
+        if face_role == 'teacher':
+            collection = teachers_collection
+            id_field = 'teacher_id'
+            dashboard_route = '/teacher_dashboard'
+        else:
+            collection = students_collection
+            id_field = 'student_id'
+            dashboard_route = '/dashboard'
+
+        if not collection:
+            return jsonify({'success': False, 'message': 'Database not available'})
+
+        users = collection.find({'face_image': {'$exists': True, '$ne': None}})
+        for user in users:
+            try:
+                ref_image_array = np.frombuffer(user['face_image'], np.uint8)
+                ref_image = cv2.imdecode(ref_image_array, cv2.IMREAD_COLOR)
+                ref_features = get_face_features(ref_image)
+                if ref_features is None:
+                    continue
+                dist = np.linalg.norm(test_features - ref_features)
+                if dist < 0.6:
+                    session['logged_in'] = True
+                    session['user_type'] = face_role
+                    session[id_field] = user[id_field]
+                    session['name'] = user.get('name')
+                    return jsonify({
+                        'success': True,
+                        'message': f'Welcome {user["name"]}! Redirecting...',
+                        'redirect_url': dashboard_route,
+                        'face_role': face_role
+                    })
+            except Exception as e:
+                print(f"Error processing user {user.get(id_field)}: {e}")
+                continue
+
+        return jsonify({'success': False, 'message': f'Face not recognized in {face_role} database'})
+    except Exception as e:
+        print(f"Auto face login error: {e}")
+        return jsonify({'success': False, 'message': 'Login failed due to server error'})
+
 @app.route('/dashboard')
 def dashboard():
     if 'logged_in' not in session or session.get('user_type') != 'student':
@@ -856,6 +873,14 @@ def dashboard():
     
     return render_template('dashboard.html', student=student, attendance_records=attendance_records)
 
+@app.route('/attendance.html')
+def attendance_page():
+    if 'logged_in' not in session or session.get('user_type') != 'student':
+        return redirect(url_for('login_page'))
+    student_id = session.get('student_id')
+    student = students_collection.find_one({'student_id': student_id}) if students_collection else None
+    return render_template('attendance.html', student=student)
+
 @app.route('/mark-attendance', methods=['POST'])
 def mark_attendance():
     if 'logged_in' not in session or session.get('user_type') != 'student':
@@ -955,12 +980,169 @@ def mark_attendance():
     else:
         return jsonify({'success': False, 'message': message, 'overlay': overlay_data})
 
+@app.route('/liveness-preview', methods=['POST'])
+def liveness_preview():
+    if 'logged_in' not in session or session.get('user_type') != 'student':
+        return jsonify({'success': False, 'message': 'Not logged in'})
+    
+    try:
+        data = request.json or {}
+        face_image = data.get('face_image')
+        if not face_image:
+            return jsonify({'success': False, 'message': 'No image received'})
+        
+        image = decode_image(face_image)
+        if image is None or image.size == 0:
+            return jsonify({'success': False, 'message': 'Invalid image data'})
+        
+        h, w = image.shape[:2]
+        vis = image.copy()
+        detections = yolo_face.detect(image, max_det=10)
+        
+        if not detections:
+            overlay_data = image_to_data_uri(vis)
+            return jsonify({
+                'success': True,
+                'live': False,
+                'live_prob': 0.0,
+                'message': 'No face detected',
+                'overlay': overlay_data
+            })
+        
+        best = max(detections, key=lambda d: d["score"])
+        x1, y1, x2, y2 = [int(v) for v in best["bbox"]]
+        x1e, y1e, x2e, y2e = expand_and_clip_box((x1, y1, x2, y2), scale=1.2, w=w, h=h)
+        face_crop = image[y1e:y2e, x1e:x2e]
+        
+        if face_crop.size == 0:
+            overlay_data = image_to_data_uri(vis)
+            return jsonify({
+                'success': True,
+                'live': False,
+                'live_prob': 0.0,
+                'message': 'Failed to crop face',
+                'overlay': overlay_data
+            })
+        
+        live_prob = anti_spoof_bin.predict_live_prob(face_crop)
+        threshold = 0.7
+        label = "LIVE" if live_prob >= threshold else "SPOOF"
+        color = (0, 200, 0) if label == "LIVE" else (0, 0, 255)
+        
+        draw_live_overlay(vis, (x1e, y1e, x2e, y2e), label, live_prob, color)
+        overlay_data = image_to_data_uri(vis)
+        
+        return jsonify({
+            'success': True,
+            'live': bool(live_prob >= threshold),
+            'live_prob': float(live_prob),
+            'overlay': overlay_data
+        })
+    except Exception as e:
+        print("liveness_preview error:", e)
+        return jsonify({'success': False, 'message': 'Server error during preview'})
+
+# Teacher Routes
+@app.route('/teacher_register.html')
+def teacher_register_page():
+    return render_template('teacher_register.html')
+
+@app.route('/teacher_login.html')
+def teacher_login_page():
+    return render_template('teacher_login.html')
+
+@app.route('/teacher_register', methods=['POST'])
+def teacher_register():
+    if not teachers_collection:
+        flash('Database not available. Please try again later.', 'danger')
+        return redirect(url_for('teacher_register_page'))
+    
+    try:
+        teacher_data = {
+            'teacher_id': request.form.get('teacher_id'),
+            'name': request.form.get('name'),
+            'email': request.form.get('email'),
+            'department': request.form.get('department'),
+            'designation': request.form.get('designation'),
+            'mobile': request.form.get('mobile'),
+            'dob': request.form.get('dob'),
+            'gender': request.form.get('gender'),
+            'password': request.form.get('password'),
+            'created_at': datetime.now()
+        }
+        face_image = request.form.get('face_image')
+        if face_image and ',' in face_image:
+            image_data = face_image.split(',')[1]
+            teacher_data['face_image'] = Binary(base64.b64decode(image_data))
+            teacher_data['face_image_type'] = face_image.split(',')[0].split(':')[1].split(';')[0]
+        else:
+            flash('Face image is required for registration.', 'danger')
+            return redirect(url_for('teacher_register_page'))
+        
+        result = teachers_collection.insert_one(teacher_data)
+        if result.inserted_id:
+            flash('Registration successful! You can now login.', 'success')
+            return redirect(url_for('teacher_login_page'))
+        else:
+            flash('Registration failed. Please try again.', 'danger')
+            return redirect(url_for('teacher_register_page'))
+    except pymongo.errors.DuplicateKeyError:
+        flash('Teacher ID already exists. Please use a different ID.', 'danger')
+        return redirect(url_for('teacher_register_page'))
+    except Exception as e:
+        flash(f'Registration failed: {str(e)}', 'danger')
+        return redirect(url_for('teacher_register_page'))
+
+@app.route('/teacher_login', methods=['POST'])
+def teacher_login():
+    if not teachers_collection:
+        flash('Database not available. Please try again later.', 'danger')
+        return redirect(url_for('teacher_login_page'))
+    
+    teacher_id = request.form.get('teacher_id')
+    password = request.form.get('password')
+    teacher = teachers_collection.find_one({'teacher_id': teacher_id})
+    
+    if teacher and teacher['password'] == password:
+        session['logged_in'] = True
+        session['user_type'] = 'teacher'
+        session['teacher_id'] = teacher_id
+        session['name'] = teacher.get('name')
+        flash('Login successful!', 'success')
+        return redirect(url_for('teacher_dashboard'))
+    else:
+        flash('Invalid credentials. Please try again.', 'danger')
+        return redirect(url_for('teacher_login_page'))
+
+@app.route('/teacher_dashboard')
+def teacher_dashboard():
+    if 'logged_in' not in session or session.get('user_type') != 'teacher':
+        return redirect(url_for('teacher_login_page'))
+    
+    teacher_id = session.get('teacher_id')
+    teacher = teachers_collection.find_one({'teacher_id': teacher_id}) if teachers_collection else None
+    
+    if teacher and 'face_image' in teacher and teacher['face_image']:
+        face_image_base64 = base64.b64encode(teacher['face_image']).decode('utf-8')
+        mime_type = teacher.get('face_image_type', 'image/jpeg')
+        teacher['face_image_url'] = f"data:{mime_type};base64,{face_image_base64}"
+    
+    return render_template('teacher_dashboard.html', teacher=teacher)
+
+@app.route('/teacher_logout')
+def teacher_logout():
+    session.clear()
+    flash('You have been logged out', 'info')
+    return redirect(url_for('teacher_login_page'))
+
+# Common logout
 @app.route('/logout')
 def logout():
     session.clear()
     flash('You have been logged out', 'info')
     return redirect(url_for('login_page'))
 
+# Metrics endpoints
 @app.route('/metrics-json')
 def metrics_json():
     m = compute_metrics()
@@ -982,6 +1164,47 @@ def metrics_json():
         'Unauthorized Attempts': counts["unauthorizedRejected"],
     })
 
+@app.route('/metrics-data', methods=['GET'])
+def metrics_data():
+    data = compute_metrics()
+    recent = []
+    if metrics_events:
+        recent = list(metrics_events.find({}, {"_id": 0}).sort("ts", -1).limit(200))
+        for r in recent:
+            if isinstance(r.get("ts"), datetime):
+                r["ts"] = r["ts"].isoformat()
+            event, attempt_type = classify_event(r)
+            if event and not r.get("event"):
+                r["event"] = event
+            if attempt_type and not r.get("attempt_type"):
+                r["attempt_type"] = attempt_type
+            if "liveness_pass" not in r:
+                if r.get("decision") == "spoof_blocked":
+                    r["liveness_pass"] = False
+                elif isinstance(r.get("live_prob"), (int, float)):
+                    r["liveness_pass"] = bool(r["live_prob"] >= 0.7)
+                else:
+                    r["liveness_pass"] = None
+
+    data["recent"] = recent
+    data["avg_latency_ms"] = compute_latency_avg()
+    return jsonify(data)
+
+@app.route('/metrics-events')
+def metrics_events_api():
+    if not metrics_events:
+        return jsonify([])
+    
+    limit = int(request.args.get("limit", 200))
+    cursor = metrics_events.find({}, {"_id": 0}).sort("ts", -1).limit(limit)
+    events = list(cursor)
+    
+    for ev in events:
+        if isinstance(ev.get("ts"), datetime):
+            ev["ts"] = ev["ts"].isoformat()
+    
+    return jsonify(events)
+
 # Health check endpoint
 @app.route('/health')
 def health_check():
@@ -989,10 +1212,18 @@ def health_check():
         'status': 'healthy',
         'onnx_available': ONNX_AVAILABLE,
         'models_loaded': models_loaded,
-        'database_connected': db is not None,  # ✅ Fixed
+        'database_connected': db is not None,
         'timestamp': datetime.now().isoformat()
     })
 
+# Error handlers
+@app.errorhandler(404)
+def not_found_error(error):
+    return render_template('404.html'), 404
+
+@app.errorhandler(500)
+def internal_error(error):
+    return render_template('500.html'), 500
 
 if __name__ == '__main__':
     port = int(os.environ.get("PORT", 7860))