diff --git a/src/main/java/org/openepics/names/service/NamesService.java b/src/main/java/org/openepics/names/service/NamesService.java
index 2d91491c82e5709a63e8b6e8fea0dea36d1f666a..ae2845a5fe896c284222e924e3ecc47ee30d60d1 100644
--- a/src/main/java/org/openepics/names/service/NamesService.java
+++ b/src/main/java/org/openepics/names/service/NamesService.java
@@ -60,6 +60,7 @@ import org.openepics.names.util.HolderSystemDeviceStructure;
import org.openepics.names.util.NameElementUtil;
import org.openepics.names.util.NameUtil;
import org.openepics.names.util.TextUtil;
+import org.openepics.names.util.ValidateNameElementUtil;
import org.openepics.names.util.ValidateUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@@ -243,7 +244,7 @@ public class NamesService {
// name elements for names
// validate input
- ValidateUtil.validateNamesInputRead(
+ ValidateNameElementUtil.validateNamesInputRead(
deleted, queryFields, queryValues,
includeHistory,
orderBy, isAsc,
@@ -507,7 +508,7 @@ public class NamesService {
HolderSystemDeviceStructure holder = new HolderSystemDeviceStructure(holderIRepositories, false);
// validate data
- ValidateUtil.validateNameDataCreate(name, namingConvention, holderRepositories, holder);
+ ValidateNameElementUtil.validateNameDataCreate(name, namingConvention, holderRepositories, holder);
return Boolean.TRUE;
}
@@ -529,10 +530,10 @@ public class NamesService {
// validate towards repository
// validate input
- ValidateUtil.validateNameElementInputCreate(nameElement);
+ ValidateNameElementUtil.validateNameElementInputCreate(nameElement);
// validate data
- ValidateUtil.validateNameElementDataCreate(nameElement, namingConvention, holderIRepositories, nameRepository, holder);
+ ValidateNameElementUtil.validateNameElementDataCreate(nameElement, namingConvention, holderIRepositories, nameRepository, holder);
}
public void validateNamesCreate(List<NameElementCommand> nameElements) {
// initiate holder of containers for system and device structure content, for performance reasons
@@ -558,10 +559,10 @@ public class NamesService {
// validate towards repository
// validate input
- ValidateUtil.validateNameElementInputUpdate(nameElement);
+ ValidateNameElementUtil.validateNameElementInputUpdate(nameElement);
// validate data
- ValidateUtil.validateNameElementDataUpdate(nameElement, namingConvention, holderIRepositories, nameRepository, holder);
+ ValidateNameElementUtil.validateNameElementDataUpdate(nameElement, namingConvention, holderIRepositories, nameRepository, holder);
}
public void validateNamesUpdate(List<NameElementCommand> nameElements) {
// initiate holder of containers for system and device structure content, for performance reasons
@@ -585,10 +586,10 @@ public class NamesService {
// retrieve name (uuid, latest, not deleted)
// validate input
- ValidateUtil.validateNameElementInputDelete(nameElement);
+ ValidateNameElementUtil.validateNameElementInputDelete(nameElement);
// validate data
- ValidateUtil.validateNameElementDataDelete(nameElement, namingConvention, holderIRepositories, nameRepository, holder);
+ ValidateNameElementUtil.validateNameElementDataDelete(nameElement, namingConvention, holderIRepositories, nameRepository, holder);
}
public void validateNamesDelete(List<NameElementCommand> nameElements) {
// validate authority
diff --git a/src/main/java/org/openepics/names/service/StructuresService.java b/src/main/java/org/openepics/names/service/StructuresService.java
index 4bb6b9c97a0f31d9a46406f4bbfbde012a4e83c6..97c1b3e72c0b93c9de16853452a51e9297b6c02b 100644
--- a/src/main/java/org/openepics/names/service/StructuresService.java
+++ b/src/main/java/org/openepics/names/service/StructuresService.java
@@ -61,6 +61,7 @@ import org.openepics.names.util.HolderRepositories;
import org.openepics.names.util.HolderSystemDeviceStructure;
import org.openepics.names.util.StructureElementUtil;
import org.openepics.names.util.TextUtil;
+import org.openepics.names.util.ValidateStructureElementUtil;
import org.openepics.names.util.StructureElementUtil.StructureChoice;
import org.openepics.names.util.ValidateUtil;
import org.springframework.beans.factory.annotation.Autowired;
@@ -308,7 +309,7 @@ public class StructuresService {
// structure elements for structures
// validate input
- ValidateUtil.validateStructuresInputRead(
+ ValidateStructureElementUtil.validateStructuresInputRead(
type, statuses, deleted, queryFields, queryValues,
includeHistory,
orderBy, isAsc,
@@ -640,7 +641,7 @@ public class StructuresService {
HolderSystemDeviceStructure holder = new HolderSystemDeviceStructure(holderIRepositories, false);
// validate data
- ValidateUtil.validateStructureDataCreate(type, mnemonicpath, namingConvention, holderIRepositories, holder);
+ ValidateStructureElementUtil.validateStructureDataCreate(type, mnemonicpath, namingConvention, holderIRepositories, holder);
return Boolean.TRUE;
}
@@ -662,10 +663,10 @@ public class StructuresService {
// relative other data
// validate input
- ValidateUtil.validateStructureElementInputCreate(structureElement, namingConvention);
+ ValidateStructureElementUtil.validateStructureElementInputCreate(structureElement, namingConvention);
// validate data
- ValidateUtil.validateStructureElementDataCreate(structureElement, namingConvention, holderRepositories, holder);
+ ValidateStructureElementUtil.validateStructureElementDataCreate(structureElement, namingConvention, holderRepositories, holder);
}
public void validateStructuresCreate(List<StructureElementCommand> structureElements) {
// initiate holder of containers for system and device structure content, for performance reasons
@@ -691,10 +692,10 @@ public class StructuresService {
// relative other data
// validate input
- ValidateUtil.validateStructureElementInputUpdate(structureElement, namingConvention);
+ ValidateStructureElementUtil.validateStructureElementInputUpdate(structureElement, namingConvention);
// validate data
- ValidateUtil.validateStructureElementDataUpdate(structureElement, namingConvention, holderRepositories, holder);
+ ValidateStructureElementUtil.validateStructureElementDataUpdate(structureElement, namingConvention, holderRepositories, holder);
}
public void validateStructuresUpdate(List<StructureElementCommand> structureElements) {
// initiate holder of containers for system and device structure content, for performance reasons
@@ -720,10 +721,10 @@ public class StructuresService {
// relative other data
// validate input
- ValidateUtil.validateStructureElementInputDelete(structureElement, namingConvention);
+ ValidateStructureElementUtil.validateStructureElementInputDelete(structureElement, namingConvention);
// validate data
- ValidateUtil.validateStructureElementDataDelete(structureElement, namingConvention, holderRepositories, holder);
+ ValidateStructureElementUtil.validateStructureElementDataDelete(structureElement, namingConvention, holderRepositories, holder);
}
public void validateStructuresDelete(List<StructureElementCommand> structureElements) {
// initiate holder of containers for system and device structure content, for performance reasons
@@ -749,10 +750,10 @@ public class StructuresService {
// relative other data
// validate input
- ValidateUtil.validateStructureElementInputApprove(structureElement, namingConvention);
+ ValidateStructureElementUtil.validateStructureElementInputApprove(structureElement, namingConvention);
// validate data
- ValidateUtil.validateStructureElementDataApprove(structureElement, namingConvention, holderRepositories, holder);
+ ValidateStructureElementUtil.validateStructureElementDataApprove(structureElement, namingConvention, holderRepositories, holder);
}
public void validateStructuresApprove(List<StructureElementCommand> structureElements) {
// initiate holder of containers for system and device structure content, for performance reasons
@@ -778,10 +779,10 @@ public class StructuresService {
// relative other data
// validate input
- ValidateUtil.validateStructureElementInputCancel(structureElement, namingConvention);
+ ValidateStructureElementUtil.validateStructureElementInputCancel(structureElement, namingConvention);
// validate data
- ValidateUtil.validateStructureElementDataCancel(structureElement, namingConvention, holderRepositories, holder);
+ ValidateStructureElementUtil.validateStructureElementDataCancel(structureElement, namingConvention, holderRepositories, holder);
}
public void validateStructuresCancel(List<StructureElementCommand> structureElements) {
// initiate holder of containers for system and device structure content, for performance reasons
@@ -807,10 +808,10 @@ public class StructuresService {
// relative other data
// validate input
- ValidateUtil.validateStructureElementInputReject(structureElement, namingConvention);
+ ValidateStructureElementUtil.validateStructureElementInputReject(structureElement, namingConvention);
// validate data
- ValidateUtil.validateStructureElementDataReject(structureElement, namingConvention, holderRepositories, holder);
+ ValidateStructureElementUtil.validateStructureElementDataReject(structureElement, namingConvention, holderRepositories, holder);
}
public void validateStructuresReject(List<StructureElementCommand> structureElements) {
// initiate holder of containers for system and device structure content, for performance reasons
diff --git a/src/main/java/org/openepics/names/util/ValidateNameElementUtil.java b/src/main/java/org/openepics/names/util/ValidateNameElementUtil.java
new file mode 100644
index 0000000000000000000000000000000000000000..be50a152b2e7436c25b667ed9746ca404f4b1ab1
--- /dev/null
+++ b/src/main/java/org/openepics/names/util/ValidateNameElementUtil.java
@@ -0,0 +1,479 @@
+/*
+ * 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.util;
+
+import java.util.List;
+import java.util.UUID;
+
+import org.apache.commons.lang3.StringUtils;
+import org.openepics.names.repository.NameRepository;
+import org.openepics.names.repository.model.DeviceType;
+import org.openepics.names.repository.model.Name;
+import org.openepics.names.repository.model.Subsystem;
+import org.openepics.names.repository.model.System;
+import org.openepics.names.repository.model.SystemGroup;
+import org.openepics.names.rest.beans.FieldName;
+import org.openepics.names.rest.beans.FieldStructure;
+import org.openepics.names.rest.beans.Status;
+import org.openepics.names.rest.beans.element.NameElementCommand;
+
+/**
+ * Utility class to assist in handling of validation.
+ *
+ * @author Lars Johansson
+ */
+public class ValidateNameElementUtil {
+
+ // note
+ // handling of system structure, device structure
+ // parent system structure uuid (system group, system, subsystem)
+ // parent device structure uuid (device type)
+ //
+ // NameElement
+ // uuid,
+ // systemgroup, system, subsystem, devicetype, systemstructure, devicestructure,
+ // index, name,
+ // description, status, latest, deleted, when, who, comment
+ //
+ // NameElementCommand
+ // create - parentsystemstructure, parentdevicestructure (optional), index, description, comment
+ // update - uuid, parentsystemstructure, parentdevicestructure (optional), index, description, comment
+ // delete - uuid, comment
+
+ private enum NameChoice {CREATE, UPDATE, DELETE}
+
+ /**
+ * This class is not to be instantiated.
+ */
+ private ValidateNameElementUtil() {
+ throw new IllegalStateException("Utility class");
+ }
+
+ /**
+ * Validate parameters for read names.
+ *
+ * @param deleted deleted
+ * @param queryFields query fields
+ * @param queryValues query values
+ * @param includeHistory include history
+ * @param orderBy order by
+ * @param isAsc is ascending
+ * @param offset offset
+ * @param limit limit
+ */
+ public static void validateNamesInputRead(
+ Boolean deleted, FieldName[] queryFields, String[] queryValues,
+ Boolean includeHistory,
+ FieldName orderBy, Boolean isAsc,
+ Integer offset, Integer limit) {
+
+ // validate input
+ // queryFields and queryValues
+ // either
+ // both null
+ // both non-null, same length, non-empty
+ // uuid
+
+ boolean condition = ((queryFields == null && queryValues == null)
+ || (queryFields != null && queryValues != null && queryFields.length == queryValues.length && queryFields.length > 0));
+ ExceptionUtil.validateConditionInputNotCorrectException(condition,
+ TextUtil.VALUES_ARE_NOT_CORRECT, "url and parameters (queryFields, queryValues) have different lengths or are empty", null);
+
+ if (queryFields != null) {
+ for (int i=0; i<queryFields.length; i++) {
+ if (FieldName.UUID.equals(queryFields[i])) {
+ ValidateUtil.validateInputUuid(queryValues[i]);
+ }
+ }
+ }
+ }
+
+ /**
+ * Validate name element parameters (input) for create.
+ *
+ * @param nameElement name element
+ */
+ public static void validateNameElementInputCreate(NameElementCommand nameElement) {
+ validateNameElementInput(nameElement, NameChoice.CREATE);
+ }
+
+ /**
+ * Validate name element parameters (input) for update.
+ *
+ * @param nameElement name element
+ */
+ public static void validateNameElementInputUpdate(NameElementCommand nameElement) {
+ validateNameElementInput(nameElement, NameChoice.UPDATE);
+ }
+
+ /**
+ * Validate name element parameters (input) for delete.
+ *
+ * @param nameElement name element
+ */
+ public static void validateNameElementInputDelete(NameElementCommand nameElement) {
+ validateNameElementInput(nameElement, NameChoice.DELETE);
+ }
+
+ /**
+ * Validate name element parameters (input).
+ *
+ * @param nameElement name element
+ * @param nameChoice name choice
+ */
+ private static void validateNameElementInput(NameElementCommand nameElement, NameChoice nameChoice) {
+ // attributes
+ // uuid - required if not create, required empty if create
+ // parentsystemstructure (uuid)
+ // parentdevicestructure (uuid)
+ // index
+ // description
+ // comment
+
+ if (nameElement == null || nameChoice == null) {
+ return;
+ }
+
+ UUID uuid = nameElement.getUuid();
+ UUID parentSystemstructure = nameElement.getParentsystemstructure();
+ UUID parentDevicestructure = nameElement.getParentdevicestructure();
+ String index = nameElement.getIndex();
+ String description = nameElement.getDescription();
+ String comment = nameElement.getComment();
+
+ if (NameChoice.CREATE.equals(nameChoice)) {
+ ExceptionUtil.validateConditionInputNotEmptyException(uuid == null,
+ TextUtil.VALUE_IS_NOT_EMPTY,
+ uuid != null ? uuid.toString() : null,
+ TextUtil.UUID);
+ } else {
+ ValidateUtil.validateInputUuid(uuid != null ? uuid.toString() : null);
+ }
+
+ if (!NameChoice.DELETE.equals(nameChoice)) {
+ ExceptionUtil.validateConditionInputNotAvailableException(parentSystemstructure != null,
+ TextUtil.VALUE_IS_NOT_AVAILABLE, nameElement.toString(), TextUtil.PARENTSYSTEMSTRUCTURE);
+
+ // optional (either none or both)
+ // parentdevicestructure
+ // index
+ if (parentDevicestructure != null && index == null) {
+ throw ExceptionUtil.createInputNotCorrectException(null, nameElement.toString(), TextUtil.INDEX);
+ } else if (parentDevicestructure == null && index != null) {
+ throw ExceptionUtil.createInputNotCorrectException(null, nameElement.toString(), TextUtil.PARENTDEVICESTRUCTURE);
+ }
+
+ ValidateUtil.validateInputDescription(description);
+ }
+
+ ValidateUtil.validateInputComment(comment);
+ }
+
+ // ----------------------------------------------------------------------------------------------------
+
+ /**
+ * Validate name element data for create.
+ *
+ * @param nameElement name element
+ * @param namingConvention naming convention
+ * @param holderIRepositories holder repositories
+ * @param nameRepository name repository
+ * @param holder holder
+ */
+ public static void validateNameElementDataCreate(NameElementCommand nameElement, EssNamingConvention namingConvention, HolderIRepositories holderIRepositories, NameRepository nameRepository, HolderSystemDeviceStructure holder) {
+ validateNameElementData(nameElement, namingConvention, holderIRepositories, nameRepository, holder, NameChoice.CREATE);
+ }
+
+ /**
+ * Validate name element data for update.
+ *
+ * @param nameElement name element
+ * @param namingConvention naming convention
+ * @param holderIRepositories holder repositories
+ * @param nameRepository name repositories
+ * @param holder holder
+ */
+ public static void validateNameElementDataUpdate(NameElementCommand nameElement, EssNamingConvention namingConvention, HolderIRepositories holderIRepositories, NameRepository nameRepository, HolderSystemDeviceStructure holder) {
+ validateNameElementData(nameElement, namingConvention, holderIRepositories, nameRepository, holder, NameChoice.UPDATE);
+ }
+
+ /**
+ * Validate name element data for delete.
+ *
+ * @param nameElement name element
+ * @param namingConvention naming convention
+ * @param holderIRepositories holder repositories
+ * @param nameRepository name repositories
+ * @param holder holder
+ */
+ public static void validateNameElementDataDelete(NameElementCommand nameElement, EssNamingConvention namingConvention, HolderIRepositories holderIRepositories, NameRepository nameRepository, HolderSystemDeviceStructure holder) {
+ validateNameElementData(nameElement, namingConvention, holderIRepositories, nameRepository, holder, NameChoice.DELETE);
+ }
+
+ /**
+ * Validate name element data.
+ *
+ * @param nameElement name element
+ * @param namingConvention naming convention
+ * @param holderIRepositories holder repositories
+ * @param nameRepository name repository
+ * @param holder holder
+ * @param nameChoice name choice
+ */
+ private static void validateNameElementData(NameElementCommand nameElement, EssNamingConvention namingConvention, HolderIRepositories holderIRepositories, NameRepository nameRepository, HolderSystemDeviceStructure holder, NameChoice nameChoice) {
+ // attributes
+ // uuid
+ // parentsystemstructure
+ // parentdevicestructure
+ // index
+ // description
+ // comment
+ //
+ // name
+ // - system structure uuid
+ // ( - system structure uuid, device structure uuid )
+ // - system structure uuid, device structure uuid, index
+
+ if (nameElement == null || namingConvention == null || holderIRepositories == null || nameRepository == null || holder == null || nameChoice == null) {
+ return;
+ }
+
+ String details = nameElement.toString();
+
+ // name
+ // update, delete - uuid available, not deleted
+ // 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());
+ ExceptionUtil.validateConditionDataNotCorrectException(names != null && names.size() == 1,
+ TextUtil.VALUE_IS_NOT_CORRECT, details, TextUtil.UUID);
+ }
+
+ SystemGroup systemGroup = null;
+ System system = null;
+ Subsystem subsystem = null;
+ DeviceType deviceType = null;
+
+ int countDevicestructureIndex = 0;
+ String derivedName = null;
+
+ boolean condition = true;
+
+ UUID uuid = nameElement.getUuid();
+ UUID parentSystemstructure = nameElement.getParentsystemstructure();
+ UUID parentDevicestructure = nameElement.getParentdevicestructure();
+ String index = nameElement.getIndex();
+
+ if (NameChoice.CREATE.equals(nameChoice) || NameChoice.UPDATE.equals(nameChoice)) {
+ // systemgroup, system, subsystem - in repository
+ // found
+ // not deleted
+ // devicetype - possibly, in repository
+ // found
+ // not deleted
+ // name - naming convention rules
+ // derive name from system structure, device structure, index
+ // index - possibly, naming convention rules
+ // valid
+ // name
+ // name not exists
+ // name equivalence not exists
+
+ // find out system group, system, subsystem
+ // one of the three expected to be non-null, other two expected to be null
+ systemGroup = holderIRepositories.getSystemGroupRepository().findLatestByUuid(parentSystemstructure.toString());
+ system = holderIRepositories.getSystemRepository().findLatestByUuid(parentSystemstructure.toString());
+ subsystem = holderIRepositories.getSubsystemRepository().findLatestByUuid(parentSystemstructure.toString());
+
+ // device structure
+ if (parentDevicestructure != null) {
+ countDevicestructureIndex++;
+ deviceType = holderIRepositories.getDeviceTypeRepository().findLatestByUuid(parentDevicestructure.toString());
+ ExceptionUtil.validateConditionDataNotAvailableException(deviceType != null, TextUtil.DATA_IS_NOT_AVAILABLE, details, TextUtil.PARENTDEVICESTRUCTURE);
+ ExceptionUtil.validateConditionDataDeletedException(!deviceType.isDeleted(), TextUtil.DATA_IS_DELETED, details, TextUtil.PARENTDEVICESTRUCTURE);
+ }
+
+ // system structure
+ if (systemGroup != null) {
+ ExceptionUtil.validateConditionDataDeletedException(!systemGroup.isDeleted(), TextUtil.DATA_IS_DELETED, details, TextUtil.PARENTSYSTEMSTRUCTURE);
+ derivedName = NameUtil.getName(systemGroup, deviceType, index, holder);
+ } else if (system != null) {
+ ExceptionUtil.validateConditionDataDeletedException(!system.isDeleted(), TextUtil.DATA_IS_DELETED, details, TextUtil.PARENTSYSTEMSTRUCTURE);
+ derivedName = NameUtil.getName(system, deviceType, index, holder);
+ } else if (subsystem != null) {
+ ExceptionUtil.validateConditionDataDeletedException(!subsystem.isDeleted(), TextUtil.DATA_IS_DELETED, details, TextUtil.PARENTSYSTEMSTRUCTURE);
+ derivedName = NameUtil.getName(subsystem, deviceType, index, holder);
+ } else {
+ throw ExceptionUtil.createDataNotCorrectException(TextUtil.DATA_IS_NOT_CORRECT, details, TextUtil.PARENTSYSTEMSTRUCTURE);
+ }
+
+ // index
+ if (!StringUtils.isEmpty(index)) {
+ countDevicestructureIndex++;
+ // TODO overrideRuleset depend on user authority
+ condition = namingConvention.isInstanceIndexValid(derivedName, false);
+ ExceptionUtil.validateConditionDataNotValidException(condition, TextUtil.DATA_IS_NOT_VALID, details, TextUtil.INDEX);
+ }
+
+ condition = countDevicestructureIndex == 0 || countDevicestructureIndex == 2;
+ ExceptionUtil.validateConditionDataNotAvailableException(condition, TextUtil.DEVICETYPE_OR_INDEX_IS_NOT_AVAILABLE, details, TextUtil.PARENTDEVICESTRUCTURE);
+
+ // name
+ // ok with same name, name equivalence if same uuid
+ List<Name> names = nameRepository.readNames(false, FieldName.NAME, derivedName);
+ if (NameChoice.CREATE.equals(nameChoice)) {
+ condition = names == null || names.isEmpty();
+ } else {
+ // NameChoice.UPDATE.equals(nameChoice)
+ condition = names == null || names.isEmpty() || names.size() == 1 && names.get(0).getUuid().equals(uuid);
+ }
+ ExceptionUtil.validateConditionDataExistException(condition, TextUtil.CONVENTION_NAME_EXISTS, details, TextUtil.PARENTSYSTEMSTRUCTURE);
+
+ names = nameRepository.readNames(false, FieldName.NAMEEQUIVALENCE, namingConvention.equivalenceClassRepresentative(derivedName));
+ if (NameChoice.CREATE.equals(nameChoice)) {
+ condition = names == null || names.isEmpty();
+ } else {
+ // NameChoice.UPDATE.equals(nameChoice)
+ condition = names == null || names.isEmpty() || names.size() == 1 && names.get(0).getUuid().equals(uuid);
+ }
+ ExceptionUtil.validateConditionDataExistException(condition, TextUtil.CONVENTION_NAME_EQUIVALENCE_EXISTS, details, TextUtil.PARENTSYSTEMSTRUCTURE);
+ } else if (NameChoice.DELETE.equals(nameChoice)) {
+ // n.a.
+ // uuid - already handled
+ // comment - already handled
+ }
+ }
+
+ // ----------------------------------------------------------------------------------------------------
+
+ /**
+ * Validate name data.
+ * This method corresponds to name element data for create, albeit in a different way.
+ *
+ * @param name name
+ * @param namingConvention naming convention
+ * @param holderRepositories holder repositories
+ * @param holder holder
+ *
+ * @see ValidateUtil#validateNameDataCreate(NameElement, EssNamingConvention, HolderIRepositories, NameRepository, HolderSystemDeviceStructure)
+ */
+ public static void validateNameDataCreate(String name, EssNamingConvention namingConvention, HolderRepositories holderRepositories, HolderSystemDeviceStructure holder) {
+ if (name == null || namingConvention == null || holderRepositories == null || holder == null) {
+ return;
+ }
+
+ String details = name;
+ String field = TextUtil.NAME;
+
+ // find out system group, system, subsystem + check if valid
+ // find out discipline, device group, device type + check if valid
+ // find out instance index + check if valid
+ // check name equivalence
+
+ String sg = NamingConventionUtil.extractSystemGroup(name);
+ String sys = NamingConventionUtil.extractSystem(name);
+ String sub = NamingConventionUtil.extractSubsystem(name);
+ String dt = NamingConventionUtil.extractDeviceType(name);
+ String idx = NamingConventionUtil.extractInstanceIndex(name);
+
+ String mnemonicPathSystemstructure = NamingConventionUtil.extractMnemonicPathSystemStructure(name);
+ String mnemonicPathDevicestructure = NamingConventionUtil.extractMnemonicPathDeviceStructure(name);
+
+ int count = 0;
+ int countSgSys = 0;
+ int countSgSub = 0;
+ if (sg != null) {
+ count++;
+ countSgSys++;
+ countSgSub++;
+ }
+ if (sys != null) {
+ count++;
+ countSgSys++;
+ }
+ if (sub != null) {
+ count++;
+ countSgSub++;
+ }
+
+ // one or two system structure mnemonics + not system group and system + not system group and subsystem
+ if (count < 1 || count > 2 || countSgSys == 2 || countSgSub == 2) {
+ throw ExceptionUtil.createDataNotCorrectException(TextUtil.SYSTEM_STRUCTURE_IS_NOT_CORRECT, details, field);
+ }
+
+ SystemGroup systemGroup = null;
+ System system = null;
+ Subsystem subsystem = null;
+ DeviceType deviceType = null;
+
+ String derivedName = null;
+
+ // ensure that system structure parents and device structure parents are available, latest and not deleted
+ // if device type
+ // if system group
+ // else
+ // if system
+ // else
+ // (if not system then error)
+ // if subsystem
+
+ // device structure
+ if (!StringUtils.isEmpty(dt)) {
+ List<DeviceType> deviceTypes = holderRepositories.getDeviceTypeRepository().readDeviceTypes(Status.APPROVED, false, FieldStructure.MNEMONICPATH, mnemonicPathDevicestructure);
+ ExceptionUtil.validateConditionDataNotAvailableException(deviceTypes != null && deviceTypes.size() == 1, TextUtil.DEVICETYPE_IS_NOT_AVAILABLE, details, field);
+ deviceType = deviceTypes.get(0);
+ }
+
+ // system structure
+ List<Subsystem> subsystems = holderRepositories.getSubsystemRepository().readSubsystems(Status.APPROVED, false, FieldStructure.MNEMONICPATH, mnemonicPathSystemstructure);
+ List<System> systems = holderRepositories.getSystemRepository().readSystems(Status.APPROVED, false, FieldStructure.MNEMONICPATH, mnemonicPathSystemstructure);
+ List<SystemGroup> systemGroups = holderRepositories.getSystemGroupRepository().readSystemGroups(Status.APPROVED, false, FieldStructure.MNEMONICPATH, mnemonicPathSystemstructure);
+
+ if (subsystems != null && subsystems.size() == 1) {
+ subsystem = subsystems.get(0);
+ derivedName = NameUtil.getName(subsystem, deviceType, NamingConventionUtil.extractInstanceIndex(name), holder);
+ } else if (systems != null && systems.size() == 1) {
+ system = systems.get(0);
+ derivedName = NameUtil.getName(system, deviceType, NamingConventionUtil.extractInstanceIndex(name), holder);
+ } else if (systemGroups != null && systemGroups.size() == 1) {
+ systemGroup = systemGroups.get(0);
+ derivedName = NameUtil.getName(systemGroup, deviceType, NamingConventionUtil.extractInstanceIndex(name), holder);
+ } else {
+ throw ExceptionUtil.createDataNotCorrectException(TextUtil.SYSTEM_STRUCTURE_IS_NOT_CORRECT, details, field);
+ }
+
+ // index
+ if (!StringUtils.isEmpty(idx)) {
+ // TODO overrideRuleset depend on user authority
+ ExceptionUtil.validateConditionDataNotValidException(namingConvention.isInstanceIndexValid(name, false), TextUtil.INDEX_IS_NOT_VALID, details, field);
+ }
+
+ // name
+ // name corresponds to derived name
+ // convention name not exists
+ // convention name equivalence not exists
+ ExceptionUtil.validateConditionDataNotCorrectException(StringUtils.equals(name, derivedName), TextUtil.CONVENTION_NAME_IS_NOT_CORRECT, details, field);
+
+ List<Name> names = holderRepositories.getNameRepository().readNames(false, FieldName.NAME, name);
+ ExceptionUtil.validateConditionDataExistException(names.isEmpty(), TextUtil.CONVENTION_NAME_EXISTS, details, field);
+
+ names = holderRepositories.getNameRepository().readNames(false, FieldName.NAMEEQUIVALENCE, namingConvention.equivalenceClassRepresentative(name));
+ ExceptionUtil.validateConditionDataExistException(names.isEmpty(), TextUtil.CONVENTION_NAME_EQUIVALENCE_EXISTS, details, field);
+ }
+
+}
diff --git a/src/main/java/org/openepics/names/util/ValidateStructureElementUtil.java b/src/main/java/org/openepics/names/util/ValidateStructureElementUtil.java
new file mode 100644
index 0000000000000000000000000000000000000000..352c4e1265244d1d586ee07cbea2ec1301e42797
--- /dev/null
+++ b/src/main/java/org/openepics/names/util/ValidateStructureElementUtil.java
@@ -0,0 +1,892 @@
+/*
+ * 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.util;
+
+import java.util.List;
+import java.util.UUID;
+
+import org.apache.commons.lang3.StringUtils;
+import org.openepics.names.repository.model.Discipline;
+import org.openepics.names.repository.model.System;
+import org.openepics.names.repository.model.SystemGroup;
+import org.openepics.names.rest.beans.FieldStructure;
+import org.openepics.names.rest.beans.Status;
+import org.openepics.names.rest.beans.Type;
+import org.openepics.names.rest.beans.element.StructureElementCommand;
+import org.openepics.names.service.exception.DataConflictException;
+
+import com.google.common.collect.Lists;
+
+/**
+ * Utility class to assist in handling of validation.
+ *
+ * @author Lars Johansson
+ */
+public class ValidateStructureElementUtil {
+
+ // note
+ // handling of system structure, device structure
+ // parent system structure uuid (system group, system, subsystem)
+ // parent device structure uuid (device type)
+ //
+ // StructureElement
+ // type, uuid, parent uuid,
+ // name, mnemonic, mnemonic path, level,
+ // description, status, latest, deleted, when, who, comment
+ //
+ // StructureElementCommand
+ // create - type, parent, name, mnemonic, description, comment
+ // update - uuid, type, parent, name, mnemonic, description, comment
+ // delete - uuid, type comment
+
+ private enum StructureChoice {CREATE, UPDATE, DELETE, APPROVE, REJECT, CANCEL}
+
+ /**
+ * This class is not to be instantiated.
+ */
+ private ValidateStructureElementUtil() {
+ throw new IllegalStateException("Utility class");
+ }
+
+ /**
+ * Validate parameters for read structures.
+ *
+ * @param type type
+ * @param statuses statuses
+ * @param deleted deleted
+ * @param queryFields query fields
+ * @param queryValues query values
+ * @param includeHistory include history
+ * @param orderBy order by
+ * @param isAsc is ascending
+ * @param offset offset
+ * @param limit limit
+ */
+ public static void validateStructuresInputRead(
+ Type type, Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues,
+ Boolean includeHistory,
+ FieldStructure orderBy, Boolean isAsc,
+ Integer offset, Integer limit) {
+
+ // validate input
+ // type
+ // queryFields and queryValues
+ // either
+ // both null
+ // both non-null, same length, non-empty
+ // uuid
+
+ ValidateUtil.validateInputType(type);
+ boolean condition = ((queryFields == null && queryValues == null)
+ || (queryFields != null && queryValues != null && queryFields.length == queryValues.length && queryFields.length > 0));
+ ExceptionUtil.validateConditionInputNotCorrectException(condition,
+ TextUtil.VALUES_ARE_NOT_CORRECT, "url and parameters (queryFields, queryValues) have different lengths or are empty", null);
+
+ if (queryFields != null) {
+ for (int i=0; i<queryFields.length; i++) {
+ if (FieldStructure.UUID.equals(queryFields[i])) {
+ ValidateUtil.validateInputUuid(queryValues[i]);
+ }
+ }
+
+ }
+ }
+
+ /**
+ * Validate structure element parameters (input) for create.
+ *
+ * @param structureElement structure element
+ */
+ public static void validateStructureElementInputCreate(StructureElementCommand structureElement, EssNamingConvention namingConvention) {
+ validateStructureElementInput(structureElement, namingConvention, StructureChoice.CREATE);
+ }
+
+ /**
+ * Validate structure element parameters (input) for update.
+ *
+ * @param structureElement structure element
+ */
+ public static void validateStructureElementInputUpdate(StructureElementCommand structureElement, EssNamingConvention namingConvention) {
+ validateStructureElementInput(structureElement, namingConvention, StructureChoice.UPDATE);
+ }
+
+ /**
+ * Validate structure element parameters (input) for delete.
+ *
+ * @param structureElement structure element
+ */
+ public static void validateStructureElementInputDelete(StructureElementCommand structureElement, EssNamingConvention namingConvention) {
+ validateStructureElementInput(structureElement, namingConvention, StructureChoice.DELETE);
+ }
+
+ /**
+ * Validate structure element parameters (input) for approve.
+ *
+ * @param structureElement structure element
+ */
+ public static void validateStructureElementInputApprove(StructureElementCommand structureElement, EssNamingConvention namingConvention) {
+ validateStructureElementInput(structureElement, namingConvention, StructureChoice.APPROVE);
+ }
+
+ /**
+ * Validate structure element parameters (input) for cancel.
+ *
+ * @param structureElement structure element
+ */
+ public static void validateStructureElementInputCancel(StructureElementCommand structureElement, EssNamingConvention namingConvention) {
+ validateStructureElementInput(structureElement, namingConvention, StructureChoice.CANCEL);
+ }
+
+ /**
+ * Validate structure element parameters (input) for reject.
+ *
+ * @param structureElement structure element
+ */
+ public static void validateStructureElementInputReject(StructureElementCommand structureElement, EssNamingConvention namingConvention) {
+ validateStructureElementInput(structureElement, namingConvention, StructureChoice.REJECT);
+ }
+
+ /**
+ * Validate structure element parameters (input).
+ *
+ * @param structureElement structure element
+ * @param structureChoice structure choice
+ */
+ private static void validateStructureElementInput(StructureElementCommand structureElement, EssNamingConvention namingConvention, StructureChoice structureChoice) {
+ // check structure element input
+ // uuid - required if not create, required empty if create
+ // type - required
+ // parent (uuid) - also validate data, parent uuid available if type is system, subsystem, device group, device type
+ // name - required
+ // mnemonic - required except for device group
+ // description - required
+ // comment - required
+
+ if (structureElement == null || structureChoice == null) {
+ return;
+ }
+
+ Type type = structureElement.getType();
+ UUID uuid = structureElement.getUuid();
+ UUID parentUuid = structureElement.getParent();
+ String name = structureElement.getName();
+ String mnemonic = structureElement.getMnemonic();
+ String description = structureElement.getDescription();
+ String comment = structureElement.getComment();
+
+ if (StructureChoice.CREATE.equals(structureChoice)) {
+ ExceptionUtil.validateConditionInputNotEmptyException(uuid == null,
+ TextUtil.VALUE_IS_NOT_EMPTY,
+ uuid != null ? uuid.toString() : null,
+ TextUtil.UUID);
+ } else {
+ ValidateUtil.validateInputUuid(uuid != null ? uuid.toString() : null);
+ }
+
+ ValidateUtil.validateInputType(type);
+
+ if (!StructureChoice.DELETE.equals(structureChoice)) {
+ if (Type.SYSTEM.equals(type)
+ || Type.SUBSYSTEM.equals(type)
+ || Type.DEVICEGROUP.equals(type)
+ || Type.DEVICETYPE.equals(type)) {
+ ExceptionUtil.validateConditionInputNotAvailableException(parentUuid != null,
+ TextUtil.PARENT_IS_NOT_AVAILABLE, structureElement.toString(), TextUtil.PARENT);
+ ValidateUtil.validateInputUuid(parentUuid.toString());
+ }
+
+ ValidateUtil.validateInputName(name);
+
+ // validate mnemonic
+ // validate mnemonic input (value itself, not in relation to other values)
+ // validateMnemonic takes isMnemonicRequired into account
+ MnemonicValidation mnemonicValidation = namingConvention.validateMnemonic(type, mnemonic);
+ ExceptionUtil.validateConditionInputNotValidException(MnemonicValidation.VALID.equals(mnemonicValidation),
+ TextUtil.MNEMONIC_IS_NOT_VALID, structureElement.toString(), TextUtil.MNEMONIC);
+
+ ValidateUtil.validateInputDescription(description);
+ }
+
+ ValidateUtil.validateInputComment(comment);
+ }
+
+ // ----------------------------------------------------------------------------------------------------
+
+ /**
+ * Validate structure element data for create.
+ *
+ * @param structureElement structure element
+ * @param namingConvention naming convention
+ * @param holderRepositories holder repositories
+ * @param holder holder
+ */
+ public static void validateStructureElementDataCreate(StructureElementCommand structureElement, EssNamingConvention namingConvention, HolderRepositories holderRepositories, HolderSystemDeviceStructure holder) {
+ validateStructureElementDataInItself(structureElement, namingConvention, holderRepositories, holder, StructureChoice.CREATE);
+ validateStructureElementDataRelativeOtherData(structureElement, namingConvention, holderRepositories, holder, StructureChoice.CREATE);
+ }
+
+ /**
+ * Validate structure element data for update.
+ *
+ * @param structureElement structure element
+ * @param namingConvention naming convention
+ * @param holderRepositories holder repositories
+ * @param holder holder
+ */
+ public static void validateStructureElementDataUpdate(StructureElementCommand structureElement, EssNamingConvention namingConvention, HolderRepositories holderRepositories, HolderSystemDeviceStructure holder) {
+ validateStructureElementDataInItself(structureElement, namingConvention, holderRepositories, holder, StructureChoice.UPDATE);
+ validateStructureElementDataRelativeOtherData(structureElement, namingConvention, holderRepositories, holder, StructureChoice.UPDATE);
+ }
+
+ /**
+ * Validate structure element data for delete.
+ *
+ * @param structureElement structure element
+ * @param namingConvention naming convention
+ * @param holderRepositories holder repositories
+ * @param holder holder
+ */
+ public static void validateStructureElementDataDelete(StructureElementCommand structureElement, EssNamingConvention namingConvention, HolderRepositories holderRepositories, HolderSystemDeviceStructure holder) {
+ validateStructureElementDataInItself(structureElement, namingConvention, holderRepositories, holder, StructureChoice.DELETE);
+ validateStructureElementDataRelativeOtherData(structureElement, namingConvention, holderRepositories, holder, StructureChoice.DELETE);
+ }
+
+ /**
+ * Validate structure element data for approve.
+ *
+ * @param structureElement structure element
+ * @param namingConvention naming convention
+ * @param holderRepositories holder repositories
+ * @param holder holder
+ */
+ public static void validateStructureElementDataApprove(StructureElementCommand structureElement, EssNamingConvention namingConvention, HolderRepositories holderRepositories, HolderSystemDeviceStructure holder) {
+ validateStructureElementDataInItself(structureElement, namingConvention, holderRepositories, holder, StructureChoice.APPROVE);
+ validateStructureElementDataRelativeOtherData(structureElement, namingConvention, holderRepositories, holder, StructureChoice.APPROVE);
+ }
+
+ /**
+ * Validate structure element data for cancel.
+ *
+ * @param structureElement structure element
+ * @param namingConvention naming convention
+ * @param holderRepositories holder repositories
+ * @param holder holder
+ */
+ public static void validateStructureElementDataCancel(StructureElementCommand structureElement, EssNamingConvention namingConvention, HolderRepositories holderRepositories, HolderSystemDeviceStructure holder) {
+ validateStructureElementDataInItself(structureElement, namingConvention, holderRepositories, holder, StructureChoice.CANCEL);
+ validateStructureElementDataRelativeOtherData(structureElement, namingConvention, holderRepositories, holder, StructureChoice.CANCEL);
+ }
+
+ /**
+ * Validate structure element data for reject.
+ *
+ * @param structureElement structure element
+ * @param namingConvention naming convention
+ * @param holderRepositories holder repositories
+ * @param holder holder
+ */
+ public static void validateStructureElementDataReject(StructureElementCommand structureElement, EssNamingConvention namingConvention, HolderRepositories holderRepositories, HolderSystemDeviceStructure holder) {
+ validateStructureElementDataInItself(structureElement, namingConvention, holderRepositories, holder, StructureChoice.REJECT);
+ validateStructureElementDataRelativeOtherData(structureElement, namingConvention, holderRepositories, holder, StructureChoice.REJECT);
+ }
+
+ /**
+ * Validate structure element data in itself.
+ *
+ * @param structureElement
+ * @param namingConvention
+ * @param holderRepositories
+ * @param holder
+ * @param structureChoice
+ */
+ public static void validateStructureElementDataInItself(StructureElementCommand structureElement, EssNamingConvention namingConvention, HolderRepositories holderRepositories, HolderSystemDeviceStructure holder, StructureChoice structureChoice) {
+ // check structure element data in itself
+ // update, delete
+ // definitely (not possibly)
+ // no pending entry waiting to be approved, cancelled, rejected (pending with higher id than currently approved)
+ // uuid - approved, latest, not deleted - list size 1
+ // approve, reject, cancel
+ // uuid - pending, latest, not deleted - list size 1
+
+ if (structureElement == null || namingConvention == null || holderRepositories == null || holder == null || structureChoice == null) {
+ return;
+ }
+
+ String message = structureElement.getType().toString().toLowerCase() + TextUtil.SPACE + TextUtil.IS_NOT_CORRECT;
+ String details = structureElement.toString();
+ String field = TextUtil.UUID;
+
+ // validate data in itself
+ // systemgroup, discipline
+ // not have parent
+ // update, delete
+ // entry not pending
+ // entry approved and not deleted
+ // approve, cancel, reject
+ // entry pending
+
+ Type type = structureElement.getType();
+ UUID uuid = structureElement.getUuid();
+ UUID parentUuid = structureElement.getParent();
+
+ if ((Type.SYSTEMGROUP.equals(type) || Type.DISCIPLINE.equals(type))
+ && parentUuid != null) {
+ throw ExceptionUtil.createDataNotCorrectException(TextUtil.PARENT_IS_NOT_CORRECT, details, field);
+ } else if (StructureChoice.UPDATE.equals(structureChoice) || StructureChoice.DELETE.equals(structureChoice)) {
+ validateStructuresStatusSize0(
+ uuid, type, Status.PENDING, null,
+ holderRepositories, message, details, field);
+
+ validateStructuresStatusSize1(
+ uuid, type, Status.APPROVED, Boolean.FALSE,
+ holderRepositories, message, details, field);
+ } else if (StructureChoice.APPROVE.equals(structureChoice) || StructureChoice.CANCEL.equals(structureChoice) || StructureChoice.REJECT.equals(structureChoice)) {
+ validateStructuresStatusSize1(
+ uuid, type, Status.PENDING, null,
+ holderRepositories, message, details, field);
+ }
+ }
+
+ private static void validateStructuresStatusSize0(UUID uuid, Type type, Status status, Boolean deleted,
+ HolderRepositories holderRepositories, String message, String details, String field) {
+ ExceptionUtil.validateConditionDataNotCorrectException(
+ getStructuresSize(uuid, type, status, deleted, holderRepositories) == 0, message, details, field);
+ }
+ private static void validateStructuresStatusSize1(UUID uuid, Type type, Status status, Boolean deleted,
+ HolderRepositories holderRepositories, String message, String details, String field) {
+ ExceptionUtil.validateConditionDataNotCorrectException(
+ getStructuresSize(uuid, type, status, deleted, holderRepositories) == 1, message, details, field);
+ }
+ private static int getStructuresSize(UUID uuid, Type type, Status status, Boolean deleted,
+ HolderRepositories holderRepositories) {
+ if (Type.SYSTEMGROUP.equals(type)) {
+ return holderRepositories.getSystemGroupRepository().readSystemGroups(status, deleted, FieldStructure.UUID, uuid.toString()).size();
+ } else if (Type.SYSTEM.equals(type)) {
+ return holderRepositories.getSystemRepository().readSystems(status, deleted, FieldStructure.UUID, uuid.toString()).size();
+ } else if (Type.SUBSYSTEM.equals(type)) {
+ return holderRepositories.getSubsystemRepository().readSubsystems(status, deleted, FieldStructure.UUID, uuid.toString()).size();
+ } else if (Type.DISCIPLINE.equals(type)) {
+ return holderRepositories.getDisciplineRepository().readDisciplines(status, deleted, FieldStructure.UUID, uuid.toString()).size();
+ } else if (Type.DEVICEGROUP.equals(type)) {
+ return holderRepositories.getDeviceGroupRepository().readDeviceGroups(status, deleted, FieldStructure.UUID, uuid.toString()).size();
+ } else if (Type.DEVICETYPE.equals(type)) {
+ return holderRepositories.getDeviceTypeRepository().readDeviceTypes(status, deleted, FieldStructure.UUID, uuid.toString()).size();
+ }
+ return 0;
+ }
+
+ /**
+ * Validate structure element data relative other data.
+ *
+ * @param structureElement structure element
+ * @param namingConvention naming convention
+ * @param holderRepositories holder repositories
+ * @param holder holder
+ * @param structureChoice structure choice
+ */
+ public static void validateStructureElementDataRelativeOtherData(StructureElementCommand structureElement, EssNamingConvention namingConvention, HolderRepositories holderRepositories, HolderSystemDeviceStructure holder, StructureChoice structureChoice) {
+ // check structure element data in relation to other data
+ // create, update
+ // parent uuid - (if applicable) approved, latest, not deleted
+ // mnemonic - (if not same) not exists
+ // mnemonic equivalence - (if not same) equivalence not exists
+ // approve
+ // uuid - pending, not latest, deleted
+ // no or less checks if entry to be deleted - approve (delete)
+ // more or same checks as above if entry is not be deleted - approve (create), approve (update)
+ // need checks as content may have changed from time of create, update, delete to time of approve
+ // checks on mnemonic, mnemonic equivalence are to ensure can coexist, can move
+ // possibly
+ // additional checks if names are affected
+ // comment not same as previous comment
+
+ if (structureElement == null || namingConvention == null || holderRepositories == null || holder == null || structureChoice == null) {
+ return;
+ }
+
+ String message = null;
+ String details = structureElement.toString();
+ String field = TextUtil.MNEMONIC;
+
+ // validate data relative other data
+ // create, update
+ // entry (uuid,) status, mnemonic
+ // entry (uuid,) status, mnemonic equivalence
+ // approve
+ // entry uuid, status
+
+ Type type = structureElement.getType();
+ UUID uuid = structureElement.getUuid();
+ UUID parentUuid = structureElement.getParent();
+ String mnemonic = structureElement.getMnemonic();
+
+ if (StructureChoice.CREATE.equals(structureChoice) || StructureChoice.UPDATE.equals(structureChoice)) {
+ if (Type.SYSTEMGROUP.equals(type)) {
+ // note rules for mnemonic for system group
+ if (!StringUtils.isEmpty(mnemonic)) {
+ // status, mnemonic
+ message = TextUtil.SYSTEMGROUP_IS_NOT_CORRECT;
+ validateStructuresStatusMnemonic(uuid, type, parentUuid, mnemonic,
+ namingConvention, holderRepositories, structureChoice, message, details, field);
+
+ // status, mnemonic equivalence
+ validateStructuresStatusMnemonicequivalence(uuid, type, parentUuid, mnemonic,
+ namingConvention, holderRepositories, structureChoice, message, details, field);
+ }
+ } else if (Type.SYSTEM.equals(type)) {
+ // status, parent
+ message = TextUtil.SYSTEMGROUP_IS_NOT_CORRECT;
+ validateStructuresParent(type, parentUuid, Status.APPROVED, false,
+ holderRepositories, message, details, field);
+
+ // status, mnemonic
+ message = TextUtil.SYSTEM_IS_NOT_CORRECT;
+ validateStructuresStatusMnemonic(uuid, type, parentUuid, mnemonic,
+ namingConvention, holderRepositories, structureChoice, message, details, field);
+
+ // status, mnemonic equivalence
+ validateStructuresStatusMnemonicequivalence(uuid, type, parentUuid, mnemonic,
+ namingConvention, holderRepositories, structureChoice, message, details, field);
+ } else if (Type.SUBSYSTEM.equals(type)) {
+ // status, parent
+ message = TextUtil.SYSTEM_IS_NOT_CORRECT;
+ validateStructuresParent(type, parentUuid, Status.APPROVED, false,
+ holderRepositories, message, details, field);
+
+ // status, mnemonic
+ message = TextUtil.SUBSYSTEM_IS_NOT_CORRECT;
+ validateStructuresStatusMnemonic(uuid, type, parentUuid, mnemonic,
+ namingConvention, holderRepositories, structureChoice, message, details, field);
+
+ // status, mnemonic equivalence
+ validateStructuresStatusMnemonicequivalence(uuid, type, parentUuid, mnemonic,
+ namingConvention, holderRepositories, structureChoice, message, details, field);
+ } else if (Type.DISCIPLINE.equals(type)) {
+ message = TextUtil.DISCIPLINE_IS_NOT_CORRECT;
+
+ // status, mnemonic
+ validateStructuresStatusMnemonic(uuid, type, parentUuid, mnemonic,
+ namingConvention, holderRepositories, structureChoice, message, details, field);
+
+ // status, mnemonic equivalence
+ validateStructuresStatusMnemonicequivalence(uuid, type, parentUuid, mnemonic,
+ namingConvention, holderRepositories, structureChoice, message, details, field);
+ } else if (Type.DEVICEGROUP.equals(type)) {
+ // status, parent
+ message = TextUtil.DISCIPLINE_IS_NOT_CORRECT;
+ List<Discipline> disciplines = holderRepositories.getDisciplineRepository().readDisciplines(Status.APPROVED, false, FieldStructure.UUID, parentUuid.toString());
+ ExceptionUtil.validateConditionDataConflictException(disciplines != null && disciplines.size() == 1, message, details, TextUtil.PARENT);
+
+ // note rules for mnemonic for device group
+
+ // mnemonic
+ message = TextUtil.DEVICEGROUP_IS_NOT_CORRECT;
+ ExceptionUtil.validateConditionDataConflictException(StringUtils.isEmpty(mnemonic), message, details, field);
+ } else if (Type.DEVICETYPE.equals(type)) {
+ // status, parent
+ message = TextUtil.DEVICEGROUP_IS_NOT_CORRECT;
+ validateStructuresParent(type, parentUuid, Status.APPROVED, false,
+ holderRepositories, message, details, field);
+
+ // status, mnemonic
+ message = TextUtil.DEVICETYPE_IS_NOT_CORRECT;
+ validateStructuresStatusMnemonic(uuid, type, parentUuid, mnemonic,
+ namingConvention, holderRepositories, structureChoice, message, details, field);
+
+ // status, mnemonic equivalence
+ validateStructuresStatusMnemonicequivalence(uuid, type, parentUuid, mnemonic,
+ namingConvention, holderRepositories, structureChoice, message, details, field);
+ }
+ } else if (StructureChoice.APPROVE.equals(structureChoice)) {
+ // possibly additional checks to ensure (status, mnemonic) and (status, mnemonic equivalence)
+ // however that would be duplicate checks as already checked at time of create, update
+
+ if (Type.SYSTEMGROUP.equals(type)) {
+ // status, uuid
+ message = TextUtil.SYSTEMGROUP_IS_NOT_CORRECT;
+ validateStructuresStatusSize1(uuid, type, Status.PENDING, null,
+ holderRepositories, message, details, field);
+ } else if (Type.SYSTEM.equals(type)) {
+ // status, parent
+ message = TextUtil.SYSTEMGROUP_IS_NOT_CORRECT;
+ validateStructuresStatusSize1(parentUuid, Type.SYSTEMGROUP, Status.APPROVED, false,
+ holderRepositories, message, details, field);
+
+ // status, uuid
+ message = TextUtil.SYSTEM_IS_NOT_CORRECT;
+ validateStructuresStatusSize1(uuid, type, Status.PENDING, null,
+ holderRepositories, message, details, field);
+ } else if (Type.SUBSYSTEM.equals(type)) {
+ // status, parent
+ message = TextUtil.SYSTEM_IS_NOT_CORRECT;
+ validateStructuresStatusSize1(parentUuid, Type.SYSTEM, Status.APPROVED, false,
+ holderRepositories, message, details, field);
+
+ // status, uuid
+ message = TextUtil.SUBSYSTEM_IS_NOT_CORRECT;
+ validateStructuresStatusSize1(uuid, type, Status.PENDING, null,
+ holderRepositories, message, details, field);
+ } else if (Type.DISCIPLINE.equals(type)) {
+ // status, uuid
+ message = TextUtil.DISCIPLINE_IS_NOT_CORRECT;
+ validateStructuresStatusSize1(uuid, type, Status.PENDING, null,
+ holderRepositories, message, details, field);
+ } else if (Type.DEVICEGROUP.equals(type)) {
+ // status, parent
+ message = TextUtil.DISCIPLINE_IS_NOT_CORRECT;
+ validateStructuresStatusSize1(parentUuid, Type.DISCIPLINE, Status.APPROVED, false,
+ holderRepositories, message, details, field);
+
+ // status, uuid
+ message = TextUtil.DEVICEGROUP_IS_NOT_CORRECT;
+ validateStructuresStatusSize1(uuid, type, Status.PENDING, null,
+ holderRepositories, message, details, field);
+
+ // no mnemonic for device group
+ ExceptionUtil.validateConditionDataConflictException(StringUtils.isEmpty(mnemonic), message, details, field);
+ } else if (Type.DEVICETYPE.equals(type)) {
+ // status, parent
+ message = TextUtil.DISCIPLINE_IS_NOT_CORRECT;
+ validateStructuresStatusSize1(parentUuid, Type.DEVICEGROUP, Status.APPROVED, false,
+ holderRepositories, message, details, field);
+
+ // status, uuid
+ message = TextUtil.DEVICETYPE_IS_NOT_CORRECT;
+ validateStructuresStatusSize1(uuid, type, Status.PENDING, null,
+ holderRepositories, message, details, field);
+ }
+ }
+ }
+
+ private static void validateStructuresParent(Type type, UUID parent, Status status, Boolean deleted,
+ HolderRepositories holderRepositories, String message, String details, String field){
+ ExceptionUtil.validateConditionDataConflictException(
+ getStructuresParentSize(type, parent, status, deleted, holderRepositories) == 1, message, details, field);
+ }
+ private static void validateStructuresStatusMnemonic(UUID uuid, Type type, UUID parent, String mnemonic,
+ EssNamingConvention namingConvention, HolderRepositories holderRepositories, StructureChoice structureChoice,
+ String message, String details, String field){
+
+ // parent may be null
+ List<UUID> listUuid = null;
+
+ listUuid = getStructures(type, parent, mnemonic, Status.PENDING, false, false, namingConvention, holderRepositories);
+ validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, listUuid.isEmpty(), message, details, field);
+ validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, listUuid.isEmpty() || listUuid.size() == 1 && listUuid.get(0).equals(uuid), message, details, field);
+
+ listUuid = getStructures(type, parent, mnemonic, Status.APPROVED, false, false, namingConvention, holderRepositories);
+ validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, listUuid.isEmpty(), message, details, field);
+ validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, listUuid.isEmpty() || listUuid.size() == 1 && listUuid.get(0).equals(uuid), message, details, field);
+ }
+ private static void validateStructuresStatusMnemonicequivalence(UUID uuid, Type type, UUID parent, String mnemonic,
+ EssNamingConvention namingConvention, HolderRepositories holderRepositories, StructureChoice structureChoice,
+ String message, String details, String field){
+
+ // parent may be null
+ List<UUID> listUuid = null;
+
+ listUuid = getStructures(type, parent, mnemonic, Status.PENDING, false, true, namingConvention, holderRepositories);
+ validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, listUuid.isEmpty(), message, details, field);
+ validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, listUuid.isEmpty() || listUuid.size() == 1 && listUuid.get(0).equals(uuid), message, details, field);
+
+ listUuid = getStructures(type, parent, mnemonic, Status.APPROVED, false, true, namingConvention, holderRepositories);
+ validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, listUuid.isEmpty(), message, details, field);
+ validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, listUuid.isEmpty() || listUuid.size() == 1 && listUuid.get(0).equals(uuid), message, details, field);
+ }
+ private static int getStructuresParentSize(Type type, UUID parent, Status status, Boolean deleted,
+ HolderRepositories holderRepositories) {
+ String queryValue = parent.toString();
+ if (Type.SYSTEM.equals(type)) {
+ return holderRepositories.getSystemGroupRepository().readSystemGroups(status, deleted, FieldStructure.UUID, queryValue).size();
+ } else if (Type.SUBSYSTEM.equals(type)) {
+ return holderRepositories.getSystemRepository().readSystems(status, deleted, FieldStructure.UUID, queryValue).size();
+ } else if (Type.DEVICEGROUP.equals(type)) {
+ return holderRepositories.getDisciplineRepository().readDisciplines(status, deleted, FieldStructure.UUID, queryValue).size();
+ } else if (Type.DEVICETYPE.equals(type)) {
+ return holderRepositories.getDeviceGroupRepository().readDeviceGroups(status, deleted, FieldStructure.UUID, queryValue).size();
+ }
+ return 0;
+ }
+ private static List<UUID> getStructures(Type type, UUID parent, String mnemonic, Status status, Boolean deleted, Boolean equivalence,
+ EssNamingConvention namingConvention, HolderRepositories holderRepositories) {
+
+ boolean hasMnemonic = !StringUtils.isEmpty(mnemonic);
+ FieldStructure mnemonicField = null;
+ String mnemonicValue = null;
+ if (hasMnemonic) {
+ mnemonicField = Boolean.TRUE.equals(equivalence)
+ ? FieldStructure.MNEMONICEQUIVALENCE
+ : FieldStructure.MNEMONIC;
+ mnemonicValue = Boolean.TRUE.equals(equivalence)
+ ? namingConvention.equivalenceClassRepresentative(mnemonic)
+ : mnemonic;
+ }
+
+ // uuid, parent, mnemonic
+ boolean queryParentTable = false;
+ FieldStructure[] queryFields = null;
+ String[] queryValues = null;
+ if (Type.SYSTEMGROUP.equals(type) || Type.DISCIPLINE.equals(type)) {
+ // no parent - query table for type
+ if (hasMnemonic) {
+ queryFields = new FieldStructure[]{mnemonicField};
+ queryValues = new String[]{mnemonicValue};
+ } else {
+ return Lists.newArrayList();
+ }
+ } else {
+ // parent
+ if (hasMnemonic) {
+ // query table for type
+ queryFields = new FieldStructure[]{FieldStructure.PARENT, mnemonicField};
+ queryValues = new String[]{parent.toString(), mnemonicValue};
+ } else {
+ // query table for parent to type
+ queryParentTable = true;
+ queryFields = new FieldStructure[]{FieldStructure.UUID};
+ queryValues = new String[]{parent.toString()};
+ }
+ }
+
+ // query table and return list with uuid
+ if (Type.SYSTEMGROUP.equals(type)) {
+ return StructureUtil.listSystemGroup2Uuid(holderRepositories.getSystemGroupRepository().readSystemGroups(status, deleted, queryFields, queryValues));
+ } else if (Type.SYSTEM.equals(type)) {
+ if (queryParentTable) {
+ return StructureUtil.listSystemGroup2Uuid(holderRepositories.getSystemGroupRepository().readSystemGroups(status, deleted, queryFields, queryValues));
+ } else {
+ return StructureUtil.listSystem2Uuid(holderRepositories.getSystemRepository().readSystems(status, deleted, queryFields, queryValues));
+ }
+ } else if (Type.SUBSYSTEM.equals(type)) {
+ if (queryParentTable) {
+ return StructureUtil.listSystem2Uuid(holderRepositories.getSystemRepository().readSystems(status, deleted, queryFields, queryValues));
+ } else {
+ return StructureUtil.listSubsystem2Uuid(holderRepositories.getSubsystemRepository().readSubsystems(status, deleted, queryFields, queryValues));
+ }
+ } else if (Type.DISCIPLINE.equals(type)) {
+ return StructureUtil.listDiscipline2Uuid(holderRepositories.getDisciplineRepository().readDisciplines(status, deleted, queryFields, queryValues));
+ } else if (Type.DEVICEGROUP.equals(type)) {
+ if (queryParentTable) {
+ return StructureUtil.listDiscipline2Uuid(holderRepositories.getDisciplineRepository().readDisciplines(status, deleted, queryFields, queryValues));
+ } else {
+ return StructureUtil.listDeviceGroup2Uuid(holderRepositories.getDeviceGroupRepository().readDeviceGroups(status, deleted, queryFields, queryValues)); }
+ } else if (Type.DEVICETYPE.equals(type)) {
+ if (queryParentTable) {
+ return StructureUtil.listDeviceGroup2Uuid(holderRepositories.getDeviceGroupRepository().readDeviceGroups(status, deleted, queryFields, queryValues));
+ } else {
+ return StructureUtil.listDeviceType2Uuid(holderRepositories.getDeviceTypeRepository().readDeviceTypes(status, deleted, queryFields, queryValues));
+ }
+ }
+ return Lists.newArrayList();
+ }
+
+ // ----------------------------------------------------------------------------------------------------
+
+ /**
+ * Validate structure data.
+ * This method corresponds to structure element data for create, albeit in a different way.
+ *
+ * @param type type
+ * @param mnemonicpath mnemonic path
+ * @param namingConvention naming convention
+ * @param holderIRepositories holder repositories
+ * @param holder holder
+ */
+ public static void validateStructureDataCreate(Type type, String mnemonicpath, EssNamingConvention namingConvention, HolderIRepositories holderIRepositories, HolderSystemDeviceStructure holder) {
+ if (type == null || mnemonicpath == null || namingConvention == null || holderIRepositories == null || holder == null) {
+ return;
+ }
+
+ String details = mnemonicpath;
+ String field = TextUtil.MNEMONIC_PATH;
+
+ String[] path = NamingConventionUtil.string2MnemonicPath(mnemonicpath);
+ ExceptionUtil.validateConditionDataNotValidException(path != null && path.length >= 1 && path.length <= 2,
+ TextUtil.STRUCTURE_MNEMONIC_PATH_IS_NOT_VALID, details, field);
+ String mnemonicpathEquivalence = namingConvention.equivalenceClassRepresentative(mnemonicpath);
+
+ if (Type.SYSTEMGROUP.equals(type)) {
+ validateStructuresMnemonicpathNotValid(type, path.length == 1, details, field);
+
+ // system group may have empty path but there will be mnemonicpath in this context
+
+ // mnemonic path
+ SystemGroup sg = holderIRepositories.getSystemGroupRepository().findLatestNotDeletedByMnemonic(path[0]);
+ validateStructuresMnemonicpathDuplicate(type, sg == null, details, field);
+
+ // mnemonic path equivalence
+ List<SystemGroup> systemGroups = holderIRepositories.getSystemGroupRepository().findLatestNotDeleted();
+ for (SystemGroup systemGroup : systemGroups) {
+ validateStructuresMnemonicpathequivalenceDuplicate(type, !StringUtils.equals(systemGroup.getMnemonicEquivalence(), namingConvention.equivalenceClassRepresentative(path[0])), details, field);
+ }
+ } else if (Type.SYSTEM.equals(type)) {
+ validateStructuresMnemonicpathNotValid(type, path.length == 1, details, field);
+
+ // path with 1 element - system group or system ---> check both individually
+ // check mnemonic, mnemonic equivalence
+
+ // mnemonic path system group
+ List<String> mnemonicPaths = StructureUtil.getMnemonicPathsSystemGroup(holder, false, namingConvention);
+ for (String existingPath : mnemonicPaths) {
+ validateStructuresMnemonicpathDuplicate(type, !StringUtils.equals(mnemonicpath, existingPath), details, field);
+ }
+
+ // mnemonic path equivalence system group
+ mnemonicPaths = StructureUtil.getMnemonicPathsSystemGroup(holder, true, namingConvention);
+ for (String existingPath : mnemonicPaths) {
+ validateStructuresMnemonicpathequivalenceDuplicate(type, !StringUtils.equals(mnemonicpathEquivalence, namingConvention.equivalenceClassRepresentative(existingPath)), details, field);
+ }
+
+ // mnemonic path
+ mnemonicPaths = StructureUtil.getMnemonicPathsSystem(holder, false, namingConvention);
+ for (String existingPath : mnemonicPaths) {
+ validateStructuresMnemonicpathDuplicate(type, !StringUtils.equals(mnemonicpath, existingPath), details, field);
+ }
+
+ // mnemonic path equivalence
+ mnemonicPaths = StructureUtil.getMnemonicPathsSystem(holder, true, namingConvention);
+ for (String existingPath : mnemonicPaths) {
+ validateStructuresMnemonicpathequivalenceDuplicate(type, !StringUtils.equals(mnemonicpathEquivalence, namingConvention.equivalenceClassRepresentative(existingPath)), details, field);
+ }
+ } else if (Type.SUBSYSTEM.equals(type)) {
+ validateStructuresMnemonicpathNotValid(type, path.length == 2, details, field);
+
+ System sys = holderIRepositories.getSystemRepository().findLatestNotDeletedByMnemonic(path[0]);
+ validateStructuresMnemonicpathNotAvailable(type, sys != null, details, field);
+ SystemGroup sg = holderIRepositories.getSystemGroupRepository().findLatestNotDeletedByUuid(sys.getParentUuid().toString());
+
+ // mnemonic path
+ validateStructuresMnemonicpathDuplicate(type, !StringUtils.equals(path[0], path[1]), details, field);
+ if (!StringUtils.isEmpty(sg.getMnemonic())) {
+ validateStructuresMnemonicpathDuplicate(type, !StringUtils.equals(sg.getMnemonic(), path[1]), details, field);
+ }
+
+ List<String> mnemonicPaths = StructureUtil.getMnemonicPathsSubsystem(holder, false, namingConvention);
+ for (String existingPath : mnemonicPaths) {
+ validateStructuresMnemonicpathDuplicate(type, !StringUtils.equals(mnemonicpath, existingPath), details, field);
+ }
+
+ // mnemonic path equivalence
+ validateStructuresMnemonicpathDuplicate(type, !StringUtils.equals(namingConvention.equivalenceClassRepresentative(path[0]), namingConvention.equivalenceClassRepresentative(path[1])), details, field);
+ if (!StringUtils.isEmpty(sg.getMnemonic())) {
+ validateStructuresMnemonicpathDuplicate(type, !StringUtils.equals(namingConvention.equivalenceClassRepresentative(sg.getMnemonic()), namingConvention.equivalenceClassRepresentative(path[1])), details, field);
+ }
+
+ mnemonicPaths = StructureUtil.getMnemonicPathsSubsystem(holder, true, namingConvention);
+ for (String existingPath : mnemonicPaths) {
+ validateStructuresMnemonicpathequivalenceDuplicate(type, !StringUtils.equals(mnemonicpathEquivalence, namingConvention.equivalenceClassRepresentative(existingPath)), details, field); }
+ } else if (Type.DISCIPLINE.equals(type)) {
+ validateStructuresMnemonicpathNotValid(type, path.length == 1, details, field);
+
+ // mnemonic path
+ Discipline di = holderIRepositories.getDisciplineRepository().findLatestNotDeletedByMnemonic(path[0]);
+ validateStructuresMnemonicpathDuplicate(type, di == null, details, field);
+
+ // mnemonic path equivalence
+ List<Discipline> disciplines = holderIRepositories.getDisciplineRepository().findLatestNotDeleted();
+ for (Discipline discipline : disciplines) {
+ validateStructuresMnemonicpathequivalenceDuplicate(type, !StringUtils.equals(discipline.getMnemonicEquivalence(), namingConvention.equivalenceClassRepresentative(path[0])), details, field);
+ }
+ } else if (Type.DEVICEGROUP.equals(type)) {
+ throw ExceptionUtil.createDataNotValidException(TextUtil.DEVICEGROUP_IS_NOT_VALID, details, field);
+ } else if (Type.DEVICETYPE.equals(type)) {
+ // since device group is between discipline and device type and device group has no mnemonic,
+ // it can not be traced to which device group that this device type belongs,
+ // therefore it can not be known to which mnemonic line it belongs
+ // by looking at mnemonic
+ // instead similar approach as for other Type, i.e. compare with list of mnemonic paths
+ // rest of checks in validatecreate
+
+ validateStructuresMnemonicpathNotValid(type, path.length == 2, details, field);
+
+ // discipline
+ Discipline discipline = holderIRepositories.getDisciplineRepository().findLatestNotDeletedByMnemonic(path[0]);
+ ExceptionUtil.validateConditionDataNotValidException(discipline != null,
+ TextUtil.DISCIPLINE_IS_NOT_VALID, details, field);
+
+ // mnemonic path
+ validateStructuresMnemonicpathDuplicate(type, !StringUtils.equals(path[0], path[1]), details, field);
+
+ List<String> mnemonicPaths = StructureUtil.getMnemonicPathsDeviceType(holder, false, namingConvention);
+ for (String existingPath : mnemonicPaths) {
+ validateStructuresMnemonicpathDuplicate(type, !StringUtils.equals(mnemonicpath, existingPath), details, field);
+ }
+
+ // mnemonic path equivalence
+ validateStructuresMnemonicpathDuplicate(type, !StringUtils.equals(namingConvention.equivalenceClassRepresentative(path[0]), namingConvention.equivalenceClassRepresentative(path[1])), details, field);
+
+ mnemonicPaths = StructureUtil.getMnemonicPathsDeviceType(holder, true, namingConvention);
+ for (String existingPath : mnemonicPaths) {
+ validateStructuresMnemonicpathequivalenceDuplicate(type, !StringUtils.equals(mnemonicpathEquivalence, namingConvention.equivalenceClassRepresentative(existingPath)), details, field);
+ }
+ }
+ }
+
+ private static void validateStructuresMnemonicpathNotAvailable(Type type, boolean condition, String details, String field) {
+ ExceptionUtil.validateConditionDataNotValidException(condition,
+ type.toString().toLowerCase() + TextUtil.SPACE + TextUtil.MNEMONIC_PATH_IS_NOT_AVAILABLE, details, field);
+ }
+ private static void validateStructuresMnemonicpathNotValid(Type type, boolean condition, String details, String field) {
+ ExceptionUtil.validateConditionDataNotValidException(condition,
+ type.toString().toLowerCase() + TextUtil.SPACE + TextUtil.MNEMONIC_PATH_IS_NOT_VALID, details, field);
+ }
+ private static void validateStructuresMnemonicpathDuplicate(Type type, boolean condition, String details, String field) {
+ ExceptionUtil.validateConditionDataConflictException(condition,
+ type.toString().toLowerCase() + TextUtil.SPACE + TextUtil.MNEMONIC_PATH_HAS_DUPLICATE, details, field);
+ }
+ private static void validateStructuresMnemonicpathequivalenceDuplicate(Type type, boolean condition, String details, String field) {
+ ExceptionUtil.validateConditionDataConflictException(condition,
+ type.toString().toLowerCase() + TextUtil.SPACE + TextUtil.MNEMONIC_PATH_EQUIVALENCE_HAS_DUPLICATE, details, field);
+ }
+
+ // ----------------------------------------------------------------------------------------------------
+
+ /**
+ * Validate condition if precondition is fulfilled and throw data conflict exception with reason if validation fails.
+ *
+ * @param precondition precondition
+ * @param condition condition
+ * @param message message
+ * @param details details
+ * @param field field
+ *
+ * @see DataConflictException
+ */
+ private static void validateConditionIfPrecondition(boolean precondition, boolean condition, String message, String details, String field) {
+ if (precondition) {
+ ExceptionUtil.validateConditionDataConflictException(condition, message, details, field);
+ }
+ }
+
+ /**
+ * 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 message message
+ * @param details details
+ * @param field field
+ *
+ * @see DataConflictException
+ */
+ 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/main/java/org/openepics/names/util/ValidateUtil.java b/src/main/java/org/openepics/names/util/ValidateUtil.java
index 70d11e3913e89f74f2c6c3c8811734aec4a4d32d..71c7f7b71c67bde90a2ecef9ac34ed5397d0c428 100644
--- a/src/main/java/org/openepics/names/util/ValidateUtil.java
+++ b/src/main/java/org/openepics/names/util/ValidateUtil.java
@@ -18,26 +18,11 @@
package org.openepics.names.util;
-import java.util.List;
import java.util.UUID;
import org.apache.commons.lang3.StringUtils;
-import org.openepics.names.repository.NameRepository;
-import org.openepics.names.repository.model.DeviceType;
-import org.openepics.names.repository.model.Discipline;
-import org.openepics.names.repository.model.Name;
-import org.openepics.names.repository.model.Subsystem;
-import org.openepics.names.repository.model.System;
-import org.openepics.names.repository.model.SystemGroup;
-import org.openepics.names.rest.beans.FieldName;
-import org.openepics.names.rest.beans.FieldStructure;
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.openepics.names.service.exception.DataConflictException;
-
-import com.google.common.collect.Lists;
/**
* Utility class to assist in handling of validation.
@@ -46,33 +31,6 @@ import com.google.common.collect.Lists;
*/
public class ValidateUtil {
- // note
- // handling of system structure, device structure
- // parent system structure uuid (system group, system, subsystem)
- // parent device structure uuid (device type)
- //
- // NameElement
- // uuid,
- // systemgroup, system, subsystem, devicetype, systemstructure, devicestructure,
- // index, name,
- // description, status, latest, deleted, when, who, comment
- // StructureElement
- // type, uuid, parent uuid,
- // name, mnemonic, mnemonic path, level,
- // description, status, latest, deleted, when, who, comment
- //
- // NameElementCommand
- // create - parentsystemstructure, parentdevicestructure (optional), index, description, comment
- // update - uuid, parentsystemstructure, parentdevicestructure (optional), index, description, comment
- // delete - uuid, comment
- // StructureElementCommand
- // create - type, parent, name, mnemonic, description, comment
- // update - uuid, type, parent, name, mnemonic, description, comment
- // delete - uuid, type comment
-
- private enum NameChoice {CREATE, UPDATE, DELETE}
- private enum StructureChoice {CREATE, UPDATE, DELETE, APPROVE, REJECT, CANCEL}
-
/**
* This class is not to be instantiated.
*/
@@ -217,1216 +175,4 @@ public class ValidateUtil {
}
}
- // ----------------------------------------------------------------------------------------------------
-
- /**
- * Validate parameters for read names.
- *
- * @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
- * @param includeHistory include history
- * @param orderBy order by
- * @param isAsc is ascending
- * @param offset offset
- * @param limit limit
- */
- public static void validateNamesInputRead(
- Boolean deleted, FieldName[] queryFields, String[] queryValues,
- Boolean includeHistory,
- FieldName orderBy, Boolean isAsc,
- Integer offset, Integer limit) {
-
- // validate input
- // queryFields and queryValues
- // either
- // both null
- // both non-null, same length, non-empty
- // uuid
-
- boolean condition = ((queryFields == null && queryValues == null)
- || (queryFields != null && queryValues != null && queryFields.length == queryValues.length && queryFields.length > 0));
- ExceptionUtil.validateConditionInputNotCorrectException(condition,
- TextUtil.VALUES_ARE_NOT_CORRECT, "url and parameters (queryFields, queryValues) have different lengths or are empty", null);
-
- if (queryFields != null) {
- for (int i=0; i<queryFields.length; i++) {
- if (FieldName.UUID.equals(queryFields[i])) {
- ValidateUtil.validateInputUuid(queryValues[i]);
- }
- }
- }
- }
-
- /**
- * Validate name element parameters (input) for create.
- *
- * @param nameElement name element
- */
- public static void validateNameElementInputCreate(NameElementCommand nameElement) {
- validateNameElementInput(nameElement, NameChoice.CREATE);
- }
-
- /**
- * Validate name element parameters (input) for update.
- *
- * @param nameElement name element
- */
- public static void validateNameElementInputUpdate(NameElementCommand nameElement) {
- validateNameElementInput(nameElement, NameChoice.UPDATE);
- }
-
- /**
- * Validate name element parameters (input) for delete.
- *
- * @param nameElement name element
- */
- public static void validateNameElementInputDelete(NameElementCommand nameElement) {
- validateNameElementInput(nameElement, NameChoice.DELETE);
- }
-
- /**
- * Validate name element parameters (input).
- *
- * @param nameElement name element
- * @param nameChoice name choice
- */
- private static void validateNameElementInput(NameElementCommand nameElement, NameChoice nameChoice) {
- // attributes
- // uuid - required if not create, required empty if create
- // parentsystemstructure (uuid)
- // parentdevicestructure (uuid)
- // index
- // description
- // comment
-
- if (nameElement == null || nameChoice == null) {
- return;
- }
-
- if (NameChoice.CREATE.equals(nameChoice)) {
- ExceptionUtil.validateConditionInputNotEmptyException(nameElement.getUuid() == null,
- TextUtil.VALUE_IS_NOT_EMPTY,
- nameElement.getUuid() != null ? nameElement.getUuid().toString() : null,
- TextUtil.UUID);
- } else {
- validateInputUuid(nameElement.getUuid() != null ? nameElement.getUuid().toString() : null);
- }
-
- if (!NameChoice.DELETE.equals(nameChoice)) {
- ExceptionUtil.validateConditionInputNotAvailableException(nameElement.getParentsystemstructure() != null,
- TextUtil.VALUE_IS_NOT_AVAILABLE, nameElement.toString(), TextUtil.PARENTSYSTEMSTRUCTURE);
-
- // optional (either none or both)
- // parentdevicestructure
- // index
- if (nameElement.getParentdevicestructure() != null && nameElement.getIndex() == null) {
- throw ExceptionUtil.createInputNotCorrectException(null, nameElement.toString(), TextUtil.INDEX);
- } else if (nameElement.getParentdevicestructure() == null && nameElement.getIndex() != null) {
- throw ExceptionUtil.createInputNotCorrectException(null, nameElement.toString(), TextUtil.PARENTDEVICESTRUCTURE);
- }
-
- validateInputDescription(nameElement.getDescription());
- }
-
- validateInputComment(nameElement.getComment());
- }
-
- // ----------------------------------------------------------------------------------------------------
-
- /**
- * Validate name element data for create.
- *
- * @param nameElement name element
- * @param namingConvention naming convention
- * @param holderIRepositories holder repositories
- * @param nameRepository name repository
- * @param holder holder
- */
- public static void validateNameElementDataCreate(NameElementCommand nameElement, EssNamingConvention namingConvention, HolderIRepositories holderIRepositories, NameRepository nameRepository, HolderSystemDeviceStructure holder) {
- validateNameElementData(nameElement, namingConvention, holderIRepositories, nameRepository, holder, NameChoice.CREATE);
- }
-
- /**
- * Validate name element data for update.
- *
- * @param nameElement name element
- * @param namingConvention naming convention
- * @param holderIRepositories holder repositories
- * @param nameRepository name repositories
- * @param holder holder
- */
- public static void validateNameElementDataUpdate(NameElementCommand nameElement, EssNamingConvention namingConvention, HolderIRepositories holderIRepositories, NameRepository nameRepository, HolderSystemDeviceStructure holder) {
- validateNameElementData(nameElement, namingConvention, holderIRepositories, nameRepository, holder, NameChoice.UPDATE);
- }
-
- /**
- * Validate name element data for delete.
- *
- * @param nameElement name element
- * @param namingConvention naming convention
- * @param holderIRepositories holder repositories
- * @param nameRepository name repositories
- * @param holder holder
- */
- public static void validateNameElementDataDelete(NameElementCommand nameElement, EssNamingConvention namingConvention, HolderIRepositories holderIRepositories, NameRepository nameRepository, HolderSystemDeviceStructure holder) {
- validateNameElementData(nameElement, namingConvention, holderIRepositories, nameRepository, holder, NameChoice.DELETE);
- }
-
- /**
- * Validate name element data.
- *
- * @param nameElement name element
- * @param namingConvention naming convention
- * @param holderIRepositories holder repositories
- * @param nameRepository name repository
- * @param holder holder
- * @param nameChoice name choice
- */
- private static void validateNameElementData(NameElementCommand nameElement, EssNamingConvention namingConvention, HolderIRepositories holderIRepositories, NameRepository nameRepository, HolderSystemDeviceStructure holder, NameChoice nameChoice) {
- // attributes
- // uuid
- // parentsystemstructure
- // parentdevicestructure
- // index
- // description
- // comment
- //
- // name
- // - system structure uuid
- // ( - system structure uuid, device structure uuid )
- // - system structure uuid, device structure uuid, index
-
- if (nameElement == null || namingConvention == null || holderIRepositories == null || nameRepository == null || holder == null || nameChoice == null) {
- return;
- }
-
- String details = nameElement.toString();
-
- // name
- // update, delete - uuid available, not deleted
- // 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());
- ExceptionUtil.validateConditionDataNotCorrectException(names != null && names.size() == 1,
- TextUtil.VALUE_IS_NOT_CORRECT, details, TextUtil.UUID);
- }
-
- SystemGroup systemGroup = null;
- System system = null;
- Subsystem subsystem = null;
- DeviceType deviceType = null;
-
- int countDevicestructureIndex = 0;
- String derivedName = null;
-
- boolean condition = true;
-
- if (NameChoice.CREATE.equals(nameChoice) || NameChoice.UPDATE.equals(nameChoice)) {
- // systemgroup, system, subsystem - in repository
- // found
- // not deleted
- // devicetype - possibly, in repository
- // found
- // not deleted
- // name - naming convention rules
- // derive name from system structure, device structure, index
- // index - possibly, naming convention rules
- // valid
- // name
- // name not exists
- // name equivalence not exists
-
- // find out system group, system, subsystem
- // one of the three expected to be non-null, other two expected to be null
- systemGroup = holderIRepositories.getSystemGroupRepository().findLatestByUuid(nameElement.getParentsystemstructure().toString());
- system = holderIRepositories.getSystemRepository().findLatestByUuid(nameElement.getParentsystemstructure().toString());
- subsystem = holderIRepositories.getSubsystemRepository().findLatestByUuid(nameElement.getParentsystemstructure().toString());
-
- // device structure
- if (nameElement.getParentdevicestructure() != null) {
- countDevicestructureIndex++;
- deviceType = holderIRepositories.getDeviceTypeRepository().findLatestByUuid(nameElement.getParentdevicestructure().toString());
- ExceptionUtil.validateConditionDataNotAvailableException(deviceType != null, TextUtil.DATA_IS_NOT_AVAILABLE, details, TextUtil.PARENTDEVICESTRUCTURE);
- ExceptionUtil.validateConditionDataDeletedException(!deviceType.isDeleted(), TextUtil.DATA_IS_DELETED, details, TextUtil.PARENTDEVICESTRUCTURE);
- }
-
- // system structure
- if (systemGroup != null) {
- ExceptionUtil.validateConditionDataDeletedException(!systemGroup.isDeleted(), TextUtil.DATA_IS_DELETED, details, TextUtil.PARENTSYSTEMSTRUCTURE);
- derivedName = NameUtil.getName(systemGroup, deviceType, nameElement.getIndex(), holder);
- } else if (system != null) {
- ExceptionUtil.validateConditionDataDeletedException(!system.isDeleted(), TextUtil.DATA_IS_DELETED, details, TextUtil.PARENTSYSTEMSTRUCTURE);
- derivedName = NameUtil.getName(system, deviceType, nameElement.getIndex(), holder);
- } else if (subsystem != null) {
- ExceptionUtil.validateConditionDataDeletedException(!subsystem.isDeleted(), TextUtil.DATA_IS_DELETED, details, TextUtil.PARENTSYSTEMSTRUCTURE);
- derivedName = NameUtil.getName(subsystem, deviceType, nameElement.getIndex(), holder);
- } else {
- throw ExceptionUtil.createDataNotCorrectException(TextUtil.DATA_IS_NOT_CORRECT, details, TextUtil.PARENTSYSTEMSTRUCTURE);
- }
-
- // index
- if (!StringUtils.isEmpty(nameElement.getIndex())) {
- countDevicestructureIndex++;
- // TODO overrideRuleset depend on user authority
- condition = namingConvention.isInstanceIndexValid(derivedName, false);
- ExceptionUtil.validateConditionDataNotValidException(condition, TextUtil.DATA_IS_NOT_VALID, details, TextUtil.INDEX);
- }
-
- condition = countDevicestructureIndex == 0 || countDevicestructureIndex == 2;
- ExceptionUtil.validateConditionDataNotAvailableException(condition, TextUtil.DEVICETYPE_OR_INDEX_IS_NOT_AVAILABLE, details, TextUtil.PARENTDEVICESTRUCTURE);
-
- // name
- // ok with same name, name equivalence if same uuid
- List<Name> names = nameRepository.readNames(false, FieldName.NAME, derivedName);
- if (NameChoice.CREATE.equals(nameChoice)) {
- condition = names == null || names.isEmpty();
- } else {
- // NameChoice.UPDATE.equals(nameChoice)
- condition = names == null || names.isEmpty() || names.size() == 1 && names.get(0).getUuid().equals(nameElement.getUuid());
- }
- ExceptionUtil.validateConditionDataExistException(condition, TextUtil.CONVENTION_NAME_EXISTS, details, TextUtil.PARENTSYSTEMSTRUCTURE);
-
- names = nameRepository.readNames(false, FieldName.NAMEEQUIVALENCE, namingConvention.equivalenceClassRepresentative(derivedName));
- if (NameChoice.CREATE.equals(nameChoice)) {
- condition = names == null || names.isEmpty();
- } else {
- // NameChoice.UPDATE.equals(nameChoice)
- condition = names == null || names.isEmpty() || names.size() == 1 && names.get(0).getUuid().equals(nameElement.getUuid());
- }
- ExceptionUtil.validateConditionDataExistException(condition, TextUtil.CONVENTION_NAME_EQUIVALENCE_EXISTS, details, TextUtil.PARENTSYSTEMSTRUCTURE);
- } else if (NameChoice.DELETE.equals(nameChoice)) {
- // n.a.
- // uuid - already handled
- // comment - already handled
- }
- }
-
- // ----------------------------------------------------------------------------------------------------
-
- /**
- * Validate name data.
- * This method corresponds to name element data for create, albeit in a different way.
- *
- * @param name name
- * @param namingConvention naming convention
- * @param holderRepositories holder repositories
- * @param holder holder
- *
- * @see ValidateUtil#validateNameDataCreate(NameElement, EssNamingConvention, HolderIRepositories, NameRepository, HolderSystemDeviceStructure)
- */
- public static void validateNameDataCreate(String name, EssNamingConvention namingConvention, HolderRepositories holderRepositories, HolderSystemDeviceStructure holder) {
- if (name == null || namingConvention == null || holderRepositories == null || holder == null) {
- return;
- }
-
- String details = name;
- String field = TextUtil.NAME;
-
- // find out system group, system, subsystem + check if valid
- // find out discipline, device group, device type + check if valid
- // find out instance index + check if valid
- // check name equivalence
-
- String sg = NamingConventionUtil.extractSystemGroup(name);
- String sys = NamingConventionUtil.extractSystem(name);
- String sub = NamingConventionUtil.extractSubsystem(name);
- String dt = NamingConventionUtil.extractDeviceType(name);
- String idx = NamingConventionUtil.extractInstanceIndex(name);
-
- String mnemonicPathSystemstructure = NamingConventionUtil.extractMnemonicPathSystemStructure(name);
- String mnemonicPathDevicestructure = NamingConventionUtil.extractMnemonicPathDeviceStructure(name);
-
- int count = 0;
- int countSgSys = 0;
- int countSgSub = 0;
- if (sg != null) {
- count++;
- countSgSys++;
- countSgSub++;
- }
- if (sys != null) {
- count++;
- countSgSys++;
- }
- if (sub != null) {
- count++;
- countSgSub++;
- }
-
- // one or two system structure mnemonics + not system group and system + not system group and subsystem
- if (count < 1 || count > 2 || countSgSys == 2 || countSgSub == 2) {
- throw ExceptionUtil.createDataNotCorrectException(TextUtil.SYSTEM_STRUCTURE_IS_NOT_CORRECT, details, field);
- }
-
- SystemGroup systemGroup = null;
- System system = null;
- Subsystem subsystem = null;
- DeviceType deviceType = null;
-
- String derivedName = null;
-
- // ensure that system structure parents and device structure parents are available, latest and not deleted
- // if device type
- // if system group
- // else
- // if system
- // else
- // (if not system then error)
- // if subsystem
-
- // device structure
- if (!StringUtils.isEmpty(dt)) {
- List<DeviceType> deviceTypes = holderRepositories.getDeviceTypeRepository().readDeviceTypes(Status.APPROVED, false, FieldStructure.MNEMONICPATH, mnemonicPathDevicestructure);
- ExceptionUtil.validateConditionDataNotAvailableException(deviceTypes != null && deviceTypes.size() == 1, TextUtil.DEVICETYPE_IS_NOT_AVAILABLE, details, field);
- deviceType = deviceTypes.get(0);
- }
-
- // system structure
- List<Subsystem> subsystems = holderRepositories.getSubsystemRepository().readSubsystems(Status.APPROVED, false, FieldStructure.MNEMONICPATH, mnemonicPathSystemstructure);
- List<System> systems = holderRepositories.getSystemRepository().readSystems(Status.APPROVED, false, FieldStructure.MNEMONICPATH, mnemonicPathSystemstructure);
- List<SystemGroup> systemGroups = holderRepositories.getSystemGroupRepository().readSystemGroups(Status.APPROVED, false, FieldStructure.MNEMONICPATH, mnemonicPathSystemstructure);
-
- if (subsystems != null && subsystems.size() == 1) {
- subsystem = subsystems.get(0);
- derivedName = NameUtil.getName(subsystem, deviceType, NamingConventionUtil.extractInstanceIndex(name), holder);
- } else if (systems != null && systems.size() == 1) {
- system = systems.get(0);
- derivedName = NameUtil.getName(system, deviceType, NamingConventionUtil.extractInstanceIndex(name), holder);
- } else if (systemGroups != null && systemGroups.size() == 1) {
- systemGroup = systemGroups.get(0);
- derivedName = NameUtil.getName(systemGroup, deviceType, NamingConventionUtil.extractInstanceIndex(name), holder);
- } else {
- throw ExceptionUtil.createDataNotCorrectException(TextUtil.SYSTEM_STRUCTURE_IS_NOT_CORRECT, details, field);
- }
-
- // index
- if (!StringUtils.isEmpty(idx)) {
- // TODO overrideRuleset depend on user authority
- ExceptionUtil.validateConditionDataNotValidException(namingConvention.isInstanceIndexValid(name, false), TextUtil.INDEX_IS_NOT_VALID, details, field);
- }
-
- // name
- // name corresponds to derived name
- // convention name not exists
- // convention name equivalence not exists
- ExceptionUtil.validateConditionDataNotCorrectException(StringUtils.equals(name, derivedName), TextUtil.CONVENTION_NAME_IS_NOT_CORRECT, details, field);
-
- List<Name> names = holderRepositories.getNameRepository().readNames(false, FieldName.NAME, name);
- ExceptionUtil.validateConditionDataExistException(names.isEmpty(), TextUtil.CONVENTION_NAME_EXISTS, details, field);
-
- names = holderRepositories.getNameRepository().readNames(false, FieldName.NAMEEQUIVALENCE, namingConvention.equivalenceClassRepresentative(name));
- ExceptionUtil.validateConditionDataExistException(names.isEmpty(), TextUtil.CONVENTION_NAME_EQUIVALENCE_EXISTS, details, field);
- }
-
- // ----------------------------------------------------------------------------------------------------
-
- /**
- * Validate parameters for read structures.
- *
- * @param type type
- * @param statuses statuses
- * @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
- * @param includeHistory include history
- * @param orderBy order by
- * @param isAsc is ascending
- * @param offset offset
- * @param limit limit
- */
- public static void validateStructuresInputRead(
- Type type, Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues,
- Boolean includeHistory,
- FieldStructure orderBy, Boolean isAsc,
- Integer offset, Integer limit) {
-
- // validate input
- // type
- // queryFields and queryValues
- // either
- // both null
- // both non-null, same length, non-empty
- // uuid
-
- ValidateUtil.validateInputType(type);
- boolean condition = ((queryFields == null && queryValues == null)
- || (queryFields != null && queryValues != null && queryFields.length == queryValues.length && queryFields.length > 0));
- ExceptionUtil.validateConditionInputNotCorrectException(condition,
- TextUtil.VALUES_ARE_NOT_CORRECT, "url and parameters (queryFields, queryValues) have different lengths or are empty", null);
-
- if (queryFields != null) {
- for (int i=0; i<queryFields.length; i++) {
- if (FieldStructure.UUID.equals(queryFields[i])) {
- ValidateUtil.validateInputUuid(queryValues[i]);
- }
- }
-
- }
- }
-
- /**
- * Validate structure element parameters (input) for create.
- *
- * @param structureElement structure element
- */
- public static void validateStructureElementInputCreate(StructureElementCommand structureElement, EssNamingConvention namingConvention) {
- validateStructureElementInput(structureElement, namingConvention, StructureChoice.CREATE);
- }
-
- /**
- * Validate structure element parameters (input) for update.
- *
- * @param structureElement structure element
- */
- public static void validateStructureElementInputUpdate(StructureElementCommand structureElement, EssNamingConvention namingConvention) {
- validateStructureElementInput(structureElement, namingConvention, StructureChoice.UPDATE);
- }
-
- /**
- * Validate structure element parameters (input) for delete.
- *
- * @param structureElement structure element
- */
- public static void validateStructureElementInputDelete(StructureElementCommand structureElement, EssNamingConvention namingConvention) {
- validateStructureElementInput(structureElement, namingConvention, StructureChoice.DELETE);
- }
-
- /**
- * Validate structure element parameters (input) for approve.
- *
- * @param structureElement structure element
- */
- public static void validateStructureElementInputApprove(StructureElementCommand structureElement, EssNamingConvention namingConvention) {
- validateStructureElementInput(structureElement, namingConvention, StructureChoice.APPROVE);
- }
-
- /**
- * Validate structure element parameters (input) for cancel.
- *
- * @param structureElement structure element
- */
- public static void validateStructureElementInputCancel(StructureElementCommand structureElement, EssNamingConvention namingConvention) {
- validateStructureElementInput(structureElement, namingConvention, StructureChoice.CANCEL);
- }
-
- /**
- * Validate structure element parameters (input) for reject.
- *
- * @param structureElement structure element
- */
- public static void validateStructureElementInputReject(StructureElementCommand structureElement, EssNamingConvention namingConvention) {
- validateStructureElementInput(structureElement, namingConvention, StructureChoice.REJECT);
- }
-
- /**
- * Validate structure element parameters (input).
- *
- * @param structureElement structure element
- * @param structureChoice structure choice
- */
- private static void validateStructureElementInput(StructureElementCommand structureElement, EssNamingConvention namingConvention, StructureChoice structureChoice) {
- // check structure element input
- // uuid - required if not create, required empty if create
- // type - required
- // parent (uuid) - also validate data, parent uuid available if type is system, subsystem, device group, device type
- // name - required
- // mnemonic - required except for device group
- // description - required
- // comment - required
-
- if (structureElement == null || structureChoice == null) {
- return;
- }
-
- if (StructureChoice.CREATE.equals(structureChoice)) {
- ExceptionUtil.validateConditionInputNotEmptyException(structureElement.getUuid() == null,
- TextUtil.VALUE_IS_NOT_EMPTY,
- structureElement.getUuid() != null ? structureElement.getUuid().toString() : null,
- TextUtil.UUID);
- } else {
- validateInputUuid(structureElement.getUuid() != null ? structureElement.getUuid().toString() : null);
- }
-
- validateInputType(structureElement.getType());
-
- if (!StructureChoice.DELETE.equals(structureChoice)) {
- if (Type.SYSTEM.equals(structureElement.getType())
- || Type.SUBSYSTEM.equals(structureElement.getType())
- || Type.DEVICEGROUP.equals(structureElement.getType())
- || Type.DEVICETYPE.equals(structureElement.getType())) {
- ExceptionUtil.validateConditionInputNotAvailableException(structureElement.getParent() != null,
- TextUtil.PARENT_IS_NOT_AVAILABLE, structureElement.toString(), TextUtil.PARENT);
- ValidateUtil.validateInputUuid(structureElement.getParent().toString());
- }
-
- validateInputName(structureElement.getName());
-
- // validate mnemonic
- // validate mnemonic input (value itself, not in relation to other values)
- // validateMnemonic takes isMnemonicRequired into account
- MnemonicValidation mnemonicValidation = namingConvention.validateMnemonic(structureElement.getType(), structureElement.getMnemonic());
- ExceptionUtil.validateConditionInputNotValidException(MnemonicValidation.VALID.equals(mnemonicValidation),
- TextUtil.MNEMONIC_IS_NOT_VALID, structureElement.toString(), TextUtil.MNEMONIC);
-
- validateInputDescription(structureElement.getDescription());
- }
-
- validateInputComment(structureElement.getComment());
- }
-
- // ----------------------------------------------------------------------------------------------------
-
- /**
- * Validate structure element data for create.
- *
- * @param structureElement structure element
- * @param namingConvention naming convention
- * @param holderRepositories holder repositories
- * @param holder holder
- */
- public static void validateStructureElementDataCreate(StructureElementCommand structureElement, EssNamingConvention namingConvention, HolderRepositories holderRepositories, HolderSystemDeviceStructure holder) {
- validateStructureElementDataInItself(structureElement, namingConvention, holderRepositories, holder, StructureChoice.CREATE);
- validateStructureElementDataRelativeOtherData(structureElement, namingConvention, holderRepositories, holder, StructureChoice.CREATE);
- }
-
- /**
- * Validate structure element data for update.
- *
- * @param structureElement structure element
- * @param namingConvention naming convention
- * @param holderRepositories holder repositories
- * @param holder holder
- */
- public static void validateStructureElementDataUpdate(StructureElementCommand structureElement, EssNamingConvention namingConvention, HolderRepositories holderRepositories, HolderSystemDeviceStructure holder) {
- validateStructureElementDataInItself(structureElement, namingConvention, holderRepositories, holder, StructureChoice.UPDATE);
- validateStructureElementDataRelativeOtherData(structureElement, namingConvention, holderRepositories, holder, StructureChoice.UPDATE);
- }
-
- /**
- * Validate structure element data for delete.
- *
- * @param structureElement structure element
- * @param namingConvention naming convention
- * @param holderRepositories holder repositories
- * @param holder holder
- */
- public static void validateStructureElementDataDelete(StructureElementCommand structureElement, EssNamingConvention namingConvention, HolderRepositories holderRepositories, HolderSystemDeviceStructure holder) {
- validateStructureElementDataInItself(structureElement, namingConvention, holderRepositories, holder, StructureChoice.DELETE);
- validateStructureElementDataRelativeOtherData(structureElement, namingConvention, holderRepositories, holder, StructureChoice.DELETE);
- }
-
- /**
- * Validate structure element data for approve.
- *
- * @param structureElement structure element
- * @param namingConvention naming convention
- * @param holderRepositories holder repositories
- * @param holder holder
- */
- public static void validateStructureElementDataApprove(StructureElementCommand structureElement, EssNamingConvention namingConvention, HolderRepositories holderRepositories, HolderSystemDeviceStructure holder) {
- validateStructureElementDataInItself(structureElement, namingConvention, holderRepositories, holder, StructureChoice.APPROVE);
- validateStructureElementDataRelativeOtherData(structureElement, namingConvention, holderRepositories, holder, StructureChoice.APPROVE);
- }
-
- /**
- * Validate structure element data for cancel.
- *
- * @param structureElement structure element
- * @param namingConvention naming convention
- * @param holderRepositories holder repositories
- * @param holder holder
- */
- public static void validateStructureElementDataCancel(StructureElementCommand structureElement, EssNamingConvention namingConvention, HolderRepositories holderRepositories, HolderSystemDeviceStructure holder) {
- validateStructureElementDataInItself(structureElement, namingConvention, holderRepositories, holder, StructureChoice.CANCEL);
- validateStructureElementDataRelativeOtherData(structureElement, namingConvention, holderRepositories, holder, StructureChoice.CANCEL);
- }
-
- /**
- * Validate structure element data for reject.
- *
- * @param structureElement structure element
- * @param namingConvention naming convention
- * @param holderRepositories holder repositories
- * @param holder holder
- */
- public static void validateStructureElementDataReject(StructureElementCommand structureElement, EssNamingConvention namingConvention, HolderRepositories holderRepositories, HolderSystemDeviceStructure holder) {
- validateStructureElementDataInItself(structureElement, namingConvention, holderRepositories, holder, StructureChoice.REJECT);
- validateStructureElementDataRelativeOtherData(structureElement, namingConvention, holderRepositories, holder, StructureChoice.REJECT);
- }
-
- /**
- * Validate structure element data in itself.
- *
- * @param structureElement
- * @param namingConvention
- * @param holderRepositories
- * @param holder
- * @param structureChoice
- */
- public static void validateStructureElementDataInItself(StructureElementCommand structureElement, EssNamingConvention namingConvention, HolderRepositories holderRepositories, HolderSystemDeviceStructure holder, StructureChoice structureChoice) {
- // check structure element data in itself
- // update, delete
- // definitely (not possibly)
- // no pending entry waiting to be approved, cancelled, rejected (pending with higher id than currently approved)
- // uuid - approved, latest, not deleted - list size 1
- // approve, reject, cancel
- // uuid - pending, latest, not deleted - list size 1
-
- if (structureElement == null || namingConvention == null || holderRepositories == null || holder == null || structureChoice == null) {
- return;
- }
-
- String message = structureElement.getType().toString().toLowerCase() + TextUtil.SPACE + TextUtil.IS_NOT_CORRECT;
- String details = structureElement.toString();
- String field = TextUtil.UUID;
-
- // validate data in itself
- // systemgroup, discipline
- // not have parent
- // update, delete
- // entry not pending
- // entry approved and not deleted
- // approve, cancel, reject
- // entry pending
-
- if ((Type.SYSTEMGROUP.equals(structureElement.getType()) || Type.DISCIPLINE.equals(structureElement.getType()))
- && structureElement.getParent() != null) {
- throw ExceptionUtil.createDataNotCorrectException(TextUtil.PARENT_IS_NOT_CORRECT, details, field);
- } else if (StructureChoice.UPDATE.equals(structureChoice) || StructureChoice.DELETE.equals(structureChoice)) {
- ValidateUtil.validateStructuresStatusSize0(
- structureElement.getUuid(), structureElement.getType(), Status.PENDING, null,
- holderRepositories, message, details, field);
-
- ValidateUtil.validateStructuresStatusSize1(
- structureElement.getUuid(), structureElement.getType(), Status.APPROVED, Boolean.FALSE,
- holderRepositories, message, details, field);
- } else if (StructureChoice.APPROVE.equals(structureChoice) || StructureChoice.CANCEL.equals(structureChoice) || StructureChoice.REJECT.equals(structureChoice)) {
- ValidateUtil.validateStructuresStatusSize1(
- structureElement.getUuid(), structureElement.getType(), Status.PENDING, null,
- holderRepositories, message, details, field);
- }
- }
-
- private static void validateStructuresStatusSize0(UUID uuid, Type type, Status status, Boolean deleted,
- HolderRepositories holderRepositories, String message, String details, String field) {
- ExceptionUtil.validateConditionDataNotCorrectException(
- getStructuresSize(uuid, type, status, deleted, holderRepositories) == 0, message, details, field);
- }
- private static void validateStructuresStatusSize1(UUID uuid, Type type, Status status, Boolean deleted,
- HolderRepositories holderRepositories, String message, String details, String field) {
- ExceptionUtil.validateConditionDataNotCorrectException(
- getStructuresSize(uuid, type, status, deleted, holderRepositories) == 1, message, details, field);
- }
- private static int getStructuresSize(UUID uuid, Type type, Status status, Boolean deleted,
- HolderRepositories holderRepositories) {
- if (Type.SYSTEMGROUP.equals(type)) {
- return holderRepositories.getSystemGroupRepository().readSystemGroups(status, deleted, FieldStructure.UUID, uuid.toString()).size();
- } else if (Type.SYSTEM.equals(type)) {
- return holderRepositories.getSystemRepository().readSystems(status, deleted, FieldStructure.UUID, uuid.toString()).size();
- } else if (Type.SUBSYSTEM.equals(type)) {
- return holderRepositories.getSubsystemRepository().readSubsystems(status, deleted, FieldStructure.UUID, uuid.toString()).size();
- } else if (Type.DISCIPLINE.equals(type)) {
- return holderRepositories.getDisciplineRepository().readDisciplines(status, deleted, FieldStructure.UUID, uuid.toString()).size();
- } else if (Type.DEVICEGROUP.equals(type)) {
- return holderRepositories.getDeviceGroupRepository().readDeviceGroups(status, deleted, FieldStructure.UUID, uuid.toString()).size();
- } else if (Type.DEVICETYPE.equals(type)) {
- return holderRepositories.getDeviceTypeRepository().readDeviceTypes(status, deleted, FieldStructure.UUID, uuid.toString()).size();
- }
- return 0;
- }
-
- /**
- * Validate structure element data relative other data.
- *
- * @param structureElement structure element
- * @param namingConvention naming convention
- * @param holderRepositories holder repositories
- * @param holder holder
- * @param structureChoice structure choice
- */
- public static void validateStructureElementDataRelativeOtherData(StructureElementCommand structureElement, EssNamingConvention namingConvention, HolderRepositories holderRepositories, HolderSystemDeviceStructure holder, StructureChoice structureChoice) {
- // check structure element data in relation to other data
- // create, update
- // parent uuid - (if applicable) approved, latest, not deleted
- // mnemonic - (if not same) not exists
- // mnemonic equivalence - (if not same) equivalence not exists
- // approve
- // uuid - pending, not latest, deleted
- // no or less checks if entry to be deleted - approve (delete)
- // more or same checks as above if entry is not be deleted - approve (create), approve (update)
- // need checks as content may have changed from time of create, update, delete to time of approve
- // checks on mnemonic, mnemonic equivalence are to ensure can coexist, can move
- // possibly
- // additional checks if names are affected
- // comment not same as previous comment
-
- if (structureElement == null || namingConvention == null || holderRepositories == null || holder == null || structureChoice == null) {
- return;
- }
-
- String message = null;
- String details = structureElement.toString();
- String field = TextUtil.MNEMONIC;
-
- // validate data relative other data
- // create, update
- // entry (uuid,) status, mnemonic
- // entry (uuid,) status, mnemonic equivalence
- // approve
- // entry uuid, status
-
- if (StructureChoice.CREATE.equals(structureChoice) || StructureChoice.UPDATE.equals(structureChoice)) {
- if (Type.SYSTEMGROUP.equals(structureElement.getType())) {
- // note rules for mnemonic for system group
- if (!StringUtils.isEmpty(structureElement.getMnemonic())) {
- // status, mnemonic
- message = TextUtil.SYSTEMGROUP_IS_NOT_CORRECT;
- validateStructuresStatusMnemonic(structureElement.getUuid(), structureElement.getType(), structureElement.getParent(), structureElement.getMnemonic(),
- namingConvention, holderRepositories, structureChoice, message, details, field);
-
- // status, mnemonic equivalence
- validateStructuresStatusMnemonicequivalence(structureElement.getUuid(), structureElement.getType(), structureElement.getParent(), structureElement.getMnemonic(),
- namingConvention, holderRepositories, structureChoice, message, details, field);
- }
- } else if (Type.SYSTEM.equals(structureElement.getType())) {
- // status, parent
- message = TextUtil.SYSTEMGROUP_IS_NOT_CORRECT;
- validateStructuresParent(structureElement.getType(), structureElement.getParent(), Status.APPROVED, false,
- holderRepositories, message, details, field);
-
- // status, mnemonic
- message = TextUtil.SYSTEM_IS_NOT_CORRECT;
- validateStructuresStatusMnemonic(structureElement.getUuid(), structureElement.getType(), structureElement.getParent(), structureElement.getMnemonic(),
- namingConvention, holderRepositories, structureChoice, message, details, field);
-
- // status, mnemonic equivalence
- validateStructuresStatusMnemonicequivalence(structureElement.getUuid(), structureElement.getType(), structureElement.getParent(), structureElement.getMnemonic(),
- namingConvention, holderRepositories, structureChoice, message, details, field);
- } else if (Type.SUBSYSTEM.equals(structureElement.getType())) {
- // status, parent
- message = TextUtil.SYSTEM_IS_NOT_CORRECT;
- validateStructuresParent(structureElement.getType(), structureElement.getParent(), Status.APPROVED, false,
- holderRepositories, message, details, field);
-
- // status, mnemonic
- message = TextUtil.SUBSYSTEM_IS_NOT_CORRECT;
- validateStructuresStatusMnemonic(structureElement.getUuid(), structureElement.getType(), structureElement.getParent(), structureElement.getMnemonic(),
- namingConvention, holderRepositories, structureChoice, message, details, field);
-
- // status, mnemonic equivalence
- validateStructuresStatusMnemonicequivalence(structureElement.getUuid(), structureElement.getType(), structureElement.getParent(), structureElement.getMnemonic(),
- namingConvention, holderRepositories, structureChoice, message, details, field);
- } else if (Type.DISCIPLINE.equals(structureElement.getType())) {
- message = TextUtil.DISCIPLINE_IS_NOT_CORRECT;
-
- // status, mnemonic
- validateStructuresStatusMnemonic(structureElement.getUuid(), structureElement.getType(), structureElement.getParent(), structureElement.getMnemonic(),
- namingConvention, holderRepositories, structureChoice, message, details, field);
-
- // status, mnemonic equivalence
- validateStructuresStatusMnemonicequivalence(structureElement.getUuid(), structureElement.getType(), structureElement.getParent(), structureElement.getMnemonic(),
- namingConvention, holderRepositories, structureChoice, message, details, field);
- } else if (Type.DEVICEGROUP.equals(structureElement.getType())) {
- // status, parent
- message = TextUtil.DISCIPLINE_IS_NOT_CORRECT;
- List<Discipline> disciplines = holderRepositories.getDisciplineRepository().readDisciplines(Status.APPROVED, false, FieldStructure.UUID, structureElement.getParent().toString());
- ExceptionUtil.validateConditionDataConflictException(disciplines != null && disciplines.size() == 1, message, details, TextUtil.PARENT);
-
- // note rules for mnemonic for device group
-
- // mnemonic
- message = TextUtil.DEVICEGROUP_IS_NOT_CORRECT;
- ExceptionUtil.validateConditionDataConflictException(StringUtils.isEmpty(structureElement.getMnemonic()), message, details, field);
- } else if (Type.DEVICETYPE.equals(structureElement.getType())) {
- // status, parent
- message = TextUtil.DEVICEGROUP_IS_NOT_CORRECT;
- validateStructuresParent(structureElement.getType(), structureElement.getParent(), Status.APPROVED, false,
- holderRepositories, message, details, field);
-
- // status, mnemonic
- message = TextUtil.DEVICETYPE_IS_NOT_CORRECT;
- validateStructuresStatusMnemonic(structureElement.getUuid(), structureElement.getType(), structureElement.getParent(), structureElement.getMnemonic(),
- namingConvention, holderRepositories, structureChoice, message, details, field);
-
- // status, mnemonic equivalence
- validateStructuresStatusMnemonicequivalence(structureElement.getUuid(), structureElement.getType(), structureElement.getParent(), structureElement.getMnemonic(),
- namingConvention, holderRepositories, structureChoice, message, details, field);
- }
- } else if (StructureChoice.APPROVE.equals(structureChoice)) {
- // possibly additional checks to ensure (status, mnemonic) and (status, mnemonic equivalence)
- // however that would be duplicate checks as already checked at time of create, update
-
- if (Type.SYSTEMGROUP.equals(structureElement.getType())) {
- // status, uuid
- message = TextUtil.SYSTEMGROUP_IS_NOT_CORRECT;
- validateStructuresStatusSize1(structureElement.getUuid(), structureElement.getType(), Status.PENDING, null,
- holderRepositories, message, details, field);
- } else if (Type.SYSTEM.equals(structureElement.getType())) {
- // status, parent
- message = TextUtil.SYSTEMGROUP_IS_NOT_CORRECT;
- validateStructuresStatusSize1(structureElement.getParent(), Type.SYSTEMGROUP, Status.APPROVED, false,
- holderRepositories, message, details, field);
-
- // status, uuid
- message = TextUtil.SYSTEM_IS_NOT_CORRECT;
- validateStructuresStatusSize1(structureElement.getUuid(), structureElement.getType(), Status.PENDING, null,
- holderRepositories, message, details, field);
- } else if (Type.SUBSYSTEM.equals(structureElement.getType())) {
- // status, parent
- message = TextUtil.SYSTEM_IS_NOT_CORRECT;
- validateStructuresStatusSize1(structureElement.getParent(), Type.SYSTEM, Status.APPROVED, false,
- holderRepositories, message, details, field);
-
- // status, uuid
- message = TextUtil.SUBSYSTEM_IS_NOT_CORRECT;
- validateStructuresStatusSize1(structureElement.getUuid(), structureElement.getType(), Status.PENDING, null,
- holderRepositories, message, details, field);
- } else if (Type.DISCIPLINE.equals(structureElement.getType())) {
- // status, uuid
- message = TextUtil.DISCIPLINE_IS_NOT_CORRECT;
- validateStructuresStatusSize1(structureElement.getUuid(), structureElement.getType(), Status.PENDING, null,
- holderRepositories, message, details, field);
- } else if (Type.DEVICEGROUP.equals(structureElement.getType())) {
- // status, parent
- message = TextUtil.DISCIPLINE_IS_NOT_CORRECT;
- validateStructuresStatusSize1(structureElement.getParent(), Type.DISCIPLINE, Status.APPROVED, false,
- holderRepositories, message, details, field);
-
- // status, uuid
- message = TextUtil.DEVICEGROUP_IS_NOT_CORRECT;
- validateStructuresStatusSize1(structureElement.getUuid(), structureElement.getType(), Status.PENDING, null,
- holderRepositories, message, details, field);
-
- // no mnemonic for device group
- ExceptionUtil.validateConditionDataConflictException(StringUtils.isEmpty(structureElement.getMnemonic()), message, details, field);
- } else if (Type.DEVICETYPE.equals(structureElement.getType())) {
- // status, parent
- message = TextUtil.DISCIPLINE_IS_NOT_CORRECT;
- validateStructuresStatusSize1(structureElement.getParent(), Type.DEVICEGROUP, Status.APPROVED, false,
- holderRepositories, message, details, field);
-
- // status, uuid
- message = TextUtil.DEVICETYPE_IS_NOT_CORRECT;
- validateStructuresStatusSize1(structureElement.getUuid(), structureElement.getType(), Status.PENDING, null,
- holderRepositories, message, details, field);
- }
- }
- }
-
- private static void validateStructuresParent(Type type, UUID parent, Status status, Boolean deleted,
- HolderRepositories holderRepositories, String message, String details, String field){
- ExceptionUtil.validateConditionDataConflictException(
- getStructuresParentSize(type, parent, status, deleted, holderRepositories) == 1, message, details, field);
- }
- private static void validateStructuresStatusMnemonic(UUID uuid, Type type, UUID parent, String mnemonic,
- EssNamingConvention namingConvention, HolderRepositories holderRepositories, StructureChoice structureChoice,
- String message, String details, String field){
-
- // parent may be null
- List<UUID> listUuid = null;
-
- listUuid = getStructures(type, parent, mnemonic, Status.PENDING, false, false, namingConvention, holderRepositories);
- validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, listUuid.isEmpty(), message, details, field);
- validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, listUuid.isEmpty() || listUuid.size() == 1 && listUuid.get(0).equals(uuid), message, details, field);
-
- listUuid = getStructures(type, parent, mnemonic, Status.APPROVED, false, false, namingConvention, holderRepositories);
- validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, listUuid.isEmpty(), message, details, field);
- validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, listUuid.isEmpty() || listUuid.size() == 1 && listUuid.get(0).equals(uuid), message, details, field);
- }
- private static void validateStructuresStatusMnemonicequivalence(UUID uuid, Type type, UUID parent, String mnemonic,
- EssNamingConvention namingConvention, HolderRepositories holderRepositories, StructureChoice structureChoice,
- String message, String details, String field){
-
- // parent may be null
- List<UUID> listUuid = null;
-
- listUuid = getStructures(type, parent, mnemonic, Status.PENDING, false, true, namingConvention, holderRepositories);
- validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, listUuid.isEmpty(), message, details, field);
- validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, listUuid.isEmpty() || listUuid.size() == 1 && listUuid.get(0).equals(uuid), message, details, field);
-
- listUuid = getStructures(type, parent, mnemonic, Status.APPROVED, false, true, namingConvention, holderRepositories);
- validateConditionIfStructureChoice(StructureChoice.CREATE, structureChoice, listUuid.isEmpty(), message, details, field);
- validateConditionIfStructureChoice(StructureChoice.UPDATE, structureChoice, listUuid.isEmpty() || listUuid.size() == 1 && listUuid.get(0).equals(uuid), message, details, field);
- }
- private static int getStructuresParentSize(Type type, UUID parent, Status status, Boolean deleted,
- HolderRepositories holderRepositories) {
- if (Type.SYSTEM.equals(type)) {
- return holderRepositories.getSystemGroupRepository().readSystemGroups(status, deleted, FieldStructure.UUID, parent.toString()).size();
- } else if (Type.SUBSYSTEM.equals(type)) {
- return holderRepositories.getSystemRepository().readSystems(status, deleted, FieldStructure.UUID, parent.toString()).size();
- } else if (Type.DEVICEGROUP.equals(type)) {
- return holderRepositories.getDisciplineRepository().readDisciplines(status, deleted, FieldStructure.UUID, parent.toString()).size();
- } else if (Type.DEVICETYPE.equals(type)) {
- return holderRepositories.getDeviceGroupRepository().readDeviceGroups(status, deleted, FieldStructure.UUID, parent.toString()).size();
- }
- return 0;
- }
- private static List<UUID> getStructures(Type type, UUID parent, String mnemonic, Status status, Boolean deleted, Boolean equivalence,
- EssNamingConvention namingConvention, HolderRepositories holderRepositories) {
-
- boolean hasMnemonic = !StringUtils.isEmpty(mnemonic);
- FieldStructure mnemonicField = null;
- String mnemonicValue = null;
- if (hasMnemonic) {
- mnemonicField = Boolean.TRUE.equals(equivalence)
- ? FieldStructure.MNEMONICEQUIVALENCE
- : FieldStructure.MNEMONIC;
- mnemonicValue = Boolean.TRUE.equals(equivalence)
- ? namingConvention.equivalenceClassRepresentative(mnemonic)
- : mnemonic;
- }
-
- // uuid, parent, mnemonic
- boolean queryParentTable = false;
- FieldStructure[] queryFields = null;
- String[] queryValues = null;
- if (Type.SYSTEMGROUP.equals(type) || Type.DISCIPLINE.equals(type)) {
- // no parent - query table for type
- if (hasMnemonic) {
- queryFields = new FieldStructure[]{mnemonicField};
- queryValues = new String[]{mnemonicValue};
- } else {
- return Lists.newArrayList();
- }
- } else {
- // parent
- if (hasMnemonic) {
- // query table for type
- queryFields = new FieldStructure[]{FieldStructure.PARENT, mnemonicField};
- queryValues = new String[]{parent.toString(), mnemonicValue};
- } else {
- // query table for parent to type
- queryParentTable = true;
- queryFields = new FieldStructure[]{FieldStructure.UUID};
- queryValues = new String[]{parent.toString()};
- }
- }
-
- // query table and return list with uuid
- if (Type.SYSTEMGROUP.equals(type)) {
- return StructureUtil.listSystemGroup2Uuid(holderRepositories.getSystemGroupRepository().readSystemGroups(status, deleted, queryFields, queryValues));
- } else if (Type.SYSTEM.equals(type)) {
- if (queryParentTable) {
- return StructureUtil.listSystemGroup2Uuid(holderRepositories.getSystemGroupRepository().readSystemGroups(status, deleted, queryFields, queryValues));
- } else {
- return StructureUtil.listSystem2Uuid(holderRepositories.getSystemRepository().readSystems(status, deleted, queryFields, queryValues));
- }
- } else if (Type.SUBSYSTEM.equals(type)) {
- if (queryParentTable) {
- return StructureUtil.listSystem2Uuid(holderRepositories.getSystemRepository().readSystems(status, deleted, queryFields, queryValues));
- } else {
- return StructureUtil.listSubsystem2Uuid(holderRepositories.getSubsystemRepository().readSubsystems(status, deleted, queryFields, queryValues));
- }
- } else if (Type.DISCIPLINE.equals(type)) {
- return StructureUtil.listDiscipline2Uuid(holderRepositories.getDisciplineRepository().readDisciplines(status, deleted, queryFields, queryValues));
- } else if (Type.DEVICEGROUP.equals(type)) {
- if (queryParentTable) {
- return StructureUtil.listDiscipline2Uuid(holderRepositories.getDisciplineRepository().readDisciplines(status, deleted, queryFields, queryValues));
- } else {
- return StructureUtil.listDeviceGroup2Uuid(holderRepositories.getDeviceGroupRepository().readDeviceGroups(status, deleted, queryFields, queryValues)); }
- } else if (Type.DEVICETYPE.equals(type)) {
- if (queryParentTable) {
- return StructureUtil.listDeviceGroup2Uuid(holderRepositories.getDeviceGroupRepository().readDeviceGroups(status, deleted, queryFields, queryValues));
- } else {
- return StructureUtil.listDeviceType2Uuid(holderRepositories.getDeviceTypeRepository().readDeviceTypes(status, deleted, queryFields, queryValues));
- }
- }
- return Lists.newArrayList();
- }
-
- // ----------------------------------------------------------------------------------------------------
-
- /**
- * Validate structure data.
- * This method corresponds to structure element data for create, albeit in a different way.
- *
- * @param type type
- * @param mnemonicpath mnemonic path
- * @param namingConvention naming convention
- * @param holderIRepositories holder repositories
- * @param holder holder
- */
- public static void validateStructureDataCreate(Type type, String mnemonicpath, EssNamingConvention namingConvention, HolderIRepositories holderIRepositories, HolderSystemDeviceStructure holder) {
- if (type == null || mnemonicpath == null || namingConvention == null || holderIRepositories == null || holder == null) {
- return;
- }
-
- String details = mnemonicpath;
- String field = TextUtil.MNEMONIC_PATH;
-
- String[] path = NamingConventionUtil.string2MnemonicPath(mnemonicpath);
- ExceptionUtil.validateConditionDataNotValidException(path != null && path.length >= 1 && path.length <= 2,
- TextUtil.STRUCTURE_MNEMONIC_PATH_IS_NOT_VALID, details, field);
- String mnemonicpathEquivalence = namingConvention.equivalenceClassRepresentative(mnemonicpath);
-
- if (Type.SYSTEMGROUP.equals(type)) {
- validateStructuresMnemonicpathNotValid(type, path.length == 1, details, field);
-
- // system group may have empty path but there will be mnemonicpath in this context
-
- // mnemonic path
- SystemGroup sg = holderIRepositories.getSystemGroupRepository().findLatestNotDeletedByMnemonic(path[0]);
- validateStructuresMnemonicpathDuplicate(type, sg == null, details, field);
-
- // mnemonic path equivalence
- List<SystemGroup> systemGroups = holderIRepositories.getSystemGroupRepository().findLatestNotDeleted();
- for (SystemGroup systemGroup : systemGroups) {
- validateStructuresMnemonicpathequivalenceDuplicate(type, !StringUtils.equals(systemGroup.getMnemonicEquivalence(), namingConvention.equivalenceClassRepresentative(path[0])), details, field);
- }
- } else if (Type.SYSTEM.equals(type)) {
- validateStructuresMnemonicpathNotValid(type, path.length == 1, details, field);
-
- // path with 1 element - system group or system ---> check both individually
- // check mnemonic, mnemonic equivalence
-
- // mnemonic path system group
- List<String> mnemonicPaths = StructureUtil.getMnemonicPathsSystemGroup(holder, false, namingConvention);
- for (String existingPath : mnemonicPaths) {
- validateStructuresMnemonicpathDuplicate(type, !StringUtils.equals(mnemonicpath, existingPath), details, field);
- }
-
- // mnemonic path equivalence system group
- mnemonicPaths = StructureUtil.getMnemonicPathsSystemGroup(holder, true, namingConvention);
- for (String existingPath : mnemonicPaths) {
- validateStructuresMnemonicpathequivalenceDuplicate(type, !StringUtils.equals(mnemonicpathEquivalence, namingConvention.equivalenceClassRepresentative(existingPath)), details, field);
- }
-
- // mnemonic path
- mnemonicPaths = StructureUtil.getMnemonicPathsSystem(holder, false, namingConvention);
- for (String existingPath : mnemonicPaths) {
- validateStructuresMnemonicpathDuplicate(type, !StringUtils.equals(mnemonicpath, existingPath), details, field);
- }
-
- // mnemonic path equivalence
- mnemonicPaths = StructureUtil.getMnemonicPathsSystem(holder, true, namingConvention);
- for (String existingPath : mnemonicPaths) {
- validateStructuresMnemonicpathequivalenceDuplicate(type, !StringUtils.equals(mnemonicpathEquivalence, namingConvention.equivalenceClassRepresentative(existingPath)), details, field);
- }
- } else if (Type.SUBSYSTEM.equals(type)) {
- validateStructuresMnemonicpathNotValid(type, path.length == 2, details, field);
-
- System sys = holderIRepositories.getSystemRepository().findLatestNotDeletedByMnemonic(path[0]);
- validateStructuresMnemonicpathNotAvailable(type, sys != null, details, field);
- SystemGroup sg = holderIRepositories.getSystemGroupRepository().findLatestNotDeletedByUuid(sys.getParentUuid().toString());
-
- // mnemonic path
- validateStructuresMnemonicpathDuplicate(type, !StringUtils.equals(path[0], path[1]), details, field);
- if (!StringUtils.isEmpty(sg.getMnemonic())) {
- validateStructuresMnemonicpathDuplicate(type, !StringUtils.equals(sg.getMnemonic(), path[1]), details, field);
- }
-
- List<String> mnemonicPaths = StructureUtil.getMnemonicPathsSubsystem(holder, false, namingConvention);
- for (String existingPath : mnemonicPaths) {
- validateStructuresMnemonicpathDuplicate(type, !StringUtils.equals(mnemonicpath, existingPath), details, field);
- }
-
- // mnemonic path equivalence
- validateStructuresMnemonicpathDuplicate(type, !StringUtils.equals(namingConvention.equivalenceClassRepresentative(path[0]), namingConvention.equivalenceClassRepresentative(path[1])), details, field);
- if (!StringUtils.isEmpty(sg.getMnemonic())) {
- validateStructuresMnemonicpathDuplicate(type, !StringUtils.equals(namingConvention.equivalenceClassRepresentative(sg.getMnemonic()), namingConvention.equivalenceClassRepresentative(path[1])), details, field);
- }
-
- mnemonicPaths = StructureUtil.getMnemonicPathsSubsystem(holder, true, namingConvention);
- for (String existingPath : mnemonicPaths) {
- validateStructuresMnemonicpathequivalenceDuplicate(type, !StringUtils.equals(mnemonicpathEquivalence, namingConvention.equivalenceClassRepresentative(existingPath)), details, field); }
- } else if (Type.DISCIPLINE.equals(type)) {
- validateStructuresMnemonicpathNotValid(type, path.length == 1, details, field);
-
- // mnemonic path
- Discipline di = holderIRepositories.getDisciplineRepository().findLatestNotDeletedByMnemonic(path[0]);
- validateStructuresMnemonicpathDuplicate(type, di == null, details, field);
-
- // mnemonic path equivalence
- List<Discipline> disciplines = holderIRepositories.getDisciplineRepository().findLatestNotDeleted();
- for (Discipline discipline : disciplines) {
- validateStructuresMnemonicpathequivalenceDuplicate(type, !StringUtils.equals(discipline.getMnemonicEquivalence(), namingConvention.equivalenceClassRepresentative(path[0])), details, field);
- }
- } else if (Type.DEVICEGROUP.equals(type)) {
- throw ExceptionUtil.createDataNotValidException(TextUtil.DEVICEGROUP_IS_NOT_VALID, details, field);
- } else if (Type.DEVICETYPE.equals(type)) {
- // since device group is between discipline and device type and device group has no mnemonic,
- // it can not be traced to which device group that this device type belongs,
- // therefore it can not be known to which mnemonic line it belongs
- // by looking at mnemonic
- // instead similar approach as for other Type, i.e. compare with list of mnemonic paths
- // rest of checks in validatecreate
-
- validateStructuresMnemonicpathNotValid(type, path.length == 2, details, field);
-
- // discipline
- Discipline discipline = holderIRepositories.getDisciplineRepository().findLatestNotDeletedByMnemonic(path[0]);
- ExceptionUtil.validateConditionDataNotValidException(discipline != null,
- TextUtil.DISCIPLINE_IS_NOT_VALID, details, field);
-
- // mnemonic path
- validateStructuresMnemonicpathDuplicate(type, !StringUtils.equals(path[0], path[1]), details, field);
-
- List<String> mnemonicPaths = StructureUtil.getMnemonicPathsDeviceType(holder, false, namingConvention);
- for (String existingPath : mnemonicPaths) {
- validateStructuresMnemonicpathDuplicate(type, !StringUtils.equals(mnemonicpath, existingPath), details, field);
- }
-
- // mnemonic path equivalence
- validateStructuresMnemonicpathDuplicate(type, !StringUtils.equals(namingConvention.equivalenceClassRepresentative(path[0]), namingConvention.equivalenceClassRepresentative(path[1])), details, field);
-
- mnemonicPaths = StructureUtil.getMnemonicPathsDeviceType(holder, true, namingConvention);
- for (String existingPath : mnemonicPaths) {
- validateStructuresMnemonicpathequivalenceDuplicate(type, !StringUtils.equals(mnemonicpathEquivalence, namingConvention.equivalenceClassRepresentative(existingPath)), details, field);
- }
- }
- }
-
- private static void validateStructuresMnemonicpathNotAvailable(Type type, boolean condition, String details, String field) {
- ExceptionUtil.validateConditionDataNotValidException(condition,
- type.toString().toLowerCase() + TextUtil.SPACE + TextUtil.MNEMONIC_PATH_IS_NOT_AVAILABLE, details, field);
- }
- private static void validateStructuresMnemonicpathNotValid(Type type, boolean condition, String details, String field) {
- ExceptionUtil.validateConditionDataNotValidException(condition,
- type.toString().toLowerCase() + TextUtil.SPACE + TextUtil.MNEMONIC_PATH_IS_NOT_VALID, details, field);
- }
- private static void validateStructuresMnemonicpathDuplicate(Type type, boolean condition, String details, String field) {
- ExceptionUtil.validateConditionDataConflictException(condition,
- type.toString().toLowerCase() + TextUtil.SPACE + TextUtil.MNEMONIC_PATH_HAS_DUPLICATE, details, field);
- }
- private static void validateStructuresMnemonicpathequivalenceDuplicate(Type type, boolean condition, String details, String field) {
- ExceptionUtil.validateConditionDataConflictException(condition,
- type.toString().toLowerCase() + TextUtil.SPACE + TextUtil.MNEMONIC_PATH_EQUIVALENCE_HAS_DUPLICATE, details, field);
- }
-
- // ----------------------------------------------------------------------------------------------------
-
- /**
- * Validate condition if precondition is fulfilled and throw data conflict exception with reason if validation fails.
- *
- * @param precondition precondition
- * @param condition condition
- * @param message message
- * @param details details
- * @param field field
- *
- * @see DataConflictException
- */
- private static void validateConditionIfPrecondition(boolean precondition, boolean condition, String message, String details, String field) {
- if (precondition) {
- ExceptionUtil.validateConditionDataConflictException(condition, message, details, field);
- }
- }
-
- /**
- * 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 message message
- * @param details details
- * @param field field
- *
- * @see DataConflictException
- */
- 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/ValidateUtilTest.java b/src/test/java/org/openepics/names/util/ValidateUtilTest.java
index d2e19534b149286f30c5d179fa3e3dd46a51c159..b4a9910bf5e0934b3c6595298be42500419d03e5 100644
--- a/src/test/java/org/openepics/names/util/ValidateUtilTest.java
+++ b/src/test/java/org/openepics/names/util/ValidateUtilTest.java
@@ -281,7 +281,7 @@ class ValidateUtilTest {
*/
@Test
void validateInputReadNames() {
- ValidateUtil.validateNamesInputRead(
+ ValidateNameElementUtil.validateNamesInputRead(
null, null, null,
null,
null, null,
@@ -293,7 +293,7 @@ class ValidateUtilTest {
*/
@Test
void validateInputCreateNameElement() {
- ValidateUtil.validateNameElementInputCreate(null);
+ ValidateNameElementUtil.validateNameElementInputCreate(null);
}
/**
@@ -301,7 +301,7 @@ class ValidateUtilTest {
*/
@Test
void validateDataCreateNameElement() {
- ValidateUtil.validateNameElementDataCreate(null, null, null, null, null);
+ ValidateNameElementUtil.validateNameElementDataCreate(null, null, null, null, null);
}
/**
@@ -309,14 +309,14 @@ class ValidateUtilTest {
*/
@Test
void validateDataCreateName() {
- ValidateUtil.validateNameDataCreate(null, null, null, null);
+ ValidateNameElementUtil.validateNameDataCreate(null, null, null, null);
}
/**
* Test of validate input update name element.
*/
@Test
void validateInputUpdateNameElement() {
- ValidateUtil.validateNameElementInputUpdate(null);
+ ValidateNameElementUtil.validateNameElementInputUpdate(null);
}
/**
@@ -324,7 +324,7 @@ class ValidateUtilTest {
*/
@Test
void validateDataUpdateNameElement() {
- ValidateUtil.validateNameElementDataUpdate(null, null, null, null, null);
+ ValidateNameElementUtil.validateNameElementDataUpdate(null, null, null, null, null);
}
// ----------------------------------------------------------------------------------------------------
@@ -335,7 +335,7 @@ class ValidateUtilTest {
@Test
void validateInputReadStructuresTypeNull() {
try {
- ValidateUtil.validateStructuresInputRead(
+ ValidateStructureElementUtil.validateStructuresInputRead(
null, null, null, null, null,
null,
null, null,
@@ -352,32 +352,32 @@ class ValidateUtilTest {
*/
@Test
void validateInputReadStructures() {
- ValidateUtil.validateStructuresInputRead(
+ ValidateStructureElementUtil.validateStructuresInputRead(
Type.SYSTEMGROUP, null, null, null, null,
null,
null, null,
null, null);
- ValidateUtil.validateStructuresInputRead(
+ ValidateStructureElementUtil.validateStructuresInputRead(
Type.SYSTEM, null, null, null, null,
null,
null, null,
null, null);
- ValidateUtil.validateStructuresInputRead(
+ ValidateStructureElementUtil.validateStructuresInputRead(
Type.SUBSYSTEM, null, null, null, null,
null,
null, null,
null, null);
- ValidateUtil.validateStructuresInputRead(
+ ValidateStructureElementUtil.validateStructuresInputRead(
Type.DISCIPLINE, null, null, null, null,
null,
null, null,
null, null);
- ValidateUtil.validateStructuresInputRead(
+ ValidateStructureElementUtil.validateStructuresInputRead(
Type.DEVICEGROUP, null, null, null, null,
null,
null, null,
null, null);
- ValidateUtil.validateStructuresInputRead(
+ ValidateStructureElementUtil.validateStructuresInputRead(
Type.DEVICETYPE, null, null, null, null,
null,
null, null,
@@ -389,7 +389,7 @@ class ValidateUtilTest {
*/
@Test
void validateDataCreateStructureElement() {
- ValidateUtil.validateStructureElementDataCreate(null, null, null, null);
+ ValidateStructureElementUtil.validateStructureElementDataCreate(null, null, null, null);
}
/**
@@ -397,7 +397,7 @@ class ValidateUtilTest {
*/
@Test
void validateDataCreateStructuret() {
- ValidateUtil.validateStructureDataCreate(null, null, null, null, null);
+ ValidateStructureElementUtil.validateStructureDataCreate(null, null, null, null, null);
}
/**
@@ -405,7 +405,7 @@ class ValidateUtilTest {
*/
@Test
void validateInputUpdateStructureElement() {
- ValidateUtil.validateStructureElementInputUpdate(null, null);
+ ValidateStructureElementUtil.validateStructureElementInputUpdate(null, null);
}
/**
@@ -413,7 +413,7 @@ class ValidateUtilTest {
*/
@Test
void validateDataUpdateStructureElement() {
- ValidateUtil.validateStructureElementDataUpdate(null, null, null, null);
+ ValidateStructureElementUtil.validateStructureElementDataUpdate(null, null, null, null);
}
}