From b5053b2f4ecf023c392b1f9561c76fdf4fdb602d Mon Sep 17 00:00:00 2001
From: Lars Johansson <lars.johansson@ess.eu>
Date: Tue, 3 May 2022 16:20:49 +0200
Subject: [PATCH] Replace http status codes with custom exceptions in
validation
Handle exceptions in service and controller layers.
Translate exceptions to http status codes in global exception handler.
---
.../GlobalControllerExceptionHandler.java | 60 ++-
.../rest/controller/NamesController.java | 62 +--
.../rest/controller/StructuresController.java | 82 ++--
.../openepics/names/service/NamesService.java | 23 +-
.../exception/DataConflictException.java | 44 ++
.../exception/DataDeletedException.java | 44 ++
.../service/exception/DataExistException.java | 44 ++
.../exception/DataNotAvailableException.java | 44 ++
.../exception/DataNotCorrectException.java | 44 ++
.../exception/DataNotFoundException.java | 44 ++
.../exception/DataNotValidException.java | 44 ++
.../exception/InputNotAvailableException.java | 44 ++
.../exception/InputNotCorrectException.java | 44 ++
.../exception/InputNotValidException.java | 44 ++
.../exception/ServiceException.java} | 24 +-
.../openepics/names/util/ExceptionUtil.java | 260 +++++++++--
.../org/openepics/names/util/LogUtil.java | 22 +-
.../openepics/names/util/ValidateUtil.java | 436 ++++++++----------
.../names/util/ExceptionUtilTest.java | 144 ++++--
.../names/util/ValidateUtilTest.java | 98 ++--
20 files changed, 1173 insertions(+), 478 deletions(-)
create mode 100644 src/main/java/org/openepics/names/service/exception/DataConflictException.java
create mode 100644 src/main/java/org/openepics/names/service/exception/DataDeletedException.java
create mode 100644 src/main/java/org/openepics/names/service/exception/DataExistException.java
create mode 100644 src/main/java/org/openepics/names/service/exception/DataNotAvailableException.java
create mode 100644 src/main/java/org/openepics/names/service/exception/DataNotCorrectException.java
create mode 100644 src/main/java/org/openepics/names/service/exception/DataNotFoundException.java
create mode 100644 src/main/java/org/openepics/names/service/exception/DataNotValidException.java
create mode 100644 src/main/java/org/openepics/names/service/exception/InputNotAvailableException.java
create mode 100644 src/main/java/org/openepics/names/service/exception/InputNotCorrectException.java
create mode 100644 src/main/java/org/openepics/names/service/exception/InputNotValidException.java
rename src/main/java/org/openepics/names/{util/ServiceHttpStatusException.java => service/exception/ServiceException.java} (68%)
diff --git a/src/main/java/org/openepics/names/rest/controller/GlobalControllerExceptionHandler.java b/src/main/java/org/openepics/names/rest/controller/GlobalControllerExceptionHandler.java
index c39844c2..f6790331 100644
--- a/src/main/java/org/openepics/names/rest/controller/GlobalControllerExceptionHandler.java
+++ b/src/main/java/org/openepics/names/rest/controller/GlobalControllerExceptionHandler.java
@@ -23,8 +23,18 @@ import java.util.logging.Logger;
import org.apache.commons.lang3.StringUtils;
import org.openepics.names.rest.beans.response.Response;
+import org.openepics.names.service.exception.DataConflictException;
+import org.openepics.names.service.exception.DataDeletedException;
+import org.openepics.names.service.exception.DataExistException;
+import org.openepics.names.service.exception.DataNotAvailableException;
+import org.openepics.names.service.exception.DataNotCorrectException;
+import org.openepics.names.service.exception.DataNotFoundException;
+import org.openepics.names.service.exception.DataNotValidException;
+import org.openepics.names.service.exception.InputNotAvailableException;
+import org.openepics.names.service.exception.InputNotCorrectException;
+import org.openepics.names.service.exception.InputNotValidException;
+import org.openepics.names.service.exception.ServiceException;
import org.openepics.names.util.ExceptionUtil;
-import org.openepics.names.util.ServiceHttpStatusException;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ExceptionHandler;
@@ -34,7 +44,19 @@ import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExcep
/**
* Global exception handler to ensure exceptions are communicated to request origin in a uniform way.
- *
+ * <br/><br/>
+ * Note
+ * <ul>
+ * <li>400 {@link HttpStatus#BAD_REQUEST}</li>
+ * <li>401 {@link HttpStatus#UNAUTHORIZED}</li>
+ * <li>403 {@link HttpStatus#FORBIDDEN}</li>
+ * <li>404 {@link HttpStatus#NOT_FOUND}</li>
+ * <li>409 {@link HttpStatus#CONFLICT}</li>
+ * <li>422 {@link HttpStatus#UNPROCESSABLE_ENTITY}</li>
+ * <li>500 {@link HttpStatus#INTERNAL_SERVER_ERROR}</li>
+ * <li>501 {@link HttpStatus#NOT_IMPLEMENTED}</li>
+ * </ul>
+*
* @author Lars Johansson
*/
@RestControllerAdvice
@@ -54,12 +76,36 @@ public class GlobalControllerExceptionHandler extends ResponseEntityExceptionHan
HttpStatus resultStatus = HttpStatus.INTERNAL_SERVER_ERROR;
- if (ex instanceof ServiceHttpStatusException) {
- ServiceHttpStatusException shse = (ServiceHttpStatusException) ex;
+ if (ex instanceof ServiceException) {
+ ServiceException se = (ServiceException) ex;
response.setMessage(StringUtils.trimToEmpty(ex.getMessage()));
- response.setDetails(StringUtils.trimToEmpty(shse.getDetails()));
- response.setField(StringUtils.trimToEmpty(shse.getField()));
- resultStatus = shse.getHttpStatus();
+ response.setDetails(StringUtils.trimToEmpty(se.getDetails()));
+ response.setField(StringUtils.trimToEmpty(se.getField()));
+
+ if (ex instanceof InputNotAvailableException || ex instanceof InputNotCorrectException || ex instanceof InputNotValidException) {
+ // resultStatus = HttpStatus.UNPROCESSABLE_ENTITY;
+ resultStatus = HttpStatus.BAD_REQUEST;
+ }
+
+ if (ex instanceof DataNotFoundException) {
+ // resultStatus = HttpStatus.NOT_FOUND;
+ resultStatus = HttpStatus.BAD_REQUEST;
+ }
+
+ if (ex instanceof DataNotAvailableException || ex instanceof DataNotCorrectException || ex instanceof DataNotValidException) {
+ // resultStatus = HttpStatus.UNPROCESSABLE_ENTITY;
+ resultStatus = HttpStatus.BAD_REQUEST;
+ }
+
+ if (ex instanceof DataDeletedException) {
+ // resultStatus = HttpStatus.UNPROCESSABLE_ENTITY;
+ resultStatus = HttpStatus.BAD_REQUEST;
+ }
+
+ if (ex instanceof DataConflictException || ex instanceof DataExistException) {
+ // resultStatus = HttpStatus.CONFLICT;
+ resultStatus = HttpStatus.BAD_REQUEST;
+ }
}
return new ResponseEntity<>(response, Response.HEADER_JSON, resultStatus);
diff --git a/src/main/java/org/openepics/names/rest/controller/NamesController.java b/src/main/java/org/openepics/names/rest/controller/NamesController.java
index bd3b4423..5870cb1b 100644
--- a/src/main/java/org/openepics/names/rest/controller/NamesController.java
+++ b/src/main/java/org/openepics/names/rest/controller/NamesController.java
@@ -31,9 +31,9 @@ import org.openepics.names.rest.beans.response.ResponseBoolean;
import org.openepics.names.rest.beans.response.ResponseBooleanList;
import org.openepics.names.rest.beans.response.ResponsePageNameElements;
import org.openepics.names.service.NamesService;
+import org.openepics.names.service.exception.ServiceException;
import org.openepics.names.util.ExceptionUtil;
import org.openepics.names.util.LogUtil;
-import org.openepics.names.util.ServiceHttpStatusException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.http.HttpStatus;
@@ -74,8 +74,8 @@ public class NamesController implements INames {
try {
namesService.validateNamesCreate(nameElements);
return new ResponseEntity<>(namesService.createNames(nameElements), Response.HEADER_JSON, HttpStatus.CREATED);
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
throw e;
} catch (Exception e) {
@@ -95,8 +95,8 @@ public class NamesController implements INames {
return namesService.readNames(
deleted, queryFields, queryValues,
orderBy, isAsc, page, pageSize);
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
throw e;
} catch (Exception e) {
@@ -112,8 +112,8 @@ public class NamesController implements INames {
FieldName orderBy, Boolean isAsc, Integer page, Integer pageSize) {
try {
return namesService.readNames(name, orderBy, isAsc, page, pageSize);
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
throw e;
} catch (Exception e) {
@@ -129,8 +129,8 @@ public class NamesController implements INames {
FieldName orderBy, Boolean isAsc, Integer page, Integer pageSize) {
try {
return namesService.readNamesSystemStructure(mnemonicpath, orderBy, isAsc, page, pageSize);
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
throw e;
} catch (Exception e) {
@@ -146,8 +146,8 @@ public class NamesController implements INames {
FieldName orderBy, Boolean isAsc, Integer page, Integer pageSize) {
try {
return namesService.readNamesDeviceStructure(mnemonicpath, orderBy, isAsc, page, pageSize);
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
throw e;
} catch (Exception e) {
@@ -163,8 +163,8 @@ public class NamesController implements INames {
FieldName orderBy, Boolean isAsc, Integer page, Integer pageSize) {
try {
return namesService.readNamesHistory(uuid, orderBy, isAsc, page, pageSize);
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
throw e;
} catch (Exception e) {
@@ -180,8 +180,8 @@ public class NamesController implements INames {
public String equivalenceName(String name) {
try {
return namesService.equivalenceName(name);
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
throw e;
} catch (Exception e) {
@@ -195,8 +195,8 @@ public class NamesController implements INames {
public ResponseEntity<ResponseBoolean> existsName(String name) {
try {
return new ResponseEntity<>(new ResponseBoolean(namesService.existsName(name)), Response.HEADER_JSON, HttpStatus.OK);
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
return new ResponseEntity<>(new ResponseBoolean(Boolean.FALSE, e.getMessage(), e.getDetails(), e.getField()), Response.HEADER_JSON, HttpStatus.OK);
} catch (Exception e) {
@@ -210,8 +210,8 @@ public class NamesController implements INames {
public ResponseEntity<ResponseBoolean> isLegacyName(String name) {
try {
return new ResponseEntity<>(new ResponseBoolean(namesService.isLegacyName(name)), Response.HEADER_JSON, HttpStatus.OK);
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
return new ResponseEntity<>(new ResponseBoolean(Boolean.FALSE, e.getMessage(), e.getDetails(), e.getField()), Response.HEADER_JSON, HttpStatus.OK);
} catch (Exception e) {
@@ -225,8 +225,8 @@ public class NamesController implements INames {
public ResponseEntity<ResponseBoolean> isValidToCreateName(String name) {
try {
return new ResponseEntity<>(new ResponseBoolean(namesService.isValidToCreateName(name)), Response.HEADER_JSON, HttpStatus.OK);
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
return new ResponseEntity<>(new ResponseBoolean(Boolean.FALSE, e.getMessage(), e.getDetails(), e.getField()), Response.HEADER_JSON, HttpStatus.OK);
} catch (Exception e) {
@@ -247,8 +247,8 @@ public class NamesController implements INames {
try {
namesService.validateNamesCreate(nameElement);
responses.add(new ResponseBoolean(Boolean.TRUE));
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
if (response) {
response = false;
@@ -277,8 +277,8 @@ public class NamesController implements INames {
try {
namesService.validateNamesUpdate(nameElement);
responses.add(new ResponseBoolean(Boolean.TRUE));
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
if (response) {
response = false;
@@ -307,8 +307,8 @@ public class NamesController implements INames {
try {
namesService.validateNamesDelete(nameElement);
responses.add(new ResponseBoolean(Boolean.TRUE));
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
if (response) {
response = false;
@@ -340,8 +340,8 @@ public class NamesController implements INames {
try {
namesService.validateNamesUpdate(nameElements);
return namesService.updateNames(nameElements);
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
throw e;
} catch (Exception e) {
@@ -363,8 +363,8 @@ public class NamesController implements INames {
try {
namesService.validateNamesDelete(nameElements);
return namesService.deleteNames(nameElements);
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
throw e;
} catch (Exception e) {
diff --git a/src/main/java/org/openepics/names/rest/controller/StructuresController.java b/src/main/java/org/openepics/names/rest/controller/StructuresController.java
index 98f36330..31eb633b 100644
--- a/src/main/java/org/openepics/names/rest/controller/StructuresController.java
+++ b/src/main/java/org/openepics/names/rest/controller/StructuresController.java
@@ -33,9 +33,9 @@ import org.openepics.names.rest.beans.response.ResponseBoolean;
import org.openepics.names.rest.beans.response.ResponseBooleanList;
import org.openepics.names.rest.beans.response.ResponsePageStructureElements;
import org.openepics.names.service.StructuresService;
+import org.openepics.names.service.exception.ServiceException;
import org.openepics.names.util.ExceptionUtil;
import org.openepics.names.util.LogUtil;
-import org.openepics.names.util.ServiceHttpStatusException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.http.HttpStatus;
@@ -83,8 +83,8 @@ public class StructuresController implements IStructures {
try {
structuresService.validateStructuresCreate(structureElements);
return new ResponseEntity<>(structuresService.createStructures(structureElements), Response.HEADER_JSON, HttpStatus.CREATED);
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
throw e;
} catch (Exception e) {
@@ -104,8 +104,8 @@ public class StructuresController implements IStructures {
return structuresService.readStructures(
type, statuses, deleted, queryFields, queryValues,
orderBy, isAsc, page, pageSize);
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
throw e;
} catch (Exception e) {
@@ -123,8 +123,8 @@ public class StructuresController implements IStructures {
return structuresService.readStructuresChildren(
type, uuid,
orderBy, isAsc, page, pageSize);
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
throw e;
} catch (Exception e) {
@@ -140,8 +140,8 @@ public class StructuresController implements IStructures {
FieldStructure orderBy, Boolean isAsc, Integer page, Integer pageSize) {
try {
return structuresService.readStructuresMnemonic(mnemonic, orderBy, isAsc, page, pageSize);
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
throw e;
} catch (Exception e) {
@@ -157,8 +157,8 @@ public class StructuresController implements IStructures {
FieldStructure orderBy, Boolean isAsc, Integer page, Integer pageSize) {
try {
return structuresService.readStructuresMnemonicpath(mnemonicpath, orderBy, isAsc, page, pageSize);
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
throw e;
} catch (Exception e) {
@@ -176,8 +176,8 @@ public class StructuresController implements IStructures {
return structuresService.readStructuresHistory(
uuid, type,
orderBy, isAsc, page, pageSize);
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
throw e;
} catch (Exception e) {
@@ -193,8 +193,8 @@ public class StructuresController implements IStructures {
public String equivalenceMnemonic(String mnemonic) {
try {
return structuresService.equivalenceMnemonic(mnemonic);
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
throw e;
} catch (Exception e) {
@@ -208,8 +208,8 @@ public class StructuresController implements IStructures {
public ResponseEntity<ResponseBoolean> existsStructure(Type type, String mnemonicpath) {
try {
return new ResponseEntity<>(new ResponseBoolean(structuresService.existsStructure(type, mnemonicpath)), Response.HEADER_JSON, HttpStatus.OK);
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
return new ResponseEntity<>(new ResponseBoolean(Boolean.FALSE, e.getMessage(), e.getDetails(), e.getField()), Response.HEADER_JSON, HttpStatus.OK);
} catch (Exception e) {
@@ -223,8 +223,8 @@ public class StructuresController implements IStructures {
public ResponseEntity<ResponseBoolean> isValidToCreateStructure(Type type, String mnemonicpath) {
try {
return new ResponseEntity<>(new ResponseBoolean(structuresService.isValidToCreateStructure(type, mnemonicpath)), Response.HEADER_JSON, HttpStatus.OK);
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
return new ResponseEntity<>(new ResponseBoolean(Boolean.FALSE, e.getMessage(), e.getDetails(), e.getField()), Response.HEADER_JSON, HttpStatus.OK);
} catch (Exception e) {
@@ -245,8 +245,8 @@ public class StructuresController implements IStructures {
try {
structuresService.validateStructuresCreate(structureElement);
responses.add(new ResponseBoolean(Boolean.TRUE));
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
if (response) {
response = false;
@@ -275,8 +275,8 @@ public class StructuresController implements IStructures {
try {
structuresService.validateStructuresUpdate(structureElement);
responses.add(new ResponseBoolean(Boolean.TRUE));
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
if (response) {
response = false;
@@ -305,8 +305,8 @@ public class StructuresController implements IStructures {
try {
structuresService.validateStructuresDelete(structureElement);
responses.add(new ResponseBoolean(Boolean.TRUE));
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
if (response) {
response = false;
@@ -335,8 +335,8 @@ public class StructuresController implements IStructures {
try {
structuresService.validateStructuresApprove(structureElement);
responses.add(new ResponseBoolean(Boolean.TRUE));
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
if (response) {
response = false;
@@ -365,8 +365,8 @@ public class StructuresController implements IStructures {
try {
structuresService.validateStructuresCancel(structureElement);
responses.add(new ResponseBoolean(Boolean.TRUE));
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
if (response) {
response = false;
@@ -395,8 +395,8 @@ public class StructuresController implements IStructures {
try {
structuresService.validateStructuresReject(structureElement);
responses.add(new ResponseBoolean(Boolean.TRUE));
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
if (response) {
response = false;
@@ -423,8 +423,8 @@ public class StructuresController implements IStructures {
try {
structuresService.validateStructuresUpdate(structureElements);
return structuresService.updateStructures(structureElements);
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
throw e;
} catch (Exception e) {
@@ -442,8 +442,8 @@ public class StructuresController implements IStructures {
try {
structuresService.validateStructuresDelete(structureElements);
return structuresService.deleteStructures(structureElements);
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
throw e;
} catch (Exception e) {
@@ -460,8 +460,8 @@ public class StructuresController implements IStructures {
try {
structuresService.validateStructuresApprove(structureElements);
return structuresService.approveStructures(structureElements);
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
throw e;
} catch (Exception e) {
@@ -476,8 +476,8 @@ public class StructuresController implements IStructures {
try {
structuresService.validateStructuresCancel(structureElements);
return structuresService.cancelStructures(structureElements);
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
throw e;
} catch (Exception e) {
@@ -492,8 +492,8 @@ public class StructuresController implements IStructures {
try {
structuresService.validateStructuresReject(structureElements);
return structuresService.rejectStructures(structureElements);
- } catch (ServiceHttpStatusException e) {
- LogUtil.logServiceHttpStatusException(LOGGER, Level.SEVERE, e);
+ } catch (ServiceException e) {
+ LogUtil.logServiceException(LOGGER, Level.SEVERE, e);
LogUtil.logStackTraceElements(LOGGER, Level.SEVERE, e);
throw e;
} catch (Exception e) {
diff --git a/src/main/java/org/openepics/names/service/NamesService.java b/src/main/java/org/openepics/names/service/NamesService.java
index bdf2c295..a2e8eea2 100644
--- a/src/main/java/org/openepics/names/service/NamesService.java
+++ b/src/main/java/org/openepics/names/service/NamesService.java
@@ -47,13 +47,13 @@ import org.openepics.names.rest.beans.element.NameElement;
import org.openepics.names.rest.beans.element.NameElementCommand;
import org.openepics.names.rest.beans.response.ResponsePageNameElements;
import org.openepics.names.util.EssNamingConvention;
+import org.openepics.names.util.ExceptionUtil;
import org.openepics.names.util.HolderIRepositories;
import org.openepics.names.util.HolderSystemDeviceStructure;
import org.openepics.names.util.NameElementUtil;
import org.openepics.names.util.NameUtil;
import org.openepics.names.util.ValidateUtil;
import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@@ -372,49 +372,49 @@ public class NamesService {
// do
List<Name> names = nameRepository.readNames(false, FieldName.NAME, name);
- ValidateUtil.validateCondition(names != null && names.size() == 1, HttpStatus.BAD_REQUEST, "name not available", name, null);
+ ExceptionUtil.validateConditionDataNotAvailableException(names != null && names.size() == 1, "name not available", name, null);
Name toBeChecked = names.get(0);
// system structure
if (toBeChecked.getSystemgroupUuid() != null) {
SystemGroup systemGroup = holderIRepositories.getSystemGroupRepository().findLatestNotDeletedByUuid(toBeChecked.getSystemgroupUuid().toString());
- ValidateUtil.validateCondition(systemGroup != null, HttpStatus.BAD_REQUEST, "system group not available", name, null);
+ ExceptionUtil.validateConditionDataNotAvailableException(systemGroup != null, "system group not available", name, null);
if (systemGroup.isDeleted()) {
return Boolean.TRUE;
}
} else if (toBeChecked.getSystemUuid() != null) {
org.openepics.names.repository.model.System system = holderIRepositories.getSystemRepository().findLatestNotDeletedByUuid(toBeChecked.getSystemUuid().toString());
- ValidateUtil.validateCondition(system != null, HttpStatus.BAD_REQUEST, "system not available", name, null);
+ ExceptionUtil.validateConditionDataNotAvailableException(system != null, "system not available", name, null);
if (system.isDeleted()) {
return Boolean.TRUE;
}
SystemGroup systemGroup = holderIRepositories.getSystemGroupRepository().findLatestNotDeletedByUuid(system.getParentUuid().toString());
- ValidateUtil.validateCondition(systemGroup != null, HttpStatus.BAD_REQUEST, "system group not available", name, null);
+ ExceptionUtil.validateConditionDataNotAvailableException(systemGroup != null, "system group not available", name, null);
if (systemGroup.isDeleted()) {
return Boolean.TRUE;
}
} else if (toBeChecked.getSubsystemUuid() != null) {
Subsystem subsystem = holderIRepositories.getSubsystemRepository().findLatestNotDeletedByUuid(toBeChecked.getSubsystemUuid().toString());
- ValidateUtil.validateCondition(subsystem != null, HttpStatus.BAD_REQUEST, "subsystem not available", name, null);
+ ExceptionUtil.validateConditionDataNotAvailableException(subsystem != null, "subsystem not available", name, null);
if (subsystem.isDeleted()) {
return Boolean.TRUE;
}
org.openepics.names.repository.model.System system = holderIRepositories.getSystemRepository().findLatestNotDeletedByUuid(subsystem.getParentUuid().toString());
- ValidateUtil.validateCondition(system != null, HttpStatus.BAD_REQUEST, "system not available", name, null);
+ ExceptionUtil.validateConditionDataNotAvailableException(system != null, "system not available", name, null);
if (system.isDeleted()) {
return Boolean.TRUE;
}
SystemGroup systemGroup = holderIRepositories.getSystemGroupRepository().findLatestNotDeletedByUuid(system.getParentUuid().toString());
- ValidateUtil.validateCondition(systemGroup != null, HttpStatus.BAD_REQUEST, "system group not available", name, null);
+ ExceptionUtil.validateConditionDataNotAvailableException(systemGroup != null, "system group not available", name, null);
if (systemGroup.isDeleted()) {
return Boolean.TRUE;
@@ -423,21 +423,21 @@ public class NamesService {
// device structure
if (toBeChecked.getDevicetypeUuid() != null) {
DeviceType deviceType = holderIRepositories.getDeviceTypeRepository().findLatestNotDeletedByUuid(toBeChecked.getDevicetypeUuid().toString());
- ValidateUtil.validateCondition(deviceType != null, HttpStatus.BAD_REQUEST, "device type not available", name, null);
+ ExceptionUtil.validateConditionDataNotAvailableException(deviceType != null, "device type not available", name, null);
if (deviceType.isDeleted()) {
return Boolean.TRUE;
}
DeviceGroup deviceGroup = holderIRepositories.getDeviceGroupRepository().findLatestNotDeletedByUuid(deviceType.getParentUuid().toString());
- ValidateUtil.validateCondition(deviceGroup != null, HttpStatus.BAD_REQUEST, "device group not available", name, null);
+ ExceptionUtil.validateConditionDataNotAvailableException(deviceGroup != null, "device group not available", name, null);
if (deviceGroup.isDeleted()) {
return Boolean.TRUE;
}
Discipline discipline = holderIRepositories.getDisciplineRepository().findLatestNotDeletedByUuid(deviceType.getParentUuid().toString());
- ValidateUtil.validateCondition(discipline != null, HttpStatus.BAD_REQUEST, "device group not available", name, null);
+ ExceptionUtil.validateConditionDataNotAvailableException(discipline != null, "device group not available", name, null);
if (discipline.isDeleted()) {
return Boolean.TRUE;
@@ -752,7 +752,6 @@ public class NamesService {
name.setRequested(requested);
name.setRequestedBy(requestedBy);
name.setRequestedComment(requestedComment);
-
}
}
diff --git a/src/main/java/org/openepics/names/service/exception/DataConflictException.java b/src/main/java/org/openepics/names/service/exception/DataConflictException.java
new file mode 100644
index 00000000..85ea1ec7
--- /dev/null
+++ b/src/main/java/org/openepics/names/service/exception/DataConflictException.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2022 European Spallation Source ERIC.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+package org.openepics.names.service.exception;
+
+/**
+ * Exception class to assist in handling of service layer exceptions.
+ *
+ * @author Lars Johansson
+ */
+public class DataConflictException extends ServiceException {
+
+ /**
+ *
+ */
+ private static final long serialVersionUID = 717292299575574858L;
+
+ /**
+ * Public constructor.
+ *
+ * @param message message
+ * @param details details
+ * @param field field
+ */
+ public DataConflictException(String message, String details, String field) {
+ super(message, details, field, null);
+ }
+
+}
diff --git a/src/main/java/org/openepics/names/service/exception/DataDeletedException.java b/src/main/java/org/openepics/names/service/exception/DataDeletedException.java
new file mode 100644
index 00000000..f3f04ef4
--- /dev/null
+++ b/src/main/java/org/openepics/names/service/exception/DataDeletedException.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2022 European Spallation Source ERIC.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+package org.openepics.names.service.exception;
+
+/**
+ * Exception class to assist in handling of service layer exceptions.
+ *
+ * @author Lars Johansson
+ */
+public class DataDeletedException extends ServiceException {
+
+ /**
+ *
+ */
+ private static final long serialVersionUID = 8214965988959148282L;
+
+ /**
+ * Public constructor.
+ *
+ * @param message message
+ * @param details details
+ * @param field field
+ */
+ public DataDeletedException(String message, String details, String field) {
+ super(message, details, field, null);
+ }
+
+}
diff --git a/src/main/java/org/openepics/names/service/exception/DataExistException.java b/src/main/java/org/openepics/names/service/exception/DataExistException.java
new file mode 100644
index 00000000..6a33e4dd
--- /dev/null
+++ b/src/main/java/org/openepics/names/service/exception/DataExistException.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2022 European Spallation Source ERIC.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+package org.openepics.names.service.exception;
+
+/**
+ * Exception class to assist in handling of service layer exceptions.
+ *
+ * @author Lars Johansson
+ */
+public class DataExistException extends ServiceException {
+
+ /**
+ *
+ */
+ private static final long serialVersionUID = -3192828921283195697L;
+
+ /**
+ * Public constructor.
+ *
+ * @param message message
+ * @param details details
+ * @param field field
+ */
+ public DataExistException(String message, String details, String field) {
+ super(message, details, field, null);
+ }
+
+}
diff --git a/src/main/java/org/openepics/names/service/exception/DataNotAvailableException.java b/src/main/java/org/openepics/names/service/exception/DataNotAvailableException.java
new file mode 100644
index 00000000..0ef14183
--- /dev/null
+++ b/src/main/java/org/openepics/names/service/exception/DataNotAvailableException.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2022 European Spallation Source ERIC.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+package org.openepics.names.service.exception;
+
+/**
+ * Exception class to assist in handling of service layer exceptions.
+ *
+ * @author Lars Johansson
+ */
+public class DataNotAvailableException extends ServiceException {
+
+ /**
+ *
+ */
+ private static final long serialVersionUID = 771292348691428745L;
+
+ /**
+ * Public constructor.
+ *
+ * @param message message
+ * @param details details
+ * @param field field
+ */
+ public DataNotAvailableException(String message, String details, String field) {
+ super(message, details, field, null);
+ }
+
+}
diff --git a/src/main/java/org/openepics/names/service/exception/DataNotCorrectException.java b/src/main/java/org/openepics/names/service/exception/DataNotCorrectException.java
new file mode 100644
index 00000000..43e9fda6
--- /dev/null
+++ b/src/main/java/org/openepics/names/service/exception/DataNotCorrectException.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2022 European Spallation Source ERIC.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+package org.openepics.names.service.exception;
+
+/**
+ * Exception class to assist in handling of service layer exceptions.
+ *
+ * @author Lars Johansson
+ */
+public class DataNotCorrectException extends ServiceException {
+
+ /**
+ *
+ */
+ private static final long serialVersionUID = 3525813299369253195L;
+
+ /**
+ * Public constructor.
+ *
+ * @param message message
+ * @param details details
+ * @param field field
+ */
+ public DataNotCorrectException(String message, String details, String field) {
+ super(message, details, field, null);
+ }
+
+}
diff --git a/src/main/java/org/openepics/names/service/exception/DataNotFoundException.java b/src/main/java/org/openepics/names/service/exception/DataNotFoundException.java
new file mode 100644
index 00000000..966a8abc
--- /dev/null
+++ b/src/main/java/org/openepics/names/service/exception/DataNotFoundException.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2022 European Spallation Source ERIC.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+package org.openepics.names.service.exception;
+
+/**
+ * Exception class to assist in handling of service layer exceptions.
+ *
+ * @author Lars Johansson
+ */
+public class DataNotFoundException extends ServiceException {
+
+ /**
+ *
+ */
+ private static final long serialVersionUID = -3908854009422708172L;
+
+ /**
+ * Public constructor.
+ *
+ * @param message message
+ * @param details details
+ * @param field field
+ */
+ public DataNotFoundException(String message, String details, String field) {
+ super(message, details, field, null);
+ }
+
+}
diff --git a/src/main/java/org/openepics/names/service/exception/DataNotValidException.java b/src/main/java/org/openepics/names/service/exception/DataNotValidException.java
new file mode 100644
index 00000000..6a2f78fd
--- /dev/null
+++ b/src/main/java/org/openepics/names/service/exception/DataNotValidException.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2022 European Spallation Source ERIC.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+package org.openepics.names.service.exception;
+
+/**
+ * Exception class to assist in handling of service layer exceptions.
+ *
+ * @author Lars Johansson
+ */
+public class DataNotValidException extends ServiceException {
+
+ /**
+ *
+ */
+ private static final long serialVersionUID = -1203854671942406300L;
+
+ /**
+ * Public constructor.
+ *
+ * @param message message
+ * @param details details
+ * @param field field
+ */
+ public DataNotValidException(String message, String details, String field) {
+ super(message, details, field, null);
+ }
+
+}
diff --git a/src/main/java/org/openepics/names/service/exception/InputNotAvailableException.java b/src/main/java/org/openepics/names/service/exception/InputNotAvailableException.java
new file mode 100644
index 00000000..6ae21c1b
--- /dev/null
+++ b/src/main/java/org/openepics/names/service/exception/InputNotAvailableException.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2022 European Spallation Source ERIC.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+package org.openepics.names.service.exception;
+
+/**
+ * Exception class to assist in handling of service layer exceptions.
+ *
+ * @author Lars Johansson
+ */
+public class InputNotAvailableException extends ServiceException {
+
+ /**
+ *
+ */
+ private static final long serialVersionUID = 2223786874114860161L;
+
+ /**
+ * Public constructor.
+ *
+ * @param message message
+ * @param details details
+ * @param field field
+ */
+ public InputNotAvailableException(String message, String details, String field) {
+ super(message, details, field, null);
+ }
+
+}
diff --git a/src/main/java/org/openepics/names/service/exception/InputNotCorrectException.java b/src/main/java/org/openepics/names/service/exception/InputNotCorrectException.java
new file mode 100644
index 00000000..e61e92e9
--- /dev/null
+++ b/src/main/java/org/openepics/names/service/exception/InputNotCorrectException.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2022 European Spallation Source ERIC.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+package org.openepics.names.service.exception;
+
+/**
+ * Exception class to assist in handling of service layer exceptions.
+ *
+ * @author Lars Johansson
+ */
+public class InputNotCorrectException extends ServiceException {
+
+ /**
+ *
+ */
+ private static final long serialVersionUID = -1951806640288908108L;
+
+ /**
+ * Public constructor.
+ *
+ * @param message message
+ * @param details details
+ * @param field field
+ */
+ public InputNotCorrectException(String message, String details, String field) {
+ super(message, details, field, null);
+ }
+
+}
diff --git a/src/main/java/org/openepics/names/service/exception/InputNotValidException.java b/src/main/java/org/openepics/names/service/exception/InputNotValidException.java
new file mode 100644
index 00000000..aeb7b592
--- /dev/null
+++ b/src/main/java/org/openepics/names/service/exception/InputNotValidException.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2022 European Spallation Source ERIC.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+package org.openepics.names.service.exception;
+
+/**
+ * Exception class to assist in handling of service layer exceptions.
+ *
+ * @author Lars Johansson
+ */
+public class InputNotValidException extends ServiceException {
+
+ /**
+ *
+ */
+ private static final long serialVersionUID = -2652292043931691939L;
+
+ /**
+ * Public constructor.
+ *
+ * @param message message
+ * @param details details
+ * @param field field
+ */
+ public InputNotValidException(String message, String details, String field) {
+ super(message, details, field, null);
+ }
+
+}
diff --git a/src/main/java/org/openepics/names/util/ServiceHttpStatusException.java b/src/main/java/org/openepics/names/service/exception/ServiceException.java
similarity index 68%
rename from src/main/java/org/openepics/names/util/ServiceHttpStatusException.java
rename to src/main/java/org/openepics/names/service/exception/ServiceException.java
index 7a839db8..60f3ff25 100644
--- a/src/main/java/org/openepics/names/util/ServiceHttpStatusException.java
+++ b/src/main/java/org/openepics/names/service/exception/ServiceException.java
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2021 European Spallation Source ERIC.
+ * Copyright (C) 2022 European Spallation Source ERIC.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
@@ -16,51 +16,37 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
-package org.openepics.names.util;
-
-import org.springframework.http.HttpStatus;
+package org.openepics.names.service.exception;
/**
* Exception class to assist in handling of service layer exceptions.
*
* @author Lars Johansson
*/
-public class ServiceHttpStatusException extends RuntimeException {
+public class ServiceException extends RuntimeException {
/**
*
*/
- private static final long serialVersionUID = 5346696855950320329L;
+ private static final long serialVersionUID = -5521814109184738596L;
- private final HttpStatus httpStatus;
private final String details;
private final String field;
/**
* Public constructor.
*
- * @param httpStatus http status
* @param message message
* @param details details
* @param field field
* @param cause cause
*/
- public ServiceHttpStatusException(HttpStatus httpStatus, String message, String details, String field, Throwable cause) {
+ public ServiceException(String message, String details, String field, Throwable cause) {
super(message, cause);
- this.httpStatus = httpStatus;
this.details = details;
this.field = field;
}
- /**
- * Return http status of exception.
- *
- * @return http status
- */
- public HttpStatus getHttpStatus() {
- return httpStatus;
- }
-
/**
* Returns details of exception.
*
diff --git a/src/main/java/org/openepics/names/util/ExceptionUtil.java b/src/main/java/org/openepics/names/util/ExceptionUtil.java
index 8ba39c06..e754ff80 100644
--- a/src/main/java/org/openepics/names/util/ExceptionUtil.java
+++ b/src/main/java/org/openepics/names/util/ExceptionUtil.java
@@ -18,21 +18,19 @@
package org.openepics.names.util;
-import org.springframework.http.HttpStatus;
+import org.openepics.names.service.exception.DataConflictException;
+import org.openepics.names.service.exception.DataDeletedException;
+import org.openepics.names.service.exception.DataExistException;
+import org.openepics.names.service.exception.DataNotAvailableException;
+import org.openepics.names.service.exception.DataNotCorrectException;
+import org.openepics.names.service.exception.DataNotFoundException;
+import org.openepics.names.service.exception.DataNotValidException;
+import org.openepics.names.service.exception.InputNotAvailableException;
+import org.openepics.names.service.exception.InputNotCorrectException;
+import org.openepics.names.service.exception.InputNotValidException;
/**
* Utility class to assist in handling of exceptions.
- * <br/><br/>
- * Note
- * <ul>
- * <li>400 {@link HttpStatus#BAD_REQUEST}</li>
- * <li>401 {@link HttpStatus#UNAUTHORIZED}</li>
- * <li>403 {@link HttpStatus#FORBIDDEN}</li>
- * <li>404 {@link HttpStatus#NOT_FOUND}</li>
- * <li>409 {@link HttpStatus#CONFLICT}</li>
- * <li>500 {@link HttpStatus#INTERNAL_SERVER_ERROR}</li>
- * <li>501 {@link HttpStatus#NOT_IMPLEMENTED}</li>
- * </ul>
*
* @author Lars Johansson
*/
@@ -49,105 +47,275 @@ public class ExceptionUtil {
}
/**
- * Create service http status exception.
+ * Create data conflict exception.
* Intended for communication inside server.
*
- * @param status http status
* @param message message
* @param details details
* @param field field
- * @param cause cause
- * @return service http status exception
+ * @return data conflict exception
*/
- protected static ServiceHttpStatusException createServiceHttpStatusException(HttpStatus status, String message, String details, String field, Throwable cause) {
- return new ServiceHttpStatusException(status, message, details, field, cause);
+ public static DataConflictException createDataConflictException(String message, String details, String field) {
+ return new DataConflictException(message, details, field);
}
/**
- * Create service http status exception for {@link HttpStatus#BAD_REQUEST}.
+ * Create data deleted exception.
* Intended for communication inside server.
*
* @param message message
* @param details details
* @param field field
- * @return service http status exception
+ * @return data deleted exception
*/
- public static ServiceHttpStatusException createServiceHttpStatusExceptionBadRequest(String message, String details, String field) {
- return createServiceHttpStatusException(HttpStatus.BAD_REQUEST, message, details, field, null);
+ public static DataDeletedException createDataDeletedException(String message, String details, String field) {
+ return new DataDeletedException(message, details, field);
}
/**
- * Create service http status exception for {@link HttpStatus#UNAUTHORIZED}.
+ * Create data exist exception.
* Intended for communication inside server.
*
* @param message message
* @param details details
* @param field field
- * @return service http status exception
+ * @return data exist exception
*/
- public static ServiceHttpStatusException createServiceHttpStatusExceptionUnauthorized(String message, String details, String field) {
- return createServiceHttpStatusException(HttpStatus.UNAUTHORIZED, message, details, field, null);
+ public static DataExistException createDataExistException(String message, String details, String field) {
+ return new DataExistException(message, details, field);
}
/**
- * Create service http status exception for {@link HttpStatus#FORBIDDEN}.
+ * Create data not available exception.
* Intended for communication inside server.
*
* @param message message
* @param details details
* @param field field
- * @return service http status exception
+ * @return data not available exception
*/
- public static ServiceHttpStatusException createServiceHttpStatusExceptionForbidden(String message, String details, String field) {
- return createServiceHttpStatusException(HttpStatus.FORBIDDEN, message, details, field, null);
+ public static DataNotAvailableException createDataNotAvailableException(String message, String details, String field) {
+ return new DataNotAvailableException(message, details, field);
}
/**
- * Create service http status exception for {@link HttpStatus#NOT_FOUND}.
+ * Create data not correct exception.
* Intended for communication inside server.
*
* @param message message
* @param details details
* @param field field
- * @return service http status exception
+ * @return data not correct exception
*/
- public static ServiceHttpStatusException createServiceHttpStatusExceptionNotFound(String message, String details, String field) {
- return createServiceHttpStatusException(HttpStatus.NOT_FOUND, message, details, field, null);
+ public static DataNotCorrectException createDataNotCorrectException(String message, String details, String field) {
+ return new DataNotCorrectException(message, details, field);
}
/**
- * Create service http status exception for {@link HttpStatus#CONFLICT}.
+ * Create data not found exception.
* Intended for communication inside server.
*
* @param message message
* @param details details
* @param field field
- * @return service http status exception
+ * @return data not found exception
*/
- public static ServiceHttpStatusException createServiceHttpStatusExceptionConflict(String message, String details, String field) {
- return createServiceHttpStatusException(HttpStatus.CONFLICT, message, details, field, null);
+ public static DataNotFoundException createDataNotFoundException(String message, String details, String field) {
+ return new DataNotFoundException(message, details, field);
}
/**
- * Create service http status exception for {@link HttpStatus#INTERNAL_SERVER_ERROR}.
+ * Create data not valid exception.
* Intended for communication inside server.
*
* @param message message
- * @return service http status exception
+ * @param details details
+ * @param field field
+ * @return data not valid exception
+ */
+ public static DataNotValidException createDataNotValidException(String message, String details, String field) {
+ return new DataNotValidException(message, details, field);
+ }
+
+ /**
+ * Create input not available exception.
+ * Intended for communication inside server.
+ *
+ * @param message message
+ * @param details details
+ * @param field field
+ * @return input not available exception
+ */
+ public static InputNotAvailableException createInputNotAvailableException(String message, String details, String field) {
+ return new InputNotAvailableException(message, details, field);
+ }
+
+ /**
+ * Create input not correct exception.
+ * Intended for communication inside server.
+ *
+ * @param message message
+ * @param details details
+ * @param field field
+ * @return input not correct exception
*/
- public static ServiceHttpStatusException createServiceHttpStatusExceptionInternalServerError(String message, String details, String field) {
- return createServiceHttpStatusException(HttpStatus.INTERNAL_SERVER_ERROR, message, details, field, null);
+ public static InputNotCorrectException createInputNotCorrectException(String message, String details, String field) {
+ return new InputNotCorrectException(message, details, field);
}
/**
- * Create service http status exception for {@link HttpStatus#NOT_IMPLEMENTED}.
+ * Create input not valid exception.
* Intended for communication inside server.
*
* @param message message
- * @return service http status exception
+ * @param details details
+ * @param field field
+ * @return input not valid exception
+ */
+ public static InputNotValidException createInputNotValidException(String message, String details, String field) {
+ return new InputNotValidException(message, details, field);
+ }
+
+ // ----------------------------------------------------------------------------------------------------
+
+ /**
+ * Validate condition and throw data conflict exception if condition not <tt>true</tt>.
+ *
+ * @param condition condition
+ * @param message message
+ * @param details details
+ * @param field field
+ */
+ public static void validateConditionDataConflictException(boolean condition, String message, String details, String field) {
+ if (!condition) {
+ throw ExceptionUtil.createDataConflictException(message, details, field);
+ }
+ }
+
+ /**
+ * Validate condition and throw data deleted exception if condition not <tt>true</tt>.
+ *
+ * @param condition condition
+ * @param message message
+ * @param details details
+ * @param field field
+ */
+ public static void validateConditionDataDeletedException(boolean condition, String message, String details, String field) {
+ if (!condition) {
+ throw ExceptionUtil.createDataDeletedException(message, details, field);
+ }
+ }
+
+ /**
+ * Validate condition and throw data exist exception if condition not <tt>true</tt>.
+ *
+ * @param condition condition
+ * @param message message
+ * @param details details
+ * @param field field
+ */
+ public static void validateConditionDataExistException(boolean condition, String message, String details, String field) {
+ if (!condition) {
+ throw ExceptionUtil.createDataExistException(message, details, field);
+ }
+ }
+
+ /**
+ * Validate condition and throw data not available exception if condition not <tt>true</tt>.
+ *
+ * @param condition condition
+ * @param message message
+ * @param details details
+ * @param field field
+ */
+ public static void validateConditionDataNotAvailableException(boolean condition, String message, String details, String field) {
+ if (!condition) {
+ throw ExceptionUtil.createDataNotAvailableException(message, details, field);
+ }
+ }
+
+ /**
+ * Validate condition and throw data not correct exception if condition not <tt>true</tt>.
+ *
+ * @param condition condition
+ * @param message message
+ * @param details details
+ * @param field field
+ */
+ public static void validateConditionDataNotCorrectException(boolean condition, String message, String details, String field) {
+ if (!condition) {
+ throw ExceptionUtil.createDataNotCorrectException(message, details, field);
+ }
+ }
+
+ /**
+ * Validate condition and throw data not found exception if condition not <tt>true</tt>.
+ *
+ * @param condition condition
+ * @param message message
+ * @param details details
+ * @param field field
+ */
+ public static void validateConditionDataNotFoundException(boolean condition, String message, String details, String field) {
+ if (!condition) {
+ throw ExceptionUtil.createDataNotFoundException(message, details, field);
+ }
+ }
+
+ /**
+ * Validate condition and throw data not valid exception if condition not <tt>true</tt>.
+ *
+ * @param condition condition
+ * @param message message
+ * @param details details
+ * @param field field
+ */
+ public static void validateConditionDataNotValidException(boolean condition, String message, String details, String field) {
+ if (!condition) {
+ throw ExceptionUtil.createDataNotValidException(message, details, field);
+ }
+ }
+
+ /**
+ * Validate condition and throw input not available exception if condition not <tt>true</tt>.
+ *
+ * @param condition condition
+ * @param message message
+ * @param details details
+ * @param field field
+ */
+ public static void validateConditionInputNotAvailableException(boolean condition, String message, String details, String field) {
+ if (!condition) {
+ throw ExceptionUtil.createInputNotAvailableException(message, details, field);
+ }
+ }
+
+ /**
+ * Validate condition and throw input not correct exception if condition not <tt>true</tt>.
+ *
+ * @param condition condition
+ * @param message message
+ * @param details details
+ * @param field field
+ */
+ public static void validateConditionInputNotCorrectException(boolean condition, String message, String details, String field) {
+ if (!condition) {
+ throw ExceptionUtil.createInputNotCorrectException(message, details, field);
+ }
+ }
+
+ /**
+ * Validate condition and throw input not valid exception if condition not <tt>true</tt>.
+ *
+ * @param condition condition
+ * @param message message
+ * @param details details
+ * @param field field
*/
- public static ServiceHttpStatusException createServiceHttpStatusExceptionNotImplemented(String message, String details, String field) {
- return createServiceHttpStatusException(HttpStatus.NOT_IMPLEMENTED, message, details, field, null);
+ public static void validateConditionInputNotValidException(boolean condition, String message, String details, String field) {
+ if (!condition) {
+ throw ExceptionUtil.createInputNotValidException(message, details, field);
+ }
}
}
diff --git a/src/main/java/org/openepics/names/util/LogUtil.java b/src/main/java/org/openepics/names/util/LogUtil.java
index a088b95c..f8acc373 100644
--- a/src/main/java/org/openepics/names/util/LogUtil.java
+++ b/src/main/java/org/openepics/names/util/LogUtil.java
@@ -22,6 +22,7 @@ import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.commons.lang3.StringUtils;
+import org.openepics.names.service.exception.ServiceException;
/**
* Utility class to assist in handling of logs.
@@ -41,13 +42,13 @@ public class LogUtil {
}
/**
- * Log service http status exception.
+ * Log service exception.
*
* @param logger logger
* @param level log level
- * @param e service https status exception
+ * @param e service exception
*/
- public static void logServiceHttpStatusException(Logger logger, Level level, ServiceHttpStatusException e) {
+ public static void logServiceException(Logger logger, Level level, ServiceException e) {
if (logger == null || level == null || e == null) {
return;
}
@@ -58,10 +59,10 @@ public class LogUtil {
String details = !StringUtils.isEmpty(e.getDetails())
? " ### " + e.getDetails()
: "";
- String httpStatus = e.getHttpStatus() != null
- ? " ### " + e.getHttpStatus().toString()
+ String field = !StringUtils.isEmpty(e.getField())
+ ? " ### " + e.getField()
: "";
- msg = msg + details + httpStatus;
+ msg = msg + details + field;
logger.log(level, msg);
}
@@ -71,9 +72,9 @@ public class LogUtil {
*
* @param logger logger
* @param level log level
- * @param e service https status exception
+ * @param e service exception
*/
- public static void logStackTraceElements(Logger logger, Level level, ServiceHttpStatusException e) {
+ public static void logStackTraceElements(Logger logger, Level level, ServiceException e) {
logStackTraceElements(logger, Level.SEVERE, e, 10, ORG_OPENEPICS_NAMES, ORG_OPENEPICS_NAMES_UTIL_EXCEPTION_UTIL);
}
@@ -93,12 +94,12 @@ public class LogUtil {
*
* @param logger logger
* @param level log level
- * @param e service https status exception
+ * @param e service exception
* @param maxNumberOfLogs max number of logs
* @param filterInclude filter include
* @param filterExclude filter exclude
*/
- public static void logStackTraceElements(Logger logger, Level level, ServiceHttpStatusException e, int maxNumberOfLogs, String filterInclude, String filterExclude) {
+ public static void logStackTraceElements(Logger logger, Level level, ServiceException e, int maxNumberOfLogs, String filterInclude, String filterExclude) {
if (logger == null || level == null || e == null || maxNumberOfLogs <= 0) {
return;
}
@@ -106,6 +107,7 @@ public class LogUtil {
logStackTraceElements(logger, level, e.getStackTrace(), maxNumberOfLogs, filterInclude, filterExclude);
}
+
/**
* Log stack trace elements.
*
diff --git a/src/main/java/org/openepics/names/util/ValidateUtil.java b/src/main/java/org/openepics/names/util/ValidateUtil.java
index 91ad1ade..be8c91c3 100644
--- a/src/main/java/org/openepics/names/util/ValidateUtil.java
+++ b/src/main/java/org/openepics/names/util/ValidateUtil.java
@@ -36,7 +36,7 @@ import org.openepics.names.rest.beans.Status;
import org.openepics.names.rest.beans.Type;
import org.openepics.names.rest.beans.element.NameElementCommand;
import org.openepics.names.rest.beans.element.StructureElementCommand;
-import org.springframework.http.HttpStatus;
+import org.openepics.names.service.exception.DataConflictException;
/**
* Utility class to assist in handling of validation.
@@ -106,8 +106,8 @@ public class ValidateUtil {
*/
public static void validateInputComment(String comment) {
// available
- validateCondition(!StringUtils.isEmpty(comment), HttpStatus.BAD_REQUEST,
- "comment " + ValidateUtil.IS_NOT_AVAILABLE, comment, "comment");
+ ExceptionUtil.validateConditionInputNotAvailableException(
+ !StringUtils.isEmpty(comment), "comment " + ValidateUtil.IS_NOT_AVAILABLE, comment, "comment");
}
/**
@@ -117,8 +117,8 @@ public class ValidateUtil {
*/
public static void validateInputDescription(String description) {
// available
- validateCondition(!StringUtils.isEmpty(description), HttpStatus.BAD_REQUEST,
- "description " + ValidateUtil.IS_NOT_AVAILABLE, description, "description");
+ ExceptionUtil.validateConditionInputNotAvailableException(
+ !StringUtils.isEmpty(description), "description " + ValidateUtil.IS_NOT_AVAILABLE, description, "description");
}
/**
@@ -128,8 +128,8 @@ public class ValidateUtil {
*/
public static void validateInputIndex(String index) {
// available
- validateCondition(!StringUtils.isEmpty(index), HttpStatus.BAD_REQUEST,
- "index " + ValidateUtil.IS_NOT_AVAILABLE, index, "index");
+ ExceptionUtil.validateConditionInputNotAvailableException(
+ !StringUtils.isEmpty(index), "index " + ValidateUtil.IS_NOT_AVAILABLE, index, "index");
}
/**
@@ -139,8 +139,8 @@ public class ValidateUtil {
*/
public static void validateInputMnemonic(String mnemonic) {
// available
- validateCondition(!StringUtils.isEmpty(mnemonic), HttpStatus.BAD_REQUEST,
- "mnemonic " + ValidateUtil.IS_NOT_AVAILABLE, mnemonic, "mnemonic");
+ ExceptionUtil.validateConditionInputNotAvailableException(
+ !StringUtils.isEmpty(mnemonic), "mnemonic " + ValidateUtil.IS_NOT_AVAILABLE, mnemonic, "mnemonic");
}
/**
@@ -150,8 +150,8 @@ public class ValidateUtil {
*/
public static void validateInputMnemonicpath(String mnemonicpath) {
// available
- validateCondition(!StringUtils.isEmpty(mnemonicpath), HttpStatus.BAD_REQUEST,
- "mnemonicpath " + ValidateUtil.IS_NOT_AVAILABLE, mnemonicpath, "mnemonicpath");
+ ExceptionUtil.validateConditionInputNotAvailableException(
+ !StringUtils.isEmpty(mnemonicpath), "mnemonicpath " + ValidateUtil.IS_NOT_AVAILABLE, mnemonicpath, "mnemonicpath");
}
/**
@@ -161,8 +161,8 @@ public class ValidateUtil {
*/
public static void validateInputName(String name) {
// available
- validateCondition(!StringUtils.isEmpty(name), HttpStatus.BAD_REQUEST,
- "name " + ValidateUtil.IS_NOT_AVAILABLE, name, "name");
+ ExceptionUtil.validateConditionInputNotAvailableException(
+ !StringUtils.isEmpty(name), "name " + ValidateUtil.IS_NOT_AVAILABLE, name, "name");
}
/**
@@ -182,12 +182,13 @@ public class ValidateUtil {
*/
public static void validateInputStatus(Status status, Status expected) {
// available
- validateCondition(status != null, HttpStatus.BAD_REQUEST,
- "status " + ValidateUtil.IS_NOT_AVAILABLE, null, "status");
+ ExceptionUtil.validateConditionInputNotAvailableException(
+ status != null, "status " + ValidateUtil.IS_NOT_AVAILABLE, null, "status");
+
// expected status
if (expected != null) {
- validateCondition(expected.equals(status), HttpStatus.BAD_REQUEST,
- "status " + ValidateUtil.IS_NOT_CORRECT, status.toString(), "status");
+ ExceptionUtil.validateConditionInputNotCorrectException(
+ expected.equals(status), "status " + ValidateUtil.IS_NOT_CORRECT, status.toString(), "status");
}
}
@@ -208,12 +209,13 @@ public class ValidateUtil {
*/
public static void validateInputType(Type type, Type expected) {
// available
- validateCondition(type != null, HttpStatus.BAD_REQUEST,
- "type " + ValidateUtil.IS_NOT_AVAILABLE, null, "type");
+ ExceptionUtil.validateConditionInputNotAvailableException(
+ type != null, "type " + ValidateUtil.IS_NOT_AVAILABLE, null, "type");
+
// expected type
if (expected != null) {
- validateCondition(expected.equals(type), HttpStatus.BAD_REQUEST,
- "type " + ValidateUtil.IS_NOT_CORRECT, type.toString(), "type");
+ ExceptionUtil.validateConditionInputNotCorrectException(
+ expected.equals(type), "type " + ValidateUtil.IS_NOT_CORRECT, type.toString(), "type");
}
}
@@ -225,13 +227,12 @@ public class ValidateUtil {
public static void validateInputUuid(String uuid) {
// available
// correct
- validateCondition(!StringUtils.isEmpty(uuid), HttpStatus.BAD_REQUEST,
- "uuid " + ValidateUtil.IS_NOT_AVAILABLE, uuid, "uuid");
+ ExceptionUtil.validateConditionInputNotAvailableException(
+ !StringUtils.isEmpty(uuid), "uuid " + ValidateUtil.IS_NOT_AVAILABLE, uuid, "uuid");
try {
UUID.fromString(uuid);
} catch (IllegalArgumentException e) {
- throw ExceptionUtil.createServiceHttpStatusExceptionBadRequest(
- "uuid " + ValidateUtil.IS_NOT_CORRECT, uuid, null);
+ throw ExceptionUtil.createInputNotCorrectException("uuid " + ValidateUtil.IS_NOT_CORRECT, uuid, null);
}
}
@@ -264,8 +265,8 @@ public class ValidateUtil {
boolean condition = ((queryFields == null && queryValues == null)
|| (queryFields != null && queryValues != null && queryFields.length == queryValues.length && queryFields.length > 0));
- ValidateUtil.validateCondition(condition, HttpStatus.BAD_REQUEST,
- "url and parameters " + ValidateUtil.ARE_NOT_CORRECT, "queryFields, queryValues with different lengths or empty", null);
+ ExceptionUtil.validateConditionInputNotCorrectException(
+ condition, "url and parameters " + ValidateUtil.ARE_NOT_CORRECT, "queryFields, queryValues with different lengths or empty", null);
if (queryFields != null) {
for (int i=0; i<queryFields.length; i++) {
if (FieldName.UUID.equals(queryFields[i])) {
@@ -326,12 +327,18 @@ public class ValidateUtil {
}
if (!NameChoice.DELETE.equals(nameChoice)) {
- ValidateUtil.validateCondition(nameElement.getParentsystemstructure() != null, HttpStatus.BAD_REQUEST,
+ ExceptionUtil.validateConditionInputNotAvailableException(nameElement.getParentsystemstructure() != null,
"parent system structure uuid " + ValidateUtil.IS_NOT_CORRECT, nameElement.toString(), "parentsystemstructure");
- // parentdevicestructure optional
+ // optional (either none or both)
+ // parentdevicestructure
+ // index
+ if (nameElement.getParentdevicestructure() != null && nameElement.getIndex() == null) {
+ throw ExceptionUtil.createInputNotValidException("index " + ValidateUtil.IS_NOT_VALID, nameElement.toString(), "index");
+ } else if (nameElement.getParentdevicestructure() == null && nameElement.getIndex() != null) {
+ throw ExceptionUtil.createInputNotValidException("parent device structure uuid " + ValidateUtil.IS_NOT_CORRECT, nameElement.toString(), "parentdevicestructure");
+ }
- // validateInputIndex(nameElement.getIndex()); optional
validateInputDescription(nameElement.getDescription());
}
@@ -412,8 +419,7 @@ public class ValidateUtil {
// retrieve for uuid and check
if (NameChoice.UPDATE.equals(nameChoice) || NameChoice.DELETE.equals(nameChoice)) {
List<Name> names = nameRepository.readNames(false, FieldName.UUID, nameElement.getUuid().toString());
- validateCondition(names != null && names.size() == 1, HttpStatus.BAD_REQUEST,
- ValidateUtil.NAME + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, nameElement.toString(), "uuid");
+ ExceptionUtil.validateConditionDataNotCorrectException(names != null && names.size() == 1, ValidateUtil.NAME + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, nameElement.toString(), "uuid");
}
SystemGroup systemGroup = null;
@@ -451,25 +457,25 @@ public class ValidateUtil {
if (nameElement.getParentdevicestructure() != null) {
countDevicestructureIndex++;
deviceType = holderIRepositories.getDeviceTypeRepository().findLatestByUuid(nameElement.getParentdevicestructure().toString());
- ValidateUtil.validateCondition(deviceType != null, HttpStatus.BAD_REQUEST, ValidateUtil.DEVICETYPE + ValidateUtil.SPACE + ValidateUtil.IS_NOT_AVAILABLE, nameElement.toString(), "parentdevicestructure");
- ValidateUtil.validateCondition(!deviceType.isDeleted(), HttpStatus.BAD_REQUEST, ValidateUtil.DEVICETYPE + ValidateUtil.SPACE + ValidateUtil.IS_DELETED, nameElement.toString(), "parentdevicestructure");
+ ExceptionUtil.validateConditionDataNotAvailableException(deviceType != null, ValidateUtil.DEVICETYPE + ValidateUtil.SPACE + ValidateUtil.IS_NOT_AVAILABLE, nameElement.toString(), "parentdevicestructure");
+ ExceptionUtil.validateConditionDataDeletedException(!deviceType.isDeleted(), ValidateUtil.DEVICETYPE + ValidateUtil.SPACE + ValidateUtil.IS_DELETED, nameElement.toString(), "parentdevicestructure");
}
// system structure
if (systemGroup != null) {
- ValidateUtil.validateCondition(!systemGroup.isDeleted(), HttpStatus.BAD_REQUEST, ValidateUtil.SYSTEMGROUP + ValidateUtil.SPACE + ValidateUtil.IS_DELETED, nameElement.toString(), "parentsystemstructure");
+ ExceptionUtil.validateConditionDataDeletedException(!systemGroup.isDeleted(), ValidateUtil.SYSTEMGROUP + ValidateUtil.SPACE + ValidateUtil.IS_DELETED, nameElement.toString(), "parentsystemstructure");
derivedName = NameUtil.getName(systemGroup, deviceType, nameElement.getIndex(), holder);
} else if (system != null) {
- ValidateUtil.validateCondition(!system.isDeleted(), HttpStatus.BAD_REQUEST, ValidateUtil.SYSTEM + ValidateUtil.SPACE + ValidateUtil.IS_DELETED, nameElement.toString(), "parentsystemstructure");
+ ExceptionUtil.validateConditionDataDeletedException(!system.isDeleted(), ValidateUtil.SYSTEM + ValidateUtil.SPACE + ValidateUtil.IS_DELETED, nameElement.toString(), "parentsystemstructure");
derivedName = NameUtil.getName(system, deviceType, nameElement.getIndex(), holder);
} else if (subsystem != null) {
- ValidateUtil.validateCondition(!subsystem.isDeleted(), HttpStatus.BAD_REQUEST, ValidateUtil.SUBSYSTEM + ValidateUtil.SPACE + ValidateUtil.IS_DELETED, nameElement.toString(), "parentsystemstructure");
+ ExceptionUtil.validateConditionDataDeletedException(!subsystem.isDeleted(), ValidateUtil.SUBSYSTEM + ValidateUtil.SPACE + ValidateUtil.IS_DELETED, nameElement.toString(), "parentsystemstructure");
derivedName = NameUtil.getName(subsystem, deviceType, nameElement.getIndex(), holder);
} else {
- throw ExceptionUtil.createServiceHttpStatusExceptionBadRequest("system structure uuid " + IS_NOT_CORRECT, nameElement.toString(), null);
+ throw ExceptionUtil.createDataNotCorrectException("system structure uuid " + IS_NOT_CORRECT, nameElement.toString(), null);
}
// index
@@ -477,11 +483,11 @@ public class ValidateUtil {
countDevicestructureIndex++;
// TODO overrideRuleset depend on user authority
condition = namingConvention.isInstanceIndexValid(derivedName, false);
- validateCondition(condition, HttpStatus.BAD_REQUEST, "instance index " + ValidateUtil.IS_NOT_VALID, nameElement.toString(), "index");
+ ExceptionUtil.validateConditionDataNotValidException(condition, "instance index " + ValidateUtil.IS_NOT_VALID, nameElement.toString(), "index");
}
condition = countDevicestructureIndex == 0 || countDevicestructureIndex == 2;
- ValidateUtil.validateCondition(condition, HttpStatus.BAD_REQUEST, ValidateUtil.DEVICETYPE + ValidateUtil.SPACE + "or instance index " + ValidateUtil.IS_NOT_AVAILABLE, nameElement.toString(), "parentdevicestructure");
+ ExceptionUtil.validateConditionDataNotAvailableException(condition, ValidateUtil.DEVICETYPE + ValidateUtil.SPACE + "or instance index " + ValidateUtil.IS_NOT_AVAILABLE, nameElement.toString(), "parentdevicestructure");
// name
// ok with same name, name equivalence if same uuid
@@ -492,7 +498,7 @@ public class ValidateUtil {
// NameChoice.UPDATE.equals(nameChoice)
condition = names == null || names.isEmpty() || names.size() == 1 && names.get(0).getUuid().equals(nameElement.getUuid());
}
- validateCondition(condition, HttpStatus.BAD_REQUEST, "convention name " + ValidateUtil.EXISTS, nameElement.toString(), null);
+ ExceptionUtil.validateConditionDataExistException(condition, "convention name " + ValidateUtil.EXISTS, nameElement.toString(), null);
names = nameRepository.readNames(false, FieldName.NAMEEQUIVALENCE, namingConvention.equivalenceClassRepresentative(derivedName));
if (NameChoice.CREATE.equals(nameChoice)) {
@@ -501,7 +507,7 @@ public class ValidateUtil {
// NameChoice.UPDATE.equals(nameChoice)
condition = names == null || names.isEmpty() || names.size() == 1 && names.get(0).getUuid().equals(nameElement.getUuid());
}
- validateCondition(condition, HttpStatus.BAD_REQUEST, "convention name equivalence " + ValidateUtil.EXISTS, nameElement.toString(), null);
+ ExceptionUtil.validateConditionDataExistException(condition, "convention name equivalence " + ValidateUtil.EXISTS, nameElement.toString(), null);
} else if (NameChoice.DELETE.equals(nameChoice)) {
// n.a.
// uuid - already handled
@@ -550,12 +556,10 @@ public class ValidateUtil {
count++;
}
if (count > 2 || count < 1) {
- throw ExceptionUtil.createServiceHttpStatusExceptionBadRequest(
- "system structure " + ValidateUtil.IS_NOT_CORRECT, name, null);
+ throw ExceptionUtil.createDataNotCorrectException("system structure " + ValidateUtil.IS_NOT_CORRECT, name, null);
} else if ( (!StringUtils.isEmpty(sg) && !StringUtils.isEmpty(sys))
|| (!StringUtils.isEmpty(sg) && !StringUtils.isEmpty(sub))) {
- throw ExceptionUtil.createServiceHttpStatusExceptionBadRequest(
- "system structure " + ValidateUtil.IS_NOT_CORRECT, name, null);
+ throw ExceptionUtil.createDataNotCorrectException("system structure " + ValidateUtil.IS_NOT_CORRECT, name, null);
}
SystemGroup systemGroup = null;
@@ -583,35 +587,30 @@ public class ValidateUtil {
// device structure
if (!StringUtils.isEmpty(dt)) {
deviceType = holderIRepositories.getDeviceTypeRepository().findLatestNotDeletedByMnemonic(dt);
- ValidateUtil.validateCondition(deviceType != null, HttpStatus.BAD_REQUEST,
- ValidateUtil.DEVICETYPE + ValidateUtil.SPACE + ValidateUtil.IS_NOT_AVAILABLE, name, null);
+ ExceptionUtil.validateConditionDataNotAvailableException(deviceType != null, ValidateUtil.DEVICETYPE + ValidateUtil.SPACE + ValidateUtil.IS_NOT_AVAILABLE, name, null);
}
// system structure
if (!StringUtils.isEmpty(sg)) {
systemGroup = holderIRepositories.getSystemGroupRepository().findLatestNotDeletedByMnemonic(sg);
- ValidateUtil.validateCondition(systemGroup != null, HttpStatus.BAD_REQUEST,
- ValidateUtil.SYSTEMGROUP + ValidateUtil.SPACE + ValidateUtil.IS_NOT_AVAILABLE, name, null);
+ ExceptionUtil.validateConditionDataNotAvailableException(systemGroup != null, ValidateUtil.SYSTEMGROUP + ValidateUtil.SPACE + ValidateUtil.IS_NOT_AVAILABLE, name, null);
derivedName = NameUtil.getName(systemGroup, deviceType, NamingConventionUtil.extractInstanceIndex(name), holder);
} else {
if (!StringUtils.isEmpty(sys)) {
system = holderIRepositories.getSystemRepository().findLatestNotDeletedByMnemonic(sys);
- ValidateUtil.validateCondition(system != null, HttpStatus.BAD_REQUEST,
- ValidateUtil.SYSTEM + ValidateUtil.SPACE + ValidateUtil.IS_NOT_AVAILABLE, name, null);
+ ExceptionUtil.validateConditionDataNotAvailableException(system != null, ValidateUtil.SYSTEM + ValidateUtil.SPACE + ValidateUtil.IS_NOT_AVAILABLE, name, null);
derivedName = NameUtil.getName(system, deviceType, NamingConventionUtil.extractInstanceIndex(name), holder);
} else {
- throw ExceptionUtil.createServiceHttpStatusExceptionBadRequest(
+ throw ExceptionUtil.createDataNotAvailableException(
ValidateUtil.SYSTEM + ValidateUtil.SPACE + ValidateUtil.IS_NOT_AVAILABLE, name, null);
}
// TODO is this condition correct?
- ValidateUtil.validateCondition(system != null, HttpStatus.BAD_REQUEST,
- ValidateUtil.SYSTEM + ValidateUtil.SPACE + ValidateUtil.IS_NOT_AVAILABLE, name, null);
+ ExceptionUtil.validateConditionDataNotAvailableException(system != null, ValidateUtil.SYSTEM + ValidateUtil.SPACE + ValidateUtil.IS_NOT_AVAILABLE, name, null);
if (!StringUtils.isEmpty(sub)) {
subsystem = holderIRepositories.getSubsystemRepository().findLatestNotDeletedByParentAndMnemonic(system.getUuid().toString(), sub);
- ValidateUtil.validateCondition(subsystem != null, HttpStatus.BAD_REQUEST,
- ValidateUtil.SUBSYSTEM + ValidateUtil.SPACE + ValidateUtil.IS_NOT_AVAILABLE, name, null);
+ ExceptionUtil.validateConditionDataNotAvailableException(subsystem != null, ValidateUtil.SUBSYSTEM + ValidateUtil.SPACE + ValidateUtil.IS_NOT_AVAILABLE, name, null);
derivedName = NameUtil.getName(subsystem, deviceType, NamingConventionUtil.extractInstanceIndex(name), holder);
}
@@ -621,8 +620,7 @@ public class ValidateUtil {
if (!StringUtils.isEmpty(idx)) {
// TODO overrideRuleset depend on user authority
condition = namingConvention.isInstanceIndexValid(name, false);
- validateCondition(condition, HttpStatus.BAD_REQUEST,
- "instance index " + ValidateUtil.IS_NOT_VALID, name, null);
+ ExceptionUtil.validateConditionDataNotValidException(condition, "instance index " + ValidateUtil.IS_NOT_VALID, name, null);
}
// name
@@ -630,18 +628,15 @@ public class ValidateUtil {
// convention name not exists
// convention name equivalence not exists
condition = StringUtils.equals(name, derivedName);
- validateCondition(condition, HttpStatus.BAD_REQUEST,
- "convention name " + ValidateUtil.IS_NOT_CORRECT, name, null);
+ ExceptionUtil.validateConditionDataNotCorrectException(condition, "convention name " + ValidateUtil.IS_NOT_CORRECT, name, null);
List<Name> names = nameRepository.readNames(false, FieldName.NAME, name);
condition = names == null || names.isEmpty();
- validateCondition(condition, HttpStatus.BAD_REQUEST,
- "convention name " + ValidateUtil.EXISTS, name, null);
+ ExceptionUtil.validateConditionDataExistException(condition, "convention name " + ValidateUtil.EXISTS, name, null);
names = nameRepository.readNames(false, FieldName.NAMEEQUIVALENCE, namingConvention.equivalenceClassRepresentative(name));
condition = names == null || names.isEmpty();
- validateCondition(condition, HttpStatus.BAD_REQUEST,
- "convention name equivalence " + ValidateUtil.EXISTS, name, null);
+ ExceptionUtil.validateConditionDataExistException(condition, "convention name equivalence " + ValidateUtil.EXISTS, name, null);
}
// ----------------------------------------------------------------------------------------------------
@@ -677,7 +672,7 @@ public class ValidateUtil {
ValidateUtil.validateInputType(type);
boolean condition = ((queryFields == null && queryValues == null)
|| (queryFields != null && queryValues != null && queryFields.length == queryValues.length && queryFields.length > 0));
- ValidateUtil.validateCondition(condition, HttpStatus.BAD_REQUEST,
+ ExceptionUtil.validateConditionInputNotCorrectException(condition,
"url and parameters " + ValidateUtil.ARE_NOT_CORRECT, "queryFields, queryValues with different lengths or empty", null);
if (queryFields != null) {
for (int i=0; i<queryFields.length; i++) {
@@ -768,18 +763,13 @@ public class ValidateUtil {
validateInputType(structureElement.getType());
if (!StructureChoice.DELETE.equals(structureChoice)) {
- if (Type.SYSTEM.equals(structureElement.getType())) {
- validateCondition(structureElement.getParent() != null, HttpStatus.BAD_REQUEST, "parent uuid " + ValidateUtil.IS_NOT_AVAILABLE, structureElement.toString(), "parent");
- ValidateUtil.validateInputUuid(structureElement.getParent().toString());
- } else if (Type.SUBSYSTEM.equals(structureElement.getType())) {
- validateCondition(structureElement.getParent() != null, HttpStatus.BAD_REQUEST, "parent uuid " + ValidateUtil.IS_NOT_AVAILABLE, structureElement.toString(), "parent");
- ValidateUtil.validateInputUuid(structureElement.getParent().toString());
- } else if (Type.DEVICEGROUP.equals(structureElement.getType())) {
- validateCondition(structureElement.getParent() != null, HttpStatus.BAD_REQUEST, "parent uuid " + ValidateUtil.IS_NOT_AVAILABLE, structureElement.toString(), "parent");
- ValidateUtil.validateInputUuid(structureElement.getParent().toString());
- } else if (Type.DEVICETYPE.equals(structureElement.getType())) {
- validateCondition(structureElement.getParent() != null, HttpStatus.BAD_REQUEST, "parent uuid " + ValidateUtil.IS_NOT_AVAILABLE, structureElement.toString(), "parent");
- ValidateUtil.validateInputUuid(structureElement.getParent().toString());
+ switch (structureElement.getType()) {
+ case SYSTEM, SUBSYSTEM, DEVICEGROUP, DEVICETYPE:
+ ExceptionUtil.validateConditionInputNotAvailableException(structureElement.getParent() != null, "parent uuid " + ValidateUtil.IS_NOT_AVAILABLE, structureElement.toString(), "parent");
+ ValidateUtil.validateInputUuid(structureElement.getParent().toString());
+ break;
+ default:
+ break;
}
validateInputName(structureElement.getName());
@@ -788,7 +778,7 @@ public class ValidateUtil {
// validate mnemonic input (value itself, not in relation to other values)
// validateMnemonic takes isMnemonicRequired into account
MnemonicValidation mnemonicValidation = namingConvention.validateMnemonic(structureElement.getType(), structureElement.getMnemonic());
- validateCondition(MnemonicValidation.VALID.equals(mnemonicValidation), HttpStatus.BAD_REQUEST, "mnemonic " + ValidateUtil.IS_NOT_VALID, structureElement.toString(), "mnemonic");
+ ExceptionUtil.validateConditionInputNotValidException(MnemonicValidation.VALID.equals(mnemonicValidation), "mnemonic " + ValidateUtil.IS_NOT_VALID, structureElement.toString(), "mnemonic");
validateInputDescription(structureElement.getDescription());
}
@@ -905,80 +895,80 @@ public class ValidateUtil {
// status, uuid
// status, not deleted, uuid
systemGroups = holderRepositories.getSystemGroupRepository().readSystemGroups(Status.PENDING, null, FieldStructure.UUID, structureElement.getUuid().toString());
- ValidateUtil.validateCondition(systemGroups != null && systemGroups.size() == 0, HttpStatus.BAD_REQUEST, ValidateUtil.SYSTEMGROUP + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
+ ExceptionUtil.validateConditionDataNotCorrectException(systemGroups != null && systemGroups.size() == 0, ValidateUtil.SYSTEMGROUP + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
systemGroups = holderRepositories.getSystemGroupRepository().readSystemGroups(Status.APPROVED, false, FieldStructure.UUID, structureElement.getUuid().toString());
- ValidateUtil.validateCondition(systemGroups != null && systemGroups.size() == 1, HttpStatus.BAD_REQUEST, ValidateUtil.SYSTEMGROUP + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
+ ExceptionUtil.validateConditionDataNotCorrectException(systemGroups != null && systemGroups.size() == 1, ValidateUtil.SYSTEMGROUP + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
} else if (Type.SYSTEM.equals(structureElement.getType())) {
List<System> systems = null;
// status, uuid
// status, not deleted, uuid
systems = holderRepositories.getSystemRepository().readSystems(Status.PENDING, null, FieldStructure.UUID, structureElement.getUuid().toString());
- ValidateUtil.validateCondition(systems != null && systems.size() == 0, HttpStatus.BAD_REQUEST, ValidateUtil.SYSTEM + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
+ ExceptionUtil.validateConditionDataNotCorrectException(systems != null && systems.size() == 0, ValidateUtil.SYSTEM + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
systems = holderRepositories.getSystemRepository().readSystems(Status.APPROVED, false, FieldStructure.UUID, structureElement.getUuid().toString());
- ValidateUtil.validateCondition(systems != null && systems.size() == 1, HttpStatus.BAD_REQUEST, ValidateUtil.SYSTEM + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
+ ExceptionUtil.validateConditionDataNotCorrectException(systems != null && systems.size() == 1, ValidateUtil.SYSTEM + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
} else if (Type.SUBSYSTEM.equals(structureElement.getType())) {
List<Subsystem> subsystems = null;
// status, uuid
// status, not deleted, uuid
subsystems = holderRepositories.getSubsystemRepository().readSubsystems(Status.PENDING, null, FieldStructure.UUID, structureElement.getUuid().toString());
- ValidateUtil.validateCondition(subsystems != null && subsystems.size() == 0, HttpStatus.BAD_REQUEST, ValidateUtil.SUBSYSTEM + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
+ ExceptionUtil.validateConditionDataNotCorrectException(subsystems != null && subsystems.size() == 0, ValidateUtil.SUBSYSTEM + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
subsystems = holderRepositories.getSubsystemRepository().readSubsystems(Status.APPROVED, false, FieldStructure.UUID, structureElement.getUuid().toString());
- ValidateUtil.validateCondition(subsystems != null && subsystems.size() == 1, HttpStatus.BAD_REQUEST, ValidateUtil.SUBSYSTEM + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
+ ExceptionUtil.validateConditionDataNotCorrectException(subsystems != null && subsystems.size() == 1, ValidateUtil.SUBSYSTEM + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
} else if (Type.DISCIPLINE.equals(structureElement.getType())) {
List<Discipline> disciplines = null;
// status, uuid
// status, not deleted, uuid
disciplines = holderRepositories.getDisciplineRepository().readDisciplines(Status.PENDING, null, FieldStructure.UUID, structureElement.getUuid().toString());
- ValidateUtil.validateCondition(disciplines != null && disciplines.size() == 0, HttpStatus.BAD_REQUEST, ValidateUtil.DISCIPLINE + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
+ ExceptionUtil.validateConditionDataNotCorrectException(disciplines != null && disciplines.size() == 0, ValidateUtil.DISCIPLINE + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
disciplines = holderRepositories.getDisciplineRepository().readDisciplines(Status.APPROVED, false, FieldStructure.UUID, structureElement.getUuid().toString());
- ValidateUtil.validateCondition(disciplines != null && disciplines.size() == 1, HttpStatus.BAD_REQUEST, ValidateUtil.DISCIPLINE + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
+ ExceptionUtil.validateConditionDataNotCorrectException(disciplines != null && disciplines.size() == 1, ValidateUtil.DISCIPLINE + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
} else if (Type.DEVICEGROUP.equals(structureElement.getType())) {
List<DeviceGroup> deviceGroups = null;
// status, uuid
// status, not deleted, uuid
deviceGroups = holderRepositories.getDeviceGroupRepository().readDeviceGroups(Status.PENDING, null, FieldStructure.UUID, structureElement.getUuid().toString());
- ValidateUtil.validateCondition(deviceGroups != null && deviceGroups.size() == 0, HttpStatus.BAD_REQUEST, ValidateUtil.DEVICEGROUP + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
+ ExceptionUtil.validateConditionDataNotCorrectException(deviceGroups != null && deviceGroups.size() == 0, ValidateUtil.DEVICEGROUP + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
deviceGroups = holderRepositories.getDeviceGroupRepository().readDeviceGroups(Status.APPROVED, false, FieldStructure.UUID, structureElement.getUuid().toString());
- ValidateUtil.validateCondition(deviceGroups != null && deviceGroups.size() == 1, HttpStatus.BAD_REQUEST, ValidateUtil.DEVICEGROUP + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
+ ExceptionUtil.validateConditionDataNotCorrectException(deviceGroups != null && deviceGroups.size() == 1, ValidateUtil.DEVICEGROUP + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
} else if (Type.DEVICETYPE.equals(structureElement.getType())) {
List<DeviceType> deviceTypes = null;
// status, uuid
// status, not deleted, uuid
deviceTypes = holderRepositories.getDeviceTypeRepository().readDeviceTypes(Status.PENDING, null, FieldStructure.UUID, structureElement.getUuid().toString());
- ValidateUtil.validateCondition(deviceTypes != null && deviceTypes.size() == 0, HttpStatus.BAD_REQUEST, ValidateUtil.DEVICETYPE + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
+ ExceptionUtil.validateConditionDataNotCorrectException(deviceTypes != null && deviceTypes.size() == 0, ValidateUtil.DEVICETYPE + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
deviceTypes = holderRepositories.getDeviceTypeRepository().readDeviceTypes(Status.APPROVED, false, FieldStructure.UUID, structureElement.getUuid().toString());
- ValidateUtil.validateCondition(deviceTypes != null && deviceTypes.size() == 1, HttpStatus.BAD_REQUEST, ValidateUtil.DEVICETYPE + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
+ ExceptionUtil.validateConditionDataNotCorrectException(deviceTypes != null && deviceTypes.size() == 1, ValidateUtil.DEVICETYPE + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
}
} else if (StructureChoice.APPROVE.equals(structureChoice) || StructureChoice.CANCEL.equals(structureChoice) || StructureChoice.REJECT.equals(structureChoice)) {
if (Type.SYSTEMGROUP.equals(structureElement.getType())) {
// status, uuid
List<SystemGroup> systemGroups = holderRepositories.getSystemGroupRepository().readSystemGroups(Status.PENDING, null, FieldStructure.UUID, structureElement.getUuid().toString());
- ValidateUtil.validateCondition(systemGroups != null && systemGroups.size() == 1, HttpStatus.BAD_REQUEST, ValidateUtil.SYSTEMGROUP + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
+ ExceptionUtil.validateConditionDataNotCorrectException(systemGroups != null && systemGroups.size() == 1, ValidateUtil.SYSTEMGROUP + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
} else if (Type.SYSTEM.equals(structureElement.getType())) {
// status, uuid
List<System> systems = holderRepositories.getSystemRepository().readSystems(Status.PENDING, null, FieldStructure.UUID, structureElement.getUuid().toString());
- ValidateUtil.validateCondition(systems != null && systems.size() == 1, HttpStatus.BAD_REQUEST, ValidateUtil.SYSTEM + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
+ ExceptionUtil.validateConditionDataNotCorrectException(systems != null && systems.size() == 1, ValidateUtil.SYSTEM + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
} else if (Type.SUBSYSTEM.equals(structureElement.getType())) {
// status, uuid
List<Subsystem> subsystems = holderRepositories.getSubsystemRepository().readSubsystems(Status.PENDING, null, FieldStructure.UUID, structureElement.getUuid().toString());
- ValidateUtil.validateCondition(subsystems != null && subsystems.size() == 1, HttpStatus.BAD_REQUEST, ValidateUtil.SUBSYSTEM + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
+ ExceptionUtil.validateConditionDataNotCorrectException(subsystems != null && subsystems.size() == 1, ValidateUtil.SUBSYSTEM + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
} else if (Type.DISCIPLINE.equals(structureElement.getType())) {
// status, uuid
List<Discipline> disciplines = holderRepositories.getDisciplineRepository().readDisciplines(Status.PENDING, null, FieldStructure.UUID, structureElement.getUuid().toString());
- ValidateUtil.validateCondition(disciplines != null && disciplines.size() == 1, HttpStatus.BAD_REQUEST, ValidateUtil.DISCIPLINE + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
+ ExceptionUtil.validateConditionDataNotCorrectException(disciplines != null && disciplines.size() == 1, ValidateUtil.DISCIPLINE + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
} else if (Type.DEVICEGROUP.equals(structureElement.getType())) {
// status, uuid
List<DeviceGroup> deviceGroups = holderRepositories.getDeviceGroupRepository().readDeviceGroups(Status.PENDING, null, FieldStructure.UUID, structureElement.getUuid().toString());
- ValidateUtil.validateCondition(deviceGroups != null && deviceGroups.size() == 1, HttpStatus.BAD_REQUEST, ValidateUtil.DEVICEGROUP + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
+ ExceptionUtil.validateConditionDataNotCorrectException(deviceGroups != null && deviceGroups.size() == 1, ValidateUtil.DEVICEGROUP + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
} else if (Type.DEVICETYPE.equals(structureElement.getType())) {
// status, uuid
List<DeviceType> deviceTypes = holderRepositories.getDeviceTypeRepository().readDeviceTypes(Status.PENDING, null, FieldStructure.UUID, structureElement.getUuid().toString());
- ValidateUtil.validateCondition(deviceTypes != null && deviceTypes.size() == 1, HttpStatus.BAD_REQUEST, ValidateUtil.DEVICETYPE + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
+ ExceptionUtil.validateConditionDataNotCorrectException(deviceTypes != null && deviceTypes.size() == 1, ValidateUtil.DEVICETYPE + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, structureElement.toString(), "uuid");
}
}
}
@@ -1022,19 +1012,19 @@ public class ValidateUtil {
// status, mnemonic
systemGroups = holderRepositories.getSystemGroupRepository().readSystemGroups(Status.PENDING, false, FieldStructure.MNEMONIC, structureElement.getMnemonic());
- validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, systemGroups == null || systemGroups.isEmpty(), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
- validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, systemGroups == null || systemGroups.isEmpty() || systemGroups.size() == 1 && systemGroups.get(0).getUuid().equals(structureElement.getUuid()), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, systemGroups == null || systemGroups.isEmpty(), message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, systemGroups == null || systemGroups.isEmpty() || systemGroups.size() == 1 && systemGroups.get(0).getUuid().equals(structureElement.getUuid()), message, details, "mnemonic");
systemGroups = holderRepositories.getSystemGroupRepository().readSystemGroups(Status.APPROVED, false, FieldStructure.MNEMONIC, structureElement.getMnemonic());
- validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, systemGroups == null || systemGroups.isEmpty(), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
- validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, systemGroups == null || systemGroups.isEmpty() || systemGroups.size() == 1 && systemGroups.get(0).getUuid().equals(structureElement.getUuid()), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, systemGroups == null || systemGroups.isEmpty(), message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, systemGroups == null || systemGroups.isEmpty() || systemGroups.size() == 1 && systemGroups.get(0).getUuid().equals(structureElement.getUuid()), message, details, "mnemonic");
// status, mnemonic equivalence
systemGroups = holderRepositories.getSystemGroupRepository().readSystemGroups(Status.PENDING, false, FieldStructure.MNEMONICEQUIVALENCE, namingConvention.equivalenceClassRepresentative(structureElement.getMnemonic()));
- validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, systemGroups == null || systemGroups.isEmpty(), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
- validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, systemGroups == null || systemGroups.isEmpty() || systemGroups.size() == 1 && systemGroups.get(0).getUuid().equals(structureElement.getUuid()), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, systemGroups == null || systemGroups.isEmpty(), message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, systemGroups == null || systemGroups.isEmpty() || systemGroups.size() == 1 && systemGroups.get(0).getUuid().equals(structureElement.getUuid()), message, details, "mnemonic");
systemGroups = holderRepositories.getSystemGroupRepository().readSystemGroups(Status.APPROVED, false, FieldStructure.MNEMONICEQUIVALENCE, namingConvention.equivalenceClassRepresentative(structureElement.getMnemonic()));
- validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, systemGroups == null || systemGroups.isEmpty(), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
- validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, systemGroups == null || systemGroups.isEmpty() || systemGroups.size() == 1 && systemGroups.get(0).getUuid().equals(structureElement.getUuid()), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, systemGroups == null || systemGroups.isEmpty(), message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, systemGroups == null || systemGroups.isEmpty() || systemGroups.size() == 1 && systemGroups.get(0).getUuid().equals(structureElement.getUuid()), message, details, "mnemonic");
}
} else if (Type.SYSTEM.equals(structureElement.getType())) {
List<SystemGroup> systemGroups = null;
@@ -1044,24 +1034,24 @@ public class ValidateUtil {
// status, parent
message = ValidateUtil.SYSTEMGROUP + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT;
systemGroups = holderRepositories.getSystemGroupRepository().readSystemGroups(Status.APPROVED, false, FieldStructure.UUID, structureElement.getParent().toString());
- ValidateUtil.validateCondition(systemGroups != null && systemGroups.size() == 1, HttpStatus.BAD_REQUEST, message, details, "parent");
+ ExceptionUtil.validateConditionDataConflictException(systemGroups != null && systemGroups.size() == 1, message, details, "parent");
// status, parent, mnemonic
message = ValidateUtil.SYSTEM + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT;
systems = holderRepositories.getSystemRepository().readSystems(new Status[] {Status.PENDING}, false, new FieldStructure[] {FieldStructure.PARENT, FieldStructure.MNEMONIC}, new String[] {systemGroups.get(0).getUuid().toString(), structureElement.getMnemonic()}, null, null, null, null);
- validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, systems == null || systems.isEmpty(), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
- validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, systems == null || systems.isEmpty() || systems.size() == 1 && systems.get(0).getUuid().equals(structureElement.getUuid()), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, systems == null || systems.isEmpty(), message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, systems == null || systems.isEmpty() || systems.size() == 1 && systems.get(0).getUuid().equals(structureElement.getUuid()), message, details, "mnemonic");
systems = holderRepositories.getSystemRepository().readSystems(new Status[] {Status.APPROVED}, false, new FieldStructure[] {FieldStructure.PARENT, FieldStructure.MNEMONIC}, new String[] {systemGroups.get(0).getUuid().toString(), structureElement.getMnemonic()}, null, null, null, null);
- validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, systems == null || systems.isEmpty(), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
- validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, systems == null || systems.isEmpty() || systems.size() == 1 && systems.get(0).getUuid().equals(structureElement.getUuid()), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, systems == null || systems.isEmpty(), message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, systems == null || systems.isEmpty() || systems.size() == 1 && systems.get(0).getUuid().equals(structureElement.getUuid()), message, details, "mnemonic");
// status, parent, mnemonic equivalence
systems = holderRepositories.getSystemRepository().readSystems(new Status[] {Status.PENDING}, false, new FieldStructure[] {FieldStructure.PARENT, FieldStructure.MNEMONICEQUIVALENCE}, new String[] {systemGroups.get(0).getUuid().toString(), namingConvention.equivalenceClassRepresentative(structureElement.getMnemonic())}, null, null, null, null);
- validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, systems == null || systems.isEmpty(), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
- validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, systems == null || systems.isEmpty() || systems.size() == 1 && systems.get(0).getUuid().equals(structureElement.getUuid()), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, systems == null || systems.isEmpty(), message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, systems == null || systems.isEmpty() || systems.size() == 1 && systems.get(0).getUuid().equals(structureElement.getUuid()), message, details, "mnemonic");
systems = holderRepositories.getSystemRepository().readSystems(new Status[] {Status.APPROVED}, false, new FieldStructure[] {FieldStructure.PARENT, FieldStructure.MNEMONICEQUIVALENCE}, new String[] {systemGroups.get(0).getUuid().toString(), namingConvention.equivalenceClassRepresentative(structureElement.getMnemonic())}, null, null, null, null);
- validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, systems == null || systems.isEmpty(), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
- validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, systems == null || systems.isEmpty() || systems.size() == 1 && systems.get(0).getUuid().equals(structureElement.getUuid()), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, systems == null || systems.isEmpty(), message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, systems == null || systems.isEmpty() || systems.size() == 1 && systems.get(0).getUuid().equals(structureElement.getUuid()), message, details, "mnemonic");
} else if (Type.SUBSYSTEM.equals(structureElement.getType())) {
List<System> systems = null;
List<Subsystem> subsystems = null;
@@ -1070,43 +1060,43 @@ public class ValidateUtil {
// status, parent
message = ValidateUtil.SYSTEM + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT;
systems = holderRepositories.getSystemRepository().readSystems(Status.APPROVED, false, FieldStructure.UUID, structureElement.getParent().toString());
- ValidateUtil.validateCondition(systems != null && systems.size() == 1, HttpStatus.BAD_REQUEST, message, details, "parent");
+ ExceptionUtil.validateConditionDataConflictException(systems != null && systems.size() == 1, message, details, "parent");
// status, parent, mnemonic
message = ValidateUtil.SUBSYSTEM + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT;
subsystems = holderRepositories.getSubsystemRepository().readSubsystems(new Status[] {Status.PENDING}, false, new FieldStructure[] {FieldStructure.PARENT, FieldStructure.MNEMONIC}, new String[] {systems.get(0).getUuid().toString(), structureElement.getMnemonic()}, null, null, null, null);
- validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, subsystems == null || subsystems.isEmpty(), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
- validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, subsystems == null || subsystems.isEmpty() || subsystems.size() == 1 && subsystems.get(0).getUuid().equals(structureElement.getUuid()), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, subsystems == null || subsystems.isEmpty(), message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, subsystems == null || subsystems.isEmpty() || subsystems.size() == 1 && subsystems.get(0).getUuid().equals(structureElement.getUuid()), message, details, "mnemonic");
subsystems = holderRepositories.getSubsystemRepository().readSubsystems(new Status[] {Status.APPROVED}, false, new FieldStructure[] {FieldStructure.PARENT, FieldStructure.MNEMONIC}, new String[] {systems.get(0).getUuid().toString(), structureElement.getMnemonic()}, null, null, null, null);
- validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, subsystems == null || subsystems.isEmpty(), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
- validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, subsystems == null || subsystems.isEmpty() || subsystems.size() == 1 && subsystems.get(0).getUuid().equals(structureElement.getUuid()), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, subsystems == null || subsystems.isEmpty(), message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, subsystems == null || subsystems.isEmpty() || subsystems.size() == 1 && subsystems.get(0).getUuid().equals(structureElement.getUuid()), message, details, "mnemonic");
// status. parent, mnemonic equivalence
subsystems = holderRepositories.getSubsystemRepository().readSubsystems(new Status[] {Status.PENDING}, false, new FieldStructure[] {FieldStructure.PARENT, FieldStructure.MNEMONICEQUIVALENCE}, new String[] {systems.get(0).getUuid().toString(), namingConvention.equivalenceClassRepresentative(structureElement.getMnemonic())}, null, null, null, null);
- validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, subsystems == null || subsystems.isEmpty(), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
- validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, subsystems == null || subsystems.isEmpty() || subsystems.size() == 1 && subsystems.get(0).getUuid().equals(structureElement.getUuid()), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, subsystems == null || subsystems.isEmpty(), message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, subsystems == null || subsystems.isEmpty() || subsystems.size() == 1 && subsystems.get(0).getUuid().equals(structureElement.getUuid()), message, details, "mnemonic");
subsystems = holderRepositories.getSubsystemRepository().readSubsystems(new Status[] {Status.APPROVED}, false, new FieldStructure[] {FieldStructure.PARENT, FieldStructure.MNEMONICEQUIVALENCE}, new String[] {systems.get(0).getUuid().toString(), namingConvention.equivalenceClassRepresentative(structureElement.getMnemonic())}, null, null, null, null);
- validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, subsystems == null || subsystems.isEmpty(), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
- validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, subsystems == null || subsystems.isEmpty() || subsystems.size() == 1 && subsystems.get(0).getUuid().equals(structureElement.getUuid()), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, subsystems == null || subsystems.isEmpty(), message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, subsystems == null || subsystems.isEmpty() || subsystems.size() == 1 && subsystems.get(0).getUuid().equals(structureElement.getUuid()), message, details, "mnemonic");
} else if (Type.DISCIPLINE.equals(structureElement.getType())) {
List<Discipline> disciplines = null;
String message = ValidateUtil.DISCIPLINE + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT;
// status, mnemonic
disciplines = holderRepositories.getDisciplineRepository().readDisciplines(Status.PENDING, false, FieldStructure.MNEMONIC, structureElement.getMnemonic());
- validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, disciplines == null || disciplines.isEmpty(), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
- validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, disciplines == null || disciplines.isEmpty() || disciplines.size() == 1 && disciplines.get(0).getUuid().equals(structureElement.getUuid()), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, disciplines == null || disciplines.isEmpty(), message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, disciplines == null || disciplines.isEmpty() || disciplines.size() == 1 && disciplines.get(0).getUuid().equals(structureElement.getUuid()), message, details, "mnemonic");
disciplines = holderRepositories.getDisciplineRepository().readDisciplines(Status.APPROVED, false, FieldStructure.MNEMONIC, structureElement.getMnemonic());
- validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, disciplines == null || disciplines.isEmpty(), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
- validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, disciplines == null || disciplines.isEmpty() || disciplines.size() == 1 && disciplines.get(0).getUuid().equals(structureElement.getUuid()), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, disciplines == null || disciplines.isEmpty(), message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, disciplines == null || disciplines.isEmpty() || disciplines.size() == 1 && disciplines.get(0).getUuid().equals(structureElement.getUuid()), message, details, "mnemonic");
// status, mnemonic equivalence
disciplines = holderRepositories.getDisciplineRepository().readDisciplines(Status.PENDING, false, FieldStructure.MNEMONICEQUIVALENCE, namingConvention.equivalenceClassRepresentative(structureElement.getMnemonic()));
- validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, disciplines == null || disciplines.isEmpty(), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
- validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, disciplines == null || disciplines.isEmpty() || disciplines.size() == 1 && disciplines.get(0).getUuid().equals(structureElement.getUuid()), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, disciplines == null || disciplines.isEmpty(), message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, disciplines == null || disciplines.isEmpty() || disciplines.size() == 1 && disciplines.get(0).getUuid().equals(structureElement.getUuid()), message, details, "mnemonic");
disciplines = holderRepositories.getDisciplineRepository().readDisciplines(Status.APPROVED, false, FieldStructure.MNEMONICEQUIVALENCE, namingConvention.equivalenceClassRepresentative(structureElement.getMnemonic()));
- validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, disciplines == null || disciplines.isEmpty(), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
- validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, disciplines == null || disciplines.isEmpty() || disciplines.size() == 1 && disciplines.get(0).getUuid().equals(structureElement.getUuid()), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, disciplines == null || disciplines.isEmpty(), message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, disciplines == null || disciplines.isEmpty() || disciplines.size() == 1 && disciplines.get(0).getUuid().equals(structureElement.getUuid()), message, details, "mnemonic");
} else if (Type.DEVICEGROUP.equals(structureElement.getType())) {
List<Discipline> disciplines = null;
String message = null;
@@ -1114,13 +1104,13 @@ public class ValidateUtil {
// status, parent
message = ValidateUtil.DISCIPLINE + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT;
disciplines = holderRepositories.getDisciplineRepository().readDisciplines(Status.APPROVED, false, FieldStructure.UUID, structureElement.getParent().toString());
- ValidateUtil.validateCondition(disciplines != null && disciplines.size() == 1, HttpStatus.BAD_REQUEST, message, details, "parent");
+ ExceptionUtil.validateConditionDataConflictException(disciplines != null && disciplines.size() == 1, message, details, "parent");
// note rules for mnemonic for device group
// mnemonic
message = ValidateUtil.DEVICEGROUP + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT;
- ValidateUtil.validateCondition(StringUtils.isEmpty(structureElement.getMnemonic()), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
+ ExceptionUtil.validateConditionDataConflictException(StringUtils.isEmpty(structureElement.getMnemonic()), message, details, "mnemonic");
} else if (Type.DEVICETYPE.equals(structureElement.getType())) {
List<DeviceGroup> deviceGroups = null;
List<DeviceType> deviceTypes = null;
@@ -1129,24 +1119,24 @@ public class ValidateUtil {
// status, parent
message = ValidateUtil.DEVICEGROUP + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT;
deviceGroups = holderRepositories.getDeviceGroupRepository().readDeviceGroups(Status.APPROVED, false, FieldStructure.UUID, structureElement.getParent().toString());
- ValidateUtil.validateCondition(deviceGroups != null && deviceGroups.size() == 1, HttpStatus.BAD_REQUEST, message, details, "parent");
+ ExceptionUtil.validateConditionDataConflictException(deviceGroups != null && deviceGroups.size() == 1, message, details, "parent");
// status, parent, mnemonic
message = ValidateUtil.DEVICETYPE + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT;
deviceTypes = holderRepositories.getDeviceTypeRepository().readDeviceTypes(new Status[] {Status.PENDING}, false, new FieldStructure[] {FieldStructure.PARENT, FieldStructure.MNEMONIC}, new String[] {deviceGroups.get(0).getUuid().toString(), structureElement.getMnemonic()}, null, null, null, null);
- validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, deviceTypes == null || deviceTypes.isEmpty(), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
- validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, deviceTypes == null || deviceTypes.isEmpty() || deviceTypes.size() == 1 && deviceTypes.get(0).getUuid().equals(structureElement.getUuid()), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, deviceTypes == null || deviceTypes.isEmpty(), message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, deviceTypes == null || deviceTypes.isEmpty() || deviceTypes.size() == 1 && deviceTypes.get(0).getUuid().equals(structureElement.getUuid()), message, details, "mnemonic");
deviceTypes = holderRepositories.getDeviceTypeRepository().readDeviceTypes(new Status[] {Status.APPROVED}, false, new FieldStructure[] {FieldStructure.PARENT, FieldStructure.MNEMONIC}, new String[] {deviceGroups.get(0).getUuid().toString(), structureElement.getMnemonic()}, null, null, null, null);
- validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, deviceTypes == null || deviceTypes.isEmpty(), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
- validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, deviceTypes == null || deviceTypes.isEmpty() || deviceTypes.size() == 1 && deviceTypes.get(0).getUuid().equals(structureElement.getUuid()), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, deviceTypes == null || deviceTypes.isEmpty(), message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, deviceTypes == null || deviceTypes.isEmpty() || deviceTypes.size() == 1 && deviceTypes.get(0).getUuid().equals(structureElement.getUuid()), message, details, "mnemonic");
// status, parent, mnemonic equivalence
deviceTypes = holderRepositories.getDeviceTypeRepository().readDeviceTypes(new Status[] {Status.PENDING}, false, new FieldStructure[] {FieldStructure.PARENT, FieldStructure.MNEMONICEQUIVALENCE}, new String[] {deviceGroups.get(0).getUuid().toString(), namingConvention.equivalenceClassRepresentative(structureElement.getMnemonic())}, null, null, null, null);
- validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, deviceTypes == null || deviceTypes.isEmpty(), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
- validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, deviceTypes == null || deviceTypes.isEmpty() || deviceTypes.size() == 1 && deviceTypes.get(0).getUuid().equals(structureElement.getUuid()), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, deviceTypes == null || deviceTypes.isEmpty(), message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, deviceTypes == null || deviceTypes.isEmpty() || deviceTypes.size() == 1 && deviceTypes.get(0).getUuid().equals(structureElement.getUuid()), message, details, "mnemonic");
deviceTypes = holderRepositories.getDeviceTypeRepository().readDeviceTypes(new Status[] {Status.APPROVED}, false, new FieldStructure[] {FieldStructure.PARENT, FieldStructure.MNEMONICEQUIVALENCE}, new String[] {deviceGroups.get(0).getUuid().toString(), namingConvention.equivalenceClassRepresentative(structureElement.getMnemonic())}, null, null, null, null);
- validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, deviceTypes == null || deviceTypes.isEmpty(), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
- validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, deviceTypes == null || deviceTypes.isEmpty() || deviceTypes.size() == 1 && deviceTypes.get(0).getUuid().equals(structureElement.getUuid()), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, deviceTypes == null || deviceTypes.isEmpty(), message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, deviceTypes == null || deviceTypes.isEmpty() || deviceTypes.size() == 1 && deviceTypes.get(0).getUuid().equals(structureElement.getUuid()), message, details, "mnemonic");
}
} else if (StructureChoice.APPROVE.equals(structureChoice)) {
if (Type.SYSTEMGROUP.equals(structureElement.getType())) {
@@ -1156,17 +1146,17 @@ public class ValidateUtil {
// to be approved - status, uuid
toBeApproved = holderRepositories.getSystemGroupRepository().readSystemGroups(Status.PENDING, null, FieldStructure.UUID, structureElement.getUuid().toString());
- ValidateUtil.validateCondition(toBeApproved != null && toBeApproved.size() == 1, HttpStatus.BAD_REQUEST, message, details, "uuid");
+ ExceptionUtil.validateConditionDataConflictException(toBeApproved != null && toBeApproved.size() == 1, message, details, "uuid");
// status, mnemonic
systemGroups = holderRepositories.getSystemGroupRepository().readSystemGroups(Status.APPROVED, false, FieldStructure.MNEMONIC, toBeApproved.get(0).getMnemonic());
- validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, systemGroups == null || systemGroups.isEmpty(), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
- validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, systemGroups == null || systemGroups.isEmpty() || systemGroups.size() == 1 && systemGroups.get(0).getUuid().equals(toBeApproved.get(0).getUuid()), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, systemGroups == null || systemGroups.isEmpty(), message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, systemGroups == null || systemGroups.isEmpty() || systemGroups.size() == 1 && systemGroups.get(0).getUuid().equals(toBeApproved.get(0).getUuid()), message, details, "mnemonic");
// status, mnemonic equivalence
systemGroups = holderRepositories.getSystemGroupRepository().readSystemGroups(Status.APPROVED, false, FieldStructure.MNEMONICEQUIVALENCE, toBeApproved.get(0).getMnemonicEquivalence());
- validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, systemGroups == null || systemGroups.isEmpty(), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
- validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, systemGroups == null || systemGroups.isEmpty() || systemGroups.size() == 1 && systemGroups.get(0).getUuid().equals(toBeApproved.get(0).getUuid()), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, systemGroups == null || systemGroups.isEmpty(), message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, systemGroups == null || systemGroups.isEmpty() || systemGroups.size() == 1 && systemGroups.get(0).getUuid().equals(toBeApproved.get(0).getUuid()), message, details, "mnemonic");
} else if (Type.SYSTEM.equals(structureElement.getType())) {
List<SystemGroup> systemGroups = null;
List<System> toBeApproved = null;
@@ -1176,23 +1166,23 @@ public class ValidateUtil {
// to be approved - status, uuid
message = ValidateUtil.SYSTEM + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT;
toBeApproved = holderRepositories.getSystemRepository().readSystems(Status.PENDING, null, FieldStructure.UUID, structureElement.getUuid().toString());
- ValidateUtil.validateCondition(toBeApproved != null && toBeApproved.size() == 1, HttpStatus.BAD_REQUEST, message, details, "uuid");
+ ExceptionUtil.validateConditionDataConflictException(toBeApproved != null && toBeApproved.size() == 1, message, details, "uuid");
// status, parent
message = ValidateUtil.SYSTEMGROUP + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT;
systemGroups = holderRepositories.getSystemGroupRepository().readSystemGroups(Status.APPROVED, false, FieldStructure.UUID, toBeApproved.get(0).getParentUuid().toString());
- ValidateUtil.validateCondition(systemGroups != null && systemGroups.size() == 1, HttpStatus.BAD_REQUEST, message, details, "parent");
+ ExceptionUtil.validateConditionDataConflictException(systemGroups != null && systemGroups.size() == 1, message, details, "parent");
// status, mnemonic
message = ValidateUtil.SYSTEM + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT;
systems = holderRepositories.getSystemRepository().readSystems(Status.APPROVED, false, FieldStructure.MNEMONIC, toBeApproved.get(0).getMnemonic());
- validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, systems == null || systems.isEmpty(), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
- validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, systems == null || systems.isEmpty() || systems.size() == 1 && systems.get(0).getUuid().equals(toBeApproved.get(0).getUuid()), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, systems == null || systems.isEmpty(), message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, systems == null || systems.isEmpty() || systems.size() == 1 && systems.get(0).getUuid().equals(toBeApproved.get(0).getUuid()), message, details, "mnemonic");
// status, mnemonic equivalence
systems = holderRepositories.getSystemRepository().readSystems(Status.APPROVED, false, FieldStructure.MNEMONICEQUIVALENCE, toBeApproved.get(0).getMnemonicEquivalence());
- validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, systems == null || systems.isEmpty(), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
- validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, systems == null || systems.isEmpty() || systems.size() == 1 && systems.get(0).getUuid().equals(toBeApproved.get(0).getUuid()), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, systems == null || systems.isEmpty(), message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, systems == null || systems.isEmpty() || systems.size() == 1 && systems.get(0).getUuid().equals(toBeApproved.get(0).getUuid()), message, details, "mnemonic");
} else if (Type.SUBSYSTEM.equals(structureElement.getType())) {
List<System> systems = null;
List<Subsystem> toBeApproved = null;
@@ -1202,23 +1192,23 @@ public class ValidateUtil {
// to be approved - status, uuid
message = ValidateUtil.SUBSYSTEM + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT;
toBeApproved = holderRepositories.getSubsystemRepository().readSubsystems(Status.PENDING, null, FieldStructure.UUID, structureElement.getUuid().toString());
- ValidateUtil.validateCondition(toBeApproved != null && toBeApproved.size() == 1, HttpStatus.BAD_REQUEST, message, details, "uuid");
+ ExceptionUtil.validateConditionDataConflictException(toBeApproved != null && toBeApproved.size() == 1, message, details, "uuid");
// status, parent
message = ValidateUtil.SYSTEM + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT;
systems = holderRepositories.getSystemRepository().readSystems(Status.APPROVED, false, FieldStructure.UUID, toBeApproved.get(0).getParentUuid().toString());
- ValidateUtil.validateCondition(systems != null && systems.size() == 1, HttpStatus.BAD_REQUEST, message, details, "parent");
+ ExceptionUtil.validateConditionDataConflictException(systems != null && systems.size() == 1, message, details, "parent");
// status, mnemonic
message = ValidateUtil.SUBSYSTEM + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT;
subsystems = holderRepositories.getSubsystemRepository().readSubsystems(Status.APPROVED, false, FieldStructure.MNEMONIC, toBeApproved.get(0).getMnemonic());
- validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, subsystems == null || subsystems.isEmpty(), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
- validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, subsystems == null || subsystems.isEmpty() || subsystems.size() == 1 && subsystems.get(0).getUuid().equals(toBeApproved.get(0).getUuid()), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, subsystems == null || subsystems.isEmpty(), message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, subsystems == null || subsystems.isEmpty() || subsystems.size() == 1 && subsystems.get(0).getUuid().equals(toBeApproved.get(0).getUuid()), message, details, "mnemonic");
// status, mnemonic equivalence
subsystems = holderRepositories.getSubsystemRepository().readSubsystems(Status.APPROVED, false, FieldStructure.MNEMONICEQUIVALENCE, toBeApproved.get(0).getMnemonicEquivalence());
- validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, subsystems == null || subsystems.isEmpty(), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
- validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, subsystems == null || subsystems.isEmpty() || subsystems.size() == 1 && subsystems.get(0).getUuid().equals(toBeApproved.get(0).getUuid()), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, subsystems == null || subsystems.isEmpty(), message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, subsystems == null || subsystems.isEmpty() || subsystems.size() == 1 && subsystems.get(0).getUuid().equals(toBeApproved.get(0).getUuid()), message, details, "mnemonic");
} else if (Type.DISCIPLINE.equals(structureElement.getType())) {
List<Discipline> toBeApproved = null;
List<Discipline> disciplines = null;
@@ -1226,17 +1216,17 @@ public class ValidateUtil {
// to be approved - status, uuid
toBeApproved = holderRepositories.getDisciplineRepository().readDisciplines(Status.PENDING, null, FieldStructure.UUID, structureElement.getUuid().toString());
- ValidateUtil.validateCondition(toBeApproved != null && toBeApproved.size() == 1, HttpStatus.BAD_REQUEST, message, details, "uuid");
+ ExceptionUtil.validateConditionDataConflictException(toBeApproved != null && toBeApproved.size() == 1, message, details, "uuid");
// status, mnemonic
disciplines = holderRepositories.getDisciplineRepository().readDisciplines(Status.APPROVED, false, FieldStructure.MNEMONIC, toBeApproved.get(0).getMnemonic());
- validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, disciplines == null || disciplines.isEmpty(), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
- validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, disciplines == null || disciplines.isEmpty() || disciplines.size() == 1 && disciplines.get(0).getUuid().equals(toBeApproved.get(0).getUuid()), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, disciplines == null || disciplines.isEmpty(), message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, disciplines == null || disciplines.isEmpty() || disciplines.size() == 1 && disciplines.get(0).getUuid().equals(toBeApproved.get(0).getUuid()), message, details, "mnemonic");
// status, mnemonic equivalence
disciplines = holderRepositories.getDisciplineRepository().readDisciplines(Status.APPROVED, false, FieldStructure.MNEMONICEQUIVALENCE, toBeApproved.get(0).getMnemonicEquivalence());
- validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, disciplines == null || disciplines.isEmpty(), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
- validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, disciplines == null || disciplines.isEmpty() || disciplines.size() == 1 && disciplines.get(0).getUuid().equals(toBeApproved.get(0).getUuid()), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, disciplines == null || disciplines.isEmpty(), message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, disciplines == null || disciplines.isEmpty() || disciplines.size() == 1 && disciplines.get(0).getUuid().equals(toBeApproved.get(0).getUuid()), message, details, "mnemonic");
} else if (Type.DEVICEGROUP.equals(structureElement.getType())) {
List<Discipline> disciplines = null;
List<DeviceGroup> toBeApproved = null;
@@ -1245,18 +1235,18 @@ public class ValidateUtil {
// to be approved - status, uuid
message = ValidateUtil.DEVICEGROUP + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT;
toBeApproved = holderRepositories.getDeviceGroupRepository().readDeviceGroups(Status.PENDING, null, FieldStructure.UUID, structureElement.getUuid().toString());
- ValidateUtil.validateCondition(toBeApproved != null && toBeApproved.size() == 1, HttpStatus.BAD_REQUEST, message, details, "uuid");
+ ExceptionUtil.validateConditionDataConflictException(toBeApproved != null && toBeApproved.size() == 1, message, details, "uuid");
// status, parent
message = ValidateUtil.DISCIPLINE + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT;
disciplines = holderRepositories.getDisciplineRepository().readDisciplines(Status.APPROVED, false, FieldStructure.UUID, toBeApproved.get(0).getParentUuid().toString());
- ValidateUtil.validateCondition(disciplines != null && disciplines.size() == 1, HttpStatus.BAD_REQUEST, message, details, "parent");
+ ExceptionUtil.validateConditionDataConflictException(disciplines != null && disciplines.size() == 1, message, details, "parent");
// note rules for mnemonic for device group
// mnemonic
message = ValidateUtil.DEVICEGROUP + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT;
- ValidateUtil.validateCondition(StringUtils.isEmpty(structureElement.getMnemonic()), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
+ ExceptionUtil.validateConditionDataConflictException(StringUtils.isEmpty(structureElement.getMnemonic()), message, details, "mnemonic");
} else if (Type.DEVICETYPE.equals(structureElement.getType())) {
List<DeviceGroup> deviceGroups = null;
List<DeviceType> toBeApproved = null;
@@ -1266,23 +1256,23 @@ public class ValidateUtil {
// to be approved - status, uuid
message = ValidateUtil.DEVICETYPE + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT;
toBeApproved = holderRepositories.getDeviceTypeRepository().readDeviceTypes(Status.PENDING, null, FieldStructure.UUID, structureElement.getUuid().toString());
- ValidateUtil.validateCondition(toBeApproved != null && toBeApproved.size() == 1, HttpStatus.BAD_REQUEST, message, details, "uuid");
+ ExceptionUtil.validateConditionDataConflictException(toBeApproved != null && toBeApproved.size() == 1, message, details, "uuid");
// status, parent
message = ValidateUtil.DEVICEGROUP + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT;
deviceGroups = holderRepositories.getDeviceGroupRepository().readDeviceGroups(Status.APPROVED, false, FieldStructure.UUID, toBeApproved.get(0).getParentUuid().toString());
- ValidateUtil.validateCondition(deviceGroups != null && deviceGroups.size() == 1, HttpStatus.BAD_REQUEST, message, details, "parent");
+ ExceptionUtil.validateConditionDataConflictException(deviceGroups != null && deviceGroups.size() == 1, message, details, "parent");
// status, mnemonic
message = ValidateUtil.DEVICETYPE + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT;
deviceTypes = holderRepositories.getDeviceTypeRepository().readDeviceTypes(Status.APPROVED, false, FieldStructure.MNEMONIC, toBeApproved.get(0).getMnemonic());
- validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, deviceTypes == null || deviceTypes.isEmpty(), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
- validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, deviceTypes == null || deviceTypes.isEmpty() || deviceTypes.size() == 1 && deviceTypes.get(0).getUuid().equals(toBeApproved.get(0).getUuid()), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, deviceTypes == null || deviceTypes.isEmpty(), message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, deviceTypes == null || deviceTypes.isEmpty() || deviceTypes.size() == 1 && deviceTypes.get(0).getUuid().equals(toBeApproved.get(0).getUuid()), message, details, "mnemonic");
// status, mnemonic equivalence
deviceTypes = holderRepositories.getDeviceTypeRepository().readDeviceTypes(Status.APPROVED, false, FieldStructure.MNEMONICEQUIVALENCE, toBeApproved.get(0).getMnemonicEquivalence());
- validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, deviceTypes == null || deviceTypes.isEmpty(), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
- validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, deviceTypes == null || deviceTypes.isEmpty() || deviceTypes.size() == 1 && deviceTypes.get(0).getUuid().equals(toBeApproved.get(0).getUuid()), HttpStatus.BAD_REQUEST, message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, deviceTypes == null || deviceTypes.isEmpty(), message, details, "mnemonic");
+ validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, deviceTypes == null || deviceTypes.isEmpty() || deviceTypes.size() == 1 && deviceTypes.get(0).getUuid().equals(toBeApproved.get(0).getUuid()), message, details, "mnemonic");
}
}
}
@@ -1305,26 +1295,26 @@ public class ValidateUtil {
}
String[] path = NamingConventionUtil.string2MnemonicPath(mnemonicpath);
- validateCondition(path != null && path.length >= 1 && path.length <= 2,
- HttpStatus.BAD_REQUEST, ValidateUtil.STRUCTURE + " mnemonic path " + ValidateUtil.IS_NOT_VALID, path + ", " + mnemonicpath, null);
+ ExceptionUtil.validateConditionDataNotValidException(path != null && path.length >= 1 && path.length <= 2,
+ ValidateUtil.STRUCTURE + " mnemonic path " + ValidateUtil.IS_NOT_VALID, path + ", " + mnemonicpath, null);
String mnemonicpathEquivalence = namingConvention.equivalenceClassRepresentative(mnemonicpath);
if (Type.SYSTEMGROUP.equals(type)) {
- validateCondition(path.length == 1, HttpStatus.BAD_REQUEST, ValidateUtil.SYSTEMGROUP + " mnemonic path " + ValidateUtil.IS_NOT_VALID, path.length + ", " + mnemonicpath, null);
+ ExceptionUtil.validateConditionDataNotValidException(path.length == 1, ValidateUtil.SYSTEMGROUP + " mnemonic path " + ValidateUtil.IS_NOT_VALID, path.length + ", " + mnemonicpath, null);
// system group may have empty path but there will be mnemonicpath in this context
// mnemonic
SystemGroup sg = holderIRepositories.getSystemGroupRepository().findLatestNotDeletedByMnemonic(path[0]);
- ValidateUtil.validateCondition(sg == null, HttpStatus.BAD_REQUEST, ValidateUtil.SYSTEMGROUP + " mnemonic path duplicate", path[0] + ", " + mnemonicpath, null);
+ ExceptionUtil.validateConditionDataConflictException(sg == null, ValidateUtil.SYSTEMGROUP + " mnemonic path duplicate", path[0] + ", " + mnemonicpath, null);
// mnemonic equivalence
List<SystemGroup> systemGroups = holderIRepositories.getSystemGroupRepository().findLatestNotDeleted();
for (SystemGroup systemGroup : systemGroups) {
- validateCondition(!StringUtils.equals(systemGroup.getMnemonicEquivalence(), namingConvention.equivalenceClassRepresentative(path[0])), HttpStatus.BAD_REQUEST, ValidateUtil.SYSTEMGROUP + " mnemonic path equivalence duplicate", path[0] + ", " + mnemonicpath, null);
+ ExceptionUtil.validateConditionDataConflictException(!StringUtils.equals(systemGroup.getMnemonicEquivalence(), namingConvention.equivalenceClassRepresentative(path[0])), ValidateUtil.SYSTEMGROUP + " mnemonic path equivalence duplicate", path[0] + ", " + mnemonicpath, null);
}
} else if (Type.SYSTEM.equals(type)) {
- validateCondition(path.length == 1, HttpStatus.BAD_REQUEST, ValidateUtil.SYSTEM + " mnemonic path " + ValidateUtil.IS_NOT_VALID, path.length + ", " + mnemonicpath, null);
+ ExceptionUtil.validateConditionDataNotValidException(path.length == 1, ValidateUtil.SYSTEM + " mnemonic path " + ValidateUtil.IS_NOT_VALID, path.length + ", " + mnemonicpath, null);
// path with 1 element - system group or system ---> check both individually
// check mnemonic, mnemonic equivalence
@@ -1332,90 +1322,90 @@ public class ValidateUtil {
// mnemonic system group
List<String> mnemonicPaths = StructureUtil.getMnemonicPathsSystemGroup(holder, false, namingConvention);
for (String existingPath : mnemonicPaths) {
- validateCondition(!StringUtils.equals(mnemonicpath, existingPath), HttpStatus.BAD_REQUEST, ValidateUtil.SYSTEM + " mnemonic path duplicate", mnemonicpath, null);
+ ExceptionUtil.validateConditionDataConflictException(!StringUtils.equals(mnemonicpath, existingPath), ValidateUtil.SYSTEM + " mnemonic path duplicate", mnemonicpath, null);
}
// mnemonic path system group
mnemonicPaths = StructureUtil.getMnemonicPathsSystemGroup(holder, true, namingConvention);
for (String existingPath : mnemonicPaths) {
- validateCondition(!StringUtils.equals(mnemonicpathEquivalence, namingConvention.equivalenceClassRepresentative(existingPath)), HttpStatus.BAD_REQUEST, ValidateUtil.SYSTEM + " mnemonic path equivalence duplicate", mnemonicpath, null);
+ ExceptionUtil.validateConditionDataConflictException(!StringUtils.equals(mnemonicpathEquivalence, namingConvention.equivalenceClassRepresentative(existingPath)), ValidateUtil.SYSTEM + " mnemonic path equivalence duplicate", mnemonicpath, null);
}
// mnemonic
mnemonicPaths = StructureUtil.getMnemonicPathsSystem(holder, false, namingConvention);
for (String existingPath : mnemonicPaths) {
- validateCondition(!StringUtils.equals(mnemonicpath, existingPath), HttpStatus.BAD_REQUEST, ValidateUtil.SYSTEM + " mnemonic path duplicate", mnemonicpath, null);
+ ExceptionUtil.validateConditionDataConflictException(!StringUtils.equals(mnemonicpath, existingPath), ValidateUtil.SYSTEM + " mnemonic path duplicate", mnemonicpath, null);
}
// mnemonic equivalence
mnemonicPaths = StructureUtil.getMnemonicPathsSystem(holder, true, namingConvention);
for (String existingPath : mnemonicPaths) {
- validateCondition(!StringUtils.equals(mnemonicpathEquivalence, namingConvention.equivalenceClassRepresentative(existingPath)), HttpStatus.BAD_REQUEST, ValidateUtil.SYSTEM + " mnemonic path equivalence duplicate", mnemonicpath, null);
+ ExceptionUtil.validateConditionDataConflictException(!StringUtils.equals(mnemonicpathEquivalence, namingConvention.equivalenceClassRepresentative(existingPath)), ValidateUtil.SYSTEM + " mnemonic path equivalence duplicate", mnemonicpath, null);
}
} else if (Type.SUBSYSTEM.equals(type)) {
- validateCondition(path.length == 2, HttpStatus.BAD_REQUEST, ValidateUtil.SUBSYSTEM + " mnemonic path " + ValidateUtil.IS_NOT_VALID, path.length + ", " + mnemonicpath, null);
+ ExceptionUtil.validateConditionDataNotValidException(path.length == 2, ValidateUtil.SUBSYSTEM + " mnemonic path " + ValidateUtil.IS_NOT_VALID, path.length + ", " + mnemonicpath, null);
System sys = holderIRepositories.getSystemRepository().findLatestNotDeletedByMnemonic(path[0]);
- ValidateUtil.validateCondition(sys != null, HttpStatus.BAD_REQUEST, ValidateUtil.SUBSYSTEM + " mnemonic path not available", path[0] + ", " + mnemonicpath, null);
+ ExceptionUtil.validateConditionDataNotAvailableException(sys != null, ValidateUtil.SUBSYSTEM + " mnemonic path not available", path[0] + ", " + mnemonicpath, null);
SystemGroup sg = holderIRepositories.getSystemGroupRepository().findLatestNotDeletedByUuid(sys.getParentUuid().toString());
// mnemonic
- validateCondition(!StringUtils.equals(path[0], path[1]), HttpStatus.BAD_REQUEST, ValidateUtil.SUBSYSTEM + " mnemonic path duplicate", mnemonicpath, null);
+ ExceptionUtil.validateConditionDataConflictException(!StringUtils.equals(path[0], path[1]), ValidateUtil.SUBSYSTEM + " mnemonic path duplicate", mnemonicpath, null);
if (!StringUtils.isEmpty(sg.getMnemonic())) {
- validateCondition(!StringUtils.equals(sg.getMnemonic(), path[1]), HttpStatus.BAD_REQUEST, ValidateUtil.SUBSYSTEM + " mnemonic path duplicate", mnemonicpath, null);
+ ExceptionUtil.validateConditionDataConflictException(!StringUtils.equals(sg.getMnemonic(), path[1]), ValidateUtil.SUBSYSTEM + " mnemonic path duplicate", mnemonicpath, null);
}
List<String> mnemonicPaths = StructureUtil.getMnemonicPathsSubsystem(holder, false, namingConvention);
for (String existingPath : mnemonicPaths) {
- validateCondition(!StringUtils.equals(mnemonicpath, existingPath), HttpStatus.BAD_REQUEST, ValidateUtil.SUBSYSTEM + " mnemonic path duplicate", mnemonicpath, null);
+ ExceptionUtil.validateConditionDataConflictException(!StringUtils.equals(mnemonicpath, existingPath), ValidateUtil.SUBSYSTEM + " mnemonic path duplicate", mnemonicpath, null);
}
// mnemonic equivalence
- validateCondition(!StringUtils.equals(namingConvention.equivalenceClassRepresentative(path[0]), namingConvention.equivalenceClassRepresentative(path[1])), HttpStatus.BAD_REQUEST, ValidateUtil.SYSTEM + " mnemonic path duplicate", mnemonicpath, null);
+ ExceptionUtil.validateConditionDataConflictException(!StringUtils.equals(namingConvention.equivalenceClassRepresentative(path[0]), namingConvention.equivalenceClassRepresentative(path[1])), ValidateUtil.SYSTEM + " mnemonic path duplicate", mnemonicpath, null);
if (!StringUtils.isEmpty(sg.getMnemonic())) {
- validateCondition(!StringUtils.equals(namingConvention.equivalenceClassRepresentative(sg.getMnemonic()), namingConvention.equivalenceClassRepresentative(path[1])), HttpStatus.BAD_REQUEST, ValidateUtil.SUBSYSTEM + " mnemonic path duplicate", mnemonicpath, null);
+ ExceptionUtil.validateConditionDataConflictException(!StringUtils.equals(namingConvention.equivalenceClassRepresentative(sg.getMnemonic()), namingConvention.equivalenceClassRepresentative(path[1])), ValidateUtil.SUBSYSTEM + " mnemonic path duplicate", mnemonicpath, null);
}
mnemonicPaths = StructureUtil.getMnemonicPathsSubsystem(holder, true, namingConvention);
for (String existingPath : mnemonicPaths) {
- validateCondition(!StringUtils.equals(mnemonicpathEquivalence, namingConvention.equivalenceClassRepresentative(existingPath)), HttpStatus.BAD_REQUEST, ValidateUtil.SUBSYSTEM + " mnemonic path equivalence duplicate", mnemonicpath, null);
+ ExceptionUtil.validateConditionDataConflictException(!StringUtils.equals(mnemonicpathEquivalence, namingConvention.equivalenceClassRepresentative(existingPath)), ValidateUtil.SUBSYSTEM + " mnemonic path equivalence duplicate", mnemonicpath, null);
}
} else if (Type.DISCIPLINE.equals(type)) {
- validateCondition(path.length == 1, HttpStatus.BAD_REQUEST, ValidateUtil.DISCIPLINE + " mnemonic path " + ValidateUtil.IS_NOT_VALID, path[0] + ", " + mnemonicpath, null);
+ ExceptionUtil.validateConditionDataNotValidException(path.length == 1, ValidateUtil.DISCIPLINE + " mnemonic path " + ValidateUtil.IS_NOT_VALID, path[0] + ", " + mnemonicpath, null);
// mnemonic
Discipline di = holderIRepositories.getDisciplineRepository().findLatestNotDeletedByMnemonic(path[0]);
- ValidateUtil.validateCondition(di == null, HttpStatus.BAD_REQUEST, ValidateUtil.DISCIPLINE + " mnemonic path duplicate", path[0] + ", " + mnemonicpath, null);
+ ExceptionUtil.validateConditionDataConflictException(di == null, ValidateUtil.DISCIPLINE + " mnemonic path duplicate", path[0] + ", " + mnemonicpath, null);
// mnemonic equivalence
List<Discipline> disciplines = holderIRepositories.getDisciplineRepository().findLatestNotDeleted();
for (Discipline discipline : disciplines) {
- validateCondition(!StringUtils.equals(discipline.getMnemonicEquivalence(), namingConvention.equivalenceClassRepresentative(path[0])),
- HttpStatus.BAD_REQUEST, ValidateUtil.DISCIPLINE + " mnemonic path equivalence duplicate", path[0] + ", " + mnemonicpath, null);
+ ExceptionUtil.validateConditionDataConflictException(!StringUtils.equals(discipline.getMnemonicEquivalence(), namingConvention.equivalenceClassRepresentative(path[0])),
+ ValidateUtil.DISCIPLINE + " mnemonic path equivalence duplicate", path[0] + ", " + mnemonicpath, null);
}
} else if (Type.DEVICEGROUP.equals(type)) {
- throw ExceptionUtil.createServiceHttpStatusExceptionBadRequest(ValidateUtil.DEVICEGROUP + " mnemonic path " + ValidateUtil.IS_NOT_VALID, path.length + ", " + mnemonicpath, null);
+ throw ExceptionUtil.createDataNotValidException(ValidateUtil.DEVICEGROUP + " mnemonic path " + ValidateUtil.IS_NOT_VALID, path.length + ", " + mnemonicpath, null);
} else if (Type.DEVICETYPE.equals(type)) {
- validateCondition(path.length == 2, HttpStatus.BAD_REQUEST, ValidateUtil.STRUCTURE + " " + ValidateUtil.DEVICETYPE + " mnemonic path " + ValidateUtil.IS_NOT_VALID, path.length + ", " + mnemonicpath, null);
+ ExceptionUtil.validateConditionDataNotValidException(path.length == 2, ValidateUtil.STRUCTURE + " " + ValidateUtil.DEVICETYPE + " mnemonic path " + ValidateUtil.IS_NOT_VALID, path.length + ", " + mnemonicpath, null);
// discipline
Discipline discipline = holderIRepositories.getDisciplineRepository().findLatestNotDeletedByMnemonic(path[0]);
- ValidateUtil.validateCondition(discipline != null, HttpStatus.BAD_REQUEST, ValidateUtil.DISCIPLINE + " " + ValidateUtil.IS_NOT_VALID, path[0] + ", " + mnemonicpath, null);
+ ExceptionUtil.validateConditionDataNotValidException(discipline != null, ValidateUtil.DISCIPLINE + " " + ValidateUtil.IS_NOT_VALID, path[0] + ", " + mnemonicpath, null);
// mnemonic
- validateCondition(!StringUtils.equals(path[0], path[1]), HttpStatus.BAD_REQUEST, ValidateUtil.DEVICETYPE + " mnemonic path duplicate", mnemonicpath, null);
+ ExceptionUtil.validateConditionDataConflictException(!StringUtils.equals(path[0], path[1]), ValidateUtil.DEVICETYPE + " mnemonic path duplicate", mnemonicpath, null);
List<String> mnemonicPaths = StructureUtil.getMnemonicPathsDeviceType(holder, false, namingConvention);
for (String existingPath : mnemonicPaths) {
- validateCondition(!StringUtils.equals(mnemonicpath, existingPath), HttpStatus.BAD_REQUEST, ValidateUtil.DEVICETYPE + " mnemonic path duplicate", mnemonicpath, null);
+ ExceptionUtil.validateConditionDataConflictException(!StringUtils.equals(mnemonicpath, existingPath), ValidateUtil.DEVICETYPE + " mnemonic path duplicate", mnemonicpath, null);
}
// mnemonic equivalence
- validateCondition(!StringUtils.equals(namingConvention.equivalenceClassRepresentative(path[0]), namingConvention.equivalenceClassRepresentative(path[1])), HttpStatus.BAD_REQUEST, ValidateUtil.DEVICETYPE + " mnemonic path duplicate", mnemonicpath, null);
+ ExceptionUtil.validateConditionDataConflictException(!StringUtils.equals(namingConvention.equivalenceClassRepresentative(path[0]), namingConvention.equivalenceClassRepresentative(path[1])), ValidateUtil.DEVICETYPE + " mnemonic path duplicate", mnemonicpath, null);
mnemonicPaths = StructureUtil.getMnemonicPathsDeviceType(holder, true, namingConvention);
for (String existingPath : mnemonicPaths) {
- validateCondition(!StringUtils.equals(mnemonicpathEquivalence, namingConvention.equivalenceClassRepresentative(existingPath)), HttpStatus.BAD_REQUEST, ValidateUtil.DEVICETYPE + " mnemonic path equivalence duplicate", mnemonicpath, null);
+ ExceptionUtil.validateConditionDataConflictException(!StringUtils.equals(mnemonicpathEquivalence, namingConvention.equivalenceClassRepresentative(existingPath)), ValidateUtil.DEVICETYPE + " mnemonic path equivalence duplicate", mnemonicpath, null);
}
// since device group is between discipline and device type and device group has no mnemonic,
@@ -1430,62 +1420,36 @@ public class ValidateUtil {
// ----------------------------------------------------------------------------------------------------
/**
- * Validate condition and throw ServiceHttpStatusException with reason if validation fails.
- *
- * @param condition condition
- * @param status http status
- * @param message message
- * @param details details
- * @param field field
- *
- * @see ServiceHttpStatusException
- */
- public static void validateCondition(boolean condition, HttpStatus status, String message, String details, String field) {
- if (!condition) {
- switch(status) {
- case BAD_REQUEST:
- throw ExceptionUtil.createServiceHttpStatusExceptionBadRequest(message, details, field);
- default:
- throw ExceptionUtil.createServiceHttpStatusExceptionInternalServerError(message, details, field);
- }
- }
- }
-
- /**
- * Validate condition if precondition is fulfilled and throw ServiceHttpStatusException with reason if validation fails.
+ * Validate condition if precondition is fulfilled and throw data conflict exception with reason if validation fails.
*
* @param precondition precondition
* @param condition condition
- * @param status http status
* @param message message
* @param details details
* @param field field
*
- * @see ServiceHttpStatusException
+ * @see DataConflictException
*/
- public static void validateConditionIfPrecondition(boolean precondition, boolean condition, HttpStatus status, String message, String details, String field) {
+ private static void validateConditionIfPrecondition(boolean precondition, boolean condition, String message, String details, String field) {
if (precondition) {
- validateCondition(condition, status, message, details, field);
+ ExceptionUtil.validateConditionDataConflictException(condition, message, details, field);
}
}
/**
- * Validate condition if precondition (StructureChoice) is fulfilled and throw ServiceHttpStatusException with reason if validation fails.
+ * Validate condition if precondition (StructureChoice) is fulfilled and throw data conflict exception with reason if validation fails.
*
* @param expected expected structure choice
* @param actual actual structure choice
* @param condition condition
- * @param status http status
* @param message message
* @param details details
* @param field field
*
- * @see ServiceHttpStatusException
+ * @see DataConflictException
*/
- public static void validateConditionIfStructureChoice(StructureChoice expected, StructureChoice actual, boolean condition, HttpStatus status, String message, String details, String field) {
- validateConditionIfPrecondition(expected != null && expected.equals(actual), condition, status, message, details, field);
+ private static void validateConditionIfStructureChoice(StructureChoice expected, StructureChoice actual, boolean condition, String message, String details, String field) {
+ validateConditionIfPrecondition(expected != null && expected.equals(actual), condition, message, details, field);
}
-
-
}
diff --git a/src/test/java/org/openepics/names/util/ExceptionUtilTest.java b/src/test/java/org/openepics/names/util/ExceptionUtilTest.java
index 26bf183f..5b5ec63b 100644
--- a/src/test/java/org/openepics/names/util/ExceptionUtilTest.java
+++ b/src/test/java/org/openepics/names/util/ExceptionUtilTest.java
@@ -19,10 +19,20 @@
package org.openepics.names.util;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import org.junit.jupiter.api.Test;
-import org.springframework.http.HttpStatus;
+import org.openepics.names.service.exception.DataConflictException;
+import org.openepics.names.service.exception.DataDeletedException;
+import org.openepics.names.service.exception.DataExistException;
+import org.openepics.names.service.exception.DataNotAvailableException;
+import org.openepics.names.service.exception.DataNotCorrectException;
+import org.openepics.names.service.exception.DataNotFoundException;
+import org.openepics.names.service.exception.DataNotValidException;
+import org.openepics.names.service.exception.InputNotAvailableException;
+import org.openepics.names.service.exception.InputNotCorrectException;
+import org.openepics.names.service.exception.InputNotValidException;
/**
* Unit tests for ExceptionUtil class.
@@ -34,65 +44,133 @@ import org.springframework.http.HttpStatus;
public class ExceptionUtilTest {
/**
- * Test of create service http status exception.
+ * Test of create data conflict exception.
*/
@Test
- public void createServiceHttpStatusException() {
- ServiceHttpStatusException exception = ExceptionUtil.createServiceHttpStatusException(null, null, null, null, null);
- assertNull(exception.getHttpStatus());
+ public void createDataConflictException() {
+ DataConflictException exception = ExceptionUtil.createDataConflictException(null, null, null);
+ assertNotNull(exception);
assertNull(exception.getMessage());
assertNull(exception.getDetails());
assertNull(exception.getField());
assertNull(exception.getCause());
+ }
- exception = ExceptionUtil.createServiceHttpStatusExceptionBadRequest(null, null, null);
- assertEquals(HttpStatus.BAD_REQUEST, exception.getHttpStatus());
+ /**
+ * Test of create data deleted exception.
+ */
+ @Test
+ public void createDataDeletedException() {
+ DataDeletedException exception = ExceptionUtil.createDataDeletedException(null, null, null);
+ assertNotNull(exception);
assertEquals(null, exception.getMessage());
assertEquals(null, exception.getDetails());
assertEquals(null, exception.getField());
- assertEquals(null, exception.getCause());
+ assertNull(exception.getCause());
+ }
- exception = ExceptionUtil.createServiceHttpStatusExceptionUnauthorized(null, null, null);
- assertEquals(HttpStatus.UNAUTHORIZED, exception.getHttpStatus());
- assertEquals(null, exception.getMessage());
- assertEquals(null, exception.getDetails());
+ /**
+ * Test of create data exist exception.
+ */
+ @Test
+ public void createDataExistException() {
+ DataExistException exception = ExceptionUtil.createDataExistException("1", "2", "3");
+ assertNotNull(exception);
+ assertEquals("1", exception.getMessage());
+ assertEquals("2", exception.getDetails());
+ assertEquals("3", exception.getField());
+ assertNull(exception.getCause());
+ }
+
+ /**
+ * Test of create data not available exception.
+ */
+ @Test
+ public void createDataNotAvailableException() {
+ DataNotAvailableException exception = ExceptionUtil.createDataNotAvailableException("1", "2", null);
+ assertNotNull(exception);
+ assertEquals("1", exception.getMessage());
+ assertEquals("2", exception.getDetails());
assertEquals(null, exception.getField());
- assertEquals(null, exception.getCause());
+ assertNull(exception.getCause());
+ }
- exception = ExceptionUtil.createServiceHttpStatusExceptionForbidden(null, null, null);
- assertEquals(HttpStatus.FORBIDDEN, exception.getHttpStatus());
- assertEquals(null, exception.getMessage());
+ /**
+ * Test of create data not correct exception.
+ */
+ @Test
+ public void createDataNotCorrectException() {
+ DataNotCorrectException exception = ExceptionUtil.createDataNotCorrectException("1", null, "3");
+ assertNotNull(exception);
+ assertEquals("1", exception.getMessage());
assertEquals(null, exception.getDetails());
- assertEquals(null, exception.getField());
- assertEquals(null, exception.getCause());
+ assertEquals("3", exception.getField());
+ assertNull(exception.getCause());
+ }
- exception = ExceptionUtil.createServiceHttpStatusExceptionNotFound(null, null, null);
- assertEquals(HttpStatus.NOT_FOUND, exception.getHttpStatus());
- assertEquals(null, exception.getMessage());
+ /**
+ * Test of create data not found exception.
+ */
+ @Test
+ public void createDataNotFoundException() {
+ DataNotFoundException exception = ExceptionUtil.createDataNotFoundException("1", null, null);
+ assertNotNull(exception);
+ assertEquals("1", exception.getMessage());
assertEquals(null, exception.getDetails());
assertEquals(null, exception.getField());
- assertEquals(null, exception.getCause());
+ assertNull(exception.getCause());
+ }
- exception = ExceptionUtil.createServiceHttpStatusExceptionConflict(null, null, null);
- assertEquals(HttpStatus.CONFLICT, exception.getHttpStatus());
+ /**
+ * Test of create data not valid exception.
+ */
+ @Test
+ public void createDataNotValidException() {
+ DataNotValidException exception = ExceptionUtil.createDataNotValidException(null, "2", "3");
+ assertNotNull(exception);
assertEquals(null, exception.getMessage());
- assertEquals(null, exception.getDetails());
+ assertEquals("2", exception.getDetails());
+ assertEquals("3", exception.getField());
+ assertNull(exception.getCause());
+ }
+
+ /**
+ * Test of create input not available exception.
+ */
+ @Test
+ public void createInputNotAvailableException() {
+ InputNotAvailableException exception = ExceptionUtil.createInputNotAvailableException(null, "2", null);
+ assertNotNull(exception);
+ assertEquals(null, exception.getMessage());
+ assertEquals("2", exception.getDetails());
assertEquals(null, exception.getField());
- assertEquals(null, exception.getCause());
+ assertNull(exception.getCause());
+ }
- exception = ExceptionUtil.createServiceHttpStatusExceptionInternalServerError(null, null, null);
- assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, exception.getHttpStatus());
+ /**
+ * Test of create input not correct exception.
+ */
+ @Test
+ public void createInputNotCorrectException() {
+ InputNotCorrectException exception = ExceptionUtil.createInputNotCorrectException(null, null, "3");
+ assertNotNull(exception);
assertEquals(null, exception.getMessage());
assertEquals(null, exception.getDetails());
- assertEquals(null, exception.getField());
- assertEquals(null, exception.getCause());
+ assertEquals("3", exception.getField());
+ assertNull(exception.getCause());
+ }
- exception = ExceptionUtil.createServiceHttpStatusExceptionNotImplemented(null, null, null);
- assertEquals(HttpStatus.NOT_IMPLEMENTED, exception.getHttpStatus());
+ /**
+ * Test of create input not valid exception.
+ */
+ @Test
+ public void createInputNotValidException() {
+ InputNotValidException exception = ExceptionUtil.createInputNotValidException(null, null, null);
+ assertNotNull(exception);
assertEquals(null, exception.getMessage());
assertEquals(null, exception.getDetails());
assertEquals(null, exception.getField());
- assertEquals(null, exception.getCause());
+ assertNull(exception.getCause());
}
}
diff --git a/src/test/java/org/openepics/names/util/ValidateUtilTest.java b/src/test/java/org/openepics/names/util/ValidateUtilTest.java
index fb233304..f86a5119 100644
--- a/src/test/java/org/openepics/names/util/ValidateUtilTest.java
+++ b/src/test/java/org/openepics/names/util/ValidateUtilTest.java
@@ -21,15 +21,11 @@ package org.openepics.names.util;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.fail;
-import java.util.List;
import java.util.UUID;
import org.junit.jupiter.api.Test;
-import org.openepics.names.repository.model.Subsystem;
import org.openepics.names.rest.beans.Type;
-import org.springframework.http.HttpStatus;
-
-import com.google.common.collect.Lists;
+import org.openepics.names.service.exception.InputNotAvailableException;
/**
* Unit tests for ValidateUtil class.
@@ -48,10 +44,13 @@ public class ValidateUtilTest {
try {
ValidateUtil.validateInputComment(null);
fail();
- } catch (ServiceHttpStatusException e) {
- assertEquals(HttpStatus.BAD_REQUEST, e.getHttpStatus());
+ } catch (InputNotAvailableException e) {
assertEquals("comment is not available", e.getMessage());
+ assertEquals(null, e.getDetails());
+ assertEquals("comment", e.getField());
assertEquals(null, e.getCause());
+ } catch (Exception e) {
+ fail();
}
}
/**
@@ -62,10 +61,13 @@ public class ValidateUtilTest {
try {
ValidateUtil.validateInputComment("");
fail();
- } catch (ServiceHttpStatusException e) {
- assertEquals(HttpStatus.BAD_REQUEST, e.getHttpStatus());
+ } catch (InputNotAvailableException e) {
assertEquals("comment is not available", e.getMessage());
+ assertEquals("", e.getDetails());
+ assertEquals("comment", e.getField());
assertEquals(null, e.getCause());
+ } catch (Exception e) {
+ fail();
}
}
/**
@@ -84,10 +86,13 @@ public class ValidateUtilTest {
try {
ValidateUtil.validateInputDescription(null);
fail();
- } catch (ServiceHttpStatusException e) {
- assertEquals(HttpStatus.BAD_REQUEST, e.getHttpStatus());
+ } catch (InputNotAvailableException e) {
assertEquals("description is not available", e.getMessage());
+ assertEquals(null, e.getDetails());
+ assertEquals("description", e.getField());
assertEquals(null, e.getCause());
+ } catch (Exception e) {
+ fail();
}
}
/**
@@ -98,10 +103,13 @@ public class ValidateUtilTest {
try {
ValidateUtil.validateInputDescription("");
fail();
- } catch (ServiceHttpStatusException e) {
- assertEquals(HttpStatus.BAD_REQUEST, e.getHttpStatus());
+ } catch (InputNotAvailableException e) {
assertEquals("description is not available", e.getMessage());
+ assertEquals("", e.getDetails());
+ assertEquals("description", e.getField());
assertEquals(null, e.getCause());
+ } catch (Exception e) {
+ fail();
}
}
/**
@@ -120,10 +128,13 @@ public class ValidateUtilTest {
try {
ValidateUtil.validateInputMnemonic(null);
fail();
- } catch (ServiceHttpStatusException e) {
- assertEquals(HttpStatus.BAD_REQUEST, e.getHttpStatus());
+ } catch (InputNotAvailableException e) {
assertEquals("mnemonic is not available", e.getMessage());
+ assertEquals(null, e.getDetails());
+ assertEquals("mnemonic", e.getField());
assertEquals(null, e.getCause());
+ } catch (Exception e) {
+ fail();
}
}
/**
@@ -134,10 +145,13 @@ public class ValidateUtilTest {
try {
ValidateUtil.validateInputMnemonic("");
fail();
- } catch (ServiceHttpStatusException e) {
- assertEquals(HttpStatus.BAD_REQUEST, e.getHttpStatus());
+ } catch (InputNotAvailableException e) {
assertEquals("mnemonic is not available", e.getMessage());
+ assertEquals("", e.getDetails());
+ assertEquals("mnemonic", e.getField());
assertEquals(null, e.getCause());
+ } catch (Exception e) {
+ fail();
}
}
/**
@@ -156,10 +170,13 @@ public class ValidateUtilTest {
try {
ValidateUtil.validateInputName(null);
fail();
- } catch (ServiceHttpStatusException e) {
- assertEquals(HttpStatus.BAD_REQUEST, e.getHttpStatus());
+ } catch (InputNotAvailableException e) {
assertEquals("name is not available", e.getMessage());
+ assertEquals(null, e.getDetails());
+ assertEquals("name", e.getField());
assertEquals(null, e.getCause());
+ } catch (Exception e) {
+ fail();
}
}
/**
@@ -170,10 +187,13 @@ public class ValidateUtilTest {
try {
ValidateUtil.validateInputName("");
fail();
- } catch (ServiceHttpStatusException e) {
- assertEquals(HttpStatus.BAD_REQUEST, e.getHttpStatus());
+ } catch (InputNotAvailableException e) {
assertEquals("name is not available", e.getMessage());
+ assertEquals("", e.getDetails());
+ assertEquals("name", e.getField());
assertEquals(null, e.getCause());
+ } catch (Exception e) {
+ fail();
}
}
/**
@@ -192,10 +212,13 @@ public class ValidateUtilTest {
try {
ValidateUtil.validateInputType(null);
fail();
- } catch (ServiceHttpStatusException e) {
- assertEquals(HttpStatus.BAD_REQUEST, e.getHttpStatus());
+ } catch (InputNotAvailableException e) {
assertEquals("type is not available", e.getMessage());
+ assertEquals(null, e.getDetails());
+ assertEquals("type", e.getField());
assertEquals(null, e.getCause());
+ } catch (Exception e) {
+ fail();
}
}
/**
@@ -219,10 +242,13 @@ public class ValidateUtilTest {
try {
ValidateUtil.validateInputUuid(null);
fail();
- } catch (ServiceHttpStatusException e) {
- assertEquals(HttpStatus.BAD_REQUEST, e.getHttpStatus());
+ } catch (InputNotAvailableException e) {
assertEquals("uuid is not available", e.getMessage());
+ assertEquals(null, e.getDetails());
+ assertEquals("uuid", e.getField());
assertEquals(null, e.getCause());
+ } catch (Exception e) {
+ fail();
}
}
/**
@@ -233,9 +259,10 @@ public class ValidateUtilTest {
try {
ValidateUtil.validateInputUuid("");
fail();
- } catch (ServiceHttpStatusException e) {
- assertEquals(HttpStatus.BAD_REQUEST, e.getHttpStatus());
+ } catch (InputNotAvailableException e) {
assertEquals("uuid is not available", e.getMessage());
+ assertEquals("", e.getDetails());
+ assertEquals("uuid", e.getField());
assertEquals(null, e.getCause());
}
}
@@ -314,8 +341,7 @@ public class ValidateUtilTest {
null, null,
null, null);
fail();
- } catch (ServiceHttpStatusException e) {
- assertEquals(HttpStatus.BAD_REQUEST, e.getHttpStatus());
+ } catch (InputNotAvailableException e) {
assertEquals("type is not available", e.getMessage());
assertEquals(null, e.getCause());
}
@@ -390,18 +416,4 @@ public class ValidateUtilTest {
ValidateUtil.validateStructureElementDataUpdate(null, null, null, null);
}
- @Test
- public void validateDummy() {
- final List<Subsystem> subsystems = Lists.newArrayList();
- try {
- ValidateUtil.validateCondition(subsystems != null && subsystems.size() == 1, HttpStatus.INTERNAL_SERVER_ERROR,
- ValidateUtil.SUBSYSTEM + ValidateUtil.SPACE + ValidateUtil.IS_NOT_CORRECT, null, null);
- fail();
- } catch (ServiceHttpStatusException e) {
- assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, e.getHttpStatus());
- assertEquals("subsystem is not correct", e.getMessage());
- assertEquals(null, e.getCause());
- }
- }
-
}
--
GitLab