Initial deployment of da-autodelete-dev

Dockerfile

@@ -0,0 +1,27 @@
+FROM openjdk:21-jdk-slim
+
+WORKDIR /app
+
+# Install required packages
+RUN apt-get update && apt-get install -y \
+    curl \
+    wget \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy application files
+COPY . .
+
+# Build application (if build.gradle.kts exists)
+RUN if [ -f "build.gradle.kts" ]; then \
+        ./gradlew build -x test; \
+    fi
+
+# Expose port
+EXPOSE 8080
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
+    CMD curl -f http://localhost:8080/actuator/health || exit 1
+
+# Run application
+CMD ["java", "-jar", "build/libs/da-autodelete.jar"]

README.md

@@ -1,10 +1,38 @@
 ---
-title: Da Autodelete Dev
-emoji: 🏃
+title: da-autodelete (dev)
+emoji: 🔧
 colorFrom: blue
-colorTo: gray
+colorTo: green
 sdk: docker
-pinned: false
+app_port: 8080
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# da-autodelete - dev Environment
+
+This is the da-autodelete microservice deployed in the dev environment.
+
+## Features
+
+- RESTful API endpoints
+- Health monitoring via Actuator
+- JWT authentication integration
+- PostgreSQL database connectivity
+
+## API Documentation
+
+Once deployed, API documentation will be available at:
+- Swagger UI: https://huggingface.co/spaces/dalabsai/da-autodelete-dev/swagger-ui.html
+- Health Check: https://huggingface.co/spaces/dalabsai/da-autodelete-dev/actuator/health
+
+## Environment
+
+- **Environment**: dev
+- **Port**: 8080
+- **Java Version**: 21
+- **Framework**: Spring Boot
+
+## Deployment
+
+This service is automatically deployed via the DALab CI/CD pipeline.
+
+Last updated: 2025-06-16 23:40:24

build.gradle.kts

@@ -0,0 +1,20 @@
+// da-autodelete inherits common configuration from parent build.gradle.kts
+// This build file adds autodelete-specific dependencies
+
+dependencies {
+    // da-protos common entities and utilities
+    implementation(project(":da-protos"))
+    
+    // Cloud Storage SDKs for deletion operations
+    implementation("software.amazon.awssdk:s3:2.20.162")
+    implementation("com.azure:azure-storage-blob:12.23.0")
+    implementation("com.google.cloud:google-cloud-storage:2.28.0")
+    
+    // Additional dependencies specific to da-autodelete
+    implementation("org.springframework.cloud:spring-cloud-starter-openfeign:4.1.1")
+}
+
+// Configure main application class
+configure<org.springframework.boot.gradle.dsl.SpringBootExtension> {
+    mainClass.set("com.dalab.autodelete.DaAutodeleteApplication")
+} 

src/main/docker/Dockerfile

@@ -0,0 +1,23 @@
+# Ultra-lean container using Google Distroless
+# Expected final size: ~120-180MB (minimal base + JRE + JAR only)
+
+FROM gcr.io/distroless/java21-debian12:nonroot
+
+# Set working directory
+WORKDIR /app
+
+# Copy JAR file
+COPY build/libs/da-autodelete.jar app.jar
+
+# Expose standard Spring Boot port
+EXPOSE 8080
+
+# Run application (distroless has no shell, so use exec form)
+ENTRYPOINT ["java", \
+    "-XX:+UseContainerSupport", \
+    "-XX:MaxRAMPercentage=75.0", \
+    "-XX:+UseG1GC", \
+    "-XX:+UseStringDeduplication", \
+    "-Djava.security.egd=file:/dev/./urandom", \
+    "-Dspring.backgroundpreinitializer.ignore=true", \
+    "-jar", "app.jar"]

src/main/docker/Dockerfile.alpine-jlink

@@ -0,0 +1,43 @@
+# Ultra-minimal Alpine + Custom JRE
+# Expected size: ~120-160MB
+
+# Stage 1: Create custom JRE with only needed modules
+FROM eclipse-temurin:21-jdk-alpine as jre-builder
+WORKDIR /app
+
+# Analyze JAR to find required modules
+COPY build/libs/*.jar app.jar
+RUN jdeps --ignore-missing-deps --print-module-deps app.jar > modules.txt
+
+# Create minimal JRE with only required modules
+RUN jlink \
+    --add-modules $(cat modules.txt),java.logging,java.xml,java.sql,java.naming,java.desktop,java.management,java.security.jgss,java.instrument \
+    --strip-debug \
+    --no-man-pages \
+    --no-header-files \
+    --compress=2 \
+    --output /custom-jre
+
+# Stage 2: Production image
+FROM alpine:3.19
+RUN apk add --no-cache tzdata && \
+    addgroup -g 1001 -S appgroup && \
+    adduser -u 1001 -S appuser -G appgroup
+
+# Copy custom JRE
+COPY --from=jre-builder /custom-jre /opt/java
+ENV JAVA_HOME=/opt/java
+ENV PATH="$JAVA_HOME/bin:$PATH"
+
+WORKDIR /app
+COPY build/libs/*.jar app.jar
+RUN chown appuser:appgroup app.jar
+
+USER appuser
+EXPOSE 8080
+
+ENTRYPOINT ["java", \
+    "-XX:+UseContainerSupport", \
+    "-XX:MaxRAMPercentage=70.0", \
+    "-XX:+UseG1GC", \
+    "-jar", "app.jar"]

src/main/docker/Dockerfile.layered

@@ -0,0 +1,34 @@
+# Ultra-optimized layered build using Distroless
+# Expected size: ~180-220MB with better caching
+
+FROM gcr.io/distroless/java21-debian12:nonroot as base
+
+# Stage 1: Extract JAR layers for optimal caching
+FROM eclipse-temurin:21-jdk-alpine as extractor
+WORKDIR /app
+COPY build/libs/*.jar app.jar
+RUN java -Djarmode=layertools -jar app.jar extract
+
+# Stage 2: Production image with extracted layers
+FROM base
+WORKDIR /app
+
+# Copy layers in dependency order (best caching)
+COPY --from=extractor /app/dependencies/ ./
+COPY --from=extractor /app/spring-boot-loader/ ./
+COPY --from=extractor /app/snapshot-dependencies/ ./
+COPY --from=extractor /app/application/ ./
+
+EXPOSE 8080
+
+# Optimized JVM settings for micro-containers
+ENTRYPOINT ["java", \
+    "-XX:+UseContainerSupport", \
+    "-XX:MaxRAMPercentage=70.0", \
+    "-XX:+UseG1GC", \
+    "-XX:+UseStringDeduplication", \
+    "-XX:+CompactStrings", \
+    "-Xshare:on", \
+    "-Djava.security.egd=file:/dev/./urandom", \
+    "-Dspring.backgroundpreinitializer.ignore=true", \
+    "org.springframework.boot.loader.JarLauncher"]

src/main/docker/Dockerfile.native

@@ -0,0 +1,20 @@
+# GraalVM Native Image - Ultra-fast startup, tiny size
+# Expected size: ~50-80MB, startup <100ms
+# Note: Requires native compilation support in Spring Boot
+
+# Stage 1: Native compilation
+FROM ghcr.io/graalvm/graalvm-ce:ol9-java21 as native-builder
+WORKDIR /app
+
+# Install native-image
+RUN gu install native-image
+
+# Copy source and build native executable
+COPY . .
+RUN ./gradlew nativeCompile
+
+# Stage 2: Minimal runtime
+FROM scratch
+COPY --from=native-builder /app/build/native/nativeCompile/app /app
+EXPOSE 8080
+ENTRYPOINT ["/app"]

src/main/java/com/dalab/autodelete/DaAutodeleteApplication.java

@@ -0,0 +1,35 @@
+package com.dalab.autodelete;
+
+import io.swagger.v3.oas.models.OpenAPI;
+import io.swagger.v3.oas.models.info.Info;
+import io.swagger.v3.oas.models.info.License;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.Bean;
+import org.springframework.scheduling.annotation.EnableAsync;
+import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;
+
+@SpringBootApplication
+@EnableMethodSecurity // For @PreAuthorize annotations
+@EnableAsync // If async operations are needed
+// @EnableFeignClients // If this service will call other services via Feign
+public class DaAutodeleteApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(DaAutodeleteApplication.class, args);
+    }
+
+    @Bean
+    public OpenAPI customOpenAPI(@Value("${spring.application.name:DALab AutoDelete Service}") String appName,
+                               @Value("${spring.application.description:API for AutoDelete Service}") String appDescription,
+                               @Value("${spring.application.version:0.0.1-SNAPSHOT}") String appVersion) {
+        return new OpenAPI()
+                .info(new Info()
+                        .title(appName)
+                        .version(appVersion)
+                        .description(appDescription)
+                        .termsOfService("http://swagger.io/terms/") // Placeholder
+                        .license(new License().name("Apache 2.0").url("http://springdoc.org"))); // Placeholder
+    }
+} 

src/main/java/com/dalab/autodelete/controller/DeletionConfigController.java

@@ -0,0 +1,49 @@
+package com.dalab.autodelete.controller;
+
+import com.dalab.autodelete.dto.DeletionConfigDTO;
+import com.dalab.autodelete.service.IDeletionConfigService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+@RequestMapping("/api/v1/deletion/config")
+@Tag(name = "Deletion Configuration API", description = "APIs for managing auto-deletion configurations")
+@RequiredArgsConstructor
+public class DeletionConfigController {
+
+    private final IDeletionConfigService deletionConfigService;
+
+    @Operation(summary = "Get current deletion configuration",
+               responses = {
+                   @ApiResponse(responseCode = "200", description = "Successfully retrieved configuration"),
+                   @ApiResponse(responseCode = "403", description = "Forbidden if user does not have required role")
+               })
+    @GetMapping
+    @PreAuthorize("hasAnyRole('ADMIN', 'DATA_STEWARD')")
+    public ResponseEntity<DeletionConfigDTO> getDeletionConfiguration() {
+        return ResponseEntity.ok(deletionConfigService.getDeletionConfig());
+    }
+
+    @Operation(summary = "Update deletion configuration",
+               description = "Updates the global auto-deletion configuration. Only ADMINs can perform this.",
+               responses = {
+                   @ApiResponse(responseCode = "200", description = "Configuration updated successfully"),
+                   @ApiResponse(responseCode = "400", description = "Invalid configuration provided"),
+                   @ApiResponse(responseCode = "403", description = "Forbidden if user is not an ADMIN")
+               })
+    @PutMapping
+    @PreAuthorize("hasRole('ADMIN')")
+    public ResponseEntity<Void> updateDeletionConfiguration(@RequestBody DeletionConfigDTO deletionConfigDTO) {
+        try {
+            deletionConfigService.updateDeletionConfig(deletionConfigDTO);
+            return ResponseEntity.ok().build();
+        } catch (IllegalArgumentException e) {
+            return ResponseEntity.badRequest().build();
+        }
+    }
+} 

src/main/java/com/dalab/autodelete/controller/DeletionTaskController.java

@@ -0,0 +1,110 @@
+package com.dalab.autodelete.controller;
+
+import com.dalab.autodelete.dto.*;
+import com.dalab.autodelete.service.IDeletionTaskService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.web.PageableDefault;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+@RequestMapping("/api/v1/deletion/tasks")
+@Tag(name = "Deletion Task API", description = "APIs for managing auto-deletion tasks")
+@RequiredArgsConstructor
+public class DeletionTaskController {
+
+    private final IDeletionTaskService deletionTaskService;
+
+    @Operation(summary = "Submit a new deletion task",
+               responses = {
+                   @ApiResponse(responseCode = "202", description = "Task accepted for processing or approval"),
+                   @ApiResponse(responseCode = "400", description = "Invalid request payload or validation error")
+               })
+    @PostMapping
+    @PreAuthorize("hasAnyRole('ADMIN', 'DATA_STEWARD', 'AUTOMATION_SERVICE')") // AUTOMATION_SERVICE for system-triggered tasks
+    public ResponseEntity<DeletionTaskResponse> submitDeletionTask(@Valid @RequestBody DeletionTaskRequest request) {
+        DeletionTaskResponse response = deletionTaskService.submitDeletionTask(request);
+        if ("FAILED_VALIDATION".equals(response.getStatus())) {
+            return ResponseEntity.badRequest().body(response);
+        }
+        return ResponseEntity.status(HttpStatus.ACCEPTED).body(response);
+    }
+
+    @Operation(summary = "Get deletion task status by ID",
+               responses = {
+                   @ApiResponse(responseCode = "200", description = "Successfully retrieved task status"),
+                   @ApiResponse(responseCode = "404", description = "Task not found")
+               })
+    @GetMapping("/{taskId}")
+    @PreAuthorize("hasAnyRole('ADMIN', 'DATA_STEWARD', 'USER', 'AUTOMATION_SERVICE')") // USER can see their own tasks, need filtering logic in service
+    public ResponseEntity<DeletionTaskStatusDTO> getDeletionTaskStatus(@Parameter(description = "ID of the deletion task") @PathVariable String taskId) {
+        DeletionTaskStatusDTO status = deletionTaskService.getTaskStatus(taskId);
+        if (status == null) {
+            return ResponseEntity.notFound().build();
+        }
+        // TODO: Add logic to check if the authenticated user is allowed to see this task (e.g., if they triggered it)
+        return ResponseEntity.ok(status);
+    }
+
+    @Operation(summary = "List all deletion tasks",
+               description = "Lists deletion tasks with pagination. ADMINs/DATA_STEWARDS see all, others might see a filtered list.")
+    @GetMapping
+    @PreAuthorize("hasAnyRole('ADMIN', 'DATA_STEWARD', 'USER', 'AUTOMATION_SERVICE')")
+    public ResponseEntity<DeletionTaskListResponse> listDeletionTasks(@PageableDefault(size = 20) Pageable pageable) {
+        // TODO: Service layer should handle filtering based on user role (e.g., non-admins see only their tasks)
+        DeletionTaskListResponse response = deletionTaskService.listTasks(pageable);
+        return ResponseEntity.ok(response);
+    }
+
+    @Operation(summary = "Approve a pending deletion task",
+               description = "Only users with ADMIN or DATA_STEWARD role can approve tasks.",
+               responses = {
+                   @ApiResponse(responseCode = "200", description = "Task approved successfully"),
+                   @ApiResponse(responseCode = "404", description = "Task not found"),
+                   @ApiResponse(responseCode = "409", description = "Task is not in a state that can be approved")
+               })
+    @PostMapping("/{taskId}/approve")
+    @PreAuthorize("hasAnyRole('ADMIN', 'DATA_STEWARD')")
+    public ResponseEntity<DeletionTaskStatusDTO> approveDeletionTask(
+            @Parameter(description = "ID of the task to approve") @PathVariable String taskId,
+            @RequestBody(required = false) TaskApprovalRequest approvalRequest) {
+        DeletionTaskStatusDTO status = deletionTaskService.approveTask(taskId, approvalRequest);
+        if (status == null) { // Should be handled by an exception in a real service normally
+            return ResponseEntity.notFound().build();
+        }
+        if (status.getErrorMessages() != null && !status.getErrorMessages().isEmpty()) {
+            return ResponseEntity.status(HttpStatus.CONFLICT).body(status);
+        }
+        return ResponseEntity.ok(status);
+    }
+
+    @Operation(summary = "Reject a pending deletion task",
+            description = "Only users with ADMIN or DATA_STEWARD role can reject tasks.",
+            responses = {
+                    @ApiResponse(responseCode = "200", description = "Task rejected successfully"),
+                    @ApiResponse(responseCode = "404", description = "Task not found"),
+                    @ApiResponse(responseCode = "409", description = "Task is not in a state that can be rejected")
+            })
+    @PostMapping("/{taskId}/reject")
+    @PreAuthorize("hasAnyRole('ADMIN', 'DATA_STEWARD')")
+    public ResponseEntity<DeletionTaskStatusDTO> rejectDeletionTask(
+            @Parameter(description = "ID of the task to reject") @PathVariable String taskId,
+            @RequestBody(required = false) TaskApprovalRequest rejectionRequest) {
+        DeletionTaskStatusDTO status = deletionTaskService.rejectTask(taskId, rejectionRequest);
+        if (status == null) { // Should be handled by an exception
+            return ResponseEntity.notFound().build();
+        }
+        if (status.getErrorMessages() != null && !status.getErrorMessages().isEmpty()) {
+            return ResponseEntity.status(HttpStatus.CONFLICT).body(status);
+        }
+        return ResponseEntity.ok(status);
+    }
+} 

src/main/java/com/dalab/autodelete/dto/DeletionConfigDTO.java

@@ -0,0 +1,30 @@
+package com.dalab.autodelete.dto;
+
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.AllArgsConstructor;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * DTO for representing the auto-deletion configuration.
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class DeletionConfigDTO {
+
+    private Boolean enabled; // Global enable/disable for auto-deletion
+    private boolean softDeleteByDefault; // If true, performs a soft delete (marks as deleted)
+    private Long defaultSoftDeleteRetentionDays; // If soft-deleted, how long before permanent deletion (if applicable)
+    private boolean requireApprovalForHardDelete; // If manual approval is needed for permanent (hard) deletion
+    private boolean requireApprovalForSoftDelete; // If manual approval is needed for soft deletion
+
+    // Could define specific deletion strategies or grace periods per data source type or classification
+    // For example: Map<String, DeletionStrategy> deletionStrategies;
+    // DeletionStrategy could include things like: immediate, after X days, notify and wait, etc.
+    private List<String> notificationEmailsOnError; // Who to notify if deletion task fails critically
+} 

src/main/java/com/dalab/autodelete/dto/DeletionTaskListResponse.java

@@ -0,0 +1,40 @@
+package com.dalab.autodelete.dto;
+
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.AllArgsConstructor;
+import org.springframework.data.domain.Page;
+
+import java.util.List;
+
+/**
+ * DTO for a paginated list of deletion task statuses.
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class DeletionTaskListResponse {
+    private List<DeletionTaskStatusDTO> tasks;
+    private int pageNumber;
+    private int pageSize;
+    private long totalElements;
+    private int totalPages;
+    private boolean first;
+    private boolean last;
+    private int numberOfElements;
+
+    public static DeletionTaskListResponse fromPage(Page<DeletionTaskStatusDTO> page) {
+        return DeletionTaskListResponse.builder()
+                .tasks(page.getContent())
+                .pageNumber(page.getNumber())
+                .pageSize(page.getSize())
+                .totalElements(page.getTotalElements())
+                .totalPages(page.getTotalPages())
+                .first(page.isFirst())
+                .last(page.isLast())
+                .numberOfElements(page.getNumberOfElements())
+                .build();
+    }
+} 

src/main/java/com/dalab/autodelete/dto/DeletionTaskRequest.java

@@ -0,0 +1,58 @@
+package com.dalab.autodelete.dto;
+
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.AllArgsConstructor;
+
+import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
+import java.util.List;
+
+/**
+ * DTO for requesting a new deletion task.
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class DeletionTaskRequest {
+
+    @Size(max = 255, message = "Task name cannot exceed 255 characters.")
+    private String taskName; // Optional friendly name for the task
+
+    @NotNull(message = "Deletion scope cannot be null.")
+    private DeletionScope scope;
+
+    private String triggeredBy; // User or system that triggered the task
+    private String justification; // Reason for deletion
+
+    private DeletionConfigOverride overrideConfig; // Optional config overrides for this specific task
+
+    /**
+     * Defines the scope of assets to be deleted.
+     */
+    @Data
+    @Builder
+    @NoArgsConstructor
+    @AllArgsConstructor
+    public static class DeletionScope {
+        @NotEmpty(message = "At least one asset ID must be provided for deletion.")
+        private List<String> assetIds; // List of asset IDs to delete
+        // Could also include criteria like tags, creation date ranges, etc.
+    }
+
+    /**
+     * Allows overriding global deletion settings for this specific task.
+     */
+    @Data
+    @Builder
+    @NoArgsConstructor
+    @AllArgsConstructor
+    public static class DeletionConfigOverride {
+        private Boolean softDelete; // Override global soft-delete setting
+        private Long softDeleteRetentionDays; // Override retention if soft-deleting
+        private Boolean requireApproval; // Override approval requirement for this task
+    }
+} 

src/main/java/com/dalab/autodelete/dto/DeletionTaskResponse.java

@@ -0,0 +1,23 @@
+package com.dalab.autodelete.dto;
+
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.AllArgsConstructor;
+
+import java.time.LocalDateTime;
+
+/**
+ * DTO representing the response after submitting a deletion task.
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class DeletionTaskResponse {
+    private String taskId;
+    private String taskName;
+    private String status; // e.g., PENDING_APPROVAL, SUBMITTED, FAILED_VALIDATION
+    private LocalDateTime submittedAt;
+    private String message; // Any relevant message, e.g., reason for validation failure
+} 

src/main/java/com/dalab/autodelete/dto/DeletionTaskStatusDTO.java

@@ -0,0 +1,42 @@
+package com.dalab.autodelete.dto;
+
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.AllArgsConstructor;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+/**
+ * DTO for representing the detailed status of a deletion task.
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class DeletionTaskStatusDTO {
+    private String taskId;
+    private String taskName;
+    private String status; // PENDING_APPROVAL, APPROVED, REJECTED, SUBMITTED, IN_PROGRESS, COMPLETED, FAILED, PARTIALLY_COMPLETED
+    private LocalDateTime submittedAt;
+    private LocalDateTime startedAt;
+    private LocalDateTime completedAt;
+    private String triggeredBy;
+    private String justification;
+
+    private DeletionTaskRequest.DeletionScope scope; // Original scope
+    private DeletionTaskRequest.DeletionConfigOverride overrideConfig; // Applied overrides
+
+    private int totalAssetsInScope;
+    private int assetsProcessedSuccessfully;
+    private int assetsFailedToProcess;
+    private int assetsPendingProcessing;
+
+    // Could add a list of individual asset statuses if needed for detailed view
+    // private List<AssetDeletionStatus> assetStatuses;
+
+    private String approvalComments;
+    private String rejectionComments;
+    private List<String> errorMessages;
+} 

src/main/java/com/dalab/autodelete/dto/TaskApprovalRequest.java

@@ -0,0 +1,20 @@
+package com.dalab.autodelete.dto;
+
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.AllArgsConstructor;
+
+import jakarta.validation.constraints.Size;
+
+/**
+ * DTO for providing comments during task approval or rejection.
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class TaskApprovalRequest {
+    @Size(max = 1000, message = "Comments cannot exceed 1000 characters.")
+    private String comments;
+} 

src/main/java/com/dalab/autodelete/exception/DeletionException.java

@@ -0,0 +1,15 @@
+package com.dalab.autodelete.exception;
+
+/**
+ * Custom exception for errors occurring during deletion operations.
+ */
+public class DeletionException extends Exception {
+
+    public DeletionException(String message) {
+        super(message);
+    }
+
+    public DeletionException(String message, Throwable cause) {
+        super(message, cause);
+    }
+} 

src/main/java/com/dalab/autodelete/mapper/DeletionConfigMapper.java

@@ -0,0 +1,21 @@
+package com.dalab.autodelete.mapper;
+
+import com.dalab.autodelete.dto.DeletionConfigDTO;
+import com.dalab.autodelete.model.DeletionConfigEntity;
+import org.mapstruct.Mapper;
+import org.mapstruct.MappingTarget;
+import org.mapstruct.NullValuePropertyMappingStrategy;
+import org.mapstruct.factory.Mappers;
+
+@Mapper(componentModel = "spring",
+        nullValuePropertyMappingStrategy = NullValuePropertyMappingStrategy.IGNORE)
+public interface DeletionConfigMapper {
+
+    DeletionConfigMapper INSTANCE = Mappers.getMapper(DeletionConfigMapper.class);
+
+    DeletionConfigDTO toDto(DeletionConfigEntity entity);
+
+    DeletionConfigEntity toEntity(DeletionConfigDTO dto);
+
+    void updateEntityFromDto(DeletionConfigDTO dto, @MappingTarget DeletionConfigEntity entity);
+} 

src/main/java/com/dalab/autodelete/mapper/DeletionTaskMapper.java

@@ -0,0 +1,50 @@
+package com.dalab.autodelete.mapper;
+
+import com.dalab.autodelete.dto.DeletionTaskRequest;
+import com.dalab.autodelete.dto.DeletionTaskResponse;
+import com.dalab.autodelete.dto.DeletionTaskStatusDTO;
+import com.dalab.autodelete.model.DeletionTaskEntity;
+import org.mapstruct.Mapper;
+import org.mapstruct.Mapping;
+import org.mapstruct.NullValuePropertyMappingStrategy;
+import org.mapstruct.factory.Mappers;
+
+@Mapper(componentModel = "spring",
+        nullValuePropertyMappingStrategy = NullValuePropertyMappingStrategy.IGNORE)
+public interface DeletionTaskMapper {
+
+    DeletionTaskMapper INSTANCE = Mappers.getMapper(DeletionTaskMapper.class);
+
+    // From Request DTO to Entity
+    @Mapping(target = "taskId", ignore = true) // taskId is generated in service
+    @Mapping(target = "status", ignore = true) // status is set in service
+    @Mapping(target = "submittedAt", ignore = true)
+    @Mapping(target = "startedAt", ignore = true)
+    @Mapping(target = "completedAt", ignore = true)
+    @Mapping(target = "totalAssetsInScope", ignore = true)
+    @Mapping(target = "assetsProcessedSuccessfully", ignore = true)
+    @Mapping(target = "assetsFailedToProcess", ignore = true)
+    @Mapping(target = "assetsPendingProcessing", ignore = true)
+    @Mapping(target = "assetStatuses", ignore = true)
+    @Mapping(target = "errorMessages", ignore = true)
+    @Mapping(target = "approvalComments", ignore = true)
+    @Mapping(target = "rejectionComments", ignore = true)
+    DeletionTaskEntity requestToEntity(DeletionTaskRequest requestDto);
+
+    // From Entity to Response DTO (simple initial response)
+    DeletionTaskResponse entityToTaskResponse(DeletionTaskEntity entity);
+
+    // From Entity to Status DTO (detailed status)
+    DeletionTaskStatusDTO entityToStatusDTO(DeletionTaskEntity entity);
+
+    // For mapping nested DTOs to nested Entity data classes (if not automatically handled by MapStruct)
+    DeletionTaskEntity.DeletionScopeData scopeDtoToData(DeletionTaskRequest.DeletionScope scopeDto);
+    DeletionTaskRequest.DeletionScope scopeDataToDto(DeletionTaskEntity.DeletionScopeData scopeData);
+
+    DeletionTaskEntity.DeletionConfigOverrideData overrideDtoToData(DeletionTaskRequest.DeletionConfigOverride overrideDto);
+    DeletionTaskRequest.DeletionConfigOverride overrideDataToDto(DeletionTaskEntity.DeletionConfigOverrideData overrideData);
+    
+    // If AssetDeletionStatusData needs explicit mapping (often MapStruct handles lists of identical beans)
+    // List<DeletionTaskEntity.AssetDeletionStatusData> assetStatusDtoListToDataList(List<AssetDeletionStatusDTO> dtoList);
+    // List<AssetDeletionStatusDTO> assetStatusDataListToDtoList(List<DeletionTaskEntity.AssetDeletionStatusData> dataList);
+} 

src/main/java/com/dalab/autodelete/model/DeletionConfigEntity.java

@@ -0,0 +1,40 @@
+package com.dalab.autodelete.model;
+
+import jakarta.persistence.*;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.AllArgsConstructor;
+// import org.hibernate.annotations.JdbcTypeCode; // Not needed if not using complex JSON types directly here
+// import org.hibernate.type.SqlTypes;
+
+import java.util.List;
+
+@Entity
+@Table(name = "dalab_deletion_config")
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class DeletionConfigEntity {
+
+    @Id
+    private Long id; // Use a fixed ID, e.g., 1L, as it's a global config
+
+    private boolean enabled;
+    private boolean softDeleteByDefault;
+    private Long defaultSoftDeleteRetentionDays;
+    private boolean requireApprovalForHardDelete;
+    private boolean requireApprovalForSoftDelete;
+
+    @ElementCollection(fetch = FetchType.EAGER) // Store as a collection of strings
+    @CollectionTable(name = "dalab_deletion_config_notification_emails", joinColumns = @JoinColumn(name = "config_id"))
+    @Column(name = "email")
+    private List<String> notificationEmailsOnError;
+
+    // If you add more complex configurations like per-provider or per-tag rules that are better stored as JSON,
+    // you can use @JdbcTypeCode(SqlTypes.JSON) similar to da-autoarchival's ProviderConfigData.
+    // For example:
+    // @JdbcTypeCode(SqlTypes.JSON)
+    // @Column(columnDefinition = "jsonb")
+    // private Map<String, DeletionStrategyData> deletionStrategies; 
+    // public static class DeletionStrategyData { /* fields */ }
+} 

src/main/java/com/dalab/autodelete/model/DeletionResult.java

@@ -0,0 +1,28 @@
+package com.dalab.autodelete.model;
+
+import java.time.OffsetDateTime;
+
+public class DeletionResult {
+
+    private boolean success;
+    private String message; // e.g., "Object deleted successfully" or error details
+    private OffsetDateTime completionTimestamp;
+    private long itemsDeleted; // Useful for folder deletions
+
+    public DeletionResult(boolean success, String message, long itemsDeleted) {
+        this.success = success;
+        this.message = message;
+        this.itemsDeleted = itemsDeleted;
+        this.completionTimestamp = OffsetDateTime.now();
+    }
+
+    // Getters and Setters
+    public boolean isSuccess() { return success; }
+    public void setSuccess(boolean success) { this.success = success; }
+    public String getMessage() { return message; }
+    public void setMessage(String message) { this.message = message; }
+    public OffsetDateTime getCompletionTimestamp() { return completionTimestamp; }
+    public void setCompletionTimestamp(OffsetDateTime completionTimestamp) { this.completionTimestamp = completionTimestamp; }
+    public long getItemsDeleted() { return itemsDeleted; }
+    public void setItemsDeleted(long itemsDeleted) { this.itemsDeleted = itemsDeleted; }
+} 

src/main/java/com/dalab/autodelete/model/DeletionStatus.java

@@ -0,0 +1,14 @@
+package com.dalab.autodelete.model;
+
+public enum DeletionStatus {
+    PENDING_APPROVAL, // Task is awaiting approval before execution
+    APPROVED,         // Task has been approved and is ready for processing
+    REJECTED,         // Task has been rejected and will not be processed
+    SUBMITTED,        // Task submitted directly (no approval needed) or post-approval, ready for queue
+    QUEUED,           // Task is in the processing queue
+    IN_PROGRESS,      // Task execution is actively in progress
+    COMPLETED,        // Task completed successfully (all assets processed)
+    PARTIALLY_COMPLETED, // Task completed, but some assets failed to delete
+    FAILED,           // Task failed entirely or due to a critical error
+    CANCELLED         // Task was cancelled before completion
+} 

src/main/java/com/dalab/autodelete/model/DeletionTask.java

@@ -0,0 +1,78 @@
+package com.dalab.autodelete.model;
+
+import java.time.OffsetDateTime;
+import java.util.Map;
+
+public class DeletionTask {
+
+    private String taskId;
+    private String assetId; // ID of the asset in the catalog that this deletion task refers to
+    private String gcpProjectId; // GCP Project ID where the resource resides
+    private GcpResourceType resourceType; // GCS_OBJECT, GCS_FOLDER, BIGQUERY_TABLE
+
+    // For GCS
+    private String gcsBucketName;
+    private String gcsObjectPath; // Full path for object, or prefix for folder
+
+    // For BigQuery
+    private String bqDatasetId;
+    private String bqTableId;
+
+    private DeletionStatus status;
+    private OffsetDateTime lastAttemptedAt;
+    private OffsetDateTime completedAt;
+    private String failureReason;
+
+    // Configuration specific to this deletion operation, if any (e.g., force delete)
+    private Map<String, String> operationConfig;
+
+
+    public enum GcpResourceType {
+        GCS_BUCKET, 
+        GCS_OBJECT,
+        GCS_FOLDER, 
+        BIGQUERY_DATASET, 
+        BIGQUERY_TABLE
+    }
+
+    public enum DeletionStatus {
+        PENDING,
+        IN_PROGRESS,
+        COMPLETED,
+        FAILED,
+        REQUIRES_APPROVAL 
+    }
+
+    // Constructors, Getters, Setters
+    public DeletionTask(String taskId, String assetId) {
+        this.taskId = taskId;
+        this.assetId = assetId;
+    }
+
+    public String getTaskId() { return taskId; }
+    public void setTaskId(String taskId) { this.taskId = taskId; }
+    public String getAssetId() { return assetId; }
+    public void setAssetId(String assetId) { this.assetId = assetId; }
+    public String getGcpProjectId() { return gcpProjectId; }
+    public void setGcpProjectId(String gcpProjectId) { this.gcpProjectId = gcpProjectId; }
+    public GcpResourceType getResourceType() { return resourceType; }
+    public void setResourceType(GcpResourceType resourceType) { this.resourceType = resourceType; }
+    public String getGcsBucketName() { return gcsBucketName; }
+    public void setGcsBucketName(String gcsBucketName) { this.gcsBucketName = gcsBucketName; }
+    public String getGcsObjectPath() { return gcsObjectPath; }
+    public void setGcsObjectPath(String gcsObjectPath) { this.gcsObjectPath = gcsObjectPath; }
+    public String getBqDatasetId() { return bqDatasetId; }
+    public void setBqDatasetId(String bqDatasetId) { this.bqDatasetId = bqDatasetId; }
+    public String getBqTableId() { return bqTableId; }
+    public void setBqTableId(String bqTableId) { this.bqTableId = bqTableId; }
+    public DeletionStatus getStatus() { return status; }
+    public void setStatus(DeletionStatus status) { this.status = status; }
+    public Map<String, String> getOperationConfig() { return operationConfig; }
+    public void setOperationConfig(Map<String, String> operationConfig) { this.operationConfig = operationConfig; }
+    public OffsetDateTime getLastAttemptedAt() { return lastAttemptedAt; }
+    public void setLastAttemptedAt(OffsetDateTime lastAttemptedAt) { this.lastAttemptedAt = lastAttemptedAt; }
+    public OffsetDateTime getCompletedAt() { return completedAt; }
+    public void setCompletedAt(OffsetDateTime completedAt) { this.completedAt = completedAt; }
+    public String getFailureReason() { return failureReason; }
+    public void setFailureReason(String failureReason) { this.failureReason = failureReason; }
+} 

src/main/java/com/dalab/autodelete/model/DeletionTaskEntity.java

@@ -0,0 +1,83 @@
+package com.dalab.autodelete.model;
+
+import jakarta.persistence.*;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.AllArgsConstructor;
+import org.hibernate.annotations.JdbcTypeCode;
+import org.hibernate.type.SqlTypes;
+
+import java.time.LocalDateTime;
+import java.util.List;
+// import java.util.Map; // If using Map for complex JSON fields
+
+@Entity
+@Table(name = "dalab_deletion_tasks")
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class DeletionTaskEntity {
+
+    @Id
+    private String taskId;
+
+    private String taskName;
+
+    @Enumerated(EnumType.STRING)
+    private DeletionStatus status;
+
+    private LocalDateTime submittedAt;
+    private LocalDateTime startedAt;
+    private LocalDateTime completedAt;
+
+    private String triggeredBy;
+    private String justification;
+
+    @JdbcTypeCode(SqlTypes.JSON)
+    @Column(columnDefinition = "jsonb")
+    private DeletionScopeData scope; // Store as JSON
+
+    @JdbcTypeCode(SqlTypes.JSON)
+    @Column(columnDefinition = "jsonb")
+    private DeletionConfigOverrideData overrideConfig; // Store as JSON
+
+    private int totalAssetsInScope;
+    private int assetsProcessedSuccessfully;
+    private int assetsFailedToProcess;
+    private int assetsPendingProcessing;
+
+    @JdbcTypeCode(SqlTypes.JSON)
+    @Column(columnDefinition = "jsonb")
+    private List<AssetDeletionStatusData> assetStatuses; // Store detailed asset status as JSON
+
+    @JdbcTypeCode(SqlTypes.JSON)
+    @Column(columnDefinition = "jsonb")
+    private List<String> errorMessages; // Store task-level error messages as JSON
+    
+    private String approvalComments;
+    private String rejectionComments;
+
+    // Static inner classes for JSONB data structures
+    @Data @NoArgsConstructor @AllArgsConstructor
+    public static class DeletionScopeData {
+        private List<String> assetIds;
+        // Potentially add other criteria here like tags, patterns etc.
+    }
+
+    @Data @NoArgsConstructor @AllArgsConstructor
+    public static class DeletionConfigOverrideData {
+        private Boolean softDelete;
+        private Long softDeleteRetentionDays;
+        private Boolean requireApproval;
+    }
+
+    @Data @NoArgsConstructor @AllArgsConstructor
+    public static class AssetDeletionStatusData {
+        private String assetId;
+        private String assetName; // Optional, for easier reporting
+        private String status; // e.g., PENDING, SOFT_DELETED, HARD_DELETED, FAILED
+        private String deletionType; // SOFT, HARD
+        private String errorMessage;
+        private LocalDateTime processedAt;
+    }
+} 

src/main/java/com/dalab/autodelete/provider/GcpDeletionProvider.java

@@ -0,0 +1,45 @@
+package com.dalab.autodelete.provider;
+
+import java.util.Map;
+
+import org.springframework.stereotype.Component;
+
+import com.dalab.autodelete.exception.DeletionException;
+import com.dalab.autodelete.model.DeletionResult;
+import com.dalab.autodelete.model.DeletionTask;
+
+@Component // Or configure as a bean
+public class GcpDeletionProvider implements IGcpDeletionProvider {
+
+    private static final String NOT_IMPLEMENTED_MESSAGE = "GCP deletion feature is not yet implemented for this resource type.";
+
+    @Override
+    public DeletionResult deleteGcsObject(DeletionTask task, Map<String, String> providerConfig) throws DeletionException {
+        // TODO: Implement GCS object deletion
+        // 1. Get GCS client (com.google.cloud.storage.Storage)
+        // 2. Use task.getGcsBucketName(), task.getGcsObjectPath()
+        // 3. Call storage.delete(bucketName, objectPath)
+        // 4. Return DeletionResult
+        throw new DeletionException(String.format("GCS object deletion for '%s/%s' not yet implemented.", task.getGcsBucketName(), task.getGcsObjectPath()));
+    }
+
+    @Override
+    public DeletionResult deleteGcsFolder(DeletionTask task, Map<String, String> providerConfig) throws DeletionException {
+        // TODO: Implement GCS folder deletion (iterating and deleting objects with prefix)
+        // 1. Get GCS client
+        // 2. List objects with prefix task.getGcsObjectPath() in bucket task.getGcsBucketName()
+        // 3. Delete each object found
+        // 4. Return DeletionResult with count of items deleted
+        throw new DeletionException(String.format("GCS folder deletion for prefix '%s' in bucket '%s' not yet implemented.", task.getGcsObjectPath(), task.getGcsBucketName()));
+    }
+
+    @Override
+    public DeletionResult deleteBigQueryTable(DeletionTask task, Map<String, String> providerConfig) throws DeletionException {
+        // TODO: Implement BigQuery table deletion
+        // 1. Get BigQuery client (com.google.cloud.bigquery.BigQuery)
+        // 2. Use task.getGcpProjectId(), task.getBqDatasetId(), task.getBqTableId()
+        // 3. Call bigquery.delete(TableId.of(projectId, datasetId, tableId))
+        // 4. Return DeletionResult
+        throw new DeletionException(String.format("BigQuery table deletion for '%s:%s.%s' not yet implemented.", task.getGcpProjectId(), task.getBqDatasetId(), task.getBqTableId()));
+    }
+} 

src/main/java/com/dalab/autodelete/provider/IGcpDeletionProvider.java

@@ -0,0 +1,43 @@
+package com.dalab.autodelete.provider;
+
+import java.util.Map;
+
+import com.dalab.autodelete.exception.DeletionException;
+import com.dalab.autodelete.model.DeletionResult;
+import com.dalab.autodelete.model.DeletionTask;
+
+/**
+ * Interface for GCP-specific deletion operations.
+ */
+public interface IGcpDeletionProvider {
+
+    String PROVIDER_TYPE = "GCP"; // Constant for provider type
+
+    /**
+     * Deletes a GCS object.
+     * @param task Details of the deletion task, including bucket and object path.
+     * @param providerConfig Provider-specific configurations (e.g., credentials, project if not in task).
+     * @return Result of the deletion operation.
+     * @throws DeletionException if an error occurs.
+     */
+    DeletionResult deleteGcsObject(DeletionTask task, Map<String, String> providerConfig) throws DeletionException;
+
+    /**
+     * Deletes a GCS "folder" (objects with a common prefix).
+     * @param task Details of the deletion task, including bucket and folder prefix.
+     * @param providerConfig Provider-specific configurations.
+     * @return Result of the deletion operation, potentially including count of deleted objects.
+     * @throws DeletionException if an error occurs.
+     */
+    DeletionResult deleteGcsFolder(DeletionTask task, Map<String, String> providerConfig) throws DeletionException;
+
+    /**
+     * Deletes a BigQuery table.
+     * @param task Details of the deletion task, including dataset and table ID.
+     * @param providerConfig Provider-specific configurations.
+     * @return Result of the deletion operation.
+     * @throws DeletionException if an error occurs.
+     */
+    DeletionResult deleteBigQueryTable(DeletionTask task, Map<String, String> providerConfig) throws DeletionException;
+
+} 

src/main/java/com/dalab/autodelete/repository/DeletionConfigRepository.java

@@ -0,0 +1,11 @@
+package com.dalab.autodelete.repository;
+
+import com.dalab.autodelete.model.DeletionConfigEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface DeletionConfigRepository extends JpaRepository<DeletionConfigEntity, Long> {
+    // Global config with fixed ID (1L), specific find methods likely not needed.
+    // findById(1L) will be used.
+} 

src/main/java/com/dalab/autodelete/repository/DeletionTaskRepository.java

@@ -0,0 +1,12 @@
+package com.dalab.autodelete.repository;
+
+import com.dalab.autodelete.model.DeletionTaskEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface DeletionTaskRepository extends JpaRepository<DeletionTaskEntity, String> {
+    // Custom query methods can be added here if needed, e.g.:
+    // List<DeletionTaskEntity> findByStatus(com.dalab.autodelete.model.DeletionStatus status);
+    // Page<DeletionTaskEntity> findByTriggeredBy(String triggeredBy, org.springframework.data.domain.Pageable pageable);
+} 

src/main/java/com/dalab/autodelete/service/IDeletionConfigService.java

@@ -0,0 +1,18 @@
+package com.dalab.autodelete.service;
+
+import com.dalab.autodelete.dto.DeletionConfigDTO;
+
+public interface IDeletionConfigService {
+
+    /**
+     * Retrieves the current deletion configuration.
+     * @return The current DeletionConfigDTO.
+     */
+    DeletionConfigDTO getDeletionConfig();
+
+    /**
+     * Updates the deletion configuration.
+     * @param deletionConfigDTO The new configuration to apply.
+     */
+    void updateDeletionConfig(DeletionConfigDTO deletionConfigDTO);
+} 

src/main/java/com/dalab/autodelete/service/IDeletionTaskService.java

@@ -0,0 +1,48 @@
+package com.dalab.autodelete.service;
+
+import com.dalab.autodelete.dto.DeletionTaskRequest;
+import com.dalab.autodelete.dto.DeletionTaskResponse;
+import com.dalab.autodelete.dto.DeletionTaskStatusDTO;
+import com.dalab.autodelete.dto.DeletionTaskListResponse;
+import com.dalab.autodelete.dto.TaskApprovalRequest;
+import org.springframework.data.domain.Pageable;
+
+public interface IDeletionTaskService {
+
+    /**
+     * Submits a new task for asset deletion.
+     * @param request The deletion task request details.
+     * @return A response containing the task ID and initial status.
+     */
+    DeletionTaskResponse submitDeletionTask(DeletionTaskRequest request);
+
+    /**
+     * Retrieves the status of a specific deletion task.
+     * @param taskId The ID of the task.
+     * @return The status DTO of the task, or null if not found.
+     */
+    DeletionTaskStatusDTO getTaskStatus(String taskId);
+
+    /**
+     * Lists all deletion tasks with pagination.
+     * @param pageable Pagination information.
+     * @return A paginated list of task statuses.
+     */
+    DeletionTaskListResponse listTasks(Pageable pageable);
+
+    /**
+     * Approves a pending deletion task.
+     * @param taskId The ID of the task to approve.
+     * @param approvalRequest Details for the approval (e.g., comments).
+     * @return The updated status DTO of the task.
+     */
+    DeletionTaskStatusDTO approveTask(String taskId, TaskApprovalRequest approvalRequest);
+
+    /**
+     * Rejects a pending deletion task.
+     * @param taskId The ID of the task to reject.
+     * @param rejectionRequest Details for the rejection (e.g., comments).
+     * @return The updated status DTO of the task.
+     */
+    DeletionTaskStatusDTO rejectTask(String taskId, TaskApprovalRequest rejectionRequest);
+} 

src/main/java/com/dalab/autodelete/service/exception/DeletionTaskNotFoundException.java

@@ -0,0 +1,15 @@
+package com.dalab.autodelete.service.exception;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.web.bind.annotation.ResponseStatus;
+
+@ResponseStatus(HttpStatus.NOT_FOUND)
+public class DeletionTaskNotFoundException extends RuntimeException {
+    public DeletionTaskNotFoundException(String taskId, String operation) {
+        super(String.format("Deletion task with ID '%s' not found for operation: %s", taskId, operation));
+    }
+
+    public DeletionTaskNotFoundException(String taskId) {
+        super(String.format("Deletion task with ID '%s' not found.", taskId));
+    }
+} 

src/main/java/com/dalab/autodelete/service/impl/DeletionConfigServiceImpl.java

@@ -0,0 +1,84 @@
+package com.dalab.autodelete.service.impl;
+
+import com.dalab.autodelete.dto.DeletionConfigDTO;
+import com.dalab.autodelete.mapper.DeletionConfigMapper;
+import com.dalab.autodelete.model.DeletionConfigEntity;
+import com.dalab.autodelete.repository.DeletionConfigRepository;
+import com.dalab.autodelete.service.IDeletionConfigService;
+import jakarta.annotation.PostConstruct;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.ArrayList;
+import java.util.Optional;
+
+@Service("deletionConfigService") // Explicit bean name to distinguish from potential in-memory version
+@RequiredArgsConstructor
+@Slf4j
+public class DeletionConfigServiceImpl implements IDeletionConfigService {
+
+    private final DeletionConfigRepository configRepository;
+    private final DeletionConfigMapper configMapper;
+    private static final Long GLOBAL_CONFIG_ID = 1L;
+
+    @PostConstruct
+    @Transactional
+    public void init() {
+        // Ensure a default config exists if the DB is empty for this service
+        if (!configRepository.existsById(GLOBAL_CONFIG_ID)) {
+            log.info("No global deletion configuration found. Initializing with default values.");
+            DeletionConfigEntity defaultConfig = new DeletionConfigEntity(
+                    GLOBAL_CONFIG_ID,
+                    false, // enabled
+                    true,  // softDeleteByDefault
+                    30L,   // defaultSoftDeleteRetentionDays
+                    true,  // requireApprovalForHardDelete
+                    false, // requireApprovalForSoftDelete
+                    new ArrayList<>() // notificationEmailsOnError
+            );
+            configRepository.save(defaultConfig);
+            log.info("Default global deletion configuration saved with ID: {}", GLOBAL_CONFIG_ID);
+        } else {
+            log.info("Global deletion configuration already exists with ID: {}", GLOBAL_CONFIG_ID);
+        }
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public DeletionConfigDTO getDeletionConfig() {
+        log.debug("Fetching global deletion configuration.");
+        Optional<DeletionConfigEntity> entityOptional = configRepository.findById(GLOBAL_CONFIG_ID);
+        
+        return entityOptional.map(configMapper::toDto)
+                .orElseGet(() -> {
+                    log.warn("Global deletion configuration (ID: {}) not found, returning empty DTO. This might indicate an issue if init() failed or was bypassed.", GLOBAL_CONFIG_ID);
+                    // Consider if throwing an exception or returning a default non-persistent DTO is better here.
+                    // For now, returning an empty DTO as per previous in-memory behavior for safety, but this is unusual for JPA.
+                    return new DeletionConfigDTO(); 
+                });
+    }
+
+    @Override
+    @Transactional
+    public void updateDeletionConfig(DeletionConfigDTO deletionConfigDTO) {
+        if (deletionConfigDTO == null) {
+            log.warn("Attempted to update deletion configuration with null DTO.");
+            throw new IllegalArgumentException("Deletion configuration DTO cannot be null.");
+        }
+        log.info("Updating global deletion configuration.");
+        DeletionConfigEntity entity = configRepository.findById(GLOBAL_CONFIG_ID)
+                .orElseThrow(() -> {
+                    log.error("Global deletion config (ID: {}) not found for update. This is unexpected post-initialization.", GLOBAL_CONFIG_ID);
+                    // This state (config not found during update) should ideally not happen if PostConstruct works.
+                    return new IllegalStateException("Global deletion configuration not found for update. Initialize first.");
+                });
+        
+        configMapper.updateEntityFromDto(deletionConfigDTO, entity);
+        // Ensure ID is not accidentally changed by the mapper if DTO were to carry it
+        entity.setId(GLOBAL_CONFIG_ID); 
+        configRepository.save(entity);
+        log.info("Global deletion configuration updated successfully for ID: {}.", GLOBAL_CONFIG_ID);
+    }
+} 

src/main/java/com/dalab/autodelete/service/impl/DeletionTaskServiceImpl.java

@@ -0,0 +1,156 @@
+package com.dalab.autodelete.service.impl;
+
+import com.dalab.autodelete.dto.*;
+import com.dalab.autodelete.mapper.DeletionTaskMapper;
+import com.dalab.autodelete.model.DeletionStatus;
+import com.dalab.autodelete.model.DeletionTaskEntity;
+import com.dalab.autodelete.repository.DeletionTaskRepository;
+import com.dalab.autodelete.service.IDeletionConfigService;
+import com.dalab.autodelete.service.IDeletionTaskService;
+import com.dalab.autodelete.service.exception.DeletionTaskNotFoundException;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.Pageable;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDateTime;
+import java.util.Collections;
+import java.util.List;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+@Service("deletionTaskService") // Explicit bean name
+@RequiredArgsConstructor
+@Slf4j
+public class DeletionTaskServiceImpl implements IDeletionTaskService {
+
+    private final DeletionTaskRepository taskRepository;
+    private final DeletionTaskMapper taskMapper;
+    private final IDeletionConfigService deletionConfigService; // JPA version
+
+    @Override
+    @Transactional
+    public DeletionTaskResponse submitDeletionTask(DeletionTaskRequest request) {
+        log.info("Submitting new deletion task: Name='{}', TriggeredBy='{}'", request.getTaskName(), request.getTriggeredBy());
+
+        if (request.getScope() == null || request.getScope().getAssetIds() == null || request.getScope().getAssetIds().isEmpty()) {
+            log.warn("Deletion task submission failed for task '{}': Asset IDs are missing.", request.getTaskName());
+            return DeletionTaskResponse.builder()
+                    .taskId(null)
+                    .taskName(request.getTaskName())
+                    .status(DeletionStatus.FAILED.name()) // Using enum name for status consistency
+                    .submittedAt(LocalDateTime.now())
+                    .message("Deletion scope must contain at least one asset ID.")
+                    .build();
+        }
+
+        DeletionTaskEntity entity = taskMapper.requestToEntity(request);
+        entity.setTaskId(UUID.randomUUID().toString());
+        entity.setSubmittedAt(LocalDateTime.now());
+
+        DeletionConfigDTO globalConfig = deletionConfigService.getDeletionConfig();
+        boolean isSoftDelete = determineIfSoftDelete(request, globalConfig);
+        boolean requiresApproval = determineApprovalRequirement(request, globalConfig, isSoftDelete);
+
+        entity.setStatus(requiresApproval ? DeletionStatus.PENDING_APPROVAL : DeletionStatus.SUBMITTED);
+        
+        // Initialize asset statuses if scope is present
+        if (request.getScope() != null && request.getScope().getAssetIds() != null) {
+            List<DeletionTaskEntity.AssetDeletionStatusData> initialAssetStatuses = request.getScope().getAssetIds().stream()
+                .map(assetId -> new DeletionTaskEntity.AssetDeletionStatusData(assetId, null, "PENDING", isSoftDelete ? "SOFT" : "HARD", null, null))
+                .collect(Collectors.toList());
+            entity.setAssetStatuses(initialAssetStatuses);
+            entity.setTotalAssetsInScope(initialAssetStatuses.size());
+            entity.setAssetsPendingProcessing(initialAssetStatuses.size());
+            entity.setAssetsFailedToProcess(0);
+            entity.setAssetsProcessedSuccessfully(0);
+        }
+
+        DeletionTaskEntity savedEntity = taskRepository.save(entity);
+        log.info("Deletion task '{}' submitted with ID {} and status {}.", savedEntity.getTaskName(), savedEntity.getTaskId(), savedEntity.getStatus());
+        return taskMapper.entityToTaskResponse(savedEntity);
+    }
+
+    private boolean determineIfSoftDelete(DeletionTaskRequest request, DeletionConfigDTO globalConfig) {
+        if (request.getOverrideConfig() != null && request.getOverrideConfig().getSoftDelete() != null) {
+            return request.getOverrideConfig().getSoftDelete();
+        }
+        return globalConfig.isSoftDeleteByDefault();
+    }
+
+    private boolean determineApprovalRequirement(DeletionTaskRequest request, DeletionConfigDTO globalConfig, boolean isSoftDelete) {
+        if (request.getOverrideConfig() != null && request.getOverrideConfig().getRequireApproval() != null) {
+            return request.getOverrideConfig().getRequireApproval();
+        }
+        return isSoftDelete ? globalConfig.isRequireApprovalForSoftDelete() : globalConfig.isRequireApprovalForHardDelete();
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public DeletionTaskStatusDTO getTaskStatus(String taskId) {
+        log.debug("Fetching status for deletion task ID: {}", taskId);
+        return taskRepository.findById(taskId)
+                .map(taskMapper::entityToStatusDTO)
+                .orElse(null); // Controller handles null by returning 404
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public DeletionTaskListResponse listTasks(Pageable pageable) {
+        log.debug("Listing deletion tasks with pagination: {}", pageable);
+        Page<DeletionTaskEntity> taskPage = taskRepository.findAll(pageable);
+        List<DeletionTaskStatusDTO> dtoList = taskPage.getContent().stream()
+                .map(taskMapper::entityToStatusDTO)
+                .collect(Collectors.toList());
+        PageImpl<DeletionTaskStatusDTO> dtoPage = new PageImpl<>(dtoList, pageable, taskPage.getTotalElements());
+        return DeletionTaskListResponse.fromPage(dtoPage);
+    }
+
+    @Override
+    @Transactional
+    public DeletionTaskStatusDTO approveTask(String taskId, TaskApprovalRequest approvalRequest) {
+        log.info("Approving deletion task ID: {}", taskId);
+        DeletionTaskEntity task = taskRepository.findById(taskId)
+                .orElseThrow(() -> new DeletionTaskNotFoundException(taskId, "approve"));
+
+        if (task.getStatus() != DeletionStatus.PENDING_APPROVAL) {
+            log.warn("Cannot approve task {}: not in PENDING_APPROVAL state (current: {}).", taskId, task.getStatus());
+            DeletionTaskStatusDTO currentStatusDto = taskMapper.entityToStatusDTO(task);
+            currentStatusDto.setErrorMessages(Collections.singletonList("Task is not in a state that can be approved."));
+            return currentStatusDto;
+        }
+        task.setStatus(DeletionStatus.APPROVED); // Or SUBMITTED if it bypasses a queue and goes to processing
+        if (approvalRequest != null) {
+            task.setApprovalComments(approvalRequest.getComments());
+        }
+        // TODO: Trigger async processing of the task if approval is the gate
+        DeletionTaskEntity savedTask = taskRepository.save(task);
+        log.info("Deletion task {} approved, new status: {}.", taskId, savedTask.getStatus());
+        return taskMapper.entityToStatusDTO(savedTask);
+    }
+
+    @Override
+    @Transactional
+    public DeletionTaskStatusDTO rejectTask(String taskId, TaskApprovalRequest rejectionRequest) {
+        log.info("Rejecting deletion task ID: {}", taskId);
+        DeletionTaskEntity task = taskRepository.findById(taskId)
+                .orElseThrow(() -> new DeletionTaskNotFoundException(taskId, "reject"));
+
+        if (task.getStatus() != DeletionStatus.PENDING_APPROVAL) {
+            log.warn("Cannot reject task {}: not in PENDING_APPROVAL state (current: {}).", taskId, task.getStatus());
+            DeletionTaskStatusDTO currentStatusDto = taskMapper.entityToStatusDTO(task);
+            currentStatusDto.setErrorMessages(Collections.singletonList("Task is not in a state that can be rejected."));
+            return currentStatusDto;
+        }
+        task.setStatus(DeletionStatus.REJECTED);
+        if (rejectionRequest != null) {
+            task.setRejectionComments(rejectionRequest.getComments());
+        }
+        DeletionTaskEntity savedTask = taskRepository.save(task);
+        log.info("Deletion task {} rejected, new status: {}.", taskId, savedTask.getStatus());
+        return taskMapper.entityToStatusDTO(savedTask);
+    }
+} 

src/main/java/com/dalab/autodelete/service/storage/BulkDeletionResult.java

@@ -0,0 +1,30 @@
+package com.dalab.autodelete.service.storage;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * Result of a bulk deletion operation.
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class BulkDeletionResult {
+    
+    private String bulkOperationId;
+    private List<DeletionResult> individualResults;
+    private int totalItems;
+    private int successfulDeletions;
+    private int failedDeletions;
+    private DeletionStatus overallStatus;
+    private LocalDateTime initiatedAt;
+    private LocalDateTime completedAt;
+    private Double totalStorageReclaimed; // In GB
+    private Double totalCostSavings; // Monthly savings in USD
+} 

src/main/java/com/dalab/autodelete/service/storage/DeletionResult.java

@@ -0,0 +1,34 @@
+package com.dalab.autodelete.service.storage;
+
+import java.time.LocalDateTime;
+import java.util.Map;
+import java.util.UUID;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * Result of a deletion operation.
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class DeletionResult {
+    
+    private UUID assetId;
+    private String operationId;
+    private String dataLocation;
+    private DeletionType deletionType;
+    private DeletionStatus status;
+    private LocalDateTime initiatedAt;
+    private LocalDateTime completedAt;
+    private Long dataSizeBytes;
+    private Map<String, String> metadata;
+    private String errorMessage;
+    private Double storageSpaceReclaimed; // In GB
+    private Double costSavings; // Monthly savings in USD
+    private String complianceLevel; // e.g., "GDPR", "HIPAA", "SOX"
+} 

src/main/java/com/dalab/autodelete/service/storage/DeletionStatus.java

@@ -0,0 +1,14 @@
+package com.dalab.autodelete.service.storage;
+
+/**
+ * Status of deletion operations.
+ */
+public enum DeletionStatus {
+    INITIATED,
+    IN_PROGRESS,
+    COMPLETED,
+    FAILED,
+    CANCELLED,
+    PENDING_APPROVAL,
+    VERIFIED
+} 

src/main/java/com/dalab/autodelete/service/storage/DeletionType.java

@@ -0,0 +1,26 @@
+package com.dalab.autodelete.service.storage;
+
+/**
+ * Types of deletion operations available.
+ */
+public enum DeletionType {
+    /**
+     * Soft delete - mark as deleted but keep data recoverable for a period.
+     */
+    SOFT,
+    
+    /**
+     * Hard delete - permanently remove data from storage.
+     */
+    HARD,
+    
+    /**
+     * Secure overwrite - overwrite data multiple times before deletion for compliance.
+     */
+    SECURE_OVERWRITE,
+    
+    /**
+     * Immediate delete - delete data immediately without any recovery period.
+     */
+    IMMEDIATE
+} 

src/main/java/com/dalab/autodelete/service/storage/DeletionVerificationResult.java

@@ -0,0 +1,29 @@
+package com.dalab.autodelete.service.storage;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * Result of deletion verification for compliance purposes.
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class DeletionVerificationResult {
+    
+    private String operationId;
+    private boolean isCompletelyDeleted;
+    private boolean isCompliant;
+    private List<String> complianceStandards; // e.g., ["GDPR", "HIPAA"]
+    private LocalDateTime verificationTimestamp;
+    private String verificationMethod;
+    private List<String> remainingTraces; // Any remaining data traces found
+    private String certificateUrl; // URL to compliance certificate if available
+    private String auditTrail; // Audit trail information
+} 

src/main/java/com/dalab/autodelete/service/storage/ICloudDeletionService.java

@@ -0,0 +1,74 @@
+package com.dalab.autodelete.service.storage;
+
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * Interface for cloud storage deletion operations.
+ * Abstracts different cloud providers (AWS S3, Azure Blob, GCP Cloud Storage).
+ */
+public interface ICloudDeletionService {
+
+    /**
+     * Perform secure deletion of data from cloud storage.
+     * 
+     * @param assetId The unique identifier of the asset being deleted
+     * @param dataLocation The location of the data to delete (e.g., S3 key, blob name)
+     * @param deletionType The type of deletion (SOFT, HARD, SECURE_OVERWRITE)
+     * @param metadata Additional metadata for the deletion operation
+     * @return DeletionResult containing the operation details
+     */
+    DeletionResult deleteData(UUID assetId, String dataLocation, DeletionType deletionType, Map<String, String> metadata);
+
+    /**
+     * Perform bulk deletion of multiple data objects.
+     * 
+     * @param assetIds List of asset IDs to delete
+     * @param dataLocations List of data locations corresponding to the assets
+     * @param deletionType The type of deletion to perform
+     * @param metadata Additional metadata for the bulk operation
+     * @return BulkDeletionResult containing results for all operations
+     */
+    BulkDeletionResult bulkDeleteData(List<UUID> assetIds, List<String> dataLocations, DeletionType deletionType, Map<String, String> metadata);
+
+    /**
+     * Get the status of a deletion operation.
+     * 
+     * @param operationId The ID of the deletion operation
+     * @return DeletionStatus indicating the current state
+     */
+    DeletionStatus getDeletionStatus(String operationId);
+
+    /**
+     * Calculate storage space that would be reclaimed by deletion.
+     * 
+     * @param dataLocations List of data locations to analyze
+     * @return StorageReclaimEstimate with space and cost information
+     */
+    StorageReclaimEstimate calculateStorageReclaim(List<String> dataLocations);
+
+    /**
+     * Verify that data has been completely deleted (compliance check).
+     * 
+     * @param operationId The deletion operation ID
+     * @return DeletionVerificationResult with compliance details
+     */
+    DeletionVerificationResult verifyDeletion(String operationId);
+
+    /**
+     * Check if the deletion service supports the specified cloud provider.
+     * 
+     * @param cloudProvider The cloud provider (AWS, AZURE, GCP)
+     * @return true if supported, false otherwise
+     */
+    boolean supportsCloudProvider(String cloudProvider);
+
+    /**
+     * Get available deletion types for the cloud provider.
+     * 
+     * @param cloudProvider The cloud provider
+     * @return Array of available deletion type names
+     */
+    DeletionType[] getAvailableDeletionTypes(String cloudProvider);
+} 

src/main/java/com/dalab/autodelete/service/storage/StorageReclaimEstimate.java

@@ -0,0 +1,25 @@
+package com.dalab.autodelete.service.storage;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * Estimate of storage space and cost that would be reclaimed by deletion.
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class StorageReclaimEstimate {
+    
+    private int totalObjects;
+    private Long totalSizeBytes;
+    private Double totalSizeGB;
+    private Double currentMonthlyCost;
+    private Double reclaimedMonthlySavings;
+    private String currency;
+    private String region;
+    private String storageClass;
+} 

src/main/resources/application.properties

@@ -0,0 +1,72 @@
+# DALab AutoDelete Service Configuration
+spring.application.name=da-autodelete
+server.port=8080
+
+# Database Configuration - da_autodelete database
+spring.datasource.url=jdbc:postgresql://localhost:5432/da_autodelete
+spring.datasource.username=da_autodelete_user
+spring.datasource.password=da_autodelete_pass
+spring.datasource.driver-class-name=org.postgresql.Driver
+
+# JPA Configuration
+spring.jpa.hibernate.ddl-auto=update
+spring.jpa.show-sql=false
+spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect
+spring.jpa.properties.hibernate.format_sql=true
+
+# Common entities database configuration (for da-protos entities)
+dalab.common.datasource.url=jdbc:postgresql://localhost:5432/dalab_common
+dalab.common.datasource.username=dalab_common_user
+dalab.common.datasource.password=dalab_common_pass
+
+# Kafka Configuration
+spring.kafka.bootstrap-servers=localhost:9092
+spring.kafka.consumer.group-id=da-autodelete-group
+spring.kafka.consumer.auto-offset-reset=earliest
+spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer
+spring.kafka.consumer.value-deserializer=org.springframework.kafka.support.serializer.JsonDeserializer
+spring.kafka.consumer.properties.spring.json.trusted.packages=*
+spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer
+spring.kafka.producer.value-serializer=org.springframework.kafka.support.serializer.JsonSerializer
+
+# Kafka Topics
+dalab.kafka.topics.policy-actions=dalab.policies.actions
+dalab.kafka.topics.deletion-events=dalab.deletion.events
+
+# Security Configuration (Keycloak JWT)
+spring.security.oauth2.resourceserver.jwt.issuer-uri=http://localhost:8180/realms/dalab
+spring.security.oauth2.resourceserver.jwt.jwk-set-uri=http://localhost:8180/realms/dalab/protocol/openid-connect/certs
+
+# Cloud Storage Configuration
+# AWS S3 Configuration
+aws.s3.region=us-east-1
+aws.s3.bucket.primary=dalab-primary-bucket
+
+# Azure Blob Storage Configuration
+azure.storage.account.name=dalabprimary
+azure.storage.container.primary=primary-container
+
+# Google Cloud Storage Configuration
+gcp.storage.project.id=dalab-project
+gcp.storage.bucket.primary=dalab-gcp-primary
+
+# Deletion Configuration
+deletion.safety.confirmation.required=true
+deletion.backup.enabled=true
+deletion.backup.retention.days=30
+deletion.secure.overwrite.enabled=false
+deletion.batch.size=50
+
+# Actuator Configuration
+management.endpoints.web.exposure.include=health,info,metrics,prometheus
+management.endpoint.health.show-details=when-authorized
+management.metrics.export.prometheus.enabled=true
+
+# OpenAPI Documentation
+springdoc.api-docs.path=/v3/api-docs
+springdoc.swagger-ui.path=/swagger-ui.html
+
+# Logging Configuration
+logging.level.com.dalab.autodelete=INFO
+logging.level.org.springframework.kafka=WARN
+logging.level.org.springframework.security=WARN 

src/test/java/com/dalab/autodelete/controller/DeletionConfigControllerTest.java

@@ -0,0 +1,111 @@
+package com.dalab.autodelete.controller;
+
+import com.dalab.autodelete.dto.DeletionConfigDTO;
+import com.dalab.autodelete.service.IDeletionConfigService;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.junit.jupiter.api.BeforeEach;
+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.security.test.context.support.WithMockUser;
+import org.springframework.test.web.servlet.MockMvc;
+
+import java.util.ArrayList;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.csrf;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
+
+@WebMvcTest(DeletionConfigController.class)
+class DeletionConfigControllerTest {
+
+    @Autowired
+    private MockMvc mockMvc;
+
+    @MockBean
+    private IDeletionConfigService deletionConfigService;
+
+    @Autowired
+    private ObjectMapper objectMapper;
+
+    private DeletionConfigDTO sampleConfigDTO;
+
+    @BeforeEach
+    void setUp() {
+        sampleConfigDTO = DeletionConfigDTO.builder()
+                .enabled(true)
+                .softDeleteByDefault(true)
+                .defaultSoftDeleteRetentionDays(30L)
+                .requireApprovalForHardDelete(true)
+                .requireApprovalForSoftDelete(false)
+                .notificationEmailsOnError(new ArrayList<>()) 
+                .build();
+    }
+
+    @Test
+    @WithMockUser(authorities = "ROLE_ADMIN")
+    void getDeletionConfiguration_AsAdmin_ShouldReturnConfig() throws Exception {
+        when(deletionConfigService.getDeletionConfig()).thenReturn(sampleConfigDTO);
+
+        mockMvc.perform(get("/api/v1/deletion/config"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.enabled").value(true))
+                .andExpect(jsonPath("$.softDeleteByDefault").value(true));
+    }
+
+    @Test
+    @WithMockUser(authorities = "ROLE_DATA_STEWARD")
+    void getDeletionConfiguration_AsDataSteward_ShouldReturnConfig() throws Exception {
+        when(deletionConfigService.getDeletionConfig()).thenReturn(sampleConfigDTO);
+
+        mockMvc.perform(get("/api/v1/deletion/config"))
+                .andExpect(status().isOk());
+    }
+    
+    @Test
+    @WithMockUser(authorities = "ROLE_USER") // A regular user should not access this
+    void getDeletionConfiguration_AsUser_ShouldBeForbidden() throws Exception {
+        mockMvc.perform(get("/api/v1/deletion/config"))
+                .andExpect(status().isForbidden());
+    }
+
+    @Test
+    @WithMockUser(authorities = "ROLE_ADMIN")
+    void updateDeletionConfiguration_AsAdmin_ShouldReturnOk() throws Exception {
+        doNothing().when(deletionConfigService).updateDeletionConfig(any(DeletionConfigDTO.class));
+
+        mockMvc.perform(put("/api/v1/deletion/config")
+                        .with(csrf())
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(sampleConfigDTO)))
+                .andExpect(status().isOk());
+
+        verify(deletionConfigService, times(1)).updateDeletionConfig(any(DeletionConfigDTO.class));
+    }
+
+    @Test
+    @WithMockUser(authorities = "ROLE_DATA_STEWARD")
+    void updateDeletionConfiguration_AsDataSteward_ShouldBeForbidden() throws Exception {
+        mockMvc.perform(put("/api/v1/deletion/config")
+                        .with(csrf())
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(sampleConfigDTO)))
+                .andExpect(status().isForbidden());
+    }
+     @Test
+    @WithMockUser(authorities = "ROLE_ADMIN")
+    void updateDeletionConfiguration_WithNullBody_AsAdmin_ShouldReturnBadRequest() throws Exception {
+        // Simulate service throwing IllegalArgumentException for null DTO
+        doThrow(new IllegalArgumentException("DTO cannot be null")).when(deletionConfigService).updateDeletionConfig(null);
+
+        mockMvc.perform(put("/api/v1/deletion/config")
+                        .with(csrf())
+                        .contentType(MediaType.APPLICATION_JSON)
+                        /* .content(objectMapper.writeValueAsString(null)) */) // Sending empty content or invalid content
+                .andExpect(status().isBadRequest()); // Spring typically handles invalid JSON or missing body as 400
+    }
+} 

src/test/java/com/dalab/autodelete/controller/DeletionTaskControllerTest.java

@@ -0,0 +1,186 @@
+package com.dalab.autodelete.controller;
+
+import com.dalab.autodelete.dto.*;
+import com.dalab.autodelete.service.IDeletionTaskService;
+import com.dalab.autodelete.service.exception.DeletionTaskNotFoundException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.junit.jupiter.api.BeforeEach;
+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.data.domain.PageImpl;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.http.MediaType;
+import org.springframework.security.test.context.support.WithMockUser;
+import org.springframework.test.web.servlet.MockMvc;
+
+import java.time.LocalDateTime;
+import java.util.Collections;
+import java.util.List;
+import java.util.UUID;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.*;
+import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.csrf;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
+
+@WebMvcTest(DeletionTaskController.class)
+class DeletionTaskControllerTest {
+
+    @Autowired
+    private MockMvc mockMvc;
+
+    @MockBean
+    private IDeletionTaskService taskService;
+
+    @Autowired
+    private ObjectMapper objectMapper;
+
+    private DeletionTaskRequest sampleTaskRequest;
+    private DeletionTaskResponse sampleTaskResponse;
+    private DeletionTaskStatusDTO sampleTaskStatusDTO;
+    private String sampleTaskId;
+
+    @BeforeEach
+    void setUp() {
+        sampleTaskId = UUID.randomUUID().toString();
+
+        DeletionTaskRequest.DeletionScope scope = DeletionTaskRequest.DeletionScope.builder()
+                .assetIds(List.of("asset1", "asset2"))
+                .build();
+        sampleTaskRequest = DeletionTaskRequest.builder()
+                .taskName("Test Deletion Task")
+                .scope(scope)
+                .build();
+
+        sampleTaskResponse = DeletionTaskResponse.builder()
+                .taskId(sampleTaskId)
+                .taskName("Test Deletion Task")
+                .status("SUBMITTED")
+                .submittedAt(LocalDateTime.now())
+                .build();
+        
+        sampleTaskStatusDTO = DeletionTaskStatusDTO.builder()
+                .taskId(sampleTaskId)
+                .taskName("Test Deletion Task")
+                .status("SUBMITTED")
+                .submittedAt(LocalDateTime.now())
+                .scope(scope) // Assuming DeletionTaskRequest.DeletionScope is compatible or mapped
+                .totalAssetsInScope(2)
+                .build();
+    }
+
+    @Test
+    @WithMockUser(authorities = "ROLE_ADMIN")
+    void submitDeletionTask_AsAdmin_ValidRequest_ShouldReturnAccepted() throws Exception {
+        when(taskService.submitDeletionTask(any(DeletionTaskRequest.class))).thenReturn(sampleTaskResponse);
+
+        mockMvc.perform(post("/api/v1/deletion/tasks")
+                        .with(csrf())
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(sampleTaskRequest)))
+                .andExpect(status().isAccepted())
+                .andExpect(jsonPath("$.taskId").value(sampleTaskId))
+                .andExpect(jsonPath("$.status").value("SUBMITTED"));
+    }
+    
+    @Test
+    @WithMockUser(authorities = "ROLE_ADMIN")
+    void submitDeletionTask_InvalidScope_ShouldReturnBadRequest() throws Exception {
+        DeletionTaskRequest invalidRequest = DeletionTaskRequest.builder().taskName("Invalid Task").scope(null).build();
+        // Service returns a specific response for validation failure
+        DeletionTaskResponse validationFailedResponse = DeletionTaskResponse.builder()
+            .taskId(null)
+            .taskName(invalidRequest.getTaskName())
+            .status("FAILED_VALIDATION") 
+            .message("Scope is null or empty")
+            .submittedAt(LocalDateTime.now())
+            .build();
+        when(taskService.submitDeletionTask(any(DeletionTaskRequest.class))).thenReturn(validationFailedResponse);
+
+        mockMvc.perform(post("/api/v1/deletion/tasks")
+                        .with(csrf())
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(invalidRequest)))
+                .andExpect(status().isBadRequest()) // Controller logic changes status for FAILED_VALIDATION
+                .andExpect(jsonPath("$.status").value("FAILED_VALIDATION"));
+    }
+
+    @Test
+    @WithMockUser(authorities = "ROLE_USER") // Assuming USER can get status of their own tasks (logic in service)
+    void getDeletionTaskStatus_WhenTaskExists_ShouldReturnStatus() throws Exception {
+        when(taskService.getTaskStatus(sampleTaskId)).thenReturn(sampleTaskStatusDTO);
+
+        mockMvc.perform(get("/api/v1/deletion/tasks/{taskId}", sampleTaskId))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.taskId").value(sampleTaskId))
+                .andExpect(jsonPath("$.status").value("SUBMITTED"));
+    }
+
+    @Test
+    @WithMockUser(authorities = "ROLE_USER")
+    void getDeletionTaskStatus_WhenTaskNotExists_ShouldReturnNotFound() throws Exception {
+        when(taskService.getTaskStatus(sampleTaskId)).thenReturn(null); // Service returns null for not found
+
+        mockMvc.perform(get("/api/v1/deletion/tasks/{taskId}", sampleTaskId))
+                .andExpect(status().isNotFound());
+    }
+
+    @Test
+    @WithMockUser(authorities = "ROLE_DATA_STEWARD")
+    void listDeletionTasks_ShouldReturnPageOfTasks() throws Exception {
+        List<DeletionTaskStatusDTO> taskList = Collections.singletonList(sampleTaskStatusDTO);
+        PageImpl<DeletionTaskStatusDTO> page = new PageImpl<>(taskList, PageRequest.of(0, 20), 1);
+        DeletionTaskListResponse listResponse = DeletionTaskListResponse.fromPage(page);
+
+        when(taskService.listTasks(any(Pageable.class))).thenReturn(listResponse);
+
+        mockMvc.perform(get("/api/v1/deletion/tasks").param("page", "0").param("size", "20"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.tasks[0].taskId").value(sampleTaskId));
+    }
+
+    @Test
+    @WithMockUser(authorities = "ROLE_ADMIN")
+    void approveDeletionTask_AsAdmin_WhenTaskApprovable_ShouldReturnOk() throws Exception {
+        DeletionTaskStatusDTO approvedStatus = DeletionTaskStatusDTO.builder().taskId(sampleTaskId).status("APPROVED").build();
+        when(taskService.approveTask(eq(sampleTaskId), any())).thenReturn(approvedStatus);
+
+        mockMvc.perform(post("/api/v1/deletion/tasks/{taskId}/approve", sampleTaskId)
+                        .with(csrf()))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.status").value("APPROVED"));
+    }
+    
+    @Test
+    @WithMockUser(authorities = "ROLE_ADMIN")
+    void approveDeletionTask_TaskNotApprovable_ShouldReturnConflict() throws Exception {
+        DeletionTaskStatusDTO conflictStatus = DeletionTaskStatusDTO.builder()
+                                                .taskId(sampleTaskId)
+                                                .status("COMPLETED") // Example of a non-approvable state
+                                                .errorMessages(List.of("Task not in approvable state"))
+                                                .build();
+        when(taskService.approveTask(eq(sampleTaskId), any())).thenReturn(conflictStatus);
+
+        mockMvc.perform(post("/api/v1/deletion/tasks/{taskId}/approve", sampleTaskId)
+                        .with(csrf()))
+                .andExpect(status().isConflict()) // Controller maps this from DTO having errorMessages
+                .andExpect(jsonPath("$.status").value("COMPLETED"));
+    }
+
+    @Test
+    @WithMockUser(authorities = "ROLE_DATA_STEWARD")
+    void rejectDeletionTask_AsDataSteward_WhenTaskRejectable_ShouldReturnOk() throws Exception {
+        DeletionTaskStatusDTO rejectedStatus = DeletionTaskStatusDTO.builder().taskId(sampleTaskId).status("REJECTED").build();
+        when(taskService.rejectTask(eq(sampleTaskId), any())).thenReturn(rejectedStatus);
+
+        mockMvc.perform(post("/api/v1/deletion/tasks/{taskId}/reject", sampleTaskId)
+                        .with(csrf()))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.status").value("REJECTED"));
+    }
+} 

src/test/java/com/dalab/autodelete/service/impl/DeletionConfigServiceImplTest.java

@@ -0,0 +1,119 @@
+package com.dalab.autodelete.service.impl;
+
+import com.dalab.autodelete.dto.DeletionConfigDTO;
+import com.dalab.autodelete.mapper.DeletionConfigMapper;
+import com.dalab.autodelete.model.DeletionConfigEntity;
+import com.dalab.autodelete.repository.DeletionConfigRepository;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.ArrayList;
+import java.util.Optional;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class DeletionConfigServiceImplTest {
+
+    @Mock
+    private DeletionConfigRepository configRepository;
+
+    @Mock
+    private DeletionConfigMapper configMapper;
+
+    @InjectMocks
+    private DeletionConfigServiceImpl configService;
+
+    private DeletionConfigEntity sampleEntity;
+    private DeletionConfigDTO sampleDTO;
+    private static final Long GLOBAL_CONFIG_ID = 1L;
+
+    @BeforeEach
+    void setUp() {
+        sampleEntity = new DeletionConfigEntity(
+                GLOBAL_CONFIG_ID, true, true, 30L, true, false, new ArrayList<>()
+        );
+        sampleDTO = DeletionConfigDTO.builder()
+                .enabled(true).softDeleteByDefault(true).defaultSoftDeleteRetentionDays(30L)
+                .requireApprovalForHardDelete(true).requireApprovalForSoftDelete(false)
+                .notificationEmailsOnError(new ArrayList<>()).build();
+    }
+
+    @Test
+    void init_WhenConfigExists_ShouldNotSave() {
+        when(configRepository.existsById(GLOBAL_CONFIG_ID)).thenReturn(true);
+        configService.init();
+        verify(configRepository, never()).save(any(DeletionConfigEntity.class));
+    }
+
+    @Test
+    void init_WhenConfigNotExists_ShouldSaveDefault() {
+        when(configRepository.existsById(GLOBAL_CONFIG_ID)).thenReturn(false);
+        when(configRepository.save(any(DeletionConfigEntity.class))).thenReturn(sampleEntity); // Mock save
+        configService.init();
+        verify(configRepository, times(1)).save(any(DeletionConfigEntity.class));
+    }
+
+    @Test
+    void getDeletionConfig_WhenEntityExists_ShouldReturnMappedDTO() {
+        when(configRepository.findById(GLOBAL_CONFIG_ID)).thenReturn(Optional.of(sampleEntity));
+        when(configMapper.toDto(sampleEntity)).thenReturn(sampleDTO);
+
+        DeletionConfigDTO result = configService.getDeletionConfig();
+
+        assertNotNull(result);
+        assertEquals(sampleDTO.isSoftDeleteByDefault(), result.isSoftDeleteByDefault());
+        verify(configRepository, times(1)).findById(GLOBAL_CONFIG_ID);
+        verify(configMapper, times(1)).toDto(sampleEntity);
+    }
+
+    @Test
+    void getDeletionConfig_WhenEntityNotExists_ShouldReturnEmptyDTO() {
+        // This scenario tests the defensive elseGet in the service, though it should ideally not happen after init.
+        when(configRepository.findById(GLOBAL_CONFIG_ID)).thenReturn(Optional.empty());
+        
+        DeletionConfigDTO result = configService.getDeletionConfig();
+
+        assertNotNull(result); // Service returns new DTO(), not null
+        // Assert default fields of new DeletionConfigDTO() if necessary, or that it's just not null
+        assertNull(result.getEnabled()); // Example: Builder default for Boolean is null
+
+        verify(configRepository, times(1)).findById(GLOBAL_CONFIG_ID);
+        verify(configMapper, never()).toDto(any());
+    }
+
+
+    @Test
+    void updateDeletionConfig_WhenEntityExists_ShouldUpdateAndSave() {
+        when(configRepository.findById(GLOBAL_CONFIG_ID)).thenReturn(Optional.of(sampleEntity));
+        doNothing().when(configMapper).updateEntityFromDto(eq(sampleDTO), eq(sampleEntity));
+        when(configRepository.save(any(DeletionConfigEntity.class))).thenReturn(sampleEntity);
+        
+        configService.updateDeletionConfig(sampleDTO);
+
+        verify(configRepository, times(1)).findById(GLOBAL_CONFIG_ID);
+        verify(configMapper, times(1)).updateEntityFromDto(sampleDTO, sampleEntity);
+        verify(configRepository, times(1)).save(sampleEntity);
+        assertEquals(GLOBAL_CONFIG_ID, sampleEntity.getId()); // Ensure ID is preserved
+    }
+
+    @Test
+    void updateDeletionConfig_WhenDtoIsNull_ShouldThrowIllegalArgumentException() {
+        assertThrows(IllegalArgumentException.class, () -> {
+            configService.updateDeletionConfig(null);
+        });
+    }
+    
+    @Test
+    void updateDeletionConfig_WhenEntityNotFound_ShouldThrowIllegalStateException() {
+        when(configRepository.findById(GLOBAL_CONFIG_ID)).thenReturn(Optional.empty());
+        assertThrows(IllegalStateException.class, () -> {
+            configService.updateDeletionConfig(sampleDTO);
+        });
+    }
+} 

src/test/java/com/dalab/autodelete/service/impl/DeletionTaskServiceImplTest.java

@@ -0,0 +1,240 @@
+package com.dalab.autodelete.service.impl;
+
+import com.dalab.autodelete.dto.*;
+import com.dalab.autodelete.mapper.DeletionTaskMapper;
+import com.dalab.autodelete.model.DeletionStatus;
+import com.dalab.autodelete.model.DeletionTaskEntity;
+import com.dalab.autodelete.repository.DeletionTaskRepository;
+import com.dalab.autodelete.service.IDeletionConfigService;
+import com.dalab.autodelete.service.exception.DeletionTaskNotFoundException;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class DeletionTaskServiceImplTest {
+
+    @Mock
+    private DeletionTaskRepository taskRepository;
+
+    @Mock
+    private DeletionTaskMapper taskMapper;
+
+    @Mock
+    private IDeletionConfigService deletionConfigService;
+
+    @InjectMocks
+    private DeletionTaskServiceImpl taskService;
+
+    private DeletionTaskRequest sampleTaskRequest;
+    private DeletionTaskEntity sampleTaskEntity;
+    private DeletionTaskStatusDTO sampleTaskStatusDTO;
+    private DeletionTaskResponse sampleTaskResponse;
+    private DeletionConfigDTO globalConfigDefault;
+    private DeletionConfigDTO globalConfigSoftDeleteApproval;
+    private String sampleTaskId;
+
+    @BeforeEach
+    void setUp() {
+        sampleTaskId = UUID.randomUUID().toString();
+        DeletionTaskRequest.DeletionScope scope = DeletionTaskRequest.DeletionScope.builder()
+                .assetIds(List.of("asset1")).build();
+
+        sampleTaskRequest = DeletionTaskRequest.builder()
+                .taskName("Test Task")
+                .scope(scope)
+                .triggeredBy("user@test.com")
+                .build();
+
+        sampleTaskEntity = new DeletionTaskEntity();
+        sampleTaskEntity.setTaskId(sampleTaskId);
+        sampleTaskEntity.setTaskName("Test Task");
+        sampleTaskEntity.setStatus(DeletionStatus.SUBMITTED);
+        sampleTaskEntity.setSubmittedAt(LocalDateTime.now());
+        sampleTaskEntity.setScope(new DeletionTaskEntity.DeletionScopeData(List.of("asset1")));
+        sampleTaskEntity.setAssetStatuses(new ArrayList<>());
+
+        sampleTaskStatusDTO = DeletionTaskStatusDTO.builder().taskId(sampleTaskId).status(DeletionStatus.SUBMITTED.name()).build();
+        sampleTaskResponse = DeletionTaskResponse.builder().taskId(sampleTaskId).status(DeletionStatus.SUBMITTED.name()).build();
+        
+        globalConfigDefault = DeletionConfigDTO.builder()
+                                .enabled(true)
+                                .softDeleteByDefault(false) // Hard delete by default
+                                .requireApprovalForHardDelete(false) // No approval for hard delete
+                                .requireApprovalForSoftDelete(true) // Approval for soft delete
+                                .build();
+        
+        globalConfigSoftDeleteApproval = DeletionConfigDTO.builder()
+                                .enabled(true)
+                                .softDeleteByDefault(true) // Soft delete by default
+                                .requireApprovalForHardDelete(true) // Approval for hard delete
+                                .requireApprovalForSoftDelete(true) // Approval for soft delete
+                                .build();
+    }
+
+    @Test
+    void submitDeletionTask_ValidRequest_NoApprovalNeeded_ShouldSaveAndReturnResponse() {
+        when(deletionConfigService.getDeletionConfig()).thenReturn(globalConfigDefault);
+        when(taskMapper.requestToEntity(sampleTaskRequest)).thenReturn(sampleTaskEntity); // sampleTaskEntity is already set up
+        when(taskRepository.save(any(DeletionTaskEntity.class))).thenReturn(sampleTaskEntity);
+        when(taskMapper.entityToTaskResponse(sampleTaskEntity)).thenReturn(sampleTaskResponse);
+
+        DeletionTaskResponse response = taskService.submitDeletionTask(sampleTaskRequest);
+
+        assertNotNull(response);
+        assertEquals(DeletionStatus.SUBMITTED.name(), response.getStatus());
+        ArgumentCaptor<DeletionTaskEntity> entityCaptor = ArgumentCaptor.forClass(DeletionTaskEntity.class);
+        verify(taskRepository).save(entityCaptor.capture());
+        assertEquals(DeletionStatus.SUBMITTED, entityCaptor.getValue().getStatus());
+        assertNotNull(entityCaptor.getValue().getAssetStatuses());
+        assertEquals(1, entityCaptor.getValue().getAssetsPendingProcessing());
+        assertEquals("HARD", entityCaptor.getValue().getAssetStatuses().get(0).getDeletionType());
+    }
+    
+    @Test
+    void submitDeletionTask_RequiresHardDeleteApproval_ShouldSetPendingApproval() {
+        DeletionConfigDTO config = DeletionConfigDTO.builder().softDeleteByDefault(false).requireApprovalForHardDelete(true).build();
+        when(deletionConfigService.getDeletionConfig()).thenReturn(config);
+        when(taskMapper.requestToEntity(sampleTaskRequest)).thenReturn(sampleTaskEntity);
+        when(taskRepository.save(any(DeletionTaskEntity.class))).thenReturn(sampleTaskEntity);
+
+        taskService.submitDeletionTask(sampleTaskRequest);
+
+        ArgumentCaptor<DeletionTaskEntity> entityCaptor = ArgumentCaptor.forClass(DeletionTaskEntity.class);
+        verify(taskRepository).save(entityCaptor.capture());
+        assertEquals(DeletionStatus.PENDING_APPROVAL, entityCaptor.getValue().getStatus());
+    }
+
+    @Test
+    void submitDeletionTask_SoftDeleteOverride_RequiresSoftApproval_ShouldSetPendingApproval() {
+        sampleTaskRequest.setOverrideConfig(DeletionTaskRequest.DeletionConfigOverride.builder().softDelete(true).build());
+        when(deletionConfigService.getDeletionConfig()).thenReturn(globalConfigSoftDeleteApproval);
+        when(taskMapper.requestToEntity(sampleTaskRequest)).thenReturn(sampleTaskEntity);
+        when(taskRepository.save(any(DeletionTaskEntity.class))).thenReturn(sampleTaskEntity);
+
+        taskService.submitDeletionTask(sampleTaskRequest);
+        ArgumentCaptor<DeletionTaskEntity> entityCaptor = ArgumentCaptor.forClass(DeletionTaskEntity.class);
+        verify(taskRepository).save(entityCaptor.capture());
+        assertEquals(DeletionStatus.PENDING_APPROVAL, entityCaptor.getValue().getStatus());
+         assertEquals("SOFT", entityCaptor.getValue().getAssetStatuses().get(0).getDeletionType());
+    }
+
+    @Test
+    void submitDeletionTask_InvalidScope_ShouldReturnFailedStatus() {
+        DeletionTaskRequest invalidRequest = DeletionTaskRequest.builder().taskName("Invalid").scope(null).build();
+        DeletionTaskResponse response = taskService.submitDeletionTask(invalidRequest);
+        assertEquals(DeletionStatus.FAILED.name(), response.getStatus());
+        verify(taskRepository, never()).save(any());
+    }
+
+    @Test
+    void getTaskStatus_TaskExists_ShouldReturnDTO() {
+        when(taskRepository.findById(sampleTaskId)).thenReturn(Optional.of(sampleTaskEntity));
+        when(taskMapper.entityToStatusDTO(sampleTaskEntity)).thenReturn(sampleTaskStatusDTO);
+
+        DeletionTaskStatusDTO result = taskService.getTaskStatus(sampleTaskId);
+
+        assertNotNull(result);
+        assertEquals(sampleTaskId, result.getTaskId());
+    }
+
+    @Test
+    void getTaskStatus_TaskNotExists_ShouldReturnNull() {
+        when(taskRepository.findById(sampleTaskId)).thenReturn(Optional.empty());
+        DeletionTaskStatusDTO result = taskService.getTaskStatus(sampleTaskId);
+        assertNull(result);
+    }
+
+    @Test
+    void listTasks_ShouldReturnPaginatedDTOs() {
+        Pageable pageable = PageRequest.of(0, 10);
+        List<DeletionTaskEntity> taskList = Collections.singletonList(sampleTaskEntity);
+        Page<DeletionTaskEntity> page = new PageImpl<>(taskList, pageable, 1);
+        when(taskRepository.findAll(pageable)).thenReturn(page);
+        when(taskMapper.entityToStatusDTO(sampleTaskEntity)).thenReturn(sampleTaskStatusDTO);
+
+        DeletionTaskListResponse response = taskService.listTasks(pageable);
+
+        assertNotNull(response);
+        assertEquals(1, response.getTasks().size());
+        assertEquals(sampleTaskId, response.getTasks().get(0).getTaskId());
+    }
+
+    @Test
+    void approveTask_TaskExistsAndPending_ShouldApprove() {
+        sampleTaskEntity.setStatus(DeletionStatus.PENDING_APPROVAL);
+        when(taskRepository.findById(sampleTaskId)).thenReturn(Optional.of(sampleTaskEntity));
+        when(taskRepository.save(any(DeletionTaskEntity.class))).thenReturn(sampleTaskEntity);
+        when(taskMapper.entityToStatusDTO(any(DeletionTaskEntity.class))).thenAnswer(invocation -> {
+            DeletionTaskEntity entity = invocation.getArgument(0);
+            return DeletionTaskStatusDTO.builder().taskId(entity.getTaskId()).status(entity.getStatus().name()).build();
+        });
+
+        TaskApprovalRequest approvalReq = TaskApprovalRequest.builder().comments("Approved by test").build();
+        DeletionTaskStatusDTO result = taskService.approveTask(sampleTaskId, approvalReq);
+
+        assertEquals(DeletionStatus.APPROVED.name(), result.getStatus());
+        assertEquals("Approved by test", sampleTaskEntity.getApprovalComments());
+        verify(taskRepository).save(sampleTaskEntity);
+    }
+
+    @Test
+    void approveTask_TaskNotPending_ShouldReturnCurrentStatusWithErrors() {
+        sampleTaskEntity.setStatus(DeletionStatus.COMPLETED);
+        when(taskRepository.findById(sampleTaskId)).thenReturn(Optional.of(sampleTaskEntity));
+        // Mapper will be called to return the current DTO
+        when(taskMapper.entityToStatusDTO(sampleTaskEntity)).thenReturn(DeletionTaskStatusDTO.builder().taskId(sampleTaskId).status(DeletionStatus.COMPLETED.name()).build());
+
+        DeletionTaskStatusDTO result = taskService.approveTask(sampleTaskId, new TaskApprovalRequest());
+
+        assertEquals(DeletionStatus.COMPLETED.name(), result.getStatus());
+        assertNotNull(result.getErrorMessages());
+        assertFalse(result.getErrorMessages().isEmpty());
+        verify(taskRepository, never()).save(any());
+    }
+    
+    @Test
+    void approveTask_TaskNotFound_ShouldThrowException() {
+        when(taskRepository.findById(sampleTaskId)).thenReturn(Optional.empty());
+        assertThrows(DeletionTaskNotFoundException.class, () -> {
+            taskService.approveTask(sampleTaskId, new TaskApprovalRequest());
+        });
+    }
+
+    @Test
+    void rejectTask_TaskExistsAndPending_ShouldReject() {
+        sampleTaskEntity.setStatus(DeletionStatus.PENDING_APPROVAL);
+        when(taskRepository.findById(sampleTaskId)).thenReturn(Optional.of(sampleTaskEntity));
+        when(taskRepository.save(any(DeletionTaskEntity.class))).thenReturn(sampleTaskEntity);
+         when(taskMapper.entityToStatusDTO(any(DeletionTaskEntity.class))).thenAnswer(invocation -> {
+            DeletionTaskEntity entity = invocation.getArgument(0);
+            return DeletionTaskStatusDTO.builder().taskId(entity.getTaskId()).status(entity.getStatus().name()).build();
+        });
+
+        TaskApprovalRequest rejectionReq = TaskApprovalRequest.builder().comments("Rejected by test").build();
+        DeletionTaskStatusDTO result = taskService.rejectTask(sampleTaskId, rejectionReq);
+
+        assertEquals(DeletionStatus.REJECTED.name(), result.getStatus());
+        assertEquals("Rejected by test", sampleTaskEntity.getRejectionComments());
+        verify(taskRepository).save(sampleTaskEntity);
+    }
+}