Feat: implement soft delete for employees with audit tracking

- Add soft delete functionality to Employee entity via deletedAt field
- Implement JPA auditing with createdBy and lastModifiedBy tracking
- Configure JpaConfig with AuditorAware for user audit trail
- Update BaseModel with audit fields and entity listeners
- Modify employee delete endpoint to require status (TERMINATED/RESIGNED)
- Handle supervisor reassignment when deleting employees with subordinates
- Update EmployeeRepository queries to exclude soft-deleted records
- Add validation to prevent deletion of already deleted employees
- update unit tests for soft delete

Author: iodsky

src/main/java/com/iodsky/sweldox/common/BaseModel.java

@@ -1,16 +1,19 @@
 package com.iodsky.sweldox.common;
 
-import jakarta.persistence.Column;
-import jakarta.persistence.MappedSuperclass;
-import jakarta.persistence.Version;
+import com.iodsky.sweldox.security.user.User;
+import jakarta.persistence.*;
 import lombok.Getter;
 import lombok.Setter;
 import org.hibernate.annotations.CreationTimestamp;
 import org.hibernate.annotations.UpdateTimestamp;
+import org.springframework.data.annotation.CreatedBy;
+import org.springframework.data.annotation.LastModifiedBy;
+import org.springframework.data.jpa.domain.support.AuditingEntityListener;
 
 import java.time.Instant;
 
 @MappedSuperclass
+@EntityListeners(AuditingEntityListener.class)
 @Getter
 @Setter
 public abstract class BaseModel {
@@ -22,6 +25,23 @@ public abstract class BaseModel {
     @UpdateTimestamp
     private Instant updatedAt;
 
+    private Instant deletedAt;
+
+    @CreatedBy
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "created_by")
+    private User createdBy;
+
+    @LastModifiedBy
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "last_modified_by")
+    private User lastModifiedBy;
+
     @Version
     private Long version;
+
+    public boolean isDeleted() {
+        return deletedAt != null;
+    }
+
 }

src/main/java/com/iodsky/sweldox/common/JpaConfig.java

@@ -0,0 +1,30 @@
+package com.iodsky.sweldox.common;
+
+import com.iodsky.sweldox.security.user.User;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.domain.AuditorAware;
+import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.context.SecurityContextHolder;
+
+import java.util.Optional;
+
+@Configuration
+@EnableJpaAuditing
+public class JpaConfig {
+
+    @Bean
+    public AuditorAware<User> auditorProvider() {
+        return () -> {
+            Authentication auth = SecurityContextHolder.getContext().getAuthentication();
+            if (auth == null || !auth.isAuthenticated()
+                || "anonymousUser".equals(auth.getPrincipal())) {
+                return Optional.empty();
+            }
+
+            return Optional.of((User) auth.getPrincipal());
+        };
+    }
+
+}

src/main/java/com/iodsky/sweldox/employee/EmployeeController.java

@@ -82,8 +82,8 @@ public ResponseEntity<ApiResponse<EmployeeDto>> updateEmployee(@PathVariable lon
 
     @PreAuthorize("hasRole('HR')")
     @DeleteMapping("/{id}")
-    public ResponseEntity<ApiResponse<DeleteResponse>> deleteEmployee(@PathVariable long id) {
-        employeeService.deleteEmployeeById(id);
+    public ResponseEntity<ApiResponse<DeleteResponse>> deleteEmployee(@PathVariable long id, @RequestParam String status) {
+        employeeService.deleteEmployeeById(id, status);
         DeleteResponse res = new DeleteResponse("Employee", id);
         return ResponseFactory.ok("Employee deleted successfully", res);
     }

src/main/java/com/iodsky/sweldox/employee/EmployeeRepository.java

@@ -4,17 +4,25 @@
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.Query;
+import org.springframework.lang.NonNull;
 import org.springframework.stereotype.Repository;
 
 import java.util.List;
 
 @Repository
 public interface EmployeeRepository extends JpaRepository<Employee, Long> {
 
+    @Query("SELECT e FROM Employee e WHERE e.deletedAt IS NULL")
+    @NonNull
+    Page<Employee> findAll(@NonNull Pageable pageable);
+
+    @Query("SELECT e FROM Employee e WHERE e.deletedAt IS NULL AND e.employmentDetails.status = :status")
     Page<Employee> findByEmploymentDetails_Status(Status status, Pageable pageable);
 
+    @Query("SELECT e FROM Employee e WHERE e.deletedAt IS NULL AND e.employmentDetails.department.id = :departmentId")
     Page<Employee> findByEmploymentDetails_Department_Id(String departmentId, Pageable pageable);
 
+    @Query("SELECT e FROM Employee e WHERE e.deletedAt IS NULL AND e.employmentDetails.supervisor.id = :supervisorId")
     Page<Employee> findByEmploymentDetails_Supervisor_Id(Long supervisorId, Pageable pageable);
 
     @Query("""
@@ -27,4 +35,7 @@ WHERE e.employmentDetails.status NOT IN (
        """)
     List<Long> findAllActiveEmployeeIds();
 
+    @Query("SELECT e FROM Employee e WHERE e.deletedAt IS NULL AND e.employmentDetails.supervisor.id = :supervisorId")
+    List<Employee> findAllByEmploymentDetails_Supervisor_Id(Long supervisorId);
+
 }

src/main/java/com/iodsky/sweldox/employee/EmployeeService.java

@@ -25,6 +25,7 @@
 import org.springframework.web.server.ResponseStatusException;
 
 import java.io.IOException;
+import java.time.Instant;
 import java.util.*;
 import java.util.stream.Collectors;
 
@@ -135,10 +136,36 @@ public Employee updateEmployeeById(Long id, EmployeeRequest request) {
         }
     }
 
-    public void deleteEmployeeById(Long id) {
-        employeeRepository.findById(id).ifPresentOrElse(employeeRepository::delete, () -> {
-            throw new ResponseStatusException(HttpStatus.NOT_FOUND, "Employee " + id + " not found");
-        });
+    @Transactional
+    public void deleteEmployeeById(Long id, String status) {
+        Employee employee = getEmployeeById(id);
+        if (employee.isDeleted()) {
+            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Employee already deleted");
+        }
+
+        Status status_;
+        try {
+            status_ = Status.valueOf(status.toUpperCase());
+            if (status_ != Status.TERMINATED && status_ != Status.RESIGNED) {
+                throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Status must be either TERMINATED or RESIGNED");
+            }
+        } catch (IllegalArgumentException e) {
+            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Status must be either TERMINATED or RESIGNED");
+        }
+
+        List<Employee> subordinates = employeeRepository.findAllByEmploymentDetails_Supervisor_Id(employee.getId());
+        if (!subordinates.isEmpty()) {
+            subordinates.forEach(subordinate -> subordinate.getEmploymentDetails().setSupervisor(null));
+            employeeRepository.saveAll(subordinates);
+        }
+
+        employee.setDeletedAt(Instant.now());
+        employee.getEmploymentDetails().setStatus(status_);
+        employee.getEmploymentDetails().setDeletedAt(Instant.now());
+        employee.getCompensation().setDeletedAt(Instant.now());
+        employee.getGovernmentId().setDeletedAt(Instant.now());
+
+        employeeRepository.save(employee);
     }
 
     public List<Long> getAllActiveEmployeeIds() {

src/test/java/com/iodsky/sweldox/employee/EmployeeServiceTest.java

@@ -62,6 +62,9 @@ void setUp() {
         compensation.setBenefits(new ArrayList<>());
         employee.setCompensation(compensation);
 
+        GovernmentId governmentId = new GovernmentId();
+        employee.setGovernmentId(governmentId);
+
         request = new EmployeeRequest();
         EmploymentDetailsRequest reqDetails = new EmploymentDetailsRequest();
         reqDetails.setDepartmentId("DEP001");
@@ -280,20 +283,43 @@ class DeleteEmployeeTests {
         @Test
         void shouldDeleteEmployeeSuccessfully() {
             when(employeeRepository.findById(1L)).thenReturn(Optional.of(employee));
+            when(employeeRepository.save(any(Employee.class))).thenReturn(employee);
 
-            employeeService.deleteEmployeeById(1L);
+            employeeService.deleteEmployeeById(1L, "TERMINATED");
 
-            verify(employeeRepository).delete(employee);
+            verify(employeeRepository).save(employee);
+            assertNotNull(employee.getDeletedAt());
         }
 
         @Test
         void shouldThrowNotFoundWhenDeletingNonexistentEmployee() {
             when(employeeRepository.findById(1L)).thenReturn(Optional.empty());
 
             ResponseStatusException ex = assertThrows(ResponseStatusException.class,
-                    () -> employeeService.deleteEmployeeById(1L));
+                    () -> employeeService.deleteEmployeeById(1L, "RESIGNED"));
 
             assertEquals(HttpStatus.NOT_FOUND, ex.getStatusCode());
         }
+
+        @Test
+        void shouldThrowBadRequestWhenDeletingAlreadyDeletedEmployee() {
+            employee.setDeletedAt(java.time.Instant.now());
+            when(employeeRepository.findById(1L)).thenReturn(Optional.of(employee));
+
+            ResponseStatusException ex = assertThrows(ResponseStatusException.class,
+                    () -> employeeService.deleteEmployeeById(1L, "TERMINATED"));
+
+            assertEquals(HttpStatus.BAD_REQUEST, ex.getStatusCode());
+        }
+
+        @Test
+        void shouldThrowBadRequestWhenStatusIsInvalid() {
+            when(employeeRepository.findById(1L)).thenReturn(Optional.of(employee));
+
+            ResponseStatusException ex = assertThrows(ResponseStatusException.class,
+                    () -> employeeService.deleteEmployeeById(1L, "ACTIVE"));
+
+            assertEquals(HttpStatus.BAD_REQUEST, ex.getStatusCode());
+        }
     }
 }