Initial deployment of da-autoarchival-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-autoarchival.jar"]

README.md

@@ -1,10 +1,38 @@
 ---
-title: Da Autoarchival Dev
-emoji: 📉
-colorFrom: purple
-colorTo: purple
+title: da-autoarchival (dev)
+emoji: 🔧
+colorFrom: blue
+colorTo: green
 sdk: docker
-pinned: false
+app_port: 8080
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# da-autoarchival - dev Environment
+
+This is the da-autoarchival 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-autoarchival-dev/swagger-ui.html
+- Health Check: https://huggingface.co/spaces/dalabsai/da-autoarchival-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:12

build.gradle.kts

@@ -0,0 +1,21 @@
+// da-autoarchival inherits common configuration from parent build.gradle.kts
+// This build file adds autoarchival-specific dependencies
+
+dependencies {
+    // da-protos common entities and utilities
+    implementation(project(":da-protos"))
+    
+    // Cloud Storage SDKs
+    implementation("software.amazon.awssdk:s3:2.20.162")
+    implementation("software.amazon.awssdk:glacier: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-autoarchival
+    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.autoarchival.DaAutoarchivalApplication")
+} 

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-autoarchival.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/autoarchival/DaAutoarchivalApplication.java

@@ -0,0 +1,35 @@
+package com.dalab.autoarchival;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.scheduling.annotation.EnableAsync;
+import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;
+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.context.annotation.Bean;
+
+@SpringBootApplication
+@EnableMethodSecurity // For @PreAuthorize annotations
+@EnableAsync // If async operations are needed
+// @EnableFeignClients // If this service will call other services via Feign
+public class DaAutoarchivalApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(DaAutoarchivalApplication.class, args);
+    }
+
+    @Bean
+    public OpenAPI customOpenAPI(@Value("${spring.application.name:DALab AutoArchival Service}") String appName,
+                               @Value("${spring.application.description:API for AutoArchival 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/autoarchival/controller/ArchivalConfigController.java

@@ -0,0 +1,68 @@
+package com.dalab.autoarchival.controller;
+
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import com.dalab.autoarchival.dto.ArchivalConfigDTO;
+import com.dalab.autoarchival.service.IArchivalConfigService;
+
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * REST controller for managing archival configuration.
+ */
+@RestController
+@RequestMapping("/api/v1/archival/config")
+@RequiredArgsConstructor
+@Slf4j
+public class ArchivalConfigController {
+
+    private final IArchivalConfigService archivalConfigService;
+
+    /**
+     * Retrieves the current archival configuration.
+     * Requires ADMIN or DATA_STEWARD role.
+     *
+     * @return ResponseEntity with current ArchivalConfigDTO.
+     */
+    @GetMapping
+    @PreAuthorize("hasAnyAuthority('ROLE_ADMIN', 'ROLE_DATA_STEWARD')")
+    public ResponseEntity<ArchivalConfigDTO> getArchivalConfig() {
+        log.info("Request to retrieve archival configuration");
+        try {
+            ArchivalConfigDTO config = archivalConfigService.getArchivalConfig();
+            return ResponseEntity.ok(config);
+        } catch (Exception e) {
+            log.error("Error retrieving archival configuration: {}", e.getMessage(), e);
+            return ResponseEntity.internalServerError().build();
+        }
+    }
+
+    /**
+     * Updates the archival configuration.
+     * Requires ADMIN role.
+     *
+     * @param configDTO The new archival configuration.
+     * @return ResponseEntity with updated configuration.
+     */
+    @PutMapping
+    @PreAuthorize("hasAuthority('ROLE_ADMIN')")
+    public ResponseEntity<ArchivalConfigDTO> updateArchivalConfig(@Valid @RequestBody ArchivalConfigDTO configDTO) {
+        log.info("Request to update archival configuration: {}", configDTO);
+        try {
+            archivalConfigService.updateArchivalConfig(configDTO);
+            ArchivalConfigDTO updatedConfig = archivalConfigService.getArchivalConfig();
+            return ResponseEntity.ok(updatedConfig);
+        } catch (Exception e) {
+            log.error("Error updating archival configuration: {}", e.getMessage(), e);
+            return ResponseEntity.internalServerError().build();
+        }
+    }
+} 

src/main/java/com/dalab/autoarchival/controller/ArchivalTaskController.java

@@ -0,0 +1,147 @@
+package com.dalab.autoarchival.controller;
+
+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.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import com.dalab.autoarchival.dto.ArchivalTaskListResponse;
+import com.dalab.autoarchival.dto.ArchivalTaskRequest;
+import com.dalab.autoarchival.dto.ArchivalTaskResponse;
+import com.dalab.autoarchival.dto.ArchivalTaskStatusDTO;
+import com.dalab.autoarchival.dto.TaskApprovalRequest;
+import com.dalab.autoarchival.service.IArchivalTaskService;
+
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+@RestController
+@RequestMapping("/api/v1/archival/tasks")
+@RequiredArgsConstructor
+@Slf4j
+public class ArchivalTaskController {
+
+    private final IArchivalTaskService archivalTaskService;
+
+    /**
+     * Submits a new archival task for specified assets.
+     * Requires DATA_STEWARD or ADMIN role.
+     *
+     * @param taskRequest The archival task request details.
+     * @return ResponseEntity with ArchivalTaskResponse indicating task submission status.
+     */
+    @PostMapping
+    @PreAuthorize("hasAnyAuthority('ROLE_ADMIN', 'ROLE_DATA_STEWARD')")
+    public ResponseEntity<ArchivalTaskResponse> submitArchivalTask(@Valid @RequestBody ArchivalTaskRequest taskRequest) {
+        log.info("Received request to submit archival task: {}", taskRequest.getTaskName());
+        try {
+            ArchivalTaskResponse response = archivalTaskService.submitArchivalTask(taskRequest);
+            if ("FAILED_VALIDATION".equals(response.getStatus())) {
+                return ResponseEntity.badRequest().body(response);
+            }
+            return ResponseEntity.status(HttpStatus.ACCEPTED).body(response);
+        } catch (Exception e) {
+            log.error("Unexpected error submitting archival task '{}': {}", taskRequest.getTaskName(), e.getMessage(), e);
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
+                    .body(ArchivalTaskResponse.builder()
+                            .taskName(taskRequest.getTaskName())
+                            .status("ERROR")
+                            .message("An unexpected error occurred while submitting the archival task.")
+                            .submittedAt(java.time.LocalDateTime.now())
+                            .build());
+        }
+    }
+
+    /**
+     * Retrieves the status of a specific archival task.
+     * Requires DATA_STEWARD, ADMIN, or USER role (user who submitted, or involved).
+     *
+     * @param taskId The ID of the archival task.
+     * @return ResponseEntity with ArchivalTaskStatusDTO or Not Found.
+     */
+    @GetMapping("/{taskId}")
+    @PreAuthorize("hasAnyAuthority('ROLE_ADMIN', 'ROLE_DATA_STEWARD', 'ROLE_USER')") // User role may need further refinement (e.g., task owner)
+    public ResponseEntity<ArchivalTaskStatusDTO> getArchivalTaskStatus(@PathVariable String taskId) {
+        log.info("Request to retrieve status for archival task ID: {}", taskId);
+        ArchivalTaskStatusDTO statusDTO = archivalTaskService.getTaskStatus(taskId);
+        if (statusDTO != null) {
+            return ResponseEntity.ok(statusDTO);
+        } else {
+            log.warn("Archival task with ID '{}' not found.", taskId);
+            return ResponseEntity.notFound().build();
+        }
+    }
+
+    /**
+     * Lists all archival tasks with pagination.
+     * Requires DATA_STEWARD, ADMIN, or USER role.
+     *
+     * @param pageable Pagination information.
+     * @return ResponseEntity with ArchivalTaskListResponse.
+     */
+    @GetMapping
+    @PreAuthorize("hasAnyAuthority('ROLE_ADMIN', 'ROLE_DATA_STEWARD', 'ROLE_USER')")
+    public ResponseEntity<ArchivalTaskListResponse> listArchivalTasks(@PageableDefault(size = 20) Pageable pageable) {
+        log.info("Request to list archival tasks. Pagination: {}", pageable);
+        try {
+            ArchivalTaskListResponse response = archivalTaskService.listTasks(pageable);
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            log.error("Error listing archival tasks: {}", e.getMessage(), e);
+            // Consider a more specific error response DTO if needed
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        }
+    }
+
+    /**
+     * Approves a pending archival task.
+     * Requires ADMIN or designated approver role.
+     */
+    @PostMapping("/{taskId}/approve")
+    @PreAuthorize("hasAuthority('ROLE_ADMIN')") // Or a more specific approver role
+    public ResponseEntity<ArchivalTaskStatusDTO> approveArchivalTask(@PathVariable String taskId, 
+                                                                   @RequestBody(required = false) TaskApprovalRequest approvalRequest) {
+        log.info("Request to approve archival task ID: {}. Comments: {}", taskId, approvalRequest != null ? approvalRequest.getComments() : "N/A");
+        ArchivalTaskStatusDTO updatedStatus = archivalTaskService.approveTask(taskId, approvalRequest);
+        if (updatedStatus == null) {
+            return ResponseEntity.notFound().build();
+        }
+        if ("APPROVED".equals(updatedStatus.getStatus()) || "SUBMITTED".equals(updatedStatus.getStatus())) { // Or other success states
+            return ResponseEntity.ok(updatedStatus);
+        } else {
+            // Task might not have been in an approvable state
+            return ResponseEntity.status(HttpStatus.CONFLICT).body(updatedStatus);
+        }
+    }
+
+    /**
+     * Rejects a pending archival task.
+     * Requires ADMIN or designated approver role.
+     */
+    @PostMapping("/{taskId}/reject")
+    @PreAuthorize("hasAuthority('ROLE_ADMIN')") // Or a more specific approver role
+    public ResponseEntity<ArchivalTaskStatusDTO> rejectArchivalTask(@PathVariable String taskId, 
+                                                                  @RequestBody(required = false) TaskApprovalRequest rejectionRequest) {
+        log.info("Request to reject archival task ID: {}. Comments: {}", taskId, rejectionRequest != null ? rejectionRequest.getComments() : "N/A");
+        ArchivalTaskStatusDTO updatedStatus = archivalTaskService.rejectTask(taskId, rejectionRequest);
+        if (updatedStatus == null) {
+            return ResponseEntity.notFound().build();
+        }
+        if ("REJECTED".equals(updatedStatus.getStatus())) {
+            return ResponseEntity.ok(updatedStatus);
+        } else {
+            // Task might not have been in a rejectable state
+            return ResponseEntity.status(HttpStatus.CONFLICT).body(updatedStatus);
+        }
+    }
+
+    // POST /tasks/{taskId}/restore to be added later
+} 

src/main/java/com/dalab/autoarchival/dto/ArchivalConfigDTO.java

@@ -0,0 +1,43 @@
+package com.dalab.autoarchival.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-archival configuration.
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class ArchivalConfigDTO {
+
+    private Boolean enabled; // Global enable/disable for auto-archival
+    private String defaultArchivalTier; // e.g., "S3_GLACIER_DEEP_ARCHIVE", "AZURE_ARCHIVE"
+    private Long defaultRetentionDays; // Default retention before data is eligible for permanent deletion after archival
+    private boolean requireApprovalForArchival; // If manual approval is needed before archival
+    private boolean requireApprovalForRestore; // If manual approval is needed for restoration
+
+    // Potentially add provider-specific configurations or rules here if needed
+    // For example, specific storage account details or lifecycle policy names
+    private Map<String, ProviderArchivalConfig> providerConfigs;
+
+    // Represents archival settings specific to a cloud provider
+    @Data
+    @Builder
+    @NoArgsConstructor
+    @AllArgsConstructor
+    public static class ProviderArchivalConfig {
+        private String archivalStorageLocation; // e.g., bucket name, container name
+        private String defaultRegion; // if applicable
+        private Map<String, String> customProperties; // for provider-specific settings
+    }
+    
+    // Could also include a list of rules directly, or link to policies in da-policyengine
+    // For simplicity, starting with general config. Rules might be handled by Policy Engine.
+} 

src/main/java/com/dalab/autoarchival/dto/ArchivalTaskListResponse.java

@@ -0,0 +1,41 @@
+package com.dalab.autoarchival.dto;
+
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.AllArgsConstructor;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.Pageable;
+
+import java.util.List;
+
+/**
+ * DTO for a paginated list of archival tasks.
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class ArchivalTaskListResponse {
+    private List<ArchivalTaskStatusDTO> tasks; // Using full status DTO for now
+    private int pageNumber;
+    private int pageSize;
+    private long totalElements;
+    private int totalPages;
+    private boolean last;
+    private boolean first;
+    private int numberOfElements;
+
+    public static ArchivalTaskListResponse fromPage(PageImpl<ArchivalTaskStatusDTO> page) {
+        return ArchivalTaskListResponse.builder()
+                .tasks(page.getContent())
+                .pageNumber(page.getNumber())
+                .pageSize(page.getSize())
+                .totalElements(page.getTotalElements())
+                .totalPages(page.getTotalPages())
+                .last(page.isLast())
+                .first(page.isFirst())
+                .numberOfElements(page.getNumberOfElements())
+                .build();
+    }
+} 

src/main/java/com/dalab/autoarchival/dto/ArchivalTaskRequest.java

@@ -0,0 +1,56 @@
+package com.dalab.autoarchival.dto;
+
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.AllArgsConstructor;
+
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * DTO for requesting an archival task.
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class ArchivalTaskRequest {
+
+    private String taskName; // Optional user-defined name for the task
+
+    @NotNull(message = "Archival scope cannot be null")
+    @Valid
+    private ArchivalScope scope;
+
+    // Optional: Allow overriding some global/provider config for this specific task
+    private ArchivalConfigOverride overrideConfig;
+
+    private String triggeredBy; // User or system that triggered the task
+    private String justification; // Optional justification for the archival
+
+    @Data
+    @Builder
+    @NoArgsConstructor
+    @AllArgsConstructor
+    public static class ArchivalScope {
+        // Define how assets are specified, e.g., by IDs, by query, by tags
+        @NotEmpty(message = "At least one asset ID or a query must be provided.") // Example validation
+        private List<String> assetIds; // Direct list of asset IDs from the catalog
+        // private String assetQuery; // Or a query to select assets (e.g., SQL-like or from da-catalog search API)
+        // private Map<String, String> assetTags; // Or assets matching specific tags
+    }
+
+    @Data
+    @Builder
+    @NoArgsConstructor
+    @AllArgsConstructor
+    public static class ArchivalConfigOverride {
+        private String targetArchivalTier; // Override default tier
+        private Long retentionDays; // Override default retention
+        // Potentially other specific overrides
+    }
+} 

src/main/java/com/dalab/autoarchival/dto/ArchivalTaskResponse.java

@@ -0,0 +1,27 @@
+package com.dalab.autoarchival.dto;
+
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.AllArgsConstructor;
+
+import java.time.LocalDateTime;
+
+/**
+ * DTO for archival task submission response.
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class ArchivalTaskResponse {
+    
+    private String taskId;
+    private String taskName;
+    private String status;
+    private String message;
+    private LocalDateTime submittedAt;
+    private String submittedBy;
+    private Integer estimatedProcessingTimeMinutes;
+    
+} 

src/main/java/com/dalab/autoarchival/dto/ArchivalTaskStatusDTO.java

@@ -0,0 +1,52 @@
+package com.dalab.autoarchival.dto;
+
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.AllArgsConstructor;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * DTO for representing the detailed status of an archival task.
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class ArchivalTaskStatusDTO {
+    private String taskId;
+    private String taskName;
+    private String status; // e.g., SUBMITTED, PENDING_APPROVAL, IN_PROGRESS, COMPLETED, FAILED, PARTIALLY_COMPLETED
+    private LocalDateTime submittedAt;
+    private LocalDateTime startedAt;
+    private LocalDateTime completedAt;
+    private String triggeredBy;
+    private String justification;
+    private ArchivalTaskRequest.ArchivalScope scope; // The original scope
+    private ArchivalTaskRequest.ArchivalConfigOverride overrideConfig; // Original overrides
+
+    private int totalAssetsInScope;
+    private int assetsArchivedSuccessfully;
+    private int assetsFailedToArchive;
+    private int assetsPendingArchival;
+
+    private List<AssetArchivalStatus> assetStatuses; // Status for each asset in the task
+    private List<String> errorMessages; // Overall task error messages
+
+    @Data
+    @Builder
+    @NoArgsConstructor
+    @AllArgsConstructor
+    public static class AssetArchivalStatus {
+        private String assetId;
+        private String assetName; // Optional, might need to be fetched from catalog
+        private String status; // PENDING, IN_PROGRESS, ARCHIVED, FAILED, RESTORED
+        private String archivalLocation; // e.g., S3 URI, Azure Blob URI post-archival
+        private String errorMessage; // If archival failed for this asset
+        private LocalDateTime archivedAt;
+        private LocalDateTime restoredAt;
+    }
+} 

src/main/java/com/dalab/autoarchival/dto/RestoreRequestDTO.java

@@ -0,0 +1,32 @@
+package com.dalab.autoarchival.dto;
+
+import java.util.List;
+
+import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * DTO for restore request from archived storage.
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class RestoreRequestDTO {
+    
+    @NotNull
+    @NotEmpty
+    private List<String> assetIds;
+    
+    private String requestedBy;
+    private String reason;
+    private String targetLocation;
+    private Integer retentionDays; // How long to keep restored data accessible
+    private Boolean priorityRestore; // Fast restore vs standard
+    private String restoreTier; // Added field expected by service
+    
+} 

src/main/java/com/dalab/autoarchival/dto/RestoreResponseDTO.java

@@ -0,0 +1,30 @@
+package com.dalab.autoarchival.dto;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * DTO for restore operation response.
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class RestoreResponseDTO {
+    
+    private String restoreTaskId;
+    private String archivalTaskId;
+    private String status; // SUBMITTED, IN_PROGRESS, COMPLETED, FAILED
+    private String message;
+    private List<String> assetIds;
+    private LocalDateTime requestedAt;
+    private LocalDateTime estimatedCompletionAt;
+    private String targetLocation;
+    private Integer retentionDays;
+    
+} 

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

@@ -0,0 +1,21 @@
+package com.dalab.autoarchival.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;
+    // Add approver/rejector userID if needed, though it can be derived from security context
+} 

src/main/java/com/dalab/autoarchival/exception/ArchivalException.java

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

src/main/java/com/dalab/autoarchival/kafka/consumer/PolicyActionEventListener.java

@@ -0,0 +1,58 @@
+package com.dalab.autoarchival.kafka.consumer;
+
+import java.util.Map;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.kafka.annotation.KafkaListener;
+import org.springframework.kafka.support.KafkaHeaders;
+import org.springframework.messaging.handler.annotation.Header;
+import org.springframework.messaging.handler.annotation.Payload;
+import org.springframework.stereotype.Component;
+
+import com.dalab.autoarchival.service.IArchivalTaskService;
+
+@Component
+public class PolicyActionEventListener {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(PolicyActionEventListener.class);
+
+    private final IArchivalTaskService archivalTaskService;
+
+    public PolicyActionEventListener(IArchivalTaskService archivalTaskService) {
+        this.archivalTaskService = archivalTaskService;
+    }
+
+    @KafkaListener(
+            topics = "${dalab.kafka.topics.policy-actions}",
+            groupId = "${spring.kafka.consumer.group-id}"
+    )
+    public void handlePolicyActionEvent(
+            @Payload Map<String, Object> event,
+            @Header(KafkaHeaders.RECEIVED_TOPIC) String topic,
+            @Header(KafkaHeaders.RECEIVED_PARTITION) int partition,
+            @Header(KafkaHeaders.OFFSET) long offset
+    ) {
+        String eventId = (String) event.get("eventId");
+        String policyId = (String) event.get("policyId");
+        String actionType = (String) event.get("actionType");
+        
+        LOGGER.info(
+                "Received PolicyActionEvent on topic: {}, partition: {}, offset: {}. Event ID: {}, Policy ID: {}, Action: {}",
+                topic, partition, offset, eventId, policyId, actionType
+        );
+
+        // Filter for archival-related actions
+        if ("ARCHIVE".equals(actionType) || "AUTO_ARCHIVE".equals(actionType)) {
+            try {
+                archivalTaskService.processArchivalAction(event);
+                LOGGER.debug("Successfully triggered archival processing for eventId: {}", eventId);
+            } catch (Exception e) {
+                LOGGER.error("Error processing PolicyActionEvent for archival (eventId: {}): {}", eventId, e.getMessage(), e);
+                // TODO: Implement proper error handling and dead-letter queue (DLQ) strategy
+            }
+        } else {
+            LOGGER.debug("Skipping PolicyActionEvent with action type: {} for eventId: {}", actionType, eventId);
+        }
+    }
+} 

src/main/java/com/dalab/autoarchival/mapper/ArchivalConfigMapper.java

@@ -0,0 +1,25 @@
+package com.dalab.autoarchival.mapper;
+
+import com.dalab.autoarchival.dto.ArchivalConfigDTO;
+import com.dalab.autoarchival.model.ArchivalConfigEntity;
+import org.mapstruct.Mapper;
+import org.mapstruct.MappingTarget;
+import org.mapstruct.factory.Mappers;
+
+/**
+ * Mapper for converting between ArchivalConfigEntity and ArchivalConfigDTO.
+ */
+@Mapper
+public interface ArchivalConfigMapper {
+    
+    ArchivalConfigMapper INSTANCE = Mappers.getMapper(ArchivalConfigMapper.class);
+    
+    // Methods expected by the service implementation
+    ArchivalConfigDTO toDto(ArchivalConfigEntity entity);
+    void updateEntityFromDto(ArchivalConfigDTO dto, @MappingTarget ArchivalConfigEntity entity);
+    
+    // Original methods
+    ArchivalConfigDTO toDTO(ArchivalConfigEntity entity);
+    ArchivalConfigEntity toEntity(ArchivalConfigDTO dto);
+    
+} 

src/main/java/com/dalab/autoarchival/mapper/ArchivalTaskMapper.java

@@ -0,0 +1,29 @@
+package com.dalab.autoarchival.mapper;
+
+import com.dalab.autoarchival.dto.ArchivalTaskStatusDTO;
+import com.dalab.autoarchival.dto.ArchivalTaskResponse;
+import com.dalab.autoarchival.dto.ArchivalTaskRequest;
+import com.dalab.autoarchival.dto.RestoreRequestDTO;
+import com.dalab.autoarchival.model.ArchivalTaskEntity;
+import org.mapstruct.Mapper;
+import org.mapstruct.factory.Mappers;
+
+/**
+ * Mapper for converting between ArchivalTaskEntity and DTOs.
+ */
+@Mapper
+public interface ArchivalTaskMapper {
+    
+    ArchivalTaskMapper INSTANCE = Mappers.getMapper(ArchivalTaskMapper.class);
+    
+    // Methods expected by the service implementation
+    ArchivalTaskEntity requestToEntity(ArchivalTaskRequest request);
+    ArchivalTaskResponse entityToTaskResponse(ArchivalTaskEntity entity);
+    ArchivalTaskStatusDTO entityToStatusDTO(ArchivalTaskEntity entity);
+    ArchivalTaskEntity.RestoreRequestData restoreRequestDtoToData(RestoreRequestDTO dto);
+    
+    // Original methods
+    ArchivalTaskStatusDTO toStatusDTO(ArchivalTaskEntity entity);
+    ArchivalTaskResponse toResponseDTO(ArchivalTaskEntity entity);
+    
+} 

src/main/java/com/dalab/autoarchival/model/ArchivalConfigEntity.java

@@ -0,0 +1,41 @@
+package com.dalab.autoarchival.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.util.Map;
+
+@Entity
+@Table(name = "dalab_archival_config")
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class ArchivalConfigEntity {
+
+    @Id
+    private Long id; // Use a fixed ID, e.g., 1L, as it's a global config
+
+    private boolean enabled;
+    private String defaultArchivalTier;
+    private Long defaultRetentionDays;
+    private boolean requireApprovalForArchival;
+    private boolean requireApprovalForRestore;
+
+    @JdbcTypeCode(SqlTypes.JSON)
+    @Column(columnDefinition = "jsonb")
+    private Map<String, ProviderConfigData> providerConfigs; // Store as JSON
+
+    // Static inner class for provider config data to be serialized to JSON
+    @Data
+    @NoArgsConstructor
+    @AllArgsConstructor
+    public static class ProviderConfigData {
+        private String archivalStorageLocation;
+        private String defaultRegion;
+        private Map<String, String> customProperties;
+    }
+} 

src/main/java/com/dalab/autoarchival/model/ArchivalResult.java

@@ -0,0 +1,88 @@
+package com.dalab.autoarchival.model;
+
+/**
+ * DTO to hold the results of an archival operation.
+ */
+public class ArchivalResult {
+
+    private String archiveId;          // Unique identifier for the created archive (e.g., S3 Object Version ID, Glacier Archive ID).
+    private String storageLocation;    // URI or path to the archived object (e.g., s3://bucket/key, gs://bucket/object).
+    private long sizeBytes;            // Size of the archived data in bytes.
+    private String checksum;           // Checksum (e.g., MD5, SHA256) of the archived data, if available.
+    private String storageClass;       // Actual storage class used (e.g., GLACIER, DEEP_ARCHIVE).
+    private java.time.OffsetDateTime archivalTimestamp; // Timestamp when the archival was completed.
+
+    // Constructors
+    public ArchivalResult() {
+    }
+
+    public ArchivalResult(String archiveId, String storageLocation, long sizeBytes, String checksum, String storageClass, java.time.OffsetDateTime archivalTimestamp) {
+        this.archiveId = archiveId;
+        this.storageLocation = storageLocation;
+        this.sizeBytes = sizeBytes;
+        this.checksum = checksum;
+        this.storageClass = storageClass;
+        this.archivalTimestamp = archivalTimestamp;
+    }
+
+    // Getters and Setters
+    public String getArchiveId() {
+        return archiveId;
+    }
+
+    public void setArchiveId(String archiveId) {
+        this.archiveId = archiveId;
+    }
+
+    public String getStorageLocation() {
+        return storageLocation;
+    }
+
+    public void setStorageLocation(String storageLocation) {
+        this.storageLocation = storageLocation;
+    }
+
+    public long getSizeBytes() {
+        return sizeBytes;
+    }
+
+    public void setSizeBytes(long sizeBytes) {
+        this.sizeBytes = sizeBytes;
+    }
+
+    public String getChecksum() {
+        return checksum;
+    }
+
+    public void setChecksum(String checksum) {
+        this.checksum = checksum;
+    }
+
+    public String getStorageClass() {
+        return storageClass;
+    }
+
+    public void setStorageClass(String storageClass) {
+        this.storageClass = storageClass;
+    }
+
+    public java.time.OffsetDateTime getArchivalTimestamp() {
+        return archivalTimestamp;
+    }
+
+    public void setArchivalTimestamp(java.time.OffsetDateTime archivalTimestamp) {
+        this.archivalTimestamp = archivalTimestamp;
+    }
+
+    @Override
+    public String toString() {
+        return "ArchivalResult{" +
+                "archiveId='" + archiveId + '\'' +
+                ", storageLocation='" + storageLocation + '\'' +
+                ", sizeBytes=" + sizeBytes +
+                ", checksum='" + checksum + '\'' +
+                ", storageClass='" + storageClass + '\'' +
+                ", archivalTimestamp=" + archivalTimestamp +
+                '}';
+    }
+} 

src/main/java/com/dalab/autoarchival/model/ArchivalStatus.java

@@ -0,0 +1,17 @@
+package com.dalab.autoarchival.model;
+
+public enum ArchivalStatus {
+    PENDING_APPROVAL,
+    APPROVED, // Approved, ready for processing or being processed
+    REJECTED,
+    SUBMITTED, // Submitted directly, no approval needed, or post-approval
+    IN_PROGRESS,
+    COMPLETED,
+    PARTIALLY_COMPLETED,
+    FAILED,
+    CANCELLED,
+    RESTORATION_REQUESTED,
+    RESTORATION_IN_PROGRESS,
+    RESTORED, // Assets are available
+    RESTORATION_FAILED
+} 

src/main/java/com/dalab/autoarchival/model/ArchivalTask.java

@@ -0,0 +1,67 @@
+package com.dalab.autoarchival.model;
+
+import java.time.OffsetDateTime;
+import java.util.Map;
+
+/**
+ * Represents an archival task.
+ * This is a placeholder and would typically be a JPA entity or a more detailed DTO.
+ */
+public class ArchivalTask {
+
+    private String taskId;
+    private String assetId; // ID of the asset to be archived/restored
+    private String originalDataSourceProvider; // e.g., "AWS", "GCP", "AZURE"
+    private String originalDataSourceDetails; // e.g., S3 bucket/key, GCS object path
+    private ArchivalStatus status;
+
+    // Fields to store results from ICloudArchivalProvider
+    private String archiveId; // From ArchivalResult
+    private String archiveStorageLocation; // From ArchivalResult
+    private String restoreJobId; // From RestoreResult
+    private OffsetDateTime lastArchivedAt;
+    private OffsetDateTime lastRestoreInitiatedAt;
+
+    private Map<String, String> providerConfiguration; // To store provider specific config like target bucket/storage class for THIS task
+
+
+    public enum ArchivalStatus {
+        PENDING_ARCHIVAL,
+        ARCHIVAL_IN_PROGRESS,
+        ARCHIVED,
+        PENDING_RESTORATION,
+        RESTORATION_IN_PROGRESS,
+        RESTORED,
+        FAILED_ARCHIVAL,
+        FAILED_RESTORATION
+    }
+
+    // Constructors, Getters, Setters
+    public ArchivalTask(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 getOriginalDataSourceProvider() { return originalDataSourceProvider; }
+    public void setOriginalDataSourceProvider(String originalDataSourceProvider) { this.originalDataSourceProvider = originalDataSourceProvider; }
+    public String getOriginalDataSourceDetails() { return originalDataSourceDetails; }
+    public void setOriginalDataSourceDetails(String originalDataSourceDetails) { this.originalDataSourceDetails = originalDataSourceDetails; }
+    public ArchivalStatus getStatus() { return status; }
+    public void setStatus(ArchivalStatus status) { this.status = status; }
+    public String getArchiveId() { return archiveId; }
+    public void setArchiveId(String archiveId) { this.archiveId = archiveId; }
+    public String getArchiveStorageLocation() { return archiveStorageLocation; }
+    public void setArchiveStorageLocation(String archiveStorageLocation) { this.archiveStorageLocation = archiveStorageLocation; }
+    public String getRestoreJobId() { return restoreJobId; }
+    public void setRestoreJobId(String restoreJobId) { this.restoreJobId = restoreJobId; }
+    public OffsetDateTime getLastArchivedAt() { return lastArchivedAt; }
+    public void setLastArchivedAt(OffsetDateTime lastArchivedAt) { this.lastArchivedAt = lastArchivedAt; }
+    public OffsetDateTime getLastRestoreInitiatedAt() { return lastRestoreInitiatedAt; }
+    public void setLastRestoreInitiatedAt(OffsetDateTime lastRestoreInitiatedAt) { this.lastRestoreInitiatedAt = lastRestoreInitiatedAt; }
+    public Map<String, String> getProviderConfiguration() { return providerConfiguration; }
+    public void setProviderConfiguration(Map<String, String> providerConfiguration) { this.providerConfiguration = providerConfiguration; }
+} 

src/main/java/com/dalab/autoarchival/model/ArchivalTaskEntity.java

@@ -0,0 +1,98 @@
+package com.dalab.autoarchival.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;
+
+@Entity
+@Table(name = "dalab_archival_tasks")
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class ArchivalTaskEntity {
+
+    @Id
+    private String taskId;
+
+    private String taskName;
+
+    @Enumerated(EnumType.STRING)
+    private ArchivalStatus status;
+
+    private LocalDateTime submittedAt;
+    private LocalDateTime startedAt;
+    private LocalDateTime completedAt;
+
+    private String triggeredBy;
+    private String justification;
+
+    @JdbcTypeCode(SqlTypes.JSON)
+    @Column(columnDefinition = "jsonb")
+    private ArchivalScopeData scope; // Store as JSON
+
+    @JdbcTypeCode(SqlTypes.JSON)
+    @Column(columnDefinition = "jsonb")
+    private ArchivalConfigOverrideData overrideConfig; // Store as JSON
+
+    private int totalAssetsInScope;
+    private int assetsArchivedSuccessfully;
+    private int assetsFailedToArchive;
+    private int assetsPendingArchival;
+
+    @JdbcTypeCode(SqlTypes.JSON)
+    @Column(columnDefinition = "jsonb")
+    private List<AssetArchivalStatusData> assetStatuses; // Store as JSON
+
+    @JdbcTypeCode(SqlTypes.JSON)
+    @Column(columnDefinition = "jsonb")
+    private List<String> errorMessages; // Store as JSON
+    
+    private String approvalComments;
+    private String rejectionComments;
+
+    @JdbcTypeCode(SqlTypes.JSON)
+    @Column(columnDefinition = "jsonb")
+    private RestoreRequestData restoreRequestDetails; // Store restore request as JSON
+    private LocalDateTime lastRestoreRequestedAt;
+    private String lastRestoreStatus;
+
+
+    // Static inner classes for JSONB data
+    @Data @NoArgsConstructor @AllArgsConstructor
+    public static class ArchivalScopeData {
+        private List<String> assetIds;
+    }
+
+    @Data @NoArgsConstructor @AllArgsConstructor
+    public static class ArchivalConfigOverrideData {
+        private String targetArchivalTier;
+        private Long retentionDays;
+    }
+
+    @Data @NoArgsConstructor @AllArgsConstructor
+    public static class AssetArchivalStatusData {
+        private String assetId;
+        private String assetName;
+        private String status; // PENDING, IN_PROGRESS, ARCHIVED, FAILED, RESTORED
+        private String archivalLocation;
+        private String errorMessage;
+        private LocalDateTime archivedAt;
+        private LocalDateTime restoredAt;
+    }
+
+    @Data @NoArgsConstructor @AllArgsConstructor
+    public static class RestoreRequestData {
+        private String restoreTier;
+        private int availabilityDays;
+        private String triggeredBy;
+        private String justification;
+        private LocalDateTime requestedAt;
+    }
+} 

src/main/java/com/dalab/autoarchival/model/RestoreResult.java

@@ -0,0 +1,66 @@
+package com.dalab.autoarchival.model;
+
+/**
+ * DTO to hold the results of a restore initiation operation.
+ */
+public class RestoreResult {
+
+    private String restoreJobId;        // Identifier for the restore job (e.g., Glacier Job ID).
+    private String statusMessage;       // Initial status or message from the provider (e.g., "Restore initiated").
+    private java.time.OffsetDateTime estimatedCompletionTime; // Estimated time when data will be available, if provided.
+    private String retrievalTier;       // Tier used for retrieval (e.g., Standard, Expedited, Bulk for Glacier).
+
+    // Constructors
+    public RestoreResult() {
+    }
+
+    public RestoreResult(String restoreJobId, String statusMessage, java.time.OffsetDateTime estimatedCompletionTime, String retrievalTier) {
+        this.restoreJobId = restoreJobId;
+        this.statusMessage = statusMessage;
+        this.estimatedCompletionTime = estimatedCompletionTime;
+        this.retrievalTier = retrievalTier;
+    }
+
+    // Getters and Setters
+    public String getRestoreJobId() {
+        return restoreJobId;
+    }
+
+    public void setRestoreJobId(String restoreJobId) {
+        this.restoreJobId = restoreJobId;
+    }
+
+    public String getStatusMessage() {
+        return statusMessage;
+    }
+
+    public void setStatusMessage(String statusMessage) {
+        this.statusMessage = statusMessage;
+    }
+
+    public java.time.OffsetDateTime getEstimatedCompletionTime() {
+        return estimatedCompletionTime;
+    }
+
+    public void setEstimatedCompletionTime(java.time.OffsetDateTime estimatedCompletionTime) {
+        this.estimatedCompletionTime = estimatedCompletionTime;
+    }
+
+    public String getRetrievalTier() {
+        return retrievalTier;
+    }
+
+    public void setRetrievalTier(String retrievalTier) {
+        this.retrievalTier = retrievalTier;
+    }
+
+    @Override
+    public String toString() {
+        return "RestoreResult{" +
+                "restoreJobId='" + restoreJobId + '\'' +
+                ", statusMessage='" + statusMessage + '\'' +
+                ", estimatedCompletionTime=" + estimatedCompletionTime +
+                ", retrievalTier='" + retrievalTier + '\'' +
+                '}';
+    }
+} 

src/main/java/com/dalab/autoarchival/provider/AwsS3GlacierArchivalProvider.java

@@ -0,0 +1,43 @@
+package com.dalab.autoarchival.provider;
+
+import java.io.InputStream;
+import java.util.Map;
+
+import org.springframework.stereotype.Component;
+
+import com.dalab.autoarchival.exception.ArchivalException;
+import com.dalab.autoarchival.model.ArchivalResult;
+import com.dalab.autoarchival.model.ArchivalTask;
+import com.dalab.autoarchival.model.RestoreResult;
+
+@Component // Or configure as a bean in a config class
+public class AwsS3GlacierArchivalProvider implements ICloudArchivalProvider {
+
+    private static final String PROVIDER_TYPE = "AWS";
+    private static final String NOT_IMPLEMENTED_MESSAGE = "AWS S3/Glacier archival feature is not yet implemented.";
+
+    @Override
+    public String getProviderType() {
+        return PROVIDER_TYPE;
+    }
+
+    @Override
+    public ArchivalResult archive(ArchivalTask task, InputStream dataToArchive, Map<String, String> providerSpecificConfig) throws ArchivalException {
+        // TODO: Implement AWS S3/Glacier archival logic
+        // 1. Configure AWS S3 Client (consider S3AsyncClient for non-blocking)
+        // 2. Determine target bucket, key, storage class (e.g., GLACIER, DEEP_ARCHIVE) from providerSpecificConfig or task
+        // 3. Upload InputStream to S3 with appropriate storage class.
+        // 4. Populate and return ArchivalResult.
+        throw new ArchivalException(NOT_IMPLEMENTED_MESSAGE);
+    }
+
+    @Override
+    public RestoreResult initiateRestore(ArchivalTask task, Map<String, String> providerSpecificConfig) throws ArchivalException {
+        // TODO: Implement AWS S3/Glacier restore initiation logic
+        // 1. Configure AWS S3 Client.
+        // 2. Use task.getArchiveId() or task.getArchiveStorageLocation() to identify the object.
+        // 3. Initiate restore request (e.g., s3Client.restoreObjectV2(...)).
+        // 4. Populate and return RestoreResult.
+        throw new ArchivalException(NOT_IMPLEMENTED_MESSAGE);
+    }
+} 

src/main/java/com/dalab/autoarchival/provider/GcsArchiveStorageProvider.java

@@ -0,0 +1,40 @@
+package com.dalab.autoarchival.provider;
+
+import com.dalab.autoarchival.exception.ArchivalException;
+import com.dalab.autoarchival.model.ArchivalResult;
+import com.dalab.autoarchival.model.ArchivalTask;
+import com.dalab.autoarchival.model.RestoreResult;
+import org.springframework.stereotype.Component;
+
+import java.io.InputStream;
+import java.util.Map;
+
+@Component // Or configure as a bean in a config class
+public class GcsArchiveStorageProvider implements ICloudArchivalProvider {
+
+    private static final String PROVIDER_TYPE = "GCP";
+    private static final String NOT_IMPLEMENTED_MESSAGE = "GCP Cloud Storage archival feature is not yet implemented.";
+
+    @Override
+    public String getProviderType() {
+        return PROVIDER_TYPE;
+    }
+
+    @Override
+    public ArchivalResult archive(ArchivalTask task, InputStream dataToArchive, Map<String, String> providerSpecificConfig) throws ArchivalException {
+        // TODO: Implement GCS archival logic
+        // 1. Configure GCS Storage client.
+        // 2. Determine target bucket, object name, storage class (e.g., ARCHIVE) from providerSpecificConfig or task.
+        // 3. Upload InputStream to GCS.
+        // 4. Populate and return ArchivalResult.
+        throw new ArchivalException(NOT_IMPLEMENTED_MESSAGE);
+    }
+
+    @Override
+    public RestoreResult initiateRestore(ArchivalTask task, Map<String, String> providerSpecificConfig) throws ArchivalException {
+        // TODO: Implement GCS restore logic (GCS restore is typically just changing storage class or direct download if not in coldline/archive that requires restore step)
+        // For GCS "Archive" class, objects are accessible directly but with higher retrieval costs/times.
+        // A "restore" might mean copying to a standard storage class bucket or simply noting accessibility.
+        throw new ArchivalException(NOT_IMPLEMENTED_MESSAGE);
+    }
+} 

src/main/java/com/dalab/autoarchival/provider/ICloudArchivalProvider.java

@@ -0,0 +1,50 @@
+package com.dalab.autoarchival.provider;
+
+import com.dalab.autoarchival.model.ArchivalTask; 
+import com.dalab.autoarchival.model.ArchivalResult;
+import com.dalab.autoarchival.model.RestoreResult;
+import com.dalab.autoarchival.exception.ArchivalException;
+
+import java.io.InputStream;
+import java.util.Map;
+
+/**
+ * Interface for cloud-specific archival storage providers.
+ * Implementations will handle the actual interaction with services like AWS S3 Glacier, GCS Archive, etc.
+ */
+public interface ICloudArchivalProvider {
+
+    /**
+     * Gets the specific cloud provider type this provider supports (e.g., "AWS", "GCP").
+     * This can be used by a factory to select the correct provider.
+     * @return The cloud provider type identifier.
+     */
+    String getProviderType();
+
+    /**
+     * Archives the given data stream for the specified archival task.
+     *
+     * @param task The ArchivalTask entity containing details about the asset and archival job.
+     * @param dataToArchive An InputStream containing the data to be archived.
+     * @param providerSpecificConfig Configuration specific to this provider (e.g., bucket name, region, storage class).
+     * @return An ArchivalResult containing details of the archival operation (e.g., archive ID, location).
+     * @throws ArchivalException if any error occurs during the archival process.
+     */
+    ArchivalResult archive(ArchivalTask task, InputStream dataToArchive, Map<String, String> providerSpecificConfig) throws ArchivalException;
+
+    /**
+     * Initiates the restoration of an archived asset.
+     * For some services (like Glacier), this might be an asynchronous operation.
+     *
+     * @param task The ArchivalTask entity for which data needs to be restored.
+     *             It should contain necessary identifiers from a previous successful archival.
+     * @param providerSpecificConfig Configuration specific to this provider.
+     * @return A RestoreResult indicating the status of the restore initiation (e.g., job ID for tracking).
+     * @throws ArchivalException if any error occurs during the restore initiation.
+     */
+    RestoreResult initiateRestore(ArchivalTask task, Map<String, String> providerSpecificConfig) throws ArchivalException;
+
+    // Optional methods for more detailed restore management - can be added later
+    // String getRestoreStatus(ArchivalTask task, String restoreJobId, Map<String, String> providerSpecificConfig) throws ArchivalException;
+    // InputStream retrieveRestoredData(ArchivalTask task, String restoreJobId, Map<String, String> providerSpecificConfig) throws ArchivalException;
+} 

src/main/java/com/dalab/autoarchival/repository/ArchivalConfigRepository.java

@@ -0,0 +1,11 @@
+package com.dalab.autoarchival.repository;
+
+import com.dalab.autoarchival.model.ArchivalConfigEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface ArchivalConfigRepository extends JpaRepository<ArchivalConfigEntity, Long> {
+    // Since it's a global config with a fixed ID, specific find methods might not be needed
+    // Can use findById(1L)
+} 

src/main/java/com/dalab/autoarchival/repository/ArchivalTaskRepository.java

@@ -0,0 +1,10 @@
+package com.dalab.autoarchival.repository;
+
+import com.dalab.autoarchival.model.ArchivalTaskEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface ArchivalTaskRepository extends JpaRepository<ArchivalTaskEntity, String> {
+    // Add custom query methods if needed, e.g., findByStatus, findByTriggeredBy, etc.
+} 

src/main/java/com/dalab/autoarchival/service/IArchivalConfigService.java

@@ -0,0 +1,18 @@
+package com.dalab.autoarchival.service;
+
+import com.dalab.autoarchival.dto.ArchivalConfigDTO;
+
+public interface IArchivalConfigService {
+
+    /**
+     * Retrieves the current archival configuration.
+     * @return The current ArchivalConfigDTO, or a default/empty one if not configured.
+     */
+    ArchivalConfigDTO getArchivalConfig();
+
+    /**
+     * Updates the archival configuration.
+     * @param archivalConfigDTO The new configuration to apply.
+     */
+    void updateArchivalConfig(ArchivalConfigDTO archivalConfigDTO);
+} 

src/main/java/com/dalab/autoarchival/service/IArchivalTaskService.java

@@ -0,0 +1,78 @@
+package com.dalab.autoarchival.service;
+
+import com.dalab.autoarchival.dto.ArchivalTaskListResponse;
+import com.dalab.autoarchival.dto.ArchivalTaskRequest;
+import com.dalab.autoarchival.dto.ArchivalTaskResponse;
+import com.dalab.autoarchival.dto.ArchivalTaskStatusDTO;
+import com.dalab.autoarchival.dto.TaskApprovalRequest;
+import com.dalab.autoarchival.dto.RestoreRequestDTO;
+import com.dalab.autoarchival.dto.RestoreResponseDTO;
+// Potentially add other DTOs like ArchivalTaskSummaryDTO if needed for other methods
+import org.springframework.data.domain.Pageable;
+
+public interface IArchivalTaskService {
+
+    /**
+     * Submits a new archival task.
+     *
+     * @param request The archival task request.
+     * @return ArchivalTaskResponse indicating the outcome of the submission.
+     */
+    ArchivalTaskResponse submitArchivalTask(ArchivalTaskRequest request);
+
+    /**
+     * Retrieves the status of a specific archival task.
+     *
+     * @param taskId The ID of the task.
+     * @return ArchivalTaskStatusDTO containing the detailed status, or null if not found.
+     */
+    ArchivalTaskStatusDTO getTaskStatus(String taskId);
+
+    /**
+     * Lists all archival tasks with pagination.
+     *
+     * @param pageable Pagination information.
+     * @return ArchivalTaskListResponse containing the paginated list of tasks.
+     */
+    ArchivalTaskListResponse listTasks(Pageable pageable);
+
+    /**
+     * Approves a task.
+     *
+     * @param taskId The ID of the task to be approved.
+     * @param approvalRequest DTO containing approval parameters.
+     * @return ArchivalTaskStatusDTO indicating the outcome of the approval.
+     */
+    ArchivalTaskStatusDTO approveTask(String taskId, TaskApprovalRequest approvalRequest);
+
+    /**
+     * Rejects a task.
+     *
+     * @param taskId The ID of the task to be rejected.
+     * @param rejectionRequest DTO containing rejection parameters.
+     * @return ArchivalTaskStatusDTO indicating the outcome of the rejection.
+     */
+    ArchivalTaskStatusDTO rejectTask(String taskId, TaskApprovalRequest rejectionRequest);
+
+    /**
+     * Requests restoration of assets associated with an archival task.
+     *
+     * @param taskId The ID of the original archival task whose assets are to be restored.
+     * @param restoreRequest DTO containing restore parameters.
+     * @return RestoreResponseDTO indicating the outcome of the restore request.
+     */
+    RestoreResponseDTO requestRestore(String taskId, RestoreRequestDTO restoreRequest);
+
+    /**
+     * Processes archival action from policy engine events.
+     *
+     * @param event The policy action event containing archival instructions.
+     */
+    void processArchivalAction(java.util.Map<String, Object> event);
+
+    // Future methods:
+    // Page<ArchivalTaskSummaryDTO> listTasks(Pageable pageable);
+    // void approveTask(String taskId, String approverComments);
+    // void rejectTask(String taskId, String rejectorComments);
+    // ArchivalTaskResponse requestRestore(String taskId, RestoreRequestDTO restoreRequest);
+} 

src/main/java/com/dalab/autoarchival/service/impl/ArchivalConfigServiceImpl.java

@@ -0,0 +1,76 @@
+package com.dalab.autoarchival.service.impl;
+
+import com.dalab.autoarchival.dto.ArchivalConfigDTO;
+import com.dalab.autoarchival.mapper.ArchivalConfigMapper;
+import com.dalab.autoarchival.model.ArchivalConfigEntity;
+import com.dalab.autoarchival.repository.ArchivalConfigRepository;
+import com.dalab.autoarchival.service.IArchivalConfigService;
+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.HashMap;
+import java.util.Optional;
+
+@Service("archivalConfigService") // Specify bean name to avoid conflict if InMemory still exists
+@RequiredArgsConstructor
+@Slf4j
+public class ArchivalConfigServiceImpl implements IArchivalConfigService {
+
+    private final ArchivalConfigRepository configRepository;
+    private final ArchivalConfigMapper configMapper;
+    private static final Long GLOBAL_CONFIG_ID = 1L;
+
+    @PostConstruct
+    public void init() {
+        // Ensure a default config exists if the DB is empty
+        if (!configRepository.existsById(GLOBAL_CONFIG_ID)) {
+            log.info("No global archival configuration found. Initializing with default values.");
+            ArchivalConfigEntity defaultConfig = new ArchivalConfigEntity(
+                    GLOBAL_CONFIG_ID,
+                    false, // enabled
+                    "STANDARD_ARCHIVE", // defaultArchivalTier
+                    3650L, // defaultRetentionDays (10 years)
+                    true, // requireApprovalForArchival
+                    true,  // requireApprovalForRestore
+                    new HashMap<>() // providerConfigs
+            );
+            configRepository.save(defaultConfig);
+        }
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public ArchivalConfigDTO getArchivalConfig() {
+        log.debug("Fetching global archival configuration.");
+        Optional<ArchivalConfigEntity> entityOptional = configRepository.findById(GLOBAL_CONFIG_ID);
+        // Should always exist due to PostConstruct, but handle defensively
+        return entityOptional.map(configMapper::toDto)
+                .orElseGet(() -> {
+                    log.warn("Global archival configuration (ID: {}) not found, returning empty DTO. This should not happen after initialization.", GLOBAL_CONFIG_ID);
+                    return new ArchivalConfigDTO(); // Or throw exception
+                });
+    }
+
+    @Override
+    @Transactional
+    public void updateArchivalConfig(ArchivalConfigDTO archivalConfigDTO) {
+        if (archivalConfigDTO == null) {
+            throw new IllegalArgumentException("Archival configuration DTO cannot be null.");
+        }
+        log.info("Updating global archival configuration.");
+        ArchivalConfigEntity entity = configRepository.findById(GLOBAL_CONFIG_ID)
+                .orElseThrow(() -> {
+                    log.error("Global archival config (ID: {}) not found for update. This is unexpected.", GLOBAL_CONFIG_ID);
+                    return new IllegalStateException("Global archival configuration not found for update.");
+                });
+        
+        configMapper.updateEntityFromDto(archivalConfigDTO, entity);
+        // Ensure ID is not changed by mapper if DTO carries it over
+        entity.setId(GLOBAL_CONFIG_ID); 
+        configRepository.save(entity);
+        log.info("Global archival configuration updated successfully.");
+    }
+} 

src/main/java/com/dalab/autoarchival/service/impl/ArchivalTaskNotFoundException.java

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

src/main/java/com/dalab/autoarchival/service/impl/ArchivalTaskServiceImpl.java

@@ -0,0 +1,225 @@
+package com.dalab.autoarchival.service.impl;
+
+import java.time.LocalDateTime;
+import java.util.Collections;
+import java.util.List;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+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 com.dalab.autoarchival.dto.ArchivalConfigDTO;
+import com.dalab.autoarchival.dto.ArchivalTaskListResponse;
+import com.dalab.autoarchival.dto.ArchivalTaskRequest;
+import com.dalab.autoarchival.dto.ArchivalTaskResponse;
+import com.dalab.autoarchival.dto.ArchivalTaskStatusDTO;
+import com.dalab.autoarchival.dto.RestoreRequestDTO;
+import com.dalab.autoarchival.dto.RestoreResponseDTO;
+import com.dalab.autoarchival.dto.TaskApprovalRequest;
+import com.dalab.autoarchival.mapper.ArchivalTaskMapper;
+import com.dalab.autoarchival.model.ArchivalStatus;
+import com.dalab.autoarchival.model.ArchivalTaskEntity;
+import com.dalab.autoarchival.repository.ArchivalTaskRepository;
+import com.dalab.autoarchival.service.IArchivalConfigService;
+import com.dalab.autoarchival.service.IArchivalTaskService;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+@Service("archivalTaskService") // Specify bean name
+@RequiredArgsConstructor
+@Slf4j
+public class ArchivalTaskServiceImpl implements IArchivalTaskService {
+
+    private final ArchivalTaskRepository taskRepository;
+    private final ArchivalTaskMapper taskMapper;
+    private final IArchivalConfigService archivalConfigService; // JPA version
+
+    @Override
+    @Transactional
+    public ArchivalTaskResponse submitArchivalTask(ArchivalTaskRequest request) {
+        log.info("Submitting new archival task: {}", request.getTaskName());
+        if (request.getScope() == null || request.getScope().getAssetIds() == null || request.getScope().getAssetIds().isEmpty()) {
+            log.warn("Archival task submission failed for task {}: Asset IDs are missing.", request.getTaskName());
+            // Not creating an entity for a failed validation that doesn't hit DB
+            return ArchivalTaskResponse.builder()
+                    .taskId(null) // No ID generated
+                    .taskName(request.getTaskName())
+                    .status("FAILED_VALIDATION")
+                    .submittedAt(LocalDateTime.now())
+                    .message("Archival scope must contain at least one asset ID.")
+                    .build();
+        }
+
+        ArchivalTaskEntity entity = taskMapper.requestToEntity(request);
+        entity.setTaskId(UUID.randomUUID().toString());
+        entity.setSubmittedAt(LocalDateTime.now());
+
+        ArchivalConfigDTO globalConfig = archivalConfigService.getArchivalConfig();
+        if (globalConfig.isRequireApprovalForArchival()) {
+            entity.setStatus(ArchivalStatus.PENDING_APPROVAL);
+        } else {
+            entity.setStatus(ArchivalStatus.SUBMITTED);
+            // TODO: If not pending approval, potentially trigger async processing immediately
+        }
+        
+        // Initialize asset statuses if scope is present
+        if (request.getScope() != null && request.getScope().getAssetIds() != null) {
+            List<ArchivalTaskEntity.AssetArchivalStatusData> initialAssetStatuses = request.getScope().getAssetIds().stream()
+                .map(assetId -> new ArchivalTaskEntity.AssetArchivalStatusData(assetId, null, "PENDING", null, null, null, null))
+                .collect(Collectors.toList());
+            entity.setAssetStatuses(initialAssetStatuses);
+            entity.setAssetsPendingArchival(initialAssetStatuses.size());
+        }
+
+        ArchivalTaskEntity savedEntity = taskRepository.save(entity);
+        log.info("Archival task {} submitted with ID {} and status {}.", savedEntity.getTaskName(), savedEntity.getTaskId(), savedEntity.getStatus());
+        return taskMapper.entityToTaskResponse(savedEntity);
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public ArchivalTaskStatusDTO getTaskStatus(String taskId) {
+        log.debug("Fetching status for archival task ID: {}", taskId);
+        return taskRepository.findById(taskId)
+                .map(taskMapper::entityToStatusDTO)
+                .orElse(null);
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public ArchivalTaskListResponse listTasks(Pageable pageable) {
+        log.debug("Listing archival tasks with pagination: {}", pageable);
+        Page<ArchivalTaskEntity> taskPage = taskRepository.findAll(pageable);
+        List<ArchivalTaskStatusDTO> dtoList = taskPage.getContent().stream()
+                .map(taskMapper::entityToStatusDTO)
+                .collect(Collectors.toList());
+        PageImpl<ArchivalTaskStatusDTO> dtoPage = new PageImpl<>(dtoList, pageable, taskPage.getTotalElements());
+        return ArchivalTaskListResponse.fromPage(dtoPage);
+    }
+
+    @Override
+    @Transactional
+    public ArchivalTaskStatusDTO approveTask(String taskId, TaskApprovalRequest approvalRequest) {
+        log.info("Approving archival task ID: {}", taskId);
+        ArchivalTaskEntity task = taskRepository.findById(taskId)
+                .orElseThrow(() -> new ArchivalTaskNotFoundException(taskId, "approve"));
+
+        if (task.getStatus() != ArchivalStatus.PENDING_APPROVAL) {
+            log.warn("Cannot approve task {}: not in PENDING_APPROVAL state (current: {}).", taskId, task.getStatus());
+            // Return current status with an error message if desired, or throw specific exception
+            ArchivalTaskStatusDTO currentStatusDto = taskMapper.entityToStatusDTO(task);
+            currentStatusDto.setErrorMessages(Collections.singletonList("Task is not in a state that can be approved."));
+            return currentStatusDto;
+        }
+        task.setStatus(ArchivalStatus.APPROVED); // Or SUBMITTED to enter processing queue
+        if (approvalRequest != null) {
+            task.setApprovalComments(approvalRequest.getComments());
+        }
+        // TODO: Trigger async processing if approval is the gate
+        ArchivalTaskEntity savedTask = taskRepository.save(task);
+        return taskMapper.entityToStatusDTO(savedTask);
+    }
+
+    @Override
+    @Transactional
+    public ArchivalTaskStatusDTO rejectTask(String taskId, TaskApprovalRequest rejectionRequest) {
+        log.info("Rejecting archival task ID: {}", taskId);
+        ArchivalTaskEntity task = taskRepository.findById(taskId)
+                .orElseThrow(() -> new ArchivalTaskNotFoundException(taskId, "reject"));
+
+        if (task.getStatus() != ArchivalStatus.PENDING_APPROVAL) {
+            log.warn("Cannot reject task {}: not in PENDING_APPROVAL state (current: {}).", taskId, task.getStatus());
+            ArchivalTaskStatusDTO currentStatusDto = taskMapper.entityToStatusDTO(task);
+            currentStatusDto.setErrorMessages(Collections.singletonList("Task is not in a state that can be rejected."));
+            return currentStatusDto;
+        }
+        task.setStatus(ArchivalStatus.REJECTED);
+        if (rejectionRequest != null) {
+            task.setRejectionComments(rejectionRequest.getComments());
+        }
+        ArchivalTaskEntity savedTask = taskRepository.save(task);
+        return taskMapper.entityToStatusDTO(savedTask);
+    }
+
+    @Override
+    @Transactional
+    public RestoreResponseDTO requestRestore(String taskId, RestoreRequestDTO restoreRequestDto) {
+        log.info("Requesting restore for archival task ID: {}", taskId);
+        ArchivalTaskEntity task = taskRepository.findById(taskId)
+                .orElseThrow(() -> new ArchivalTaskNotFoundException(taskId, "restore request"));
+
+        // Typically, only COMPLETED or ARCHIVED tasks can be restored
+        if (task.getStatus() != ArchivalStatus.COMPLETED && task.getStatus() != ArchivalStatus.APPROVED /* if APPROVED implies archived */ ) {
+            log.warn("Cannot restore task {}: not in a restorable state (current: {}).", taskId, task.getStatus());
+            return RestoreResponseDTO.builder()
+                    .archivalTaskId(taskId)
+                    .status("NOT_RESTORABLE")
+                    .requestedAt(LocalDateTime.now())
+                    .message("Archival task is not in a state that allows restoration.")
+                    .build();
+        }
+        
+        task.setRestoreRequestDetails(taskMapper.restoreRequestDtoToData(restoreRequestDto));
+        task.getRestoreRequestDetails().setRequestedAt(LocalDateTime.now()); // Ensure request time is set
+        task.setLastRestoreRequestedAt(LocalDateTime.now());
+        task.setLastRestoreStatus(ArchivalStatus.RESTORATION_REQUESTED.name());
+        task.setStatus(ArchivalStatus.RESTORATION_REQUESTED); // Update main task status
+
+        // TODO: Trigger async restore process. This process should:
+        // 1. Iterate task.getAssetStatuses()
+        // 2. For each asset, call cloud provider API to initiate restore from task.assetStatuses[i].archivalLocation
+        // 3. Update task.assetStatuses[i].status to RESTORATION_IN_PROGRESS, then RESTORED/FAILED
+        // 4. Update task.assetsRestoredSuccessfully etc. counts
+        // 5. Update task.status (main) to RESTORATION_IN_PROGRESS, then RESTORED or PARTIALLY_COMPLETED / RESTORATION_FAILED
+        
+        ArchivalTaskEntity savedTask = taskRepository.save(task);
+        log.info("Restore initiated for task {}. New status: {}. Restore Tier: {}", 
+                 savedTask.getTaskId(), savedTask.getStatus(), restoreRequestDto.getRestoreTier());
+
+        return RestoreResponseDTO.builder()
+                .restoreTaskId(savedTask.getTaskId()) // Using archival task ID as restore task ID for now
+                .archivalTaskId(savedTask.getTaskId())
+                .status(savedTask.getStatus().name())
+                .requestedAt(savedTask.getLastRestoreRequestedAt())
+                .message("Restore process initiated.")
+                .build();
+    }
+
+    @Override
+    public void processArchivalAction(java.util.Map<String, Object> event) {
+        // Extract relevant information from the event
+        String eventId = (String) event.get("eventId");
+        String policyId = (String) event.get("policyId");
+        String actionType = (String) event.get("actionType");
+        String assetId = (String) event.get("assetId");
+        
+        log.info("Processing archival action for event: {}, policy: {}, asset: {}", eventId, policyId, assetId);
+        
+        try {
+            // Create an archival scope with the asset ID
+            ArchivalTaskRequest.ArchivalScope scope = ArchivalTaskRequest.ArchivalScope.builder()
+                    .assetIds(java.util.List.of(assetId))
+                    .build();
+            
+            // Create an archival task request based on the policy action
+            ArchivalTaskRequest request = ArchivalTaskRequest.builder()
+                    .taskName("Auto-archival from policy " + policyId)
+                    .scope(scope)
+                    .justification("Automated archival triggered by policy engine")
+                    .build();
+            
+            // Submit the archival task
+            ArchivalTaskResponse response = submitArchivalTask(request);
+            log.info("Successfully created archival task {} for event {}", response.getTaskId(), eventId);
+            
+        } catch (Exception e) {
+            log.error("Failed to process archival action for event {}: {}", eventId, e.getMessage(), e);
+            throw new RuntimeException("Failed to process archival action", e);
+        }
+    }
+} 

src/main/java/com/dalab/autoarchival/service/storage/ArchivalResult.java

@@ -0,0 +1,33 @@
+package com.dalab.autoarchival.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 an archival operation.
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class ArchivalResult {
+    
+    private UUID assetId;
+    private String operationId;
+    private String sourceLocation;
+    private String archivedLocation;
+    private String targetTier;
+    private OperationStatus status;
+    private LocalDateTime initiatedAt;
+    private LocalDateTime completedAt;
+    private Long dataSizeBytes;
+    private Map<String, String> metadata;
+    private String errorMessage;
+    private Double estimatedMonthlySavings;
+} 

src/main/java/com/dalab/autoarchival/service/storage/CostSavingsEstimate.java

@@ -0,0 +1,26 @@
+package com.dalab.autoarchival.service.storage;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * Cost savings estimate for archival operations.
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class CostSavingsEstimate {
+    
+    private String sourceStorageClass;
+    private String targetStorageClass;
+    private Long dataSizeBytes;
+    private Double currentMonthlyCost;
+    private Double archivedMonthlyCost;
+    private Double monthlySavings;
+    private Double savingsPercentage;
+    private String currency;
+    private String region;
+} 

src/main/java/com/dalab/autoarchival/service/storage/ICloudStorageService.java

@@ -0,0 +1,74 @@
+package com.dalab.autoarchival.service.storage;
+
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * Interface for cloud storage operations supporting archival and restoration.
+ * Abstracts different cloud providers (AWS S3/Glacier, Azure Blob, GCP Cloud Storage).
+ */
+public interface ICloudStorageService {
+
+    /**
+     * Archive data to cold storage tier.
+     * 
+     * @param assetId The unique identifier of the asset being archived
+     * @param sourceLocation The original location of the data (e.g., S3 key, blob name)
+     * @param targetTier The target storage tier (e.g., "GLACIER", "ARCHIVE", "COLDLINE")
+     * @param metadata Additional metadata to store with the archived object
+     * @return ArchivalResult containing the archived location and operation details
+     */
+    ArchivalResult archiveData(UUID assetId, String sourceLocation, String targetTier, Map<String, String> metadata);
+
+    /**
+     * Restore data from cold storage to accessible tier.
+     * 
+     * @param assetId The unique identifier of the asset being restored
+     * @param archivedLocation The location of the archived data
+     * @param targetTier The target tier for restoration (e.g., "STANDARD", "HOT")
+     * @return RestorationResult containing the restoration job details
+     */
+    RestorationResult restoreData(UUID assetId, String archivedLocation, String targetTier);
+
+    /**
+     * Get the status of an archival operation.
+     * 
+     * @param operationId The ID of the archival operation
+     * @return OperationStatus indicating the current state
+     */
+    OperationStatus getArchivalStatus(String operationId);
+
+    /**
+     * Get the status of a restoration operation.
+     * 
+     * @param operationId The ID of the restoration operation
+     * @return OperationStatus indicating the current state
+     */
+    OperationStatus getRestorationStatus(String operationId);
+
+    /**
+     * Calculate the cost savings from archiving data.
+     * 
+     * @param sourceLocation The original location
+     * @param targetTier The archival tier
+     * @param dataSizeBytes The size of data in bytes
+     * @return CostSavingsEstimate with monthly savings information
+     */
+    CostSavingsEstimate calculateCostSavings(String sourceLocation, String targetTier, long dataSizeBytes);
+
+    /**
+     * Check if the storage 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 storage tiers for the cloud provider.
+     * 
+     * @param cloudProvider The cloud provider
+     * @return Array of available tier names
+     */
+    String[] getAvailableStorageTiers(String cloudProvider);
+} 

src/main/java/com/dalab/autoarchival/service/storage/OperationStatus.java

@@ -0,0 +1,13 @@
+package com.dalab.autoarchival.service.storage;
+
+/**
+ * Status of cloud storage operations (archival/restoration).
+ */
+public enum OperationStatus {
+    INITIATED,
+    IN_PROGRESS,
+    COMPLETED,
+    FAILED,
+    CANCELLED,
+    PENDING_APPROVAL
+} 

src/main/java/com/dalab/autoarchival/service/storage/RestorationResult.java

@@ -0,0 +1,32 @@
+package com.dalab.autoarchival.service.storage;
+
+import java.time.LocalDateTime;
+import java.util.UUID;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * Result of a restoration operation.
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class RestorationResult {
+    
+    private UUID assetId;
+    private String operationId;
+    private String archivedLocation;
+    private String restoredLocation;
+    private String targetTier;
+    private OperationStatus status;
+    private LocalDateTime initiatedAt;
+    private LocalDateTime completedAt;
+    private LocalDateTime expiresAt; // For temporary restoration
+    private Long dataSizeBytes;
+    private String errorMessage;
+    private Double estimatedCost;
+} 

src/main/java/com/dalab/autoarchival/service/storage/impl/AwsS3StorageService.java

@@ -0,0 +1,272 @@
+package com.dalab.autoarchival.service.storage.impl;
+
+import java.time.LocalDateTime;
+import java.util.Map;
+import java.util.UUID;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+
+import com.dalab.autoarchival.service.storage.ArchivalResult;
+import com.dalab.autoarchival.service.storage.CostSavingsEstimate;
+import com.dalab.autoarchival.service.storage.ICloudStorageService;
+import com.dalab.autoarchival.service.storage.OperationStatus;
+import com.dalab.autoarchival.service.storage.RestorationResult;
+
+import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
+import software.amazon.awssdk.regions.Region;
+import software.amazon.awssdk.services.s3.S3Client;
+import software.amazon.awssdk.services.s3.model.CopyObjectRequest;
+import software.amazon.awssdk.services.s3.model.HeadObjectRequest;
+import software.amazon.awssdk.services.s3.model.HeadObjectResponse;
+import software.amazon.awssdk.services.s3.model.RestoreObjectRequest;
+import software.amazon.awssdk.services.s3.model.RestoreRequest;
+import software.amazon.awssdk.services.s3.model.StorageClass;
+import software.amazon.awssdk.services.s3.model.Tier;
+
+/**
+ * AWS S3 implementation of cloud storage service for archival operations.
+ * Supports S3 Standard, S3 IA, S3 Glacier, and S3 Glacier Deep Archive.
+ */
+@Service
+public class AwsS3StorageService implements ICloudStorageService {
+
+    private static final Logger log = LoggerFactory.getLogger(AwsS3StorageService.class);
+
+    private final S3Client s3Client;
+    private final String defaultRegion;
+
+    // Cost per GB per month (USD) - these are approximate values
+    private static final double STANDARD_COST_PER_GB = 0.023;
+    private static final double IA_COST_PER_GB = 0.0125;
+    private static final double GLACIER_COST_PER_GB = 0.004;
+    private static final double DEEP_ARCHIVE_COST_PER_GB = 0.00099;
+
+    public AwsS3StorageService(@Value("${aws.region:us-east-1}") String region) {
+        this.defaultRegion = region;
+        this.s3Client = S3Client.builder()
+                .region(Region.of(region))
+                .credentialsProvider(DefaultCredentialsProvider.create())
+                .build();
+    }
+
+    @Override
+    public ArchivalResult archiveData(UUID assetId, String sourceLocation, String targetTier, Map<String, String> metadata) {
+        log.info("Archiving asset {} from {} to tier {}", assetId, sourceLocation, targetTier);
+        
+        try {
+            // Parse S3 location (format: s3://bucket/key)
+            String[] parts = parseS3Location(sourceLocation);
+            String bucket = parts[0];
+            String key = parts[1];
+            
+            // Get object metadata
+            HeadObjectResponse headResponse = s3Client.headObject(HeadObjectRequest.builder()
+                    .bucket(bucket)
+                    .key(key)
+                    .build());
+            
+            // Create copy request with new storage class
+            StorageClass storageClass = mapToS3StorageClass(targetTier);
+            String operationId = UUID.randomUUID().toString();
+            
+            CopyObjectRequest copyRequest = CopyObjectRequest.builder()
+                    .sourceBucket(bucket)
+                    .sourceKey(key)
+                    .destinationBucket(bucket)
+                    .destinationKey(key)
+                    .storageClass(storageClass)
+                    .metadata(metadata)
+                    .build();
+            
+            s3Client.copyObject(copyRequest);
+            
+            return ArchivalResult.builder()
+                    .assetId(assetId)
+                    .operationId(operationId)
+                    .sourceLocation(sourceLocation)
+                    .archivedLocation(sourceLocation) // Same location, different storage class
+                    .targetTier(targetTier)
+                    .status(OperationStatus.COMPLETED)
+                    .initiatedAt(LocalDateTime.now())
+                    .completedAt(LocalDateTime.now())
+                    .dataSizeBytes(headResponse.contentLength())
+                    .metadata(metadata)
+                    .estimatedMonthlySavings(calculateMonthlySavings("STANDARD", targetTier, headResponse.contentLength()))
+                    .build();
+                    
+        } catch (Exception e) {
+            log.error("Failed to archive asset {}: {}", assetId, e.getMessage(), e);
+            return ArchivalResult.builder()
+                    .assetId(assetId)
+                    .operationId(UUID.randomUUID().toString())
+                    .sourceLocation(sourceLocation)
+                    .targetTier(targetTier)
+                    .status(OperationStatus.FAILED)
+                    .initiatedAt(LocalDateTime.now())
+                    .errorMessage(e.getMessage())
+                    .build();
+        }
+    }
+
+    @Override
+    public RestorationResult restoreData(UUID assetId, String archivedLocation, String targetTier) {
+        log.info("Restoring asset {} from {} to tier {}", assetId, archivedLocation, targetTier);
+        
+        try {
+            String[] parts = parseS3Location(archivedLocation);
+            String bucket = parts[0];
+            String key = parts[1];
+            
+            String operationId = UUID.randomUUID().toString();
+            
+            // For Glacier/Deep Archive, initiate restore request
+            if (targetTier.equals("STANDARD") || targetTier.equals("EXPEDITED")) {
+                RestoreRequest restoreRequest = RestoreRequest.builder()
+                        .days(7) // Restore for 7 days
+                        .glacierJobParameters(builder -> builder.tier(Tier.STANDARD))
+                        .build();
+                
+                RestoreObjectRequest request = RestoreObjectRequest.builder()
+                        .bucket(bucket)
+                        .key(key)
+                        .restoreRequest(restoreRequest)
+                        .build();
+                
+                s3Client.restoreObject(request);
+                
+                return RestorationResult.builder()
+                        .assetId(assetId)
+                        .operationId(operationId)
+                        .archivedLocation(archivedLocation)
+                        .restoredLocation(archivedLocation)
+                        .targetTier(targetTier)
+                        .status(OperationStatus.IN_PROGRESS)
+                        .initiatedAt(LocalDateTime.now())
+                        .expiresAt(LocalDateTime.now().plusDays(7))
+                        .estimatedCost(0.01) // Approximate restore cost
+                        .build();
+            }
+            
+            // For other tiers, use copy operation
+            return RestorationResult.builder()
+                    .assetId(assetId)
+                    .operationId(operationId)
+                    .archivedLocation(archivedLocation)
+                    .restoredLocation(archivedLocation)
+                    .targetTier(targetTier)
+                    .status(OperationStatus.COMPLETED)
+                    .initiatedAt(LocalDateTime.now())
+                    .completedAt(LocalDateTime.now())
+                    .build();
+                    
+        } catch (Exception e) {
+            log.error("Failed to restore asset {}: {}", assetId, e.getMessage(), e);
+            return RestorationResult.builder()
+                    .assetId(assetId)
+                    .operationId(UUID.randomUUID().toString())
+                    .archivedLocation(archivedLocation)
+                    .targetTier(targetTier)
+                    .status(OperationStatus.FAILED)
+                    .initiatedAt(LocalDateTime.now())
+                    .errorMessage(e.getMessage())
+                    .build();
+        }
+    }
+
+    @Override
+    public OperationStatus getArchivalStatus(String operationId) {
+        // In a real implementation, you would track operation status in a database
+        // For now, return COMPLETED as archival operations are typically synchronous
+        return OperationStatus.COMPLETED;
+    }
+
+    @Override
+    public OperationStatus getRestorationStatus(String operationId) {
+        // In a real implementation, you would check the actual restore status
+        // For now, return IN_PROGRESS for demonstration
+        return OperationStatus.IN_PROGRESS;
+    }
+
+    @Override
+    public CostSavingsEstimate calculateCostSavings(String sourceLocation, String targetTier, long dataSizeBytes) {
+        double dataSizeGB = dataSizeBytes / (1024.0 * 1024.0 * 1024.0);
+        
+        double currentCost = STANDARD_COST_PER_GB * dataSizeGB;
+        double targetCost = getCostPerGB(targetTier) * dataSizeGB;
+        double savings = currentCost - targetCost;
+        double savingsPercentage = (savings / currentCost) * 100;
+        
+        return CostSavingsEstimate.builder()
+                .sourceStorageClass("STANDARD")
+                .targetStorageClass(targetTier)
+                .dataSizeBytes(dataSizeBytes)
+                .currentMonthlyCost(currentCost)
+                .archivedMonthlyCost(targetCost)
+                .monthlySavings(savings)
+                .savingsPercentage(savingsPercentage)
+                .currency("USD")
+                .region(defaultRegion)
+                .build();
+    }
+
+    @Override
+    public boolean supportsCloudProvider(String cloudProvider) {
+        return "AWS".equalsIgnoreCase(cloudProvider);
+    }
+
+    @Override
+    public String[] getAvailableStorageTiers(String cloudProvider) {
+        if (supportsCloudProvider(cloudProvider)) {
+            return new String[]{"STANDARD", "STANDARD_IA", "GLACIER", "DEEP_ARCHIVE"};
+        }
+        return new String[0];
+    }
+
+    private String[] parseS3Location(String s3Location) {
+        // Parse s3://bucket/key format
+        if (!s3Location.startsWith("s3://")) {
+            throw new IllegalArgumentException("Invalid S3 location format: " + s3Location);
+        }
+        
+        String withoutProtocol = s3Location.substring(5);
+        int firstSlash = withoutProtocol.indexOf('/');
+        if (firstSlash == -1) {
+            throw new IllegalArgumentException("Invalid S3 location format: " + s3Location);
+        }
+        
+        String bucket = withoutProtocol.substring(0, firstSlash);
+        String key = withoutProtocol.substring(firstSlash + 1);
+        
+        return new String[]{bucket, key};
+    }
+
+    private StorageClass mapToS3StorageClass(String targetTier) {
+        return switch (targetTier.toUpperCase()) {
+            case "STANDARD" -> StorageClass.STANDARD;
+            case "STANDARD_IA" -> StorageClass.STANDARD_IA;
+            case "GLACIER" -> StorageClass.GLACIER;
+            case "DEEP_ARCHIVE" -> StorageClass.DEEP_ARCHIVE;
+            default -> throw new IllegalArgumentException("Unsupported storage tier: " + targetTier);
+        };
+    }
+
+    private double getCostPerGB(String storageClass) {
+        return switch (storageClass.toUpperCase()) {
+            case "STANDARD" -> STANDARD_COST_PER_GB;
+            case "STANDARD_IA" -> IA_COST_PER_GB;
+            case "GLACIER" -> GLACIER_COST_PER_GB;
+            case "DEEP_ARCHIVE" -> DEEP_ARCHIVE_COST_PER_GB;
+            default -> STANDARD_COST_PER_GB;
+        };
+    }
+
+    private double calculateMonthlySavings(String sourceClass, String targetClass, long dataSizeBytes) {
+        double dataSizeGB = dataSizeBytes / (1024.0 * 1024.0 * 1024.0);
+        double sourceCost = getCostPerGB(sourceClass) * dataSizeGB;
+        double targetCost = getCostPerGB(targetClass) * dataSizeGB;
+        return Math.max(0, sourceCost - targetCost);
+    }
+} 

src/main/resources/application.properties

@@ -0,0 +1,67 @@
+# DALab AutoArchival Service Configuration
+spring.application.name=da-autoarchival
+server.port=8080
+
+# Database Configuration - da_autoarchival database
+spring.datasource.url=jdbc:postgresql://localhost:5432/da_autoarchival
+spring.datasource.username=da_autoarchival_user
+spring.datasource.password=da_autoarchival_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-autoarchival-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.archival-events=dalab.archival.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/Glacier Configuration
+aws.s3.region=us-east-1
+aws.s3.bucket.archival=dalab-archival-bucket
+aws.glacier.vault.name=dalab-glacier-vault
+
+# Azure Blob Storage Configuration
+azure.storage.account.name=dalabarchival
+azure.storage.container.archival=archival-container
+
+# Google Cloud Storage Configuration
+gcp.storage.project.id=dalab-project
+gcp.storage.bucket.archival=dalab-gcp-archival
+
+# Archival Configuration
+archival.default.retention.days=2555  # 7 years
+archival.cost.optimization.threshold=0.3  # 30% savings threshold
+archival.batch.size=100
+
+# Actuator Configuration
+management.endpoints.web.exposure.include=health,info,metrics,prometheus
+management.endpoint.health.show-details=when-authorized
+management.metrics.export.prometheus.enabled=true
+
+# Logging Configuration
+logging.level.com.dalab.autoarchival=INFO
+logging.level.org.springframework.kafka=WARN
+logging.level.org.springframework.security=WARN 

src/test/java/com/dalab/autoarchival/controller/ArchivalConfigControllerTest.java

@@ -0,0 +1,99 @@
+package com.dalab.autoarchival.controller;
+
+import com.dalab.autoarchival.dto.ArchivalConfigDTO;
+import com.dalab.autoarchival.service.IArchivalConfigService;
+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.HashMap;
+
+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(ArchivalConfigController.class)
+class ArchivalConfigControllerTest {
+
+    @Autowired
+    private MockMvc mockMvc;
+
+    @MockBean
+    private IArchivalConfigService archivalConfigService;
+
+    @Autowired
+    private ObjectMapper objectMapper;
+
+    private ArchivalConfigDTO sampleConfigDTO;
+
+    @BeforeEach
+    void setUp() {
+        sampleConfigDTO = ArchivalConfigDTO.builder()
+                .enabled(true)
+                .defaultArchivalTier("S3_GLACIER")
+                .defaultRetentionDays(365L)
+                .requireApprovalForArchival(true)
+                .requireApprovalForRestore(false)
+                .providerConfigs(new HashMap<>()) 
+                .build();
+    }
+
+    @Test
+    @WithMockUser(authorities = "ROLE_ADMIN")
+    void getArchivalConfiguration_AsAdmin_ShouldReturnConfig() throws Exception {
+        when(archivalConfigService.getArchivalConfig()).thenReturn(sampleConfigDTO);
+
+        mockMvc.perform(get("/api/v1/archival/config"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.enabled").value(true))
+                .andExpect(jsonPath("$.defaultArchivalTier").value("S3_GLACIER"));
+    }
+
+    @Test
+    @WithMockUser(authorities = "ROLE_DATA_STEWARD")
+    void getArchivalConfiguration_AsDataSteward_ShouldReturnConfig() throws Exception {
+        when(archivalConfigService.getArchivalConfig()).thenReturn(sampleConfigDTO);
+
+        mockMvc.perform(get("/api/v1/archival/config"))
+                .andExpect(status().isOk());
+    }
+    
+    @Test
+    @WithMockUser(authorities = "ROLE_USER")
+    void getArchivalConfiguration_AsUser_ShouldBeForbidden() throws Exception {
+        mockMvc.perform(get("/api/v1/archival/config"))
+                .andExpect(status().isForbidden());
+    }
+
+    @Test
+    @WithMockUser(authorities = "ROLE_ADMIN")
+    void updateArchivalConfiguration_AsAdmin_ShouldReturnOk() throws Exception {
+        doNothing().when(archivalConfigService).updateArchivalConfig(any(ArchivalConfigDTO.class));
+
+        mockMvc.perform(put("/api/v1/archival/config")
+                        .with(csrf()) // Add CSRF token for PUT if Spring Security CSRF is enabled
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(sampleConfigDTO)))
+                .andExpect(status().isOk());
+
+        verify(archivalConfigService, times(1)).updateArchivalConfig(any(ArchivalConfigDTO.class));
+    }
+
+    @Test
+    @WithMockUser(authorities = "ROLE_DATA_STEWARD")
+    void updateArchivalConfiguration_AsDataSteward_ShouldBeForbidden() throws Exception {
+        mockMvc.perform(put("/api/v1/archival/config")
+                        .with(csrf())
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(sampleConfigDTO)))
+                .andExpect(status().isForbidden());
+    }
+} 

src/test/java/com/dalab/autoarchival/controller/ArchivalTaskControllerTest.java

@@ -0,0 +1,192 @@
+package com.dalab.autoarchival.controller;
+
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.*;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
+
+import java.time.LocalDateTime;
+import java.util.Collections;
+import java.util.List;
+import java.util.UUID;
+
+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.Pageable;
+import org.springframework.http.MediaType;
+import org.springframework.security.test.context.support.WithMockUser;
+import org.springframework.test.web.servlet.MockMvc;
+
+import com.dalab.autoarchival.dto.ArchivalTaskListResponse;
+import com.dalab.autoarchival.dto.ArchivalTaskRequest;
+import com.dalab.autoarchival.dto.ArchivalTaskResponse;
+import com.dalab.autoarchival.dto.ArchivalTaskStatusDTO;
+import com.dalab.autoarchival.dto.RestoreRequestDTO;
+import com.dalab.autoarchival.dto.RestoreResponseDTO;
+import com.dalab.autoarchival.service.IArchivalTaskService;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+@WebMvcTest(ArchivalTaskController.class)
+class ArchivalTaskControllerTest {
+
+    @Autowired
+    private MockMvc mockMvc;
+
+    @MockBean
+    private IArchivalTaskService taskService;
+
+    @Autowired
+    private ObjectMapper objectMapper;
+
+    private ArchivalTaskRequest sampleTaskRequest;
+    private ArchivalTaskResponse sampleTaskResponse;
+    private ArchivalTaskStatusDTO sampleTaskStatusDTO;
+    private String sampleTaskId;
+
+    @BeforeEach
+    void setUp() {
+        sampleTaskId = UUID.randomUUID().toString();
+
+        ArchivalTaskRequest.ArchivalScope scope = ArchivalTaskRequest.ArchivalScope.builder()
+                .assetIds(List.of("asset1", "asset2"))
+                .build();
+        sampleTaskRequest = ArchivalTaskRequest.builder()
+                .taskName("Test Archival Task")
+                .scope(scope)
+                .build();
+
+        sampleTaskResponse = ArchivalTaskResponse.builder()
+                .taskId(sampleTaskId)
+                .taskName("Test Archival Task")
+                .status("SUBMITTED")
+                .submittedAt(LocalDateTime.now())
+                .build();
+        
+        sampleTaskStatusDTO = ArchivalTaskStatusDTO.builder()
+                .taskId(sampleTaskId)
+                .taskName("Test Archival Task")
+                .status("SUBMITTED")
+                .submittedAt(LocalDateTime.now())
+                .scope(scope)
+                .totalAssetsInScope(2)
+                .build();
+    }
+
+    @Test
+    @WithMockUser(authorities = "ROLE_ADMIN")
+    void submitArchivalTask_AsAdmin_ShouldReturnAccepted() throws Exception {
+        when(taskService.submitArchivalTask(any(ArchivalTaskRequest.class))).thenReturn(sampleTaskResponse);
+
+        mockMvc.perform(post("/api/v1/archival/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 submitArchivalTask_WithInvalidScope_ShouldReturnBadRequest() throws Exception {
+        ArchivalTaskRequest invalidRequest = ArchivalTaskRequest.builder().taskName("Invalid Task").scope(null).build();
+        ArchivalTaskResponse validationResponse = ArchivalTaskResponse.builder()
+                                .status("FAILED_VALIDATION").message("Scope is null").build();
+        when(taskService.submitArchivalTask(any(ArchivalTaskRequest.class))).thenReturn(validationResponse);
+
+        mockMvc.perform(post("/api/v1/archival/tasks")
+                        .with(csrf())
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(invalidRequest)))
+                .andExpect(status().isBadRequest());
+    }
+
+    @Test
+    @WithMockUser(authorities = "ROLE_USER") // Assuming USER can get status
+    void getArchivalTaskStatus_WhenTaskExists_ShouldReturnStatus() throws Exception {
+        when(taskService.getTaskStatus(sampleTaskId)).thenReturn(sampleTaskStatusDTO);
+
+        mockMvc.perform(get("/api/v1/archival/tasks/{taskId}", sampleTaskId))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.taskId").value(sampleTaskId))
+                .andExpect(jsonPath("$.status").value("SUBMITTED"));
+    }
+
+    @Test
+    @WithMockUser(authorities = "ROLE_USER")
+    void getArchivalTaskStatus_WhenTaskNotExists_ShouldReturnNotFound() throws Exception {
+        when(taskService.getTaskStatus(sampleTaskId)).thenReturn(null);
+
+        mockMvc.perform(get("/api/v1/archival/tasks/{taskId}", sampleTaskId))
+                .andExpect(status().isNotFound());
+    }
+
+    @Test
+    @WithMockUser(authorities = "ROLE_USER")
+    void listArchivalTasks_ShouldReturnPageOfTasks() throws Exception {
+        ArchivalTaskListResponse listResponse = ArchivalTaskListResponse.builder()
+                .tasks(Collections.singletonList(sampleTaskStatusDTO))
+                .pageNumber(0).pageSize(20).totalElements(1).totalPages(1).last(true).first(true).numberOfElements(1)
+                .build();
+        when(taskService.listTasks(any(Pageable.class))).thenReturn(listResponse);
+
+        mockMvc.perform(get("/api/v1/archival/tasks").param("page", "0").param("size", "20"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.tasks[0].taskId").value(sampleTaskId));
+    }
+
+    @Test
+    @WithMockUser(authorities = "ROLE_ADMIN")
+    void approveArchivalTask_AsAdmin_ShouldReturnOk() throws Exception {
+        ArchivalTaskStatusDTO approvedStatus = ArchivalTaskStatusDTO.builder().taskId(sampleTaskId).status("APPROVED").build();
+        when(taskService.approveTask(eq(sampleTaskId), any())).thenReturn(approvedStatus);
+
+        mockMvc.perform(post("/api/v1/archival/tasks/{taskId}/approve", sampleTaskId)
+                        .with(csrf()))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.status").value("APPROVED"));
+    }
+    
+    @Test
+    @WithMockUser(authorities = "ROLE_ADMIN")
+    void approveArchivalTask_NotApprovable_ShouldReturnConflict() throws Exception {
+        ArchivalTaskStatusDTO conflictStatus = ArchivalTaskStatusDTO.builder().taskId(sampleTaskId).status("COMPLETED").build();
+        when(taskService.approveTask(eq(sampleTaskId), any())).thenReturn(conflictStatus);
+
+        mockMvc.perform(post("/api/v1/archival/tasks/{taskId}/approve", sampleTaskId)
+                        .with(csrf()))
+                .andExpect(status().isConflict());
+    }
+
+
+    @Test
+    @WithMockUser(authorities = "ROLE_ADMIN")
+    void rejectArchivalTask_AsAdmin_ShouldReturnOk() throws Exception {
+        ArchivalTaskStatusDTO rejectedStatus = ArchivalTaskStatusDTO.builder().taskId(sampleTaskId).status("REJECTED").build();
+        when(taskService.rejectTask(eq(sampleTaskId), any())).thenReturn(rejectedStatus);
+
+        mockMvc.perform(post("/api/v1/archival/tasks/{taskId}/reject", sampleTaskId)
+                        .with(csrf()))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.status").value("REJECTED"));
+    }
+
+    @Test
+    @WithMockUser(authorities = "ROLE_ADMIN")
+    void requestRestoreArchivalTask_AsAdmin_ShouldReturnAccepted() throws Exception {
+        RestoreRequestDTO restoreRequest = RestoreRequestDTO.builder().restoreTier("STANDARD").retentionDays(7).build();
+        RestoreResponseDTO restoreResponse = RestoreResponseDTO.builder().archivalTaskId(sampleTaskId).status("RESTORATION_REQUESTED").build();
+        when(taskService.requestRestore(eq(sampleTaskId), any(RestoreRequestDTO.class))).thenReturn(restoreResponse);
+
+        mockMvc.perform(post("/api/v1/archival/tasks/{taskId}/restore", sampleTaskId)
+                        .with(csrf())
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(restoreRequest)))
+                .andExpect(status().isAccepted())
+                .andExpect(jsonPath("$.status").value("RESTORATION_REQUESTED"));
+    }
+} 

src/test/java/com/dalab/autoarchival/service/impl/ArchivalConfigServiceImplTest.java

@@ -0,0 +1,103 @@
+package com.dalab.autoarchival.service.impl;
+
+import com.dalab.autoarchival.dto.ArchivalConfigDTO;
+import com.dalab.autoarchival.mapper.ArchivalConfigMapper;
+import com.dalab.autoarchival.model.ArchivalConfigEntity;
+import com.dalab.autoarchival.repository.ArchivalConfigRepository;
+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.Optional;
+import java.util.HashMap;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class ArchivalConfigServiceImplTest {
+
+    @Mock
+    private ArchivalConfigRepository configRepository;
+
+    @Mock
+    private ArchivalConfigMapper configMapper;
+
+    @InjectMocks
+    private ArchivalConfigServiceImpl configService;
+
+    private ArchivalConfigEntity sampleEntity;
+    private ArchivalConfigDTO sampleDTO;
+    private static final Long GLOBAL_CONFIG_ID = 1L;
+
+    @BeforeEach
+    void setUp() {
+        sampleEntity = new ArchivalConfigEntity(
+                GLOBAL_CONFIG_ID, true, "S3_STANDARD", 30L, true, true, new HashMap<>()
+        );
+        sampleDTO = ArchivalConfigDTO.builder()
+                .enabled(true).defaultArchivalTier("S3_STANDARD").defaultRetentionDays(30L)
+                .requireApprovalForArchival(true).requireApprovalForRestore(true).providerConfigs(new HashMap<>()).build();
+    }
+
+    @Test
+    void init_WhenConfigExists_ShouldNotSave() {
+        when(configRepository.existsById(GLOBAL_CONFIG_ID)).thenReturn(true);
+        configService.init();
+        verify(configRepository, never()).save(any(ArchivalConfigEntity.class));
+    }
+
+    @Test
+    void init_WhenConfigNotExists_ShouldSaveDefault() {
+        when(configRepository.existsById(GLOBAL_CONFIG_ID)).thenReturn(false);
+        when(configRepository.save(any(ArchivalConfigEntity.class))).thenReturn(sampleEntity); // Mock save
+        configService.init();
+        verify(configRepository, times(1)).save(any(ArchivalConfigEntity.class));
+    }
+
+    @Test
+    void getArchivalConfig_ShouldReturnMappedDTO() {
+        when(configRepository.findById(GLOBAL_CONFIG_ID)).thenReturn(Optional.of(sampleEntity));
+        when(configMapper.toDto(sampleEntity)).thenReturn(sampleDTO);
+
+        ArchivalConfigDTO result = configService.getArchivalConfig();
+
+        assertNotNull(result);
+        assertEquals(sampleDTO.getDefaultArchivalTier(), result.getDefaultArchivalTier());
+        verify(configRepository, times(1)).findById(GLOBAL_CONFIG_ID);
+        verify(configMapper, times(1)).toDto(sampleEntity);
+    }
+
+    @Test
+    void updateArchivalConfig_ShouldUpdateAndSaveFolder() {
+        when(configRepository.findById(GLOBAL_CONFIG_ID)).thenReturn(Optional.of(sampleEntity));
+        // configMapper.updateEntityFromDto is void, so mock it if necessary (e.g. with doNothing() or verify interaction)
+        doNothing().when(configMapper).updateEntityFromDto(eq(sampleDTO), eq(sampleEntity));
+        when(configRepository.save(any(ArchivalConfigEntity.class))).thenReturn(sampleEntity);
+        
+        configService.updateArchivalConfig(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 updateArchivalConfig_WhenDtoIsNull_ShouldThrowException() {
+        assertThrows(IllegalArgumentException.class, () -> {
+            configService.updateArchivalConfig(null);
+        });
+    }
+    
+    @Test
+    void updateArchivalConfig_WhenEntityNotFound_ShouldThrowException() {
+        when(configRepository.findById(GLOBAL_CONFIG_ID)).thenReturn(Optional.empty());
+        assertThrows(IllegalStateException.class, () -> {
+            configService.updateArchivalConfig(sampleDTO);
+        });
+    }
+} 

src/test/java/com/dalab/autoarchival/service/impl/ArchivalTaskServiceImplTest.java

@@ -0,0 +1,246 @@
+package com.dalab.autoarchival.service.impl;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+import java.time.LocalDateTime;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+
+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 com.dalab.autoarchival.dto.ArchivalConfigDTO;
+import com.dalab.autoarchival.dto.ArchivalTaskListResponse;
+import com.dalab.autoarchival.dto.ArchivalTaskRequest;
+import com.dalab.autoarchival.dto.ArchivalTaskResponse;
+import com.dalab.autoarchival.dto.ArchivalTaskStatusDTO;
+import com.dalab.autoarchival.dto.RestoreRequestDTO;
+import com.dalab.autoarchival.dto.RestoreResponseDTO;
+import com.dalab.autoarchival.dto.TaskApprovalRequest;
+import com.dalab.autoarchival.mapper.ArchivalTaskMapper;
+import com.dalab.autoarchival.model.ArchivalStatus;
+import com.dalab.autoarchival.model.ArchivalTaskEntity;
+import com.dalab.autoarchival.repository.ArchivalTaskRepository;
+import com.dalab.autoarchival.service.IArchivalConfigService;
+
+@ExtendWith(MockitoExtension.class)
+class ArchivalTaskServiceImplTest {
+
+    @Mock
+    private ArchivalTaskRepository taskRepository;
+
+    @Mock
+    private ArchivalTaskMapper taskMapper;
+
+    @Mock
+    private IArchivalConfigService archivalConfigService; // JPA version
+
+    @InjectMocks
+    private ArchivalTaskServiceImpl taskService;
+
+    private ArchivalTaskRequest sampleTaskRequest;
+    private ArchivalTaskEntity sampleTaskEntity;
+    private ArchivalTaskStatusDTO sampleTaskStatusDTO;
+    private ArchivalTaskResponse sampleTaskResponse;
+    private String sampleTaskId;
+    private ArchivalConfigDTO globalConfigNoApproval;
+    private ArchivalConfigDTO globalConfigWithApproval;
+
+    @BeforeEach
+    void setUp() {
+        sampleTaskId = UUID.randomUUID().toString();
+        ArchivalTaskRequest.ArchivalScope scope = ArchivalTaskRequest.ArchivalScope.builder()
+                .assetIds(List.of("asset1")).build();
+
+        sampleTaskRequest = ArchivalTaskRequest.builder()
+                .taskName("Test Task")
+                .scope(scope)
+                .triggeredBy("user@test.com")
+                .build();
+
+        sampleTaskEntity = new ArchivalTaskEntity();
+        sampleTaskEntity.setTaskId(sampleTaskId);
+        sampleTaskEntity.setTaskName("Test Task");
+        sampleTaskEntity.setStatus(ArchivalStatus.SUBMITTED);
+        sampleTaskEntity.setSubmittedAt(LocalDateTime.now());
+        sampleTaskEntity.setScope(new ArchivalTaskEntity.ArchivalScopeData(List.of("asset1")));
+
+        sampleTaskStatusDTO = ArchivalTaskStatusDTO.builder().taskId(sampleTaskId).status("SUBMITTED").build();
+        sampleTaskResponse = ArchivalTaskResponse.builder().taskId(sampleTaskId).status("SUBMITTED").build();
+        
+        globalConfigNoApproval = ArchivalConfigDTO.builder().requireApprovalForArchival(false).build();
+        globalConfigWithApproval = ArchivalConfigDTO.builder().requireApprovalForArchival(true).build();
+    }
+
+    @Test
+    void submitArchivalTask_ValidRequest_NoApprovalNeeded_ShouldSaveAndReturnResponse() {
+        when(archivalConfigService.getArchivalConfig()).thenReturn(globalConfigNoApproval);
+        when(taskMapper.requestToEntity(sampleTaskRequest)).thenReturn(sampleTaskEntity);
+        when(taskRepository.save(any(ArchivalTaskEntity.class))).thenReturn(sampleTaskEntity);
+        when(taskMapper.entityToTaskResponse(sampleTaskEntity)).thenReturn(sampleTaskResponse);
+
+        ArchivalTaskResponse response = taskService.submitArchivalTask(sampleTaskRequest);
+
+        assertNotNull(response);
+        assertEquals("SUBMITTED", response.getStatus());
+        ArgumentCaptor<ArchivalTaskEntity> entityCaptor = ArgumentCaptor.forClass(ArchivalTaskEntity.class);
+        verify(taskRepository).save(entityCaptor.capture());
+        assertEquals(ArchivalStatus.SUBMITTED, entityCaptor.getValue().getStatus());
+        assertNotNull(entityCaptor.getValue().getAssetStatuses());
+        assertEquals(1, entityCaptor.getValue().getAssetsPendingArchival());
+    }
+    
+    @Test
+    void submitArchivalTask_ValidRequest_ApprovalNeeded_ShouldSetPendingApproval() {
+        when(archivalConfigService.getArchivalConfig()).thenReturn(globalConfigWithApproval);
+        when(taskMapper.requestToEntity(sampleTaskRequest)).thenReturn(sampleTaskEntity);
+        when(taskRepository.save(any(ArchivalTaskEntity.class))).thenReturn(sampleTaskEntity);
+        when(taskMapper.entityToTaskResponse(sampleTaskEntity)).thenReturn(sampleTaskResponse);
+
+        taskService.submitArchivalTask(sampleTaskRequest);
+
+        ArgumentCaptor<ArchivalTaskEntity> entityCaptor = ArgumentCaptor.forClass(ArchivalTaskEntity.class);
+        verify(taskRepository).save(entityCaptor.capture());
+        assertEquals(ArchivalStatus.PENDING_APPROVAL, entityCaptor.getValue().getStatus());
+    }
+
+    @Test
+    void submitArchivalTask_InvalidScope_ShouldReturnFailedValidation() {
+        ArchivalTaskRequest invalidRequest = ArchivalTaskRequest.builder().scope(null).build();
+        ArchivalTaskResponse response = taskService.submitArchivalTask(invalidRequest);
+        assertEquals("FAILED_VALIDATION", 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);
+
+        ArchivalTaskStatusDTO result = taskService.getTaskStatus(sampleTaskId);
+
+        assertNotNull(result);
+        assertEquals(sampleTaskId, result.getTaskId());
+    }
+
+    @Test
+    void getTaskStatus_TaskNotExists_ShouldReturnNull() {
+        when(taskRepository.findById(sampleTaskId)).thenReturn(Optional.empty());
+        ArchivalTaskStatusDTO result = taskService.getTaskStatus(sampleTaskId);
+        assertNull(result);
+    }
+
+    @Test
+    void listTasks_ShouldReturnPaginatedDTOs() {
+        Pageable pageable = PageRequest.of(0, 10);
+        Page<ArchivalTaskEntity> page = new PageImpl<>(Collections.singletonList(sampleTaskEntity), pageable, 1);
+        when(taskRepository.findAll(pageable)).thenReturn(page);
+        when(taskMapper.entityToStatusDTO(sampleTaskEntity)).thenReturn(sampleTaskStatusDTO);
+
+        ArchivalTaskListResponse 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(ArchivalStatus.PENDING_APPROVAL);
+        when(taskRepository.findById(sampleTaskId)).thenReturn(Optional.of(sampleTaskEntity));
+        when(taskRepository.save(any(ArchivalTaskEntity.class))).thenReturn(sampleTaskEntity);
+        when(taskMapper.entityToStatusDTO(sampleTaskEntity)).thenAnswer(inv -> {
+            ArchivalTaskEntity e = inv.getArgument(0);
+            return ArchivalTaskStatusDTO.builder().taskId(e.getTaskId()).status(e.getStatus().name()).build();
+        });
+
+        TaskApprovalRequest approvalReq = TaskApprovalRequest.builder().comments("Approved").build();
+        ArchivalTaskStatusDTO result = taskService.approveTask(sampleTaskId, approvalReq);
+
+        assertEquals("APPROVED", result.getStatus());
+        assertEquals("Approved", sampleTaskEntity.getApprovalComments());
+        verify(taskRepository).save(sampleTaskEntity);
+    }
+
+    @Test
+    void approveTask_TaskNotPending_ShouldReturnCurrentStatusWithErrors() {
+        sampleTaskEntity.setStatus(ArchivalStatus.COMPLETED);
+        when(taskRepository.findById(sampleTaskId)).thenReturn(Optional.of(sampleTaskEntity));
+        when(taskMapper.entityToStatusDTO(sampleTaskEntity)).thenReturn(ArchivalTaskStatusDTO.builder().status("COMPLETED").build());
+
+        ArchivalTaskStatusDTO result = taskService.approveTask(sampleTaskId, new TaskApprovalRequest());
+
+        assertEquals("COMPLETED", 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(ArchivalTaskNotFoundException.class, () -> {
+            taskService.approveTask(sampleTaskId, new TaskApprovalRequest());
+        });
+    }
+
+    // Similar tests for rejectTask and requestRestore
+    @Test
+    void rejectTask_TaskExistsAndPending_ShouldReject() {
+        sampleTaskEntity.setStatus(ArchivalStatus.PENDING_APPROVAL);
+        when(taskRepository.findById(sampleTaskId)).thenReturn(Optional.of(sampleTaskEntity));
+        when(taskRepository.save(any(ArchivalTaskEntity.class))).thenReturn(sampleTaskEntity);
+         when(taskMapper.entityToStatusDTO(sampleTaskEntity)).thenAnswer(inv -> {
+            ArchivalTaskEntity e = inv.getArgument(0);
+            return ArchivalTaskStatusDTO.builder().taskId(e.getTaskId()).status(e.getStatus().name()).build();
+        });
+
+        TaskApprovalRequest rejectionReq = TaskApprovalRequest.builder().comments("Rejected").build();
+        ArchivalTaskStatusDTO result = taskService.rejectTask(sampleTaskId, rejectionReq);
+
+        assertEquals("REJECTED", result.getStatus());
+        assertEquals("Rejected", sampleTaskEntity.getRejectionComments());
+        verify(taskRepository).save(sampleTaskEntity);
+    }
+
+    @Test
+    void requestRestore_TaskCompleted_ShouldInitiateRestore() {
+        sampleTaskEntity.setStatus(ArchivalStatus.COMPLETED);
+        RestoreRequestDTO restoreDto = RestoreRequestDTO.builder().restoreTier("STANDARD").retentionDays(1).build();
+        ArchivalTaskEntity.RestoreRequestData restoreData = new ArchivalTaskEntity.RestoreRequestData("STANDARD", 1, null, null, null);
+        
+        when(taskRepository.findById(sampleTaskId)).thenReturn(Optional.of(sampleTaskEntity));
+        when(taskMapper.restoreRequestDtoToData(restoreDto)).thenReturn(restoreData);
+        when(taskRepository.save(any(ArchivalTaskEntity.class))).thenReturn(sampleTaskEntity);
+
+        RestoreResponseDTO response = taskService.requestRestore(sampleTaskId, restoreDto);
+
+        assertEquals(ArchivalStatus.RESTORATION_REQUESTED.name(), response.getStatus());
+        assertNotNull(sampleTaskEntity.getRestoreRequestDetails());
+        verify(taskRepository).save(sampleTaskEntity);
+    }
+    
+    @Test
+    void requestRestore_TaskNotRestorable_ShouldReturnNotRestorable() {
+        sampleTaskEntity.setStatus(ArchivalStatus.IN_PROGRESS);
+        RestoreRequestDTO restoreDto = RestoreRequestDTO.builder().build();
+        when(taskRepository.findById(sampleTaskId)).thenReturn(Optional.of(sampleTaskEntity));
+
+        RestoreResponseDTO response = taskService.requestRestore(sampleTaskId, restoreDto);
+        assertEquals("NOT_RESTORABLE", response.getStatus());
+        verify(taskRepository, never()).save(any());
+    }
+}