Type list of floats not generated correctly in tosca

[sdc.git] / catalog-be / src / main / java / org / openecomp / sdc / be / tosca / PropertyConvertor.java

diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/PropertyConvertor.java b/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/PropertyConvertor.java
index 75385d1..d1cd495 100644 (file)
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/PropertyConvertor.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/PropertyConvertor.java
@@ -43,6 +43,7 @@ import org.openecomp.sdc.be.model.PropertyConstraint;
 import org.openecomp.sdc.be.model.PropertyDefinition;
 import org.openecomp.sdc.be.model.Resource;
 import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
+import org.openecomp.sdc.be.model.tosca.ToscaType;
 import org.openecomp.sdc.be.model.tosca.constraints.EqualConstraint;
 import org.openecomp.sdc.be.model.tosca.constraints.GreaterOrEqualConstraint;
 import org.openecomp.sdc.be.model.tosca.constraints.GreaterThanConstraint;
@@ -54,6 +55,7 @@ import org.openecomp.sdc.be.model.tosca.constraints.MaxLengthConstraint;
 import org.openecomp.sdc.be.model.tosca.constraints.MinLengthConstraint;
 import org.openecomp.sdc.be.model.tosca.constraints.PatternConstraint;
 import org.openecomp.sdc.be.model.tosca.constraints.ValidValuesConstraint;
+import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintValueDoNotMatchPropertyTypeException;
 import org.openecomp.sdc.be.model.tosca.converters.DataTypePropertyConverter;
 import org.openecomp.sdc.be.model.tosca.converters.ToscaMapValueConverter;
 import org.openecomp.sdc.be.model.tosca.converters.ToscaValueBaseConverter;
@@ -130,39 +132,89 @@ public class PropertyConvertor {
         prop.setMetadata(property.getMetadata());
 
         if (CollectionUtils.isNotEmpty(property.getConstraints())) {
-            prop.setConstraints(convertConstraints(property.getConstraints()));
+            try {
+                prop.setConstraints(convertConstraints(property.getConstraints(), property.getType(), property.getSchemaType()));
+            } catch (ConstraintValueDoNotMatchPropertyTypeException e) {
+                log.error(e.getMessage());
+            }
         }
         return prop;
     }
 
-    private List<ToscaPropertyConstraint> convertConstraints(List<PropertyConstraint> constraints) {
+    private List<ToscaPropertyConstraint> convertConstraints(List<PropertyConstraint> constraints, String propertyType, String schemaType)
+        throws ConstraintValueDoNotMatchPropertyTypeException {
         List<ToscaPropertyConstraint> convertedConstraints = new ArrayList<>();
         for (PropertyConstraint constraint : constraints) {
             if (constraint instanceof EqualConstraint) {
-                convertedConstraints.add(new ToscaPropertyConstraintEqual(((EqualConstraint) constraint).getEqual()));
+                EqualConstraint equalConstraint = ((EqualConstraint) constraint);
+
+                if (doesTypeNeedConvertingToIntOrFloat(propertyType)) {
+                    equalConstraint.changeConstraintValueTypeTo(propertyType);
+                }
+
+                ToscaPropertyConstraintEqual prop = new ToscaPropertyConstraintEqual(equalConstraint.getEqual());
+                convertedConstraints.add(prop);
             }
             if (constraint instanceof GreaterThanConstraint) {
-                convertedConstraints.add(new ToscaPropertyConstraintGreaterThan(((GreaterThanConstraint) constraint).getGreaterThan()));
+                GreaterThanConstraint greaterThanConstraint = ((GreaterThanConstraint) constraint);
+
+                if (doesTypeNeedConvertingToIntOrFloat(propertyType)) {
+                    greaterThanConstraint.changeConstraintValueTypeTo(propertyType);
+                }
+
+                ToscaPropertyConstraintGreaterThan prop = new ToscaPropertyConstraintGreaterThan(greaterThanConstraint.getGreaterThan());
+                convertedConstraints.add(prop);
             }
             if (constraint instanceof GreaterOrEqualConstraint) {
-                convertedConstraints.add(new ToscaPropertyConstraintGreaterOrEqual(((GreaterOrEqualConstraint) constraint).getGreaterOrEqual()));
+                GreaterOrEqualConstraint greaterOrEqualConstraint = ((GreaterOrEqualConstraint) constraint);
+
+                if (doesTypeNeedConvertingToIntOrFloat(propertyType)) {
+                    greaterOrEqualConstraint.changeConstraintValueTypeTo(propertyType);
+                }
+
+                ToscaPropertyConstraintGreaterOrEqual prop = new ToscaPropertyConstraintGreaterOrEqual(greaterOrEqualConstraint.getGreaterOrEqual());
+                convertedConstraints.add(prop);
             }
             if (constraint instanceof LessThanConstraint) {
-                convertedConstraints.add(new ToscaPropertyConstraintLessThan(((LessThanConstraint) constraint).getLessThan()));
+                LessThanConstraint lessThanConstraint = ((LessThanConstraint) constraint);
+
+                if (doesTypeNeedConvertingToIntOrFloat(propertyType)) {
+                    lessThanConstraint.changeConstraintValueTypeTo(propertyType);
+                }
+
+                ToscaPropertyConstraintLessThan prop = new ToscaPropertyConstraintLessThan(lessThanConstraint.getLessThan());
+                convertedConstraints.add(prop);
             }
             if (constraint instanceof LessOrEqualConstraint) {
-                convertedConstraints.add(new ToscaPropertyConstraintLessOrEqual(((LessOrEqualConstraint) constraint).getLessOrEqual()));
+                LessOrEqualConstraint lessOrEqualConstraint = ((LessOrEqualConstraint) constraint);
+
+                if (doesTypeNeedConvertingToIntOrFloat(propertyType)) {
+                    lessOrEqualConstraint.changeConstraintValueTypeTo(propertyType);
+                }
+
+                ToscaPropertyConstraintLessOrEqual prop = new ToscaPropertyConstraintLessOrEqual(lessOrEqualConstraint.getLessOrEqual());
+                convertedConstraints.add(prop);
             }
             if (constraint instanceof InRangeConstraint) {
                 InRangeConstraint inRangeConstraint = (InRangeConstraint) constraint;
-                List<Object> range = new ArrayList<>();
-                range.add(inRangeConstraint.getMin());
-                range.add(inRangeConstraint.getMax());
-                convertedConstraints.add(new ToscaPropertyConstraintInRange(range));
+
+                if (doesTypeNeedConvertingToIntOrFloat(propertyType)) {
+                    inRangeConstraint.changeConstraintValueTypeTo(propertyType);
+                }
+
+                convertedConstraints.add(new ToscaPropertyConstraintInRange(inRangeConstraint.getInRange()));
             }
             if (constraint instanceof ValidValuesConstraint) {
-                List validValues = ((ValidValuesConstraint) constraint).getValidValues();
-                convertedConstraints.add(new ToscaPropertyConstraintValidValues(validValues));
+                ValidValuesConstraint validValues = ((ValidValuesConstraint) constraint);
+
+                if (isTypeMapOrList(propertyType) && doesTypeNeedConvertingToIntOrFloat(schemaType)) {
+                    validValues.changeConstraintValueTypeTo(schemaType);
+                } else if (doesTypeNeedConvertingToIntOrFloat(propertyType)) {
+                    validValues.changeConstraintValueTypeTo(propertyType);
+                }
+
+                List prop = validValues.getValidValues();
+                convertedConstraints.add(new ToscaPropertyConstraintValidValues(prop));
             }
             if (constraint instanceof LengthConstraint) {
                 convertedConstraints.add(new ToscaPropertyConstraintLength(((LengthConstraint) constraint).getLength()));
@@ -180,6 +232,14 @@ public class PropertyConvertor {
         return convertedConstraints;
     }
 
+    private boolean doesTypeNeedConvertingToIntOrFloat(String propertyType) {
+        return ToscaType.INTEGER.getType().equals(propertyType) || ToscaType.FLOAT.getType().equals(propertyType);
+    }
+
+    private boolean isTypeMapOrList (String type) {
+        return ToscaType.MAP.getType().equals(type) || ToscaType.LIST.getType().equals(type);
+    }
+
     public Object convertToToscaObject(PropertyDataDefinition property, String value, Map<String, DataTypeDefinition> dataTypes,
                                        boolean preserveEmptyValue) {
         String propertyType = property.getType();