Added working database connection and facedection api

src/main/java/com/cs102/attendance/DatabaseTestRunner.java

@@ -0,0 +1,89 @@
+package com.cs102.attendance;
+
+import com.cs102.attendance.entity.*;
+import com.cs102.attendance.service.*;
+import com.cs102.attendance.repository.*;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.CommandLineRunner;
+import org.springframework.stereotype.Component;
+
+import java.time.LocalDate;
+import java.time.LocalTime;
+import java.util.Optional;
+
+@Component
+public class DatabaseTestRunner implements CommandLineRunner {
+
+    @Autowired private StudentService studentService;
+    @Autowired private SessionService sessionService;
+    @Autowired private StudentRepository studentRepository;
+    @Autowired private SessionRepository sessionRepository;
+    
+    @Override
+    public void run(String... args) throws Exception {
+        System.out.println("\nTESTING DATABASE OPERATIONS...\n");
+        
+        try {
+            // 1. Test Student Creation (or find existing)
+            System.out.println("1. Checking/Creating test student...");
+            Student student;
+            Optional<Student> existingStudent = studentRepository.findByCode("TEST001");
+            
+            if (existingStudent.isPresent()) {
+                student = existingStudent.get();
+                System.out.println("Found existing test student: " + student.getName() + " (ID: " + student.getId() + ")");
+            } else {
+                student = studentService.enrol("TEST001", "John Doe", "CS102", "Group A", "[email protected]", "123-456-7890");
+                System.out.println("Created new test student: " + student.getName() + " (ID: " + student.getId() + ")");
+            }
+            
+            // 2. Test Session Creation (or find existing)
+            System.out.println("\n2. Checking/Creating test session...");
+            Session session;
+            Optional<Session> existingSession = sessionRepository.findByNameAndDate("Test Lecture", LocalDate.now());
+            
+            if (existingSession.isPresent()) {
+                session = existingSession.get();
+                System.out.println("Found existing test session: " + session.getName() + " (ID: " + session.getId() + ")");
+            } else {
+                session = sessionService.createSession("Test Lecture", LocalDate.now(), LocalTime.of(9, 0), LocalTime.of(11, 0));
+                System.out.println("Created new test session: " + session.getName() + " (ID: " + session.getId() + ")");
+            }
+            
+            // 3. Test Face Data Upload (check if already exists)
+            System.out.println("\n3. Checking/Uploading face data...");
+            try {
+                FaceData faceData = studentService.uploadFaceImage(student.getId(), "http://example.com/face.jpg");
+                System.out.println("Uploaded face data (ID: " + faceData.getId() + ")");
+            } catch (Exception e) {
+                System.out.println("Face data upload skipped (likely already exists): " + e.getMessage());
+            }
+            
+            // 4. Test database queries (always run these tests)
+            System.out.println("\n4. Testing database queries...");
+            var students = studentService.getAllStudents();
+            System.out.println("Found " + students.size() + " student(s) in database");
+            
+            // 5. Test today's sessions query
+            System.out.println("\n5. Testing session queries...");
+            var sessions = sessionService.getTodaySessions();
+            System.out.println("Found " + sessions.size() + " session(s) for today");
+            
+            // 6. Test connection integrity
+            System.out.println("\n6. Testing connection integrity...");
+            Optional<Student> retrievedStudent = studentService.getStudentById(student.getId());
+            if (retrievedStudent.isPresent()) {
+                System.out.println("Student retrieval test: PASSED");
+            } else {
+                System.out.println("Student retrieval test: FAILED");
+            }
+            
+            System.out.println("\nALL DATABASE TESTS PASSED!");
+            System.out.println("Database is working correctly with persistent data.\n");
+            
+        } catch (Exception e) {
+            System.err.println("DATABASE TEST FAILED: " + e.getMessage());
+            e.printStackTrace();
+        }
+    }
+} 

src/main/java/com/cs102/attendance/config/RecognitionProperties.java

@@ -0,0 +1,28 @@
+package com.cs102.attendance.config;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+
+@Component
+@ConfigurationProperties(prefix = "recognition")
+public class RecognitionProperties {
+    
+    private double confidence = 0.70;
+    private long cooldownMs = 10000;
+    
+    public double getConfidence() {
+        return confidence;
+    }
+    
+    public void setConfidence(double confidence) {
+        this.confidence = confidence;
+    }
+    
+    public long getCooldownMs() {
+        return cooldownMs;
+    }
+    
+    public void setCooldownMs(long cooldownMs) {
+        this.cooldownMs = cooldownMs;
+    }
+} 

src/main/java/com/cs102/attendance/config/SecurityConfig.java

@@ -2,22 +2,26 @@ package com.cs102.attendance.config;
 
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
-import org.springframework.security.config.Customizer;
 import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
 import org.springframework.security.web.SecurityFilterChain;
 
 @Configuration
+@EnableWebSecurity
 public class SecurityConfig {
 
     @Bean
     public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
         http
-            .csrf(csrf -> csrf.disable()) // Disable CSRF for simplicity
-            .authorizeHttpRequests(auth -> auth
-                .requestMatchers("/call-face-recognition").permitAll()
-                .anyRequest().authenticated()
-            )
-            .httpBasic(Customizer.withDefaults()); // or formLogin/custom config
+            .csrf(csrf -> csrf.disable()) // Disable CSRF for API testing
+            .cors(cors -> cors.disable()) // Disable CORS for testing
+            .authorizeHttpRequests(authz -> authz
+                .requestMatchers("/api/**").permitAll() // Allow all API requests
+                .requestMatchers("/actuator/**").permitAll() // Allow actuator endpoints
+                .requestMatchers("/error").permitAll() // Allow error page
+                .anyRequest().permitAll() // Allow all requests for testing
+            );
+        
         return http.build();
     }
-}
+} 

src/main/java/com/cs102/attendance/controller/AttendanceController.java

@@ -0,0 +1,82 @@
+package com.cs102.attendance.controller;
+
+import com.cs102.attendance.entity.AttendanceRecord;
+import com.cs102.attendance.enums.Status;
+import com.cs102.attendance.service.AttendanceService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.UUID;
+
+@RestController
+@RequestMapping("/api/attendance")
+@CrossOrigin(origins = "*")
+public class AttendanceController {
+
+    @Autowired
+    @Qualifier("manual")
+    private AttendanceService manualMarker;
+
+    @Autowired
+    @Qualifier("auto")
+    private AttendanceService autoMarker;
+
+    // Mark attendance manually
+    @PostMapping("/manual")
+    public ResponseEntity<AttendanceRecord> markManualAttendance(@RequestBody MarkAttendanceRequest request) {
+        try {
+            AttendanceRecord record = manualMarker.markAttendance(
+                request.getStudentId(),
+                request.getSessionId(),
+                request.getStatus()
+            );
+            return ResponseEntity.ok(record);
+        } catch (RuntimeException e) {
+            return ResponseEntity.badRequest().body(null);
+        }
+    }
+
+    // Mark attendance automatically (with confidence)
+    @PostMapping("/auto")
+    public ResponseEntity<AttendanceRecord> markAutoAttendance(@RequestBody MarkAutoAttendanceRequest request) {
+        try {
+            // For auto marking, we need to cast to AutoMarker to access the confidence method
+            com.cs102.attendance.service.AutoMarker autoMarkerImpl = 
+                (com.cs102.attendance.service.AutoMarker) autoMarker;
+            
+            // First get the student and session entities, then call the method with confidence
+            AttendanceRecord record = autoMarkerImpl.markAttendance(
+                request.getStudentId(),
+                request.getSessionId(),
+                request.getStatus()
+            );
+            return ResponseEntity.ok(record);
+        } catch (RuntimeException e) {
+            return ResponseEntity.badRequest().body(null);
+        }
+    }
+
+    // DTOs for request bodies
+    public static class MarkAttendanceRequest {
+        private UUID studentId;
+        private UUID sessionId;
+        private Status status;
+
+        // Getters and setters
+        public UUID getStudentId() { return studentId; }
+        public void setStudentId(UUID studentId) { this.studentId = studentId; }
+        public UUID getSessionId() { return sessionId; }
+        public void setSessionId(UUID sessionId) { this.sessionId = sessionId; }
+        public Status getStatus() { return status; }
+        public void setStatus(Status status) { this.status = status; }
+    }
+
+    public static class MarkAutoAttendanceRequest extends MarkAttendanceRequest {
+        private double confidence;
+
+        public double getConfidence() { return confidence; }
+        public void setConfidence(double confidence) { this.confidence = confidence; }
+    }
+} 

src/main/java/com/cs102/attendance/controller/HealthController.java

@@ -1,49 +1,184 @@
-// package com.cs102.attendance.controller;
+package com.cs102.attendance.controller;
 
-// import org.springframework.beans.factory.annotation.Autowired;
-// import org.springframework.http.ResponseEntity;
-// import org.springframework.web.bind.annotation.GetMapping;
-// import org.springframework.web.bind.annotation.RequestMapping;
-// import org.springframework.web.bind.annotation.RestController;
+import com.zaxxer.hikari.HikariDataSource;
+import com.zaxxer.hikari.HikariPoolMXBean;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
 
-// import javax.sql.DataSource;
-// import java.sql.Connection;
-// import java.sql.SQLException;
-// import java.util.HashMap;
-// import java.util.Map;
+import javax.management.JMX;
+import javax.management.MBeanServer;
+import javax.management.ObjectName;
+import javax.sql.DataSource;
+import java.lang.management.ManagementFactory;
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.HashMap;
+import java.util.Map;
 
-// @RestController
-// @RequestMapping("/api/health")
-// public class HealthController {
+@RestController
+@RequestMapping("/api/health")
+public class HealthController {
 
-//     @Autowired
-//     private DataSource dataSource;
+    @Autowired
+    private DataSource dataSource;
 
-//     @GetMapping("/database")
-//     public ResponseEntity<Map<String, Object>> checkDatabaseConnection() {
-//         Map<String, Object> response = new HashMap<>();
+    @GetMapping("/database")
+    public ResponseEntity<Map<String, Object>> checkDatabaseConnection() {
+        Map<String, Object> response = new HashMap<>();
         
-//         try (Connection connection = dataSource.getConnection()) {
-//             // Test the connection
-//             boolean isValid = connection.isValid(5); // 5 second timeout
+        try (Connection connection = dataSource.getConnection()) {
+            // Test the connection
+            boolean isValid = connection.isValid(5); // 5 second timeout
             
-//             if (isValid) {
-//                 response.put("status", "UP");
-//                 response.put("database", "Connected");
-//                 response.put("url", connection.getMetaData().getURL());
-//                 response.put("driver", connection.getMetaData().getDriverName());
-//                 response.put("version", connection.getMetaData().getDatabaseProductVersion());
-//                 return ResponseEntity.ok(response);
-//             } else {
-//                 response.put("status", "DOWN");
-//                 response.put("database", "Connection invalid");
-//                 return ResponseEntity.status(503).body(response);
-//             }
-//         } catch (SQLException e) {
-//             response.put("status", "DOWN");
-//             response.put("database", "Connection failed");
-//             response.put("error", e.getMessage());
-//             return ResponseEntity.status(503).body(response);
-//         }
-//     }
-// } 
+            if (isValid) {
+                response.put("status", "UP");
+                response.put("database", "Connected");
+                response.put("url", connection.getMetaData().getURL());
+                response.put("driver", connection.getMetaData().getDriverName());
+                response.put("version", connection.getMetaData().getDatabaseProductVersion());
+                return ResponseEntity.ok(response);
+            } else {
+                response.put("status", "DOWN");
+                response.put("database", "Connection invalid");
+                return ResponseEntity.status(503).body(response);
+            }
+        } catch (SQLException e) {
+            response.put("status", "DOWN");
+            response.put("database", "Connection failed");
+            response.put("error", e.getMessage());
+            return ResponseEntity.status(503).body(response);
+        }
+    }
+
+    @GetMapping("/connection-pool")
+    public ResponseEntity<Map<String, Object>> checkConnectionPool() {
+        Map<String, Object> response = new HashMap<>();
+        
+        try {
+            if (dataSource instanceof HikariDataSource) {
+                HikariDataSource hikariDataSource = (HikariDataSource) dataSource;
+                
+                response.put("status", "UP");
+                response.put("poolName", "AttendanceHikariCP");
+                
+                // Basic configuration details (always available)
+                response.put("maximumPoolSize", hikariDataSource.getMaximumPoolSize());
+                response.put("minimumIdle", hikariDataSource.getMinimumIdle());
+                response.put("connectionTimeout", hikariDataSource.getConnectionTimeout());
+                response.put("idleTimeout", hikariDataSource.getIdleTimeout());
+                response.put("maxLifetime", hikariDataSource.getMaxLifetime());
+                response.put("leakDetectionThreshold", hikariDataSource.getLeakDetectionThreshold());
+                
+                // Try to get HikariCP MBean for detailed metrics
+                try {
+                    MBeanServer server = ManagementFactory.getPlatformMBeanServer();
+                    ObjectName poolName = new ObjectName("com.zaxxer.hikari:type=Pool (AttendanceHikariCP)");
+                    
+                    if (server.isRegistered(poolName)) {
+                        HikariPoolMXBean poolProxy = JMX.newMXBeanProxy(server, poolName, HikariPoolMXBean.class);
+                        
+                        response.put("activeConnections", poolProxy.getActiveConnections());
+                        response.put("idleConnections", poolProxy.getIdleConnections());
+                        response.put("totalConnections", poolProxy.getTotalConnections());
+                        response.put("threadsAwaitingConnection", poolProxy.getThreadsAwaitingConnection());
+                        
+                        // Health indicators
+                        int activeConnections = poolProxy.getActiveConnections();
+                        int totalConnections = poolProxy.getTotalConnections();
+                        int maxPoolSize = hikariDataSource.getMaximumPoolSize();
+                        
+                        response.put("poolUtilization", String.format("%.2f%%", 
+                            (double) totalConnections / maxPoolSize * 100));
+                        response.put("activeUtilization", String.format("%.2f%%", 
+                            (double) activeConnections / maxPoolSize * 100));
+                        
+                        // Warning thresholds
+                        if (totalConnections >= maxPoolSize * 0.9) {
+                            response.put("warning", "Connection pool is near maximum capacity");
+                        }
+                        if (poolProxy.getThreadsAwaitingConnection() > 0) {
+                            response.put("warning", "Threads are waiting for connections - possible bottleneck");
+                        }
+                    } else {
+                        response.put("mbeanStatus", "MBean not registered - pool metrics unavailable");
+                        response.put("note", "Pool configuration is available, but runtime metrics require MBean access");
+                    }
+                } catch (Exception mbeanException) {
+                    response.put("mbeanError", "Cannot access pool MBean: " + mbeanException.getMessage());
+                    response.put("note", "Pool configuration is available, but runtime metrics are not accessible");
+                }
+                
+                return ResponseEntity.ok(response);
+            } else {
+                response.put("status", "UNKNOWN");
+                response.put("message", "DataSource is not HikariCP");
+                return ResponseEntity.ok(response);
+            }
+        } catch (Exception e) {
+            response.put("status", "ERROR");
+            response.put("error", "Failed to get connection pool info: " + e.getMessage());
+            return ResponseEntity.status(500).body(response);
+        }
+    }
+    
+    @GetMapping("/connection-test")
+    public ResponseEntity<Map<String, Object>> testConnectionLeak() {
+        Map<String, Object> response = new HashMap<>();
+        
+        try {
+            // Test multiple rapid connections to check for leaks
+            for (int i = 0; i < 3; i++) {
+                try (Connection connection = dataSource.getConnection()) {
+                    connection.isValid(1);
+                }
+            }
+            
+            response.put("status", "UP");
+            response.put("message", "Connection leak test passed");
+            response.put("testConnections", 3);
+            return ResponseEntity.ok(response);
+            
+        } catch (SQLException e) {
+            response.put("status", "DOWN");
+            response.put("error", "Connection leak test failed: " + e.getMessage());
+            return ResponseEntity.status(503).body(response);
+        }
+    }
+    
+    @GetMapping("/pool-simple")
+    public ResponseEntity<Map<String, Object>> getSimplePoolInfo() {
+        Map<String, Object> response = new HashMap<>();
+        
+        try {
+            if (dataSource instanceof HikariDataSource) {
+                HikariDataSource hikariDataSource = (HikariDataSource) dataSource;
+                
+                response.put("status", "UP");
+                response.put("dataSourceType", "HikariCP");
+                response.put("poolName", hikariDataSource.getPoolName());
+                response.put("jdbcUrl", hikariDataSource.getJdbcUrl());
+                response.put("maximumPoolSize", hikariDataSource.getMaximumPoolSize());
+                response.put("minimumIdle", hikariDataSource.getMinimumIdle());
+                response.put("connectionTimeout", hikariDataSource.getConnectionTimeout() + "ms");
+                response.put("idleTimeout", hikariDataSource.getIdleTimeout() + "ms");
+                response.put("maxLifetime", hikariDataSource.getMaxLifetime() + "ms");
+                response.put("leakDetectionThreshold", hikariDataSource.getLeakDetectionThreshold() + "ms");
+                response.put("isRunning", !hikariDataSource.isClosed());
+                
+                return ResponseEntity.ok(response);
+            } else {
+                response.put("status", "UNKNOWN");
+                response.put("dataSourceType", dataSource.getClass().getSimpleName());
+                response.put("message", "Not using HikariCP");
+                return ResponseEntity.ok(response);
+            }
+        } catch (Exception e) {
+            response.put("status", "ERROR");
+            response.put("error", "Failed to get pool info: " + e.getMessage());
+            return ResponseEntity.status(500).body(response);
+        }
+    }
+} 

src/main/java/com/cs102/attendance/controller/SessionController.java

@@ -0,0 +1,113 @@
+package com.cs102.attendance.controller;
+
+import com.cs102.attendance.entity.Session;
+import com.cs102.attendance.dto.SessionDto;
+import com.cs102.attendance.service.SessionService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.time.LocalDate;
+import java.time.LocalTime;
+import java.util.List;
+import java.util.UUID;
+import java.util.Optional;
+
+@RestController
+@RequestMapping("/api/sessions")
+@CrossOrigin(origins = "*")
+public class SessionController {
+
+    @Autowired
+    private SessionService sessionService;
+
+    // Create a new session
+    @PostMapping
+    public ResponseEntity<Session> createSession(@RequestBody CreateSessionRequest request) {
+        try {
+            Session session = sessionService.createSession(
+                request.getName(),
+                request.getDate(),
+                request.getStartTime(),
+                request.getEndTime()
+            );
+            return ResponseEntity.ok(session);
+        } catch (Exception e) {
+            return ResponseEntity.badRequest().build();
+        }
+    }
+
+    // Get all sessions
+    @GetMapping
+    public ResponseEntity<List<Session>> getAllSessions() {
+        List<Session> sessions = sessionService.getAllSessions();
+        return ResponseEntity.ok(sessions);
+    }
+
+    // Get session by ID
+    @GetMapping("/{id}")
+    public ResponseEntity<Session> getSessionById(@PathVariable UUID id) {
+        Optional<Session> session = sessionService.getSessionById(id);
+        return session.map(ResponseEntity::ok)
+                     .orElse(ResponseEntity.notFound().build());
+    }
+
+    // Get today's sessions
+    @GetMapping("/today")
+    public ResponseEntity<List<SessionDto>> getTodaySessions() {
+        List<SessionDto> sessions = sessionService.getTodaySessionDtos();
+        return ResponseEntity.ok(sessions);
+    }
+
+    // Get sessions for specific date
+    @GetMapping("/date/{date}")
+    public ResponseEntity<List<Session>> getSessionsByDate(@PathVariable String date) {
+        try {
+            LocalDate localDate = LocalDate.parse(date);
+            List<Session> sessions = sessionService.getTodaySessions(localDate);
+            return ResponseEntity.ok(sessions);
+        } catch (Exception e) {
+            return ResponseEntity.badRequest().build();
+        }
+    }
+
+    // Close session
+    @PutMapping("/{id}/close")
+    public ResponseEntity<Session> closeSession(@PathVariable UUID id) {
+        try {
+            Session session = sessionService.closeSession(id);
+            return ResponseEntity.ok(session);
+        } catch (RuntimeException e) {
+            return ResponseEntity.notFound().build();
+        }
+    }
+
+    // Delete session
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Void> deleteSession(@PathVariable UUID id) {
+        try {
+            sessionService.deleteSession(id);
+            return ResponseEntity.ok().build();
+        } catch (Exception e) {
+            return ResponseEntity.notFound().build();
+        }
+    }
+
+    // DTO for request body
+    public static class CreateSessionRequest {
+        private String name;
+        private LocalDate date;
+        private LocalTime startTime;
+        private LocalTime endTime;
+
+        // Getters and setters
+        public String getName() { return name; }
+        public void setName(String name) { this.name = name; }
+        public LocalDate getDate() { return date; }
+        public void setDate(LocalDate date) { this.date = date; }
+        public LocalTime getStartTime() { return startTime; }
+        public void setStartTime(LocalTime startTime) { this.startTime = startTime; }
+        public LocalTime getEndTime() { return endTime; }
+        public void setEndTime(LocalTime endTime) { this.endTime = endTime; }
+    }
+} 

src/main/java/com/cs102/attendance/controller/StudentController.java

@@ -0,0 +1,168 @@
+package com.cs102.attendance.controller;
+
+import com.cs102.attendance.entity.Student;
+import com.cs102.attendance.entity.FaceData;
+import com.cs102.attendance.service.StudentService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.UUID;
+import java.util.Optional;
+
+@RestController
+@RequestMapping("/api/students")
+@CrossOrigin(origins = "*") // Allow CORS for testing
+public class StudentController {
+
+    @Autowired
+    private StudentService studentService;
+
+    // Create a new student
+    @PostMapping
+    public ResponseEntity<Student> createStudent(@RequestBody CreateStudentRequest request) {
+        try {
+            Student student = studentService.enrol(
+                request.getCode(),
+                request.getName(),
+                request.getClassName(),
+                request.getStudentGroup(),
+                request.getEmail(),
+                request.getPhone()
+            );
+            return ResponseEntity.ok(student);
+        } catch (Exception e) {
+            return ResponseEntity.badRequest().build();
+        }
+    }
+
+    // Get all students
+    @GetMapping
+    public ResponseEntity<List<Student>> getAllStudents() {
+        try {
+            List<Student> students = studentService.getAllStudents();
+            return ResponseEntity.ok(students);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return ResponseEntity.status(500).build();
+        }
+    }
+
+    // Simple test endpoint
+    @GetMapping("/health-check")
+    public ResponseEntity<String> testEndpoint() {
+        return ResponseEntity.ok("Students endpoint is working!");
+    }
+
+    // Count endpoint
+    @GetMapping("/count")
+    public ResponseEntity<Long> getStudentCount() {
+        try {
+            List<Student> students = studentService.getAllStudents();
+            return ResponseEntity.ok((long) students.size());
+        } catch (Exception e) {
+            e.printStackTrace();
+            return ResponseEntity.status(500).body(-1L);
+        }
+    }
+
+    // Get student by ID
+    @GetMapping("/{id}")
+    public ResponseEntity<Student> getStudentById(@PathVariable UUID id) {
+        Optional<Student> student = studentService.getStudentById(id);
+        return student.map(ResponseEntity::ok)
+                     .orElse(ResponseEntity.notFound().build());
+    }
+
+    // Update student
+    @PutMapping("/{id}")
+    public ResponseEntity<Student> updateStudent(@PathVariable UUID id, @RequestBody UpdateStudentRequest request) {
+        try {
+            Student updated = studentService.updateProfile(
+                id,
+                request.getName(),
+                request.getClassName(),
+                request.getStudentGroup(),
+                request.getEmail(),
+                request.getPhone()
+            );
+            return ResponseEntity.ok(updated);
+        } catch (RuntimeException e) {
+            return ResponseEntity.notFound().build();
+        }
+    }
+
+    // Delete student
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Void> deleteStudent(@PathVariable UUID id) {
+        try {
+            studentService.deleteStudent(id);
+            return ResponseEntity.ok().build();
+        } catch (Exception e) {
+            return ResponseEntity.notFound().build();
+        }
+    }
+
+    // Upload face image (URL)
+    @PostMapping("/{id}/face-image")
+    public ResponseEntity<FaceData> uploadFaceImage(@PathVariable UUID id, @RequestBody FaceImageRequest request) {
+        try {
+            FaceData faceData = studentService.uploadFaceImage(id, request.getImageUrl());
+            return ResponseEntity.ok(faceData);
+        } catch (RuntimeException e) {
+            return ResponseEntity.notFound().build();
+        }
+    }
+
+    // DTOs for request bodies
+    public static class CreateStudentRequest {
+        private String code;
+        private String name;
+        private String className;
+        private String studentGroup;
+        private String email;
+        private String phone;
+
+        // Getters and setters
+        public String getCode() { return code; }
+        public void setCode(String code) { this.code = code; }
+        public String getName() { return name; }
+        public void setName(String name) { this.name = name; }
+        public String getClassName() { return className; }
+        public void setClassName(String className) { this.className = className; }
+        public String getStudentGroup() { return studentGroup; }
+        public void setStudentGroup(String studentGroup) { this.studentGroup = studentGroup; }
+        public String getEmail() { return email; }
+        public void setEmail(String email) { this.email = email; }
+        public String getPhone() { return phone; }
+        public void setPhone(String phone) { this.phone = phone; }
+    }
+
+    public static class UpdateStudentRequest {
+        private String name;
+        private String className;
+        private String studentGroup;
+        private String email;
+        private String phone;
+
+        // Getters and setters
+        public String getName() { return name; }
+        public void setName(String name) { this.name = name; }
+        public String getClassName() { return className; }
+        public void setClassName(String className) { this.className = className; }
+        public String getStudentGroup() { return studentGroup; }
+        public void setStudentGroup(String studentGroup) { this.studentGroup = studentGroup; }
+        public String getEmail() { return email; }
+        public void setEmail(String email) { this.email = email; }
+        public String getPhone() { return phone; }
+        public void setPhone(String phone) { this.phone = phone; }
+    }
+
+    public static class FaceImageRequest {
+        private String imageUrl;
+
+        public String getImageUrl() { return imageUrl; }
+        public void setImageUrl(String imageUrl) { this.imageUrl = imageUrl; }
+    }
+} 

src/main/java/com/cs102/attendance/controller/TestController.java

@@ -1,75 +1,78 @@
-// package com.cs102.attendance.controller;
+package com.cs102.attendance.controller;
 
-// import com.cs102.attendance.entity.TestConnection;
-// import com.cs102.attendance.repository.TestConnectionRepository;
-// import org.springframework.beans.factory.annotation.Autowired;
-// import org.springframework.http.ResponseEntity;
-// import org.springframework.web.bind.annotation.*;
+import com.cs102.attendance.entity.Student;
+import com.cs102.attendance.repository.StudentRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
 
-// import java.util.HashMap;
-// import java.util.List;
-// import java.util.Map;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 
-// @RestController
-// @RequestMapping("/api/test")
-// public class TestController {
+@RestController
+@RequestMapping("/api/test")
+public class TestController {
 
-//     @Autowired
-//     private TestConnectionRepository testConnectionRepository;
+    @Autowired
+    private StudentRepository studentRepository;
 
-//     @GetMapping("/database-operations")
-//     public ResponseEntity<Map<String, Object>> testDatabaseOperations() {
-//         Map<String, Object> response = new HashMap<>();
+    @GetMapping("/database-operations")
+    public ResponseEntity<Map<String, Object>> testDatabaseOperations() {
+        Map<String, Object> response = new HashMap<>();
         
-//         try {
-//             // Test 1: Simple query
-//             Integer queryResult = testConnectionRepository.testQuery();
-//             response.put("simpleQuery", queryResult == 1 ? "PASS" : "FAIL");
+        try {
+            // Test 1: Insert operation
+            Student testStudent = new Student("TEST001", "Test Student");
+            testStudent.setEmail("[email protected]");
+            Student saved = studentRepository.save(testStudent);
+            response.put("insertOperation", saved.getId() != null ? "PASS" : "FAIL");
             
-//             // Test 2: Insert operation
-//             TestConnection testEntity = new TestConnection("Connection test from Spring Boot");
-//             TestConnection saved = testConnectionRepository.save(testEntity);
-//             response.put("insertOperation", saved.getId() != null ? "PASS" : "FAIL");
+            // Test 2: Read operation
+            List<Student> allRecords = studentRepository.findAll();
+            response.put("readOperation", !allRecords.isEmpty() ? "PASS" : "FAIL");
+            response.put("recordCount", allRecords.size());
             
-//             // Test 3: Read operation
-//             List<TestConnection> allRecords = testConnectionRepository.findAll();
-//             response.put("readOperation", !allRecords.isEmpty() ? "PASS" : "FAIL");
-//             response.put("recordCount", allRecords.size());
+            // Test 3: Delete operation
+            studentRepository.deleteById(saved.getId());
+            response.put("deleteOperation", "PASS");
             
-//             // Test 4: Delete operation
-//             testConnectionRepository.deleteById(saved.getId());
-//             response.put("deleteOperation", "PASS");
+            response.put("overallStatus", "SUCCESS");
+            response.put("message", "All database operations completed successfully");
             
-//             response.put("overallStatus", "SUCCESS");
-//             response.put("message", "All database operations completed successfully");
-            
-//             return ResponseEntity.ok(response);
-//         } catch (Exception e) {
-//             response.put("overallStatus", "FAILED");
-//             response.put("error", e.getMessage());
-//             response.put("errorClass", e.getClass().getSimpleName());
-//             return ResponseEntity.status(500).body(response);
-//         }
-//     }
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            response.put("overallStatus", "FAILED");
+            response.put("error", e.getMessage());
+            response.put("errorClass", e.getClass().getSimpleName());
+            return ResponseEntity.status(500).body(response);
+        }
+    }
     
-//     @PostMapping("/insert-test-data")
-//     public ResponseEntity<TestConnection> insertTestData(@RequestParam(defaultValue = "Test message") String message) {
-//         try {
-//             TestConnection testEntity = new TestConnection(message);
-//             TestConnection saved = testConnectionRepository.save(testEntity);
-//             return ResponseEntity.ok(saved);
-//         } catch (Exception e) {
-//             return ResponseEntity.status(500).build();
-//         }
-//     }
+    @PostMapping("/insert-test-data")
+    public ResponseEntity<Student> insertTestData(
+            @RequestParam String code,
+            @RequestParam String name,
+            @RequestParam(required = false) String email) {
+        try {
+            Student testStudent = new Student(code, name);
+            if (email != null) {
+                testStudent.setEmail(email);
+            }
+            Student saved = studentRepository.save(testStudent);
+            return ResponseEntity.ok(saved);
+        } catch (Exception e) {
+            return ResponseEntity.status(500).build();
+        }
+    }
     
-//     @GetMapping("/all-test-data")
-//     public ResponseEntity<List<TestConnection>> getAllTestData() {
-//         try {
-//             List<TestConnection> allRecords = testConnectionRepository.findAll();
-//             return ResponseEntity.ok(allRecords);
-//         } catch (Exception e) {
-//             return ResponseEntity.status(500).build();
-//         }
-//     }
-// } 
+    @GetMapping("/all-test-data")
+    public ResponseEntity<List<Student>> getAllTestData() {
+        try {
+            List<Student> allRecords = studentRepository.findAll();
+            return ResponseEntity.ok(allRecords);
+        } catch (Exception e) {
+            return ResponseEntity.status(500).build();
+        }
+    }
+} 

src/main/java/com/cs102/attendance/dto/MainViewDto.java

@@ -0,0 +1,55 @@
+package com.cs102.attendance.dto;
+
+import java.util.List;
+
+public class MainViewDto {
+    private List<SessionDto> todaySessions;
+    private List<StudentRosterDto> studentRoster;
+    private int totalStudents;
+    private int totalSessions;
+    
+    // Constructors
+    public MainViewDto() {}
+    
+    public MainViewDto(List<SessionDto> todaySessions, List<StudentRosterDto> studentRoster) {
+        this.todaySessions = todaySessions;
+        this.studentRoster = studentRoster;
+        this.totalStudents = studentRoster != null ? studentRoster.size() : 0;
+        this.totalSessions = todaySessions != null ? todaySessions.size() : 0;
+    }
+    
+    // Getters and Setters
+    public List<SessionDto> getTodaySessions() {
+        return todaySessions;
+    }
+    
+    public void setTodaySessions(List<SessionDto> todaySessions) {
+        this.todaySessions = todaySessions;
+        this.totalSessions = todaySessions != null ? todaySessions.size() : 0;
+    }
+    
+    public List<StudentRosterDto> getStudentRoster() {
+        return studentRoster;
+    }
+    
+    public void setStudentRoster(List<StudentRosterDto> studentRoster) {
+        this.studentRoster = studentRoster;
+        this.totalStudents = studentRoster != null ? studentRoster.size() : 0;
+    }
+    
+    public int getTotalStudents() {
+        return totalStudents;
+    }
+    
+    public void setTotalStudents(int totalStudents) {
+        this.totalStudents = totalStudents;
+    }
+    
+    public int getTotalSessions() {
+        return totalSessions;
+    }
+    
+    public void setTotalSessions(int totalSessions) {
+        this.totalSessions = totalSessions;
+    }
+} 

src/main/java/com/cs102/attendance/dto/SessionDto.java

@@ -0,0 +1,101 @@
+package com.cs102.attendance.dto;
+
+import java.time.LocalDate;
+import java.time.LocalTime;
+import java.util.UUID;
+
+public class SessionDto {
+    private UUID id;
+    private String name;
+    private LocalDate date;
+    private LocalTime startTime;
+    private LocalTime endTime;
+    private long presentCount;
+    private long absentCount;
+    private long lateCount;
+    private long totalStudents;
+    
+    // Constructors
+    public SessionDto() {}
+    
+    public SessionDto(UUID id, String name, LocalDate date, LocalTime startTime, LocalTime endTime) {
+        this.id = id;
+        this.name = name;
+        this.date = date;
+        this.startTime = startTime;
+        this.endTime = endTime;
+    }
+    
+    // Getters and Setters
+    public UUID getId() {
+        return id;
+    }
+    
+    public void setId(UUID id) {
+        this.id = id;
+    }
+    
+    public String getName() {
+        return name;
+    }
+    
+    public void setName(String name) {
+        this.name = name;
+    }
+    
+    public LocalDate getDate() {
+        return date;
+    }
+    
+    public void setDate(LocalDate date) {
+        this.date = date;
+    }
+    
+    public LocalTime getStartTime() {
+        return startTime;
+    }
+    
+    public void setStartTime(LocalTime startTime) {
+        this.startTime = startTime;
+    }
+    
+    public LocalTime getEndTime() {
+        return endTime;
+    }
+    
+    public void setEndTime(LocalTime endTime) {
+        this.endTime = endTime;
+    }
+    
+    public long getPresentCount() {
+        return presentCount;
+    }
+    
+    public void setPresentCount(long presentCount) {
+        this.presentCount = presentCount;
+    }
+    
+    public long getAbsentCount() {
+        return absentCount;
+    }
+    
+    public void setAbsentCount(long absentCount) {
+        this.absentCount = absentCount;
+    }
+    
+    public long getLateCount() {
+        return lateCount;
+    }
+    
+    public void setLateCount(long lateCount) {
+        this.lateCount = lateCount;
+    }
+    
+    public long getTotalStudents() {
+        return totalStudents;
+    }
+    
+    public void setTotalStudents(long totalStudents) {
+        this.totalStudents = totalStudents;
+    }
+} 

src/main/java/com/cs102/attendance/dto/StudentRosterDto.java

@@ -0,0 +1,54 @@
+package com.cs102.attendance.dto;
+
+import com.cs102.attendance.enums.Status;
+import java.util.UUID;
+
+public class StudentRosterDto {
+    private UUID id;
+    private String code;
+    private String name;
+    private Status status;
+    
+    // Constructors
+    public StudentRosterDto() {}
+    
+    public StudentRosterDto(UUID id, String code, String name, Status status) {
+        this.id = id;
+        this.code = code;
+        this.name = name;
+        this.status = status;
+    }
+    
+    // Getters and Setters
+    public UUID getId() {
+        return id;
+    }
+    
+    public void setId(UUID id) {
+        this.id = id;
+    }
+    
+    public String getCode() {
+        return code;
+    }
+    
+    public void setCode(String code) {
+        this.code = code;
+    }
+    
+    public String getName() {
+        return name;
+    }
+    
+    public void setName(String name) {
+        this.name = name;
+    }
+    
+    public Status getStatus() {
+        return status;
+    }
+    
+    public void setStatus(Status status) {
+        this.status = status;
+    }
+} 

src/main/java/com/cs102/attendance/entity/AttendanceRecord.java

@@ -0,0 +1,93 @@
+package com.cs102.attendance.entity;
+
+import com.cs102.attendance.enums.Status;
+import com.cs102.attendance.enums.Method;
+import jakarta.persistence.*;
+import java.time.LocalDateTime;
+
+@jakarta.persistence.Entity
+@Table(name = "attendance_records")
+public class AttendanceRecord extends Entity {
+    
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "student_id", nullable = false)
+    private Student student;
+    
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "session_id", nullable = false)
+    private Session session;
+    
+    @Enumerated(EnumType.STRING)
+    @Column(nullable = false)
+    private Status status;
+    
+    @Enumerated(EnumType.STRING)
+    @Column(nullable = false)
+    private Method method;
+    
+    @Column
+    private Double confidence;
+    
+    @Column(name = "marked_at", nullable = false)
+    private LocalDateTime markedAt;
+    
+    // Constructors
+    public AttendanceRecord() {}
+    
+    public AttendanceRecord(Student student, Session session, Status status, Method method) {
+        this.student = student;
+        this.session = session;
+        this.status = status;
+        this.method = method;
+        this.markedAt = LocalDateTime.now();
+    }
+    
+    // Getters and Setters
+    public Student getStudent() {
+        return student;
+    }
+    
+    public void setStudent(Student student) {
+        this.student = student;
+    }
+    
+    public Session getSession() {
+        return session;
+    }
+    
+    public void setSession(Session session) {
+        this.session = session;
+    }
+    
+    public Status getStatus() {
+        return status;
+    }
+    
+    public void setStatus(Status status) {
+        this.status = status;
+    }
+    
+    public Method getMethod() {
+        return method;
+    }
+    
+    public void setMethod(Method method) {
+        this.method = method;
+    }
+    
+    public Double getConfidence() {
+        return confidence;
+    }
+    
+    public void setConfidence(Double confidence) {
+        this.confidence = confidence;
+    }
+    
+    public LocalDateTime getMarkedAt() {
+        return markedAt;
+    }
+    
+    public void setMarkedAt(LocalDateTime markedAt) {
+        this.markedAt = markedAt;
+    }
+} 

src/main/java/com/cs102/attendance/entity/Entity.java

@@ -0,0 +1,34 @@
+package com.cs102.attendance.entity;
+
+import jakarta.persistence.*;
+import java.util.Objects;
+import java.util.UUID;
+
+@MappedSuperclass
+public abstract class Entity {
+    
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    private UUID id;
+    
+    public UUID getId() {
+        return id;
+    }
+    
+    public void setId(UUID id) {
+        this.id = id;
+    }
+    
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Entity entity = (Entity) o;
+        return Objects.equals(id, entity.id);
+    }
+    
+    @Override
+    public int hashCode() {
+        return Objects.hash(id);
+    }
+} 

src/main/java/com/cs102/attendance/entity/FaceData.java

@@ -0,0 +1,57 @@
+package com.cs102.attendance.entity;
+
+import jakarta.persistence.*;
+
+@jakarta.persistence.Entity
+@Table(name = "face_data")
+public class FaceData extends Entity {
+    
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "student_id", nullable = false)
+    private Student student;
+    
+    @Column(name = "image_url")
+    private String imageUrl;
+    
+    @Lob
+    @Column(name = "image_data")
+    private byte[] imageData;
+    
+    // Constructors
+    public FaceData() {}
+    
+    public FaceData(Student student, String imageUrl) {
+        this.student = student;
+        this.imageUrl = imageUrl;
+    }
+    
+    public FaceData(Student student, byte[] imageData) {
+        this.student = student;
+        this.imageData = imageData;
+    }
+    
+    // Getters and Setters
+    public Student getStudent() {
+        return student;
+    }
+    
+    public void setStudent(Student student) {
+        this.student = student;
+    }
+    
+    public String getImageUrl() {
+        return imageUrl;
+    }
+    
+    public void setImageUrl(String imageUrl) {
+        this.imageUrl = imageUrl;
+    }
+    
+    public byte[] getImageData() {
+        return imageData;
+    }
+    
+    public void setImageData(byte[] imageData) {
+        this.imageData = imageData;
+    }
+} 

src/main/java/com/cs102/attendance/entity/Session.java

@@ -0,0 +1,80 @@
+package com.cs102.attendance.entity;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import jakarta.persistence.*;
+import java.time.LocalDate;
+import java.time.LocalTime;
+import java.util.List;
+import java.util.ArrayList;
+
+@jakarta.persistence.Entity
+@Table(name = "sessions")
+public class Session extends Entity {
+    
+    @Column(nullable = false)
+    private String name;
+    
+    @Column(nullable = false)
+    private LocalDate date;
+    
+    @Column(name = "start_time", nullable = false)
+    private LocalTime startTime;
+    
+    @Column(name = "end_time", nullable = false)
+    private LocalTime endTime;
+    
+    @OneToMany(mappedBy = "session", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
+    @JsonIgnore
+    private List<AttendanceRecord> attendanceRecords = new ArrayList<>();
+    
+    // Constructors
+    public Session() {}
+    
+    public Session(String name, LocalDate date, LocalTime startTime, LocalTime endTime) {
+        this.name = name;
+        this.date = date;
+        this.startTime = startTime;
+        this.endTime = endTime;
+    }
+    
+    // Getters and Setters
+    public String getName() {
+        return name;
+    }
+    
+    public void setName(String name) {
+        this.name = name;
+    }
+    
+    public LocalDate getDate() {
+        return date;
+    }
+    
+    public void setDate(LocalDate date) {
+        this.date = date;
+    }
+    
+    public LocalTime getStartTime() {
+        return startTime;
+    }
+    
+    public void setStartTime(LocalTime startTime) {
+        this.startTime = startTime;
+    }
+    
+    public LocalTime getEndTime() {
+        return endTime;
+    }
+    
+    public void setEndTime(LocalTime endTime) {
+        this.endTime = endTime;
+    }
+    
+    public List<AttendanceRecord> getAttendanceRecords() {
+        return attendanceRecords;
+    }
+    
+    public void setAttendanceRecords(List<AttendanceRecord> attendanceRecords) {
+        this.attendanceRecords = attendanceRecords;
+    }
+} 

src/main/java/com/cs102/attendance/entity/Student.java

@@ -0,0 +1,108 @@
+package com.cs102.attendance.entity;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import jakarta.persistence.*;
+import java.util.List;
+import java.util.ArrayList;
+
+@jakarta.persistence.Entity
+@Table(name = "students")
+public class Student extends Entity {
+    
+    @Column(unique = true, nullable = false)
+    private String code;
+    
+    @Column(nullable = false)
+    private String name;
+    
+    @Column(name = "class_name")
+    private String className;
+    
+    @Column(name = "student_group")
+    private String studentGroup;
+    
+    private String email;
+    
+    private String phone;
+    
+    @OneToMany(mappedBy = "student", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
+    @JsonIgnore
+    private List<FaceData> faceData = new ArrayList<>();
+    
+    @OneToMany(mappedBy = "student", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
+    @JsonIgnore
+    private List<AttendanceRecord> attendanceRecords = new ArrayList<>();
+    
+    // Constructors
+    public Student() {}
+    
+    public Student(String code, String name) {
+        this.code = code;
+        this.name = name;
+    }
+    
+    // Getters and Setters
+    public String getCode() {
+        return code;
+    }
+    
+    public void setCode(String code) {
+        this.code = code;
+    }
+    
+    public String getName() {
+        return name;
+    }
+    
+    public void setName(String name) {
+        this.name = name;
+    }
+    
+    public String getClassName() {
+        return className;
+    }
+    
+    public void setClassName(String className) {
+        this.className = className;
+    }
+    
+    public String getStudentGroup() {
+        return studentGroup;
+    }
+    
+    public void setStudentGroup(String studentGroup) {
+        this.studentGroup = studentGroup;
+    }
+    
+    public String getEmail() {
+        return email;
+    }
+    
+    public void setEmail(String email) {
+        this.email = email;
+    }
+    
+    public String getPhone() {
+        return phone;
+    }
+    
+    public void setPhone(String phone) {
+        this.phone = phone;
+    }
+    
+    public List<FaceData> getFaceData() {
+        return faceData;
+    }
+    
+    public void setFaceData(List<FaceData> faceData) {
+        this.faceData = faceData;
+    }
+    
+    public List<AttendanceRecord> getAttendanceRecords() {
+        return attendanceRecords;
+    }
+    
+    public void setAttendanceRecords(List<AttendanceRecord> attendanceRecords) {
+        this.attendanceRecords = attendanceRecords;
+    }
+} 

src/main/java/com/cs102/attendance/entity/TestConnection.java

@@ -1,53 +0,0 @@
-// package com.cs102.attendance.entity;
-
-// import jakarta.persistence.*;
-// import java.time.LocalDateTime;
-
-// @Entity
-// @Table(name = "test_connections")
-// public class TestConnection {
-    
-//     @Id
-//     @GeneratedValue(strategy = GenerationType.IDENTITY)
-//     private Long id;
-    
-//     @Column(name = "test_message")
-//     private String testMessage;
-    
-//     @Column(name = "created_at")
-//     private LocalDateTime createdAt;
-    
-//     public TestConnection() {
-//         this.createdAt = LocalDateTime.now();
-//     }
-    
-//     public TestConnection(String testMessage) {
-//         this.testMessage = testMessage;
-//         this.createdAt = LocalDateTime.now();
-//     }
-    
-//     // Getters and setters
-//     public Long getId() {
-//         return id;
-//     }
-    
-//     public void setId(Long id) {
-//         this.id = id;
-//     }
-    
-//     public String getTestMessage() {
-//         return testMessage;
-//     }
-    
-//     public void setTestMessage(String testMessage) {
-//         this.testMessage = testMessage;
-//     }
-    
-//     public LocalDateTime getCreatedAt() {
-//         return createdAt;
-//     }
-    
-//     public void setCreatedAt(LocalDateTime createdAt) {
-//         this.createdAt = createdAt;
-//     }
-// } 

src/main/java/com/cs102/attendance/enums/Method.java

@@ -0,0 +1,6 @@
+package com.cs102.attendance.enums;
+
+public enum Method {
+    AUTO,
+    MANUAL
+} 

src/main/java/com/cs102/attendance/enums/Status.java

@@ -0,0 +1,7 @@
+package com.cs102.attendance.enums;
+
+public enum Status {
+    PRESENT,
+    ABSENT,
+    LATE
+} 

src/main/java/com/cs102/attendance/repository/AttendanceRepository.java

@@ -0,0 +1,16 @@
+package com.cs102.attendance.repository;
+
+import com.cs102.attendance.entity.AttendanceRecord;
+import com.cs102.attendance.entity.Session;
+import com.cs102.attendance.entity.Student;
+import com.cs102.attendance.enums.Status;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+import java.util.Optional;
+import java.util.UUID;
+
+@Repository
+public interface AttendanceRepository extends JpaRepository<AttendanceRecord, UUID> {
+    Optional<AttendanceRecord> findBySessionAndStudent(Session session, Student student);
+    long countBySessionAndStatus(Session session, Status status);
+} 

src/main/java/com/cs102/attendance/repository/FaceDataRepository.java

@@ -0,0 +1,10 @@
+package com.cs102.attendance.repository;
+
+import com.cs102.attendance.entity.FaceData;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+import java.util.UUID;
+
+@Repository
+public interface FaceDataRepository extends JpaRepository<FaceData, UUID> {
+} 

src/main/java/com/cs102/attendance/repository/SessionRepository.java

@@ -0,0 +1,13 @@
+package com.cs102.attendance.repository;
+
+import com.cs102.attendance.entity.Session;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+import java.time.LocalDate;
+import java.util.Optional;
+import java.util.UUID;
+
+@Repository
+public interface SessionRepository extends JpaRepository<Session, UUID> {
+    Optional<Session> findByNameAndDate(String name, LocalDate date);
+} 

src/main/java/com/cs102/attendance/repository/StudentRepository.java

@@ -0,0 +1,12 @@
+package com.cs102.attendance.repository;
+
+import com.cs102.attendance.entity.Student;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+import java.util.Optional;
+import java.util.UUID;
+
+@Repository
+public interface StudentRepository extends JpaRepository<Student, UUID> {
+    Optional<Student> findByCode(String code);
+} 

src/main/java/com/cs102/attendance/repository/TestConnectionRepository.java

@@ -1,13 +0,0 @@
-// package com.cs102.attendance.repository;
-
-// import com.cs102.attendance.entity.TestConnection;
-// import org.springframework.data.jpa.repository.JpaRepository;
-// import org.springframework.data.jpa.repository.Query;
-// import org.springframework.stereotype.Repository;
-
-// @Repository
-// public interface TestConnectionRepository extends JpaRepository<TestConnection, Long> {
-    
-//     @Query(value = "SELECT 1", nativeQuery = true)
-//     Integer testQuery();
-// } 

src/main/java/com/cs102/attendance/service/AttendanceService.java

@@ -0,0 +1,13 @@
+package com.cs102.attendance.service;
+
+import com.cs102.attendance.entity.AttendanceRecord;
+import com.cs102.attendance.entity.Session;
+import com.cs102.attendance.entity.Student;
+import com.cs102.attendance.enums.Status;
+
+import java.util.UUID;
+
+public interface AttendanceService {
+    AttendanceRecord markAttendance(UUID studentId, UUID sessionId, Status status);
+    AttendanceRecord markAttendance(Student student, Session session, Status status);
+} 

src/main/java/com/cs102/attendance/service/AutoMarker.java

@@ -0,0 +1,89 @@
+package com.cs102.attendance.service;
+
+import com.cs102.attendance.entity.AttendanceRecord;
+import com.cs102.attendance.entity.Session;
+import com.cs102.attendance.entity.Student;
+import com.cs102.attendance.enums.Method;
+import com.cs102.attendance.enums.Status;
+import com.cs102.attendance.repository.AttendanceRepository;
+import com.cs102.attendance.repository.StudentRepository;
+import com.cs102.attendance.repository.SessionRepository;
+import com.cs102.attendance.config.RecognitionProperties;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDateTime;
+import java.util.Optional;
+import java.util.UUID;
+
+@Component
+@Qualifier("auto")
+@Transactional
+public class AutoMarker implements AttendanceService {
+    
+    @Autowired
+    private AttendanceRepository attendanceRepository;
+    
+    @Autowired
+    private StudentRepository studentRepository;
+    
+    @Autowired
+    private SessionRepository sessionRepository;
+    
+    @Autowired
+    private RecognitionProperties recognitionProperties;
+    
+    @Override
+    public AttendanceRecord markAttendance(UUID studentId, UUID sessionId, Status status) {
+        Optional<Student> student = studentRepository.findById(studentId);
+        Optional<Session> session = sessionRepository.findById(sessionId);
+        
+        if (student.isPresent() && session.isPresent()) {
+            return markAttendance(student.get(), session.get(), status);
+        }
+        
+        throw new RuntimeException("Student or Session not found");
+    }
+    
+    @Override
+    public AttendanceRecord markAttendance(Student student, Session session, Status status) {
+        return markAttendance(student, session, status, recognitionProperties.getConfidence());
+    }
+    
+    public AttendanceRecord markAttendance(Student student, Session session, Status status, double confidence) {
+        // Check confidence threshold
+        if (confidence < recognitionProperties.getConfidence()) {
+            throw new RuntimeException("Recognition confidence too low: " + confidence);
+        }
+        
+        // Check if attendance record already exists and cooldown period
+        Optional<AttendanceRecord> existingRecord = attendanceRepository.findBySessionAndStudent(session, student);
+        
+        if (existingRecord.isPresent()) {
+            AttendanceRecord record = existingRecord.get();
+            LocalDateTime lastMarked = record.getMarkedAt();
+            LocalDateTime now = LocalDateTime.now();
+            
+            // Check cooldown period
+            long timeSinceLastMark = java.time.Duration.between(lastMarked, now).toMillis();
+            if (timeSinceLastMark < recognitionProperties.getCooldownMs()) {
+                throw new RuntimeException("Cooldown period not elapsed. Please wait " + 
+                    (recognitionProperties.getCooldownMs() - timeSinceLastMark) + "ms");
+            }
+            
+            // Update existing record
+            record.setStatus(status);
+            record.setMethod(Method.AUTO);
+            record.setConfidence(confidence);
+            record.setMarkedAt(now);
+            return attendanceRepository.save(record);
+        } else {
+            // Create new record
+            AttendanceRecord record = new AttendanceRecord(student, session, status, Method.AUTO);
+            record.setConfidence(confidence);
+            return attendanceRepository.save(record);
+        }
+    }
+} 

src/main/java/com/cs102/attendance/service/ManualMarker.java

@@ -0,0 +1,62 @@
+package com.cs102.attendance.service;
+
+import com.cs102.attendance.entity.AttendanceRecord;
+import com.cs102.attendance.entity.Session;
+import com.cs102.attendance.entity.Student;
+import com.cs102.attendance.enums.Method;
+import com.cs102.attendance.enums.Status;
+import com.cs102.attendance.repository.AttendanceRepository;
+import com.cs102.attendance.repository.StudentRepository;
+import com.cs102.attendance.repository.SessionRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Optional;
+import java.util.UUID;
+
+@Component
+@Qualifier("manual")
+@Transactional
+public class ManualMarker implements AttendanceService {
+    
+    @Autowired
+    private AttendanceRepository attendanceRepository;
+    
+    @Autowired
+    private StudentRepository studentRepository;
+    
+    @Autowired
+    private SessionRepository sessionRepository;
+    
+    @Override
+    public AttendanceRecord markAttendance(UUID studentId, UUID sessionId, Status status) {
+        Optional<Student> student = studentRepository.findById(studentId);
+        Optional<Session> session = sessionRepository.findById(sessionId);
+        
+        if (student.isPresent() && session.isPresent()) {
+            return markAttendance(student.get(), session.get(), status);
+        }
+        
+        throw new RuntimeException("Student or Session not found");
+    }
+    
+    @Override
+    public AttendanceRecord markAttendance(Student student, Session session, Status status) {
+        // Check if attendance record already exists
+        Optional<AttendanceRecord> existingRecord = attendanceRepository.findBySessionAndStudent(session, student);
+        
+        AttendanceRecord record;
+        if (existingRecord.isPresent()) {
+            record = existingRecord.get();
+            record.setStatus(status);
+            record.setMethod(Method.MANUAL);
+            record.setConfidence(null); // Manual marking doesn't have confidence
+        } else {
+            record = new AttendanceRecord(student, session, status, Method.MANUAL);
+        }
+        
+        return attendanceRepository.save(record);
+    }
+} 

src/main/java/com/cs102/attendance/service/SessionService.java

@@ -0,0 +1,90 @@
+package com.cs102.attendance.service;
+
+import com.cs102.attendance.entity.Session;
+import com.cs102.attendance.repository.SessionRepository;
+import com.cs102.attendance.repository.AttendanceRepository;
+import com.cs102.attendance.dto.SessionDto;
+import com.cs102.attendance.enums.Status;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDate;
+import java.time.LocalTime;
+import java.util.List;
+import java.util.UUID;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+@Service
+@Transactional
+public class SessionService {
+    
+    @Autowired
+    private SessionRepository sessionRepository;
+    
+    @Autowired
+    private AttendanceRepository attendanceRepository;
+    
+    public Session createSession(String name, LocalDate date, LocalTime startTime, LocalTime endTime) {
+        Session session = new Session(name, date, startTime, endTime);
+        return sessionRepository.save(session);
+    }
+    
+    public Session closeSession(UUID sessionId) {
+        Optional<Session> optionalSession = sessionRepository.findById(sessionId);
+        if (optionalSession.isPresent()) {
+            Session session = optionalSession.get();
+            // Session is considered closed when end time has passed
+            // Additional logic can be added here if needed
+            return session;
+        }
+        throw new RuntimeException("Session not found with id: " + sessionId);
+    }
+    
+    public List<Session> getTodaySessions() {
+        return getTodaySessions(LocalDate.now());
+    }
+    
+    public List<Session> getTodaySessions(LocalDate date) {
+        return sessionRepository.findAll().stream()
+                .filter(session -> session.getDate().equals(date))
+                .collect(Collectors.toList());
+    }
+    
+    public SessionDto getSessionDto(Session session) {
+        SessionDto dto = new SessionDto(
+            session.getId(),
+            session.getName(),
+            session.getDate(),
+            session.getStartTime(),
+            session.getEndTime()
+        );
+        
+        // Calculate attendance counts
+        dto.setPresentCount(attendanceRepository.countBySessionAndStatus(session, Status.PRESENT));
+        dto.setAbsentCount(attendanceRepository.countBySessionAndStatus(session, Status.ABSENT));
+        dto.setLateCount(attendanceRepository.countBySessionAndStatus(session, Status.LATE));
+        dto.setTotalStudents(dto.getPresentCount() + dto.getAbsentCount() + dto.getLateCount());
+        
+        return dto;
+    }
+    
+    public List<SessionDto> getTodaySessionDtos() {
+        return getTodaySessions().stream()
+                .map(this::getSessionDto)
+                .collect(Collectors.toList());
+    }
+    
+    public List<Session> getAllSessions() {
+        return sessionRepository.findAll();
+    }
+    
+    public Optional<Session> getSessionById(UUID id) {
+        return sessionRepository.findById(id);
+    }
+    
+    public void deleteSession(UUID id) {
+        sessionRepository.deleteById(id);
+    }
+} 

src/main/java/com/cs102/attendance/service/StudentService.java

@@ -0,0 +1,83 @@
+package com.cs102.attendance.service;
+
+import com.cs102.attendance.entity.Student;
+import com.cs102.attendance.entity.FaceData;
+import com.cs102.attendance.repository.StudentRepository;
+import com.cs102.attendance.repository.FaceDataRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+import java.util.UUID;
+import java.util.Optional;
+
+@Service
+@Transactional
+public class StudentService {
+    
+    @Autowired
+    private StudentRepository studentRepository;
+    
+    @Autowired
+    private FaceDataRepository faceDataRepository;
+    
+    public Student enrol(String code, String name, String className, String studentGroup, String email, String phone) {
+        Student student = new Student();
+        student.setCode(code);
+        student.setName(name);
+        student.setClassName(className);
+        student.setStudentGroup(studentGroup);
+        student.setEmail(email);
+        student.setPhone(phone);
+        
+        return studentRepository.save(student);
+    }
+    
+    public Student updateProfile(UUID studentId, String name, String className, String studentGroup, String email, String phone) {
+        Optional<Student> optionalStudent = studentRepository.findById(studentId);
+        if (optionalStudent.isPresent()) {
+            Student student = optionalStudent.get();
+            if (name != null) student.setName(name);
+            if (className != null) student.setClassName(className);
+            if (studentGroup != null) student.setStudentGroup(studentGroup);
+            if (email != null) student.setEmail(email);
+            if (phone != null) student.setPhone(phone);
+            
+            return studentRepository.save(student);
+        }
+        throw new RuntimeException("Student not found with id: " + studentId);
+    }
+    
+    public FaceData uploadFaceImage(UUID studentId, String imageUrl) {
+        Optional<Student> optionalStudent = studentRepository.findById(studentId);
+        if (optionalStudent.isPresent()) {
+            Student student = optionalStudent.get();
+            FaceData faceData = new FaceData(student, imageUrl);
+            return faceDataRepository.save(faceData);
+        }
+        throw new RuntimeException("Student not found with id: " + studentId);
+    }
+    
+    public FaceData uploadFaceImage(UUID studentId, byte[] imageData) {
+        Optional<Student> optionalStudent = studentRepository.findById(studentId);
+        if (optionalStudent.isPresent()) {
+            Student student = optionalStudent.get();
+            FaceData faceData = new FaceData(student, imageData);
+            return faceDataRepository.save(faceData);
+        }
+        throw new RuntimeException("Student not found with id: " + studentId);
+    }
+    
+    public List<Student> getAllStudents() {
+        return studentRepository.findAll();
+    }
+    
+    public Optional<Student> getStudentById(UUID id) {
+        return studentRepository.findById(id);
+    }
+    
+    public void deleteStudent(UUID id) {
+        studentRepository.deleteById(id);
+    }
+} 

src/main/resources/application.yml

@@ -4,10 +4,32 @@ spring:
     username: ${SPRING_DATASOURCE_USERNAME}
     password: ${SPRING_DATASOURCE_PASSWORD}
     driver-class-name: org.postgresql.Driver
+    lifecycle:
+      timeout-per-shutdown-phase: 30000
     hikari:
-      maximum-pool-size: 10
-      connection-timeout: 30000
-      idle-timeout: 600000
+      maximum-pool-size: 5
+      minimum-idle: 1
+      idle-timeout: 300000
+      max-lifetime: 1800000
+      connection-timeout: 20000
+      
+      # Leak detection and validation
+      leak-detection-threshold: 15000
+      validation-timeout: 5000
+      
+      # Connection testing
+      connection-test-query: SELECT 1
+      
+      # Pool name for monitoring
+      pool-name: AttendanceHikariCP
+      
+      # Additional connection properties for PostgreSQL/Supabase
+      data-source-properties:
+        socketTimeout: 30
+        loginTimeout: 10
+        tcpKeepAlive: true
+        ApplicationName: cs102-attendance-app
+
   jpa:
     hibernate:
       ddl-auto: update
@@ -15,13 +37,42 @@ spring:
     properties:
       hibernate:
         dialect: org.hibernate.dialect.PostgreSQLDialect
+        connection.handling_mode: delayed_acquisition_and_release_after_transaction
+        query.timeout: 30000
+
+  server:
+    shutdown: graceful
+  
+  # Enhanced logging for connection monitoring
+  logging:
+    level:
+      org.hibernate.SQL: DEBUG
+      org.hibernate.type.descriptor.sql.BasicBinder: TRACE
+      com.zaxxer.hikari: DEBUG
+      com.zaxxer.hikari.HikariConfig: DEBUG
+      com.zaxxer.hikari.HikariDataSource: DEBUG
+      com.zaxxer.hikari.pool: DEBUG
 
-# Expose metrics for demo proof
-management.endpoints.web.exposure.include: health,info,metrics,prometheus
+# Expose metrics for connection pool monitoring
+management:
+  endpoints:
+    web:
+      exposure:
+        include: health,info,metrics,prometheus,hikaricp
+  endpoint:
+    health:
+      show-details: always
+  metrics:
+    export:
+      prometheus:
+        enabled: true
+  jmx:
+    exposure:
+      include: "*"
 
 # Externalised CV thresholds
 recognition:
-  confidence: 0.6
+  confidence: 0.70
   cooldownMs: 10000
 face-service:
-  url: http://localhost:5001   # backend face service url
+  url: http://localhost:5001   # to insert backend face service url

src/test/java/com/cs102/attendance/Cs102AttendanceProjectApplicationTests.java

@@ -1,50 +1,50 @@
-// package com.cs102.attendance;
+package com.cs102.attendance;
 
-// import com.cs102.attendance.repository.TestConnectionRepository;
-// import org.junit.jupiter.api.Test;
-// import org.springframework.beans.factory.annotation.Autowired;
-// import org.springframework.boot.test.context.SpringBootTest;
+import com.cs102.attendance.repository.StudentRepository;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
 
-// import javax.sql.DataSource;
-// import java.sql.Connection;
-// import java.sql.SQLException;
+import javax.sql.DataSource;
+import java.sql.Connection;
+import java.sql.SQLException;
 
-// import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.*;
 
-// @SpringBootTest
-// class Cs102AttendanceProjectApplicationTests {
+@SpringBootTest
+class Cs102AttendanceProjectApplicationTests {
 
-// 	@Autowired
-// 	private DataSource dataSource;
+	@Autowired
+	private DataSource dataSource;
 
-// 	@Autowired
-// 	private TestConnectionRepository testConnectionRepository;
+	@Autowired
+	private StudentRepository studentRepository;
 
-// 	@Test
-// 	void contextLoads() {
-// 	}
+	@Test
+	void contextLoads() {
+	}
 
-// 	@Test
-// 	void testDatabaseConnection() throws SQLException {
-// 		// Test that we can get a connection from the DataSource
-// 		try (Connection connection = dataSource.getConnection()) {
-// 			assertNotNull(connection, "Database connection should not be null");
-// 			assertTrue(connection.isValid(5), "Database connection should be valid");
+	@Test
+	void testDatabaseConnection() throws SQLException {
+		// Test that we can get a connection from the DataSource
+		try (Connection connection = dataSource.getConnection()) {
+			assertNotNull(connection, "Database connection should not be null");
+			assertTrue(connection.isValid(5), "Database connection should be valid");
 			
-// 			// Print connection details for verification
-// 			System.out.println("Database URL: " + connection.getMetaData().getURL());
-// 			System.out.println("Database Driver: " + connection.getMetaData().getDriverName());
-// 			System.out.println("Database Version: " + connection.getMetaData().getDatabaseProductVersion());
-// 		}
-// 	}
-
-// 	@Test
-// 	void testRepositoryConnection() {
-// 		// Test that the repository can execute queries
-// 		assertDoesNotThrow(() -> {
-// 			Integer result = testConnectionRepository.testQuery();
-// 			assertEquals(1, result, "Test query should return 1");
-// 		}, "Repository test query should not throw an exception");
-// 	}
-
-// }
+			// Print connection details for verification
+			System.out.println("Database URL: " + connection.getMetaData().getURL());
+			System.out.println("Database Driver: " + connection.getMetaData().getDriverName());
+			System.out.println("Database Version: " + connection.getMetaData().getDatabaseProductVersion());
+		}
+	}
+
+	@Test
+	void testRepositoryConnection() {
+		// Test that the repository can execute queries
+		assertDoesNotThrow(() -> {
+			long count = studentRepository.count();
+			assertTrue(count >= 0, "Student count should be non-negative");
+		}, "Repository test query should not throw an exception");
+	}
+
+}

src/test/java/com/cs102/attendance/DatabaseIntegrationTest.java

@@ -0,0 +1,108 @@
+package com.cs102.attendance;
+
+import com.cs102.attendance.entity.*;
+import com.cs102.attendance.enums.Method;
+import com.cs102.attendance.enums.Status;
+import com.cs102.attendance.repository.*;
+import com.cs102.attendance.service.*;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.annotation.DirtiesContext;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDate;
+import java.time.LocalTime;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@SpringBootTest
+@DirtiesContext(classMode = DirtiesContext.ClassMode.AFTER_EACH_TEST_METHOD)
+public class DatabaseIntegrationTest {
+
+    @Autowired private StudentRepository studentRepository;
+    @Autowired private SessionRepository sessionRepository;
+    @Autowired private AttendanceRepository attendanceRepository;
+    @Autowired private FaceDataRepository faceDataRepository;
+    
+    @Autowired private StudentService studentService;
+    @Autowired private SessionService sessionService;
+    
+    @Test
+    @Transactional
+    public void testCompleteWorkflow() {
+        System.out.println("Testing complete database workflow...");
+        
+        // 1. Test Student Creation
+        System.out.println("1. Creating student...");
+        Student student = studentService.enrol("CS001", "John Doe", "CS102", "Group A", "[email protected]", "123-456-7890");
+        assertNotNull(student.getId());
+        assertEquals("CS001", student.getCode());
+        System.out.println("Student created: " + student.getName());
+        
+        // 2. Test Session Creation
+        System.out.println("2. Creating session...");
+        Session session = sessionService.createSession("Morning Lecture", LocalDate.now(), LocalTime.of(9, 0), LocalTime.of(11, 0));
+        assertNotNull(session.getId());
+        assertEquals("Morning Lecture", session.getName());
+        System.out.println("Session created: " + session.getName());
+        
+        // 3. Test Face Data Upload
+        System.out.println("3. Uploading face data...");
+        FaceData faceData = studentService.uploadFaceImage(student.getId(), "http://example.com/face.jpg");
+        assertNotNull(faceData.getId());
+        assertEquals(student.getId(), faceData.getStudent().getId());
+        System.out.println("Face data uploaded");
+        
+        // 4. Test Attendance Record
+        System.out.println("4. Creating attendance record...");
+        AttendanceRecord record = new AttendanceRecord(student, session, Status.PRESENT, Method.MANUAL);
+        record = attendanceRepository.save(record);
+        assertNotNull(record.getId());
+        assertEquals(Status.PRESENT, record.getStatus());
+        System.out.println("Attendance record created");
+        
+        // 5. Test Repository Queries
+        System.out.println("5. Testing repository queries...");
+        var foundRecord = attendanceRepository.findBySessionAndStudent(session, student);
+        assertTrue(foundRecord.isPresent());
+        
+        long presentCount = attendanceRepository.countBySessionAndStatus(session, Status.PRESENT);
+        assertEquals(1, presentCount);
+        System.out.println("Repository queries working");
+        
+        // 6. Test Relationships
+        System.out.println("6. Testing entity relationships...");
+        Student savedStudent = studentRepository.findById(student.getId()).orElse(null);
+        assertNotNull(savedStudent);
+        assertEquals(1, savedStudent.getFaceData().size());
+        assertEquals(1, savedStudent.getAttendanceRecords().size());
+        System.out.println("Entity relationships working");
+        
+        System.out.println("All database tests passed.");
+    }
+    
+    @Test
+    public void testRepositoryBasicOperations() {
+        System.out.println("Testing basic repository operations...");
+        
+        // Test counts
+        long studentCount = studentRepository.count();
+        long sessionCount = sessionRepository.count();
+        long attendanceCount = attendanceRepository.count();
+        long faceDataCount = faceDataRepository.count();
+        
+        System.out.println("Current counts:");
+        System.out.println("   Students: " + studentCount);
+        System.out.println("   Sessions: " + sessionCount);
+        System.out.println("   Attendance Records: " + attendanceCount);
+        System.out.println("   Face Data: " + faceDataCount);
+        
+        assertTrue(studentCount >= 0);
+        assertTrue(sessionCount >= 0);
+        assertTrue(attendanceCount >= 0);
+        assertTrue(faceDataCount >= 0);
+        
+        System.out.println("Repository basic operations working");
+    }
+} 

src/test/java/com/cs102/attendance/controller/TestControllerTest.java

@@ -1,69 +1,77 @@
-// package com.cs102.attendance.controller;
+package com.cs102.attendance.controller;
 
-// import com.cs102.attendance.entity.TestConnection;
-// import com.cs102.attendance.repository.TestConnectionRepository;
-// import org.junit.jupiter.api.Test;
-// import org.springframework.beans.factory.annotation.Autowired;
-// import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
-// import org.springframework.test.context.bean.override.mockito.MockitoBean;
-// import org.springframework.http.MediaType;
-// import org.springframework.test.web.servlet.MockMvc;
+import com.cs102.attendance.entity.Student;
+import com.cs102.attendance.repository.StudentRepository;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
+import org.springframework.test.context.bean.override.mockito.MockitoBean;
+import org.springframework.http.MediaType;
+import org.springframework.test.web.servlet.MockMvc;
 
-// import static org.mockito.ArgumentMatchers.any;
-// import static org.mockito.Mockito.when;
-// import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
-// import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
+import java.util.UUID;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.when;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
 
-// @WebMvcTest(TestController.class)
-// public class TestControllerTest {
+@WebMvcTest(TestController.class)
+public class TestControllerTest {
 
-//     @Autowired
-//     private MockMvc mockMvc;
+    @Autowired
+    private MockMvc mockMvc;
 
-//     @MockitoBean
-//     private TestConnectionRepository testConnectionRepository;
+    @MockitoBean
+    private StudentRepository studentRepository;
 
-//     @Test
-//     public void testInsertTestDataWithDefaultMessage() throws Exception {
-//         // Given
-//         TestConnection mockSavedEntity = new TestConnection("Test message");
-//         mockSavedEntity.setId(1L);
-//         when(testConnectionRepository.save(any(TestConnection.class))).thenReturn(mockSavedEntity);
+    @Test
+    public void testInsertTestDataWithValidData() throws Exception {
+        // Given
+        Student mockSavedStudent = new Student("TEST001", "Test Student");
+        mockSavedStudent.setId(UUID.randomUUID());
+        when(studentRepository.save(any(Student.class))).thenReturn(mockSavedStudent);
 
-//         // When & Then
-//         mockMvc.perform(post("/api/test/insert-test-data")
-//                 .contentType(MediaType.APPLICATION_JSON))
-//                 .andExpect(status().isOk())
-//                 .andExpect(jsonPath("$.id").value(1L))
-//                 .andExpect(jsonPath("$.message").value("Test message"));
-//     }
+        // When & Then
+        mockMvc.perform(post("/api/test/insert-test-data")
+                .param("code", "TEST001")
+                .param("name", "Test Student")
+                .contentType(MediaType.APPLICATION_JSON))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.code").value("TEST001"))
+                .andExpect(jsonPath("$.name").value("Test Student"));
+    }
 
-//     @Test
-//     public void testInsertTestDataWithCustomMessage() throws Exception {
-//         // Given
-//         String customMessage = "Custom test message";
-//         TestConnection mockSavedEntity = new TestConnection(customMessage);
-//         mockSavedEntity.setId(2L);
-//         when(testConnectionRepository.save(any(TestConnection.class))).thenReturn(mockSavedEntity);
+    @Test
+    public void testInsertTestDataWithEmail() throws Exception {
+        // Given
+        Student mockSavedStudent = new Student("TEST002", "Test Student 2");
+        mockSavedStudent.setEmail("[email protected]");
+        mockSavedStudent.setId(UUID.randomUUID());
+        when(studentRepository.save(any(Student.class))).thenReturn(mockSavedStudent);
 
-//         // When & Then
-//         mockMvc.perform(post("/api/test/insert-test-data")
-//                 .param("message", customMessage)
-//                 .contentType(MediaType.APPLICATION_JSON))
-//                 .andExpect(status().isOk())
-//                 .andExpect(jsonPath("$.id").value(2L))
-//                 .andExpect(jsonPath("$.message").value(customMessage));
-//     }
+        // When & Then
+        mockMvc.perform(post("/api/test/insert-test-data")
+                .param("code", "TEST002")
+                .param("name", "Test Student 2")
+                .param("email", "test@example.com")
+                .contentType(MediaType.APPLICATION_JSON))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.code").value("TEST002"))
+                .andExpect(jsonPath("$.name").value("Test Student 2"))
+                .andExpect(jsonPath("$.email").value("[email protected]"));
+    }
 
-//     @Test
-//     public void testInsertTestDataWithException() throws Exception {
-//         // Given
-//         when(testConnectionRepository.save(any(TestConnection.class)))
-//                 .thenThrow(new RuntimeException("Database error"));
+    @Test
+    public void testInsertTestDataWithException() throws Exception {
+        // Given
+        when(studentRepository.save(any(Student.class)))
+                .thenThrow(new RuntimeException("Database error"));
 
-//         // When & Then
-//         mockMvc.perform(post("/api/test/insert-test-data")
-//                 .contentType(MediaType.APPLICATION_JSON))
-//                 .andExpect(status().isInternalServerError());
-//     }
-// } 
+        // When & Then
+        mockMvc.perform(post("/api/test/insert-test-data")
+                .param("code", "TEST003")
+                .param("name", "Test Student 3")
+                .contentType(MediaType.APPLICATION_JSON))
+                .andExpect(status().isInternalServerError());
+    }
+} 

video-object-detection/facedetection.html

@@ -0,0 +1,73 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Transformers.js | Real-time object detection</title>
+    <link rel="stylesheet" href="/style.css" />
+  </head>
+
+  <body>
+    <h1>
+      Real-time object detection w/ gelan-c_all
+    </h1>
+    <h4>
+      Runs locally in your browser, powered by
+      <a href="http://github.com/huggingface/transformers.js" target="_blank"
+        >🤗 Transformers.js</a
+      >
+    </h4>
+    <div id="container">
+      <video id="video" autoplay muted playsinline></video>
+      <canvas id="canvas" width="360" height="240"></canvas>
+      <div id="overlay"></div>
+    </div>
+    <div id="controls">
+      <div>
+        <label>Image size</label>
+        (<label id="size-value">96</label>)
+        <br />
+        <input
+          id="size"
+          type="range"
+          min="64"
+          max="256"
+          step="32"
+          value="96"
+          disabled
+        />
+      </div>
+      <div>
+        <label>Threshold</label>
+        (<label id="threshold-value">0.85</label>)
+        <br />
+        <input
+          id="threshold"
+          type="range"
+          min="0.01"
+          max="1"
+          step="0.01"
+          value="0.85"
+          disabled
+        />
+      </div>
+      <div>
+        <label>Scale</label>
+        (<label id="scale-value">0.5</label>)
+        <br />
+        <input
+          id="scale"
+          type="range"
+          min="0.01"
+          max="1"
+          step="0.01"
+          value="0.5"
+          disabled
+        />
+      </div>
+    </div>
+    <label id="status"></label>
+
+    <script type="module" src="/src/facedetection.js"></script>
+  </body>
+</html>

video-object-detection/index.html

@@ -1,73 +1,268 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Transformers.js | Real-time object detection</title>
-    <link rel="stylesheet" href="/style.css" />
-  </head>
-
-  <body>
-    <h1>
-      Real-time object detection w/ gelan-c_all
-    </h1>
-    <h4>
-      Runs locally in your browser, powered by
-      <a href="http://github.com/huggingface/transformers.js" target="_blank"
-        >🤗 Transformers.js</a
-      >
-    </h4>
-    <div id="container">
-      <video id="video" autoplay muted playsinline></video>
-      <canvas id="canvas" width="360" height="240"></canvas>
-      <div id="overlay"></div>
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Attendance Management System - Login</title>
+    <link rel="stylesheet" href="styles2.css">
+    <style>
+        /* Login-specific styles */
+        .login-container {
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            min-height: 100vh;
+            background: #f8fafc;
+        }
+
+        .login-card {
+            background: white;
+            padding: 3rem;
+            border-radius: 16px;
+            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.05);
+            width: 100%;
+            max-width: 400px;
+        }
+
+        .login-title {
+            text-align: center;
+            font-size: 1.5rem;
+            font-weight: 600;
+            color: #1e293b;
+            margin-bottom: 2rem;
+        }
+
+        .login-tabs {
+            display: flex;
+            background: #f1f5f9;
+            border-radius: 8px;
+            padding: 0.25rem;
+            margin-bottom: 2rem;
+        }
+
+        .tab {
+            flex: 1;
+            padding: 0.75rem;
+            text-align: center;
+            border: none;
+            background: transparent;
+            border-radius: 6px;
+            cursor: pointer;
+            font-weight: 500;
+            color: #64748b;
+            transition: all 0.2s;
+        }
+
+        .tab.active {
+            background: white;
+            color: #1e293b;
+            box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
+        }
+    </style>
+</head>
+<body>
+    <div class="login-container">
+        <div class="login-card">
+            <h1 class="login-title">Attendance Management System</h1>
+            
+            <div class="login-tabs">
+                <button class="tab active" onclick="switchTab('student')">Student</button>
+                <button class="tab" onclick="switchTab('professor')">Professor/TA</button>
+            </div>
+
+            <!-- Enhanced login form -->
+            <form id="loginForm" style="display: block;">
+                <div class="form-group">
+                    <label class="form-label" for="loginEmail">Email</label>
+                    <input type="email" id="loginEmail" class="form-input" required>
+                </div>
+                <div class="form-group">
+                    <label class="form-label" for="loginPassword">Password</label>
+                    <input type="password" id="loginPassword" class="form-input" required>
+                </div>
+                <button type="submit" class="btn btn-primary" style="width: 100%;">Login</button>
+                
+                <!-- Added register hyperlink underneath login button -->
+                <div style="text-align: center; margin-top: 1rem;">
+                    <span style="color: #64748b; font-size: 0.875rem;">Don't have an account? </span>
+                    <a href="#" onclick="showRegisterForm()" style="color: #0ea5e9; text-decoration: none; font-weight: 500; font-size: 0.875rem;">Register here</a>
+                </div>
+            </form>
+
+            <!-- Enhanced registration form with role selection and removed toggle -->
+            <form id="registerForm" style="display: none;">
+                <div class="form-group">
+                    <label class="form-label" for="registerName">Full Name</label>
+                    <input type="text" id="registerName" class="form-input" required>
+                </div>
+                <div class="form-group">
+                    <label class="form-label" for="registerEmail">Email</label>
+                    <input type="email" id="registerEmail" class="form-input" required>
+                </div>
+                <div class="form-group">
+                    <label class="form-label" for="registerRole">Role</label>
+                    <select id="registerRole" class="form-input" required>
+                        <option value="">Select your role</option>
+                        <option value="student">Student</option>
+                        <option value="professor">Professor/TA</option>
+                    </select>
+                </div>
+                <div class="form-group">
+                    <label class="form-label" for="registerPassword">Password</label>
+                    <input type="password" id="registerPassword" class="form-input" required>
+                </div>
+                <div class="form-group">
+                    <label class="form-label" for="confirmPassword">Confirm Password</label>
+                    <input type="password" id="confirmPassword" class="form-input" required>
+                </div>
+                <div id="passwordError" style="color: #ef4444; font-size: 0.875rem; margin-bottom: 1rem; display: none;">
+                    Passwords do not match
+                </div>
+                <button type="submit" class="btn btn-primary" style="width: 100%;">Register & Setup Face</button>
+                
+                <!-- Added back to login link -->
+                <div style="text-align: center; margin-top: 1rem;">
+                    <span style="color: #64748b; font-size: 0.875rem;">Already have an account? </span>
+                    <a href="#" onclick="showLoginForm()" style="color: #0ea5e9; text-decoration: none; font-weight: 500; font-size: 0.875rem;">Login here</a>
+                </div>
+            </form>
+        </div>
     </div>
-    <div id="controls">
-      <div>
-        <label>Image size</label>
-        (<label id="size-value">128</label>)
-        <br />
-        <input
-          id="size"
-          type="range"
-          min="64"
-          max="256"
-          step="32"
-          value="128"
-          disabled
-        />
-      </div>
-      <div>
-        <label>Threshold</label>
-        (<label id="threshold-value">0.85</label>)
-        <br />
-        <input
-          id="threshold"
-          type="range"
-          min="0.01"
-          max="1"
-          step="0.01"
-          value="0.85"
-          disabled
-        />
-      </div>
-      <div>
-        <label>Scale</label>
-        (<label id="scale-value">0.5</label>)
-        <br />
-        <input
-          id="scale"
-          type="range"
-          min="0.01"
-          max="1"
-          step="0.01"
-          value="0.5"
-          disabled
-        />
-      </div>
+
+    <!-- Enhanced Face Registration Modal with live camera -->
+    <div id="faceRegisterModal" class="modal">
+        <div class="modal-content" style="max-width: 500px;">
+            <div class="modal-header">
+                <h3 class="modal-title">Register Your Face</h3>
+                <button class="close-btn" onclick="closeFaceRegister()">&times;</button>
+            </div>
+            <div class="modal-body">
+                <p style="text-align: center; color: #64748b; margin-bottom: 1rem;">
+                    Position your face within the frame and click capture to complete registration
+                </p>
+                <div class="camera-container" style="position: relative; background: #000; border-radius: 8px; overflow: hidden; margin-bottom: 1rem;">
+                    <video id="faceVideo" style="width: 100%; height: 300px; object-fit: cover;" autoplay muted></video>
+                    <canvas id="faceCanvas" style="display: none;"></canvas>
+                    <div class="scan-overlay" style="position: absolute; top: 50%; left: 50%; transform: translate(-50%, -50%); width: 200px; height: 200px; border: 2px solid #22d3ee; border-radius: 50%; opacity: 0.8;"></div>
+                </div>
+                <div id="captureResult" style="text-align: center; margin-bottom: 1rem; display: none;">
+                    <div style="color: #22c55e; font-weight: 500;">✓ Face captured successfully!</div>
+                </div>
+                <div style="display: flex; gap: 1rem;">
+                    <button id="captureBtn" class="btn btn-primary" style="flex: 1;" onclick="captureFace()">Capture Face</button>
+                    <button id="completeBtn" class="btn btn-success" style="flex: 1; display: none;" onclick="completeRegistration()">Complete Registration</button>
+                    <button class="btn btn-secondary" style="flex: 1;" onclick="closeFaceRegister()">Cancel</button>
+                </div>
+            </div>
+        </div>
     </div>
-    <label id="status"></label>
 
-    <script type="module" src="/main.js"></script>
-  </body>
+    <script>
+        let currentUser = 'student';
+        let faceStream = null;
+        let faceCaptured = false;
+
+        function switchTab(userType) {
+            currentUser = userType;
+            const tabs = document.querySelectorAll('.tab');
+            tabs.forEach(tab => tab.classList.remove('active'));
+            event.target.classList.add('active');
+        }
+
+        function showRegisterForm() {
+            document.getElementById('loginForm').style.display = 'none';
+            document.getElementById('registerForm').style.display = 'block';
+            document.querySelector('.login-tabs').style.display = 'none';
+        }
+
+        function showLoginForm() {
+            document.getElementById('registerForm').style.display = 'none';
+            document.getElementById('loginForm').style.display = 'block';
+            document.querySelector('.login-tabs').style.display = 'flex';
+        }
+
+        async function showFaceRegister() {
+            document.getElementById('faceRegisterModal').classList.add('active');
+            
+            try {
+                faceStream = await navigator.mediaDevices.getUserMedia({ 
+                    video: { 
+                        width: 640, 
+                        height: 480,
+                        facingMode: 'user'
+                    } 
+                });
+                document.getElementById('faceVideo').srcObject = faceStream;
+            } catch (error) {
+                console.error('Error accessing camera:', error);
+                alert('Unable to access camera. Please ensure camera permissions are granted.');
+            }
+        }
+
+        function closeFaceRegister() {
+            document.getElementById('faceRegisterModal').classList.remove('active');
+            if (faceStream) {
+                faceStream.getTracks().forEach(track => track.stop());
+                faceStream = null;
+            }
+            // Reset capture state
+            faceCaptured = false;
+            document.getElementById('captureResult').style.display = 'none';
+            document.getElementById('captureBtn').style.display = 'block';
+            document.getElementById('completeBtn').style.display = 'none';
+        }
+
+        function captureFace() {
+            const video = document.getElementById('faceVideo');
+            const canvas = document.getElementById('faceCanvas');
+            const ctx = canvas.getContext('2d');
+
+            canvas.width = video.videoWidth;
+            canvas.height = video.videoHeight;
+            ctx.drawImage(video, 0, 0);
+
+            // Simulate face detection processing
+            setTimeout(() => {
+                faceCaptured = true;
+                document.getElementById('captureResult').style.display = 'block';
+                document.getElementById('captureBtn').style.display = 'none';
+                document.getElementById('completeBtn').style.display = 'block';
+            }, 1000);
+        }
+
+        function completeRegistration() {
+            alert('Registration completed successfully! You can now login.');
+            closeFaceRegister();
+            showLoginForm();
+        }
+
+        document.getElementById('loginForm').addEventListener('submit', function(e) {
+            e.preventDefault();
+            
+            if (currentUser === 'student') {
+                window.location.href = 'student.html';
+            } else {
+                window.location.href = 'professor.html';
+            }
+        });
+
+        document.getElementById('registerForm').addEventListener('submit', function(e) {
+            e.preventDefault();
+            
+            const password = document.getElementById('registerPassword').value;
+            const confirmPassword = document.getElementById('confirmPassword').value;
+            const errorDiv = document.getElementById('passwordError');
+
+            if (password !== confirmPassword) {
+                errorDiv.style.display = 'block';
+                return;
+            }
+
+            errorDiv.style.display = 'none';
+            const selectedRole = document.getElementById('registerRole').value;
+            sessionStorage.setItem('registeringRole', selectedRole);
+            showFaceRegister();
+        });
+    </script>
+</body>
 </html>

video-object-detection/professor.html

@@ -0,0 +1,285 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Professor Dashboard - Attendance System</title>
+    <link rel="stylesheet" href="styles2.css">
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <div class="header-left">
+                <div class="logo-icon">👨‍🏫</div>
+                <h1 class="header-title">Professor Dashboard</h1>
+            </div>
+            <div class="header-right">
+                <span class="welcome-text">Welcome, Dr. Smith</span>
+                <button class="logout-btn" onclick="logout()">Logout</button>
+            </div>
+        </div>
+
+        <div class="welcome-section">
+            <h2 class="welcome-title">Welcome back!</h2>
+            <p class="welcome-subtitle">Manage your classes and track student attendance</p>
+        </div>
+
+        <div class="stats-grid">
+            <div class="stat-card">
+                <div class="stat-icon blue">📊</div>
+                <div class="stat-content">
+                    <h3>Average Attendance</h3>
+                    <div class="stat-number">78%</div>
+                </div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-icon orange">👥</div>
+                <div class="stat-content">
+                    <h3>Total Students</h3>
+                    <div class="stat-number">125</div>
+                </div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-icon yellow">📅</div>
+                <div class="stat-content">
+                    <h3>Active Classes</h3>
+                    <div class="stat-number">3</div>
+                </div>
+            </div>
+        </div>
+
+        <div class="section-card">
+            <div class="section-header">
+                <h3 class="section-title">Class Management</h3>
+                <p class="section-subtitle">Create and manage your class sessions</p>
+            </div>
+            <div class="section-content">
+                <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 1rem;">
+                    <button class="btn btn-primary" onclick="openCreateClass()">Create Class/Session</button>
+                    <button class="btn btn-secondary" onclick="openManualAttendance()">Manual Attendance</button>
+                    <button class="btn btn-secondary" onclick="openGenerateReport()">Generate Report</button>
+                    <button class="btn btn-secondary" onclick="openStudentManagement()">Manage Students</button>
+                    <button class="btn btn-secondary" onclick="openAttendanceCheck()">Check Total Attendance</button>
+                    <button class="btn btn-danger" onclick="closeActiveSession()">Close Active Session</button>
+                </div>
+            </div>
+        </div>
+
+        <div class="section-card">
+            <div class="section-header">
+                <h3 class="section-title">Active Sessions</h3>
+            </div>
+            <div class="section-content" id="activeSessions">
+                <p class="welcome-subtitle">No active sessions at the moment</p>
+            </div>
+        </div>
+    </div>
+
+    <!-- All Professor Modals -->
+    <!-- Create Class Modal -->
+    <div id="createClassModal" class="modal">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h3 class="modal-title">Create Class/Session</h3>
+                <button class="close-btn" onclick="closeCreateClass()">&times;</button>
+            </div>
+            <form id="createClassForm">
+                <div class="form-group">
+                    <label class="form-label">Class Name</label>
+                    <input type="text" class="form-input" placeholder="e.g., CS101 - Introduction to Programming" required>
+                </div>
+                <div class="form-group">
+                    <label class="form-label">Session Date</label>
+                    <input type="date" class="form-input" required>
+                </div>
+                <div class="form-group">
+                    <label class="form-label">Start Time</label>
+                    <input type="time" class="form-input" required>
+                </div>
+                <div class="form-group">
+                    <label class="form-label">Duration (minutes)</label>
+                    <input type="number" class="form-input" placeholder="90" required>
+                </div>
+                <div style="display: flex; gap: 1rem;">
+                    <button type="submit" class="btn btn-primary" style="flex: 1;">Create Session</button>
+                    <button type="button" class="btn btn-secondary" style="flex: 1;" onclick="closeCreateClass()">Cancel</button>
+                </div>
+            </form>
+        </div>
+    </div>
+
+    <!-- Manual Attendance Modal -->
+    <div id="manualAttendanceModal" class="modal">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h3 class="modal-title">Manual Attendance Marking</h3>
+                <button class="close-btn" onclick="closeManualAttendance()">&times;</button>
+            </div>
+            <div class="form-group">
+                <label class="form-label">Select Class</label>
+                <select class="form-select">
+                    <option>CS101 - Introduction to Programming</option>
+                    <option>MATH201 - Calculus II</option>
+                    <option>PHY301 - Quantum Physics</option>
+                </select>
+            </div>
+            <div class="student-list">
+                <div class="student-item">
+                    <span>John Doe ([email protected])</span>
+                    <div class="attendance-controls">
+                        <button class="btn btn-success btn-sm">Present</button>
+                        <button class="btn btn-danger btn-sm">Absent</button>
+                    </div>
+                </div>
+                <div class="student-item">
+                    <span>Jane Smith ([email protected])</span>
+                    <div class="attendance-controls">
+                        <button class="btn btn-success btn-sm">Present</button>
+                        <button class="btn btn-danger btn-sm">Absent</button>
+                    </div>
+                </div>
+                <div class="student-item">
+                    <span>Mike Johnson ([email protected])</span>
+                    <div class="attendance-controls">
+                        <button class="btn btn-success btn-sm">Present</button>
+                        <button class="btn btn-danger btn-sm">Absent</button>
+                    </div>
+                </div>
+            </div>
+            <div style="display: flex; gap: 1rem; margin-top: 1rem;">
+                <button class="btn btn-primary" style="flex: 1;">Save Attendance</button>
+                <button class="btn btn-secondary" style="flex: 1;" onclick="closeManualAttendance()">Cancel</button>
+            </div>
+        </div>
+    </div>
+
+    <!-- Generate Report Modal -->
+    <div id="generateReportModal" class="modal">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h3 class="modal-title">Generate Attendance Report</h3>
+                <button class="close-btn" onclick="closeGenerateReport()">&times;</button>
+            </div>
+            <div class="form-group">
+                <label class="form-label">Select Class</label>
+                <select class="form-select">
+                    <option>CS101 - Introduction to Programming</option>
+                    <option>MATH201 - Calculus II</option>
+                    <option>PHY301 - Quantum Physics</option>
+                </select>
+            </div>
+            <div class="form-group">
+                <label class="form-label">Date Range</label>
+                <div style="display: flex; gap: 1rem;">
+                    <input type="date" class="form-input" style="flex: 1;">
+                    <input type="date" class="form-input" style="flex: 1;">
+                </div>
+            </div>
+            <table class="attendance-table">
+                <thead>
+                    <tr>
+                        <th>Student</th>
+                        <th>Total Classes</th>
+                        <th>Present</th>
+                        <th>Attendance Rate</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    <tr>
+                        <td>John Doe</td>
+                        <td>20</td>
+                        <td>18</td>
+                        <td><span class="status-badge status-present">90%</span></td>
+                    </tr>
+                    <tr>
+                        <td>Jane Smith</td>
+                        <td>20</td>
+                        <td>15</td>
+                        <td><span class="status-badge status-absent">75%</span></td>
+                    </tr>
+                </tbody>
+            </table>
+            <div class="export-buttons">
+                <button class="btn btn-success" onclick="exportCSV()">Export as CSV</button>
+                <button class="btn btn-danger" onclick="exportPDF()">Export as PDF</button>
+                <button class="btn btn-secondary" onclick="closeGenerateReport()">Close</button>
+            </div>
+        </div>
+    </div>
+
+    <!-- Student Management Modal -->
+    <div id="studentManagementModal" class="modal">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h3 class="modal-title">Student Management</h3>
+                <button class="close-btn" onclick="closeStudentManagement()">&times;</button>
+            </div>
+            <div class="form-group">
+                <label class="form-label">Add Student to Class</label>
+                <div style="display: flex; gap: 1rem;">
+                    <input type="email" class="form-input" placeholder="Student email" style="flex: 1;">
+                    <select class="form-select" style="flex: 1;">
+                        <option>Select Class</option>
+                        <option>CS101</option>
+                        <option>MATH201</option>
+                        <option>PHY301</option>
+                    </select>
+                    <button class="btn btn-primary">Add</button>
+                </div>
+            </div>
+            <div class="student-list">
+                <div class="student-item">
+                    <span>John Doe - CS101</span>
+                    <button class="btn btn-danger btn-sm">Remove</button>
+                </div>
+                <div class="student-item">
+                    <span>Jane Smith - CS101</span>
+                    <button class="btn btn-danger btn-sm">Remove</button>
+                </div>
+                <div class="student-item">
+                    <span>Mike Johnson - MATH201</span>
+                    <button class="btn btn-danger btn-sm">Remove</button>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- Attendance Check Modal -->
+    <div id="attendanceCheckModal" class="modal">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h3 class="modal-title">Check Total Attendance</h3>
+                <button class="close-btn" onclick="closeAttendanceCheck()">&times;</button>
+            </div>
+            <div class="form-group">
+                <label class="form-label">Select Class</label>
+                <select class="form-select">
+                    <option>CS101 - Introduction to Programming</option>
+                    <option>MATH201 - Calculus II</option>
+                    <option>PHY301 - Quantum Physics</option>
+                </select>
+            </div>
+            <div style="background: #f8fafc; padding: 1.5rem; border-radius: 8px; margin: 1rem 0;">
+                <h4 style="margin-bottom: 1rem; color: #1e293b;">Class Statistics</h4>
+                <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(150px, 1fr)); gap: 1rem;">
+                    <div>
+                        <div style="font-size: 1.5rem; font-weight: 700; color: #0ea5e9;">25</div>
+                        <div style="font-size: 0.875rem; color: #64748b;">Total Students</div>
+                    </div>
+                    <div>
+                        <div style="font-size: 1.5rem; font-weight: 700; color: #10b981;">78%</div>
+                        <div style="font-size: 0.875rem; color: #64748b;">Average Attendance</div>
+                    </div>
+                    <div>
+                        <div style="font-size: 1.5rem; font-weight: 700; color: #f59e0b;">15</div>
+                        <div style="font-size: 0.875rem; color: #64748b;">Total Sessions</div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+   <script type="module" src="src/script.js"></script>
+
+</body>
+</html>

video-object-detection/src/facedetection.js

@@ -0,0 +1,285 @@
+import { AutoModel, AutoProcessor, RawImage } from "@huggingface/transformers";
+import { Client } from "@gradio/client";
+
+// Reference the elements that we will need
+const status = document.getElementById("status");
+const container = document.getElementById("container");
+const overlay = document.getElementById("overlay");
+const canvas = document.getElementById("canvas");
+const video = document.getElementById("video");
+const thresholdSlider = document.getElementById("threshold");
+const thresholdLabel = document.getElementById("threshold-value");
+const sizeSlider = document.getElementById("size");
+const sizeLabel = document.getElementById("size-value");
+const scaleSlider = document.getElementById("scale");
+const scaleLabel = document.getElementById("scale-value");
+
+function setStreamSize(width, height) {
+  video.width = canvas.width = Math.round(width);
+  video.height = canvas.height = Math.round(height);
+}
+
+status.textContent = "Loading model...";
+
+// Load model and processor
+const model_id = "Xenova/gelan-c_all";
+const model = await AutoModel.from_pretrained(model_id);
+const processor = await AutoProcessor.from_pretrained(model_id);
+
+// Set up controls
+let scale = 0.5;
+scaleSlider.addEventListener("input", () => {
+  scale = Number(scaleSlider.value);
+  setStreamSize(video.videoWidth * scale, video.videoHeight * scale);
+  scaleLabel.textContent = scale;
+});
+scaleSlider.disabled = false;
+
+let threshold = 0.80;
+thresholdSlider.addEventListener("input", () => {
+  threshold = Number(thresholdSlider.value);
+  thresholdLabel.textContent = threshold.toFixed(2);
+});
+thresholdSlider.disabled = false;
+
+let size = 96;
+processor.feature_extractor.size = { shortest_edge: size };
+sizeSlider.addEventListener("input", () => {
+  size = Number(sizeSlider.value);
+  processor.feature_extractor.size = { shortest_edge: size };
+  sizeLabel.textContent = size;
+});
+sizeSlider.disabled = false;
+
+status.textContent = "Ready";
+
+const COLOURS = [
+  "#EF4444", "#4299E1", "#059669", "#FBBF24", "#4B52B1", "#7B3AC2",
+  "#ED507A", "#1DD1A1", "#F3873A", "#4B5563", "#DC2626", "#1852B4",
+  "#18A35D", "#F59E0B", "#4059BE", "#6027A5", "#D63D60", "#00AC9B",
+  "#E64A19", "#272A34",
+];
+
+// Function to send canvas image to Gradio API
+// async function sendCanvasImageToAPI(canvas) {
+//   return new Promise((resolve, reject) => {
+//     canvas.toBlob(async (blob) => {
+//       if (!blob) {
+//         reject("Failed to get Blob from canvas");
+//         return;
+//       }
+
+//       const file1 = new File([blob], "detected.png", { type: "image/png" });
+
+//       try {
+//         // Fetch image from URL and convert to Blob
+//         const response = await fetch("https://qvnhhditkzzeudppuezf.supabase.co/storage/v1/object/public/post-images/post-images/1752289670997-kevan.jpg");
+//         const frame2Blob = await response.blob();
+//         const file2 = new File([frame2Blob], "frame2.jpg", { type: frame2Blob.type });
+
+//         const client = await Client.connect("MiniAiLive/FaceRecognition-LivenessDetection-Demo");
+
+//         // Send canvas image as frame1, URL image as frame2
+//         const result = await client.predict("/face_compare", {
+//           frame1: file1,
+//           frame2: file2,
+//         });
+//         resolve(result);
+//       } catch (err) {
+//         reject(err);
+//       }
+//     }, "image/png");
+//   });
+// }
+
+async function sendCanvasImageToAPI(canvas) {
+  return new Promise((resolve, reject) => {
+    canvas.toBlob(async (blob) => {
+      if (!blob) {
+        reject("Failed to get Blob from canvas");
+        return;
+      }
+
+      const file = new File([blob], "detected.png", { type: "image/png" });
+
+      try {
+        const formData = new FormData();
+        formData.append("image", file);
+
+        const response = await fetch("https://kevansoon-java-endpoint.hf.space/call-face-recognition", {
+          method: "POST",
+          body: formData,
+        });
+
+        if (!response.ok) {
+          reject("Failed to send image: " + response.statusText);
+          return;
+        }
+
+        const result = await response.text(); // or JSON if backend returns JSON
+        resolve(result);
+      } catch (err) {
+        reject(err);
+      }
+    }, "image/png");
+  });
+}
+
+
+// Variables to store current bounding box and label elements
+let currentBoxElement = null;
+let currentLabelElement = null;
+
+let hasSent = false; // Flag to send API request only once per detection
+
+var color = "yellow";
+var text = "Verifying..."
+// Render a bounding box and label on the image
+function renderBox([xmin, ymin, xmax, ymax, score, id], [w, h]) {
+  if (score < threshold) return; // Skip boxes with low confidence
+
+
+
+  // Create bounding box div
+  let boxElement = document.createElement("div");
+  boxElement.className = "bounding-box";
+  Object.assign(boxElement.style, {
+    borderColor: color,
+    left: (100 * xmin) / w + "%",
+    top: (100 * ymin) / h + "%",
+    width: (100 * (xmax - xmin)) / w + "%",
+    height: (100 * (ymax - ymin)) / h + "%",
+  });
+
+  // Create label span
+  let labelElement = document.createElement("span");
+  labelElement.textContent = text;
+  labelElement.className = "bounding-box-label";
+  labelElement.style.backgroundColor = color;
+  labelElement.style.color = "black";
+
+  boxElement.appendChild(labelElement);
+  overlay.appendChild(boxElement);
+
+  // Store references globally for updating after API response
+  currentBoxElement = boxElement;
+  currentLabelElement = labelElement;
+
+  // Send image to the API on first detection
+  if (!hasSent) {
+    hasSent = true;
+    sendCanvasImageToAPI(canvas)
+      .then((response) => {
+        
+        const responseObj = JSON.parse(response); 
+        const confidenceStr = responseObj.result; // "0.982708"
+
+        // Extract decimal part only:
+        // const decimalPart = confidenceStr.slice(confidenceStr.indexOf('.') + 1);
+        // console.log(decimalPart);  // e.g., "982708"
+
+        // Convert to float for comparison
+        const decimalNumber = parseFloat(confidenceStr);
+        console.log(decimalNumber);
+        
+
+        if (decimalNumber !== null && decimalNumber > 0.80) {
+          // --- MODIFICATION START ---
+          // Instead of removing and recreating the box, just update its style.
+          color = "green";
+          text = "Verified Successfully! " + decimalNumber;
+          currentLabelElement.style.color = "black"; // Or "white" if it looks better
+
+          console.log("Updated box to green");
+          // --- MODIFICATION END ---
+          
+        } else if (decimalNumber !== null) {
+          // Not identified case - update existing box and label to red
+          color = "red";
+          text = "Failed to verify"
+          currentLabelElement.style.color = "black"; // Or "white" if it looks better
+
+          console.log("Updated box to red");
+        } else {
+          // Fallback yellow verifying state
+          currentLabelElement.textContent = "Verifying...";
+          currentLabelElement.style.backgroundColor = "yellow";
+          currentLabelElement.style.color = "black";
+          currentBoxElement.style.borderColor = "yellow";
+
+          console.log("Fallback to yellow");
+        }
+      })
+      .catch((err) => {
+        console.error("Error sending image to API:", err);
+        // On error, fallback to yellow verifying
+        if (currentLabelElement && currentBoxElement) {
+          currentLabelElement.textContent = "Verifying...";
+          currentLabelElement.style.backgroundColor = "yellow";
+          currentLabelElement.style.color = "black";
+          currentBoxElement.style.borderColor = "yellow";
+        }
+      });
+  }
+}
+
+let isProcessing = false;
+let previousTime;
+const context = canvas.getContext("2d", { willReadFrequently: true });
+
+function updateCanvas() {
+  const { width, height } = canvas;
+  context.drawImage(video, 0, 0, width, height);
+
+  if (!isProcessing) {
+    isProcessing = true;
+    (async function () {
+      const pixelData = context.getImageData(0, 0, width, height).data;
+      const image = new RawImage(pixelData, width, height, 4);
+
+      const inputs = await processor(image);
+      const { outputs } = await model(inputs);
+
+      overlay.innerHTML = "";
+
+      const sizes = inputs.reshaped_input_sizes[0].reverse();
+      outputs.tolist().forEach((x) => renderBox(x, sizes));
+
+      if (previousTime !== undefined) {
+        const fps = 1000 / (performance.now() - previousTime);
+        status.textContent = `FPS: ${fps.toFixed(2)}`;
+      }
+      previousTime = performance.now();
+      isProcessing = false;
+    })();
+  }
+
+  window.requestAnimationFrame(updateCanvas);
+}
+
+// Start the video stream
+navigator.mediaDevices
+  .getUserMedia({ video: true })
+  .then((stream) => {
+    video.srcObject = stream;
+    video.play();
+
+    const videoTrack = stream.getVideoTracks()[0];
+    const { width, height } = videoTrack.getSettings();
+
+    setStreamSize(width * scale, height * scale);
+
+    const ar = width / height;
+    const [cw, ch] = ar > 720 / 405 ? [720, 720 / ar] : [405 * ar, 405];
+    container.style.width = `${cw}px`;
+    container.style.height = `${ch}px`;
+
+    window.requestAnimationFrame(updateCanvas);
+  })
+  .catch((error) => {
+    alert(error);
+  });
+
+
+
+

video-object-detection/student.html

@@ -0,0 +1,115 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Student Dashboard - Attendance System</title>
+    <link rel="stylesheet" href="styles2.css">
+</head>
+<body>
+    <div class="container">
+        <!-- Header design matching the image -->
+        <div class="header">
+            <div class="header-left">
+                <div class="logo-icon">👤</div>
+                <h1 class="header-title">Student Dashboard</h1>
+            </div>
+            <div class="header-right">
+                <span class="welcome-text">Welcome, a@a</span>
+                <button class="logout-btn" onclick="logout()">Logout</button>
+            </div>
+        </div>
+
+        <!-- Welcome section -->
+        <div class="welcome-section">
+            <h2 class="welcome-title">Welcome back!</h2>
+            <p class="welcome-subtitle">Manage your class attendance and view your records</p>
+        </div>
+
+        <!-- Stats cards matching the image -->
+        <div class="stats-grid">
+            <div class="stat-card">
+                <div class="stat-icon blue">✓</div>
+                <div class="stat-content">
+                    <h3>Attendance Rate</h3>
+                    <div class="stat-number">85%</div>
+                </div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-icon orange">📚</div>
+                <div class="stat-content">
+                    <h3>Total Classes</h3>
+                    <div class="stat-number">24</div>
+                </div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-icon yellow">🕐</div>
+                <div class="stat-content">
+                    <h3>Classes Today</h3>
+                    <div class="stat-number">3</div>
+                </div>
+            </div>
+        </div>
+
+        <!-- Class selection section -->
+        <div class="section-card">
+            <div class="section-header">
+                <h3 class="section-title">Select Class/Session</h3>
+                <p class="section-subtitle">Available Classes</p>
+            </div>
+            <div class="section-content">
+                <select class="form-select" id="classSelect" onchange="enableFaceScanning()">
+                    <option value="">Select a class</option>
+                    <option value="cs101">CS101 - Introduction to Programming</option>
+                    <option value="math201">MATH201 - Calculus II</option>
+                    <option value="phy301">PHY301 - Quantum Physics</option>
+                </select>
+                <button id="scanFaceBtn" class="btn btn-primary" style="width: 100%; margin-top: 1rem; display: none;" onclick="openFaceScanning()">
+                    Scan Face for Attendance
+                </button>
+            </div>
+        </div>
+
+        <!-- Recent Attendance section -->
+        <div class="section-card">
+            <div class="section-header">
+                <h3 class="section-title">Recent Attendance</h3>
+            </div>
+            <div class="section-content">
+                <p class="welcome-subtitle">Your recent attendance records will appear here</p>
+            </div>
+        </div>
+    </div>
+
+    <!-- Face Scanning Modal -->
+    <div id="faceScanModal" class="modal">
+        <div class="modal-content" style="max-width: 500px;">
+            <div class="modal-header">
+                <h3 class="modal-title">Scan Face for Attendance</h3>
+                <button class="close-btn" onclick="closeFaceScanning()">&times;</button>
+            </div>
+            <div class="modal-body">
+                <p style="text-align: center; color: #64748b; margin-bottom: 1rem;">
+                    Position your face within the frame for attendance verification
+                </p>
+                <div class="camera-container" style="position: relative; background: #000; border-radius: 8px; overflow: hidden; margin-bottom: 1rem;">
+                    <video id="attendanceVideo" style="width: 100%; height: 300px; object-fit: cover;" autoplay muted></video>
+                    <canvas id="attendanceCanvas" style="display: none;"></canvas>
+                    <div class="scan-overlay" style="position: absolute; top: 50%; left: 50%; transform: translate(-50%, -50%); width: 200px; height: 200px; border: 2px solid #22d3ee; border-radius: 50%; opacity: 0.8;"></div>
+                </div>
+                <div id="scanResult" style="text-align: center; margin-bottom: 1rem; display: none;">
+                    <div style="color: #22c55e; font-weight: 500;">✓ Face verified successfully!</div>
+                </div>
+                <div style="display: flex; gap: 1rem;">
+                    <button id="scanBtn" class="btn btn-primary" style="flex: 1;" onclick="scanFace()">Scan Face</button>
+                    <button id="markPresentBtn" class="btn btn-success" style="flex: 1; display: none;" onclick="markAttendance()">Mark Present</button>
+                    <button class="btn btn-secondary" style="flex: 1;" onclick="closeFaceScanning()">Cancel</button>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <script type="module" src="src/script.js"></script>
+
+</body>
+</html>

video-object-detection/styles2.css

@@ -0,0 +1,465 @@
+* {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+
+body {
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+  background-color: #f8fafc;
+  color: #334155;
+  line-height: 1.6;
+}
+
+.container {
+  max-width: 1200px;
+  margin: 0 auto;
+  padding: 2rem;
+}
+
+/* Header design matching the image */
+.header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: 3rem;
+}
+
+.header-left {
+  display: flex;
+  align-items: center;
+  gap: 1rem;
+}
+
+.logo-icon {
+  width: 48px;
+  height: 48px;
+  background: #0ea5e9;
+  border-radius: 50%;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  color: white;
+  font-size: 1.5rem;
+}
+
+.header-title {
+  font-size: 1.5rem;
+  font-weight: 600;
+  color: #64748b;
+}
+
+.header-right {
+  display: flex;
+  align-items: center;
+  gap: 1rem;
+}
+
+.welcome-text {
+  color: #64748b;
+  font-size: 0.95rem;
+}
+
+.logout-btn {
+  color: #ef4444;
+  background: none;
+  border: none;
+  font-size: 0.95rem;
+  cursor: pointer;
+  font-weight: 500;
+}
+
+.logout-btn:hover {
+  text-decoration: underline;
+}
+
+/* Welcome section design */
+.welcome-section {
+  margin-bottom: 3rem;
+}
+
+.welcome-title {
+  font-size: 2rem;
+  font-weight: 600;
+  color: #1e293b;
+  margin-bottom: 0.5rem;
+}
+
+.welcome-subtitle {
+  color: #64748b;
+  font-size: 1rem;
+}
+
+/* Stats cards design matching the image */
+.stats-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
+  gap: 1.5rem;
+  margin-bottom: 3rem;
+}
+
+.stat-card {
+  background: white;
+  padding: 2rem;
+  border-radius: 12px;
+  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+  display: flex;
+  align-items: center;
+  gap: 1rem;
+}
+
+.stat-icon {
+  width: 48px;
+  height: 48px;
+  border-radius: 12px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 1.5rem;
+}
+
+.stat-icon.blue {
+  background: #dbeafe;
+  color: #2563eb;
+}
+
+.stat-icon.orange {
+  background: #fed7aa;
+  color: #ea580c;
+}
+
+.stat-icon.yellow {
+  background: #fef3c7;
+  color: #d97706;
+}
+
+.stat-content h3 {
+  font-size: 0.875rem;
+  color: #64748b;
+  font-weight: 500;
+  margin-bottom: 0.25rem;
+}
+
+.stat-content .stat-number {
+  font-size: 2rem;
+  font-weight: 700;
+  color: #1e293b;
+}
+
+/* Section cards design */
+.section-card {
+  background: white;
+  border-radius: 12px;
+  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+  margin-bottom: 2rem;
+}
+
+.section-header {
+  padding: 1.5rem 2rem;
+  border-bottom: 1px solid #e2e8f0;
+}
+
+.section-title {
+  font-size: 1.25rem;
+  font-weight: 600;
+  color: #1e293b;
+  margin-bottom: 0.5rem;
+}
+
+.section-subtitle {
+  color: #64748b;
+  font-size: 0.875rem;
+}
+
+.section-content {
+  padding: 2rem;
+}
+
+/* Form elements */
+.form-select {
+  width: 100%;
+  padding: 0.75rem 1rem;
+  border: 1px solid #d1d5db;
+  border-radius: 8px;
+  background: white;
+  color: #374151;
+  font-size: 0.875rem;
+  cursor: pointer;
+}
+
+.form-select:focus {
+  outline: none;
+  border-color: #0ea5e9;
+  box-shadow: 0 0 0 3px rgba(14, 165, 233, 0.1);
+}
+
+.form-group {
+  margin-bottom: 1.5rem;
+}
+
+.form-label {
+  display: block;
+  margin-bottom: 0.5rem;
+  font-weight: 500;
+  color: #374151;
+  font-size: 0.875rem;
+}
+
+.form-input {
+  width: 100%;
+  padding: 0.75rem;
+  border: 1px solid #d1d5db;
+  border-radius: 8px;
+  font-size: 0.875rem;
+  transition: border-color 0.2s;
+}
+
+.form-input:focus {
+  outline: none;
+  border-color: #0ea5e9;
+  box-shadow: 0 0 0 3px rgba(14, 165, 233, 0.1);
+}
+
+/* Buttons */
+.btn {
+  padding: 0.75rem 1.5rem;
+  border: none;
+  border-radius: 8px;
+  font-weight: 500;
+  cursor: pointer;
+  transition: all 0.2s;
+  font-size: 0.875rem;
+}
+
+.btn-primary {
+  background: #0ea5e9;
+  color: white;
+}
+
+.btn-primary:hover {
+  background: #0284c7;
+}
+
+.btn-secondary {
+  background: #f1f5f9;
+  color: #64748b;
+  border: 1px solid #e2e8f0;
+}
+
+.btn-secondary:hover {
+  background: #e2e8f0;
+}
+
+.btn-success {
+  background: #10b981;
+  color: white;
+}
+
+.btn-success:hover {
+  background: #059669;
+}
+
+.btn-danger {
+  background: #ef4444;
+  color: white;
+}
+
+.btn-danger:hover {
+  background: #dc2626;
+}
+
+.btn-sm {
+  padding: 0.375rem 0.75rem;
+  font-size: 0.75rem;
+}
+
+/* Modals */
+.modal {
+  display: none;
+  position: fixed;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  background: rgba(0, 0, 0, 0.5);
+  z-index: 1000;
+  justify-content: center;
+  align-items: center;
+}
+
+.modal.active {
+  display: flex;
+}
+
+.modal-content {
+  background: white;
+  padding: 2rem;
+  border-radius: 16px;
+  max-width: 500px;
+  width: 90%;
+  max-height: 80vh;
+  overflow-y: auto;
+}
+
+.modal-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: 1.5rem;
+}
+
+.modal-title {
+  font-size: 1.25rem;
+  font-weight: 600;
+  color: #1e293b;
+}
+
+.close-btn {
+  background: none;
+  border: none;
+  font-size: 1.5rem;
+  cursor: pointer;
+  color: #64748b;
+}
+
+/* Camera and scanning */
+.camera-container {
+  position: relative;
+  width: 100%;
+  max-width: 400px;
+  margin: 0 auto 1rem;
+}
+
+.camera-preview {
+  width: 100%;
+  height: 300px;
+  background: #f1f5f9;
+  border-radius: 8px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  color: #64748b;
+  font-size: 0.875rem;
+}
+
+.scan-overlay {
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+  width: 200px;
+  height: 200px;
+  border: 2px solid #0ea5e9;
+  border-radius: 8px;
+  pointer-events: none;
+}
+
+.scan-overlay::before {
+  content: "";
+  position: absolute;
+  top: -2px;
+  left: -2px;
+  right: -2px;
+  bottom: -2px;
+  border: 2px solid #0ea5e9;
+  border-radius: 8px;
+  animation: pulse 2s infinite;
+}
+
+@keyframes pulse {
+  0% {
+    opacity: 1;
+  }
+  50% {
+    opacity: 0.5;
+  }
+  100% {
+    opacity: 1;
+  }
+}
+
+/* Tables */
+.attendance-table {
+  width: 100%;
+  border-collapse: collapse;
+  margin-top: 1rem;
+}
+
+.attendance-table th,
+.attendance-table td {
+  padding: 0.75rem;
+  text-align: left;
+  border-bottom: 1px solid #e2e8f0;
+}
+
+.attendance-table th {
+  background: #f8fafc;
+  font-weight: 600;
+  color: #374151;
+}
+
+.status-badge {
+  padding: 0.25rem 0.75rem;
+  border-radius: 9999px;
+  font-size: 0.75rem;
+  font-weight: 500;
+}
+
+.status-present {
+  background: #dcfce7;
+  color: #166534;
+}
+
+.status-absent {
+  background: #fee2e2;
+  color: #991b1b;
+}
+
+/* Lists */
+.student-list {
+  max-height: 300px;
+  overflow-y: auto;
+  border: 1px solid #e2e8f0;
+  border-radius: 8px;
+  margin-top: 1rem;
+}
+
+.student-item {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 0.75rem;
+  border-bottom: 1px solid #e2e8f0;
+}
+
+.student-item:last-child {
+  border-bottom: none;
+}
+
+.attendance-controls {
+  display: flex;
+  gap: 0.5rem;
+}
+
+.export-buttons {
+  display: flex;
+  gap: 1rem;
+  margin-top: 1rem;
+}
+
+/* Responsive design */
+@media (max-width: 768px) {
+  .container {
+    padding: 1rem;
+  }
+
+  .header {
+    flex-direction: column;
+    gap: 1rem;
+    text-align: center;
+  }
+
+  .stats-grid {
+    grid-template-columns: 1fr;
+  }
+}

video-object-detection/vite.config.js

@@ -1,6 +1,17 @@
-import { defineConfig } from "vite";
+// vite.config.js
+import { defineConfig } from 'vite';
+import { resolve } from 'path';
+
 export default defineConfig({
   build: {
     target: "esnext",
-  },
+    rollupOptions: {
+      input: {
+        main: resolve(__dirname, 'index.html'),
+        professor: resolve(__dirname, 'professor.html'),
+        student: resolve(__dirname, 'student.html'),
+        facedetection: resolve(__dirname, 'facedetection.html'),
+      }
+    }
+  }
 });