adding validation to the controller

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

@@ -5,6 +5,7 @@ import com.nisum.Employeeinfo.mapper.EmployeeMapper;
 import com.nisum.Employeeinfo.model.Employee;
 import com.nisum.Employeeinfo.service.EmployeeService;
 import com.nisum.Employeeinfo.service.EmployeeServiceImpl;
+import com.nisum.Employeeinfo.validator.CommonServiceValidator;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -20,38 +21,71 @@ public class EmployeeController {
     @Autowired
     private EmployeeService employeeService;
 
+    @Autowired
+    private CommonServiceValidator validator;
+
     private static  final Logger log= LoggerFactory.getLogger(EmployeeController.class);
 
     @PostMapping("/addEmployee")
     public Mono<ResponseEntity<Employee>> addEmployee(@RequestBody Mono<EmployeeDto> mono){
-        return employeeService.addEmployee(mono)
-                .map(ResponseEntity::ok);
-
+//        return employeeService.addEmployee(mono)
+//                .map(ResponseEntity::ok);
+        return mono
+                .doOnNext(employeeDto -> log.info("validating incoming employee data: {}",employeeDto))
+                .flatMap(employeeDto -> {
+                    Employee employee= EmployeeMapper.toEntity(employeeDto);
+                    return validateEmployee(employee)
+                            .then(employeeService.addEmployee(Mono.just(employeeDto)));
+                })
+                .map(ResponseEntity::ok)
+                .doOnError(error -> log.error("Error while adding employee: {}", error.getMessage()));
 
     }
     @GetMapping("/getEmployeeById/{id}")
-    public Mono<Employee> getEmployeeById(@PathVariable Integer id){
+    public Mono<ResponseEntity<Employee>> getEmployeeById(@PathVariable Integer id){
 
-        return employeeService.getEmployeeById(id)
-                .doOnNext(employee -> log.info("received employee {}",employee));
+//        return employeeService.getEmployeeById(id)
+//                .doOnNext(employee -> log.info("received employee {}",employee));
+        return validator.isEmployeeIdValid(id)
+                .flatMap(valid -> employeeService.getEmployeeById(id))
+                .map(ResponseEntity::ok)
+                .doOnError(error -> log.error("Error fetching employee by ID: {}", error.getMessage()));
     }
 
     @GetMapping("/getAllEmployee")
     public Flux<Employee> getAllEmployee(){
         return employeeService.getAllEmployee()
-                .doOnNext(employee -> log.info("received all employee {}", employee));
+                .doOnNext(employee -> log.info("Processing employee data: {}", employee))
+                .doOnError(error -> log.error("Error fetching employees: {}", error.getMessage()));
 
     }
 
     @PutMapping("/{id}/updateEmployee")
-    public Mono<Employee> updateEmployee(@PathVariable Integer id, @RequestBody Mono<EmployeeDto> updatedEmployee){
-
-        return employeeService.updateEmployee(id,updatedEmployee);
+    public Mono<ResponseEntity<Employee>> updateEmployee(@PathVariable Integer id, @RequestBody Mono<EmployeeDto> updatedEmployee) {
+        return validator.isEmployeeIdValid(id)
+                .flatMap(valid -> updatedEmployee
+                        .flatMap(dto -> {
+                            Employee employee = EmployeeMapper.toEntity(dto);
+                            return validateEmployee(employee)
+                                    .then(employeeService.updateEmployee(id, Mono.just(dto)));
+                        })
+                )
+                .map(ResponseEntity::ok)
+                .doOnError(error -> log.error("Error updating employee: {}", error.getMessage()));
     }
 
     @DeleteMapping("/deleteMapping/{id}")
-    public Mono<Void> deleteEmployee(@PathVariable Integer id){
+    public Mono<ResponseEntity<Object>> deleteEmployee(@PathVariable Integer id){
+
+        return validator.isEmployeeIdValid(id)
+                .flatMap(valid -> employeeService.deleteEmployee(id))
+                .thenReturn(ResponseEntity.ok().build())
+                .doOnError(error -> log.error("Error deleting employee: {}", error.getMessage()));
+    }
 
-        return employeeService.deleteEmployee(id);
+    private Mono<Void> validateEmployee(Employee employee) {
+        return validator.isEmployeeNameValid(employee.getName())
+                .then(validator.isEmployeeSalaryValid(employee.getSal()))
+                .then();
     }
 }

src/main/java/com/nisum/Employeeinfo/validator/CommonServiceValidator.java

 package com.nisum.Employeeinfo.validator;
 
+import com.nisum.Employeeinfo.errorcode.ApiErrorCode;
+import com.nisum.Employeeinfo.exception.EmployeeNotFoundException;
+import com.nisum.Employeeinfo.exception.InvalidEmployeeDataException;
+import com.nisum.Employeeinfo.model.Employee;
+import org.springframework.stereotype.Component;
+import reactor.core.publisher.Mono;
+
+@Component
 public class CommonServiceValidator {
+
+    //validate if employee id is not null
+    public Mono<Boolean> isEmployeeIdValid(Integer id) {
+        if (id != null) {
+            return Mono.just(true);
+        }
+        return Mono.error(new InvalidEmployeeDataException(ApiErrorCode.INVALID_EMPLOYEE_DATA, "Employee ID cannot be null"));
+    }
+
+    // Validate if Employee name is not null or empty
+    public Mono<Boolean> isEmployeeNameValid(String name) {
+        if (name != null && !name.trim().isEmpty()) {
+            return Mono.just(true);
+        }
+        return Mono.error(new InvalidEmployeeDataException(ApiErrorCode.INVALID_EMPLOYEE_DATA, "Employee name cannot be empty"));
+    }
+
+    // Validate if Employee salary is non-negative
+    public Mono<Boolean> isEmployeeSalaryValid(Double sal) {
+        if (sal != null && sal >= 0) {
+            return Mono.just(true);
+        }
+        return Mono.error(new InvalidEmployeeDataException(ApiErrorCode.INVALID_EMPLOYEE_DATA, "Employee salary must be non-negative"));
+    }
+
+    // Validate if the Employee object is valid as a whole
+    public Mono<Boolean> isEmployeeObjectValid(Employee employee) {
+        if (employee == null) {
+            return Mono.error(new EmployeeNotFoundException(ApiErrorCode.EMPLOYEE_NOT_FOUND, "Employee object cannot be null"));
+        }
+
+        return isEmployeeIdValid(employee.getId())
+                .flatMap(valid -> isEmployeeNameValid(employee.getName()))
+                .flatMap(valid -> isEmployeeSalaryValid(employee.getSal()));
+    }
 }