Various attribute datatypes support, MongoDB query builder fix

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;

core/crce-metadata-dao-mongodb/src/main/java/cz/zcu/kiv/crce/metadata/dao/mongodb/internal/mapper/QueryBuilder.java

@@ -105,53 +105,42 @@ private static DBQuery.Query processCapabilityFilters(String path, Operator oper
         List<DBQuery.Query> 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);
     }
 
     private static DBQuery.Query processAttributeFilters(String path, Operator operator, List<Attribute<?>> attributes) {
         List<DBQuery.Query> 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<DBQuery.Query> 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<DBQuery.Query> 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;

core/crce-metadata-json-impl/src/main/java/cz/zcu/kiv/crce/metadata/json/internal/MetadataDeserializer.java

@@ -400,6 +400,11 @@ private <T> 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 <T> 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 {

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);
+                }
+        }
+    }
+
 }