Used throwing for set method

src/main/java/ru/nbch/credit_tracker/controller/SignalController.java

@@ -9,6 +9,7 @@ import ru.nbch.credit_tracker.entities.request.active_packages.MonitoringActiveP
 import ru.nbch.credit_tracker.entities.response.active_packages.MonitoringActivePackagesResponse;
 import ru.nbch.credit_tracker.entities.response.success.MonitoringPackageDeleteResponse;
 import ru.nbch.credit_tracker.entities.response.success.MonitoringReportListResponse;
+import ru.nbch.credit_tracker.entities.response.success.MonitoringResponse;
 import ru.nbch.credit_tracker.facade.SignalFacade;
 
 @RestController
@@ -22,7 +23,7 @@ public class SignalController {
     }
 
     @PostMapping(value = "/set", produces = MediaType.APPLICATION_XML_VALUE)
-    public ResponseEntity<Resource> setupMonitoring(@RequestParam("file") MultipartFile file) {
+    public ResponseEntity<MonitoringResponse> setupMonitoring(@RequestParam("file") MultipartFile file) {
         return signalFacade.setupMonitoring(file);
     }
 

src/main/java/ru/nbch/credit_tracker/facade/SignalFacade.java

@@ -12,10 +12,7 @@ import ru.nbch.credit_tracker.entities.request.active_packages.MonitoringActiveP
 import ru.nbch.credit_tracker.entities.request.monitoring_request.MonitoringRequest;
 import ru.nbch.credit_tracker.entities.request.monitoring_request.Subject;
 import ru.nbch.credit_tracker.entities.response.active_packages.MonitoringActivePackagesResponse;
-import ru.nbch.credit_tracker.entities.response.errors.MonitoringActivePackagesError;
+import ru.nbch.credit_tracker.entities.response.errors.*;
-import ru.nbch.credit_tracker.entities.response.errors.MonitoringDownloadError;
-import ru.nbch.credit_tracker.entities.response.errors.MonitoringPackageDeleteError;
-import ru.nbch.credit_tracker.entities.response.errors.MonitoringReportListError;
 import ru.nbch.credit_tracker.entities.response.success.MonitoringPackageDeleteResponse;
 import ru.nbch.credit_tracker.entities.response.success.MonitoringReportListResponse;
 import ru.nbch.credit_tracker.entities.response.success.MonitoringResponse;
@@ -76,14 +73,14 @@ public class SignalFacade {
         this.executor = executor;
     }
 
-    public ResponseEntity<Resource> setupMonitoring(MultipartFile file) {
+    public ResponseEntity<MonitoringResponse> setupMonitoring(MultipartFile file) {
         // первичные валидации
         if (file.isEmpty()) {
-            return getBadResponse(SignalError.ERROR_001);
+            throw new SignalErrorException(SignalError.ERROR_001, null, new MonitoringError(), true);
         }
 
         if (!isZipFile(file)) {
-            return getBadResponse(SignalError.ERROR_001);
+            throw new SignalErrorException(SignalError.ERROR_001, null, new MonitoringError(), true);
         }
 
         // Валидация Архива на количетсво файлов, размер и расширение
@@ -96,33 +93,35 @@ public class SignalFacade {
                 if (!entry.isDirectory()) {
                     fileCount++;
                     if (fileCount > 1) { // Архив должен содержать ровно один XML-файл
-                        return getBadResponse(SignalError.ERROR_001);
+                        throw new SignalErrorException(SignalError.ERROR_001, null, new MonitoringError(), true);
                     }
 
                     if (!entry.getName().toLowerCase().endsWith(".xml")) { // Файл должен быть с расширением xml
-                        return getBadResponse(SignalError.ERROR_001);
+                        throw new SignalErrorException(SignalError.ERROR_001, null, new MonitoringError(), true);
                     }
 
                     xmlEntry = entry;
                 } else {
-                    return getBadResponse(SignalError.ERROR_001); // Архив должен содержать ровно один XML-файл. Никаких доп директорий
+                    throw new SignalErrorException(SignalError.ERROR_001, null, new MonitoringError(), true); // Архив должен содержать ровно один XML-файл. Никаких доп директорий
                 }
                 zipInputStream.closeEntry();
                 entry = zipInputStream.getNextEntry();
             }
 
             if (fileCount == 0) { // Архив должен содержать ровно один XML-файл
-                return getBadResponse(SignalError.ERROR_001);
+                throw new SignalErrorException(SignalError.ERROR_001, null, new MonitoringError(), true);
             }
 
             if (xmlEntry.getSize() > MAX_XML_FILE_SIZE) { // максимально 2 Гб до запаковки
-                return getBadResponse(SignalError.ERROR_009);
+                throw new SignalErrorException(SignalError.ERROR_009, null, new MonitoringError(), true);
             }
 
         } catch (Exception e) {
+            if (e instanceof SignalErrorException) {
+                throw (SignalErrorException) e;
+            }
             log.error(e.getMessage(), e);
-            Resource answer = failureAnswerGenerator.generateFailureAnswer(SignalError.ERROR_100);
+            throw new SignalErrorException(SignalError.ERROR_100, null, new MonitoringError(), false);
-            return ResponseEntity.internalServerError().body(answer);
         }
 
         // Теперь знаем, что в архиве лежит ровно один файл с раширением xml и он весит меньше 2гб. Можно валидировать сам xml
@@ -136,16 +135,19 @@ public class SignalFacade {
             monitoringRequest = processor.read(zipInputStream, MonitoringRequest.class);
 
         } catch (Exception e) {
+            if (e instanceof SignalErrorException) {
+                throw (SignalErrorException) e;
+            }
             log.error(e.getMessage(), e);
-            Resource answer = failureAnswerGenerator.generateFailureAnswer(SignalError.ERROR_100);
+            throw new SignalErrorException(SignalError.ERROR_100, null, new MonitoringError(), false);
-            return ResponseEntity.internalServerError().body(answer);
         }
 
         // валидация xml
-        ResponseEntity<Resource> errorResponse = validateMonitoringRequest(monitoringRequest);
+        try {
-        if (errorResponse != null) {
+            validateMonitoringRequest(monitoringRequest);
+        } catch (SignalErrorException e) {
             signalService.rejectPackage(monitoringRequest);
-            return errorResponse;
+            throw e;
         }
 
         try {
@@ -153,85 +155,80 @@ public class SignalFacade {
             AuthorizationService.AuthResult authResult = authorizationService.findAuthInfo(monitoringRequest.getUserId(), monitoringRequest.getPassword());
             if (!authResult.isSuccess()) {
                 signalService.rejectPackage(monitoringRequest);
-                return getBadResponse(authResult.getError());
+                throw new SignalErrorException(authResult.getError(), null, new MonitoringError(), false);
             }
 
             // проверка на уникальность пакета
             if (signalService.isPackageNotUnique(monitoringRequest)) {
                 signalService.rejectPackage(monitoringRequest);
-                return getBadResponse(SignalError.ERROR_007);
+                throw new SignalErrorException(SignalError.ERROR_007, null, new MonitoringError(), false);
             }
 
             packageId = signalService.registerPackage(monitoringRequest);
         } catch (Exception e) {
+            if (e instanceof SignalErrorException) {
+                throw (SignalErrorException) e;
+            }
             log.error(e.getMessage(), e);
-            Resource answer = failureAnswerGenerator.generateFailureAnswer(SignalError.ERROR_100);
+            throw new SignalErrorException(SignalError.ERROR_100, null, new MonitoringError(), false);
-            return ResponseEntity.internalServerError().body(answer);
         }
 
         // в отдельном потоке запускаем поиск фидов и расчет флагов просрочек
         registerFidsAndDebts(packageId);
 
-        return ResponseEntity.ok().body(successAnswerGenerator.generateSuccessAnswer(MonitoringResponse.class));
+        return ResponseEntity.ok().body(new MonitoringResponse());
     }
 
-    private ResponseEntity<Resource> validateMonitoringRequest(MonitoringRequest request) {
+    private void validateMonitoringRequest(MonitoringRequest request) throws SignalErrorException {
         if (request == null) {
-            return getBadResponse(SignalError.ERROR_011);
+            throw new SignalErrorException(SignalError.ERROR_011, null, new MonitoringError(), false);
         }
 
-        ResponseEntity<Resource> errorResponse = validateReruqredTags(request);
+        validateReruqredTags(request);
-        if (errorResponse != null) {
+
-            return errorResponse;
+        validateTagsTypes(request);
     }
 
-        return validateTagsTypes(request);
+    private void validateReruqredTags(MonitoringRequest request) throws SignalErrorException {
-    }
-
-    ResponseEntity<Resource> validateReruqredTags(MonitoringRequest request) {
         if (request.getUserId() == null) {
-            return getBadResponse(SignalError.ERROR_002, "UserId");
+            throw new SignalErrorException(SignalError.ERROR_002, "UserId", new MonitoringError(), true);
         }
 
         if (request.getPackageName() == null) {
-            return getBadResponse(SignalError.ERROR_002, "PackageName");
+            throw new SignalErrorException(SignalError.ERROR_002, "PackageName", new MonitoringError(), true);
         }
 
         if (request.getPassword() == null) {
-            return getBadResponse(SignalError.ERROR_002, "Password");
+            throw new SignalErrorException(SignalError.ERROR_002, "Password", new MonitoringError(), true);
         }
 
         if (request.getSubjects() == null) {
-            return getBadResponse(SignalError.ERROR_002, "Subjects");
+            throw new SignalErrorException(SignalError.ERROR_002, "Subjects", new MonitoringError(), true);
         }
 
         if (request.getSubjects().getSubject().isEmpty()) {
-            return getBadResponse(SignalError.ERROR_002, "Subject");
+            throw new SignalErrorException(SignalError.ERROR_002, "Subject", new MonitoringError(), true);
+        }
     }
 
-        return null;
+    private void validateTagsTypes(MonitoringRequest request) throws SignalErrorException {
-    }
-
-    private ResponseEntity<Resource> validateTagsTypes(MonitoringRequest request) {
         if (!ValidationUtil.validatePackageName(request.getPackageName())) {
-            return getBadResponse(SignalError.ERROR_008);
+            throw new SignalErrorException(SignalError.ERROR_008, null, new MonitoringError(), true);
         }
 
         Set<String> uniqueIds = new HashSet<>();
         for (Subject subject : request.getSubjects().getSubject()) {
             if (!ValidationUtil.validatePhone(subject.getClientId())) {
-                return getBadResponse(SignalError.ERROR_003);
+                throw new SignalErrorException(SignalError.ERROR_003, null, new MonitoringError(), true);
             }
             if (!ValidationUtil.validateNPId(subject.getId())) {
-                return getBadResponse(SignalError.ERROR_010);
+                throw new SignalErrorException(SignalError.ERROR_010, null, new MonitoringError(), true);
             }
             // проверка на уникальность Id внутри одного пакета
             if (!uniqueIds.add(subject.getId())) {
-                return getBadResponse(SignalError.ERROR_004, subject.getId());
+                throw new SignalErrorException(SignalError.ERROR_004, subject.getId(), new MonitoringError(), true);
             }
         }
-
-        return null;
     }
 
     private void registerFidsAndDebts(Integer packageId) {