[feature] download provided url into temp dir

Author: marmoure

src/main/java/com/evolvedbinary/bblValidator/controller/ValidateController.java

@@ -2,40 +2,98 @@
 
 import com.evolvedbinary.bblValidator.dto.ValidationForm;
 import com.evolvedbinary.bblValidator.dto.ValidationResponse;
+import com.evolvedbinary.bblValidator.service.FileDownloadService;
 import io.micronaut.http.MediaType;
 import io.micronaut.http.annotation.Body;
 import io.micronaut.http.annotation.Consumes;
 import io.micronaut.http.annotation.Controller;
 import io.micronaut.http.annotation.Post;
 import io.micronaut.http.annotation.QueryValue;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
+import java.io.IOException;
+import java.nio.file.Path;
+
+/**
+ * Controller for handling validation requests.
+ */
 @Controller("/validate")
 public class ValidateController {
 
-    // SCENARIO: Form URL Encoded
-    // Matches when Content-Type is 'application/x-www-form-urlencoded'
+    private static final Logger LOG = LoggerFactory.getLogger(ValidateController.class);
+    private final FileDownloadService fileDownloadService;
+
+    /**
+     * Constructor for ValidateController.
+     *
+     * @param fileDownloadService service for downloading files
+     */
+    public ValidateController(FileDownloadService fileDownloadService) {
+        this.fileDownloadService = fileDownloadService;
+    }
+
+    /**
+     * Handles form URL encoded validation requests.
+     *
+     * @param form validation form
+     * @return validation response
+     */
     @Post
     @Consumes(MediaType.APPLICATION_FORM_URLENCODED)
     public ValidationResponse validateForm(@Body ValidationForm form) {
-        return new ValidationResponse(form.schemaId(), form.url(), true, "form handler");
+        try {
+            Path downloadedFile = fileDownloadService.downloadToTemp(form.url());
+            LOG.info("File downloaded to: {}", downloadedFile);
+            // TODO: Perform validation with downloadedFile
+            return new ValidationResponse(form.schemaId(), form.url(), true, "form handler");
+        } catch (IOException e) {
+            LOG.error("Failed to download file from URL: {}", form.url(), e);
+            return new ValidationResponse(form.schemaId(), form.url(), false, "Download failed: " + e.getMessage());
+        }
     }
 
-    // SCENARIO: CSV Body + Query param
-    // Matches when Content-Type is 'text/csv'
+    /**
+     * Handles CSV body + query param validation requests.
+     *
+     * @param schemaId schema ID
+     * @param csvContent CSV content
+     * @return validation response
+     */
     @Post
     @Consumes(MediaType.TEXT_CSV)
     public ValidationResponse validateCsv(@QueryValue("schema-id") String schemaId, 
                                           @Body String csvContent) {
-
-        return new ValidationResponse(schemaId, csvContent, true, "text handler");
+        try {
+            Path tempFile = fileDownloadService.saveContentToTemp(csvContent, "uploaded-content.csv");
+            LOG.info("CSV content saved to: {}", tempFile);
+            // TODO: Perform validation with tempFile
+            return new ValidationResponse(schemaId, "CSV content", true, "text handler");
+        } catch (IOException e) {
+            LOG.error("Failed to save CSV content to temp file", e);
+            return new ValidationResponse(schemaId, "CSV content", false, "Failed to save content: " + e.getMessage());
+        }
     }
 
-    // SCENARIO: Query Params Only
-    // We use ALL here as a fallback, but specific types above take precedence
+    /**
+     * Handles query params only validation requests.
+     *
+     * @param schemaId schema ID
+     * @param url URL
+     * @return validation response
+     */
     @Post
     @Consumes(MediaType.ALL) 
     public ValidationResponse validateParams(@QueryValue("schema-id") String schemaId, 
                                              @QueryValue String url) {
-        return new ValidationResponse(schemaId, url, true, "query handler");
+        try {
+            Path downloadedFile = fileDownloadService.downloadToTemp(url);
+            LOG.info("File downloaded to: {}", downloadedFile);
+            // TODO: Perform validation with downloadedFile
+            return new ValidationResponse(schemaId, url, true, "query handler");
+        } catch (IOException e) {
+            LOG.error("Failed to download file from URL: {}", url, e);
+            return new ValidationResponse(schemaId, url, false, "Download failed: " + e.getMessage());
+        }
     }
 }

src/main/java/com/evolvedbinary/bblValidator/service/FileDownloadService.java

@@ -0,0 +1,124 @@
+package com.evolvedbinary.bblValidator.service;
+
+import jakarta.inject.Singleton;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+
+@Singleton
+public class FileDownloadService {
+
+    private static final Logger LOG = LoggerFactory.getLogger(FileDownloadService.class);
+    private static final String TEMP_DIR_PREFIX = "bbl-validator-";
+    private static final String DEFAULT_FILENAME = "downloaded-file.csv";
+    private final HttpClient httpClient;
+
+    public FileDownloadService() {
+        this.httpClient = HttpClient.newBuilder()
+                .followRedirects(HttpClient.Redirect.NORMAL)
+                .build();
+    }
+
+    /**
+     * Downloads a file from the given URL and stores it in a temporary directory.
+     *
+     * @param url The URL to download from
+     * @return Path to the downloaded file in the temp directory
+     * @throws IOException if download or file operations fail
+     * @throws IllegalArgumentException if url is null or empty
+     */
+    public Path downloadToTemp(String url) throws IOException {        
+        try {
+            Path tempDir = createTempDirectory();
+            String filename = extractFilename(url);
+            Path tempFile = tempDir.resolve(filename);
+
+            HttpRequest request = HttpRequest.newBuilder()
+                    .uri(URI.create(url))
+                    .GET()
+                    .build();
+
+            HttpResponse<InputStream> response = httpClient.send(
+                    request,
+                    HttpResponse.BodyHandlers.ofInputStream()
+            );
+
+            try (InputStream inputStream = response.body()) {
+                Files.copy(inputStream, tempFile, StandardCopyOption.REPLACE_EXISTING);
+            }
+
+            LOG.info("Downloaded file from {} to {}", url, tempFile);
+            return tempFile;
+
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            throw new IOException("Download interrupted for URL: " + url, e);
+        }
+    }
+
+    /**
+     * Saves content to a temporary file.
+     *
+     * @param content The content to save
+     * @param filename The filename to use
+     * @return Path to the created temp file
+     * @throws IOException if file operations fail
+     * @throws IllegalArgumentException if content or filename is null or empty
+     */
+    public Path saveContentToTemp(String content, String filename) throws IOException {        
+        Path tempDir = createTempDirectory();
+        Path tempFile = tempDir.resolve(filename);
+
+        Files.writeString(tempFile, content);
+
+        LOG.info("Saved content to temp file: {}", tempFile);
+        return tempFile;
+    }
+
+    /**
+     * Creates a temporary directory with the standard prefix.
+     *
+     * @return Path to the created temp directory
+     * @throws IOException if directory creation fails
+     */
+    private Path createTempDirectory() throws IOException {
+        return Files.createTempDirectory(TEMP_DIR_PREFIX);
+    }
+
+    
+    /**
+     * Extracts filename from URL or returns a default name.
+     *
+     * @param url The URL to extract filename from
+     * @return The extracted filename or default filename
+     */
+    private String extractFilename(String url) {
+        try {
+            String path = URI.create(url).getPath();
+            if (path == null || path.isEmpty()) {
+                return DEFAULT_FILENAME;
+            }
+            
+            int lastSlash = path.lastIndexOf('/');
+            if (lastSlash >= 0 && lastSlash < path.length() - 1) {
+                String filename = path.substring(lastSlash + 1);
+                // Ensure filename is not empty after extraction
+                if (!filename.trim().isEmpty()) {
+                    return filename;
+                }
+            }
+        } catch (Exception e) {
+            LOG.warn("Could not extract filename from URL: {}", url, e);
+        }
+        return DEFAULT_FILENAME;
+    }
+}