Merge branch 'release/v11.2.1' of https://github.com/utmstack/UTMStack into release/v11.2.1

Author: osmontero

web-pdf/src/main/java/com/utmstack/webtopdf/config/WebDriverConfig.java

@@ -4,29 +4,48 @@
 import org.openqa.selenium.WebDriver;
 import org.openqa.selenium.chrome.ChromeOptions;
 import org.openqa.selenium.remote.RemoteWebDriver;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.context.annotation.Configuration;
 
 import java.net.MalformedURLException;
 import java.net.URL;
+import java.time.Duration;
 
 @Configuration
 @Slf4j
 public class WebDriverConfig {
 
+    @Value("${selenium.grid.url:http://localhost:4444/wd/hub}")
+    private String seleniumGridUrl;
+
     public WebDriver createWebDriver() {
         try {
+            WebDriver driver = getWebDriver();
 
-            URL serverUrl = new URL("http://localhost:4444/wd/hub");
+            driver.manage().timeouts().pageLoadTimeout(Duration.ofSeconds(60));
+            driver.manage().timeouts().scriptTimeout(Duration.ofSeconds(30));
 
-            ChromeOptions options = new ChromeOptions();
-            options.addArguments("--headless");
-            options.addArguments("--no-sandbox");
-            options.setAcceptInsecureCerts(true);
+            return driver;
 
-            return new RemoteWebDriver(serverUrl, options);
-        } catch (MalformedURLException | RuntimeException exception) {
-            log.error(exception.getMessage());
+        } catch (Exception exception) {
+            log.error("Failed to initialize RemoteWebDriver", exception);
             throw new RuntimeException("Failed to initialize RemoteWebDriver", exception);
         }
     }
-}
+
+    private WebDriver getWebDriver() throws MalformedURLException {
+        URL serverUrl = new URL(seleniumGridUrl);
+
+        ChromeOptions options = new ChromeOptions();
+        options.addArguments("--headless=new");
+        options.addArguments("--no-sandbox");
+        options.addArguments("--disable-dev-shm-usage");
+        options.addArguments("--disable-gpu");
+        options.addArguments("--disable-software-rasterizer");
+        options.addArguments("--window-size=1920,1080");
+        options.addArguments("--remote-allow-origins=*");
+        options.setAcceptInsecureCerts(true);
+
+        return new RemoteWebDriver(serverUrl, options);
+    }
+}

web-pdf/src/main/java/com/utmstack/webtopdf/controller/WebPdfController.java

@@ -22,15 +22,33 @@ public class WebPdfController {
     private final PdfGenerationService pdfGenerationService;
 
     @GetMapping("/generate-pdf")
-    public ResponseEntity<ResponseDto> generatePdf(@RequestParam String baseUrl, @RequestParam String url, @RequestParam String accessType, @RequestParam String accessKey) {
-        try {
-            byte[] pdfBytes = pdfGenerationService.generatePdf(baseUrl, url, accessKey, AccessType.valueOf(accessType.toUpperCase()));
+    public ResponseEntity<ResponseDto> generatePdf(@RequestParam String baseUrl,
+                                                   @RequestParam String url,
+                                                   @RequestParam String accessType,
+                                                   @RequestParam String accessKey) {
 
-            return ResponseEntity.ok().body(ResponseDto.builder().pdfBytes(pdfBytes).build());
 
-        }  catch (Exception e) {
-            log.error("Error generating the PDF for the URL: {}", url, e);
-            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(ResponseDto.builder().message("Error generating the PDF for the URL").build());
+        byte[] pdfBytes = pdfGenerationService.generatePdf(baseUrl,
+                                                           url,
+                                                           accessKey,
+                                                           AccessType.valueOf(accessType.toUpperCase()));
+
+        if (pdfBytes == null || pdfBytes.length == 0) {
+            log.error("PDF generation returned empty bytes for URL: {}", url);
+
+            return ResponseEntity
+                    .status(HttpStatus.BAD_REQUEST)
+                    .body(ResponseDto.builder()
+                            .error(true)
+                            .message("The")
+                            .build());
         }
+
+        return ResponseEntity.ok(
+                ResponseDto.builder()
+                        .pdfBytes(pdfBytes)
+                        .error(false)
+                        .message("PDF generado correctamente")
+                        .build());
     }
 }

web-pdf/src/main/java/com/utmstack/webtopdf/dto/ErrorResponse.java

@@ -0,0 +1,13 @@
+package com.utmstack.webtopdf.dto;
+
+import lombok.Builder;
+import lombok.Data;
+
+@Data
+@Builder
+public class ErrorResponse {
+    private boolean error;
+    private String message;
+    private String details;
+}
+

web-pdf/src/main/java/com/utmstack/webtopdf/dto/ResponseDto.java

@@ -10,4 +10,5 @@
 public class ResponseDto {
     private byte[] pdfBytes;
     private String message;
+    private boolean error;
 }

web-pdf/src/main/java/com/utmstack/webtopdf/exception/GlobalExceptionHandler.java

@@ -0,0 +1,51 @@
+package com.utmstack.webtopdf.exception;
+
+import com.utmstack.webtopdf.dto.ErrorResponse;
+import lombok.extern.slf4j.Slf4j;
+import org.openqa.selenium.TimeoutException;
+import org.openqa.selenium.NoSuchElementException;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.ControllerAdvice;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+
+@Slf4j
+@ControllerAdvice
+public class GlobalExceptionHandler {
+
+    @ExceptionHandler(TimeoutException.class)
+    public ResponseEntity<ErrorResponse> handleTimeout(TimeoutException ex) {
+        log.error("Timeout while waiting for Selenium condition: {}", ex.getMessage());
+
+        return ResponseEntity.status(HttpStatus.REQUEST_TIMEOUT)
+                .body(ErrorResponse.builder()
+                        .error(true)
+                        .message("The report took too long to load.")
+                        .details(ex.getMessage())
+                        .build());
+    }
+
+    @ExceptionHandler(NoSuchElementException.class)
+    public ResponseEntity<ErrorResponse> handleNoSuchElement(NoSuchElementException ex) {
+        log.error("Required element not found in Selenium: {}", ex.getMessage());
+
+        return ResponseEntity.status(HttpStatus.BAD_REQUEST)
+                .body(ErrorResponse.builder()
+                        .error(true)
+                        .message("A required element was not found while generating the PDF.")
+                        .details(ex.getMessage())
+                        .build());
+    }
+
+    @ExceptionHandler(Exception.class)
+    public ResponseEntity<ErrorResponse> handleGeneral(Exception ex) {
+        log.error("Unexpected error: {}", ex.getMessage(), ex);
+
+        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
+                .body(ErrorResponse.builder()
+                        .error(true)
+                        .message("An unexpected error occurred while generating the PDF.")
+                        .details(ex.getMessage())
+                        .build());
+    }
+}

web-pdf/src/main/java/com/utmstack/webtopdf/service/PdfGenerationService.java

@@ -37,16 +37,38 @@ public byte[] generatePdf(String url, String route, String accessKey, AccessType
 
         try {
             webDriver.get(reportUrl);
-            WebDriverWait wait = new WebDriverWait(webDriver, Duration.ofSeconds(10));
+
+            WebDriverWait wait = new WebDriverWait(webDriver, Duration.ofSeconds(15));
+
+            wait.until(d -> ((JavascriptExecutor) d)
+                    .executeScript("return document.readyState").equals("complete"));
+
+            Thread.sleep(500);
+
             wait.until(ExpectedConditions.presenceOfElementLocated(By.cssSelector(".report-loading")));
 
             Pdf print = ((PrintsPage) webDriver).print(printOptions);
-            webDriver.quit();
             return OutputType.BYTES.convertFromBase64Png(print.getContent());
+
+        } catch (TimeoutException e) {
+            log.error("Timeout waiting for report to load: {}", e.getMessage());
+            throw new TimeoutException("The report took too long to load.");
+
+        } catch (NoSuchElementException e) {
+            log.error("Required element not found: {}", e.getMessage());
+            throw new NoSuchElementException("A required element was not found while generating the PDF.");
+
         } catch (Exception e) {
-            log.error("Error generating PDF report: {}", e.getMessage(), e);
-            webDriver.quit();
-            return new byte[0];
+            log.error("Unexpected error generating PDF: {}", e.getMessage(), e);
+            throw new RuntimeException("Unexpected error generating the PDF.");
+
+        } finally {
+            try {
+                webDriver.quit();
+            } catch (Exception ex) {
+                log.warn("Error closing WebDriver: {}", ex.getMessage());
+            }
         }
     }
+
 }