logical changes for delete API and save API

src/main/java/com/nisum/Employeeinfo/controller/EmployeeController.java

@@ -73,12 +73,13 @@ public class EmployeeController {
                 .doOnError(error -> log.error("Error updating employee: {}", error.getMessage()));
     }
 
-    @DeleteMapping("/deleteMapping/{id}")
+    @DeleteMapping("/deleteEmployee/{id}")
     public Mono<ResponseEntity<Object>> deleteEmployee(@PathVariable Integer id){
 
         return validator.isEmployeeIdValid(id)
                 .flatMap(valid -> employeeService.deleteEmployee(id))
                 .thenReturn(ResponseEntity.ok().build())
+                .doOnSuccess(objectResponseEntity -> log.info("deleted successfully : {}" +objectResponseEntity))
                 .doOnError(error -> log.error("Error deleting employee: {}", error.getMessage()));
     }
 

src/main/java/com/nisum/Employeeinfo/dao/EmployeeDao.java

@@ -32,25 +32,38 @@ public class EmployeeDao {
                 .bind("sal",employee.getSal())
                 .fetch()
                 .rowsUpdated()
-                .flatMap(rows -> {
-                    if (rows > 0) {
-                        // Successfully inserted the employee
-                        return Mono.just(employee)
-                                .doOnSuccess(savedEmployee -> {
-                                    // Side effect: log successful insert
-                                    log.info("Successfully saved employee: {}", savedEmployee);
-                                });
-                    } else {
-                        // No rows updated, employee not found (error scenario)
-                        return Mono.error(new EmployeeNotFoundException(ApiErrorCode.EMPLOYEE_NOT_FOUND, "Employee Not Found"));
-                    }
+//                .flatMap(rows -> {
+//                    if (rows > 0) {
+//                        // Successfully inserted the employee
+//                        return Mono.just(employee)
+//                                .doOnSuccess(savedEmployee -> {
+//                                    // Side effect: log successful insert
+//                                    log.info("Successfully saved employee: {}", savedEmployee);
+//                                });
+//                    } else {
+//                        // No rows updated, employee not found (error scenario)
+//                        return Mono.error(new EmployeeNotFoundException(ApiErrorCode.EMPLOYEE_NOT_FOUND, "Employee Not Found"));
+//                    }
+//                })
+//                .onErrorResume(RuntimeException.class,ex->{
+//                    log.error("invalid employee data {}",ex.getMessage());
+//                    return Mono.just(new Employee(-1,"invalid name","invalid email","invalid dept",0.0));
+//                });
+                .flatMap(rows -> Mono.justOrEmpty(rows > 0 ? employee : null))
+                .switchIfEmpty(Mono.error(new RuntimeException("no record updated")))
+
+                // Handle runtime exceptions
+                .onErrorResume(RuntimeException.class, ex -> {
+                    log.error("Invalid employee data: {}", ex.getMessage());
+                    return Mono.just(new Employee(-1, "invalid name", "invalid email", "invalid dept", 0.0));
                 })
-                .onErrorResume(RuntimeException.class,ex->{
-                    log.error("invalid employee data {}",ex.getMessage());
-                    return Mono.just(new Employee(-1,"invalid name","invalid email","invalid dept",0.0));
-                });
 
+                // Log successful insertions
+                .doOnSuccess(savedEmployee -> log.info("Successfully saved employee: {}", savedEmployee));
     }
+
+
+
     public Flux<Employee> findAllEmployee(){
         String query="SELECT * FROM employee ";
         return databaseClient.sql(query)
@@ -124,22 +137,23 @@ public class EmployeeDao {
                 });
     }
 
-    public Mono<Void> deleteEmployeeById(Integer id){
-        String query= "DELETE FROM employee WHERE id = :id ";
+    public Mono<Long> deleteEmployeeById(Integer id) {
+        String query = "DELETE FROM employee WHERE id = :id";
+
         return databaseClient.sql(query)
-                .bind("id",id)
+                .bind("id", id)
                 .fetch()
                 .rowsUpdated()
-                .flatMap(updateRow->{
-                    if (updateRow>0){
-                        return Mono.empty();
-                    }else {
-                      return  Mono.error(new EmployeeNotFoundException(ApiErrorCode.EMPLOYEE_NOT_FOUND,"Employee_Not_Found"));
+                .flatMap(updatedRows -> {
+                    if (updatedRows > 0) {
+                        // Return the number of rows deleted
+                        return Mono.just(updatedRows);
+                    } else {
+                        // Throw an error if no rows were deleted
+                        return Mono.error(new EmployeeNotFoundException(
+                                ApiErrorCode.EMPLOYEE_NOT_FOUND, "Employee Not Found"));
                     }
                 });
-
-
-
     }
 
 

src/main/java/com/nisum/Employeeinfo/service/EmployeeService.java

@@ -14,5 +14,5 @@ public interface EmployeeService {
     public Flux<Employee> getAllEmployee();
     public Mono<Employee> getEmployeeById(Integer id);
     public Mono<Employee> updateEmployee(Integer id, Mono<EmployeeDto> mono);
-    public Mono<Void> deleteEmployee(Integer id);
+    public Mono<Long> deleteEmployee(Integer id);
 }

src/main/java/com/nisum/Employeeinfo/service/EmployeeServiceImpl.java

@@ -63,10 +63,10 @@ public class EmployeeServiceImpl implements EmployeeService{
     }
 
     @Override
-    public Mono<Void> deleteEmployee(Integer id) {
+    public Mono<Long> deleteEmployee(Integer id) {
 
         return dao.deleteEmployeeById(id)
-                .doOnSuccess(success -> log.info("employee deleted successfully"))
-                .doOnError(error -> log.error("Employee Not Found"));
+                .doOnSuccess(deletedRows -> log.info("Employee deleted successfully, Rows Deleted: {}", deletedRows))
+                .doOnError(error -> log.error("Error deleting employee: {}", error.getMessage()));
     }
 }