From 6f7828fd64fd95e057b338ccf0d8111c9bf30374 Mon Sep 17 00:00:00 2001
From: Lars Johansson <lars.johansson@ess.eu>
Date: Tue, 12 Jul 2022 14:44:03 +0200
Subject: [PATCH] Refactor REST API for structures
Use parameters one-by-one instead of arrays.
Purpose to improve usability.
---
.../repository/DeviceGroupRepository.java | 205 ++++++------
.../repository/DeviceTypeRepository.java | 205 ++++++------
.../repository/DisciplineRepository.java | 194 ++++++------
.../names/repository/SubsystemRepository.java | 205 ++++++------
.../repository/SystemGroupRepository.java | 192 ++++++-----
.../names/repository/SystemRepository.java | 204 ++++++------
.../names/rest/api/v1/IStructures.java | 95 ++++--
.../rest/controller/ReportController.java | 12 +-
.../rest/controller/StructuresController.java | 36 +--
.../names/service/StructuresService.java | 298 ++++++++++--------
.../names/util/ValidateNameElementUtil.java | 13 +-
.../util/ValidateStructureElementUtil.java | 129 ++++----
.../names/docker/StructuresDeviceGroupIT.java | 116 +++----
.../names/docker/StructuresDeviceTypeIT.java | 116 +++----
.../names/docker/StructuresDisciplineIT.java | 116 +++----
.../names/docker/StructuresSubsystemIT.java | 116 +++----
.../names/docker/StructuresSystemGroupIT.java | 116 +++----
.../names/docker/StructuresSystemIT.java | 116 +++----
.../names/util/ValidateUtilTest.java | 49 ++-
19 files changed, 1274 insertions(+), 1259 deletions(-)
diff --git a/src/main/java/org/openepics/names/repository/DeviceGroupRepository.java b/src/main/java/org/openepics/names/repository/DeviceGroupRepository.java
index 40640ef8..db47eb06 100644
--- a/src/main/java/org/openepics/names/repository/DeviceGroupRepository.java
+++ b/src/main/java/org/openepics/names/repository/DeviceGroupRepository.java
@@ -31,12 +31,15 @@ import javax.persistence.criteria.Root;
import javax.persistence.criteria.Subquery;
import org.apache.commons.lang3.BooleanUtils;
+import org.apache.commons.lang3.StringUtils;
import org.openepics.names.repository.model.DeviceGroup;
import org.openepics.names.repository.model.NameStructure;
import org.openepics.names.repository.model.Persistable;
import org.openepics.names.repository.model.Structure;
+import org.openepics.names.repository.model.System;
import org.openepics.names.rest.beans.FieldStructure;
import org.openepics.names.rest.beans.Status;
+import org.openepics.names.util.RepositoryUtil;
import org.springframework.stereotype.Repository;
/**
@@ -47,8 +50,6 @@ import org.springframework.stereotype.Repository;
@Repository
public class DeviceGroupRepository {
- private static final String PERCENT = "%";
-
@PersistenceContext
private EntityManager em;
@@ -57,13 +58,20 @@ public class DeviceGroupRepository {
*
* @param statuses statuses
* @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
+ * @param uuid uuid
+ * @param parentUuid parent uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @return count of device groups
*/
- public Long countDeviceGroups(
- Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues) {
- return countDeviceGroups(statuses, deleted, queryFields, queryValues, Boolean.FALSE);
+ public Long countDeviceGroups(Status[] statuses, Boolean deleted,
+ String uuid, String parentUuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description) {
+ return countDeviceGroups(statuses, deleted,
+ uuid, parentUuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ Boolean.FALSE);
}
/**
@@ -71,13 +79,19 @@ public class DeviceGroupRepository {
*
* @param statuses statuses
* @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
+ * @param uuid uuid
+ * @param parentUuid parent uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @param includeHistory include history
* @return count of device groups
*/
- public Long countDeviceGroups(
- Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues, Boolean includeHistory) {
+ public Long countDeviceGroups(Status[] statuses, Boolean deleted,
+ String uuid, String parentUuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description,
+ Boolean includeHistory) {
// note
// use of function for mnemonic path
@@ -90,7 +104,9 @@ public class DeviceGroupRepository {
CriteriaQuery<Long> cq = cb.createQuery(Long.class);
Root<DeviceGroup> from = cq.from(DeviceGroup.class);
- cq.where(cb.and(preparePredicatesDeviceGroups(cb, from, cq.subquery(Long.class), statuses, deleted, queryFields, queryValues, includeHistory).toArray(new Predicate[0])));
+ cq.where(cb.and(preparePredicatesDeviceGroups(cb, from, cq.subquery(Long.class), statuses, deleted,
+ uuid, parentUuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ includeHistory).toArray(new Predicate[0])));
cq.select(cb.count(from));
return em.createQuery(cq).getSingleResult();
@@ -101,41 +117,21 @@ public class DeviceGroupRepository {
*
* @param status status
* @param deleted deleted
- * @param queryField query field
- * @param queryValue query value
+ * @param uuid uuid
+ * @param parentUuid parent uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @return list of device groups
*/
- public List<DeviceGroup> readDeviceGroups(
- Status status, Boolean deleted, FieldStructure queryField, String queryValue) {
-
- return readDeviceGroups(
- status != null ? new Status[] {status} : null,
- deleted,
- queryField != null ? new FieldStructure[] {queryField} : null,
- queryValue != null ? new String[] {queryValue} : null,
- Boolean.FALSE,
- null, null, null, null);
- }
+ public List<DeviceGroup> readDeviceGroups(Status status, Boolean deleted,
+ String uuid, String parentUuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description) {
- /**
- * Find device groups.
- *
- * @param status status
- * @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
- * @return list of device groups
- */
- public List<DeviceGroup> readDeviceGroups(
- Status status, Boolean deleted, FieldStructure[] queryFields, String[] queryValues) {
-
- return readDeviceGroups(
- status != null ? new Status[] {status} : null,
- deleted,
- queryFields,
- queryValues,
- Boolean.FALSE,
- null, null, null, null);
+ return readDeviceGroups(status != null ? new Status[] {status} : null, deleted,
+ uuid, parentUuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ Boolean.FALSE, null, null, null, null);
}
/**
@@ -143,20 +139,25 @@ public class DeviceGroupRepository {
*
* @param statuses statuses
* @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
+ * @param uuid uuid
+ * @param parentUuid parent uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @param orderBy order by
* @param isAsc is ascending
* @param offset offset
* @param limit limit
* @return list of device groups
*/
- public List<DeviceGroup> readDeviceGroups(
- Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues,
+ public List<DeviceGroup> readDeviceGroups(Status[] statuses, Boolean deleted,
+ String uuid, String parentUuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description,
FieldStructure orderBy, Boolean isAsc, Integer offset, Integer limit) {
- return readDeviceGroups(
- statuses, deleted, queryFields, queryValues, Boolean.FALSE,
- orderBy, isAsc, offset, limit);
+ return readDeviceGroups(statuses, deleted,
+ uuid, parentUuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ Boolean.FALSE, orderBy, isAsc, offset, limit);
}
/**
@@ -164,8 +165,13 @@ public class DeviceGroupRepository {
*
* @param statuses statuses
* @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
+ * @param uuid uuid
+ * @param parentUuid parent uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @param includeHistory include history
* @param orderBy order by
* @param isAsc is ascending
@@ -173,9 +179,9 @@ public class DeviceGroupRepository {
* @param limit limit
* @return list of device groups
*/
- public List<DeviceGroup> readDeviceGroups(
- Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues, Boolean includeHistory,
- FieldStructure orderBy, Boolean isAsc, Integer offset, Integer limit) {
+ public List<DeviceGroup> readDeviceGroups(Status[] statuses, Boolean deleted,
+ String uuid, String parentUuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description,
+ Boolean includeHistory, FieldStructure orderBy, Boolean isAsc, Integer offset, Integer limit) {
// note
// use of function for mnemonic path
@@ -192,7 +198,9 @@ public class DeviceGroupRepository {
CriteriaQuery<DeviceGroup> cq = cb.createQuery(DeviceGroup.class);
Root<DeviceGroup> from = cq.from(DeviceGroup.class);
- cq.where(cb.and(preparePredicatesDeviceGroups(cb, from, cq.subquery(Long.class), statuses, deleted, queryFields, queryValues, includeHistory).toArray(new Predicate[0])));
+ cq.where(cb.and(preparePredicatesDeviceGroups(cb, from, cq.subquery(Long.class), statuses, deleted,
+ uuid, parentUuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ includeHistory).toArray(new Predicate[0])));
cq.select(from);
if (orderBy != null) {
@@ -248,14 +256,19 @@ public class DeviceGroupRepository {
* @param sub sub query to be used if history not included
* @param statuses statuses
* @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
+ * @param uuid uuid
+ * @param parentUuid parent uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @param includeHistory include history
* @return list of predicates
*/
- private List<Predicate> preparePredicatesDeviceGroups(
- CriteriaBuilder cb, Root<DeviceGroup> from, Subquery<Long> sub,
- Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues, Boolean includeHistory) {
+ private List<Predicate> preparePredicatesDeviceGroups(CriteriaBuilder cb, Root<DeviceGroup> from, Subquery<Long> sub, Status[] statuses, Boolean deleted,
+ String uuid, String parentUuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description,
+ Boolean includeHistory) {
List<Predicate> predicates = new ArrayList<>();
@@ -307,51 +320,31 @@ public class DeviceGroupRepository {
if (deleted != null) {
predicates.add(cb.equal(from.get(NameStructure.FIELD_DELETED), deleted));
}
- if (queryFields != null) {
- for (int i=0; i<queryFields.length; i++) {
- String queryValue = queryValues[i];
-
- // jpa query characters % and _
- // remove excess % characters
- if (queryValue.startsWith(PERCENT)) {
- while (queryValue.startsWith(PERCENT)) {
- queryValue = queryValue.substring(1);
- }
- queryValue = PERCENT + queryValue;
- }
- if (queryValue.endsWith(PERCENT)) {
- while (queryValue.endsWith(PERCENT)) {
- queryValue = queryValue.substring(0, queryValue.length()-1);
- }
- queryValue = queryValue + PERCENT;
- }
- switch (queryFields[i]) {
- case UUID:
- predicates.add(cb.and(cb.equal(from.get(NameStructure.FIELD_UUID), queryValue)));
- break;
- case PARENT:
- predicates.add(cb.and(cb.equal(from.get(DeviceGroup.FIELD_PARENT_UUID), queryValue)));
- break;
- case NAME:
- predicates.add(cb.and(cb.like(from.get(Structure.FIELD_NAME), queryValue)));
- break;
- case MNEMONIC:
- predicates.add(cb.and(cb.like(from.get(Structure.FIELD_MNEMONIC), queryValue)));
- break;
- case MNEMONICEQUIVALENCE:
- predicates.add(cb.and(cb.like(from.get(Structure.FIELD_MNEMONIC_EQUIVALENCE), queryValue)));
- break;
- case MNEMONICPATH:
- predicates.add(cb.and(cb.like(cb.function(DeviceGroup.FUNCTION_GET_MNEMONIC_PATH_DEVICEGROUP, String.class, from.get(NameStructure.FIELD_UUID)), queryValue)));
- break;
- case DESCRIPTION:
- predicates.add(cb.and(cb.like(from.get(NameStructure.FIELD_DESCRIPTION), queryValue)));
- break;
- default:
- continue;
- }
- }
+ // prepare pattern
+ // jpa query characters % and _
+ // remove excess % characters
+
+ if (!StringUtils.isEmpty(uuid)) {
+ predicates.add(cb.and(cb.equal(from.get(NameStructure.FIELD_UUID), RepositoryUtil.preparePattern(uuid))));
+ }
+ if (!StringUtils.isEmpty(parentUuid)) {
+ predicates.add(cb.and(cb.equal(from.get(System.FIELD_PARENT_UUID), RepositoryUtil.preparePattern(parentUuid))));
+ }
+ if (!StringUtils.isEmpty(name)) {
+ predicates.add(cb.and(cb.like(from.get(Structure.FIELD_NAME), RepositoryUtil.preparePattern(name))));
+ }
+ if (!StringUtils.isEmpty(mnemonic)) {
+ predicates.add(cb.and(cb.like(from.get(Structure.FIELD_MNEMONIC), RepositoryUtil.preparePattern(mnemonic))));
+ }
+ if (!StringUtils.isEmpty(mnemonicequivalence)) {
+ predicates.add(cb.and(cb.like(from.get(Structure.FIELD_MNEMONIC_EQUIVALENCE), RepositoryUtil.preparePattern(mnemonicequivalence))));
+ }
+ if (!StringUtils.isEmpty(mnemonicpath)) {
+ predicates.add(cb.and(cb.like(cb.function(DeviceGroup.FUNCTION_GET_MNEMONIC_PATH_DEVICEGROUP, String.class, from.get(NameStructure.FIELD_UUID)), RepositoryUtil.preparePattern(mnemonicpath))));
+ }
+ if (!StringUtils.isEmpty(description)) {
+ predicates.add(cb.and(cb.like(from.get(NameStructure.FIELD_DESCRIPTION), RepositoryUtil.preparePattern(description))));
}
return predicates;
diff --git a/src/main/java/org/openepics/names/repository/DeviceTypeRepository.java b/src/main/java/org/openepics/names/repository/DeviceTypeRepository.java
index 1c6449d0..b3eca34d 100644
--- a/src/main/java/org/openepics/names/repository/DeviceTypeRepository.java
+++ b/src/main/java/org/openepics/names/repository/DeviceTypeRepository.java
@@ -31,12 +31,15 @@ import javax.persistence.criteria.Root;
import javax.persistence.criteria.Subquery;
import org.apache.commons.lang3.BooleanUtils;
+import org.apache.commons.lang3.StringUtils;
import org.openepics.names.repository.model.DeviceType;
import org.openepics.names.repository.model.NameStructure;
import org.openepics.names.repository.model.Persistable;
import org.openepics.names.repository.model.Structure;
+import org.openepics.names.repository.model.System;
import org.openepics.names.rest.beans.FieldStructure;
import org.openepics.names.rest.beans.Status;
+import org.openepics.names.util.RepositoryUtil;
import org.springframework.stereotype.Repository;
/**
@@ -47,8 +50,6 @@ import org.springframework.stereotype.Repository;
@Repository
public class DeviceTypeRepository {
- private static final String PERCENT = "%";
-
@PersistenceContext
private EntityManager em;
@@ -57,13 +58,20 @@ public class DeviceTypeRepository {
*
* @param statuses statuses
* @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
+ * @param uuid uuid
+ * @param parentUuid parent uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @return count of device types
*/
- public Long countDeviceTypes(
- Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues) {
- return countDeviceTypes(statuses, deleted, queryFields, queryValues, Boolean.FALSE);
+ public Long countDeviceTypes(Status[] statuses, Boolean deleted,
+ String uuid, String parentUuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description) {
+ return countDeviceTypes(statuses, deleted,
+ uuid, parentUuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ Boolean.FALSE);
}
/**
@@ -71,13 +79,19 @@ public class DeviceTypeRepository {
*
* @param statuses statuses
* @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
+ * @param uuid uuid
+ * @param parentUuid parent uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @param includeHistory include history
* @return count of device types
*/
- public Long countDeviceTypes(
- Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues, Boolean includeHistory) {
+ public Long countDeviceTypes(Status[] statuses, Boolean deleted,
+ String uuid, String parentUuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description,
+ Boolean includeHistory) {
// note
// use of function for mnemonic path
@@ -90,7 +104,9 @@ public class DeviceTypeRepository {
CriteriaQuery<Long> cq = cb.createQuery(Long.class);
Root<DeviceType> from = cq.from(DeviceType.class);
- cq.where(cb.and(preparePredicatesDeviceTypes(cb, from, cq.subquery(Long.class), statuses, deleted, queryFields, queryValues, includeHistory).toArray(new Predicate[0])));
+ cq.where(cb.and(preparePredicatesDeviceTypes(cb, from, cq.subquery(Long.class), statuses, deleted,
+ uuid, parentUuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ includeHistory).toArray(new Predicate[0])));
cq.select(cb.count(from));
return em.createQuery(cq).getSingleResult();
@@ -101,41 +117,21 @@ public class DeviceTypeRepository {
*
* @param status status
* @param deleted deleted
- * @param queryField query field
- * @param queryValue query value
+ * @param uuid uuid
+ * @param parentUuid parent uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @return list of device types
*/
- public List<DeviceType> readDeviceTypes(
- Status status, Boolean deleted, FieldStructure queryField, String queryValue) {
-
- return readDeviceTypes(
- status != null ? new Status[] {status} : null,
- deleted,
- queryField != null ? new FieldStructure[] {queryField} : null,
- queryValue != null ? new String[] {queryValue} : null,
- Boolean.FALSE,
- null, null, null, null);
- }
+ public List<DeviceType> readDeviceTypes(Status status, Boolean deleted,
+ String uuid, String parentUuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description) {
- /**
- * Find device types.
- *
- * @param status status
- * @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
- * @return list of device types
- */
- public List<DeviceType> readDeviceTypes(
- Status status, Boolean deleted, FieldStructure[] queryFields, String[] queryValues) {
-
- return readDeviceTypes(
- status != null ? new Status[] {status} : null,
- deleted,
- queryFields,
- queryValues,
- Boolean.FALSE,
- null, null, null, null);
+ return readDeviceTypes(status != null ? new Status[] {status} : null, deleted,
+ uuid, parentUuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ Boolean.FALSE, null, null, null, null);
}
/**
@@ -143,20 +139,25 @@ public class DeviceTypeRepository {
*
* @param statuses statuses
* @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
+ * @param uuid uuid
+ * @param parentUuid parent uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @param orderBy order by
* @param isAsc is ascending
* @param offset offset
* @param limit limit
* @return list of device types
*/
- public List<DeviceType> readDeviceTypes(
- Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues,
+ public List<DeviceType> readDeviceTypes(Status[] statuses, Boolean deleted,
+ String uuid, String parentUuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description,
FieldStructure orderBy, Boolean isAsc, Integer offset, Integer limit) {
- return readDeviceTypes(
- statuses, deleted, queryFields, queryValues, Boolean.FALSE,
- orderBy, isAsc, offset, limit);
+ return readDeviceTypes(statuses, deleted,
+ uuid, parentUuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ Boolean.FALSE, orderBy, isAsc, offset, limit);
}
/**
@@ -164,8 +165,13 @@ public class DeviceTypeRepository {
*
* @param statuses statuses
* @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
+ * @param uuid uuid
+ * @param parentUuid parent uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @param includeHistory include history
* @param orderBy order by
* @param isAsc is ascending
@@ -173,9 +179,9 @@ public class DeviceTypeRepository {
* @param limit limit
* @return list of device types
*/
- public List<DeviceType> readDeviceTypes(
- Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues, Boolean includeHistory,
- FieldStructure orderBy, Boolean isAsc, Integer offset, Integer limit) {
+ public List<DeviceType> readDeviceTypes(Status[] statuses, Boolean deleted,
+ String uuid, String parentUuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description,
+ Boolean includeHistory, FieldStructure orderBy, Boolean isAsc, Integer offset, Integer limit) {
// note
// use of function for mnemonic path
@@ -192,7 +198,9 @@ public class DeviceTypeRepository {
CriteriaQuery<DeviceType> cq = cb.createQuery(DeviceType.class);
Root<DeviceType> from = cq.from(DeviceType.class);
- cq.where(cb.and(preparePredicatesDeviceTypes(cb, from, cq.subquery(Long.class), statuses, deleted, queryFields, queryValues, includeHistory).toArray(new Predicate[0])));
+ cq.where(cb.and(preparePredicatesDeviceTypes(cb, from, cq.subquery(Long.class), statuses, deleted,
+ uuid, parentUuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ includeHistory).toArray(new Predicate[0])));
cq.select(from);
if (orderBy != null) {
@@ -248,14 +256,19 @@ public class DeviceTypeRepository {
* @param sub sub query to be used if history not included
* @param statuses statuses
* @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
+ * @param uuid uuid
+ * @param parentUuid parent uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @param includeHistory include history
* @return list of predicates
*/
- private List<Predicate> preparePredicatesDeviceTypes(
- CriteriaBuilder cb, Root<DeviceType> from, Subquery<Long> sub,
- Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues, Boolean includeHistory) {
+ private List<Predicate> preparePredicatesDeviceTypes(CriteriaBuilder cb, Root<DeviceType> from, Subquery<Long> sub, Status[] statuses, Boolean deleted,
+ String uuid, String parentUuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description,
+ Boolean includeHistory) {
List<Predicate> predicates = new ArrayList<>();
@@ -307,51 +320,31 @@ public class DeviceTypeRepository {
if (deleted != null) {
predicates.add(cb.equal(from.get(NameStructure.FIELD_DELETED), deleted));
}
- if (queryFields != null) {
- for (int i=0; i<queryFields.length; i++) {
- String queryValue = queryValues[i];
-
- // jpa query characters % and _
- // remove excess % characters
- if (queryValue.startsWith(PERCENT)) {
- while (queryValue.startsWith(PERCENT)) {
- queryValue = queryValue.substring(1);
- }
- queryValue = PERCENT + queryValue;
- }
- if (queryValue.endsWith(PERCENT)) {
- while (queryValue.endsWith(PERCENT)) {
- queryValue = queryValue.substring(0, queryValue.length()-1);
- }
- queryValue = queryValue + PERCENT;
- }
- switch (queryFields[i]) {
- case UUID:
- predicates.add(cb.and(cb.equal(from.get(NameStructure.FIELD_UUID), queryValue)));
- break;
- case PARENT:
- predicates.add(cb.and(cb.equal(from.get(DeviceType.FIELD_PARENT_UUID), queryValue)));
- break;
- case NAME:
- predicates.add(cb.and(cb.like(from.get(Structure.FIELD_NAME), queryValue)));
- break;
- case MNEMONIC:
- predicates.add(cb.and(cb.like(from.get(Structure.FIELD_MNEMONIC), queryValue)));
- break;
- case MNEMONICEQUIVALENCE:
- predicates.add(cb.and(cb.like(from.get(Structure.FIELD_MNEMONIC_EQUIVALENCE), queryValue)));
- break;
- case MNEMONICPATH:
- predicates.add(cb.and(cb.like(cb.function(DeviceType.FUNCTION_GET_MNEMONIC_PATH_DEVICETYPE, String.class, from.get(NameStructure.FIELD_UUID)), queryValue)));
- break;
- case DESCRIPTION:
- predicates.add(cb.and(cb.like(from.get(NameStructure.FIELD_DESCRIPTION), queryValue)));
- break;
- default:
- continue;
- }
- }
+ // prepare pattern
+ // jpa query characters % and _
+ // remove excess % characters
+
+ if (!StringUtils.isEmpty(uuid)) {
+ predicates.add(cb.and(cb.equal(from.get(NameStructure.FIELD_UUID), RepositoryUtil.preparePattern(uuid))));
+ }
+ if (!StringUtils.isEmpty(parentUuid)) {
+ predicates.add(cb.and(cb.equal(from.get(System.FIELD_PARENT_UUID), RepositoryUtil.preparePattern(parentUuid))));
+ }
+ if (!StringUtils.isEmpty(name)) {
+ predicates.add(cb.and(cb.like(from.get(Structure.FIELD_NAME), RepositoryUtil.preparePattern(name))));
+ }
+ if (!StringUtils.isEmpty(mnemonic)) {
+ predicates.add(cb.and(cb.like(from.get(Structure.FIELD_MNEMONIC), RepositoryUtil.preparePattern(mnemonic))));
+ }
+ if (!StringUtils.isEmpty(mnemonicequivalence)) {
+ predicates.add(cb.and(cb.like(from.get(Structure.FIELD_MNEMONIC_EQUIVALENCE), RepositoryUtil.preparePattern(mnemonicequivalence))));
+ }
+ if (!StringUtils.isEmpty(mnemonicpath)) {
+ predicates.add(cb.and(cb.like(cb.function(DeviceType.FUNCTION_GET_MNEMONIC_PATH_DEVICETYPE, String.class, from.get(NameStructure.FIELD_UUID)), RepositoryUtil.preparePattern(mnemonicpath))));
+ }
+ if (!StringUtils.isEmpty(description)) {
+ predicates.add(cb.and(cb.like(from.get(NameStructure.FIELD_DESCRIPTION), RepositoryUtil.preparePattern(description))));
}
return predicates;
diff --git a/src/main/java/org/openepics/names/repository/DisciplineRepository.java b/src/main/java/org/openepics/names/repository/DisciplineRepository.java
index 043b888d..9eb3ecbe 100644
--- a/src/main/java/org/openepics/names/repository/DisciplineRepository.java
+++ b/src/main/java/org/openepics/names/repository/DisciplineRepository.java
@@ -31,12 +31,14 @@ import javax.persistence.criteria.Root;
import javax.persistence.criteria.Subquery;
import org.apache.commons.lang3.BooleanUtils;
+import org.apache.commons.lang3.StringUtils;
import org.openepics.names.repository.model.Discipline;
import org.openepics.names.repository.model.NameStructure;
import org.openepics.names.repository.model.Persistable;
import org.openepics.names.repository.model.Structure;
import org.openepics.names.rest.beans.FieldStructure;
import org.openepics.names.rest.beans.Status;
+import org.openepics.names.util.RepositoryUtil;
import org.springframework.stereotype.Repository;
/**
@@ -47,8 +49,6 @@ import org.springframework.stereotype.Repository;
@Repository
public class DisciplineRepository {
- private static final String PERCENT = "%";
-
@PersistenceContext
private EntityManager em;
@@ -57,13 +57,19 @@ public class DisciplineRepository {
*
* @param statuses statuses
* @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
+ * @param uuid uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @return count of disciplines
*/
- public Long countDisciplines(
- Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues) {
- return countDisciplines(statuses, deleted, queryFields, queryValues, Boolean.FALSE);
+ public Long countDisciplines(Status[] statuses, Boolean deleted,
+ String uuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description) {
+ return countDisciplines(statuses, deleted,
+ uuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ Boolean.FALSE);
}
/**
@@ -71,13 +77,18 @@ public class DisciplineRepository {
*
* @param statuses statuses
* @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
+ * @param uuid uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @param includeHistory include history
* @return count of disciplines
*/
- public Long countDisciplines(
- Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues, Boolean includeHistory) {
+ public Long countDisciplines(Status[] statuses, Boolean deleted,
+ String uuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description,
+ Boolean includeHistory) {
// note
// use of function for mnemonic path
@@ -90,52 +101,33 @@ public class DisciplineRepository {
CriteriaQuery<Long> cq = cb.createQuery(Long.class);
Root<Discipline> from = cq.from(Discipline.class);
- cq.where(cb.and(preparePredicatesDisciplines(cb, from, cq.subquery(Long.class), statuses, deleted, queryFields, queryValues, includeHistory).toArray(new Predicate[0])));
+ cq.where(cb.and(preparePredicatesDisciplines(cb, from, cq.subquery(Long.class), statuses, deleted,
+ uuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ includeHistory).toArray(new Predicate[0])));
cq.select(cb.count(from));
return em.createQuery(cq).getSingleResult();
}
- /**
- *Find disciplines.
- *
- * @param status status
- * @param deleted deleted
- * @param queryField query field
- * @param queryValue query value
- * @return list of disciplines
- */
- public List<Discipline> readDisciplines(
- Status status, Boolean deleted, FieldStructure queryField, String queryValue) {
-
- return readDisciplines(
- status != null ? new Status[] {status} : null,
- deleted,
- queryField != null ? new FieldStructure[] {queryField} : null,
- queryValue != null ? new String[] {queryValue} : null,
- Boolean.FALSE,
- null, null, null, null);
- }
-
/**
* Find disciplines.
*
* @param status status
* @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
+ * @param uuid uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @return list of disciplines
*/
- public List<Discipline> readDisciplines(
- Status status, Boolean deleted, FieldStructure[] queryFields, String[] queryValues) {
-
- return readDisciplines(
- status != null ? new Status[] {status} : null,
- deleted,
- queryFields,
- queryValues,
- Boolean.FALSE,
- null, null, null, null);
+ public List<Discipline> readDisciplines(Status status, Boolean deleted,
+ String uuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description) {
+
+ return readDisciplines(status != null ? new Status[] {status} : null, deleted,
+ uuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ Boolean.FALSE, null, null, null, null);
}
/**
@@ -143,20 +135,24 @@ public class DisciplineRepository {
*
* @param statuses statuses
* @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
+ * @param uuid uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @param orderBy order by
* @param isAsc is ascending
* @param offset offset
* @param limit limit
* @return list of disciplines
*/
- public List<Discipline> readDisciplines(
- Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues,
+ public List<Discipline> readDisciplines(Status[] statuses, Boolean deleted,
+ String uuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description,
FieldStructure orderBy, Boolean isAsc, Integer offset, Integer limit) {
- return readDisciplines(
- statuses, deleted, queryFields, queryValues, Boolean.FALSE,
- orderBy, isAsc, offset, limit);
+ return readDisciplines(statuses, deleted,
+ uuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ Boolean.FALSE, orderBy, isAsc, offset, limit);
}
/**
@@ -164,8 +160,12 @@ public class DisciplineRepository {
*
* @param statuses statuses
* @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
+ * @param uuid uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @param includeHistory include history
* @param orderBy order by
* @param isAsc is ascending
@@ -173,9 +173,9 @@ public class DisciplineRepository {
* @param limit limit
* @return list of disciplines
*/
- public List<Discipline> readDisciplines(
- Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues, Boolean includeHistory,
- FieldStructure orderBy, Boolean isAsc, Integer offset, Integer limit) {
+ public List<Discipline> readDisciplines(Status[] statuses, Boolean deleted,
+ String uuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description,
+ Boolean includeHistory, FieldStructure orderBy, Boolean isAsc, Integer offset, Integer limit) {
// note
// use of function for mnemonic path
@@ -192,7 +192,9 @@ public class DisciplineRepository {
CriteriaQuery<Discipline> cq = cb.createQuery(Discipline.class);
Root<Discipline> from = cq.from(Discipline.class);
- cq.where(cb.and(preparePredicatesDisciplines(cb, from, cq.subquery(Long.class), statuses, deleted, queryFields, queryValues, includeHistory).toArray(new Predicate[0])));
+ cq.where(cb.and(preparePredicatesDisciplines(cb, from, cq.subquery(Long.class), statuses, deleted,
+ uuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ includeHistory).toArray(new Predicate[0])));
cq.select(from);
if (orderBy != null) {
@@ -248,14 +250,18 @@ public class DisciplineRepository {
* @param sub sub query to be used if history not included
* @param statuses statuses
* @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
+ * @param uuid uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @param includeHistory include history
* @return list of predicates
*/
- private List<Predicate> preparePredicatesDisciplines(
- CriteriaBuilder cb, Root<Discipline> from, Subquery<Long> sub,
- Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues, Boolean includeHistory) {
+ private List<Predicate> preparePredicatesDisciplines(CriteriaBuilder cb, Root<Discipline> from, Subquery<Long> sub, Status[] statuses, Boolean deleted,
+ String uuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description,
+ Boolean includeHistory) {
List<Predicate> predicates = new ArrayList<>();
@@ -307,48 +313,28 @@ public class DisciplineRepository {
if (deleted != null) {
predicates.add(cb.equal(from.get(NameStructure.FIELD_DELETED), deleted));
}
- if (queryFields != null) {
- for (int i=0; i<queryFields.length; i++) {
- String queryValue = queryValues[i];
-
- // jpa query characters % and _
- // remove excess % characters
- if (queryValue.startsWith(PERCENT)) {
- while (queryValue.startsWith(PERCENT)) {
- queryValue = queryValue.substring(1);
- }
- queryValue = PERCENT + queryValue;
- }
- if (queryValue.endsWith(PERCENT)) {
- while (queryValue.endsWith(PERCENT)) {
- queryValue = queryValue.substring(0, queryValue.length()-1);
- }
- queryValue = queryValue + PERCENT;
- }
- switch (queryFields[i]) {
- case UUID:
- predicates.add(cb.and(cb.equal(from.get(NameStructure.FIELD_UUID), queryValue)));
- break;
- case NAME:
- predicates.add(cb.and(cb.like(from.get(Structure.FIELD_NAME), queryValue)));
- break;
- case MNEMONIC:
- predicates.add(cb.and(cb.like(from.get(Structure.FIELD_MNEMONIC), queryValue)));
- break;
- case MNEMONICEQUIVALENCE:
- predicates.add(cb.and(cb.like(from.get(Structure.FIELD_MNEMONIC_EQUIVALENCE), queryValue)));
- break;
- case MNEMONICPATH:
- predicates.add(cb.and(cb.like(from.get(Structure.FIELD_MNEMONIC), queryValue)));
- break;
- case DESCRIPTION:
- predicates.add(cb.and(cb.like(from.get(NameStructure.FIELD_DESCRIPTION), queryValue)));
- break;
- default:
- continue;
- }
- }
+ // prepare pattern
+ // jpa query characters % and _
+ // remove excess % characters
+
+ if (!StringUtils.isEmpty(uuid)) {
+ predicates.add(cb.and(cb.equal(from.get(NameStructure.FIELD_UUID), RepositoryUtil.preparePattern(uuid))));
+ }
+ if (!StringUtils.isEmpty(name)) {
+ predicates.add(cb.and(cb.like(from.get(Structure.FIELD_NAME), RepositoryUtil.preparePattern(name))));
+ }
+ if (!StringUtils.isEmpty(mnemonic)) {
+ predicates.add(cb.and(cb.like(from.get(Structure.FIELD_MNEMONIC), RepositoryUtil.preparePattern(mnemonic))));
+ }
+ if (!StringUtils.isEmpty(mnemonicequivalence)) {
+ predicates.add(cb.and(cb.like(from.get(Structure.FIELD_MNEMONIC_EQUIVALENCE), RepositoryUtil.preparePattern(mnemonicequivalence))));
+ }
+ if (!StringUtils.isEmpty(mnemonicpath)) {
+ predicates.add(cb.and(cb.like(from.get(Structure.FIELD_MNEMONIC), RepositoryUtil.preparePattern(mnemonicpath))));
+ }
+ if (!StringUtils.isEmpty(description)) {
+ predicates.add(cb.and(cb.like(from.get(NameStructure.FIELD_DESCRIPTION), RepositoryUtil.preparePattern(description))));
}
return predicates;
diff --git a/src/main/java/org/openepics/names/repository/SubsystemRepository.java b/src/main/java/org/openepics/names/repository/SubsystemRepository.java
index 0cd577f3..be409abc 100644
--- a/src/main/java/org/openepics/names/repository/SubsystemRepository.java
+++ b/src/main/java/org/openepics/names/repository/SubsystemRepository.java
@@ -31,12 +31,15 @@ import javax.persistence.criteria.Root;
import javax.persistence.criteria.Subquery;
import org.apache.commons.lang3.BooleanUtils;
+import org.apache.commons.lang3.StringUtils;
import org.openepics.names.repository.model.NameStructure;
import org.openepics.names.repository.model.Persistable;
import org.openepics.names.repository.model.Structure;
import org.openepics.names.repository.model.Subsystem;
+import org.openepics.names.repository.model.System;
import org.openepics.names.rest.beans.FieldStructure;
import org.openepics.names.rest.beans.Status;
+import org.openepics.names.util.RepositoryUtil;
import org.springframework.stereotype.Repository;
/**
@@ -47,8 +50,6 @@ import org.springframework.stereotype.Repository;
@Repository
public class SubsystemRepository {
- private static final String PERCENT = "%";
-
@PersistenceContext
private EntityManager em;
@@ -57,13 +58,20 @@ public class SubsystemRepository {
*
* @param statuses statuses
* @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
+ * @param uuid uuid
+ * @param parentUuid parent uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @return count of subsystems
*/
- public Long countSubsystems(
- Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues) {
- return countSubsystems(statuses, deleted, queryFields, queryValues, Boolean.FALSE);
+ public Long countSubsystems(Status[] statuses, Boolean deleted,
+ String uuid, String parentUuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description) {
+ return countSubsystems(statuses, deleted,
+ uuid, parentUuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ Boolean.FALSE);
}
/**
@@ -71,13 +79,19 @@ public class SubsystemRepository {
*
* @param statuses statuses
* @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
+ * @param uuid uuid
+ * @param parentUuid parent uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @param includeHistory include history
* @return count of subsystems
*/
- public Long countSubsystems(
- Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues, Boolean includeHistory) {
+ public Long countSubsystems(Status[] statuses, Boolean deleted,
+ String uuid, String parentUuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description,
+ Boolean includeHistory) {
// note
// use of function for mnemonic path
@@ -90,7 +104,9 @@ public class SubsystemRepository {
CriteriaQuery<Long> cq = cb.createQuery(Long.class);
Root<Subsystem> from = cq.from(Subsystem.class);
- cq.where(cb.and(preparePredicatesSubsystems(cb, from, cq.subquery(Long.class), statuses, deleted, queryFields, queryValues, includeHistory).toArray(new Predicate[0])));
+ cq.where(cb.and(preparePredicatesSubsystems(cb, from, cq.subquery(Long.class), statuses, deleted,
+ uuid, parentUuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ includeHistory).toArray(new Predicate[0])));
cq.select(cb.count(from));
return em.createQuery(cq).getSingleResult();
@@ -101,41 +117,21 @@ public class SubsystemRepository {
*
* @param status status
* @param deleted deleted
- * @param queryField query field
- * @param queryValue query value
+ * @param uuid uuid
+ * @param parentUuid parent uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @return list of subsystems
*/
- public List<Subsystem> readSubsystems(
- Status status, Boolean deleted, FieldStructure queryField, String queryValue) {
-
- return readSubsystems(
- status != null ? new Status[] {status} : null,
- deleted,
- queryField != null ? new FieldStructure[] {queryField} : null,
- queryValue != null ? new String[] {queryValue} : null,
- Boolean.FALSE,
- null, null, null, null);
- }
+ public List<Subsystem> readSubsystems(Status status, Boolean deleted,
+ String uuid, String parentUuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description) {
- /**
- * Find subsystems.
- *
- * @param status status
- * @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
- * @return list of subsystems
- */
- public List<Subsystem> readSubsystems(
- Status status, Boolean deleted, FieldStructure[] queryFields, String[] queryValues) {
-
- return readSubsystems(
- status != null ? new Status[] {status} : null,
- deleted,
- queryFields,
- queryValues,
- Boolean.FALSE,
- null, null, null, null);
+ return readSubsystems(status != null ? new Status[] {status} : null, deleted,
+ uuid, parentUuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ Boolean.FALSE, null, null, null, null);
}
/**
@@ -143,20 +139,25 @@ public class SubsystemRepository {
*
* @param statuses statuses
* @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
+ * @param uuid uuid
+ * @param parentUuid parent uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @param orderBy order by
* @param isAsc is ascending
* @param offset offset
* @param limit limit
* @return list of subsystems
*/
- public List<Subsystem> readSubsystems(
- Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues,
+ public List<Subsystem> readSubsystems(Status[] statuses, Boolean deleted,
+ String uuid, String parentUuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description,
FieldStructure orderBy, Boolean isAsc, Integer offset, Integer limit) {
- return readSubsystems(
- statuses, deleted, queryFields, queryValues, Boolean.FALSE,
- orderBy, isAsc, offset, limit);
+ return readSubsystems(statuses, deleted,
+ uuid, parentUuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ Boolean.FALSE, orderBy, isAsc, offset, limit);
}
/**
@@ -164,8 +165,13 @@ public class SubsystemRepository {
*
* @param statuses statuses
* @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
+ * @param uuid uuid
+ * @param parentUuid parent uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @param includeHistory include history
* @param orderBy order by
* @param isAsc is ascending
@@ -173,9 +179,9 @@ public class SubsystemRepository {
* @param limit limit
* @return list of subsystems
*/
- public List<Subsystem> readSubsystems(
- Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues, Boolean includeHistory,
- FieldStructure orderBy, Boolean isAsc, Integer offset, Integer limit) {
+ public List<Subsystem> readSubsystems(Status[] statuses, Boolean deleted,
+ String uuid, String parentUuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description,
+ Boolean includeHistory, FieldStructure orderBy, Boolean isAsc, Integer offset, Integer limit) {
// note
// use of function for mnemonic path
@@ -192,7 +198,9 @@ public class SubsystemRepository {
CriteriaQuery<Subsystem> cq = cb.createQuery(Subsystem.class);
Root<Subsystem> from = cq.from(Subsystem.class);
- cq.where(cb.and(preparePredicatesSubsystems(cb, from, cq.subquery(Long.class), statuses, deleted, queryFields, queryValues, includeHistory).toArray(new Predicate[0])));
+ cq.where(cb.and(preparePredicatesSubsystems(cb, from, cq.subquery(Long.class), statuses, deleted,
+ uuid, parentUuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ includeHistory).toArray(new Predicate[0])));
cq.select(from);
if (orderBy != null) {
@@ -248,14 +256,19 @@ public class SubsystemRepository {
* @param sub sub query to be used if history not included
* @param statuses statuses
* @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
+ * @param uuid uuid
+ * @param parentUuid parent uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @param includeHistory include history
* @return list of predicates
*/
- private List<Predicate> preparePredicatesSubsystems(
- CriteriaBuilder cb, Root<Subsystem> from, Subquery<Long> sub,
- Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues, Boolean includeHistory) {
+ private List<Predicate> preparePredicatesSubsystems(CriteriaBuilder cb, Root<Subsystem> from, Subquery<Long> sub, Status[] statuses, Boolean deleted,
+ String uuid, String parentUuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description,
+ Boolean includeHistory) {
List<Predicate> predicates = new ArrayList<>();
@@ -307,51 +320,31 @@ public class SubsystemRepository {
if (deleted != null) {
predicates.add(cb.equal(from.get(NameStructure.FIELD_DELETED), deleted));
}
- if (queryFields != null) {
- for (int i=0; i<queryFields.length; i++) {
- String queryValue = queryValues[i];
-
- // jpa query characters % and _
- // remove excess % characters
- if (queryValue.startsWith(PERCENT)) {
- while (queryValue.startsWith(PERCENT)) {
- queryValue = queryValue.substring(1);
- }
- queryValue = PERCENT + queryValue;
- }
- if (queryValue.endsWith(PERCENT)) {
- while (queryValue.endsWith(PERCENT)) {
- queryValue = queryValue.substring(0, queryValue.length()-1);
- }
- queryValue = queryValue + PERCENT;
- }
- switch (queryFields[i]) {
- case UUID:
- predicates.add(cb.and(cb.equal(from.get(NameStructure.FIELD_UUID), queryValue)));
- break;
- case PARENT:
- predicates.add(cb.and(cb.equal(from.get(Subsystem.FIELD_PARENT_UUID), queryValue)));
- break;
- case NAME:
- predicates.add(cb.and(cb.like(from.get(Structure.FIELD_NAME), queryValue)));
- break;
- case MNEMONIC:
- predicates.add(cb.and(cb.like(from.get(Structure.FIELD_MNEMONIC), queryValue)));
- break;
- case MNEMONICEQUIVALENCE:
- predicates.add(cb.and(cb.like(from.get(Structure.FIELD_MNEMONIC_EQUIVALENCE), queryValue)));
- break;
- case MNEMONICPATH:
- predicates.add(cb.and(cb.like(cb.function(Subsystem.FUNCTION_GET_MNEMONIC_PATH_SUBSYSTEM, String.class, from.get(NameStructure.FIELD_UUID)), queryValue)));
- break;
- case DESCRIPTION:
- predicates.add(cb.and(cb.like(from.get(NameStructure.FIELD_DESCRIPTION), queryValue)));
- break;
- default:
- continue;
- }
- }
+ // prepare pattern
+ // jpa query characters % and _
+ // remove excess % characters
+
+ if (!StringUtils.isEmpty(uuid)) {
+ predicates.add(cb.and(cb.equal(from.get(NameStructure.FIELD_UUID), RepositoryUtil.preparePattern(uuid))));
+ }
+ if (!StringUtils.isEmpty(parentUuid)) {
+ predicates.add(cb.and(cb.equal(from.get(System.FIELD_PARENT_UUID), RepositoryUtil.preparePattern(parentUuid))));
+ }
+ if (!StringUtils.isEmpty(name)) {
+ predicates.add(cb.and(cb.like(from.get(Structure.FIELD_NAME), RepositoryUtil.preparePattern(name))));
+ }
+ if (!StringUtils.isEmpty(mnemonic)) {
+ predicates.add(cb.and(cb.like(from.get(Structure.FIELD_MNEMONIC), RepositoryUtil.preparePattern(mnemonic))));
+ }
+ if (!StringUtils.isEmpty(mnemonicequivalence)) {
+ predicates.add(cb.and(cb.like(from.get(Structure.FIELD_MNEMONIC_EQUIVALENCE), RepositoryUtil.preparePattern(mnemonicequivalence))));
+ }
+ if (!StringUtils.isEmpty(mnemonicpath)) {
+ predicates.add(cb.and(cb.like(cb.function(Subsystem.FUNCTION_GET_MNEMONIC_PATH_SUBSYSTEM, String.class, from.get(NameStructure.FIELD_UUID)), RepositoryUtil.preparePattern(mnemonicpath))));
+ }
+ if (!StringUtils.isEmpty(description)) {
+ predicates.add(cb.and(cb.like(from.get(NameStructure.FIELD_DESCRIPTION), RepositoryUtil.preparePattern(description))));
}
return predicates;
diff --git a/src/main/java/org/openepics/names/repository/SystemGroupRepository.java b/src/main/java/org/openepics/names/repository/SystemGroupRepository.java
index 23945f05..bc4c0249 100644
--- a/src/main/java/org/openepics/names/repository/SystemGroupRepository.java
+++ b/src/main/java/org/openepics/names/repository/SystemGroupRepository.java
@@ -31,12 +31,14 @@ import javax.persistence.criteria.Root;
import javax.persistence.criteria.Subquery;
import org.apache.commons.lang3.BooleanUtils;
+import org.apache.commons.lang3.StringUtils;
import org.openepics.names.repository.model.NameStructure;
import org.openepics.names.repository.model.Persistable;
import org.openepics.names.repository.model.Structure;
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.util.RepositoryUtil;
import org.springframework.stereotype.Repository;
/**
@@ -47,8 +49,6 @@ import org.springframework.stereotype.Repository;
@Repository
public class SystemGroupRepository {
- private static final String PERCENT = "%";
-
@PersistenceContext
private EntityManager em;
@@ -57,13 +57,19 @@ public class SystemGroupRepository {
*
* @param statuses statuses
* @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
+ * @param uuid uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @return count of system groups
*/
- public Long countSystemGroups(
- Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues) {
- return countSystemGroups(statuses, deleted, queryFields, queryValues, Boolean.FALSE);
+ public Long countSystemGroups(Status[] statuses, Boolean deleted,
+ String uuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description) {
+ return countSystemGroups(statuses, deleted,
+ uuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ Boolean.FALSE);
}
/**
@@ -71,13 +77,18 @@ public class SystemGroupRepository {
*
* @param statuses statuses
* @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
+ * @param uuid uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @param includeHistory include history
* @return count of system groups
*/
- public Long countSystemGroups(
- Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues, Boolean includeHistory) {
+ public Long countSystemGroups(Status[] statuses, Boolean deleted,
+ String uuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description,
+ Boolean includeHistory) {
// where
// statuses
@@ -88,7 +99,9 @@ public class SystemGroupRepository {
CriteriaQuery<Long> cq = cb.createQuery(Long.class);
Root<SystemGroup> from = cq.from(SystemGroup.class);
- cq.where(cb.and(preparePredicatesSystemGroups(cb, from, cq.subquery(Long.class), statuses, deleted, queryFields, queryValues, includeHistory).toArray(new Predicate[0])));
+ cq.where(cb.and(preparePredicatesSystemGroups(cb, from, cq.subquery(Long.class), statuses, deleted,
+ uuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ includeHistory).toArray(new Predicate[0])));
cq.select(cb.count(from));
return em.createQuery(cq).getSingleResult();
@@ -99,41 +112,20 @@ public class SystemGroupRepository {
*
* @param status status
* @param deleted deleted
- * @param queryField query field
- * @param queryValue query value
+ * @param uuid uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @return list of system groups
*/
- public List<SystemGroup> readSystemGroups(
- Status status, Boolean deleted, FieldStructure queryField, String queryValue) {
-
- return readSystemGroups(
- status != null ? new Status[] {status} : null,
- deleted,
- queryField != null ? new FieldStructure[] {queryField} : null,
- queryValue != null ? new String[] {queryValue} : null,
- Boolean.FALSE,
- null, null, null, null);
- }
+ public List<SystemGroup> readSystemGroups(Status status, Boolean deleted,
+ String uuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description) {
- /**
- * Find system groups.
- *
- * @param status status
- * @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
- * @return list of system groups
- */
- public List<SystemGroup> readSystemGroups(
- Status status, Boolean deleted, FieldStructure[] queryFields, String[] queryValues) {
-
- return readSystemGroups(
- status != null ? new Status[] {status} : null,
- deleted,
- queryFields,
- queryValues,
- Boolean.FALSE,
- null, null, null, null);
+ return readSystemGroups(status != null ? new Status[] {status} : null, deleted,
+ uuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ Boolean.FALSE, null, null, null, null);
}
/**
@@ -141,20 +133,24 @@ public class SystemGroupRepository {
*
* @param statuses statuses
* @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
+ * @param uuid uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @param orderBy order by
* @param isAsc is ascending
* @param offset offset
* @param limit limit
* @return list of system groups
*/
- public List<SystemGroup> readSystemGroups(
- Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues,
+ public List<SystemGroup> readSystemGroups(Status[] statuses, Boolean deleted,
+ String uuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description,
FieldStructure orderBy, Boolean isAsc, Integer offset, Integer limit) {
- return readSystemGroups(
- statuses, deleted, queryFields, queryValues, Boolean.FALSE,
- orderBy, isAsc, offset, limit);
+ return readSystemGroups(statuses, deleted,
+ uuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ Boolean.FALSE, orderBy, isAsc, offset, limit);
}
/**
@@ -162,8 +158,12 @@ public class SystemGroupRepository {
*
* @param statuses statuses
* @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
+ * @param uuid uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @param includeHistory include history
* @param orderBy order by
* @param isAsc is ascending
@@ -171,9 +171,9 @@ public class SystemGroupRepository {
* @param limit limit
* @return list of system groups
*/
- public List<SystemGroup> readSystemGroups(
- Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues, Boolean includeHistory,
- FieldStructure orderBy, Boolean isAsc, Integer offset, Integer limit) {
+ public List<SystemGroup> readSystemGroups(Status[] statuses, Boolean deleted,
+ String uuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description,
+ Boolean includeHistory, FieldStructure orderBy, Boolean isAsc, Integer offset, Integer limit) {
// where
// statuses,
@@ -188,7 +188,9 @@ public class SystemGroupRepository {
CriteriaQuery<SystemGroup> cq = cb.createQuery(SystemGroup.class);
Root<SystemGroup> from = cq.from(SystemGroup.class);
- cq.where(cb.and(preparePredicatesSystemGroups(cb, from, cq.subquery(Long.class), statuses, deleted, queryFields, queryValues, includeHistory).toArray(new Predicate[0])));
+ cq.where(cb.and(preparePredicatesSystemGroups(cb, from, cq.subquery(Long.class), statuses, deleted,
+ uuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ includeHistory).toArray(new Predicate[0])));
cq.select(from);
if (orderBy != null) {
@@ -244,14 +246,18 @@ public class SystemGroupRepository {
* @param sub sub query to be used if history not included
* @param statuses statuses
* @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
+ * @param uuid uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @param includeHistory include history
* @return list of predicates
*/
- private List<Predicate> preparePredicatesSystemGroups(
- CriteriaBuilder cb, Root<SystemGroup> from, Subquery<Long> sub,
- Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues, Boolean includeHistory) {
+ private List<Predicate> preparePredicatesSystemGroups(CriteriaBuilder cb, Root<SystemGroup> from, Subquery<Long> sub, Status[] statuses, Boolean deleted,
+ String uuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description,
+ Boolean includeHistory) {
List<Predicate> predicates = new ArrayList<>();
@@ -303,48 +309,28 @@ public class SystemGroupRepository {
if (deleted != null) {
predicates.add(cb.equal(from.get(NameStructure.FIELD_DELETED), deleted));
}
- if (queryFields != null) {
- for (int i=0; i<queryFields.length; i++) {
- String queryValue = queryValues[i];
-
- // jpa query characters % and _
- // remove excess % characters
- if (queryValue.startsWith(PERCENT)) {
- while (queryValue.startsWith(PERCENT)) {
- queryValue = queryValue.substring(1);
- }
- queryValue = PERCENT + queryValue;
- }
- if (queryValue.endsWith(PERCENT)) {
- while (queryValue.endsWith(PERCENT)) {
- queryValue = queryValue.substring(0, queryValue.length()-1);
- }
- queryValue = queryValue + PERCENT;
- }
- switch (queryFields[i]) {
- case UUID:
- predicates.add(cb.and(cb.equal(from.get(NameStructure.FIELD_UUID), queryValue)));
- break;
- case NAME:
- predicates.add(cb.and(cb.like(from.get(Structure.FIELD_NAME), queryValue)));
- break;
- case MNEMONIC:
- predicates.add(cb.and(cb.like(from.get(Structure.FIELD_MNEMONIC), queryValue)));
- break;
- case MNEMONICEQUIVALENCE:
- predicates.add(cb.and(cb.like(from.get(Structure.FIELD_MNEMONIC_EQUIVALENCE), queryValue)));
- break;
- case MNEMONICPATH:
- predicates.add(cb.and(cb.like(from.get(Structure.FIELD_MNEMONIC), queryValue)));
- break;
- case DESCRIPTION:
- predicates.add(cb.and(cb.like(from.get(NameStructure.FIELD_DESCRIPTION), queryValue)));
- break;
- default:
- continue;
- }
- }
+ // prepare pattern
+ // jpa query characters % and _
+ // remove excess % characters
+
+ if (!StringUtils.isEmpty(uuid)) {
+ predicates.add(cb.and(cb.equal(from.get(NameStructure.FIELD_UUID), RepositoryUtil.preparePattern(uuid))));
+ }
+ if (!StringUtils.isEmpty(name)) {
+ predicates.add(cb.and(cb.like(from.get(Structure.FIELD_NAME), RepositoryUtil.preparePattern(name))));
+ }
+ if (!StringUtils.isEmpty(mnemonic)) {
+ predicates.add(cb.and(cb.like(from.get(Structure.FIELD_MNEMONIC), RepositoryUtil.preparePattern(mnemonic))));
+ }
+ if (!StringUtils.isEmpty(mnemonicequivalence)) {
+ predicates.add(cb.and(cb.like(from.get(Structure.FIELD_MNEMONIC_EQUIVALENCE), RepositoryUtil.preparePattern(mnemonicequivalence))));
+ }
+ if (!StringUtils.isEmpty(mnemonicpath)) {
+ predicates.add(cb.and(cb.like(from.get(Structure.FIELD_MNEMONIC), RepositoryUtil.preparePattern(mnemonicpath))));
+ }
+ if (!StringUtils.isEmpty(description)) {
+ predicates.add(cb.and(cb.like(from.get(NameStructure.FIELD_DESCRIPTION), RepositoryUtil.preparePattern(description))));
}
return predicates;
diff --git a/src/main/java/org/openepics/names/repository/SystemRepository.java b/src/main/java/org/openepics/names/repository/SystemRepository.java
index b265a490..32978d0e 100644
--- a/src/main/java/org/openepics/names/repository/SystemRepository.java
+++ b/src/main/java/org/openepics/names/repository/SystemRepository.java
@@ -31,12 +31,14 @@ import javax.persistence.criteria.Root;
import javax.persistence.criteria.Subquery;
import org.apache.commons.lang3.BooleanUtils;
+import org.apache.commons.lang3.StringUtils;
import org.openepics.names.repository.model.NameStructure;
import org.openepics.names.repository.model.Persistable;
import org.openepics.names.repository.model.Structure;
import org.openepics.names.repository.model.System;
import org.openepics.names.rest.beans.FieldStructure;
import org.openepics.names.rest.beans.Status;
+import org.openepics.names.util.RepositoryUtil;
import org.springframework.stereotype.Repository;
/**
@@ -47,8 +49,6 @@ import org.springframework.stereotype.Repository;
@Repository
public class SystemRepository {
- private static final String PERCENT = "%";
-
@PersistenceContext
private EntityManager em;
@@ -57,13 +57,20 @@ public class SystemRepository {
*
* @param statuses statuses
* @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
+ * @param uuid uuid
+ * @param parentUuid parent uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @return count of systems
*/
- public Long countSystems(
- Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues) {
- return countSystems(statuses, deleted, queryFields, queryValues, Boolean.FALSE);
+ public Long countSystems(Status[] statuses, Boolean deleted,
+ String uuid, String parentUuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description) {
+ return countSystems(statuses, deleted,
+ uuid, parentUuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ Boolean.FALSE);
}
/**
@@ -71,13 +78,19 @@ public class SystemRepository {
*
* @param statuses statuses
* @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
+ * @param uuid uuid
+ * @param parentUuid parent uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @param includeHistory include history
* @return count of systems
*/
- public Long countSystems(
- Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues, Boolean includeHistory) {
+ public Long countSystems(Status[] statuses, Boolean deleted,
+ String uuid, String parentUuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description,
+ Boolean includeHistory) {
// note
// use of function for mnemonic path
@@ -90,7 +103,9 @@ public class SystemRepository {
CriteriaQuery<Long> cq = cb.createQuery(Long.class);
Root<System> from = cq.from(System.class);
- cq.where(cb.and(preparePredicatesSystems(cb, from, cq.subquery(Long.class), statuses, deleted, queryFields, queryValues, includeHistory).toArray(new Predicate[0])));
+ cq.where(cb.and(preparePredicatesSystems(cb, from, cq.subquery(Long.class), statuses, deleted,
+ uuid, parentUuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ includeHistory).toArray(new Predicate[0])));
cq.select(cb.count(from));
return em.createQuery(cq).getSingleResult();
@@ -101,41 +116,21 @@ public class SystemRepository {
*
* @param status status
* @param deleted deleted
- * @param queryField query field
- * @param queryValue query value
+ * @param uuid uuid
+ * @param parentUuid parent uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @return list of systems
*/
- public List<System> readSystems(
- Status status, Boolean deleted, FieldStructure queryField, String queryValue) {
-
- return readSystems(
- status != null ? new Status[] {status} : null,
- deleted,
- queryField != null ? new FieldStructure[] {queryField} : null,
- queryValue != null ? new String[] {queryValue} : null,
- Boolean.FALSE,
- null, null, null, null);
- }
+ public List<System> readSystems(Status status, Boolean deleted,
+ String uuid, String parentUuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description) {
- /**
- * Find systems.
- *
- * @param status status
- * @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
- * @return list of systems
- */
- public List<System> readSystems(
- Status status, Boolean deleted, FieldStructure[] queryFields, String[] queryValues) {
-
- return readSystems(
- status != null ? new Status[] {status} : null,
- deleted,
- queryFields,
- queryValues,
- Boolean.FALSE,
- null, null, null, null);
+ return readSystems(status != null ? new Status[] {status} : null, deleted,
+ uuid, parentUuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ Boolean.FALSE, null, null, null, null);
}
/**
@@ -143,20 +138,25 @@ public class SystemRepository {
*
* @param statuses statuses
* @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
+ * @param uuid uuid
+ * @param parentUuid parent uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @param orderBy order by
* @param isAsc is ascending
* @param offset offset
* @param limit limit
* @return list of systems
*/
- public List<System> readSystems(
- Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues,
+ public List<System> readSystems(Status[] statuses, Boolean deleted,
+ String uuid, String parentUuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description,
FieldStructure orderBy, Boolean isAsc, Integer offset, Integer limit) {
- return readSystems(
- statuses, deleted, queryFields, queryValues, Boolean.FALSE,
- orderBy, isAsc, offset, limit);
+ return readSystems(statuses, deleted,
+ uuid, parentUuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ Boolean.FALSE, orderBy, isAsc, offset, limit);
}
/**
@@ -164,8 +164,13 @@ public class SystemRepository {
*
* @param statuses statuses
* @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
+ * @param uuid uuid
+ * @param parentUuid parent uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @param includeHistory include history
* @param orderBy order by
* @param isAsc is ascending
@@ -173,9 +178,9 @@ public class SystemRepository {
* @param limit limit
* @return list of systems
*/
- public List<System> readSystems(
- Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues, Boolean includeHistory,
- FieldStructure orderBy, Boolean isAsc, Integer offset, Integer limit) {
+ public List<System> readSystems(Status[] statuses, Boolean deleted,
+ String uuid, String parentUuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description,
+ Boolean includeHistory, FieldStructure orderBy, Boolean isAsc, Integer offset, Integer limit) {
// note
// use of function for mnemonic path
@@ -192,7 +197,9 @@ public class SystemRepository {
CriteriaQuery<System> cq = cb.createQuery(System.class);
Root<System> from = cq.from(System.class);
- cq.where(cb.and(preparePredicatesSystems(cb, from, cq.subquery(Long.class), statuses, deleted, queryFields, queryValues, includeHistory).toArray(new Predicate[0])));
+ cq.where(cb.and(preparePredicatesSystems(cb, from, cq.subquery(Long.class), statuses, deleted,
+ uuid, parentUuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ includeHistory).toArray(new Predicate[0])));
cq.select(from);
if (orderBy != null) {
@@ -248,14 +255,19 @@ public class SystemRepository {
* @param sub sub query to be used if history not included
* @param statuses statuses
* @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
+ * @param uuid uuid
+ * @param parentUuid parent uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @param includeHistory include history
* @return list of predicates
*/
- private List<Predicate> preparePredicatesSystems(
- CriteriaBuilder cb, Root<System> from, Subquery<Long> sub,
- Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues, Boolean includeHistory) {
+ private List<Predicate> preparePredicatesSystems(CriteriaBuilder cb, Root<System> from, Subquery<Long> sub, Status[] statuses, Boolean deleted,
+ String uuid, String parentUuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description,
+ Boolean includeHistory) {
List<Predicate> predicates = new ArrayList<>();
@@ -307,51 +319,31 @@ public class SystemRepository {
if (deleted != null) {
predicates.add(cb.equal(from.get(NameStructure.FIELD_DELETED), deleted));
}
- if (queryFields != null) {
- for (int i=0; i<queryFields.length; i++) {
- String queryValue = queryValues[i];
-
- // jpa query characters % and _
- // remove excess % characters
- if (queryValue.startsWith(PERCENT)) {
- while (queryValue.startsWith(PERCENT)) {
- queryValue = queryValue.substring(1);
- }
- queryValue = PERCENT + queryValue;
- }
- if (queryValue.endsWith(PERCENT)) {
- while (queryValue.endsWith(PERCENT)) {
- queryValue = queryValue.substring(0, queryValue.length()-1);
- }
- queryValue = queryValue + PERCENT;
- }
- switch (queryFields[i]) {
- case UUID:
- predicates.add(cb.and(cb.equal(from.get(NameStructure.FIELD_UUID), queryValue)));
- break;
- case PARENT:
- predicates.add(cb.and(cb.equal(from.get(System.FIELD_PARENT_UUID), queryValue)));
- break;
- case NAME:
- predicates.add(cb.and(cb.like(from.get(Structure.FIELD_NAME), queryValue)));
- break;
- case MNEMONIC:
- predicates.add(cb.and(cb.like(from.get(Structure.FIELD_MNEMONIC), queryValue)));
- break;
- case MNEMONICEQUIVALENCE:
- predicates.add(cb.and(cb.like(from.get(Structure.FIELD_MNEMONIC_EQUIVALENCE), queryValue)));
- break;
- case MNEMONICPATH:
- predicates.add(cb.and(cb.like(cb.function(System.FUNCTION_GET_MNEMONIC_PATH_SYSTEM, String.class, from.get(NameStructure.FIELD_UUID)), queryValue)));
- break;
- case DESCRIPTION:
- predicates.add(cb.and(cb.like(from.get(NameStructure.FIELD_DESCRIPTION), queryValue)));
- break;
- default:
- continue;
- }
- }
+ // prepare pattern
+ // jpa query characters % and _
+ // remove excess % characters
+
+ if (!StringUtils.isEmpty(uuid)) {
+ predicates.add(cb.and(cb.equal(from.get(NameStructure.FIELD_UUID), RepositoryUtil.preparePattern(uuid))));
+ }
+ if (!StringUtils.isEmpty(parentUuid)) {
+ predicates.add(cb.and(cb.equal(from.get(System.FIELD_PARENT_UUID), RepositoryUtil.preparePattern(parentUuid))));
+ }
+ if (!StringUtils.isEmpty(name)) {
+ predicates.add(cb.and(cb.like(from.get(Structure.FIELD_NAME), RepositoryUtil.preparePattern(name))));
+ }
+ if (!StringUtils.isEmpty(mnemonic)) {
+ predicates.add(cb.and(cb.like(from.get(Structure.FIELD_MNEMONIC), RepositoryUtil.preparePattern(mnemonic))));
+ }
+ if (!StringUtils.isEmpty(mnemonicequivalence)) {
+ predicates.add(cb.and(cb.like(from.get(Structure.FIELD_MNEMONIC_EQUIVALENCE), RepositoryUtil.preparePattern(mnemonicequivalence))));
+ }
+ if (!StringUtils.isEmpty(mnemonicpath)) {
+ predicates.add(cb.and(cb.like(cb.function(System.FUNCTION_GET_MNEMONIC_PATH_SYSTEM, String.class, from.get(NameStructure.FIELD_UUID)), RepositoryUtil.preparePattern(mnemonicpath))));
+ }
+ if (!StringUtils.isEmpty(description)) {
+ predicates.add(cb.and(cb.like(from.get(NameStructure.FIELD_DESCRIPTION), RepositoryUtil.preparePattern(description))));
}
return predicates;
diff --git a/src/main/java/org/openepics/names/rest/api/v1/IStructures.java b/src/main/java/org/openepics/names/rest/api/v1/IStructures.java
index 7c5efab2..6de16ad3 100644
--- a/src/main/java/org/openepics/names/rest/api/v1/IStructures.java
+++ b/src/main/java/org/openepics/names/rest/api/v1/IStructures.java
@@ -99,9 +99,9 @@ public interface IStructures {
create POST /structures - createStructures (List<StructureElementCommand>)
create POST /structures/upload - createStructures (MultipartFile)
----------------------------------------------------------------------------------------------------
- read GET /structures/{type} - readStructures (Type, Status[], Boolean, FieldStructure[], String[], FieldStructure, Boolean, Integer, Integer)
- read GET /structures/{type}/download - readStructuresDownload (Type, Status[], Boolean, FieldStructure[], String[], FieldStructure, Boolean, Integer, Integer)
- read GET /structures/children/{type}/{uuid} - readStructuresChildren (Type, String, FieldStructure, Boolean, Integer, Integer)
+ read GET /structures/{type} - readStructures (Type, Status[], Boolean, String, String, String, String, String, String, String, FieldStructure, Boolean, Integer, Integer)
+ read GET /structures/{type}/download - readStructuresDownload (Type, Status[], Boolean, String, String, String, String, String, String, String, FieldStructure, Boolean, Integer, Integer)
+ read GET /structures/children/{type}/{uuid} - readStructuresChildren (Type, String, Status[], Boolean, String, String, String, String, String, FieldStructure, Boolean, Integer, Integer)
read GET /structures/mnemonic/{mnemonic} - readStructuresMnemonic (String, FieldStructure, Boolean, Integer, Integer, FieldStructure, Boolean, Integer, Integer)
read GET /structures/mnemonicpath/{mnemonicpath} - readStructuresMnemonicpath (String, FieldStructure, Boolean, Integer, Integer, FieldStructure, Boolean, Integer, Integer)
read GET /structures/history/{uuid} - readStructuresHistory (String, Type, FieldStructure, Boolean, Integer, Integer)
@@ -283,12 +283,17 @@ public interface IStructures {
* Find valid structures (search).
* Return paged list of structure elements.
*
- * @param type type of structure to search in
- * @param statuses statuses of structures to search for
+ * @param type type of structure
+ * @param statuses statuses for structures
* @param deleted if deleted-only structures are to be included
* (false for non-deleted-only structures, true for deleted-only structures, not used for both cases)
- * @param queryFields search fields
- * @param queryValues search values corresponding to search fields
+ * @param uuid uuid
+ * @param parentuuid parent uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @param orderBy order by field
* @param isAsc sort order, ascending or descending
* @param page page starting from 0, offset
@@ -332,11 +337,16 @@ public interface IStructures {
value = "/{type}",
produces = {"application/json"})
public ResponsePageStructureElements readStructures(
- @Parameter(in = ParameterIn.PATH, description = "type of structure to search in") @PathVariable("type") Type type,
- @Parameter(in = ParameterIn.QUERY, description = "statuses of structures to search for") @RequestParam(required = false) Status[] statuses,
+ @Parameter(in = ParameterIn.PATH, description = "search by type of structure") @PathVariable("type") Type type,
+ @Parameter(in = ParameterIn.QUERY, description = "search by statuses") @RequestParam(required = false) Status[] statuses,
@Parameter(in = ParameterIn.QUERY, description = "if deleted structures are to be included or not, omitted for both deleted and not deleted structures") @RequestParam(required = false) Boolean deleted,
- @Parameter(in = ParameterIn.QUERY, description = "search fields") @RequestParam(required = false) FieldStructure[] queryFields,
- @Parameter(in = ParameterIn.QUERY, description = "search values corresponding to search fields") @RequestParam(required = false) String[] queryValues,
+ @Parameter(in = ParameterIn.QUERY, description = "search by uuid") @RequestParam(required = false) String uuid,
+ @Parameter(in = ParameterIn.QUERY, description = "search by parent uuid") @RequestParam(required = false) String parentuuid,
+ @Parameter(in = ParameterIn.QUERY, description = "search by name") @RequestParam(required = false) String name,
+ @Parameter(in = ParameterIn.QUERY, description = "search by mnemonic") @RequestParam(required = false) String mnemonic,
+ @Parameter(in = ParameterIn.QUERY, description = "search by mnemonic equivalence") @RequestParam(required = false) String mnemonicequivalence,
+ @Parameter(in = ParameterIn.QUERY, description = "search by mnemonic path") @RequestParam(required = false) String mnemonicpath,
+ @Parameter(in = ParameterIn.QUERY, description = "search by description") @RequestParam(required = false) String description,
@Parameter(in = ParameterIn.QUERY, description = "order by field") @RequestParam(required = false) FieldStructure orderBy,
@Parameter(in = ParameterIn.QUERY, description = "sort order, ascending or descending") @RequestParam(required = false) Boolean isAsc,
@Parameter(in = ParameterIn.QUERY, description = "page starting from 0, offset") @RequestParam(required = false, defaultValue = DEFAULT_PAGE) Integer page,
@@ -346,12 +356,17 @@ public interface IStructures {
* Find valid structures (search).
* Return Excel file with paged list of structure elements.
*
- * @param type type of structure to search in
- * @param statuses statuses of structures to search for
+ * @param type type of structure
+ * @param statuses statuses for structures
* @param deleted if deleted-only structures are to be included
* (false for non-deleted-only structures, true for deleted-only structures, not used for both cases)
- * @param queryFields search fields
- * @param queryValues search values corresponding to search fields
+ * @param uuid uuid
+ * @param parentuuid parent uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @param orderBy order by field
* @param isAsc sort order, ascending or descending
* @param page page starting from 0, offset
@@ -393,11 +408,16 @@ public interface IStructures {
value = "/{type}/download",
produces = {"application/vnd.ms-excel"})
public ResponseEntity<Resource> readStructuresDownload(
- @Parameter(in = ParameterIn.PATH, description = "type of structure to search in") @PathVariable("type") Type type,
- @Parameter(in = ParameterIn.QUERY, description = "statuses of structures to search for") @RequestParam(required = false) Status[] statuses,
+ @Parameter(in = ParameterIn.PATH, description = "search by type of structure") @PathVariable("type") Type type,
+ @Parameter(in = ParameterIn.QUERY, description = "search by statuses") @RequestParam(required = false) Status[] statuses,
@Parameter(in = ParameterIn.QUERY, description = "if deleted structures are to be included or not, omitted for both deleted and not deleted structures") @RequestParam(required = false) Boolean deleted,
- @Parameter(in = ParameterIn.QUERY, description = "search fields") @RequestParam(required = false) FieldStructure[] queryFields,
- @Parameter(in = ParameterIn.QUERY, description = "search values corresponding to search fields") @RequestParam(required = false) String[] queryValues,
+ @Parameter(in = ParameterIn.QUERY, description = "search by uuid") @RequestParam(required = false) String uuid,
+ @Parameter(in = ParameterIn.QUERY, description = "search by parent uuid") @RequestParam(required = false) String parentuuid,
+ @Parameter(in = ParameterIn.QUERY, description = "search by name") @RequestParam(required = false) String name,
+ @Parameter(in = ParameterIn.QUERY, description = "search by mnemonic") @RequestParam(required = false) String mnemonic,
+ @Parameter(in = ParameterIn.QUERY, description = "search by mnemonic equivalence") @RequestParam(required = false) String mnemonicequivalence,
+ @Parameter(in = ParameterIn.QUERY, description = "search by mnemonic path") @RequestParam(required = false) String mnemonicpath,
+ @Parameter(in = ParameterIn.QUERY, description = "search by description") @RequestParam(required = false) String description,
@Parameter(in = ParameterIn.QUERY, description = "order by field") @RequestParam(required = false) FieldStructure orderBy,
@Parameter(in = ParameterIn.QUERY, description = "sort order, ascending or descending") @RequestParam(required = false) Boolean isAsc,
@Parameter(in = ParameterIn.QUERY, description = "page starting from 0, offset") @RequestParam(required = false, defaultValue = DEFAULT_PAGE) Integer page,
@@ -407,8 +427,16 @@ public interface IStructures {
* Find valid children structures by type and parent uuid (exact match).
* Return paged list of structure elements.
*
- * @param type type of structure to search in
- * @param uuid uuid to find structure for
+ * @param type type of structure
+ * @param uuid uuid
+ * @param statuses statuses for structures
+ * @param deleted if deleted-only structures are to be included
+ * (false for non-deleted-only structures, true for deleted-only structures, not used for both cases)
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @param orderBy order by field
* @param isAsc sort order, ascending or descending
* @param page page starting from 0, offset
@@ -452,8 +480,15 @@ public interface IStructures {
value = "/children/{type}/{uuid}",
produces = {"application/json"})
public ResponsePageStructureElements readStructuresChildren(
- @Parameter(in = ParameterIn.PATH, description = "type of structure to search in") @PathVariable("type") Type type,
- @Parameter(in = ParameterIn.PATH, description = "uuid to find structure for") @PathVariable("uuid") String uuid,
+ @Parameter(in = ParameterIn.PATH, description = "search by type of structure") @PathVariable("type") Type type,
+ @Parameter(in = ParameterIn.PATH, description = "search by uuid") @PathVariable("uuid") String uuid,
+ @Parameter(in = ParameterIn.QUERY, description = "search by statuses") @RequestParam(required = false) Status[] statuses,
+ @Parameter(in = ParameterIn.QUERY, description = "if deleted structures are to be included or not, omitted for both deleted and not deleted structures") @RequestParam(required = false) Boolean deleted,
+ @Parameter(in = ParameterIn.QUERY, description = "search by name") @RequestParam(required = false) String name,
+ @Parameter(in = ParameterIn.QUERY, description = "search by mnemonic") @RequestParam(required = false) String mnemonic,
+ @Parameter(in = ParameterIn.QUERY, description = "search by mnemonic equivalence") @RequestParam(required = false) String mnemonicequivalence,
+ @Parameter(in = ParameterIn.QUERY, description = "search by mnemonic path") @RequestParam(required = false) String mnemonicpath,
+ @Parameter(in = ParameterIn.QUERY, description = "search by description") @RequestParam(required = false) String description,
@Parameter(in = ParameterIn.QUERY, description = "order by field") @RequestParam(required = false) FieldStructure orderBy,
@Parameter(in = ParameterIn.QUERY, description = "sort order, ascending or descending") @RequestParam(required = false) Boolean isAsc,
@Parameter(in = ParameterIn.QUERY, description = "page starting from 0, offset") @RequestParam(required = false, defaultValue = DEFAULT_PAGE) Integer page,
@@ -463,7 +498,7 @@ public interface IStructures {
* Find valid structures by mnemonic (search).
* Return paged list of structure elements.
*
- * @param mnemonic mnemonic to search for
+ * @param mnemonic mnemonic
* @param orderBy order by field
* @param isAsc sort order, ascending or descending
* @param page page starting from 0, offset
@@ -507,7 +542,7 @@ public interface IStructures {
value = "/mnemonic/{mnemonic}",
produces = {"application/json"})
public ResponsePageStructureElements readStructuresMnemonic(
- @Parameter(in = ParameterIn.PATH, description = "mnemonic to search for") @PathVariable("mnemonic") String mnemonic,
+ @Parameter(in = ParameterIn.PATH, description = "search by mnemonic") @PathVariable("mnemonic") String mnemonic,
@Parameter(in = ParameterIn.QUERY, description = "order by field") @RequestParam(required = false) FieldStructure orderBy,
@Parameter(in = ParameterIn.QUERY, description = "sort order, ascending or descending") @RequestParam(required = false) Boolean isAsc,
@Parameter(in = ParameterIn.QUERY, description = "page starting from 0, offset") @RequestParam(required = false, defaultValue = DEFAULT_PAGE) Integer page,
@@ -517,7 +552,7 @@ public interface IStructures {
* Find valid structures by mnemonic path (search).
* Return paged list of structure elements.
*
- * @param mnemonicpath mnemonic path to search for
+ * @param mnemonicpath mnemonic path
* @param orderBy order by field
* @param isAsc sort order, ascending or descending
* @param page page starting from 0, offset
@@ -561,7 +596,7 @@ public interface IStructures {
value = "/mnemonicpath/{mnemonicpath}",
produces = {"application/json"})
public ResponsePageStructureElements readStructuresMnemonicpath(
- @Parameter(in = ParameterIn.PATH, description = "mnemonic path to search for") @PathVariable("mnemonicpath") String mnemonicpath,
+ @Parameter(in = ParameterIn.PATH, description = "search by mnemonic path") @PathVariable("mnemonicpath") String mnemonicpath,
@Parameter(in = ParameterIn.QUERY, description = "order by field") @RequestParam(required = false) FieldStructure orderBy,
@Parameter(in = ParameterIn.QUERY, description = "sort order, ascending or descending") @RequestParam(required = false) Boolean isAsc,
@Parameter(in = ParameterIn.QUERY, description = "page starting from 0, offset") @RequestParam(required = false, defaultValue = DEFAULT_PAGE) Integer page,
@@ -571,7 +606,7 @@ public interface IStructures {
* Find history for structure by uuid (exact match).
* Return paged list of structure elements.
*
- * @param uuid uuid to find history for
+ * @param uuid uuid
* @param type type of structure to search in
* @param orderBy order by field
* @param isAsc sort order, ascending or descending
@@ -616,8 +651,8 @@ public interface IStructures {
value = "/history/{uuid}",
produces = {"application/json"})
public ResponsePageStructureElements readStructuresHistory(
- @Parameter(in = ParameterIn.PATH, description = "uuid to find structure for") @PathVariable("uuid") String uuid,
- @Parameter(in = ParameterIn.QUERY, description = "type of structure to search in") @RequestParam(required = false) Type type,
+ @Parameter(in = ParameterIn.PATH, description = "search by uuid") @PathVariable("uuid") String uuid,
+ @Parameter(in = ParameterIn.QUERY, description = "search by type of structure") @RequestParam(required = false) Type type,
@Parameter(in = ParameterIn.QUERY, description = "order by field") @RequestParam(required = false) FieldStructure orderBy,
@Parameter(in = ParameterIn.QUERY, description = "sort order, ascending or descending") @RequestParam(required = false) Boolean isAsc,
@Parameter(in = ParameterIn.QUERY, description = "page starting from 0, offset") @RequestParam(required = false, defaultValue = DEFAULT_PAGE) Integer page,
diff --git a/src/main/java/org/openepics/names/rest/controller/ReportController.java b/src/main/java/org/openepics/names/rest/controller/ReportController.java
index 56c108c9..b4c7437a 100644
--- a/src/main/java/org/openepics/names/rest/controller/ReportController.java
+++ b/src/main/java/org/openepics/names/rest/controller/ReportController.java
@@ -159,12 +159,12 @@ public class ReportController {
}
}
- ResponsePageStructureElements structureElementsSystemgroup = structuresService.readStructures(Type.SYSTEMGROUP, null, null, null, null, Boolean.FALSE, null, null, null, null, StructureChoice.STRUCTURE);
- ResponsePageStructureElements structureElementsSystem = structuresService.readStructures(Type.SYSTEM, null, null, null, null, Boolean.FALSE, null, null, null, null, StructureChoice.STRUCTURE);
- ResponsePageStructureElements structureElementsSubsystem = structuresService.readStructures(Type.SUBSYSTEM, null, null, null, null, Boolean.FALSE, null, null, null, null, StructureChoice.STRUCTURE);
- ResponsePageStructureElements structureElementsDiscipline = structuresService.readStructures(Type.DISCIPLINE, null, null, null, null, Boolean.FALSE, null, null, null, null, StructureChoice.STRUCTURE);
- ResponsePageStructureElements structureElementsDevicegroup = structuresService.readStructures(Type.DEVICEGROUP, null, null, null, null, Boolean.FALSE, null, null, null, null, StructureChoice.STRUCTURE);
- ResponsePageStructureElements structureElementsDevicetype = structuresService.readStructures(Type.DEVICETYPE, null, null, null, null, Boolean.FALSE, null, null, null, null, StructureChoice.STRUCTURE);
+ ResponsePageStructureElements structureElementsSystemgroup = structuresService.readStructures(Type.SYSTEMGROUP, null, null, null, null, null, null, null, null, null, Boolean.FALSE, null, null, null, null, StructureChoice.STRUCTURE);
+ ResponsePageStructureElements structureElementsSystem = structuresService.readStructures(Type.SYSTEM, null, null, null, null, null, null, null, null, null, Boolean.FALSE, null, null, null, null, StructureChoice.STRUCTURE);
+ ResponsePageStructureElements structureElementsSubsystem = structuresService.readStructures(Type.SUBSYSTEM, null, null, null, null, null, null, null, null, null, Boolean.FALSE, null, null, null, null, StructureChoice.STRUCTURE);
+ ResponsePageStructureElements structureElementsDiscipline = structuresService.readStructures(Type.DISCIPLINE, null, null, null, null, null, null, null, null, null, Boolean.FALSE, null, null, null, null, StructureChoice.STRUCTURE);
+ ResponsePageStructureElements structureElementsDevicegroup = structuresService.readStructures(Type.DEVICEGROUP, null, null, null, null, null, null, null, null, null, Boolean.FALSE, null, null, null, null, StructureChoice.STRUCTURE);
+ ResponsePageStructureElements structureElementsDevicetype = structuresService.readStructures(Type.DEVICETYPE, null, null, null, null, null, null, null, null, null, Boolean.FALSE, null, null, null, null, StructureChoice.STRUCTURE);
Map<UUID, Long> mapUuidCountSystemGroup = new TreeMap<>();
Map<UUID, Long> mapUuidCountSystem = new TreeMap<>();
diff --git a/src/main/java/org/openepics/names/rest/controller/StructuresController.java b/src/main/java/org/openepics/names/rest/controller/StructuresController.java
index afb6d327..8bd76099 100644
--- a/src/main/java/org/openepics/names/rest/controller/StructuresController.java
+++ b/src/main/java/org/openepics/names/rest/controller/StructuresController.java
@@ -141,12 +141,12 @@ public class StructuresController implements IStructures {
// ----------------------------------------------------------------------------------------------------
@Override
- public ResponsePageStructureElements readStructures(
- Type type, Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues,
+ public ResponsePageStructureElements readStructures(Type type, Status[] statuses, Boolean deleted,
+ String uuid, String parentUuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description,
FieldStructure orderBy, Boolean isAsc, Integer page, Integer pageSize) {
try {
- return structuresService.readStructures(
- type, statuses, deleted, queryFields, queryValues,
+ return structuresService.readStructures(type, statuses, deleted,
+ uuid, parentUuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
orderBy, isAsc, page, pageSize);
} catch (ServiceException e) {
logService.logServiceException(LOGGER, Level.WARNING, e);
@@ -160,9 +160,11 @@ public class StructuresController implements IStructures {
@Override
public ResponseEntity<Resource> readStructuresDownload(Type type, Status[] statuses, Boolean deleted,
- FieldStructure[] queryFields, String[] queryValues, FieldStructure orderBy, Boolean isAsc, Integer page,
- Integer pageSize) {
- ResponsePageStructureElements structureElements = readStructures(type, statuses, deleted, queryFields, queryValues, orderBy, isAsc, page, pageSize);
+ String uuid, String parentUuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description,
+ FieldStructure orderBy, Boolean isAsc, Integer page, Integer pageSize) {
+ ResponsePageStructureElements structureElements = readStructures(type, statuses, deleted,
+ uuid, parentUuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ orderBy, isAsc, page, pageSize);
InputStreamResource isr = new InputStreamResource(ExcelUtil.structureElementsToExcel(structureElements));
return ResponseEntity.ok()
.header(HttpHeaders.CONTENT_DISPOSITION, ATTACHMENT_FILENAME_STRUCTURE_ELEMENT_XLSX)
@@ -171,12 +173,12 @@ public class StructuresController implements IStructures {
}
@Override
- public ResponsePageStructureElements readStructuresChildren(
- Type type, String uuid,
+ public ResponsePageStructureElements readStructuresChildren(Type type, String uuid, Status[] statuses, Boolean deleted,
+ String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description,
FieldStructure orderBy, Boolean isAsc, Integer page, Integer pageSize) {
try {
- return structuresService.readStructuresChildren(
- type, uuid,
+ return structuresService.readStructuresChildren(type, uuid, statuses, deleted,
+ name, mnemonic, mnemonicequivalence, mnemonicpath, description,
orderBy, isAsc, page, pageSize);
} catch (ServiceException e) {
logService.logServiceException(LOGGER, Level.WARNING, e);
@@ -189,8 +191,7 @@ public class StructuresController implements IStructures {
}
@Override
- public ResponsePageStructureElements readStructuresMnemonic(
- String mnemonic,
+ public ResponsePageStructureElements readStructuresMnemonic(String mnemonic,
FieldStructure orderBy, Boolean isAsc, Integer page, Integer pageSize) {
try {
return structuresService.readStructuresMnemonic(mnemonic, orderBy, isAsc, page, pageSize);
@@ -205,8 +206,7 @@ public class StructuresController implements IStructures {
}
@Override
- public ResponsePageStructureElements readStructuresMnemonicpath(
- String mnemonicpath,
+ public ResponsePageStructureElements readStructuresMnemonicpath(String mnemonicpath,
FieldStructure orderBy, Boolean isAsc, Integer page, Integer pageSize) {
try {
return structuresService.readStructuresMnemonicpath(mnemonicpath, orderBy, isAsc, page, pageSize);
@@ -221,12 +221,10 @@ public class StructuresController implements IStructures {
}
@Override
- public ResponsePageStructureElements readStructuresHistory(
- String uuid, Type type,
+ public ResponsePageStructureElements readStructuresHistory(String uuid, Type type,
FieldStructure orderBy, Boolean isAsc, Integer page, Integer pageSize) {
try {
- return structuresService.readStructuresHistory(
- uuid, type,
+ return structuresService.readStructuresHistory(uuid, type,
orderBy, isAsc, page, pageSize);
} catch (ServiceException e) {
logService.logServiceException(LOGGER, Level.WARNING, e);
diff --git a/src/main/java/org/openepics/names/service/StructuresService.java b/src/main/java/org/openepics/names/service/StructuresService.java
index 97c1b3e7..95eef282 100644
--- a/src/main/java/org/openepics/names/service/StructuresService.java
+++ b/src/main/java/org/openepics/names/service/StructuresService.java
@@ -261,22 +261,29 @@ public class StructuresService {
// ----------------------------------------------------------------------------------------------------
- public ResponsePageStructureElements readStructures(
- Type type, Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues,
+ public ResponsePageStructureElements readStructures(Type type, Status[] statuses, Boolean deleted,
+ String uuid, String parentUuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description,
FieldStructure orderBy, Boolean isAsc, Integer offset, Integer limit) {
- return readStructures(type, statuses, deleted, queryFields, queryValues, Boolean.FALSE, orderBy, isAsc, offset, limit, StructureChoice.STRUCTURE);
+ return readStructures(type, statuses, deleted,
+ uuid, parentUuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ Boolean.FALSE, orderBy, isAsc, offset, limit, StructureChoice.STRUCTURE);
}
- public ResponsePageStructureElements readStructures(
- Type type, Status[] statuses, Boolean deleted, FieldStructure[] queryFields, String[] queryValues, Boolean includeHistory,
- FieldStructure orderBy, Boolean isAsc, Integer offset, Integer limit,
+ public ResponsePageStructureElements readStructures(Type type, Status[] statuses, Boolean deleted,
+ String uuid, String parentUuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description,
+ Boolean includeHistory, FieldStructure orderBy, Boolean isAsc, Integer offset, Integer limit,
StructureChoice structureChoice) {
LOGGER.log(Level.FINE, "readStructures, type: {0}", type);
LOGGER.log(Level.FINE, "readStructures, statuses.length: {0}", String.valueOf(statuses != null ? statuses.length : "null"));
LOGGER.log(Level.FINE, "readStructures, deleted: {0}", deleted);
- LOGGER.log(Level.FINE, "readStructures, queryFields.length: {0}", String.valueOf(queryFields != null ? queryFields.length : "null"));
- LOGGER.log(Level.FINE, "readStructures, queryValues.length: {0}", String.valueOf(queryValues != null ? queryValues.length : "null"));
+ LOGGER.log(Level.FINE, "readStructures, uuid: {0}", uuid);
+ LOGGER.log(Level.FINE, "readStructures, parentUuid: {0}", parentUuid);
+ LOGGER.log(Level.FINE, "readStructures, name: {0}", name);
+ LOGGER.log(Level.FINE, "readStructures, mnemonic: {0}", mnemonic);
+ LOGGER.log(Level.FINE, "readStructures, mnemonicequivalence: {0}", mnemonicequivalence);
+ LOGGER.log(Level.FINE, "readStructures, mnemonicpath: {0}", mnemonicpath);
+ LOGGER.log(Level.FINE, "readStructures, description: {0}", description);
LOGGER.log(Level.FINE, "readStructures, includeHistory: {0}", includeHistory);
LOGGER.log(Level.FINE, "readStructures, orderBy: {0}", orderBy);
LOGGER.log(Level.FINE, "readStructures, isAsc: {0}", isAsc);
@@ -288,16 +295,6 @@ public class StructuresService {
LOGGER.log(Level.FINE, "readStructures, status: {0}", status);
}
}
- if (queryFields != null && queryFields.length > 0) {
- for (FieldStructure queryField : queryFields) {
- LOGGER.log(Level.FINE, "readStructures, queryField: {0}", queryField);
- }
- }
- if (queryValues != null && queryValues.length > 0) {
- for (String queryValue : queryValues) {
- LOGGER.log(Level.FINE, "readStructures, queryValue: {0}", queryValue);
- }
- }
// validate input
// type
@@ -309,11 +306,9 @@ public class StructuresService {
// structure elements for structures
// validate input
- ValidateStructureElementUtil.validateStructuresInputRead(
- type, statuses, deleted, queryFields, queryValues,
- includeHistory,
- orderBy, isAsc,
- offset, limit);
+ ValidateStructureElementUtil.validateStructuresInputRead(type, statuses, deleted,
+ uuid, parentUuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ includeHistory, orderBy, isAsc, offset, limit);
// initiate holder of containers for system and device structure content, for performance reasons
HolderSystemDeviceStructure holder = new HolderSystemDeviceStructure(holderIRepositories);
@@ -322,57 +317,57 @@ public class StructuresService {
final List<StructureElement> structureElements = Lists.newArrayList();
Long totalCount = null;
if (Type.SYSTEMGROUP.equals(type)) {
- List<SystemGroup> systemGroups = holderRepositories.getSystemGroupRepository().readSystemGroups(
- statuses, deleted, queryFields, queryValues,
- includeHistory,
- orderBy, isAsc,
- offset, limit);
- totalCount = holderRepositories.getSystemGroupRepository().countSystemGroups(statuses, deleted, queryFields, queryValues, includeHistory);
+ List<SystemGroup> systemGroups = holderRepositories.getSystemGroupRepository().readSystemGroups(statuses, deleted,
+ uuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ includeHistory, orderBy, isAsc, offset, limit);
+ totalCount = holderRepositories.getSystemGroupRepository().countSystemGroups(statuses, deleted,
+ uuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ includeHistory);
LOGGER.log(Level.FINE, "readStructures, systemGroups.size: {0}", systemGroups.size());
structureElements.addAll(StructureElementUtil.getStructureElementsForSystemGroups(systemGroups, holder, structureChoice));
} else if (Type.SYSTEM.equals(type)) {
- List<System> systems = holderRepositories.getSystemRepository().readSystems(
- statuses, deleted, queryFields, queryValues,
- includeHistory,
- orderBy, isAsc,
- offset, limit);
- totalCount = holderRepositories.getSystemRepository().countSystems(statuses, deleted, queryFields, queryValues, includeHistory);
+ List<System> systems = holderRepositories.getSystemRepository().readSystems(statuses, deleted,
+ uuid, parentUuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ includeHistory, orderBy, isAsc, offset, limit);
+ totalCount = holderRepositories.getSystemRepository().countSystems(statuses, deleted,
+ uuid, parentUuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ includeHistory);
LOGGER.log(Level.FINE, "readStructures, systems.size: {0}", systems.size());
structureElements.addAll(StructureElementUtil.getStructureElementsForSystems(systems, holder, structureChoice));
} else if (Type.SUBSYSTEM.equals(type)) {
- List<Subsystem> subsystems = holderRepositories.getSubsystemRepository().readSubsystems(
- statuses, deleted, queryFields, queryValues,
- includeHistory,
- orderBy, isAsc,
- offset, limit);
- totalCount = holderRepositories.getSubsystemRepository().countSubsystems(statuses, deleted, queryFields, queryValues, includeHistory);
+ List<Subsystem> subsystems = holderRepositories.getSubsystemRepository().readSubsystems(statuses, deleted,
+ uuid, parentUuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ includeHistory, orderBy, isAsc, offset, limit);
+ totalCount = holderRepositories.getSubsystemRepository().countSubsystems(statuses, deleted,
+ uuid, parentUuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ includeHistory);
LOGGER.log(Level.FINE, "readStructures, subsystems.size: {0}", subsystems.size());
structureElements.addAll(StructureElementUtil.getStructureElementsForSubsystems(subsystems, holder, structureChoice));
} else if (Type.DISCIPLINE.equals(type)) {
- List<Discipline> disciplines = holderRepositories.getDisciplineRepository().readDisciplines(
- statuses, deleted, queryFields, queryValues,
- includeHistory,
- orderBy, isAsc,
- offset, limit);
- totalCount = holderRepositories.getDisciplineRepository().countDisciplines(statuses, deleted, queryFields, queryValues, includeHistory);
+ List<Discipline> disciplines = holderRepositories.getDisciplineRepository().readDisciplines(statuses, deleted,
+ uuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ includeHistory, orderBy, isAsc, offset, limit);
+ totalCount = holderRepositories.getDisciplineRepository().countDisciplines(statuses, deleted,
+ uuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ includeHistory);
LOGGER.log(Level.FINE, "readStructures, disciplines.size: {0}", disciplines.size());
structureElements.addAll(StructureElementUtil.getStructureElementsForDisciplines(disciplines, holder, structureChoice));
} else if (Type.DEVICEGROUP.equals(type)) {
- List<DeviceGroup> deviceGroups = holderRepositories.getDeviceGroupRepository().readDeviceGroups(
- statuses, deleted, queryFields, queryValues,
- includeHistory,
- orderBy, isAsc,
- offset, limit);
- totalCount = holderRepositories.getDeviceGroupRepository().countDeviceGroups(statuses, deleted, queryFields, queryValues, includeHistory);
+ List<DeviceGroup> deviceGroups = holderRepositories.getDeviceGroupRepository().readDeviceGroups(statuses, deleted,
+ uuid, parentUuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ includeHistory, orderBy, isAsc, offset, limit);
+ totalCount = holderRepositories.getDeviceGroupRepository().countDeviceGroups(statuses, deleted,
+ uuid, parentUuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ includeHistory);
LOGGER.log(Level.FINE, "readStructures, deviceGroups.size: {0}", deviceGroups.size());
structureElements.addAll(StructureElementUtil.getStructureElementsForDeviceGroups(deviceGroups, holder, structureChoice));
} else if (Type.DEVICETYPE.equals(type)) {
- List<DeviceType> deviceTypes = holderRepositories.getDeviceTypeRepository().readDeviceTypes(
- statuses, deleted, queryFields, queryValues,
- includeHistory,
- orderBy, isAsc,
- offset, limit);
- totalCount = holderRepositories.getDeviceTypeRepository().countDeviceTypes(statuses, deleted, queryFields, queryValues, includeHistory);
+ List<DeviceType> deviceTypes = holderRepositories.getDeviceTypeRepository().readDeviceTypes(statuses, deleted,
+ uuid, parentUuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ includeHistory, orderBy, isAsc, offset, limit);
+ totalCount = holderRepositories.getDeviceTypeRepository().countDeviceTypes(statuses, deleted,
+ uuid, parentUuid, name, mnemonic, mnemonicequivalence, mnemonicpath, description,
+ includeHistory);
LOGGER.log(Level.FINE, "readStructures, deviceTypes.size: {0}", deviceTypes.size());
structureElements.addAll(StructureElementUtil.getStructureElementsForDeviceTypes(deviceTypes, holder, structureChoice));
}
@@ -382,8 +377,8 @@ public class StructuresService {
return response;
}
- public ResponsePageStructureElements readStructuresChildren(
- Type type, String uuid,
+ public ResponsePageStructureElements readStructuresChildren(Type type, String uuid,
+ Status[] statuses, Boolean deleted, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description,
FieldStructure orderBy, Boolean isAsc, Integer offset, Integer limit) {
// validate input
@@ -402,15 +397,23 @@ public class StructuresService {
// do
if (Type.SYSTEMGROUP.equals(type)) {
- return readStructures(Type.SYSTEM, new Status[] {Status.APPROVED}, false, new FieldStructure[] {FieldStructure.PARENT}, new String[] {uuid}, orderBy, isAsc, offset, limit);
+ return readStructures(Type.SYSTEM, new Status[] {Status.APPROVED}, false,
+ null, uuid, null, null, null, null, null,
+ orderBy, isAsc, offset, limit);
} else if (Type.SYSTEM.equals(type)) {
- return readStructures(Type.SUBSYSTEM, new Status[] {Status.APPROVED}, false, new FieldStructure[] {FieldStructure.PARENT}, new String[] {uuid}, orderBy, isAsc, offset, limit);
+ return readStructures(Type.SUBSYSTEM, new Status[] {Status.APPROVED}, false,
+ null, uuid, null, null, null, null, null,
+ orderBy, isAsc, offset, limit);
} else if (Type.SUBSYSTEM.equals(type)) {
// no children in structures
} else if (Type.DISCIPLINE.equals(type)) {
- return readStructures(Type.DEVICEGROUP, new Status[] {Status.APPROVED}, false, new FieldStructure[] {FieldStructure.PARENT}, new String[] {uuid}, orderBy, isAsc, offset, limit);
+ return readStructures(Type.DEVICEGROUP, new Status[] {Status.APPROVED}, false,
+ null, uuid, null, null, null, null, null,
+ orderBy, isAsc, offset, limit);
} else if (Type.DEVICEGROUP.equals(type)) {
- return readStructures(Type.DEVICETYPE, new Status[] {Status.APPROVED}, false, new FieldStructure[] {FieldStructure.PARENT}, new String[] {uuid}, orderBy, isAsc, offset, limit);
+ return readStructures(Type.DEVICETYPE, new Status[] {Status.APPROVED}, false,
+ null, uuid, null, null, null, null, null,
+ orderBy, isAsc, offset, limit);
} else if (Type.DEVICETYPE.equals(type)) {
// no children in structures
}
@@ -424,8 +427,7 @@ public class StructuresService {
return new ResponsePageStructureElements();
}
- public ResponsePageStructureElements readStructuresMnemonic(
- String mnemonic,
+ public ResponsePageStructureElements readStructuresMnemonic(String mnemonic,
FieldStructure orderBy, Boolean isAsc, Integer offset, Integer limit) {
// validate input
@@ -441,12 +443,12 @@ public class StructuresService {
// do
// TODO handle orderBy, isAsc, offset, limit
- ResponsePageStructureElements responseSystemGroup = readStructures(Type.SYSTEMGROUP, new Status[] {Status.APPROVED}, false, new FieldStructure[] {FieldStructure.MNEMONIC}, new String[] {mnemonic}, orderBy, isAsc, offset, limit);
- ResponsePageStructureElements responseSystem = readStructures(Type.SYSTEM, new Status[] {Status.APPROVED}, false, new FieldStructure[] {FieldStructure.MNEMONIC}, new String[] {mnemonic}, orderBy, isAsc, offset, limit);
- ResponsePageStructureElements responseSubsystem = readStructures(Type.SUBSYSTEM, new Status[] {Status.APPROVED}, false, new FieldStructure[] {FieldStructure.MNEMONIC}, new String[] {mnemonic}, orderBy, isAsc, offset, limit);
- ResponsePageStructureElements responseDiscipline = readStructures(Type.DISCIPLINE, new Status[] {Status.APPROVED}, false, new FieldStructure[] {FieldStructure.MNEMONIC}, new String[] {mnemonic}, orderBy, isAsc, offset, limit);
- ResponsePageStructureElements responseDeviceGroup = readStructures(Type.DEVICEGROUP, new Status[] {Status.APPROVED}, false, new FieldStructure[] {FieldStructure.MNEMONIC}, new String[] {mnemonic}, orderBy, isAsc, offset, limit);
- ResponsePageStructureElements responseDeviceType = readStructures(Type.DEVICETYPE, new Status[] {Status.APPROVED}, false, new FieldStructure[] {FieldStructure.MNEMONIC}, new String[] {mnemonic}, orderBy, isAsc, offset, limit);
+ ResponsePageStructureElements responseSystemGroup = readStructures(Type.SYSTEMGROUP, new Status[] {Status.APPROVED}, false, null, null, null, mnemonic, null, null, null, orderBy, isAsc, offset, limit);
+ ResponsePageStructureElements responseSystem = readStructures(Type.SYSTEM, new Status[] {Status.APPROVED}, false, null, null, null, mnemonic, null, null, null, orderBy, isAsc, offset, limit);
+ ResponsePageStructureElements responseSubsystem = readStructures(Type.SUBSYSTEM, new Status[] {Status.APPROVED}, false, null, null, null, mnemonic, null, null, null, orderBy, isAsc, offset, limit);
+ ResponsePageStructureElements responseDiscipline = readStructures(Type.DISCIPLINE, new Status[] {Status.APPROVED}, false, null, null, null, mnemonic, null, null, null, orderBy, isAsc, offset, limit);
+ ResponsePageStructureElements responseDeviceGroup = readStructures(Type.DEVICEGROUP, new Status[] {Status.APPROVED}, false, null, null, null, mnemonic, null, null, null, orderBy, isAsc, offset, limit);
+ ResponsePageStructureElements responseDeviceType = readStructures(Type.DEVICETYPE, new Status[] {Status.APPROVED}, false, null, null, null, mnemonic, null, null, null, orderBy, isAsc, offset, limit);
List<StructureElement> structureElements = Lists.newArrayList();
structureElements.addAll(responseSystemGroup.getList());
@@ -459,8 +461,7 @@ public class StructuresService {
return new ResponsePageStructureElements(structureElements, Long.valueOf(structureElements.size()), structureElements.size(), 0, structureElements.size());
}
- public ResponsePageStructureElements readStructuresMnemonicpath(
- String mnemonicpath,
+ public ResponsePageStructureElements readStructuresMnemonicpath(String mnemonicpath,
FieldStructure orderBy, Boolean isAsc, Integer offset, Integer limit) {
// validate input
@@ -476,12 +477,12 @@ public class StructuresService {
// do
// TODO handle orderBy, isAsc, offset, limit
- ResponsePageStructureElements responseSystemGroup = readStructures(Type.SYSTEMGROUP, new Status[] {Status.APPROVED}, false, new FieldStructure[] {FieldStructure.MNEMONICPATH}, new String[] {mnemonicpath}, orderBy, isAsc, offset, limit);
- ResponsePageStructureElements responseSystem = readStructures(Type.SYSTEM, new Status[] {Status.APPROVED}, false, new FieldStructure[] {FieldStructure.MNEMONICPATH}, new String[] {mnemonicpath}, orderBy, isAsc, offset, limit);
- ResponsePageStructureElements responseSubsystem = readStructures(Type.SUBSYSTEM, new Status[] {Status.APPROVED}, false, new FieldStructure[] {FieldStructure.MNEMONICPATH}, new String[] {mnemonicpath}, orderBy, isAsc, offset, limit);
- ResponsePageStructureElements responseDiscipline = readStructures(Type.DISCIPLINE, new Status[] {Status.APPROVED}, false, new FieldStructure[] {FieldStructure.MNEMONICPATH}, new String[] {mnemonicpath}, orderBy, isAsc, offset, limit);
- ResponsePageStructureElements responseDeviceGroup = readStructures(Type.DEVICEGROUP, new Status[] {Status.APPROVED}, false, new FieldStructure[] {FieldStructure.MNEMONICPATH}, new String[] {mnemonicpath}, orderBy, isAsc, offset, limit);
- ResponsePageStructureElements responseDeviceType = readStructures(Type.DEVICETYPE, new Status[] {Status.APPROVED}, false, new FieldStructure[] {FieldStructure.MNEMONICPATH}, new String[] {mnemonicpath}, orderBy, isAsc, offset, limit);
+ ResponsePageStructureElements responseSystemGroup = readStructures(Type.SYSTEMGROUP, new Status[] {Status.APPROVED}, false, null, null, null, null, null, mnemonicpath, null, orderBy, isAsc, offset, limit);
+ ResponsePageStructureElements responseSystem = readStructures(Type.SYSTEM, new Status[] {Status.APPROVED}, false, null, null, null, null, null, mnemonicpath, null, orderBy, isAsc, offset, limit);
+ ResponsePageStructureElements responseSubsystem = readStructures(Type.SUBSYSTEM, new Status[] {Status.APPROVED}, false, null, null, null, null, null, mnemonicpath, null, orderBy, isAsc, offset, limit);
+ ResponsePageStructureElements responseDiscipline = readStructures(Type.DISCIPLINE, new Status[] {Status.APPROVED}, false, null, null, null, null, null, mnemonicpath, null, orderBy, isAsc, offset, limit);
+ ResponsePageStructureElements responseDeviceGroup = readStructures(Type.DEVICEGROUP, new Status[] {Status.APPROVED}, false, null, null, null, null, null, mnemonicpath, null, orderBy, isAsc, offset, limit);
+ ResponsePageStructureElements responseDeviceType = readStructures(Type.DEVICETYPE, new Status[] {Status.APPROVED}, false, null, null, null, null, null, mnemonicpath, null, orderBy, isAsc, offset, limit);
List<StructureElement> structureElements = Lists.newArrayList();
structureElements.addAll(responseSystemGroup.getList());
@@ -501,8 +502,7 @@ public class StructuresService {
* @param type type
* @return list of structure elements
*/
- public ResponsePageStructureElements readStructuresHistory(
- String uuid, Type type,
+ public ResponsePageStructureElements readStructuresHistory(String uuid, Type type,
FieldStructure orderBy, Boolean isAsc, Integer offset, Integer limit) {
// note
@@ -535,28 +535,28 @@ public class StructuresService {
ResponsePageStructureElements response = null;
if (type_either) {
if (type_systemGroup) {
- response = readStructures(Type.SYSTEMGROUP, null, null, new FieldStructure[] {FieldStructure.UUID}, new String[] {uuid}, Boolean.TRUE, orderBy, isAsc, offset, limit, StructureChoice.HISTORY);
+ response = readStructures(Type.SYSTEMGROUP, null, null, uuid, null, null, null, null, null, null, Boolean.TRUE, orderBy, isAsc, offset, limit, StructureChoice.HISTORY);
} else if (type_system) {
- response = readStructures(Type.SYSTEM, null, null, new FieldStructure[] {FieldStructure.UUID}, new String[] {uuid}, Boolean.TRUE, orderBy, isAsc, offset, limit, StructureChoice.HISTORY);
+ response = readStructures(Type.SYSTEM, null, null, uuid, null, null, null, null, null, null, Boolean.TRUE, orderBy, isAsc, offset, limit, StructureChoice.HISTORY);
} else if (type_subsystem) {
- response = readStructures(Type.SUBSYSTEM, null, null, new FieldStructure[] {FieldStructure.UUID}, new String[] {uuid}, Boolean.TRUE, orderBy, isAsc, offset, limit, StructureChoice.HISTORY);
+ response = readStructures(Type.SUBSYSTEM, null, null, uuid, null, null, null, null, null, null, Boolean.TRUE, orderBy, isAsc, offset, limit, StructureChoice.HISTORY);
} else if (type_discipline) {
- response = readStructures(Type.DISCIPLINE, null, null, new FieldStructure[] {FieldStructure.UUID}, new String[] {uuid}, Boolean.TRUE, orderBy, isAsc, offset, limit, StructureChoice.HISTORY);
+ response = readStructures(Type.DISCIPLINE, null, null, uuid, null, null, null, null, null, null, Boolean.TRUE, orderBy, isAsc, offset, limit, StructureChoice.HISTORY);
} else if (type_deviceGroup) {
- response = readStructures(Type.DEVICEGROUP, null, null, new FieldStructure[] {FieldStructure.UUID}, new String[] {uuid}, Boolean.TRUE, orderBy, isAsc, offset, limit, StructureChoice.HISTORY);
+ response = readStructures(Type.DEVICEGROUP, null, null, uuid, null, null, null, null, null, null, Boolean.TRUE, orderBy, isAsc, offset, limit, StructureChoice.HISTORY);
} else if (type_deviceType) {
- response = readStructures(Type.DEVICETYPE, null, null, new FieldStructure[] {FieldStructure.UUID}, new String[] {uuid}, Boolean.TRUE, orderBy, isAsc, offset, limit, StructureChoice.HISTORY);
+ response = readStructures(Type.DEVICETYPE, null, null, uuid, null, null, null, null, null, null, Boolean.TRUE, orderBy, isAsc, offset, limit, StructureChoice.HISTORY);
}
} else {
// go through all structures and see if / where uuid is found
// uuid in 0 or 1 of structures
- ResponsePageStructureElements responseSystemGroup = readStructures(Type.SYSTEMGROUP, null, null, new FieldStructure[] {FieldStructure.UUID}, new String[] {uuid}, Boolean.TRUE, orderBy, isAsc, offset, limit, StructureChoice.HISTORY);
- ResponsePageStructureElements responseSystem = readStructures(Type.SYSTEM, null, null, new FieldStructure[] {FieldStructure.UUID}, new String[] {uuid}, Boolean.TRUE, orderBy, isAsc, offset, limit, StructureChoice.HISTORY);
- ResponsePageStructureElements responseSubsystem = readStructures(Type.SUBSYSTEM, null, null, new FieldStructure[] {FieldStructure.UUID}, new String[] {uuid}, Boolean.TRUE, orderBy, isAsc, offset, limit, StructureChoice.HISTORY);
- ResponsePageStructureElements responseDiscipline = readStructures(Type.DISCIPLINE, null, null, new FieldStructure[] {FieldStructure.UUID}, new String[] {uuid}, Boolean.TRUE, orderBy, isAsc, offset, limit, StructureChoice.HISTORY);
- ResponsePageStructureElements responseDeviceGroup = readStructures(Type.DEVICEGROUP, null, null, new FieldStructure[] {FieldStructure.UUID}, new String[] {uuid}, Boolean.TRUE, orderBy, isAsc, offset, limit, StructureChoice.HISTORY);
- ResponsePageStructureElements responseDeviceType = readStructures(Type.DEVICETYPE, null, null, new FieldStructure[] {FieldStructure.UUID}, new String[] {uuid}, Boolean.TRUE, orderBy, isAsc, offset, limit, StructureChoice.HISTORY);
+ ResponsePageStructureElements responseSystemGroup = readStructures(Type.SYSTEMGROUP, null, null, uuid, null, null, null, null, null, null, Boolean.TRUE, orderBy, isAsc, offset, limit, StructureChoice.HISTORY);
+ ResponsePageStructureElements responseSystem = readStructures(Type.SYSTEM, null, null, uuid, null, null, null, null, null, null, Boolean.TRUE, orderBy, isAsc, offset, limit, StructureChoice.HISTORY);
+ ResponsePageStructureElements responseSubsystem = readStructures(Type.SUBSYSTEM, null, null, uuid, null, null, null, null, null, null, Boolean.TRUE, orderBy, isAsc, offset, limit, StructureChoice.HISTORY);
+ ResponsePageStructureElements responseDiscipline = readStructures(Type.DISCIPLINE, null, null, uuid, null, null, null, null, null, null, Boolean.TRUE, orderBy, isAsc, offset, limit, StructureChoice.HISTORY);
+ ResponsePageStructureElements responseDeviceGroup = readStructures(Type.DEVICEGROUP, null, null, uuid, null, null, null, null, null, null, Boolean.TRUE, orderBy, isAsc, offset, limit, StructureChoice.HISTORY);
+ ResponsePageStructureElements responseDeviceType = readStructures(Type.DEVICETYPE, null, null, uuid, null, null, null, null, null, null, Boolean.TRUE, orderBy, isAsc, offset, limit, StructureChoice.HISTORY);
structureElements.addAll(responseSystemGroup.getList());
structureElements.addAll(responseSystem.getList());
@@ -605,22 +605,28 @@ public class StructuresService {
// do
if (Type.SYSTEMGROUP.equals(type)) {
- List<SystemGroup> systemGroups = holderRepositories.getSystemGroupRepository().readSystemGroups(Status.APPROVED, false, FieldStructure.MNEMONICPATH, mnemonicpath);
+ List<SystemGroup> systemGroups = holderRepositories.getSystemGroupRepository().readSystemGroups(Status.APPROVED, false,
+ null, null, null, null, mnemonicpath, null);
return !systemGroups.isEmpty();
} else if (Type.SYSTEM.equals(type)) {
- List<System> systems = holderRepositories.getSystemRepository().readSystems(Status.APPROVED, false, FieldStructure.MNEMONICPATH, mnemonicpath);
+ List<System> systems = holderRepositories.getSystemRepository().readSystems(Status.APPROVED, false,
+ null, null, null, null, null, mnemonicpath, null);
return !systems.isEmpty();
} else if (Type.SUBSYSTEM.equals(type)) {
- List<Subsystem> subsystems = holderRepositories.getSubsystemRepository().readSubsystems(Status.APPROVED, false, FieldStructure.MNEMONICPATH, mnemonicpath);
+ List<Subsystem> subsystems = holderRepositories.getSubsystemRepository().readSubsystems(Status.APPROVED, false,
+ null, null, null, null, null, mnemonicpath, null);
return !subsystems.isEmpty();
} else if (Type.DISCIPLINE.equals(type)) {
- List<Discipline> disciplines = holderRepositories.getDisciplineRepository().readDisciplines(Status.APPROVED, false, FieldStructure.MNEMONICPATH, mnemonicpath);
+ List<Discipline> disciplines = holderRepositories.getDisciplineRepository().readDisciplines(Status.APPROVED, false,
+ null, null, null, null, mnemonicpath, null);
return !disciplines.isEmpty();
} else if (Type.DEVICEGROUP.equals(type)) {
- List<DeviceGroup> deviceGroups = holderRepositories.getDeviceGroupRepository().readDeviceGroups(Status.APPROVED, false, FieldStructure.MNEMONICPATH, mnemonicpath);
+ List<DeviceGroup> deviceGroups = holderRepositories.getDeviceGroupRepository().readDeviceGroups(Status.APPROVED, false,
+ null, null, null, null, null, mnemonicpath, null);
return !deviceGroups.isEmpty();
} else if (Type.DEVICETYPE.equals(type)) {
- List<DeviceType> deviceTypes = holderRepositories.getDeviceTypeRepository().readDeviceTypes(Status.APPROVED, false, FieldStructure.MNEMONICPATH, mnemonicpath);
+ List<DeviceType> deviceTypes = holderRepositories.getDeviceTypeRepository().readDeviceTypes(Status.APPROVED, false,
+ null, null, null, null, null, mnemonicpath, null);
return !deviceTypes.isEmpty();
}
@@ -976,7 +982,8 @@ public class StructuresService {
if (Type.SYSTEMGROUP.equals(structureElement.getType())) {
// find
- List<SystemGroup> systemGroups = holderRepositories.getSystemGroupRepository().readSystemGroups(Status.APPROVED, Boolean.FALSE, FieldStructure.UUID, queryValue);
+ List<SystemGroup> systemGroups = holderRepositories.getSystemGroupRepository().readSystemGroups(Status.APPROVED, Boolean.FALSE,
+ queryValue, null, null, null, null, null);
if (systemGroups == null || systemGroups.size() != 1) {
continue;
}
@@ -996,7 +1003,8 @@ public class StructuresService {
deletedStructureElements.add(StructureElementUtil.getStructureElementRequested(systemGroup, holder));
} else if (Type.SYSTEM.equals(structureElement.getType())) {
// find
- List<System> systems = holderRepositories.getSystemRepository().readSystems(Status.APPROVED, Boolean.FALSE, FieldStructure.UUID, queryValue);
+ List<System> systems = holderRepositories.getSystemRepository().readSystems(Status.APPROVED, Boolean.FALSE,
+ queryValue, null, null, null, null, null, null);
if (systems == null || systems.size() != 1) {
continue;
}
@@ -1016,7 +1024,8 @@ public class StructuresService {
deletedStructureElements.add(StructureElementUtil.getStructureElementRequested(system, holder));
} else if (Type.SUBSYSTEM.equals(structureElement.getType())) {
// find
- List<Subsystem> subsystems = holderRepositories.getSubsystemRepository().readSubsystems(Status.APPROVED, Boolean.FALSE, FieldStructure.UUID, queryValue);
+ List<Subsystem> subsystems = holderRepositories.getSubsystemRepository().readSubsystems(Status.APPROVED, Boolean.FALSE,
+ queryValue, null, null, null, null, null, null);
if (subsystems == null || subsystems.size() != 1) {
continue;
}
@@ -1036,7 +1045,8 @@ public class StructuresService {
deletedStructureElements.add(StructureElementUtil.getStructureElementRequested(subsystem, holder));
} else if (Type.DISCIPLINE.equals(structureElement.getType())) {
// find
- List<Discipline> disciplines = holderRepositories.getDisciplineRepository().readDisciplines(Status.APPROVED, Boolean.FALSE, FieldStructure.UUID, queryValue);
+ List<Discipline> disciplines = holderRepositories.getDisciplineRepository().readDisciplines(Status.APPROVED, Boolean.FALSE,
+ queryValue, null, null, null, null, null);
if (disciplines == null || disciplines.size() != 1) {
continue;
}
@@ -1056,7 +1066,8 @@ public class StructuresService {
deletedStructureElements.add(StructureElementUtil.getStructureElementRequested(discipline, holder));
} else if (Type.DEVICEGROUP.equals(structureElement.getType())) {
// find
- List<DeviceGroup> deviceGroups = holderRepositories.getDeviceGroupRepository().readDeviceGroups(Status.APPROVED, Boolean.FALSE, FieldStructure.UUID, queryValue);
+ List<DeviceGroup> deviceGroups = holderRepositories.getDeviceGroupRepository().readDeviceGroups(Status.APPROVED, Boolean.FALSE,
+ queryValue, null, null, null, null, null, null);
if (deviceGroups == null || deviceGroups.size() != 1) {
continue;
}
@@ -1076,7 +1087,8 @@ public class StructuresService {
deletedStructureElements.add(StructureElementUtil.getStructureElementRequested(deviceGroup, holder));
} else if (Type.DEVICETYPE.equals(structureElement.getType())) {
// find
- List<DeviceType> deviceTypes = holderRepositories.getDeviceTypeRepository().readDeviceTypes(Status.APPROVED, Boolean.FALSE, FieldStructure.UUID, queryValue);
+ List<DeviceType> deviceTypes = holderRepositories.getDeviceTypeRepository().readDeviceTypes(Status.APPROVED, Boolean.FALSE,
+ queryValue, null, null, null, null, null, null);
if (deviceTypes == null || deviceTypes.size() != 1) {
continue;
}
@@ -1140,7 +1152,8 @@ public class StructuresService {
if (Type.SYSTEMGROUP.equals(structureElement.getType())) {
// find
- List<SystemGroup> systemGroups = holderRepositories.getSystemGroupRepository().readSystemGroups(Status.APPROVED, Boolean.FALSE, FieldStructure.UUID, queryValue);
+ List<SystemGroup> systemGroups = holderRepositories.getSystemGroupRepository().readSystemGroups(Status.APPROVED, Boolean.FALSE,
+ queryValue, null, null, null, null, null);
SystemGroup systemGroup = null;
if (systemGroups != null && systemGroups.size() == 1) {
systemGroup = systemGroups.get(0);
@@ -1151,7 +1164,8 @@ public class StructuresService {
}
// find
- systemGroups = holderRepositories.getSystemGroupRepository().readSystemGroups(Status.PENDING, null, FieldStructure.UUID, queryValue);
+ systemGroups = holderRepositories.getSystemGroupRepository().readSystemGroups(Status.PENDING, null,
+ queryValue, null, null, null, null, null);
if (systemGroups == null || systemGroups.size() != 1) {
continue;
}
@@ -1176,7 +1190,8 @@ public class StructuresService {
approvedStructureElements.add(StructureElementUtil.getStructureElementProcessed(systemGroup, holder));
} else if (Type.SYSTEM.equals(structureElement.getType())) {
// find
- List<System> systems = holderRepositories.getSystemRepository().readSystems(Status.APPROVED, Boolean.FALSE, FieldStructure.UUID, queryValue);
+ List<System> systems = holderRepositories.getSystemRepository().readSystems(Status.APPROVED, Boolean.FALSE,
+ queryValue, null, null, null, null, null, null);
System system = null;
if (systems != null && systems.size() == 1) {
system = systems.get(0);
@@ -1187,7 +1202,8 @@ public class StructuresService {
}
// find
- systems = holderRepositories.getSystemRepository().readSystems(Status.PENDING, null, FieldStructure.UUID, queryValue);
+ systems = holderRepositories.getSystemRepository().readSystems(Status.PENDING, null,
+ queryValue, null, null, null, null, null, null);
if (systems == null || systems.size() != 1) {
continue;
}
@@ -1212,7 +1228,8 @@ public class StructuresService {
approvedStructureElements.add(StructureElementUtil.getStructureElementProcessed(system, holder));
} else if (Type.SUBSYSTEM.equals(structureElement.getType())) {
// find
- List<Subsystem> subsystems = holderRepositories.getSubsystemRepository().readSubsystems(Status.APPROVED, Boolean.FALSE, FieldStructure.UUID, queryValue);
+ List<Subsystem> subsystems = holderRepositories.getSubsystemRepository().readSubsystems(Status.APPROVED, Boolean.FALSE,
+ queryValue, null, null, null, null, null, null);
Subsystem subsystem = null;
if (subsystems != null && subsystems.size() == 1) {
subsystem = subsystems.get(0);
@@ -1223,7 +1240,8 @@ public class StructuresService {
}
// find
- subsystems = holderRepositories.getSubsystemRepository().readSubsystems(Status.PENDING, null, FieldStructure.UUID, queryValue);
+ subsystems = holderRepositories.getSubsystemRepository().readSubsystems(Status.PENDING, null,
+ queryValue, null, null, null, null, null, null);
if (subsystems == null || subsystems.size() != 1) {
continue;
}
@@ -1247,7 +1265,8 @@ public class StructuresService {
// add
approvedStructureElements.add(StructureElementUtil.getStructureElementProcessed(subsystem, holder));
} else if (Type.DISCIPLINE.equals(structureElement.getType())) {
- List<Discipline> disciplines = holderRepositories.getDisciplineRepository().readDisciplines(Status.APPROVED, Boolean.FALSE, FieldStructure.UUID, queryValue);
+ List<Discipline> disciplines = holderRepositories.getDisciplineRepository().readDisciplines(Status.APPROVED, Boolean.FALSE,
+ queryValue, null, null, null, null, null);
Discipline discipline = null;
if (disciplines != null && disciplines.size() == 1) {
discipline = disciplines.get(0);
@@ -1258,7 +1277,8 @@ public class StructuresService {
}
// find
- disciplines = holderRepositories.getDisciplineRepository().readDisciplines(Status.PENDING, null, FieldStructure.UUID, queryValue);
+ disciplines = holderRepositories.getDisciplineRepository().readDisciplines(Status.PENDING, null,
+ queryValue, null, null, null, null, null);
if (disciplines == null || disciplines.size() != 1) {
continue;
}
@@ -1275,7 +1295,8 @@ public class StructuresService {
approvedStructureElements.add(StructureElementUtil.getStructureElementProcessed(discipline, holder));
} else if (Type.DEVICEGROUP.equals(structureElement.getType())) {
// find
- List<DeviceGroup> deviceGroups = holderRepositories.getDeviceGroupRepository().readDeviceGroups(Status.APPROVED, Boolean.FALSE, FieldStructure.UUID, queryValue);
+ List<DeviceGroup> deviceGroups = holderRepositories.getDeviceGroupRepository().readDeviceGroups(Status.APPROVED, Boolean.FALSE,
+ queryValue, null, null, null, null, null, null);
DeviceGroup deviceGroup = null;
if (deviceGroups != null && deviceGroups.size() == 1) {
deviceGroup = deviceGroups.get(0);
@@ -1286,7 +1307,8 @@ public class StructuresService {
}
// find
- deviceGroups = holderRepositories.getDeviceGroupRepository().readDeviceGroups(Status.PENDING, null, FieldStructure.UUID, queryValue);
+ deviceGroups = holderRepositories.getDeviceGroupRepository().readDeviceGroups(Status.PENDING, null,
+ queryValue, null, null, null, null, null, null);
if (deviceGroups == null || deviceGroups.size() != 1) {
continue;
}
@@ -1303,7 +1325,8 @@ public class StructuresService {
approvedStructureElements.add(StructureElementUtil.getStructureElementProcessed(deviceGroup, holder));
} else if (Type.DEVICETYPE.equals(structureElement.getType())) {
// find
- List<DeviceType> deviceTypes = holderRepositories.getDeviceTypeRepository().readDeviceTypes(Status.APPROVED, Boolean.FALSE, FieldStructure.UUID, queryValue);
+ List<DeviceType> deviceTypes = holderRepositories.getDeviceTypeRepository().readDeviceTypes(Status.APPROVED, Boolean.FALSE,
+ queryValue, null, null, null, null, null, null);
DeviceType deviceType = null;
if (deviceTypes != null && deviceTypes.size() == 1) {
deviceType = deviceTypes.get(0);
@@ -1314,7 +1337,8 @@ public class StructuresService {
}
// find
- deviceTypes = holderRepositories.getDeviceTypeRepository().readDeviceTypes(Status.PENDING, null, FieldStructure.UUID, queryValue);
+ deviceTypes = holderRepositories.getDeviceTypeRepository().readDeviceTypes(Status.PENDING, null,
+ queryValue, null, null, null, null, null, null);
if (deviceTypes == null || deviceTypes.size() != 1) {
continue;
}
@@ -1362,7 +1386,8 @@ public class StructuresService {
if (Type.SYSTEMGROUP.equals(structureElement.getType())) {
// find
- List<SystemGroup> systemGroups = holderRepositories.getSystemGroupRepository().readSystemGroups(Status.PENDING, null, FieldStructure.UUID, queryValue);
+ List<SystemGroup> systemGroups = holderRepositories.getSystemGroupRepository().readSystemGroups(Status.PENDING, null,
+ queryValue, null, null, null, null, null);
if (systemGroups == null || systemGroups.size() != 1) {
continue;
}
@@ -1378,7 +1403,8 @@ public class StructuresService {
cancelledStructureElements.add(StructureElementUtil.getStructureElementProcessed(systemGroup, holder));
} else if (Type.SYSTEM.equals(structureElement.getType())) {
// find
- List<System> systems = holderRepositories.getSystemRepository().readSystems(Status.PENDING, null, FieldStructure.UUID, queryValue);
+ List<System> systems = holderRepositories.getSystemRepository().readSystems(Status.PENDING, null,
+ queryValue, null, null, null, null, null, null);
if (systems == null || systems.size() != 1) {
continue;
}
@@ -1394,7 +1420,8 @@ public class StructuresService {
cancelledStructureElements.add(StructureElementUtil.getStructureElementProcessed(system, holder));
} else if (Type.SUBSYSTEM.equals(structureElement.getType())) {
// find
- List<Subsystem> subsystems = holderRepositories.getSubsystemRepository().readSubsystems(Status.PENDING, null, FieldStructure.UUID, queryValue);
+ List<Subsystem> subsystems = holderRepositories.getSubsystemRepository().readSubsystems(Status.PENDING, null,
+ queryValue, null, null, null, null, null, null);
if (subsystems == null || subsystems.size() != 1) {
continue;
}
@@ -1410,7 +1437,8 @@ public class StructuresService {
cancelledStructureElements.add(StructureElementUtil.getStructureElementProcessed(subsystem, holder));
} else if (Type.DISCIPLINE.equals(structureElement.getType())) {
// find
- List<Discipline> disciplines = holderRepositories.getDisciplineRepository().readDisciplines(Status.PENDING, null, FieldStructure.UUID, queryValue);
+ List<Discipline> disciplines = holderRepositories.getDisciplineRepository().readDisciplines(Status.PENDING, null,
+ queryValue, null, null, null, null, null);
if (disciplines == null || disciplines.size() != 1) {
continue;
}
@@ -1426,7 +1454,8 @@ public class StructuresService {
cancelledStructureElements.add(StructureElementUtil.getStructureElementProcessed(discipline, holder));
} else if (Type.DEVICEGROUP.equals(structureElement.getType())) {
// find
- List<DeviceGroup> deviceGroups = holderRepositories.getDeviceGroupRepository().readDeviceGroups(Status.PENDING, null, FieldStructure.UUID, queryValue);
+ List<DeviceGroup> deviceGroups = holderRepositories.getDeviceGroupRepository().readDeviceGroups(Status.PENDING, null,
+ queryValue, null, null, null, null, null, null);
if (deviceGroups == null || deviceGroups.size() != 1) {
continue;
}
@@ -1441,7 +1470,8 @@ public class StructuresService {
// add
cancelledStructureElements.add(StructureElementUtil.getStructureElementProcessed(deviceGroup, holder));
} else if (Type.DEVICETYPE.equals(structureElement.getType())) {
- List<DeviceType> deviceTypes = holderRepositories.getDeviceTypeRepository().readDeviceTypes(Status.PENDING, null, FieldStructure.UUID, queryValue);
+ List<DeviceType> deviceTypes = holderRepositories.getDeviceTypeRepository().readDeviceTypes(Status.PENDING, null,
+ queryValue, null, null, null, null, null, null);
if (deviceTypes == null || deviceTypes.size() != 1) {
continue;
}
@@ -1488,7 +1518,8 @@ public class StructuresService {
if (Type.SYSTEMGROUP.equals(structureElement.getType())) {
// find
- List<SystemGroup> systemGroups = holderRepositories.getSystemGroupRepository().readSystemGroups(Status.PENDING, null, FieldStructure.UUID, queryValue);
+ List<SystemGroup> systemGroups = holderRepositories.getSystemGroupRepository().readSystemGroups(Status.PENDING, null,
+ queryValue, null, null, null, null, null);
if (systemGroups == null || systemGroups.size() != 1) {
continue;
}
@@ -1504,7 +1535,8 @@ public class StructuresService {
rejectedStructureElements.add(StructureElementUtil.getStructureElementProcessed(systemGroup, holder));
} else if (Type.SYSTEM.equals(structureElement.getType())) {
// find
- List<System> systems = holderRepositories.getSystemRepository().readSystems(Status.PENDING, null, FieldStructure.UUID, queryValue);
+ List<System> systems = holderRepositories.getSystemRepository().readSystems(Status.PENDING, null,
+ queryValue, null, null, null, null, null, null);
if (systems == null || systems.size() != 1) {
continue;
}
@@ -1520,7 +1552,8 @@ public class StructuresService {
rejectedStructureElements.add(StructureElementUtil.getStructureElementProcessed(system, holder));
} else if (Type.SUBSYSTEM.equals(structureElement.getType())) {
// find
- List<Subsystem> subsystems = holderRepositories.getSubsystemRepository().readSubsystems(Status.PENDING, null, FieldStructure.UUID, queryValue);
+ List<Subsystem> subsystems = holderRepositories.getSubsystemRepository().readSubsystems(Status.PENDING, null,
+ queryValue, null, null, null, null, null, null);
if (subsystems == null || subsystems.size() != 1) {
continue;
}
@@ -1536,7 +1569,8 @@ public class StructuresService {
rejectedStructureElements.add(StructureElementUtil.getStructureElementProcessed(subsystem, holder));
} else if (Type.DISCIPLINE.equals(structureElement.getType())) {
// find
- List<Discipline> disciplines = holderRepositories.getDisciplineRepository().readDisciplines(Status.PENDING, null, FieldStructure.UUID, queryValue);
+ List<Discipline> disciplines = holderRepositories.getDisciplineRepository().readDisciplines(Status.PENDING, null,
+ queryValue, null, null, null, null, null);
if (disciplines == null || disciplines.size() != 1) {
continue;
}
@@ -1552,7 +1586,8 @@ public class StructuresService {
rejectedStructureElements.add(StructureElementUtil.getStructureElementProcessed(discipline, holder));
} else if (Type.DEVICEGROUP.equals(structureElement.getType())) {
// find
- List<DeviceGroup> deviceGroups = holderRepositories.getDeviceGroupRepository().readDeviceGroups(Status.PENDING, null, FieldStructure.UUID, queryValue);
+ List<DeviceGroup> deviceGroups = holderRepositories.getDeviceGroupRepository().readDeviceGroups(Status.PENDING, null,
+ queryValue, null, null, null, null, null, null);
if (deviceGroups == null || deviceGroups.size() != 1) {
continue;
}
@@ -1567,7 +1602,8 @@ public class StructuresService {
// add
rejectedStructureElements.add(StructureElementUtil.getStructureElementProcessed(deviceGroup, holder));
} else if (Type.DEVICETYPE.equals(structureElement.getType())) {
- List<DeviceType> deviceTypes = holderRepositories.getDeviceTypeRepository().readDeviceTypes(Status.PENDING, null, FieldStructure.UUID, queryValue);
+ List<DeviceType> deviceTypes = holderRepositories.getDeviceTypeRepository().readDeviceTypes(Status.PENDING, null,
+ queryValue, null, null, null, null, null, null);
if (deviceTypes == null || deviceTypes.size() != 1) {
continue;
}
diff --git a/src/main/java/org/openepics/names/util/ValidateNameElementUtil.java b/src/main/java/org/openepics/names/util/ValidateNameElementUtil.java
index e1fb6af0..4409d1ac 100644
--- a/src/main/java/org/openepics/names/util/ValidateNameElementUtil.java
+++ b/src/main/java/org/openepics/names/util/ValidateNameElementUtil.java
@@ -28,7 +28,6 @@ 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;
@@ -423,15 +422,19 @@ public class ValidateNameElementUtil {
// device structure
if (!StringUtils.isEmpty(dt)) {
- List<DeviceType> deviceTypes = holderRepositories.getDeviceTypeRepository().readDeviceTypes(Status.APPROVED, false, FieldStructure.MNEMONICPATH, mnemonicPathDevicestructure);
+ List<DeviceType> deviceTypes = holderRepositories.getDeviceTypeRepository().readDeviceTypes(Status.APPROVED, false,
+ null, null, null, null, null, mnemonicPathDevicestructure, null);
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);
+ List<Subsystem> subsystems = holderRepositories.getSubsystemRepository().readSubsystems(Status.APPROVED, false,
+ null, null, null, null, null, mnemonicPathSystemstructure, null);
+ List<System> systems = holderRepositories.getSystemRepository().readSystems(Status.APPROVED, false,
+ null, null, null, null, null, mnemonicPathSystemstructure, null);
+ List<SystemGroup> systemGroups = holderRepositories.getSystemGroupRepository().readSystemGroups(Status.APPROVED, false,
+ null, null, null, null, mnemonicPathSystemstructure, null);
if (subsystems != null && subsystems.size() == 1) {
subsystem = subsystems.get(0);
diff --git a/src/main/java/org/openepics/names/util/ValidateStructureElementUtil.java b/src/main/java/org/openepics/names/util/ValidateStructureElementUtil.java
index 352c4e12..37bbd99b 100644
--- a/src/main/java/org/openepics/names/util/ValidateStructureElementUtil.java
+++ b/src/main/java/org/openepics/names/util/ValidateStructureElementUtil.java
@@ -69,41 +69,30 @@ public class ValidateStructureElementUtil {
* @param type type
* @param statuses statuses
* @param deleted deleted
- * @param queryFields query fields
- * @param queryValues query values
+ * @param uuid uuid
+ * @param parentUuid parent uuid
+ * @param name name
+ * @param mnemonic mnemonic
+ * @param mnemonicequivalence mnemonic equivalence
+ * @param mnemonicpath mnemonic path
+ * @param description description
* @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) {
+ public static void validateStructuresInputRead(Type type, Status[] statuses, Boolean deleted,
+ String uuid, String parentUuid, String name, String mnemonic, String mnemonicequivalence, String mnemonicpath, String description,
+ 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
+ // 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]);
- }
- }
-
+ if (!StringUtils.isEmpty(uuid)) {
+ ValidateUtil.validateInputUuid(uuid);
}
}
@@ -375,17 +364,23 @@ public class ValidateStructureElementUtil {
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();
+ return holderRepositories.getSystemGroupRepository().readSystemGroups(status, deleted,
+ uuid.toString(), null, null, null, null, null).size();
} else if (Type.SYSTEM.equals(type)) {
- return holderRepositories.getSystemRepository().readSystems(status, deleted, FieldStructure.UUID, uuid.toString()).size();
+ return holderRepositories.getSystemRepository().readSystems(status, deleted,
+ uuid.toString(), null, null, null, null, null, null).size();
} else if (Type.SUBSYSTEM.equals(type)) {
- return holderRepositories.getSubsystemRepository().readSubsystems(status, deleted, FieldStructure.UUID, uuid.toString()).size();
+ return holderRepositories.getSubsystemRepository().readSubsystems(status, deleted,
+ uuid.toString(), null, null, null, null, null, null).size();
} else if (Type.DISCIPLINE.equals(type)) {
- return holderRepositories.getDisciplineRepository().readDisciplines(status, deleted, FieldStructure.UUID, uuid.toString()).size();
+ return holderRepositories.getDisciplineRepository().readDisciplines(status, deleted,
+ uuid.toString(), null, null, null, null, null).size();
} else if (Type.DEVICEGROUP.equals(type)) {
- return holderRepositories.getDeviceGroupRepository().readDeviceGroups(status, deleted, FieldStructure.UUID, uuid.toString()).size();
+ return holderRepositories.getDeviceGroupRepository().readDeviceGroups(status, deleted,
+ uuid.toString(), null, null, null, null, null, null).size();
} else if (Type.DEVICETYPE.equals(type)) {
- return holderRepositories.getDeviceTypeRepository().readDeviceTypes(status, deleted, FieldStructure.UUID, uuid.toString()).size();
+ return holderRepositories.getDeviceTypeRepository().readDeviceTypes(status, deleted,
+ uuid.toString(), null, null, null, null, null, null).size();
}
return 0;
}
@@ -489,7 +484,8 @@ public class ValidateStructureElementUtil {
} 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());
+ List<Discipline> disciplines = holderRepositories.getDisciplineRepository().readDisciplines(Status.APPROVED, false,
+ parentUuid.toString(), null, null, null, null, null);
ExceptionUtil.validateConditionDataConflictException(disciplines != null && disciplines.size() == 1, message, details, TextUtil.PARENT);
// note rules for mnemonic for device group
@@ -575,12 +571,15 @@ public class ValidateStructureElementUtil {
private static void validateStructuresParent(Type type, UUID parent, Status status, Boolean deleted,
HolderRepositories holderRepositories, String message, String details, String field){
+ // about finding out if structures are in place in order for structure operation to be allowed
+
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){
+ // about finding out if structures are in place in order for structure operation to be allowed
// parent may be null
List<UUID> listUuid = null;
@@ -596,6 +595,7 @@ public class ValidateStructureElementUtil {
private static void validateStructuresStatusMnemonicequivalence(UUID uuid, Type type, UUID parent, String mnemonic,
EssNamingConvention namingConvention, HolderRepositories holderRepositories, StructureChoice structureChoice,
String message, String details, String field){
+ // about finding out if structures are in place in order for structure operation to be allowed
// parent may be null
List<UUID> listUuid = null;
@@ -612,40 +612,45 @@ public class ValidateStructureElementUtil {
HolderRepositories holderRepositories) {
String queryValue = parent.toString();
if (Type.SYSTEM.equals(type)) {
- return holderRepositories.getSystemGroupRepository().readSystemGroups(status, deleted, FieldStructure.UUID, queryValue).size();
+ return holderRepositories.getSystemGroupRepository().readSystemGroups(status, deleted,
+ queryValue, null, null, null, null, null).size();
} else if (Type.SUBSYSTEM.equals(type)) {
- return holderRepositories.getSystemRepository().readSystems(status, deleted, FieldStructure.UUID, queryValue).size();
+ return holderRepositories.getSystemRepository().readSystems(status, deleted,
+ queryValue, null, null, null, null, null, null).size();
} else if (Type.DEVICEGROUP.equals(type)) {
- return holderRepositories.getDisciplineRepository().readDisciplines(status, deleted, FieldStructure.UUID, queryValue).size();
+ return holderRepositories.getDisciplineRepository().readDisciplines(status, deleted,
+ queryValue, null, null, null, null, null).size();
} else if (Type.DEVICETYPE.equals(type)) {
- return holderRepositories.getDeviceGroupRepository().readDeviceGroups(status, deleted, FieldStructure.UUID, queryValue).size();
+ return holderRepositories.getDeviceGroupRepository().readDeviceGroups(status, deleted,
+ queryValue, null, null, null, null, null, null).size();
}
return 0;
}
private static List<UUID> getStructures(Type type, UUID parent, String mnemonic, Status status, Boolean deleted, Boolean equivalence,
EssNamingConvention namingConvention, HolderRepositories holderRepositories) {
+ // get structures to be used in validation
+ // may be difficult to understand, need context of how and where it is used
+ // before ok to create or approve, structures need to exist or not exist, this method helps to find out
+
+ String queryUuid = null;
+ String queryParentUuid = null;
+ String queryMnemonic = null;
+ String queryMnemonicequivalence = null;
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;
+ if (equivalence) {
+ queryMnemonicequivalence = namingConvention.equivalenceClassRepresentative(mnemonic);
+ } else {
+ queryMnemonic = 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();
}
@@ -653,43 +658,45 @@ public class ValidateStructureElementUtil {
// parent
if (hasMnemonic) {
// query table for type
- queryFields = new FieldStructure[]{FieldStructure.PARENT, mnemonicField};
- queryValues = new String[]{parent.toString(), mnemonicValue};
+ queryParentUuid = parent.toString();
} else {
// query table for parent to type
queryParentTable = true;
- queryFields = new FieldStructure[]{FieldStructure.UUID};
- queryValues = new String[]{parent.toString()};
+ queryUuid = parent.toString();
+ queryParentUuid = null;
+ queryMnemonic = null;
+ queryMnemonicequivalence = null;
}
}
// query table and return list with uuid
if (Type.SYSTEMGROUP.equals(type)) {
- return StructureUtil.listSystemGroup2Uuid(holderRepositories.getSystemGroupRepository().readSystemGroups(status, deleted, queryFields, queryValues));
+ return StructureUtil.listSystemGroup2Uuid(
+ holderRepositories.getSystemGroupRepository().readSystemGroups(status, deleted, queryUuid, null, queryMnemonic, queryMnemonicequivalence, null, null));
} else if (Type.SYSTEM.equals(type)) {
if (queryParentTable) {
- return StructureUtil.listSystemGroup2Uuid(holderRepositories.getSystemGroupRepository().readSystemGroups(status, deleted, queryFields, queryValues));
+ return StructureUtil.listSystemGroup2Uuid(holderRepositories.getSystemGroupRepository().readSystemGroups(status, deleted, queryUuid, null, queryMnemonic, queryMnemonicequivalence, null, null));
} else {
- return StructureUtil.listSystem2Uuid(holderRepositories.getSystemRepository().readSystems(status, deleted, queryFields, queryValues));
+ return StructureUtil.listSystem2Uuid(holderRepositories.getSystemRepository().readSystems(status, deleted, queryUuid, queryParentUuid, null, queryMnemonic, queryMnemonicequivalence, null, null));
}
} else if (Type.SUBSYSTEM.equals(type)) {
if (queryParentTable) {
- return StructureUtil.listSystem2Uuid(holderRepositories.getSystemRepository().readSystems(status, deleted, queryFields, queryValues));
+ return StructureUtil.listSystem2Uuid(holderRepositories.getSystemRepository().readSystems(status, deleted, queryUuid, queryParentUuid, null, queryMnemonic, queryMnemonicequivalence, null, null));
} else {
- return StructureUtil.listSubsystem2Uuid(holderRepositories.getSubsystemRepository().readSubsystems(status, deleted, queryFields, queryValues));
+ return StructureUtil.listSubsystem2Uuid(holderRepositories.getSubsystemRepository().readSubsystems(status, deleted, queryUuid, queryParentUuid, null, queryMnemonic, queryMnemonicequivalence, null, null));
}
} else if (Type.DISCIPLINE.equals(type)) {
- return StructureUtil.listDiscipline2Uuid(holderRepositories.getDisciplineRepository().readDisciplines(status, deleted, queryFields, queryValues));
+ return StructureUtil.listDiscipline2Uuid(holderRepositories.getDisciplineRepository().readDisciplines(status, deleted, queryUuid, null, queryMnemonic, queryMnemonicequivalence, null, null));
} else if (Type.DEVICEGROUP.equals(type)) {
if (queryParentTable) {
- return StructureUtil.listDiscipline2Uuid(holderRepositories.getDisciplineRepository().readDisciplines(status, deleted, queryFields, queryValues));
+ return StructureUtil.listDiscipline2Uuid(holderRepositories.getDisciplineRepository().readDisciplines(status, deleted, queryUuid, null, queryMnemonic, queryMnemonicequivalence, null, null));
} else {
- return StructureUtil.listDeviceGroup2Uuid(holderRepositories.getDeviceGroupRepository().readDeviceGroups(status, deleted, queryFields, queryValues)); }
+ return StructureUtil.listDeviceGroup2Uuid(holderRepositories.getDeviceGroupRepository().readDeviceGroups(status, deleted, queryUuid, queryParentUuid, null, queryMnemonic, queryMnemonicequivalence, null, null)); }
} else if (Type.DEVICETYPE.equals(type)) {
if (queryParentTable) {
- return StructureUtil.listDeviceGroup2Uuid(holderRepositories.getDeviceGroupRepository().readDeviceGroups(status, deleted, queryFields, queryValues));
+ return StructureUtil.listDeviceGroup2Uuid(holderRepositories.getDeviceGroupRepository().readDeviceGroups(status, deleted, queryUuid, queryParentUuid, null, queryMnemonic, queryMnemonicequivalence, null, null));
} else {
- return StructureUtil.listDeviceType2Uuid(holderRepositories.getDeviceTypeRepository().readDeviceTypes(status, deleted, queryFields, queryValues));
+ return StructureUtil.listDeviceType2Uuid(holderRepositories.getDeviceTypeRepository().readDeviceTypes(status, deleted, queryUuid, queryParentUuid, null, queryMnemonic, queryMnemonicequivalence, null, null));
}
}
return Lists.newArrayList();
diff --git a/src/test/java/org/openepics/names/docker/StructuresDeviceGroupIT.java b/src/test/java/org/openepics/names/docker/StructuresDeviceGroupIT.java
index 62675599..297b399d 100644
--- a/src/test/java/org/openepics/names/docker/StructuresDeviceGroupIT.java
+++ b/src/test/java/org/openepics/names/docker/StructuresDeviceGroupIT.java
@@ -988,11 +988,11 @@ class StructuresDeviceGroupIT {
ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=APPROVED", 0, -1);
ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=CANCELLED", 0, -1);
ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=REJECTED", 0, -1);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?queryFields=UUID&queryValues=" + createdStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=PENDING&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=APPROVED&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=CANCELLED&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=REJECTED&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?uuid=" + createdStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Di", 1);
ITUtilStructureElement.assertRead("/mnemonic/Rsha", 0);
@@ -1016,11 +1016,11 @@ class StructuresDeviceGroupIT {
ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=APPROVED", 1, -1);
ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=CANCELLED", 0, -1);
ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=REJECTED", 0, -1);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?queryFields=UUID&queryValues=" + approvedStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=PENDING&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=APPROVED&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=CANCELLED&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=REJECTED&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?uuid=" + approvedStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Di", 1);
ITUtilStructureElement.assertRead("/mnemonic/Rsha", 0);
@@ -1071,11 +1071,11 @@ class StructuresDeviceGroupIT {
ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=APPROVED", 0, -1);
ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=CANCELLED", 0, -1);
ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=REJECTED", 0, -1);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?queryFields=UUID&queryValues=" + createdStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=PENDING&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=APPROVED&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=CANCELLED&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=REJECTED&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?uuid=" + createdStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Di", 1);
ITUtilStructureElement.assertRead("/mnemonic/Rshc", 0);
@@ -1099,11 +1099,11 @@ class StructuresDeviceGroupIT {
ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=APPROVED", 0, -1);
ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=CANCELLED", 1, -1);
ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=REJECTED", 0, -1);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?queryFields=UUID&queryValues=" + cancelledStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=PENDING&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=APPROVED&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=CANCELLED&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=REJECTED&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?uuid=" + cancelledStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Di", 1);
ITUtilStructureElement.assertRead("/mnemonic/Rshc", 0);
@@ -1154,11 +1154,11 @@ class StructuresDeviceGroupIT {
ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=APPROVED", 0, -1);
ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=CANCELLED", 0, -1);
ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=REJECTED", 0, -1);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?queryFields=UUID&queryValues=" + createdStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=PENDING&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=APPROVED&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=CANCELLED&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=REJECTED&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?uuid=" + createdStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Di", 1);
ITUtilStructureElement.assertRead("/mnemonic/Rshr", 0);
@@ -1182,11 +1182,11 @@ class StructuresDeviceGroupIT {
ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=APPROVED", 0, -1);
ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=CANCELLED", 0, -1);
ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=REJECTED", 1, -1);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?queryFields=UUID&queryValues=" + rejectedStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=PENDING&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=APPROVED&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=CANCELLED&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=REJECTED&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?uuid=" + rejectedStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Di", 1);
ITUtilStructureElement.assertRead("/mnemonic/Rshr", 0);
@@ -1279,10 +1279,10 @@ class StructuresDeviceGroupIT {
// ( include if latest )
// include if latest not exists (considered present + future)
- ITUtilStructureElement.assertRead("/DEVICEGROUP?queryFields=UUID&queryValues=" + uuid.toString(), 1);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?queryFields=UUID&queryValues=" + uuid2.toString(), 1);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?queryFields=UUID&queryValues=" + uuid3.toString(), 1);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?queryFields=UUID&queryValues=" + uuid4.toString(), 1);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?uuid=" + uuid.toString(), 1);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?uuid=" + uuid2.toString(), 1);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?uuid=" + uuid3.toString(), 1);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?uuid=" + uuid4.toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/P1", 0);
ITUtilStructureElement.assertRead("/mnemonic/C1", 0);
@@ -1449,10 +1449,10 @@ class StructuresDeviceGroupIT {
// ( include if latest )
// include if latest not exists (considered present + future)
- ITUtilStructureElement.assertRead("/DEVICEGROUP?queryFields=UUID&queryValues=" + uuid.toString(), 2);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?queryFields=UUID&queryValues=" + uuid2.toString(), 2);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?queryFields=UUID&queryValues=" + uuid3.toString(), 2);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?queryFields=UUID&queryValues=" + uuid4.toString(), 1);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?uuid=" + uuid.toString(), 2);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?uuid=" + uuid2.toString(), 2);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?uuid=" + uuid3.toString(), 2);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?uuid=" + uuid4.toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/P9", 0);
ITUtilStructureElement.assertRead("/mnemonic/C9", 0);
@@ -1773,26 +1773,26 @@ class StructuresDeviceGroupIT {
// from first structure element
assertNotNull(uuid);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?queryFields=MNEMONICPATH&queryValues=Di2", 30);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=PENDING&queryFields=MNEMONICPATH&queryValues=Di2", 5);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=APPROVED&queryFields=MNEMONICPATH&queryValues=Di2", 20);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=CANCELLED&queryFields=MNEMONICPATH&queryValues=Di2", 0);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=REJECTED&queryFields=MNEMONICPATH&queryValues=Di2", 5);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=PENDING&statuses=APPROVED&queryFields=MNEMONICPATH&queryValues=Di2", 25);
-
- ITUtilStructureElement.assertRead("/DEVICEGROUP?deleted=false&queryFields=MNEMONICPATH&queryValues=Di2", 15);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?deleted=false&statuses=PENDING&queryFields=MNEMONICPATH&queryValues=Di2", 0);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?deleted=false&statuses=APPROVED&queryFields=MNEMONICPATH&queryValues=Di2", 15);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?deleted=false&statuses=CANCELLED&queryFields=MNEMONICPATH&queryValues=Di2", 0);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?deleted=false&statuses=REJECTED&queryFields=MNEMONICPATH&queryValues=Di2", 0);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?deleted=false&statuses=PENDING&statuses=APPROVED&queryFields=MNEMONICPATH&queryValues=Di2", 15);
-
- ITUtilStructureElement.assertRead("/DEVICEGROUP?deleted=true&queryFields=MNEMONICPATH&queryValues=Di2", 15);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?deleted=true&statuses=PENDING&queryFields=MNEMONICPATH&queryValues=Di2", 5);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?deleted=true&statuses=APPROVED&queryFields=MNEMONICPATH&queryValues=Di2", 5);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?deleted=true&statuses=CANCELLED&queryFields=MNEMONICPATH&queryValues=Di2", 0);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?deleted=true&statuses=REJECTED&queryFields=MNEMONICPATH&queryValues=Di2", 5);
- ITUtilStructureElement.assertRead("/DEVICEGROUP?deleted=true&statuses=PENDING&statuses=APPROVED&queryFields=MNEMONICPATH&queryValues=Di2", 10);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?mnemonicpath=Di2", 30);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=PENDING&mnemonicpath=Di2", 5);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=APPROVED&mnemonicpath=Di2", 20);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=CANCELLED&mnemonicpath=Di2", 0);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=REJECTED&mnemonicpath=Di2", 5);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?statuses=PENDING&statuses=APPROVED&mnemonicpath=Di2", 25);
+
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?deleted=false&mnemonicpath=Di2", 15);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?deleted=false&statuses=PENDING&mnemonicpath=Di2", 0);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?deleted=false&statuses=APPROVED&mnemonicpath=Di2", 15);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?deleted=false&statuses=CANCELLED&mnemonicpath=Di2", 0);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?deleted=false&statuses=REJECTED&mnemonicpath=Di2", 0);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?deleted=false&statuses=PENDING&statuses=APPROVED&mnemonicpath=Di2", 15);
+
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?deleted=true&mnemonicpath=Di2", 15);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?deleted=true&statuses=PENDING&mnemonicpath=Di2", 5);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?deleted=true&statuses=APPROVED&mnemonicpath=Di2", 5);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?deleted=true&statuses=CANCELLED&mnemonicpath=Di2", 0);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?deleted=true&statuses=REJECTED&mnemonicpath=Di2", 5);
+ ITUtilStructureElement.assertRead("/DEVICEGROUP?deleted=true&statuses=PENDING&statuses=APPROVED&mnemonicpath=Di2", 10);
ITUtilStructureElement.assertRead("/children/DEVICEGROUP/" + uuid.toString(), 0);
ITUtilStructureElement.assertRead("/children/DISCIPLINE/" + disciplineUuid.toString(), 1, -1);
diff --git a/src/test/java/org/openepics/names/docker/StructuresDeviceTypeIT.java b/src/test/java/org/openepics/names/docker/StructuresDeviceTypeIT.java
index 6016a0c9..c1e33320 100644
--- a/src/test/java/org/openepics/names/docker/StructuresDeviceTypeIT.java
+++ b/src/test/java/org/openepics/names/docker/StructuresDeviceTypeIT.java
@@ -992,11 +992,11 @@ class StructuresDeviceTypeIT {
ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=APPROVED", 0, -1);
ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=CANCELLED", 0, -1);
ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=REJECTED", 0, -1);
- ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rsha", 1);
- ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/DEVICETYPE?queryFields=UUID&queryValues=" + createdStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=PENDING&mnemonic=Rsha", 1);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=APPROVED&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=CANCELLED&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=REJECTED&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?uuid=" + createdStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Di", 1);
ITUtilStructureElement.assertRead("/mnemonic/Rsha", 0);
@@ -1021,11 +1021,11 @@ class StructuresDeviceTypeIT {
ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=APPROVED", 1, -1);
ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=CANCELLED", 0, -1);
ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=REJECTED", 0, -1);
- ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rsha", 1);
- ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/DEVICETYPE?queryFields=UUID&queryValues=" + approvedStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=PENDING&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=APPROVED&mnemonic=Rsha", 1);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=CANCELLED&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=REJECTED&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?uuid=" + approvedStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Di", 1);
ITUtilStructureElement.assertRead("/mnemonic/Rsha", 1);
@@ -1077,11 +1077,11 @@ class StructuresDeviceTypeIT {
ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=APPROVED", 0, -1);
ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=CANCELLED", 0, -1);
ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=REJECTED", 0, -1);
- ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rshc", 1);
- ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/DEVICETYPE?queryFields=UUID&queryValues=" + createdStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=PENDING&mnemonic=Rshc", 1);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=APPROVED&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=CANCELLED&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=REJECTED&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?uuid=" + createdStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Di", 1);
ITUtilStructureElement.assertRead("/mnemonic/Rshc", 0);
@@ -1106,11 +1106,11 @@ class StructuresDeviceTypeIT {
ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=APPROVED", 0, -1);
ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=CANCELLED", 1, -1);
ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=REJECTED", 0, -1);
- ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rshc", 1);
- ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/DEVICETYPE?queryFields=UUID&queryValues=" + cancelledStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=PENDING&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=APPROVED&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=CANCELLED&mnemonic=Rshc", 1);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=REJECTED&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?uuid=" + cancelledStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Di", 1);
ITUtilStructureElement.assertRead("/mnemonic/Rshc", 0);
@@ -1162,11 +1162,11 @@ class StructuresDeviceTypeIT {
ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=APPROVED", 0, -1);
ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=CANCELLED", 0, -1);
ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=REJECTED", 0, -1);
- ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rshr", 1);
- ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/DEVICETYPE?queryFields=UUID&queryValues=" + createdStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=PENDING&mnemonic=Rshr", 1);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=APPROVED&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=CANCELLED&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=REJECTED&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?uuid=" + createdStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Di", 1);
ITUtilStructureElement.assertRead("/mnemonic/Rshr", 0);
@@ -1191,11 +1191,11 @@ class StructuresDeviceTypeIT {
ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=APPROVED", 0, -1);
ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=CANCELLED", 0, -1);
ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=REJECTED", 1, -1);
- ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rshr", 1);
- ITUtilStructureElement.assertRead("/DEVICETYPE?queryFields=UUID&queryValues=" + rejectedStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=PENDING&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=APPROVED&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=CANCELLED&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=REJECTED&mnemonic=Rshr", 1);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?uuid=" + rejectedStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Di", 1);
ITUtilStructureElement.assertRead("/mnemonic/Rshr", 0);
@@ -1289,10 +1289,10 @@ class StructuresDeviceTypeIT {
// ( include if latest )
// include if latest not exists (considered present + future)
- ITUtilStructureElement.assertRead("/DEVICETYPE?queryFields=UUID&queryValues=" + uuid.toString(), 1);
- ITUtilStructureElement.assertRead("/DEVICETYPE?queryFields=UUID&queryValues=" + uuid2.toString(), 1);
- ITUtilStructureElement.assertRead("/DEVICETYPE?queryFields=UUID&queryValues=" + uuid3.toString(), 1);
- ITUtilStructureElement.assertRead("/DEVICETYPE?queryFields=UUID&queryValues=" + uuid4.toString(), 1);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?uuid=" + uuid.toString(), 1);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?uuid=" + uuid2.toString(), 1);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?uuid=" + uuid3.toString(), 1);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?uuid=" + uuid4.toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/P1", 0);
ITUtilStructureElement.assertRead("/mnemonic/C1", 0);
@@ -1462,10 +1462,10 @@ class StructuresDeviceTypeIT {
// ( include if latest )
// include if latest not exists (considered present + future)
- ITUtilStructureElement.assertRead("/DEVICETYPE?queryFields=UUID&queryValues=" + uuid.toString(), 2);
- ITUtilStructureElement.assertRead("/DEVICETYPE?queryFields=UUID&queryValues=" + uuid2.toString(), 2);
- ITUtilStructureElement.assertRead("/DEVICETYPE?queryFields=UUID&queryValues=" + uuid3.toString(), 2);
- ITUtilStructureElement.assertRead("/DEVICETYPE?queryFields=UUID&queryValues=" + uuid4.toString(), 1);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?uuid=" + uuid.toString(), 2);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?uuid=" + uuid2.toString(), 2);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?uuid=" + uuid3.toString(), 2);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?uuid=" + uuid4.toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/P9", 1);
ITUtilStructureElement.assertRead("/mnemonic/C9", 1);
@@ -1789,26 +1789,26 @@ class StructuresDeviceTypeIT {
// from first structure element
assertNotNull(uuid);
- ITUtilStructureElement.assertRead("/DEVICETYPE?queryFields=MNEMONIC&queryValues=A__", 45);
- ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=PENDING&queryFields=MNEMONIC&queryValues=A__", 10);
- ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=APPROVED&queryFields=MNEMONIC&queryValues=A__", 20);
- ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=REJECTED&queryFields=MNEMONIC&queryValues=A__", 10);
- ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=PENDING&statuses=APPROVED&queryFields=MNEMONIC&queryValues=A__", 30);
-
- ITUtilStructureElement.assertRead("/DEVICETYPE?deleted=false&queryFields=MNEMONIC&queryValues=A__", 30);
- ITUtilStructureElement.assertRead("/DEVICETYPE?deleted=false&statuses=PENDING&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/DEVICETYPE?deleted=false&statuses=APPROVED&queryFields=MNEMONIC&queryValues=A__", 15);
- ITUtilStructureElement.assertRead("/DEVICETYPE?deleted=false&statuses=CANCELLED&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/DEVICETYPE?deleted=false&statuses=REJECTED&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/DEVICETYPE?deleted=false&statuses=PENDING&statuses=APPROVED&queryFields=MNEMONIC&queryValues=A__", 20);
-
- ITUtilStructureElement.assertRead("/DEVICETYPE?deleted=true&queryFields=MNEMONIC&queryValues=A__", 15);
- ITUtilStructureElement.assertRead("/DEVICETYPE?deleted=true&statuses=PENDING&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/DEVICETYPE?deleted=true&statuses=APPROVED&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/DEVICETYPE?deleted=true&statuses=CANCELLED&queryFields=MNEMONIC&queryValues=A__", 0);
- ITUtilStructureElement.assertRead("/DEVICETYPE?deleted=true&statuses=REJECTED&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/DEVICETYPE?deleted=true&statuses=PENDING&statuses=APPROVED&queryFields=MNEMONIC&queryValues=A__", 10);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?mnemonic=A__", 45);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=PENDING&mnemonic=A__", 10);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=APPROVED&mnemonic=A__", 20);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=CANCELLED&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=REJECTED&mnemonic=A__", 10);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?statuses=PENDING&statuses=APPROVED&mnemonic=A__", 30);
+
+ ITUtilStructureElement.assertRead("/DEVICETYPE?deleted=false&mnemonic=A__", 30);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?deleted=false&statuses=PENDING&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?deleted=false&statuses=APPROVED&mnemonic=A__", 15);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?deleted=false&statuses=CANCELLED&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?deleted=false&statuses=REJECTED&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?deleted=false&statuses=PENDING&statuses=APPROVED&mnemonic=A__", 20);
+
+ ITUtilStructureElement.assertRead("/DEVICETYPE?deleted=true&mnemonic=A__", 15);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?deleted=true&statuses=PENDING&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?deleted=true&statuses=APPROVED&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?deleted=true&statuses=CANCELLED&mnemonic=A__", 0);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?deleted=true&statuses=REJECTED&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/DEVICETYPE?deleted=true&statuses=PENDING&statuses=APPROVED&mnemonic=A__", 10);
ITUtilStructureElement.assertRead("/children/DEVICETYPE/" + uuid.toString(), 0);
ITUtilStructureElement.assertRead("/children/DEVICEGROUP/" + deviceGroupUuid.toString(), 1, -1);
diff --git a/src/test/java/org/openepics/names/docker/StructuresDisciplineIT.java b/src/test/java/org/openepics/names/docker/StructuresDisciplineIT.java
index daa62485..496cbd5a 100644
--- a/src/test/java/org/openepics/names/docker/StructuresDisciplineIT.java
+++ b/src/test/java/org/openepics/names/docker/StructuresDisciplineIT.java
@@ -935,11 +935,11 @@ class StructuresDisciplineIT {
ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=APPROVED", 0, -1);
ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=CANCELLED", 0, -1);
ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=REJECTED", 0, -1);
- ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rsha", 1);
- ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/DISCIPLINE?queryFields=UUID&queryValues=" + createdStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=PENDING&mnemonic=Rsha", 1);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=APPROVED&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=CANCELLED&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=REJECTED&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?uuid=" + createdStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Rsha", 0);
@@ -959,11 +959,11 @@ class StructuresDisciplineIT {
ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=APPROVED", 1, -1);
ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=CANCELLED", 0, -1);
ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=REJECTED", 0, -1);
- ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rsha", 1);
- ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/DISCIPLINE?queryFields=UUID&queryValues=" + approvedStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=PENDING&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=APPROVED&mnemonic=Rsha", 1);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=CANCELLED&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=REJECTED&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?uuid=" + approvedStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Rsha", 1);
@@ -1010,11 +1010,11 @@ class StructuresDisciplineIT {
ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=APPROVED", 0, -1);
ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=CANCELLED", 0, -1);
ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=REJECTED", 0, -1);
- ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rshc", 1);
- ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/DISCIPLINE?queryFields=UUID&queryValues=" + createdStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=PENDING&mnemonic=Rshc", 1);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=APPROVED&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=CANCELLED&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=REJECTED&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?uuid=" + createdStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Rshc", 0);
@@ -1034,11 +1034,11 @@ class StructuresDisciplineIT {
ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=APPROVED", 0, -1);
ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=CANCELLED", 1, -1);
ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=REJECTED", 0, -1);
- ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rshc", 1);
- ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/DISCIPLINE?queryFields=UUID&queryValues=" + cancelledStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=PENDING&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=APPROVED&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=CANCELLED&mnemonic=Rshc", 1);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=REJECTED&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?uuid=" + cancelledStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Rshc", 0);
@@ -1085,11 +1085,11 @@ class StructuresDisciplineIT {
ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=APPROVED", 0, -1);
ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=CANCELLED", 0, -1);
ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=REJECTED", 0, -1);
- ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rshr", 1);
- ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/DISCIPLINE?queryFields=UUID&queryValues=" + createdStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=PENDING&mnemonic=Rshr", 1);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=APPROVED&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=CANCELLED&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=REJECTED&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?uuid=" + createdStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Rshr", 0);
@@ -1109,11 +1109,11 @@ class StructuresDisciplineIT {
ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=APPROVED", 0, -1);
ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=CANCELLED", 0, -1);
ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=REJECTED", 1, -1);
- ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rshr", 1);
- ITUtilStructureElement.assertRead("/DISCIPLINE?queryFields=UUID&queryValues=" + rejectedStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=PENDING&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=APPROVED&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=CANCELLED&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=REJECTED&mnemonic=Rshr", 1);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?uuid=" + rejectedStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Rshr", 0);
@@ -1202,10 +1202,10 @@ class StructuresDisciplineIT {
// ( include if latest )
// include if latest not exists (considered present + future)
- ITUtilStructureElement.assertRead("/DISCIPLINE?queryFields=UUID&queryValues=" + uuid.toString(), 1);
- ITUtilStructureElement.assertRead("/DISCIPLINE?queryFields=UUID&queryValues=" + uuid2.toString(), 1);
- ITUtilStructureElement.assertRead("/DISCIPLINE?queryFields=UUID&queryValues=" + uuid3.toString(), 1);
- ITUtilStructureElement.assertRead("/DISCIPLINE?queryFields=UUID&queryValues=" + uuid4.toString(), 1);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?uuid=" + uuid.toString(), 1);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?uuid=" + uuid2.toString(), 1);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?uuid=" + uuid3.toString(), 1);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?uuid=" + uuid4.toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/P1", 0);
ITUtilStructureElement.assertRead("/mnemonic/C1", 0);
@@ -1371,10 +1371,10 @@ class StructuresDisciplineIT {
// ( include if latest )
// include if latest not exists (considered present + future)
- ITUtilStructureElement.assertRead("/DISCIPLINE?queryFields=UUID&queryValues=" + uuid.toString(), 2);
- ITUtilStructureElement.assertRead("/DISCIPLINE?queryFields=UUID&queryValues=" + uuid2.toString(), 2);
- ITUtilStructureElement.assertRead("/DISCIPLINE?queryFields=UUID&queryValues=" + uuid3.toString(), 2);
- ITUtilStructureElement.assertRead("/DISCIPLINE?queryFields=UUID&queryValues=" + uuid4.toString(), 1);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?uuid=" + uuid.toString(), 2);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?uuid=" + uuid2.toString(), 2);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?uuid=" + uuid3.toString(), 2);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?uuid=" + uuid4.toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/P9", 1);
ITUtilStructureElement.assertRead("/mnemonic/C9", 1);
@@ -1694,26 +1694,26 @@ class StructuresDisciplineIT {
// from first structure element
assertNotNull(uuid);
- ITUtilStructureElement.assertRead("/DISCIPLINE?queryFields=MNEMONIC&queryValues=A__", 45);
- ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=PENDING&queryFields=MNEMONIC&queryValues=A__", 10);
- ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=APPROVED&queryFields=MNEMONIC&queryValues=A__", 20);
- ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=REJECTED&queryFields=MNEMONIC&queryValues=A__", 10);
- ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=PENDING&statuses=APPROVED&queryFields=MNEMONIC&queryValues=A__", 30);
-
- ITUtilStructureElement.assertRead("/DISCIPLINE?deleted=false&queryFields=MNEMONIC&queryValues=A__", 30);
- ITUtilStructureElement.assertRead("/DISCIPLINE?deleted=false&statuses=PENDING&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/DISCIPLINE?deleted=false&statuses=APPROVED&queryFields=MNEMONIC&queryValues=A__", 15);
- ITUtilStructureElement.assertRead("/DISCIPLINE?deleted=false&statuses=CANCELLED&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/DISCIPLINE?deleted=false&statuses=REJECTED&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/DISCIPLINE?deleted=false&statuses=PENDING&statuses=APPROVED&queryFields=MNEMONIC&queryValues=A__", 20);
-
- ITUtilStructureElement.assertRead("/DISCIPLINE?deleted=true&queryFields=MNEMONIC&queryValues=A__", 15);
- ITUtilStructureElement.assertRead("/DISCIPLINE?deleted=true&statuses=PENDING&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/DISCIPLINE?deleted=true&statuses=APPROVED&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/DISCIPLINE?deleted=true&statuses=CANCELLED&queryFields=MNEMONIC&queryValues=A__", 0);
- ITUtilStructureElement.assertRead("/DISCIPLINE?deleted=true&statuses=REJECTED&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/DISCIPLINE?deleted=true&statuses=PENDING&statuses=APPROVED&queryFields=MNEMONIC&queryValues=A__", 10);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?mnemonic=A__", 45);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=PENDING&mnemonic=A__", 10);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=APPROVED&mnemonic=A__", 20);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=CANCELLED&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=REJECTED&mnemonic=A__", 10);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?statuses=PENDING&statuses=APPROVED&mnemonic=A__", 30);
+
+ ITUtilStructureElement.assertRead("/DISCIPLINE?deleted=false&mnemonic=A__", 30);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?deleted=false&statuses=PENDING&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?deleted=false&statuses=APPROVED&mnemonic=A__", 15);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?deleted=false&statuses=CANCELLED&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?deleted=false&statuses=REJECTED&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?deleted=false&statuses=PENDING&statuses=APPROVED&mnemonic=A__", 20);
+
+ ITUtilStructureElement.assertRead("/DISCIPLINE?deleted=true&mnemonic=A__", 15);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?deleted=true&statuses=PENDING&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?deleted=true&statuses=APPROVED&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?deleted=true&statuses=CANCELLED&mnemonic=A__", 0);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?deleted=true&statuses=REJECTED&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/DISCIPLINE?deleted=true&statuses=PENDING&statuses=APPROVED&mnemonic=A__", 10);
ITUtilStructureElement.assertRead("/children/DISCIPLINE/" + uuid.toString(), 0);
diff --git a/src/test/java/org/openepics/names/docker/StructuresSubsystemIT.java b/src/test/java/org/openepics/names/docker/StructuresSubsystemIT.java
index 80caad58..0cf4086c 100644
--- a/src/test/java/org/openepics/names/docker/StructuresSubsystemIT.java
+++ b/src/test/java/org/openepics/names/docker/StructuresSubsystemIT.java
@@ -994,11 +994,11 @@ class StructuresSubsystemIT {
ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=APPROVED", 0, -1);
ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=CANCELLED", 0, -1);
ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=REJECTED", 0, -1);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rsha", 1);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?queryFields=UUID&queryValues=" + createdStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=PENDING&mnemonic=Rsha", 1);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=APPROVED&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=CANCELLED&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=REJECTED&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?uuid=" + createdStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Sg", 1);
ITUtilStructureElement.assertRead("/mnemonic/Sys", 1);
@@ -1030,11 +1030,11 @@ class StructuresSubsystemIT {
ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=APPROVED", 1, -1);
ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=CANCELLED", 0, -1);
ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=REJECTED", 0, -1);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rsha", 1);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?queryFields=UUID&queryValues=" + approvedStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=PENDING&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=APPROVED&mnemonic=Rsha", 1);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=CANCELLED&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=REJECTED&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?uuid=" + approvedStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Sg", 1);
ITUtilStructureElement.assertRead("/mnemonic/Sys", 1);
@@ -1093,11 +1093,11 @@ class StructuresSubsystemIT {
ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=APPROVED", 0, -1);
ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=CANCELLED", 0, -1);
ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=REJECTED", 0, -1);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rshc", 1);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?queryFields=UUID&queryValues=" + createdStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=PENDING&mnemonic=Rshc", 1);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=APPROVED&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=CANCELLED&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=REJECTED&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?uuid=" + createdStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Sg", 1);
ITUtilStructureElement.assertRead("/mnemonic/Sys", 1);
@@ -1129,11 +1129,11 @@ class StructuresSubsystemIT {
ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=APPROVED", 0, -1);
ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=CANCELLED", 1, -1);
ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=REJECTED", 0, -1);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rshc", 1);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?queryFields=UUID&queryValues=" + cancelledStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=PENDING&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=APPROVED&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=CANCELLED&mnemonic=Rshc", 1);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=REJECTED&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?uuid=" + cancelledStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Sg", 1);
ITUtilStructureElement.assertRead("/mnemonic/Sys", 1);
@@ -1192,11 +1192,11 @@ class StructuresSubsystemIT {
ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=APPROVED", 0, -1);
ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=CANCELLED", 0, -1);
ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=REJECTED", 0, -1);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rshr", 1);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?queryFields=UUID&queryValues=" + createdStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=PENDING&mnemonic=Rshr", 1);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=APPROVED&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=CANCELLED&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=REJECTED&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?uuid=" + createdStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Sg", 1);
ITUtilStructureElement.assertRead("/mnemonic/Sys", 1);
@@ -1228,11 +1228,11 @@ class StructuresSubsystemIT {
ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=APPROVED", 0, -1);
ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=CANCELLED", 0, -1);
ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=REJECTED", 1, -1);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rshr", 1);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?queryFields=UUID&queryValues=" + rejectedStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=PENDING&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=APPROVED&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=CANCELLED&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=REJECTED&mnemonic=Rshr", 1);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?uuid=" + rejectedStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Sg", 1);
ITUtilStructureElement.assertRead("/mnemonic/Sys", 1);
@@ -1333,10 +1333,10 @@ class StructuresSubsystemIT {
// ( include if latest )
// include if latest not exists (considered present + future)
- ITUtilStructureElement.assertRead("/SUBSYSTEM?queryFields=UUID&queryValues=" + uuid.toString(), 1);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?queryFields=UUID&queryValues=" + uuid2.toString(), 1);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?queryFields=UUID&queryValues=" + uuid3.toString(), 1);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?queryFields=UUID&queryValues=" + uuid4.toString(), 1);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?uuid=" + uuid.toString(), 1);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?uuid=" + uuid2.toString(), 1);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?uuid=" + uuid3.toString(), 1);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?uuid=" + uuid4.toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/P1", 0);
ITUtilStructureElement.assertRead("/mnemonic/C1", 0);
@@ -1510,10 +1510,10 @@ class StructuresSubsystemIT {
// ( include if latest )
// include if latest not exists (considered present + future)
- ITUtilStructureElement.assertRead("/SUBSYSTEM?queryFields=UUID&queryValues=" + uuid.toString(), 2);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?queryFields=UUID&queryValues=" + uuid2.toString(), 2);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?queryFields=UUID&queryValues=" + uuid3.toString(), 2);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?queryFields=UUID&queryValues=" + uuid4.toString(), 1);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?uuid=" + uuid.toString(), 2);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?uuid=" + uuid2.toString(), 2);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?uuid=" + uuid3.toString(), 2);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?uuid=" + uuid4.toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/P9", 1);
ITUtilStructureElement.assertRead("/mnemonic/C9", 1);
@@ -1841,26 +1841,26 @@ class StructuresSubsystemIT {
// from first structure element
assertNotNull(uuid);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?queryFields=MNEMONIC&queryValues=A__", 45);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=PENDING&queryFields=MNEMONIC&queryValues=A__", 10);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=APPROVED&queryFields=MNEMONIC&queryValues=A__", 20);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=REJECTED&queryFields=MNEMONIC&queryValues=A__", 10);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=PENDING&statuses=APPROVED&queryFields=MNEMONIC&queryValues=A__", 30);
-
- ITUtilStructureElement.assertRead("/SUBSYSTEM?deleted=false&queryFields=MNEMONIC&queryValues=A__", 30);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?deleted=false&statuses=PENDING&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?deleted=false&statuses=APPROVED&queryFields=MNEMONIC&queryValues=A__", 15);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?deleted=false&statuses=CANCELLED&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?deleted=false&statuses=REJECTED&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?deleted=false&statuses=PENDING&statuses=APPROVED&queryFields=MNEMONIC&queryValues=A__", 20);
-
- ITUtilStructureElement.assertRead("/SUBSYSTEM?deleted=true&queryFields=MNEMONIC&queryValues=A__", 15);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?deleted=true&statuses=PENDING&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?deleted=true&statuses=APPROVED&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?deleted=true&statuses=CANCELLED&queryFields=MNEMONIC&queryValues=A__", 0);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?deleted=true&statuses=REJECTED&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/SUBSYSTEM?deleted=true&statuses=PENDING&statuses=APPROVED&queryFields=MNEMONIC&queryValues=A__", 10);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?mnemonic=A__", 45);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=PENDING&mnemonic=A__", 10);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=APPROVED&mnemonic=A__", 20);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=CANCELLED&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=REJECTED&mnemonic=A__", 10);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?statuses=PENDING&statuses=APPROVED&mnemonic=A__", 30);
+
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?deleted=false&mnemonic=A__", 30);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?deleted=false&statuses=PENDING&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?deleted=false&statuses=APPROVED&mnemonic=A__", 15);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?deleted=false&statuses=CANCELLED&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?deleted=false&statuses=REJECTED&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?deleted=false&statuses=PENDING&statuses=APPROVED&mnemonic=A__", 20);
+
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?deleted=true&mnemonic=A__", 15);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?deleted=true&statuses=PENDING&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?deleted=true&statuses=APPROVED&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?deleted=true&statuses=CANCELLED&mnemonic=A__", 0);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?deleted=true&statuses=REJECTED&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/SUBSYSTEM?deleted=true&statuses=PENDING&statuses=APPROVED&mnemonic=A__", 10);
ITUtilStructureElement.assertRead("/children/SUBSYSTEM/" + uuid.toString(), 0);
ITUtilStructureElement.assertRead("/children/SYSTEM/" + systemUuid.toString(), 1, -1);
diff --git a/src/test/java/org/openepics/names/docker/StructuresSystemGroupIT.java b/src/test/java/org/openepics/names/docker/StructuresSystemGroupIT.java
index b017c149..79c37105 100644
--- a/src/test/java/org/openepics/names/docker/StructuresSystemGroupIT.java
+++ b/src/test/java/org/openepics/names/docker/StructuresSystemGroupIT.java
@@ -979,11 +979,11 @@ class StructuresSystemGroupIT {
ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=APPROVED", 0, -1);
ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=CANCELLED", 0, -1);
ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=REJECTED", 0, -1);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rsha", 1);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?queryFields=UUID&queryValues=" + createdStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=PENDING&mnemonic=Rsha", 1);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=APPROVED&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=CANCELLED&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=REJECTED&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?uuid=" + createdStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Rsha", 0);
@@ -1003,11 +1003,11 @@ class StructuresSystemGroupIT {
ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=APPROVED", 1, -1);
ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=CANCELLED", 0, -1);
ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=REJECTED", 0, -1);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rsha", 1);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?queryFields=UUID&queryValues=" + approvedStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=PENDING&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=APPROVED&mnemonic=Rsha", 1);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=CANCELLED&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=REJECTED&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?uuid=" + approvedStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Rsha", 1);
@@ -1054,11 +1054,11 @@ class StructuresSystemGroupIT {
ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=APPROVED", 0, -1);
ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=CANCELLED", 0, -1);
ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=REJECTED", 0, -1);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rshc", 1);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?queryFields=UUID&queryValues=" + createdStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=PENDING&mnemonic=Rshc", 1);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=APPROVED&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=CANCELLED&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=REJECTED&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?uuid=" + createdStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Rshc", 0);
@@ -1078,11 +1078,11 @@ class StructuresSystemGroupIT {
ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=APPROVED", 0, -1);
ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=CANCELLED", 1, -1);
ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=REJECTED", 0, -1);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rshc", 1);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?queryFields=UUID&queryValues=" + cancelledStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=PENDING&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=APPROVED&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=CANCELLED&mnemonic=Rshc", 1);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=REJECTED&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?uuid=" + cancelledStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Rshc", 0);
@@ -1129,11 +1129,11 @@ class StructuresSystemGroupIT {
ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=APPROVED", 0, -1);
ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=CANCELLED", 0, -1);
ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=REJECTED", 0, -1);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rshr", 1);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?queryFields=UUID&queryValues=" + createdStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=PENDING&mnemonic=Rshr", 1);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=APPROVED&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=CANCELLED&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=REJECTED&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?uuid=" + createdStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Rshr", 0);
@@ -1153,11 +1153,11 @@ class StructuresSystemGroupIT {
ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=APPROVED", 0, -1);
ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=CANCELLED", 0, -1);
ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=REJECTED", 1, -1);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rshr", 1);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?queryFields=UUID&queryValues=" + rejectedStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=PENDING&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=APPROVED&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=CANCELLED&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=REJECTED&mnemonic=Rshr", 1);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?uuid=" + rejectedStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Rshr", 0);
@@ -1246,10 +1246,10 @@ class StructuresSystemGroupIT {
// ( include if latest )
// include if latest not exists (considered present + future)
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?queryFields=UUID&queryValues=" + uuid.toString(), 1);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?queryFields=UUID&queryValues=" + uuid2.toString(), 1);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?queryFields=UUID&queryValues=" + uuid3.toString(), 1);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?queryFields=UUID&queryValues=" + uuid4.toString(), 1);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?uuid=" + uuid.toString(), 1);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?uuid=" + uuid2.toString(), 1);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?uuid=" + uuid3.toString(), 1);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?uuid=" + uuid4.toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/P1", 0);
ITUtilStructureElement.assertRead("/mnemonic/C1", 0);
@@ -1415,10 +1415,10 @@ class StructuresSystemGroupIT {
// ( include if latest )
// include if latest not exists (considered present + future)
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?queryFields=UUID&queryValues=" + uuid.toString(), 2);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?queryFields=UUID&queryValues=" + uuid2.toString(), 2);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?queryFields=UUID&queryValues=" + uuid3.toString(), 2);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?queryFields=UUID&queryValues=" + uuid4.toString(), 1);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?uuid=" + uuid.toString(), 2);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?uuid=" + uuid2.toString(), 2);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?uuid=" + uuid3.toString(), 2);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?uuid=" + uuid4.toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/P9", 1);
ITUtilStructureElement.assertRead("/mnemonic/C9", 1);
@@ -1738,26 +1738,26 @@ class StructuresSystemGroupIT {
// from first structure element
assertNotNull(uuid);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?queryFields=MNEMONIC&queryValues=A__", 45);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=PENDING&queryFields=MNEMONIC&queryValues=A__", 10);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=APPROVED&queryFields=MNEMONIC&queryValues=A__", 20);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=REJECTED&queryFields=MNEMONIC&queryValues=A__", 10);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=PENDING&statuses=APPROVED&queryFields=MNEMONIC&queryValues=A__", 30);
-
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?deleted=false&queryFields=MNEMONIC&queryValues=A__", 30);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?deleted=false&statuses=PENDING&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?deleted=false&statuses=APPROVED&queryFields=MNEMONIC&queryValues=A__", 15);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?deleted=false&statuses=CANCELLED&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?deleted=false&statuses=REJECTED&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?deleted=false&statuses=PENDING&statuses=APPROVED&queryFields=MNEMONIC&queryValues=A__", 20);
-
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?deleted=true&queryFields=MNEMONIC&queryValues=A__", 15);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?deleted=true&statuses=PENDING&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?deleted=true&statuses=APPROVED&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?deleted=true&statuses=CANCELLED&queryFields=MNEMONIC&queryValues=A__", 0);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?deleted=true&statuses=REJECTED&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/SYSTEMGROUP?deleted=true&statuses=PENDING&statuses=APPROVED&queryFields=MNEMONIC&queryValues=A__", 10);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?mnemonic=A__", 45);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=PENDING&mnemonic=A__", 10);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=APPROVED&mnemonic=A__", 20);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=CANCELLED&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=REJECTED&mnemonic=A__", 10);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?statuses=PENDING&statuses=APPROVED&mnemonic=A__", 30);
+
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?deleted=false&mnemonic=A__", 30);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?deleted=false&statuses=PENDING&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?deleted=false&statuses=APPROVED&mnemonic=A__", 15);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?deleted=false&statuses=CANCELLED&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?deleted=false&statuses=REJECTED&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?deleted=false&statuses=PENDING&statuses=APPROVED&mnemonic=A__", 20);
+
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?deleted=true&mnemonic=A__", 15);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?deleted=true&statuses=PENDING&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?deleted=true&statuses=APPROVED&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?deleted=true&statuses=CANCELLED&mnemonic=A__", 0);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?deleted=true&statuses=REJECTED&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/SYSTEMGROUP?deleted=true&statuses=PENDING&statuses=APPROVED&mnemonic=A__", 10);
ITUtilStructureElement.assertRead("/children/SYSTEMGROUP/" + uuid.toString(), 0);
diff --git a/src/test/java/org/openepics/names/docker/StructuresSystemIT.java b/src/test/java/org/openepics/names/docker/StructuresSystemIT.java
index 74b01f6b..97190d68 100644
--- a/src/test/java/org/openepics/names/docker/StructuresSystemIT.java
+++ b/src/test/java/org/openepics/names/docker/StructuresSystemIT.java
@@ -977,11 +977,11 @@ class StructuresSystemIT {
ITUtilStructureElement.assertRead("/SYSTEM?statuses=APPROVED", 0, -1);
ITUtilStructureElement.assertRead("/SYSTEM?statuses=CANCELLED", 0, -1);
ITUtilStructureElement.assertRead("/SYSTEM?statuses=REJECTED", 0, -1);
- ITUtilStructureElement.assertRead("/SYSTEM?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rsha", 1);
- ITUtilStructureElement.assertRead("/SYSTEM?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/SYSTEM?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/SYSTEM?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/SYSTEM?queryFields=UUID&queryValues=" + createdStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/SYSTEM?statuses=PENDING&mnemonic=Rsha", 1);
+ ITUtilStructureElement.assertRead("/SYSTEM?statuses=APPROVED&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/SYSTEM?statuses=CANCELLED&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/SYSTEM?statuses=REJECTED&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/SYSTEM?uuid=" + createdStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Sg", 1);
ITUtilStructureElement.assertRead("/mnemonic/Rsha", 0);
@@ -1006,11 +1006,11 @@ class StructuresSystemIT {
ITUtilStructureElement.assertRead("/SYSTEM?statuses=APPROVED", 1, -1);
ITUtilStructureElement.assertRead("/SYSTEM?statuses=CANCELLED", 0, -1);
ITUtilStructureElement.assertRead("/SYSTEM?statuses=REJECTED", 0, -1);
- ITUtilStructureElement.assertRead("/SYSTEM?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/SYSTEM?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rsha", 1);
- ITUtilStructureElement.assertRead("/SYSTEM?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/SYSTEM?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rsha", 0);
- ITUtilStructureElement.assertRead("/SYSTEM?queryFields=UUID&queryValues=" + approvedStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/SYSTEM?statuses=PENDING&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/SYSTEM?statuses=APPROVED&mnemonic=Rsha", 1);
+ ITUtilStructureElement.assertRead("/SYSTEM?statuses=CANCELLED&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/SYSTEM?statuses=REJECTED&mnemonic=Rsha", 0);
+ ITUtilStructureElement.assertRead("/SYSTEM?uuid=" + approvedStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Sg", 1);
ITUtilStructureElement.assertRead("/mnemonic/Rsha", 1);
@@ -1062,11 +1062,11 @@ class StructuresSystemIT {
ITUtilStructureElement.assertRead("/SYSTEM?statuses=APPROVED", 0, -1);
ITUtilStructureElement.assertRead("/SYSTEM?statuses=CANCELLED", 0, -1);
ITUtilStructureElement.assertRead("/SYSTEM?statuses=REJECTED", 0, -1);
- ITUtilStructureElement.assertRead("/SYSTEM?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rshc", 1, -1);
- ITUtilStructureElement.assertRead("/SYSTEM?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/SYSTEM?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/SYSTEM?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/SYSTEM?queryFields=UUID&queryValues=" + createdStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/SYSTEM?statuses=PENDING&mnemonic=Rshc", 1, -1);
+ ITUtilStructureElement.assertRead("/SYSTEM?statuses=APPROVED&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/SYSTEM?statuses=CANCELLED&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/SYSTEM?statuses=REJECTED&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/SYSTEM?uuid=" + createdStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Sg", 1);
ITUtilStructureElement.assertRead("/mnemonic/Rshc", 0);
@@ -1091,11 +1091,11 @@ class StructuresSystemIT {
ITUtilStructureElement.assertRead("/SYSTEM?statuses=APPROVED", 0, -1);
ITUtilStructureElement.assertRead("/SYSTEM?statuses=CANCELLED", 1, -1);
ITUtilStructureElement.assertRead("/SYSTEM?statuses=REJECTED", 0, -1);
- ITUtilStructureElement.assertRead("/SYSTEM?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/SYSTEM?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/SYSTEM?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rshc", 1);
- ITUtilStructureElement.assertRead("/SYSTEM?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rshc", 0);
- ITUtilStructureElement.assertRead("/SYSTEM?queryFields=UUID&queryValues=" + cancelledStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/SYSTEM?statuses=PENDING&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/SYSTEM?statuses=APPROVED&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/SYSTEM?statuses=CANCELLED&mnemonic=Rshc", 1);
+ ITUtilStructureElement.assertRead("/SYSTEM?statuses=REJECTED&mnemonic=Rshc", 0);
+ ITUtilStructureElement.assertRead("/SYSTEM?uuid=" + cancelledStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Sg", 1);
ITUtilStructureElement.assertRead("/mnemonic/Rshc", 0);
@@ -1147,11 +1147,11 @@ class StructuresSystemIT {
ITUtilStructureElement.assertRead("/SYSTEM?statuses=APPROVED", 0, -1);
ITUtilStructureElement.assertRead("/SYSTEM?statuses=CANCELLED", 0, -1);
ITUtilStructureElement.assertRead("/SYSTEM?statuses=REJECTED", 0, -1);
- ITUtilStructureElement.assertRead("/SYSTEM?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rshr", 1);
- ITUtilStructureElement.assertRead("/SYSTEM?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/SYSTEM?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/SYSTEM?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/SYSTEM?queryFields=UUID&queryValues=" + createdStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/SYSTEM?statuses=PENDING&mnemonic=Rshr", 1);
+ ITUtilStructureElement.assertRead("/SYSTEM?statuses=APPROVED&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/SYSTEM?statuses=CANCELLED&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/SYSTEM?statuses=REJECTED&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/SYSTEM?uuid=" + createdStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Sg", 1);
ITUtilStructureElement.assertRead("/mnemonic/Rshr", 0);
@@ -1176,11 +1176,11 @@ class StructuresSystemIT {
ITUtilStructureElement.assertRead("/SYSTEM?statuses=APPROVED", 0, -1);
ITUtilStructureElement.assertRead("/SYSTEM?statuses=CANCELLED", 0, -1);
ITUtilStructureElement.assertRead("/SYSTEM?statuses=REJECTED", 1, -1);
- ITUtilStructureElement.assertRead("/SYSTEM?statuses=PENDING&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/SYSTEM?statuses=APPROVED&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/SYSTEM?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=Rshr", 0);
- ITUtilStructureElement.assertRead("/SYSTEM?statuses=REJECTED&queryFields=MNEMONIC&queryValues=Rshr", 1);
- ITUtilStructureElement.assertRead("/SYSTEM?queryFields=UUID&queryValues=" + rejectedStructureElement.getUuid().toString(), 1);
+ ITUtilStructureElement.assertRead("/SYSTEM?statuses=PENDING&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/SYSTEM?statuses=APPROVED&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/SYSTEM?statuses=CANCELLED&mnemonic=Rshr", 0);
+ ITUtilStructureElement.assertRead("/SYSTEM?statuses=REJECTED&mnemonic=Rshr", 1);
+ ITUtilStructureElement.assertRead("/SYSTEM?uuid=" + rejectedStructureElement.getUuid().toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/Sg", 1);
ITUtilStructureElement.assertRead("/mnemonic/Rshr", 0);
@@ -1274,10 +1274,10 @@ class StructuresSystemIT {
// ( include if latest )
// include if latest not exists (considered present + future)
- ITUtilStructureElement.assertRead("/SYSTEM?queryFields=UUID&queryValues=" + uuid.toString(), 1);
- ITUtilStructureElement.assertRead("/SYSTEM?queryFields=UUID&queryValues=" + uuid2.toString(), 1);
- ITUtilStructureElement.assertRead("/SYSTEM?queryFields=UUID&queryValues=" + uuid3.toString(), 1);
- ITUtilStructureElement.assertRead("/SYSTEM?queryFields=UUID&queryValues=" + uuid4.toString(), 1);
+ ITUtilStructureElement.assertRead("/SYSTEM?uuid=" + uuid.toString(), 1);
+ ITUtilStructureElement.assertRead("/SYSTEM?uuid=" + uuid2.toString(), 1);
+ ITUtilStructureElement.assertRead("/SYSTEM?uuid=" + uuid3.toString(), 1);
+ ITUtilStructureElement.assertRead("/SYSTEM?uuid=" + uuid4.toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/P1", 0);
ITUtilStructureElement.assertRead("/mnemonic/C1", 0);
@@ -1447,10 +1447,10 @@ class StructuresSystemIT {
// ( include if latest )
// include if latest not exists (considered present + future)
- ITUtilStructureElement.assertRead("/SYSTEM?queryFields=UUID&queryValues=" + uuid.toString(), 2);
- ITUtilStructureElement.assertRead("/SYSTEM?queryFields=UUID&queryValues=" + uuid2.toString(), 2);
- ITUtilStructureElement.assertRead("/SYSTEM?queryFields=UUID&queryValues=" + uuid3.toString(), 2);
- ITUtilStructureElement.assertRead("/SYSTEM?queryFields=UUID&queryValues=" + uuid4.toString(), 1);
+ ITUtilStructureElement.assertRead("/SYSTEM?uuid=" + uuid.toString(), 2);
+ ITUtilStructureElement.assertRead("/SYSTEM?uuid=" + uuid2.toString(), 2);
+ ITUtilStructureElement.assertRead("/SYSTEM?uuid=" + uuid3.toString(), 2);
+ ITUtilStructureElement.assertRead("/SYSTEM?uuid=" + uuid4.toString(), 1);
ITUtilStructureElement.assertRead("/mnemonic/P9", 1);
ITUtilStructureElement.assertRead("/mnemonic/C9", 1);
@@ -1774,26 +1774,26 @@ class StructuresSystemIT {
// from first structure element
assertNotNull(uuid);
- ITUtilStructureElement.assertRead("/SYSTEM?queryFields=MNEMONIC&queryValues=A__", 45);
- ITUtilStructureElement.assertRead("/SYSTEM?statuses=PENDING&queryFields=MNEMONIC&queryValues=A__", 10);
- ITUtilStructureElement.assertRead("/SYSTEM?statuses=APPROVED&queryFields=MNEMONIC&queryValues=A__", 20);
- ITUtilStructureElement.assertRead("/SYSTEM?statuses=CANCELLED&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/SYSTEM?statuses=REJECTED&queryFields=MNEMONIC&queryValues=A__", 10);
- ITUtilStructureElement.assertRead("/SYSTEM?statuses=PENDING&statuses=APPROVED&queryFields=MNEMONIC&queryValues=A__", 30);
-
- ITUtilStructureElement.assertRead("/SYSTEM?deleted=false&queryFields=MNEMONIC&queryValues=A__", 30);
- ITUtilStructureElement.assertRead("/SYSTEM?deleted=false&statuses=PENDING&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/SYSTEM?deleted=false&statuses=APPROVED&queryFields=MNEMONIC&queryValues=A__", 15);
- ITUtilStructureElement.assertRead("/SYSTEM?deleted=false&statuses=CANCELLED&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/SYSTEM?deleted=false&statuses=REJECTED&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/SYSTEM?deleted=false&statuses=PENDING&statuses=APPROVED&queryFields=MNEMONIC&queryValues=A__", 20);
-
- ITUtilStructureElement.assertRead("/SYSTEM?deleted=true&queryFields=MNEMONIC&queryValues=A__", 15);
- ITUtilStructureElement.assertRead("/SYSTEM?deleted=true&statuses=PENDING&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/SYSTEM?deleted=true&statuses=APPROVED&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/SYSTEM?deleted=true&statuses=CANCELLED&queryFields=MNEMONIC&queryValues=A__", 0);
- ITUtilStructureElement.assertRead("/SYSTEM?deleted=true&statuses=REJECTED&queryFields=MNEMONIC&queryValues=A__", 5);
- ITUtilStructureElement.assertRead("/SYSTEM?deleted=true&statuses=PENDING&statuses=APPROVED&queryFields=MNEMONIC&queryValues=A__", 10);
+ ITUtilStructureElement.assertRead("/SYSTEM?mnemonic=A__", 45);
+ ITUtilStructureElement.assertRead("/SYSTEM?statuses=PENDING&mnemonic=A__", 10);
+ ITUtilStructureElement.assertRead("/SYSTEM?statuses=APPROVED&mnemonic=A__", 20);
+ ITUtilStructureElement.assertRead("/SYSTEM?statuses=CANCELLED&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/SYSTEM?statuses=REJECTED&mnemonic=A__", 10);
+ ITUtilStructureElement.assertRead("/SYSTEM?statuses=PENDING&statuses=APPROVED&mnemonic=A__", 30);
+
+ ITUtilStructureElement.assertRead("/SYSTEM?deleted=false&mnemonic=A__", 30);
+ ITUtilStructureElement.assertRead("/SYSTEM?deleted=false&statuses=PENDING&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/SYSTEM?deleted=false&statuses=APPROVED&mnemonic=A__", 15);
+ ITUtilStructureElement.assertRead("/SYSTEM?deleted=false&statuses=CANCELLED&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/SYSTEM?deleted=false&statuses=REJECTED&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/SYSTEM?deleted=false&statuses=PENDING&statuses=APPROVED&mnemonic=A__", 20);
+
+ ITUtilStructureElement.assertRead("/SYSTEM?deleted=true&mnemonic=A__", 15);
+ ITUtilStructureElement.assertRead("/SYSTEM?deleted=true&statuses=PENDING&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/SYSTEM?deleted=true&statuses=APPROVED&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/SYSTEM?deleted=true&statuses=CANCELLED&mnemonic=A__", 0);
+ ITUtilStructureElement.assertRead("/SYSTEM?deleted=true&statuses=REJECTED&mnemonic=A__", 5);
+ ITUtilStructureElement.assertRead("/SYSTEM?deleted=true&statuses=PENDING&statuses=APPROVED&mnemonic=A__", 10);
ITUtilStructureElement.assertRead("/children/SYSTEM/" + uuid.toString(), 0);
ITUtilStructureElement.assertRead("/children/SYSTEMGROUP/" + systemGroupUuid.toString(), 1, -1);
diff --git a/src/test/java/org/openepics/names/util/ValidateUtilTest.java b/src/test/java/org/openepics/names/util/ValidateUtilTest.java
index faba23cb..c0922795 100644
--- a/src/test/java/org/openepics/names/util/ValidateUtilTest.java
+++ b/src/test/java/org/openepics/names/util/ValidateUtilTest.java
@@ -334,10 +334,9 @@ class ValidateUtilTest {
void validateInputReadStructuresTypeNull() {
try {
ValidateStructureElementUtil.validateStructuresInputRead(
- null, null, null, null, null,
- null,
- null, null,
- null, null);
+ null, null, null,
+ null, null, null, null, null, null, null,
+ null, null, null, null, null);
fail();
} catch (InputNotAvailableException e) {
assertEquals(TextUtil.VALUE_IS_NOT_AVAILABLE, e.getMessage());
@@ -351,35 +350,29 @@ class ValidateUtilTest {
@Test
void validateInputReadStructures() {
ValidateStructureElementUtil.validateStructuresInputRead(
- Type.SYSTEMGROUP, null, null, null, null,
- null,
- null, null,
- null, null);
+ Type.SYSTEMGROUP, null, null,
+ null, null, null, null, null, null, null,
+ null, null, null, null, null);
ValidateStructureElementUtil.validateStructuresInputRead(
- Type.SYSTEM, null, null, null, null,
- null,
- null, null,
- null, null);
+ Type.SYSTEM, null, null,
+ null, null, null, null, null, null, null,
+ null, null, null, null, null);
ValidateStructureElementUtil.validateStructuresInputRead(
- Type.SUBSYSTEM, null, null, null, null,
- null,
- null, null,
- null, null);
+ Type.SUBSYSTEM, null, null,
+ null, null, null, null, null, null, null,
+ null, null, null, null, null);
ValidateStructureElementUtil.validateStructuresInputRead(
- Type.DISCIPLINE, null, null, null, null,
- null,
- null, null,
- null, null);
+ Type.DISCIPLINE, null, null,
+ null, null, null, null, null, null, null,
+ null, null, null, null, null);
ValidateStructureElementUtil.validateStructuresInputRead(
- Type.DEVICEGROUP, null, null, null, null,
- null,
- null, null,
- null, null);
+ Type.DEVICEGROUP, null, null,
+ null, null, null, null, null, null, null,
+ null, null, null, null, null);
ValidateStructureElementUtil.validateStructuresInputRead(
- Type.DEVICETYPE, null, null, null, null,
- null,
- null, null,
- null, null);
+ Type.DEVICETYPE, null, null,
+ null, null, null, null, null, null, null,
+ null, null, null, null, null);
}
/**
--
GitLab