diff --git a/core/crce-metadata-api/src/main/java/cz/zcu/kiv/crce/metadata/impl/GenericAttributeType.java b/core/crce-metadata-api/src/main/java/cz/zcu/kiv/crce/metadata/impl/GenericAttributeType.java index 76370362..213f6731 100644 --- a/core/crce-metadata-api/src/main/java/cz/zcu/kiv/crce/metadata/impl/GenericAttributeType.java +++ b/core/crce-metadata-api/src/main/java/cz/zcu/kiv/crce/metadata/impl/GenericAttributeType.java @@ -27,6 +27,11 @@ public GenericAttributeType(String name, String type) { this.type = String.class; break; + case "Boolean": + case "java.lang.Boolean": + this.type = Boolean.class; + break; + case "Long": case "java.lang.Long": this.type = Long.class; diff --git a/core/crce-metadata-dao-mongodb/src/main/java/cz/zcu/kiv/crce/metadata/dao/mongodb/internal/mapper/QueryBuilder.java b/core/crce-metadata-dao-mongodb/src/main/java/cz/zcu/kiv/crce/metadata/dao/mongodb/internal/mapper/QueryBuilder.java index 05052158..b5f8eec8 100644 --- a/core/crce-metadata-dao-mongodb/src/main/java/cz/zcu/kiv/crce/metadata/dao/mongodb/internal/mapper/QueryBuilder.java +++ b/core/crce-metadata-dao-mongodb/src/main/java/cz/zcu/kiv/crce/metadata/dao/mongodb/internal/mapper/QueryBuilder.java @@ -105,16 +105,20 @@ private static DBQuery.Query processCapabilityFilters(String path, Operator oper List tmp = new LinkedList<>(); for (CapabilityFilter filter : filters) { - tmp.add(processCapabilityFilter(path, filter)); + if (path.equals("")) { + tmp.add(processCapabilityFilter(filter)); + } else { + tmp.add(DBQuery.elemMatch(path, processCapabilityFilter(filter))); + } } return joinQueries(tmp, operator); } - private static DBQuery.Query processCapabilityFilter(String prefix, CapabilityFilter filter) { - DBQuery.Query namespace = DBQuery.is(joinPath(prefix, DbCapability.NAMESPACE), filter.getNamespace()); - DBQuery.Query attributes = processAttributeFilters(joinPath(prefix, DbCapability.ATTRIBUTES), filter.getOperator(), filter.getAttributes()); - DBQuery.Query subFilters = processCapabilityFilters(joinPath(prefix, DbCapability.CHILDREN), Operator.AND, filter.getSubFilters()); + private static DBQuery.Query processCapabilityFilter(CapabilityFilter filter) { + DBQuery.Query namespace = DBQuery.is(DbCapability.NAMESPACE, filter.getNamespace()); + DBQuery.Query attributes = processAttributeFilters(DbCapability.ATTRIBUTES, filter.getOperator(), filter.getAttributes()); + DBQuery.Query subFilters = processCapabilityFilters(DbCapability.CHILDREN, Operator.AND, filter.getSubFilters()); return DBQuery.and(namespace, attributes, subFilters); } @@ -122,36 +126,21 @@ private static DBQuery.Query processCapabilityFilter(String prefix, CapabilityFi private static DBQuery.Query processAttributeFilters(String path, Operator operator, List> attributes) { List tmp = new LinkedList<>(); for (Attribute attribute : attributes) { - tmp.add(processAttributeFilter(path, attribute)); + tmp.add(DBQuery.elemMatch(path, processAttributeFilter(attribute))); } return joinQueries(tmp, operator); } - private static DBQuery.Query joinQueries(List queries, Operator operator) { - if(queries.size() > 1) { - if (operator == Operator.AND) { - return DBQuery.and(queries.toArray(new DBQuery.Query[0])); - } else { - return DBQuery.or(queries.toArray(new DBQuery.Query[0])); - } - } else if (queries.size() == 1){ - return queries.get(0); - } else { - return DBQuery.empty(); - } - } - - private static DBQuery.Query processAttributeFilter(String prefix, Attribute attribute) { - DBQuery.Query name = DBQuery.is(joinPath(prefix, DbAttribute.NAME), attribute.getName()); - DBQuery.Query type = DBQuery.is(joinPath(prefix, DbAttribute.TYPE), attribute.getType().getName()); - DBQuery.Query value = processAttributeValue(prefix, attribute.getOperator(), attribute.getValue()); + private static DBQuery.Query processAttributeFilter(Attribute attribute) { + DBQuery.Query name = DBQuery.is(DbAttribute.NAME, attribute.getName()); + DBQuery.Query type = DBQuery.is(DbAttribute.TYPE, attribute.getType().getName()); + DBQuery.Query value = processAttributeValue(DbAttribute.VALUE, attribute.getOperator(), attribute.getValue()); return DBQuery.and(name, type, value); } - private static DBQuery.Query processAttributeValue(String prefix, cz.zcu.kiv.crce.metadata.Operator operator, Object value) { - String path = joinPath(prefix, DbAttribute.VALUE); + private static DBQuery.Query processAttributeValue(String path, cz.zcu.kiv.crce.metadata.Operator operator, Object value) { switch (operator) { case EQUAL: return DBQuery.is(path, value); @@ -180,6 +169,25 @@ private static DBQuery.Query processAttributeValue(String prefix, cz.zcu.kiv.crc } } + private static DBQuery.Query joinQueries(List queries, Operator operator) { + switch (queries.size()) { + case 0: + return DBQuery.empty(); + + case 1: + return queries.get(0); + + default: + switch (operator) { + case AND: + return DBQuery.and(queries.toArray(new DBQuery.Query[0])); + default: + case OR: + return DBQuery.or(queries.toArray(new DBQuery.Query[0])); + } + } + } + private static String joinPath(String prefix, String addon) { if(StringUtils.isBlank(prefix)) { return addon; diff --git a/core/crce-metadata-json-impl/src/main/java/cz/zcu/kiv/crce/metadata/json/internal/MetadataDeserializer.java b/core/crce-metadata-json-impl/src/main/java/cz/zcu/kiv/crce/metadata/json/internal/MetadataDeserializer.java index 6fcc84e1..a3663299 100644 --- a/core/crce-metadata-json-impl/src/main/java/cz/zcu/kiv/crce/metadata/json/internal/MetadataDeserializer.java +++ b/core/crce-metadata-json-impl/src/main/java/cz/zcu/kiv/crce/metadata/json/internal/MetadataDeserializer.java @@ -400,6 +400,11 @@ private void deserializeAttributes(AttributeProviderCallback callback, JsonN callback.addAttribute(new SimpleAttributeType<>(name, String.class), valueNode.asText(), operator); continue; + case "Boolean": + case "java.lang.Boolean": + callback.addAttribute(new SimpleAttributeType<>(name, Boolean.class), valueNode.asBoolean(), operator); + continue; + case "Long": case "java.lang.Long": callback.addAttribute(new SimpleAttributeType<>(name, Long.class), valueNode.asLong(), operator); @@ -420,10 +425,6 @@ private void deserializeAttributes(AttributeProviderCallback callback, JsonN callback.addAttribute(new ListAttributeType(name), deserializeList(valueNode), operator); continue; - case "Boolean": - callback.addAttribute(new SimpleAttributeType<>(name, Boolean.class), valueNode.asBoolean(), operator); - continue; - case "URI": case "java.net.URI": try { diff --git a/modules/crce-vo/src/main/java/cz/zcu/kiv/crce/vo/internal/dozer/convertor/RequirementConvertor.java b/modules/crce-vo/src/main/java/cz/zcu/kiv/crce/vo/internal/dozer/convertor/RequirementConvertor.java index b9e0ed59..d3fa89d3 100644 --- a/modules/crce-vo/src/main/java/cz/zcu/kiv/crce/vo/internal/dozer/convertor/RequirementConvertor.java +++ b/modules/crce-vo/src/main/java/cz/zcu/kiv/crce/vo/internal/dozer/convertor/RequirementConvertor.java @@ -1,17 +1,21 @@ package cz.zcu.kiv.crce.vo.internal.dozer.convertor; +import java.net.URI; +import java.net.URISyntaxException; import java.util.Arrays; +import java.util.Collections; import java.util.Map; -import java.util.Objects; import org.dozer.DozerConverter; import org.dozer.Mapper; import org.dozer.MapperAware; import cz.zcu.kiv.crce.metadata.Attribute; +import cz.zcu.kiv.crce.metadata.AttributeType; import cz.zcu.kiv.crce.metadata.MetadataFactory; import cz.zcu.kiv.crce.metadata.Requirement; import cz.zcu.kiv.crce.metadata.impl.GenericAttributeType; +import cz.zcu.kiv.crce.metadata.type.Version; import cz.zcu.kiv.crce.vo.model.metadata.AttributeVO; import cz.zcu.kiv.crce.vo.model.metadata.DirectiveVO; import cz.zcu.kiv.crce.vo.model.metadata.GenericRequirementVO; @@ -63,22 +67,15 @@ public GenericRequirementVO convertTo(Requirement requirement, GenericRequiremen @Override public Requirement convertFrom(GenericRequirementVO vo, Requirement requirement) { - if(requirement == null) { + if (requirement == null) { requirement = metadataFactory.createRequirement(vo.getNamespace(), vo.getId()); } - - Attribute tmp; for (AttributeVO attribute : vo.getAttributes()) { - Object value; - //TODO refactor this - if(Objects.equals(attribute.getType(), "java.util.List")) { - value = Arrays.asList(attribute.getValue().split(",")); - } else { - value = attribute.getValue(); - } - tmp = metadataFactory.createAttribute(new GenericAttributeType(attribute.getName(), attribute.getType()), value); - requirement.addAttribute(tmp); + AttributeType type = new GenericAttributeType(attribute.getName(), attribute.getType()); + Object value = retype(attribute.getType(), attribute.getValue()); + + requirement.addAttribute(metadataFactory.createAttribute(type, value)); } for (GenericRequirementVO child : vo.getChildren()) { @@ -96,4 +93,52 @@ public Requirement convertFrom(GenericRequirementVO vo, Requirement requirement) public void setMapper(Mapper mapper) { this.mapper = mapper; } + + /** + * Retypes string to a new object according to the type passed as argument. + * @param type Target variable type. + * @param value String value. + * @return Retyped object. + */ + private Object retype(String type, String value) { + switch (type) { + default: + case "String": + case "java.lang.String": + return value; + + case "Boolean": + case "java.lang.Boolean": + return Boolean.valueOf(value); + + case "Long": + case "java.lang.Long": + return Long.valueOf(value); + + case "Double": + case "java.lang.Double": + return Double.valueOf(value); + + case "Version": + case "cz.zcu.kiv.crce.metadata.type.Version": + return new Version(value); + + case "List": + case "java.util.List": + if (value.equals("")) { + return Collections.emptyList(); + } else { + return Arrays.asList(value.split(",")); + } + + case "URI": + case "java.net.URI": + try { + return new URI(value); + } catch (URISyntaxException ex) { + throw new IllegalArgumentException("Invalid URI: " + value, ex); + } + } + } + }