Added Database connection

README.md

@@ -1,4 +1,104 @@
----
-sdk: docker
-app_port: 7860
----
+# CS102 Smart Attendance Project
+
+A backend Spring Boot application for a smart attendance tracking system.
+
+## ⚙️ Configuration
+
+### Environment Variables
+
+Create a `.env` file in the project root or set the following environment variables:
+
+```env
+# Database Configuration
+SPRING_DATASOURCE_URL=your_url
+SPRING_DATASOURCE_USERNAME=your_username
+SPRING_DATASOURCE_PASSWORD=your_password
+
+
+## 🚀 Running the Application
+
+### Using Maven Wrapper (Recommended)
+
+```bash
+# On Unix/Linux/macOS
+./mvnw spring-boot:run
+
+# On Windows
+mvnw.cmd spring-boot:run
+```
+
+### Using Maven
+
+```bash
+# Clean and install dependencies
+mvn clean install
+
+# Run the application
+mvn spring-boot:run
+```
+
+### Using JAR file
+
+```bash
+# Build the JAR file
+mvn clean package
+
+# Run the JAR file
+java -jar target/attendance-0.0.1-SNAPSHOT.jar
+```
+
+The application will start on `http://localhost:8080` by default.
+
+### Accessing the Application
+
+When you run the application locally, you'll be redirected to a login page due to Spring Security being enabled.
+
+**Login Credentials:**
+- **Username:** `user`
+- **Password:** A new password is generated every time you run the project (check your terminal/console output)
+
+The generated password will appear in the logs like this:
+```
+Using generated security password: a1b2c3d4-e5f6-7890-abcd-ef1234567890
+```
+
+Copy this password from your terminal to log into the application.
+
+## 🔗 Application Monitoring
+
+The application includes Spring Boot Actuator for basic monitoring:
+
+- **Application Health**: `GET /actuator/health`
+- **Application Info**: `GET /actuator/info`
+- **Metrics**: `GET /actuator/metrics`
+- **Prometheus Metrics**: `GET /actuator/prometheus`
+
+## 🧪 Testing
+
+### Run Unit Tests
+
+```bash
+# Using Maven Wrapper
+./mvnw test
+
+# Using Maven
+mvn test
+```
+
+### Run Integration Tests
+
+```bash
+# Using Maven Wrapper
+./mvnw verify
+
+# Using Maven
+mvn verify
+```
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch: `git checkout -b feature/amazing-feature`
+3. Commit your changes: `git commit -m 'Add some amazing feature'`
+4. Push to the branch: `git push origin feature/amazing-feature`
+5. Open a Pull Request

pom.xml

@@ -67,6 +67,11 @@
 			<artifactId>postgresql</artifactId>
 			<scope>runtime</scope>
 		</dependency>
+		<dependency>
+			<groupId>me.paulschwarz</groupId>
+			<artifactId>spring-dotenv</artifactId>
+			<version>4.0.0</version>
+		</dependency>
 	</dependencies>
 
 	<build>

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

@@ -1,13 +0,0 @@
-package com.cs102.attendance;
-
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.RestController;
-
-@RestController
-public class TestController {
-
-    @GetMapping("/hello")
-    public String hello() {
-        return "Spring Boot is working!";
-    }
-}

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

@@ -0,0 +1,49 @@
+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 javax.sql.DataSource;
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.HashMap;
+import java.util.Map;
+
+@RestController
+@RequestMapping("/api/health")
+public class HealthController {
+
+    @Autowired
+    private DataSource dataSource;
+
+    @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
+            
+            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);
+        }
+    }
+} 

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

@@ -0,0 +1,75 @@
+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 java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@RestController
+@RequestMapping("/api/test")
+public class TestController {
+
+    @Autowired
+    private TestConnectionRepository testConnectionRepository;
+
+    @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");
+            
+            // 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 3: Read operation
+            List<TestConnection> allRecords = testConnectionRepository.findAll();
+            response.put("readOperation", !allRecords.isEmpty() ? "PASS" : "FAIL");
+            response.put("recordCount", allRecords.size());
+            
+            // Test 4: Delete operation
+            testConnectionRepository.deleteById(saved.getId());
+            response.put("deleteOperation", "PASS");
+            
+            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);
+        }
+    }
+    
+    @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();
+        }
+    }
+    
+    @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();
+        }
+    }
+} 

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

@@ -0,0 +1,53 @@
+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/repository/TestConnectionRepository.java

@@ -0,0 +1,13 @@
+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/resources/application.yml

@@ -7,6 +7,10 @@ spring:
     username: ${SPRING_DATASOURCE_USERNAME}
     password: ${SPRING_DATASOURCE_PASSWORD}
     driver-class-name: org.postgresql.Driver
+    hikari:
+      maximum-pool-size: 10
+      connection-timeout: 30000
+      idle-timeout: 600000
   jpa:
     hibernate:
       ddl-auto: update
@@ -14,16 +18,17 @@ spring:
     properties:
       hibernate:
         dialect: org.hibernate.dialect.PostgreSQLDialect
+  # security:
+  #   user:
+  #     name: ${SPRING_SECURITY_USER_NAME}
+  #     password: ${SPRING_SECURITY_USER_PASSWORD}
 
-management:
-  endpoints:
-    web:
-      exposure:
-        include: health,info,metrics,prometheus
+# Expose metrics for demo proof
+management.endpoints.web.exposure.include: health,info,metrics,prometheus
 
+# Externalised CV thresholds
 recognition:
   confidence: 0.6
   cooldownMs: 10000
-
 face-service:
-  url: http://localhost:5001
+  url: http://localhost:5001   # backend face service url

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

@@ -1,13 +1,50 @@
 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 javax.sql.DataSource;
+import java.sql.Connection;
+import java.sql.SQLException;
+
+import static org.junit.jupiter.api.Assertions.*;
+
 @SpringBootTest
 class Cs102AttendanceProjectApplicationTests {
 
+	@Autowired
+	private DataSource dataSource;
+
+	@Autowired
+	private TestConnectionRepository testConnectionRepository;
+
 	@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");
+			
+			// 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");
+	}
+
 }

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

@@ -0,0 +1,73 @@
+package com.cs102.attendance.controller;
+
+import com.cs102.attendance.entity.TestConnection;
+import com.cs102.attendance.repository.TestConnectionRepository;
+import com.fasterxml.jackson.databind.ObjectMapper;
+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.boot.test.mock.mockito.MockBean;
+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.*;
+
+@WebMvcTest(TestController.class)
+public class TestControllerTest {
+
+    @Autowired
+    private MockMvc mockMvc;
+
+    @MockBean
+    private TestConnectionRepository testConnectionRepository;
+
+    @Autowired
+    private ObjectMapper objectMapper;
+
+    @Test
+    public void testInsertTestDataWithDefaultMessage() throws Exception {
+        // Given
+        TestConnection mockSavedEntity = new TestConnection("Test message");
+        mockSavedEntity.setId(1L);
+        when(testConnectionRepository.save(any(TestConnection.class))).thenReturn(mockSavedEntity);
+
+        // 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"));
+    }
+
+    @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);
+
+        // 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));
+    }
+
+    @Test
+    public void testInsertTestDataWithException() throws Exception {
+        // Given
+        when(testConnectionRepository.save(any(TestConnection.class)))
+                .thenThrow(new RuntimeException("Database error"));
+
+        // When & Then
+        mockMvc.perform(post("/api/test/insert-test-data")
+                .contentType(MediaType.APPLICATION_JSON))
+                .andExpect(status().isInternalServerError());
+    }
+}