132 removing security features to utiils module for all microservice access

users_microservice/src/main/java/com/users/application/UsersApplication.java

@@ -10,8 +10,8 @@
 
 @EnableAsync
 @EnableJpaRepositories(
-        basePackages = {
-                "com.users.application.repository"})
+        basePackages = {"com.privileges.application.repository",
+                "com.users.application.repository",})
 @EntityScan({"com.privileges.application.entity","com.users.application.entities"})
 
 @ComponentScan(basePackages ={

utils_microservice/pom.xml

@@ -153,9 +153,9 @@
                 <artifactId>maven-compiler-plugin</artifactId>
                 <version>3.11.0</version> <!-- Replace with the latest version -->
                 <configuration>
-                    <source>17</source>
-                    <target>17</target>
-                    <release>17</release>
+                    <source>21</source>
+                    <target>21</target>
+                    <release>21</release>
                     <annotationProcessorPaths>
                         <path>
                             <groupId>org.mapstruct</groupId>

utils_microservice/src/main/java/com/utils/application/CommonMethods.java

@@ -1,18 +1,15 @@
 package com.utils.application;
 
 import com.utils.application.controllerAdvice.ExecutorControllerAdvice;
+import com.utils.application.globalExceptions.ServiceTimeoutException;
+import com.utils.application.globalExceptions.errorResponse.ErrorResponse;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-
 import java.time.LocalDateTime;
 import java.time.format.DateTimeFormatter;
 import java.util.List;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-
 import static com.utils.application.ExceptionHandler.returnErrorResponse;
+import static com.utils.application.ExceptionHandler.throwExceptionAndReport;
 
 public class CommonMethods {
 private static final Logger logger= LoggerFactory.getLogger(CommonMethods.class);
@@ -21,33 +18,28 @@ public static String formatDateTime(LocalDateTime issueDate) {
         return issueDate.format(formatter);
     }
 
-    public static List<? extends ResponseContract> returnServiceResults(Future<List<? extends ResponseContract>> futureResults,byte retryAttempt,byte retryTimes, String serviceName) {
-        while (true) {
+    public static List<ErrorResponse> retryServiceTimeout(int retryAttempt, int retryTime, ServiceContract service){
+        retryAttempt++;
+        if (retryAttempt >= retryTime) {
             try {
-                return futureResults.get(15, TimeUnit.SECONDS);
-            } catch (InterruptedException e) {
-                var errorMessage = ExecutorControllerAdvice.setMessage("Interruption occurred while executing service : " + serviceName + " reason " + e.getMessage());
-                ExecutorControllerAdvice.setResolveIssueDetails("issue is under investigation, please try again later");
-                return returnErrorResponse(false, errorMessage, "please reload the application");
-            } catch (ExecutionException e) {
-                return returnErrorResponse(false, ExceptionHandlerReporter.getMessage() + " " + e.getMessage(), ExceptionHandlerReporter.getResolveIssueDetails());
-            } catch (TimeoutException e) {
-                retryAttempt++;
-                if (retryAttempt >= retryTimes) {
-                    ExecutorControllerAdvice.setMessage("Time out occurred  while executing service : " + serviceName + " reason service waited 60 seconds");
-                    ExecutorControllerAdvice.setResolveIssueDetails("please try again later");
-                    return returnErrorResponse(false, ExceptionHandlerReporter.getMessage(), ExceptionHandlerReporter.getResolveIssueDetails());
-                }
-
-
-                logger.info("service has failed due to time out, retrying {}:", retryAttempt);
-
-                try {
-                    Thread.sleep(5000);
-                } catch (InterruptedException ex) {
-                    throw new RuntimeException(ex);
-                }
+                ExecutorControllerAdvice.setMessage("Time out occurred  while executing service : " + service + " reason service waited 60 seconds");
+                ExecutorControllerAdvice.setResolveIssueDetails("please try again later");
+                throw throwExceptionAndReport(new ServiceTimeoutException(ExceptionHandlerReporter.getMessage()), ExceptionHandlerReporter.getMessage(), ExceptionHandlerReporter.getResolveIssueDetails());
+            }catch(RuntimeException ee){
+                return returnErrorResponse(ExceptionHandlerReporter.getMessage(), ExceptionHandlerReporter.getResolveIssueDetails(), ee);
             }
         }
+
+
+        logger.info("service has failed due to time out, retrying {}:", retryAttempt);
+
+        try {
+            Thread.sleep(5000);
+        } catch (InterruptedException ex) {
+            logger.info("During service time out, sleep method interrupted while sleeping 5 seconds : {}",ex.getMessage());
+
+        }
+        return null;
     }
+
 }

utils_microservice/src/main/java/com/utils/application/ExceptionHandler.java

@@ -21,32 +21,12 @@ public static RuntimeException throwExceptionAndReport(RuntimeException ex,Strin
             throw ex;
         }catch (RuntimeException reportException){
             logger.warn("Error thrown by exception : {}\n Time thrown : {}\n Trace exception :{}", ex,formatDateTime(LocalDateTime.now()) , Arrays.stream(reportException.getStackTrace()).toList());
+            ExceptionHandlerReporter.setException(reportException);
             return reportException;
         }
     }
 
-    public static List<ErrorResponse> returnErrorResponse(boolean logging,RuntimeException ex, String errorMessage, String resolveIssueDetails){
-        try{
-            ExceptionHandlerReporter.setMessage(errorMessage);
-            ExceptionHandlerReporter.setResolveIssueDetails(resolveIssueDetails);
-            throw ex;
-        }catch (RuntimeException reportException){
-            if(logging)
-                logger.warn("Error thrown by exception : {}\n Time thrown : {}\n Trace exception :{}", ex,formatDateTime(LocalDateTime.now()) , Arrays.stream(reportException.getStackTrace()).toList());
-
-            return List.of(new ErrorResponse(errorMessage,formatDateTime(),resolveIssueDetails));
-        }
-    }
-
-    public static List<ErrorResponse> returnErrorResponse(boolean logging, String errorMessage, String resolveIssueDetails){
-
-            ExceptionHandlerReporter.setMessage(errorMessage);
-            ExceptionHandlerReporter.setResolveIssueDetails(resolveIssueDetails);
-
-            if(logging)
-                logger.warn("Exception trhown by controller advicer exception details ");
-
-            return List.of(new ErrorResponse(errorMessage,formatDateTime(),resolveIssueDetails));
-
+    public static List<ErrorResponse> returnErrorResponse(String errorMessage, String resolveIssueDetails,Throwable throwable){
+            return List.of(new ErrorResponse(errorMessage,formatDateTime(),resolveIssueDetails,throwable));
     }
 }

utils_microservice/src/main/java/com/utils/application/ExceptionHandlerReporter.java

@@ -12,6 +12,8 @@ public class ExceptionHandlerReporter {
     private static String resolveIssueDetails;
     @Getter
     private static String issueDateFormatted;
+    @Getter
+    private static RuntimeException exception;
 
     public static String formatDateTime(LocalDateTime issueDate) {
         DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
@@ -35,4 +37,7 @@ public static void setResolveIssueDetails(String resolveIssueDetails) {
         ExceptionHandlerReporter.resolveIssueDetails = resolveIssueDetails;
     }
 
+    public static void setException(RuntimeException exception) {
+        ExceptionHandlerReporter.exception = exception;
+    }
 }

utils_microservice/src/main/java/com/utils/application/controllerAdvice/ExecutorControllerAdvice.java

@@ -18,23 +18,36 @@
 public class ExecutorControllerAdvice extends ExceptionHandlerReporter {
     private static final Logger logger = LoggerFactory.getLogger(ExecutorControllerAdvice.class);
 
-
-
     @ExceptionHandler(ServiceTimeoutException.class)
     public ResponseEntity<List<ErrorResponse>> manageServiceTimeoutException(){
-        var list = List.of(new ErrorResponse(getIssueDateFormatted(),getResolveIssueDetails(), getMessage()));
+        var list = List.of(new ErrorResponse(getIssueDateFormatted(),getResolveIssueDetails(), getMessage(),getException()));
+        logger.warn("Error response : {}, error code : {}", list,HttpStatus.FORBIDDEN.value());
+        return new ResponseEntity<>(list, HttpStatus.FORBIDDEN);
+    }
+
+    @ExceptionHandler(ServiceRunnerNotFoundException.class)
+    public ResponseEntity<List<ErrorResponse>> manageServiceRunnerNotFoundException(){
+        var list = List.of(new ErrorResponse(getIssueDateFormatted(),getResolveIssueDetails(), getMessage(),getException()));
+        logger.warn("Error response : {}, error code : {}", list,HttpStatus.FORBIDDEN.value());
+        return new ResponseEntity<>(list, HttpStatus.FORBIDDEN);
+    }
+
+
+    @ExceptionHandler(IncorrectRequestException.class)
+    public ResponseEntity<List<ErrorResponse>> manageIncorrectRequestException(){
+        var list = List.of(new ErrorResponse(getIssueDateFormatted(),getResolveIssueDetails(), getMessage(),getException()));
         logger.warn("Error response : {}, error code : {}", list,HttpStatus.FORBIDDEN.value());
         return new ResponseEntity<>(list, HttpStatus.FORBIDDEN);
     }
 
     @ExceptionHandler(ServiceInterruptedException.class)
     public ResponseEntity<ErrorResponse> manageServiceInterruptedException(){
-        return new ResponseEntity<>(new ErrorResponse(getIssueDateFormatted(),getResolveIssueDetails(), getMessage()),HttpStatus.BAD_GATEWAY);
+        return new ResponseEntity<>(new ErrorResponse(getIssueDateFormatted(),getResolveIssueDetails(), getMessage(),getException()),HttpStatus.BAD_GATEWAY);
     }
 
     @ExceptionHandler(ServiceExecutionException.class)
     public ResponseEntity<ErrorResponse> manageServiceExecutionException(){
-        return new ResponseEntity<>(new ErrorResponse(getIssueDateFormatted(),getResolveIssueDetails(), getMessage()),HttpStatus.BAD_GATEWAY);
+        return new ResponseEntity<>(new ErrorResponse(getIssueDateFormatted(),getResolveIssueDetails(), getMessage(),getException()),HttpStatus.BAD_GATEWAY);
     }
 
 }

utils_microservice/src/main/java/com/utils/application/globalExceptions/ServiceRunnerNotFoundException.java

@@ -0,0 +1,7 @@
+package com.utils.application.globalExceptions;
+
+public class ServiceRunnerNotFoundException extends RuntimeException {
+    public ServiceRunnerNotFoundException(String message) {
+        super(message);
+    }
+}

utils_microservice/src/main/java/com/utils/application/globalExceptions/errorResponse/ErrorResponse.java

@@ -1,6 +1,8 @@
 package com.utils.application.globalExceptions.errorResponse;
 
+import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.utils.application.ResponseContract;
+import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.Getter;
@@ -12,5 +14,6 @@ public class ErrorResponse implements ResponseContract {
     private String errorOccurredDate;
     private String  message;
     private String resolveIssueDetails;
-
+@JsonIgnore
+private transient Throwable exception;
 }