Apply Valid Value Constraints validation

Apply Valid Value Constraints validation for FE and BE in Property Assignment, Input, Service Consumption screen Change-Id: I01c7523bad702f003cd52fd88bc69fe950b2b4f3 Issue-ID: SDC-2224 Signed-off-by: siddharth0905 <siddharth.singh4@amdocs.com>
author: siddharth0905 <siddharth.singh4@amdocs.com> 2019-04-10 17:49:51 +0530
committer: Avi Gaffa <avi.gaffa@amdocs.com> 2019-04-11 07:11:04 +0000
commit: 6896c1b309aaa50dca820169b9f1ae3f8af84294 (patch)
tree: 8da13382863f2e4adc9724dd046b535032ae58c7
parent: 4568e48647b15b5654a669651ddf536d590288b0 (diff)
53 files changed, 2827 insertions, 779 deletions
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/BaseBusinessLogic.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/BaseBusinessLogic.java
index 8ee1864862..65f1e4981a 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/BaseBusinessLogic.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/BaseBusinessLogic.java
@@ -21,7 +21,17 @@
 package org.openecomp.sdc.be.components.impl;
 
 import com.google.gson.JsonElement;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+
 import fj.data.Either;
+import org.apache.commons.lang3.ArrayUtils;
+import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.tuple.ImmutablePair;
 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
 import org.openecomp.sdc.be.components.validation.UserValidations;
@@ -37,19 +47,33 @@ import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
 import org.openecomp.sdc.be.impl.ComponentsUtils;
-import org.openecomp.sdc.be.model.*;
+import org.openecomp.sdc.be.model.Component;
+import org.openecomp.sdc.be.model.ComponentParametersView;
+import org.openecomp.sdc.be.model.DataTypeDefinition;
+import org.openecomp.sdc.be.model.IComplexDefaultValue;
+import org.openecomp.sdc.be.model.IPropertyInputCommon;
+import org.openecomp.sdc.be.model.LifecycleStateEnum;
+import org.openecomp.sdc.be.model.PropertyConstraint;
+import org.openecomp.sdc.be.model.PropertyDefinition;
+import org.openecomp.sdc.be.model.User;
 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
 import org.openecomp.sdc.be.model.jsontitan.operations.ArtifactsOperations;
 import org.openecomp.sdc.be.model.jsontitan.operations.InterfaceOperation;
 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
 import org.openecomp.sdc.be.model.operations.StorageException;
-import org.openecomp.sdc.be.model.operations.api.*;
+import org.openecomp.sdc.be.model.operations.api.IElementOperation;
+import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation;
+import org.openecomp.sdc.be.model.operations.api.IGroupInstanceOperation;
+import org.openecomp.sdc.be.model.operations.api.IGroupOperation;
+import org.openecomp.sdc.be.model.operations.api.IGroupTypeOperation;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
 import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter;
 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
 import org.openecomp.sdc.be.model.operations.impl.PolicyTypeOperation;
 import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
 import org.openecomp.sdc.be.model.operations.utils.ComponentValidationUtils;
 import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
+import org.openecomp.sdc.be.model.tosca.ToscaType;
 import org.openecomp.sdc.be.model.tosca.converters.PropertyValueConverter;
 import org.openecomp.sdc.be.model.tosca.validators.DataTypeValidatorConverter;
 import org.openecomp.sdc.be.model.tosca.validators.PropertyTypeValidator;
@@ -61,11 +85,6 @@ import org.openecomp.sdc.common.log.wrappers.Logger;
 import org.openecomp.sdc.exception.ResponseFormat;
 import org.springframework.beans.factory.annotation.Autowired;
 
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
-import java.util.function.Function;
-
 public abstract class BaseBusinessLogic {
 
     private static final String FAILED_TO_LOCK_COMPONENT_ERROR = "Failed to lock component {} error - {}";
@@ -374,7 +393,6 @@ public abstract class BaseBusinessLogic {
     ComponentTypeEnum getComponentTypeByParentComponentType(ComponentTypeEnum parentComponentType) {
         switch (parentComponentType) {
             case SERVICE:
-                return ComponentTypeEnum.RESOURCE;
             case RESOURCE:
                 return ComponentTypeEnum.RESOURCE;
             case PRODUCT:
@@ -666,8 +684,63 @@ public abstract class BaseBusinessLogic {
         return jsonElement.toString();
     }
     
-    protected void rollbackWithException(ActionStatus actionStatus, String... params) {
+    void rollbackWithException(ActionStatus actionStatus, String... params) {
         titanDao.rollback();
         throw new ComponentException(actionStatus, params);
     }
+
+	public <T extends PropertyDataDefinition> List<PropertyConstraint> setInputConstraint(T inputDefinition) {
+		if (StringUtils.isNotBlank(inputDefinition.getParentPropertyType())
+				&& StringUtils.isNotBlank(inputDefinition.getSubPropertyInputPath())) {
+			return setConstraint(inputDefinition);
+		}
+
+		return Collections.emptyList();
+	}
+
+	private <T extends PropertyDataDefinition> List<PropertyConstraint> setConstraint(T inputDefinition) {
+		List<PropertyConstraint> constraints = new ArrayList<>();
+		String[] inputPathArr = inputDefinition.getSubPropertyInputPath().split("#");
+		if (inputPathArr.length > 1) {
+			inputPathArr = ArrayUtils.remove(inputPathArr, 0);
+		}
+
+		Map<String, DataTypeDefinition> dataTypeDefinitionMap =
+				applicationDataTypeCache.getAll().left().value();
+
+		String propertyType = inputDefinition.getParentPropertyType();
+
+		for (String anInputPathArr : inputPathArr) {
+			if (ToscaType.isPrimitiveType(propertyType)) {
+				constraints.addAll(
+						dataTypeDefinitionMap.get(propertyType).getConstraints());
+			} else if (!ToscaType.isCollectionType(propertyType)) {
+				propertyType = setConstraintForComplexType(dataTypeDefinitionMap, propertyType, anInputPathArr,
+						constraints);
+			}
+		}
+
+		return constraints;
+	}
+
+	private String setConstraintForComplexType(Map<String, DataTypeDefinition> dataTypeDefinitionMap,
+											   String propertyType,
+											   String anInputPathArr,
+											   List<PropertyConstraint> constraints) {
+		String type = null;
+		List<PropertyDefinition> propertyDefinitions =
+				dataTypeDefinitionMap.get(propertyType).getProperties();
+		for (PropertyDefinition propertyDefinition : propertyDefinitions) {
+			if (propertyDefinition.getName().equals(anInputPathArr)) {
+				if (ToscaType.isPrimitiveType(propertyDefinition.getType())) {
+					constraints.addAll(propertyDefinition.getConstraints());
+				} else {
+					type = propertyDefinition.getType();
+				}
+				break;
+			}
+		}
+
+		return type;
+	}
 }
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ComponentBusinessLogic.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ComponentBusinessLogic.java
index 6b17d1c8e9..acf28c2455 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ComponentBusinessLogic.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ComponentBusinessLogic.java
@@ -20,6 +20,13 @@
 
 package org.openecomp.sdc.be.components.impl;
 
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.stream.Collectors;
+
 import fj.data.Either;
 import org.apache.commons.collections.CollectionUtils;
 import org.apache.commons.lang3.StringUtils;
@@ -34,9 +41,28 @@ import org.openecomp.sdc.be.dao.utils.MapUtil;
 import org.openecomp.sdc.be.datamodel.api.HighestFilterEnum;
 import org.openecomp.sdc.be.datatypes.components.ServiceMetadataDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
-import org.openecomp.sdc.be.datatypes.enums.*;
+import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
+import org.openecomp.sdc.be.datatypes.enums.FilterKeyEnum;
+import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
+import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
+import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
 import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition;
-import org.openecomp.sdc.be.model.*;
+import org.openecomp.sdc.be.model.ArtifactDefinition;
+import org.openecomp.sdc.be.model.CapReqDef;
+import org.openecomp.sdc.be.model.Component;
+import org.openecomp.sdc.be.model.ComponentInstance;
+import org.openecomp.sdc.be.model.ComponentInstanceInput;
+import org.openecomp.sdc.be.model.ComponentInstanceProperty;
+import org.openecomp.sdc.be.model.ComponentParametersView;
+import org.openecomp.sdc.be.model.DataTypeDefinition;
+import org.openecomp.sdc.be.model.GroupDefinition;
+import org.openecomp.sdc.be.model.IComponentInstanceConnectedElement;
+import org.openecomp.sdc.be.model.InputDefinition;
+import org.openecomp.sdc.be.model.LifecycleStateEnum;
+import org.openecomp.sdc.be.model.Operation;
+import org.openecomp.sdc.be.model.PropertyDefinition;
+import org.openecomp.sdc.be.model.Resource;
+import org.openecomp.sdc.be.model.User;
 import org.openecomp.sdc.be.model.cache.ComponentCache;
 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
 import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
@@ -54,13 +80,6 @@ import org.openecomp.sdc.common.util.ValidationUtils;
 import org.openecomp.sdc.exception.ResponseFormat;
 import org.springframework.beans.factory.annotation.Autowired;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.stream.Collectors;
-
 public abstract class ComponentBusinessLogic extends BaseBusinessLogic {
 
     @Autowired
@@ -72,6 +91,9 @@ public abstract class ComponentBusinessLogic extends BaseBusinessLogic {
     @Autowired
     private GenericTypeBusinessLogic genericTypeBusinessLogic;
 
+	@Autowired
+	private ComponentInstanceBusinessLogic componentInstanceBusinessLogic;
+
     public void setGenericTypeBusinessLogic(GenericTypeBusinessLogic genericTypeBusinessLogic) {
         this.genericTypeBusinessLogic = genericTypeBusinessLogic;
     }
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ComponentInstanceBusinessLogic.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ComponentInstanceBusinessLogic.java
index 1eb50e846a..0c6735f8c1 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ComponentInstanceBusinessLogic.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ComponentInstanceBusinessLogic.java
@@ -20,7 +20,26 @@
 
 package org.openecomp.sdc.be.components.impl;
 
+import static org.openecomp.sdc.be.components.property.GetInputUtils.isGetInputValueForInput;
+
 import com.google.common.collect.Sets;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+import java.util.function.BiConsumer;
+import java.util.stream.Collectors;
+
 import fj.data.Either;
 import org.apache.commons.collections.CollectionUtils;
 import org.apache.commons.collections.MapUtils;
@@ -38,41 +57,43 @@ import org.openecomp.sdc.be.dao.api.ActionStatus;
 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
 import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
+import org.openecomp.sdc.be.datamodel.utils.PropertyValueConstraintValidationUtil;
 import org.openecomp.sdc.be.datatypes.elements.CINodeFilterDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.GetInputValueDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.GroupDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
-import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
-import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
 import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
 import org.openecomp.sdc.be.impl.ForwardingPathUtils;
 import org.openecomp.sdc.be.impl.ServiceFilterUtils;
 import org.openecomp.sdc.be.info.CreateAndAssotiateInfo;
-import org.openecomp.sdc.be.model.Component;
-import org.openecomp.sdc.be.model.ComponentParametersView;
+import org.openecomp.sdc.be.model.ArtifactDefinition;
 import org.openecomp.sdc.be.model.CapabilityDefinition;
-import org.openecomp.sdc.be.model.InterfaceDefinition;
-import org.openecomp.sdc.be.model.RequirementDefinition;
-import org.openecomp.sdc.be.model.Resource;
-import org.openecomp.sdc.be.model.Service;
-import org.openecomp.sdc.be.model.User;
+import org.openecomp.sdc.be.model.Component;
+import org.openecomp.sdc.be.model.ComponentInstance;
+import org.openecomp.sdc.be.model.ComponentInstanceInput;
 import org.openecomp.sdc.be.model.ComponentInstancePropInput;
-import org.openecomp.sdc.be.model.LifecycleStateEnum;
-import org.openecomp.sdc.be.model.ArtifactDefinition;
+import org.openecomp.sdc.be.model.ComponentInstanceProperty;
+import org.openecomp.sdc.be.model.ComponentParametersView;
 import org.openecomp.sdc.be.model.DataTypeDefinition;
-import org.openecomp.sdc.be.model.PropertyDefinition;
 import org.openecomp.sdc.be.model.GroupDefinition;
 import org.openecomp.sdc.be.model.InputDefinition;
+import org.openecomp.sdc.be.model.InterfaceDefinition;
+import org.openecomp.sdc.be.model.LifecycleStateEnum;
+import org.openecomp.sdc.be.model.PropertyDefinition;
+import org.openecomp.sdc.be.model.PropertyDefinition.PropertyNames;
 import org.openecomp.sdc.be.model.RelationshipInfo;
 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
-import org.openecomp.sdc.be.model.ComponentInstance;
-import org.openecomp.sdc.be.model.ComponentInstanceInput;
-import org.openecomp.sdc.be.model.ComponentInstanceProperty;
-import org.openecomp.sdc.be.model.PropertyDefinition.PropertyNames;
+import org.openecomp.sdc.be.model.RequirementDefinition;
+import org.openecomp.sdc.be.model.Resource;
+import org.openecomp.sdc.be.model.Service;
+import org.openecomp.sdc.be.model.User;
+import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
 import org.openecomp.sdc.be.model.jsontitan.operations.ForwardingPathOperation;
 import org.openecomp.sdc.be.model.jsontitan.operations.NodeFilterOperation;
 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
@@ -95,24 +116,6 @@ import org.openecomp.sdc.common.util.ValidationUtils;
 import org.openecomp.sdc.exception.ResponseFormat;
 import org.springframework.beans.factory.annotation.Autowired;
 
-import java.util.Arrays;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Objects;
-import java.util.Optional;
-import java.util.Set;
-import java.util.UUID;
-import java.util.function.BiConsumer;
-import java.util.stream.Collectors;
-
-import static org.openecomp.sdc.be.components.property.GetInputUtils.isGetInputValueForInput;
-
 @org.springframework.stereotype.Component
 public class ComponentInstanceBusinessLogic extends BaseBusinessLogic {
 
@@ -131,6 +134,9 @@ public class ComponentInstanceBusinessLogic extends BaseBusinessLogic {
     public static final String FAILED_TO_COPY_COMP_INSTANCE_TO_CANVAS = "Failed to copy the component instance to the canvas";
     public static final String COPY_COMPONENT_INSTANCE_OK = "Copy component instance OK";
 
+	@Autowired
+	private ApplicationDataTypeCache applicationDataTypeCache;
+
     @Autowired
     private IComponentInstanceOperation componentInstanceOperation;
 
@@ -1673,6 +1679,17 @@ public class ComponentInstanceBusinessLogic extends BaseBusinessLogic {
             resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
             return resultOp;
         }
+
+		//Validate value and Constraint of property
+		Either<Boolean, ResponseFormat> constraintValidatorResponse =
+				PropertyValueConstraintValidationUtil.getInstance().
+						validatePropertyConstraints(properties, applicationDataTypeCache);
+		if (constraintValidatorResponse.isRight()) {
+			log.error("Failed validation value and constraint of property: {}",
+					constraintValidatorResponse.right().value());
+			return Either.right(constraintValidatorResponse.right().value());
+		}
+
         Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent, resourceInstanceId);
         if (resourceInstanceStatus.isRight()) {
             resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, resourceInstanceId, componentId));
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/InputsBusinessLogic.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/InputsBusinessLogic.java
index 357eb14ed0..f3b1b14652 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/InputsBusinessLogic.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/InputsBusinessLogic.java
@@ -24,15 +24,20 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.stream.Collectors;
 
 import fj.data.Either;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.collections4.ListUtils;
+import org.apache.commons.collections4.MapUtils;
 import org.openecomp.sdc.be.components.property.PropertyDeclarationOrchestrator;
 import org.openecomp.sdc.be.components.validation.ComponentValidations;
 import org.openecomp.sdc.be.dao.api.ActionStatus;
 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
 import org.openecomp.sdc.be.dao.utils.MapUtil;
+import org.openecomp.sdc.be.datamodel.utils.PropertyValueConstraintValidationUtil;
 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
@@ -44,12 +49,15 @@ import org.openecomp.sdc.be.model.ComponentInstanceProperty;
 import org.openecomp.sdc.be.model.ComponentParametersView;
 import org.openecomp.sdc.be.model.DataTypeDefinition;
 import org.openecomp.sdc.be.model.InputDefinition;
+import org.openecomp.sdc.be.model.PropertyDefinition;
+import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
 import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter;
 import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
 import org.openecomp.sdc.be.model.tosca.converters.PropertyValueConverter;
 import org.openecomp.sdc.common.log.wrappers.Logger;
 import org.openecomp.sdc.exception.ResponseFormat;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
 import javax.inject.Inject;
@@ -71,7 +79,6 @@ public class InputsBusinessLogic extends BaseBusinessLogic {
     private PropertyDeclarationOrchestrator propertyDeclarationOrchestrator;
     @Inject
     private ComponentInstanceBusinessLogic componentInstanceBusinessLogic;
-
     /**
      * associate inputs to a given component with paging
      *
@@ -124,7 +131,13 @@ public class InputsBusinessLogic extends BaseBusinessLogic {
             log.debug("Failed to found component instance inputs {}, error: {}", componentInstanceId, actionStatus);
             return Either.right(componentsUtils.getResponseFormat(actionStatus));
         }
-        Map<String, List<ComponentInstanceInput>> ciInputs = Optional.ofNullable(component.getComponentInstancesInputs()).orElse(Collections.emptyMap());
+		Map<String, List<ComponentInstanceInput>> ciInputs =
+				Optional.ofNullable(component.getComponentInstancesInputs()).orElse(Collections.emptyMap());
+
+		// Set Constraints on Input
+		MapUtils.emptyIfNull(ciInputs).values()
+				.forEach(inputs -> ListUtils.emptyIfNull(inputs)
+						.forEach(input -> input.setConstraints(setInputConstraint(input))));
         return Either.left(ciInputs.getOrDefault(componentInstanceId, Collections.emptyList()));
     }
 
@@ -140,7 +153,7 @@ public class InputsBusinessLogic extends BaseBusinessLogic {
     public Either<List<ComponentInstanceProperty>, ResponseFormat> getComponentInstancePropertiesByInputId(String userId, String componentId, String instanceId, String inputId) {
         validateUserExists(userId, GET_PROPERTIES_BY_INPUT, false);
         String parentId = componentId;
-        org.openecomp.sdc.be.model.Component component = null;
+        org.openecomp.sdc.be.model.Component component;
         ComponentParametersView filters = new ComponentParametersView();
         filters.disableAll();
         filters.setIgnoreComponentInstances(false);
@@ -246,6 +259,9 @@ public class InputsBusinessLogic extends BaseBusinessLogic {
             componentParametersView.disableAll();
             componentParametersView.setIgnoreInputs(false);
             componentParametersView.setIgnoreUsers(false);
+			componentParametersView.setIgnoreProperties(false);
+			componentParametersView.setIgnoreComponentInstancesProperties(false);
+			componentParametersView.setIgnoreComponentInstances(false);
 
             Either<? extends org.openecomp.sdc.be.model.Component, ResponseFormat> validateComponent = validateComponentExists(componentId, componentType, componentParametersView);
 
@@ -269,6 +285,14 @@ public class InputsBusinessLogic extends BaseBusinessLogic {
                 return result;
             }
 
+			//Validate value and Constraint of input
+			Either<Boolean, ResponseFormat> constraintValidatorResponse = validateInputValueConstraint(component, inputs);
+			if (constraintValidatorResponse.isRight()) {
+				log.error("Failed validation value and constraint of property: {}",
+						constraintValidatorResponse.right().value());
+				return Either.right(constraintValidatorResponse.right().value());
+			}
+
             Either<Map<String, DataTypeDefinition>, ResponseFormat> allDataTypes = getAllDataTypes(applicationDataTypeCache);
             if (allDataTypes.isRight()) {
                 result = Either.right(allDataTypes.right().value());
@@ -321,6 +345,29 @@ public class InputsBusinessLogic extends BaseBusinessLogic {
             }
     }
 
+	private Either<Boolean, ResponseFormat> validateInputValueConstraint(
+			org.openecomp.sdc.be.model.Component component, List<InputDefinition> inputs) {
+		PropertyValueConstraintValidationUtil propertyValueConstraintValidationUtil =
+				PropertyValueConstraintValidationUtil.getInstance();
+		List<InputDefinition> inputDefinitions = new ArrayList<>();
+		for (InputDefinition inputDefinition : inputs) {
+			InputDefinition inputDef = new InputDefinition();
+			inputDefinition.setDefaultValue(inputDefinition.getDefaultValue());
+			inputDefinition.setInputPath(inputDefinition.getSubPropertyInputPath());
+			inputDefinition.setType(inputDefinition.getType());
+			if (Objects.nonNull(inputDefinition.getParentPropertyType())) {
+				ComponentInstanceProperty propertyDefinition = new ComponentInstanceProperty();
+				propertyDefinition.setType(inputDefinition.getParentPropertyType());
+
+				inputDefinition.setProperties(Collections.singletonList(propertyDefinition));
+			}
+
+			inputDefinitions.add(inputDef);
+		}
+
+		return propertyValueConstraintValidationUtil.validatePropertyConstraints(inputDefinitions, applicationDataTypeCache);
+	}
+
     public Either<List<ComponentInstanceInput>, ResponseFormat> getInputsForComponentInput(String userId, String componentId, String inputId) {
         validateUserExists(userId, GET_PROPERTIES_BY_INPUT, false);
         org.openecomp.sdc.be.model.Component component = null;
@@ -396,7 +443,7 @@ public class InputsBusinessLogic extends BaseBusinessLogic {
                     .left()
                     .bind(inputsToCreate -> prepareInputsForCreation(userId, componentId, inputsToCreate))
                     .right()
-                    .map(err -> componentsUtils.getResponseFormat(err));
+					.map(componentsUtils::getResponseFormat);
 
             return result;
 
@@ -422,6 +469,9 @@ public class InputsBusinessLogic extends BaseBusinessLogic {
     private  Either<List<InputDefinition>, StorageOperationStatus> prepareInputsForCreation(String userId, String cmptId, List<InputDefinition> inputsToCreate) {
         Map<String, InputDefinition> inputsToPersist = MapUtil.toMap(inputsToCreate, InputDefinition::getName);
         assignOwnerIdToInputs(userId, inputsToPersist);
+		inputsToPersist.values()
+				.forEach(input -> input.setConstraints(componentInstanceBusinessLogic.setInputConstraint(input)));
+
         return toscaOperationFacade.addInputsToComponent(inputsToPersist, cmptId)
                 .left()
                 .map(persistedInputs -> inputsToCreate);
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/InterfaceOperationBusinessLogic.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/InterfaceOperationBusinessLogic.java
index 7f19e824e5..de2839f653 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/InterfaceOperationBusinessLogic.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/InterfaceOperationBusinessLogic.java
@@ -450,6 +450,8 @@ public class InterfaceOperationBusinessLogic extends BaseBusinessLogic {
             operationInput.setToscaDefaultValue(getInputToscaDefaultValue(operationInput, component));
             operationInput.setValue(componentInput.getValue());
             operationInput.setSchema(componentInput.getSchema());
+			operationInput.setParentPropertyType(componentInput.getParentPropertyType());
+			operationInput.setSubPropertyInputPath(componentInput.getSubPropertyInputPath());
         }
         //Set the tosca default value for inputs mapped to component inputs as well as other outputs
         operationInput.setToscaDefaultValue(getInputToscaDefaultValue(operationInput, component));
@@ -460,6 +462,7 @@ public class InterfaceOperationBusinessLogic extends BaseBusinessLogic {
         Map<String, List<String>> defaultInputValue;
         if (isOperationInputMappedToComponentInput(input, component.getInputs())) {
             String propertyName = input.getInputId().substring(input.getInputId().indexOf('.') + 1);
+			setParentPropertyTypeAndInputPath(input, component);
             defaultInputValue = createMappedInputPropertyDefaultValue(propertyName);
         } else {
             //Currently inputs can only be mapped to a declared input or an other operation outputs
@@ -468,6 +471,24 @@ public class InterfaceOperationBusinessLogic extends BaseBusinessLogic {
         return new Gson().toJson(defaultInputValue);
     }
 
+	private void setParentPropertyTypeAndInputPath(OperationInputDefinition input,
+												   org.openecomp.sdc.be.model.Component component) {
+		if (CollectionUtils.isEmpty(component.getInputs())) {
+			return;
+		}
+
+		component.getInputs()
+				.stream()
+				.filter(inp -> inp.getUniqueId().equals(
+						input.getInputId().substring(0, input.getInputId().lastIndexOf('.'))))
+				.forEach(inp -> {
+					input.setParentPropertyType(inp.getParentPropertyType());
+					if (Objects.nonNull(input.getName())) {
+						input.setSubPropertyInputPath(input.getName().replaceAll("\\.", "#"));
+					}
+				});
+	}
+
     private void addOperationToInterface(InterfaceDefinition interfaceDefinition, Operation interfaceOperation) {
         interfaceOperation.setUniqueId(UUID.randomUUID().toString());
         interfaceOperation.setImplementation(createArtifactDefinition(UUID.randomUUID().toString()));
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ResourceBusinessLogic.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ResourceBusinessLogic.java
index 92d26a4eb8..53ed2a4306 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ResourceBusinessLogic.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ResourceBusinessLogic.java
@@ -8,7 +8,7 @@
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      http://www.apache.org/licenses/LICENSE-2.0getUiComponentDataTransferByComponentId
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -21,10 +21,37 @@
 package org.openecomp.sdc.be.components.impl;
 
 
+import static java.util.stream.Collectors.joining;
+import static java.util.stream.Collectors.toList;
+import static java.util.stream.Collectors.toMap;
+import static java.util.stream.Collectors.toSet;
+import static org.apache.commons.collections.CollectionUtils.isNotEmpty;
+import static org.apache.commons.collections.MapUtils.isEmpty;
+import static org.apache.commons.collections.MapUtils.isNotEmpty;
+import static org.openecomp.sdc.be.components.impl.ImportUtils.findFirstToscaStringElement;
+import static org.openecomp.sdc.be.components.impl.ImportUtils.getPropertyJsonStringValue;
+import static org.openecomp.sdc.be.tosca.CsarUtils.VF_NODE_TYPE_ARTIFACTS_PATH_PATTERN;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.EnumMap;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.regex.Pattern;
+
 import fj.data.Either;
 import org.apache.commons.codec.binary.Base64;
 import org.apache.commons.collections.CollectionUtils;
 import org.apache.commons.collections.MapUtils;
+import org.apache.commons.collections4.ListUtils;
 import org.apache.commons.lang.StringUtils;
 import org.apache.commons.lang3.tuple.ImmutablePair;
 import org.openecomp.sdc.be.components.csar.CsarArtifactsAndGroupsBusinessLogic;
@@ -53,6 +80,7 @@ import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.GetInputValueDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
+import org.openecomp.sdc.be.datatypes.enums.ComponentFieldsEnum;
 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
 import org.openecomp.sdc.be.datatypes.enums.CreatedFrom;
 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
@@ -130,31 +158,6 @@ import org.yaml.snakeyaml.DumperOptions;
 import org.yaml.snakeyaml.Yaml;
 
 import javax.servlet.ServletContext;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.EnumMap;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.ListIterator;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Optional;
-import java.util.Set;
-import java.util.function.Function;
-import java.util.regex.Pattern;
-
-import static java.util.stream.Collectors.joining;
-import static java.util.stream.Collectors.toList;
-import static java.util.stream.Collectors.toMap;
-import static java.util.stream.Collectors.toSet;
-import static org.apache.commons.collections.CollectionUtils.isNotEmpty;
-import static org.apache.commons.collections.MapUtils.isEmpty;
-import static org.apache.commons.collections.MapUtils.isNotEmpty;
-import static org.openecomp.sdc.be.components.impl.ImportUtils.findFirstToscaStringElement;
-import static org.openecomp.sdc.be.components.impl.ImportUtils.getPropertyJsonStringValue;
-import static org.openecomp.sdc.be.tosca.CsarUtils.VF_NODE_TYPE_ARTIFACTS_PATH_PATTERN;
 
 @org.springframework.stereotype.Component("resourceBusinessLogic")
 public class ResourceBusinessLogic extends ComponentBusinessLogic {
@@ -5207,28 +5210,36 @@ public class ResourceBusinessLogic extends ComponentBusinessLogic {
     }
 
     @Override
-    public Either<UiComponentDataTransfer, ResponseFormat> getUiComponentDataTransferByComponentId(String resourceId, List<String> dataParamsToReturn) {
-
-        ComponentParametersView paramsToRetuen = new ComponentParametersView(dataParamsToReturn);
-        Either<Resource, StorageOperationStatus> resourceResultEither = toscaOperationFacade.getToscaElement(resourceId,
-                paramsToRetuen);
-
-        if (resourceResultEither.isRight()) {
-            if (resourceResultEither.right().value().equals(StorageOperationStatus.NOT_FOUND)) {
-                log.debug("Failed to found resource with id {} ", resourceId);
-                Either.right(componentsUtils.getResponseFormat(ActionStatus.RESOURCE_NOT_FOUND, resourceId));
-            }
-
-            log.debug("failed to get resource by id {} with filters {}", resourceId, dataParamsToReturn);
-            return Either.right(componentsUtils.getResponseFormatByResource(
-                    componentsUtils.convertFromStorageResponse(resourceResultEither.right().value()), ""));
-        }
-
-        Resource resource = resourceResultEither.left().value();
-        UiComponentDataTransfer dataTransfer = uiComponentDataConverter.getUiDataTransferFromResourceByParams(resource,
-                dataParamsToReturn);
-        return Either.left(dataTransfer);
-    }
+	public Either<UiComponentDataTransfer, ResponseFormat> getUiComponentDataTransferByComponentId(String resourceId,
+																								   List<String> dataParamsToReturn) {
+
+		ComponentParametersView paramsToRetuen = new ComponentParametersView(dataParamsToReturn);
+		Either<Resource, StorageOperationStatus> resourceResultEither =
+				toscaOperationFacade.getToscaElement(resourceId,
+						paramsToRetuen);
+
+		if (resourceResultEither.isRight()) {
+			if (resourceResultEither.right().value().equals(StorageOperationStatus.NOT_FOUND)) {
+				log.debug("Failed to found resource with id {} ", resourceId);
+				Either
+						.right(componentsUtils.getResponseFormat(ActionStatus.RESOURCE_NOT_FOUND, resourceId));
+			}
+
+			log.debug("failed to get resource by id {} with filters {}", resourceId, dataParamsToReturn);
+			return Either.right(componentsUtils.getResponseFormatByResource(
+					componentsUtils.convertFromStorageResponse(resourceResultEither.right().value()), ""));
+		}
+
+		Resource resource = resourceResultEither.left().value();
+		if (dataParamsToReturn.contains(ComponentFieldsEnum.INPUTS.getValue())) {
+			ListUtils.emptyIfNull(resource.getInputs())
+					.forEach(input -> input.setConstraints(setInputConstraint(input)));
+		}
+
+		UiComponentDataTransfer dataTransfer = uiComponentDataConverter.getUiDataTransferFromResourceByParams(resource,
+				dataParamsToReturn);
+		return Either.left(dataTransfer);
+	}
 
     @Override
     public Either<Component, ActionStatus> shouldUpgradeToLatestDerived(Component clonedComponent) {
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ServiceBusinessLogic.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ServiceBusinessLogic.java
index ba3b8dfc45..364b007ce3 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ServiceBusinessLogic.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ServiceBusinessLogic.java
@@ -20,13 +20,39 @@
 
 package org.openecomp.sdc.be.components.impl;
 
+import static org.apache.commons.collections.CollectionUtils.isEmpty;
+import static org.apache.commons.collections.CollectionUtils.isNotEmpty;
+import static org.openecomp.sdc.be.components.utils.InterfaceOperationUtils.getOperationOutputName;
+import static org.openecomp.sdc.be.components.utils.InterfaceOperationUtils.isOperationInputMappedToOtherOperationOutput;
+import static org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum.UPDATE_SERVICE_METADATA;
+import static org.openecomp.sdc.be.tosca.utils.InterfacesOperationsToscaUtil.SELF;
+import static org.openecomp.sdc.be.types.ServiceConsumptionSource.SERVICE_INPUT;
+import static org.openecomp.sdc.be.types.ServiceConsumptionSource.STATIC;
+
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Strings;
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
+
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.Callable;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
 import fj.data.Either;
 import org.apache.commons.collections.CollectionUtils;
 import org.apache.commons.collections.MapUtils;
+import org.apache.commons.collections4.ListUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.tuple.ImmutablePair;
 import org.openecomp.sdc.be.components.distribution.engine.IDistributionEngine;
@@ -46,6 +72,7 @@ import org.openecomp.sdc.be.dao.api.ActionStatus;
 import org.openecomp.sdc.be.dao.cassandra.AuditCassandraDao;
 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
 import org.openecomp.sdc.be.datamodel.ServiceRelations;
+import org.openecomp.sdc.be.datamodel.utils.PropertyValueConstraintValidationUtil;
 import org.openecomp.sdc.be.datamodel.utils.UiComponentDataConverter;
 import org.openecomp.sdc.be.datatypes.elements.CINodeFilterDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition;
@@ -54,6 +81,7 @@ import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
 import org.openecomp.sdc.be.datatypes.elements.OperationOutputDefinition;
 import org.openecomp.sdc.be.datatypes.elements.RequirementNodeFilterPropertyDataDefinition;
+import org.openecomp.sdc.be.datatypes.enums.ComponentFieldsEnum;
 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
 import org.openecomp.sdc.be.datatypes.enums.InstantiationTypes;
 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
@@ -62,7 +90,24 @@ import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
 import org.openecomp.sdc.be.externalapi.servlet.representation.ServiceDistributionReqInfo;
 import org.openecomp.sdc.be.impl.ForwardingPathUtils;
 import org.openecomp.sdc.be.impl.WebAppContextWrapper;
-import org.openecomp.sdc.be.model.*;
+import org.openecomp.sdc.be.model.ArtifactDefinition;
+import org.openecomp.sdc.be.model.Component;
+import org.openecomp.sdc.be.model.ComponentInstance;
+import org.openecomp.sdc.be.model.ComponentInstanceInterface;
+import org.openecomp.sdc.be.model.ComponentInstanceProperty;
+import org.openecomp.sdc.be.model.ComponentParametersView;
+import org.openecomp.sdc.be.model.DistributionStatusEnum;
+import org.openecomp.sdc.be.model.DistributionTransitionEnum;
+import org.openecomp.sdc.be.model.GroupInstance;
+import org.openecomp.sdc.be.model.GroupInstanceProperty;
+import org.openecomp.sdc.be.model.InputDefinition;
+import org.openecomp.sdc.be.model.InterfaceDefinition;
+import org.openecomp.sdc.be.model.LifecycleStateEnum;
+import org.openecomp.sdc.be.model.Operation;
+import org.openecomp.sdc.be.model.PropertyDefinition;
+import org.openecomp.sdc.be.model.Resource;
+import org.openecomp.sdc.be.model.Service;
+import org.openecomp.sdc.be.model.User;
 import org.openecomp.sdc.be.model.category.CategoryDefinition;
 import org.openecomp.sdc.be.model.jsontitan.operations.ForwardingPathOperation;
 import org.openecomp.sdc.be.model.jsontitan.operations.NodeFilterOperation;
@@ -77,7 +122,11 @@ import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
 import org.openecomp.sdc.be.model.tosca.validators.PropertyTypeValidator;
 import org.openecomp.sdc.be.resources.data.ComponentInstanceData;
 import org.openecomp.sdc.be.resources.data.ComponentMetadataData;
-import org.openecomp.sdc.be.resources.data.auditing.*;
+import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
+import org.openecomp.sdc.be.resources.data.auditing.AuditingGenericEvent;
+import org.openecomp.sdc.be.resources.data.auditing.DistributionDeployEvent;
+import org.openecomp.sdc.be.resources.data.auditing.DistributionNotificationEvent;
+import org.openecomp.sdc.be.resources.data.auditing.ResourceAdminEvent;
 import org.openecomp.sdc.be.resources.data.auditing.model.ResourceCommonInfo;
 import org.openecomp.sdc.be.resources.data.auditing.model.ResourceVersionInfo;
 import org.openecomp.sdc.be.types.ServiceConsumptionData;
@@ -100,20 +149,6 @@ import org.springframework.web.context.WebApplicationContext;
 
 import javax.servlet.ServletContext;
 import javax.servlet.http.HttpServletRequest;
-import java.nio.charset.StandardCharsets;
-import java.util.*;
-import java.util.concurrent.Callable;
-import java.util.function.Function;
-import java.util.stream.Collectors;
-
-import static org.apache.commons.collections.CollectionUtils.isEmpty;
-import static org.apache.commons.collections.CollectionUtils.isNotEmpty;
-import static org.openecomp.sdc.be.components.utils.InterfaceOperationUtils.getOperationOutputName;
-import static org.openecomp.sdc.be.components.utils.InterfaceOperationUtils.isOperationInputMappedToOtherOperationOutput;
-import static org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum.UPDATE_SERVICE_METADATA;
-import static org.openecomp.sdc.be.tosca.utils.InterfacesOperationsToscaUtil.SELF;
-import static org.openecomp.sdc.be.types.ServiceConsumptionSource.SERVICE_INPUT;
-import static org.openecomp.sdc.be.types.ServiceConsumptionSource.STATIC;
 
 @org.springframework.stereotype.Component("serviceBusinessLogic")
 public class ServiceBusinessLogic extends ComponentBusinessLogic {
@@ -365,7 +400,6 @@ public class ServiceBusinessLogic extends ComponentBusinessLogic {
         }
 
         OperationInputDefinition operationInputDefinition = inputCandidate.get();
-
         // add data to operation
 
         if(Objects.nonNull(serviceConsumptionData.getValue()))  {
@@ -441,6 +475,14 @@ public class ServiceBusinessLogic extends ComponentBusinessLogic {
         ServiceConsumptionSource sourceValue = ServiceConsumptionSource.getSourceValue(source);
 
         if(STATIC.equals(sourceValue)) {
+			// Validate constraint on input value
+			/*Either<Boolean, ResponseFormat> constraintValidationResult =
+					validateOperationInputConstraint(operationInputDefinition, serviceConsumptionData);
+
+			if (constraintValidationResult.isRight()) {
+				return Either.right(constraintValidationResult.right().value());
+			}*/
+
             return handleConsumptionStaticValue(consumptionValue, type, operation,
                     operationInputDefinition);
         }
@@ -612,12 +654,37 @@ public class ServiceBusinessLogic extends ComponentBusinessLogic {
             return Either.right(componentsUtils.getResponseFormat(
                     ActionStatus.INVALID_CONSUMPTION_TYPE, type));
         }
+
+		//Validate Constraint and Value
+		Either<Boolean, ResponseFormat> constraintValidationResponse =
+				validateOperationInputConstraint(operationInputDefinition, value, type);
+		if(constraintValidationResponse.isRight()) {
+			return Either.right(constraintValidationResponse.right().value());
+		}
+
         addStaticValueToInputOperation(value, operation, operationInputDefinition);
 
         return Either.left(operation);
     }
 
-    private void addStaticValueToInputOperation(String value, Operation operation,
+	private Either<Boolean, ResponseFormat> validateOperationInputConstraint(
+			OperationInputDefinition operationInputDefinition, String value, String type) {
+		ComponentInstanceProperty propertyDefinition = new ComponentInstanceProperty();
+		propertyDefinition.setType(operationInputDefinition.getParentPropertyType());
+
+		InputDefinition inputDefinition = new InputDefinition();
+		inputDefinition.setDefaultValue(value);
+		inputDefinition.setInputPath(operationInputDefinition.getSubPropertyInputPath());
+		inputDefinition.setType(type);
+		if (Objects.nonNull(operationInputDefinition.getParentPropertyType())) {
+			inputDefinition.setProperties(Collections.singletonList(propertyDefinition));
+		}
+
+		return PropertyValueConstraintValidationUtil.getInstance()
+				.validatePropertyConstraints(Collections.singletonList(inputDefinition), applicationDataTypeCache);
+	}
+
+	private void addStaticValueToInputOperation(String value, Operation operation,
                                                 OperationInputDefinition operationInputDefinition) {
         operation.getInputs().delete(operationInputDefinition);
         operationInputDefinition.setSource(STATIC.getSource());
@@ -2571,6 +2638,11 @@ public class ServiceBusinessLogic extends ComponentBusinessLogic {
         }
 
         Service service = serviceResultEither.left().value();
+		if (dataParamsToReturn.contains(ComponentFieldsEnum.INPUTS.getValue())) {
+			ListUtils.emptyIfNull(service.getInputs())
+					.forEach(input -> input.setConstraints(setInputConstraint(input)));
+		}
+
         UiComponentDataTransfer dataTransfer = uiComponentDataConverter.getUiDataTransferFromServiceByParams(service, dataParamsToReturn);
         return Either.left(dataTransfer);
     }
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/property/DefaultPropertyDeclarator.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/property/DefaultPropertyDeclarator.java
index bd7a58c48a..0f76210a1a 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/property/DefaultPropertyDeclarator.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/property/DefaultPropertyDeclarator.java
@@ -156,6 +156,14 @@ public abstract class DefaultPropertyDeclarator<PROPERTYOWNER extends Properties
         input.setInputPath(propertiesName);
         input.setInstanceUniqueId(propertiesOwner.getUniqueId());
         input.setPropertyId(propInput.getUniqueId());
+		if (Objects.isNull(input.getSubPropertyInputPath())
+				|| (Objects.nonNull(propertiesName)
+				&& input.getSubPropertyInputPath().substring(input.getSubPropertyInputPath().lastIndexOf('#'))
+				.equals(propertiesName.substring(propertiesName.lastIndexOf('#'))))) {
+			input.setParentPropertyType(propInput.getType());
+			input.setSubPropertyInputPath(propertiesName);
+		}
+
         changePropertyValueToGetInputValue(inputName, parsedPropNames, input, prop, complexProperty);
 
         if(prop instanceof IComponentInstanceConnectedElement) {
@@ -169,7 +177,7 @@ public abstract class DefaultPropertyDeclarator<PROPERTYOWNER extends Properties
 
     private void changePropertyValueToGetInputValue(String inputName, String[] parsedPropNames, InputDefinition input, PropertyDataDefinition prop, boolean complexProperty) {
         JSONObject jobject = new JSONObject();
-        String value = (String) prop.getValue();
+        String value = prop.getValue();
         if(value == null || value.isEmpty()){
             if(complexProperty){
 
@@ -185,7 +193,6 @@ public abstract class DefaultPropertyDeclarator<PROPERTYOWNER extends Properties
 
         }else{
 
-            //String value = value;
             Object objValue =  new Yaml().load(value);
             if( objValue instanceof Map || objValue  instanceof List){
                 if(!complexProperty){
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/datamodel/utils/PropertyValueConstraintValidationUtil.java b/catalog-be/src/main/java/org/openecomp/sdc/be/datamodel/utils/PropertyValueConstraintValidationUtil.java
new file mode 100644
index 0000000000..f2cdcc3a6d
--- /dev/null
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/datamodel/utils/PropertyValueConstraintValidationUtil.java
@@ -0,0 +1,374 @@
+/*
+ * Copyright © 2016-2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.openecomp.sdc.be.datamodel.utils;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+import fj.data.Either;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.collections4.ListUtils;
+import org.apache.commons.collections4.MapUtils;
+import org.apache.commons.lang3.ArrayUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.codehaus.jackson.map.ObjectMapper;
+import org.codehaus.jackson.type.TypeReference;
+import org.openecomp.sdc.be.components.impl.ResponseFormatManager;
+import org.openecomp.sdc.be.dao.api.ActionStatus;
+import org.openecomp.sdc.be.model.DataTypeDefinition;
+import org.openecomp.sdc.be.model.InputDefinition;
+import org.openecomp.sdc.be.model.PropertyConstraint;
+import org.openecomp.sdc.be.model.PropertyDefinition;
+import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
+import org.openecomp.sdc.be.model.tosca.ToscaType;
+import org.openecomp.sdc.be.model.tosca.constraints.ConstraintUtil;
+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.constraints.exception.ConstraintViolationException;
+import org.openecomp.sdc.exception.ResponseFormat;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class PropertyValueConstraintValidationUtil {
+
+    private static final String UNDERSCORE = "_";
+    private static final String VALUE_PROVIDED_IN_INVALID_FORMAT_FOR_PROPERTY =
+            "%nValue provided in invalid format for %s property";
+    private Map<String, DataTypeDefinition> dataTypeDefinitionCache;
+    private static final Logger logger = LoggerFactory.getLogger(PropertyValueConstraintValidationUtil.class);
+    private ObjectMapper objectMapper = new ObjectMapper();
+    private List<String> errorMessages = new ArrayList<>();
+    private StringBuilder completePropertyName;
+    private String completeInputName;
+    private static final String IGNORE_PROPERTY_VALUE_START_WITH = "{\"get_input\":";
+
+    public static PropertyValueConstraintValidationUtil getInstance() {
+        return new PropertyValueConstraintValidationUtil();
+    }
+
+    public Either<Boolean, ResponseFormat> validatePropertyConstraints(
+            Collection<? extends PropertyDefinition> propertyDefinitionList,
+            ApplicationDataTypeCache applicationDataTypeCache) {
+        ResponseFormatManager responseFormatManager = getResponseFormatManager();
+        dataTypeDefinitionCache = applicationDataTypeCache.getAll().left().value();
+        CollectionUtils.emptyIfNull(propertyDefinitionList).stream()
+                .filter(this::isValuePresent)
+                .forEach(this::evaluatePropertyTypeForConstraintValidation);
+
+        if (CollectionUtils.isNotEmpty(errorMessages)) {
+            logger.error("Properties with Invalid Data:", errorMessages);
+            ResponseFormat inputResponse = responseFormatManager.getResponseFormat(ActionStatus
+                    .INVALID_PROPERTY_VALUES, String.join(",", errorMessages));
+            return Either.right(inputResponse);
+        }
+
+        return Either.left(Boolean.TRUE);
+    }
+
+    private boolean isValuePresent(PropertyDefinition propertyDefinition) {
+        if (propertyDefinition instanceof InputDefinition) {
+            return StringUtils.isNotEmpty(propertyDefinition.getDefaultValue());
+        }
+
+        return StringUtils.isNotEmpty(propertyDefinition.getValue());
+    }
+
+    private void evaluatePropertyTypeForConstraintValidation(PropertyDefinition propertyDefinition) {
+        if (Objects.nonNull(propertyDefinition.getType())
+                && dataTypeDefinitionCache.containsKey(propertyDefinition.getType())) {
+
+            completeInputName = "";
+            completePropertyName = new StringBuilder();
+            if (propertyDefinition instanceof InputDefinition) {
+                completeInputName = propertyDefinition.getName();
+                propertyDefinition = getPropertyDefinitionObjectFromInputs(propertyDefinition);
+            }
+
+            if (Objects.nonNull(propertyDefinition)) {
+				if (ToscaType.isPrimitiveType(propertyDefinition.getType())) {
+					propertyDefinition.setConstraints(
+							org.openecomp.sdc.be.dao.utils.CollectionUtils.merge(propertyDefinition.getConstraints(),
+									dataTypeDefinitionCache.get(propertyDefinition.getType()).getConstraints()));
+					evaluateConstraintsOnProperty(propertyDefinition);
+				} else if (ToscaType.isCollectionType(propertyDefinition.getType())) {
+					propertyDefinition.setConstraints(
+							org.openecomp.sdc.be.dao.utils.CollectionUtils.merge(propertyDefinition.getConstraints(),
+									dataTypeDefinitionCache.get(propertyDefinition.getType()).getConstraints()));
+					evaluateConstraintsOnProperty(propertyDefinition);
+					evaluateCollectionTypeProperties(propertyDefinition);
+				} else {
+					setCompletePropertyName(propertyDefinition);
+					evaluateComplexTypeProperties(propertyDefinition);
+				}
+			}
+        } else {
+            errorMessages.add("\nUnsupported datatype found for property " + getCompletePropertyName(propertyDefinition));
+        }
+    }
+
+    private void setCompletePropertyName(PropertyDefinition propertyDefinition) {
+        if(StringUtils.isNotBlank(propertyDefinition.getUniqueId())) {
+            completePropertyName.append(
+                    propertyDefinition.getUniqueId().substring(propertyDefinition.getUniqueId().lastIndexOf('.') + 1));
+        }
+    }
+
+    private void evaluateConstraintsOnProperty(PropertyDefinition propertyDefinition) {
+        ToscaType toscaType = ToscaType.isValidType(propertyDefinition.getType());
+        if (isPropertyNotMappedAsInput(propertyDefinition)
+                && CollectionUtils.isNotEmpty(propertyDefinition.getConstraints())
+                && isValidValueConstraintPresent(propertyDefinition.getConstraints())) {
+            for (PropertyConstraint propertyConstraint : propertyDefinition.getConstraints()) {
+                try {
+                    propertyConstraint.initialize(toscaType);
+                    propertyConstraint.validate(toscaType, propertyDefinition.getValue());
+                } catch (ConstraintValueDoNotMatchPropertyTypeException | ConstraintViolationException exception) {
+                    errorMessages.add("\n" + propertyConstraint.getErrorMessage(
+                            toscaType, exception, getCompletePropertyName(propertyDefinition)));
+                }
+            }
+        } else if (isPropertyNotMappedAsInput(propertyDefinition)
+                && ToscaType.isPrimitiveType(propertyDefinition.getType())
+                && !toscaType.isValidValue(propertyDefinition.getValue())) {
+            errorMessages.add(String.format("\nUnsupported value provided for %s property supported value "
+                    + "type is %s.", getCompletePropertyName(propertyDefinition), toscaType.getType()));
+        }
+    }
+
+    private boolean isPropertyNotMappedAsInput(PropertyDefinition propertyDefinition) {
+        return !propertyDefinition.getValue().startsWith(IGNORE_PROPERTY_VALUE_START_WITH);
+    }
+
+    private void checkAndEvaluatePrimitiveProperty(PropertyDefinition propertyDefinition,
+												   DataTypeDefinition dataTypeDefinition) {
+        if (ToscaType.isPrimitiveType(dataTypeDefinition.getName())
+                && CollectionUtils.isNotEmpty(dataTypeDefinition.getConstraints())) {
+
+            PropertyDefinition definition = new PropertyDefinition();
+            definition.setValue(propertyDefinition.getValue());
+            definition.setType(dataTypeDefinition.getName());
+            definition.setConstraints(dataTypeDefinition.getConstraints());
+
+            evaluateConstraintsOnProperty(propertyDefinition);
+        }
+    }
+
+    private void evaluateComplexTypeProperties(PropertyDefinition propertyDefinition) {
+        List<PropertyDefinition> propertyDefinitions =
+                dataTypeDefinitionCache.get(propertyDefinition.getType()).getProperties();
+		try {
+			Map<String, Object> valueMap =
+					MapUtils.emptyIfNull(ConstraintUtil.parseToCollection(propertyDefinition.getValue(),
+							new TypeReference<Map<String, Object>>() {}));
+
+			if (CollectionUtils.isEmpty(propertyDefinitions)) {
+				checkAndEvaluatePrimitiveProperty(propertyDefinition,
+						dataTypeDefinitionCache.get(propertyDefinition.getType()));
+			} else {
+				ListUtils.emptyIfNull(propertyDefinitions)
+						.forEach(prop -> evaluateRegularComplexType(propertyDefinition, prop, valueMap));
+			}
+		} catch (ConstraintValueDoNotMatchPropertyTypeException e) {
+			logger.debug(e.getMessage(), e);
+			errorMessages.add(String.format(VALUE_PROVIDED_IN_INVALID_FORMAT_FOR_PROPERTY,
+					getCompletePropertyName(propertyDefinition)));
+		}
+    }
+
+    private void evaluateRegularComplexType(PropertyDefinition propertyDefinition,
+											PropertyDefinition prop,
+											Map<String, Object> valueMap) {
+        try {
+            if (valueMap.containsKey(prop.getName())) {
+                if (ToscaType.isPrimitiveType(prop.getType())) {
+                    evaluateConstraintsOnProperty(createPropertyDefinition(prop,
+                            String.valueOf(valueMap.get(prop.getName()))));
+                } else if (ToscaType.isCollectionType(prop.getType())) {
+
+                    evaluateCollectionTypeProperties(createPropertyDefinition(prop,
+                            objectMapper.writeValueAsString(valueMap.get(prop.getName()))));
+                } else {
+                    completePropertyName.append(UNDERSCORE);
+                    completePropertyName.append(prop.getName());
+                    evaluateComplexTypeProperties(
+                            createPropertyDefinition(prop, objectMapper.writeValueAsString(
+                                    valueMap.get(prop.getName()))));
+                }
+            }
+        } catch (IOException e) {
+            logger.error(e.getMessage(), e);
+            errorMessages.add(String.format(VALUE_PROVIDED_IN_INVALID_FORMAT_FOR_PROPERTY,
+                    getCompletePropertyName(propertyDefinition)));
+        }
+    }
+
+    private void evaluateCollectionTypeProperties(PropertyDefinition propertyDefinition) {
+        ToscaType toscaPropertyType = ToscaType.isValidType(propertyDefinition.getType());
+        if (ToscaType.LIST == toscaPropertyType) {
+            evaluateListType(propertyDefinition);
+        } else if (ToscaType.MAP == toscaPropertyType) {
+            evaluateMapType(propertyDefinition);
+        }
+    }
+
+    private void evaluateListType(PropertyDefinition propertyDefinition) {
+        try {
+            String schemaType = propertyDefinition.getSchemaType();
+            List list = ConstraintUtil.parseToCollection(propertyDefinition.getValue(),
+                    new TypeReference<List<Object>>() {});
+            evaluateCollectionType(propertyDefinition, list, schemaType);
+        } catch (ConstraintValueDoNotMatchPropertyTypeException e) {
+            logger.debug(e.getMessage(), e);
+            errorMessages.add(String.format(VALUE_PROVIDED_IN_INVALID_FORMAT_FOR_PROPERTY,
+                    getCompletePropertyName(propertyDefinition)));
+        }
+    }
+
+    private void evaluateMapType(PropertyDefinition propertyDefinition) {
+        try {
+            String schemaType = propertyDefinition.getSchemaType();
+            Map map = ConstraintUtil.parseToCollection(propertyDefinition.getValue(),
+                    new TypeReference<Map<String, Object>>() {
+            });
+            evaluateCollectionType(propertyDefinition, map.values(), schemaType);
+        } catch (ConstraintValueDoNotMatchPropertyTypeException e) {
+            logger.debug(e.getMessage(), e);
+            errorMessages.add(String.format(VALUE_PROVIDED_IN_INVALID_FORMAT_FOR_PROPERTY,
+                    getCompletePropertyName(propertyDefinition)));
+        }
+    }
+
+    private void evaluateCollectionPrimitiveSchemaType(PropertyDefinition propertyDefinition,
+													   Object value,
+													   String schemaType) {
+        if (Objects.nonNull(propertyDefinition.getSchema())
+                && propertyDefinition.getSchema().getProperty() instanceof PropertyDefinition) {
+            propertyDefinition.setConstraints(((PropertyDefinition) propertyDefinition.getSchema()
+                    .getProperty()).getConstraints());
+            propertyDefinition.setValue(String.valueOf(value));
+            propertyDefinition.setType(schemaType);
+            evaluateConstraintsOnProperty(propertyDefinition);
+        }
+    }
+    private void evaluateCollectionType(PropertyDefinition propertyDefinition,
+										Collection valueList,
+										String schemaType) {
+        for (Object value : valueList) {
+            try {
+                if (ToscaType.isPrimitiveType(schemaType)) {
+                    evaluateCollectionPrimitiveSchemaType(propertyDefinition, value, schemaType);
+                } else if (ToscaType.isCollectionType(schemaType)) {
+                    propertyDefinition.setValue(objectMapper.writeValueAsString(value));
+                    propertyDefinition.setType(schemaType);
+                    evaluateCollectionTypeProperties(propertyDefinition);
+                } else {
+                    propertyDefinition.setValue(objectMapper.writeValueAsString(value));
+                    propertyDefinition.setType(schemaType);
+                    completePropertyName.append(UNDERSCORE);
+                    completePropertyName.append(propertyDefinition.getName());
+                    evaluateComplexTypeProperties(propertyDefinition);
+                }
+            } catch (IOException e) {
+                logger.debug(e.getMessage(), e);
+                errorMessages.add(String.format(VALUE_PROVIDED_IN_INVALID_FORMAT_FOR_PROPERTY,
+                        getCompletePropertyName(propertyDefinition)));
+            }
+        }
+    }
+
+    private String getCompletePropertyName(PropertyDefinition propertyDefinition) {
+        return StringUtils.isNotBlank(completeInputName) ? completeInputName :
+                StringUtils.isBlank(completePropertyName) ?
+                        propertyDefinition.getName() : completePropertyName + UNDERSCORE + propertyDefinition.getName();
+    }
+
+    private PropertyDefinition createPropertyDefinition(PropertyDefinition prop, String value) {
+        PropertyDefinition propertyDefinition = new PropertyDefinition();
+        propertyDefinition.setName(prop.getName());
+        propertyDefinition.setValue(value);
+        propertyDefinition.setType(prop.getType());
+        propertyDefinition.setConstraints(prop.getConstraints());
+        propertyDefinition.setSchema(prop.getSchema());
+
+        return propertyDefinition;
+    }
+
+    private boolean isValidValueConstraintPresent(List<PropertyConstraint> propertyConstraints) {
+        return propertyConstraints.stream()
+                .anyMatch(propertyConstraint -> propertyConstraint instanceof ValidValuesConstraint);
+    }
+
+    private PropertyDefinition getPropertyDefinitionObjectFromInputs(
+            PropertyDefinition property) {
+        InputDefinition inputDefinition = (InputDefinition) property;
+        PropertyDefinition propertyDefinition = null;
+
+        if (CollectionUtils.isEmpty(inputDefinition.getProperties())
+                || ToscaType.isPrimitiveType(inputDefinition.getProperties().get(0).getType())) {
+        	propertyDefinition  = new PropertyDefinition();
+            propertyDefinition.setType(inputDefinition.getType());
+            propertyDefinition.setValue(inputDefinition.getDefaultValue());
+            propertyDefinition.setName(inputDefinition.getName());
+        } else if (Objects.nonNull(inputDefinition.getInputPath())) {
+            propertyDefinition = evaluateComplexTypeInputs(inputDefinition);
+        }
+
+        return propertyDefinition;
+    }
+
+    private PropertyDefinition evaluateComplexTypeInputs(InputDefinition inputDefinition) {
+        Map<String, Object> inputMap = new HashMap<>();
+        PropertyDefinition propertyDefinition = new PropertyDefinition();
+        String[] inputPathArr = inputDefinition.getInputPath().split("#");
+        if (inputPathArr.length > 1) {
+            inputPathArr = ArrayUtils.remove(inputPathArr, 0);
+        }
+
+        try {
+            Map<String, Object> presentMap = inputMap;
+            for (int i = 0; i < inputPathArr.length ; i++) {
+                if (i == inputPathArr.length - 1) {
+                    presentMap.computeIfAbsent(inputPathArr[i], k -> inputDefinition.getDefaultValue());
+                } else {
+                    presentMap.computeIfAbsent(inputPathArr[i], k -> new HashMap<String, Object>());
+                    presentMap = (Map<String, Object>) presentMap.get(inputPathArr[i]);
+                }
+            }
+
+            if (CollectionUtils.isNotEmpty(inputDefinition.getProperties())) {
+                propertyDefinition.setType(inputDefinition.getProperties().get(0).getType());
+            }
+            propertyDefinition.setName(inputDefinition.getName());
+            propertyDefinition.setValue(objectMapper.writeValueAsString(inputMap));
+        } catch (IOException e) {
+            logger.error(e.getMessage(), e);
+            errorMessages.add(String.format(VALUE_PROVIDED_IN_INVALID_FORMAT_FOR_PROPERTY,
+                    inputDefinition.getName()));
+        }
+
+        return propertyDefinition;
+    }
+
+    protected ResponseFormatManager getResponseFormatManager() {
+        return ResponseFormatManager.getInstance();
+    }
+}
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/ComponentPropertyServlet.java b/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/ComponentPropertyServlet.java
index 79e63c71b5..38c04a131c 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/ComponentPropertyServlet.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/ComponentPropertyServlet.java
@@ -17,28 +17,45 @@
 package org.openecomp.sdc.be.servlets;
 
 import com.jcabi.aspects.Loggable;
+
+import java.util.List;
+import java.util.Map;
+
 import fj.data.Either;
-import io.swagger.annotations.*;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiParam;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
 import org.openecomp.sdc.be.components.impl.PropertyBusinessLogic;
 import org.openecomp.sdc.be.config.BeEcompErrorManager;
 import org.openecomp.sdc.be.dao.api.ActionStatus;
+import org.openecomp.sdc.be.datamodel.utils.PropertyValueConstraintValidationUtil;
 import org.openecomp.sdc.be.model.PropertyDefinition;
 import org.openecomp.sdc.be.model.User;
+import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
 import org.openecomp.sdc.be.resources.data.EntryData;
 import org.openecomp.sdc.common.api.Constants;
 import org.openecomp.sdc.exception.ResponseFormat;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
 
 import javax.inject.Singleton;
 import javax.servlet.ServletContext;
 import javax.servlet.http.HttpServletRequest;
-import javax.ws.rs.*;
+import javax.ws.rs.Consumes;
+import javax.ws.rs.DELETE;
+import javax.ws.rs.GET;
+import javax.ws.rs.HeaderParam;
+import javax.ws.rs.POST;
+import javax.ws.rs.PUT;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.Produces;
 import javax.ws.rs.core.Context;
 import javax.ws.rs.core.MediaType;
 import javax.ws.rs.core.Response;
-import java.util.List;
-import java.util.Map;
 
 @Loggable(prepend = true, value = Loggable.DEBUG, trim = false)
 @Path("/v1/catalog")
@@ -46,6 +63,9 @@ import java.util.Map;
 @Singleton
 public class ComponentPropertyServlet extends BeGenericServlet {
 
+	@Autowired
+	ApplicationDataTypeCache applicationDataTypeCache;
+
   private static final Logger log = LoggerFactory.getLogger(ComponentPropertyServlet.class);
   private static final String CREATE_PROPERTY = "Create Property";
   private static final String DEBUG_MESSAGE = "Start handle request of {} modifier id is {}";
@@ -264,6 +284,16 @@ public class ComponentPropertyServlet extends BeGenericServlet {
         return buildErrorResponse(responseFormat);
       }
 
+		//Validate value and Constraint of property
+		Either<Boolean, ResponseFormat> constraintValidatorResponse =
+				PropertyValueConstraintValidationUtil.getInstance().
+						validatePropertyConstraints(properties.values(), applicationDataTypeCache);
+		if (constraintValidatorResponse.isRight()) {
+			log.error("Failed validation value and constraint of property: {}",
+					constraintValidatorResponse.right().value());
+			return buildErrorResponse(constraintValidatorResponse.right().value());
+		}
+
       // update property
 
       PropertyBusinessLogic businessLogic = getPropertyBL(context);
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/ServiceConsumptionServlet.java b/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/ServiceConsumptionServlet.java
index 4ed2f95676..990e3bc356 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/ServiceConsumptionServlet.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/ServiceConsumptionServlet.java
@@ -44,6 +44,7 @@ import org.openecomp.sdc.be.dao.api.ActionStatus;
 import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
 import org.openecomp.sdc.be.model.Operation;
+import org.openecomp.sdc.be.model.OperationInput;
 import org.openecomp.sdc.be.model.User;
 import org.openecomp.sdc.be.model.tosca.ToscaFunctions;
 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
@@ -158,8 +159,7 @@ public class ServiceConsumptionServlet extends BeGenericServlet {
       }
 
       List<OperationInputDefinition> inputs = inputsEither.left().value();
-      updateOperationInputListForUi(inputs);
-      return buildOkResponse(inputs);
+		return buildOkResponse(updateOperationInputListForUi(inputs, interfaceOperationBL));
     }
     catch (Exception e) {
       BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Get Operation Inputs");
@@ -169,43 +169,52 @@ public class ServiceConsumptionServlet extends BeGenericServlet {
     }
   }
 
-  private void updateOperationInputListForUi(List<OperationInputDefinition> inputsList) {
-    for(OperationInputDefinition input : inputsList) {
-
-      String value = input.getValue();
-      // No Additional UI mapping needed for STATIC source
-      if(StringUtils.isEmpty(value)
-              || ServiceConsumptionSource.STATIC.getSource().equals(input.getSource())) {
-        continue;
-      }
-
-
-      // Additional UI mapping needed for other sources
-      try {
-        Map<String, Object> valueAsMap = (new Gson()).fromJson(value, Map.class);
-        String toscaFunction = valueAsMap.keySet().iterator().next();
-        Object consumptionValueName = valueAsMap.values().iterator().next();
-        if(consumptionValueName instanceof List) {
-          List<Object> toscaFunctionList = (List<Object>) consumptionValueName;
-          String consumptionInputValue = null;
-          if (ToscaFunctions.GET_PROPERTY.getFunctionName().equals(toscaFunction)) {
-            consumptionInputValue = String.valueOf(toscaFunctionList.get(1));
-          } else if (ToscaFunctions.GET_OPERATION_OUTPUT.getFunctionName().equals(toscaFunction)) {
-            //Return full output name
-            consumptionInputValue =
-                    toscaFunctionList.get(1) + "." + toscaFunctionList.get(2) + "." +toscaFunctionList.get(3);
-          }
-          input.setValue(consumptionInputValue);
-        } else {
-          input.setValue(String.valueOf(consumptionValueName));
-        }
-      }
-      catch(JsonParseException ex){
-        log.info("This means it is static value for which no changes are needed");
-      }
-    }
-  }
-
+	private List<OperationInput> updateOperationInputListForUi(List<OperationInputDefinition> inputsList,
+															   InterfaceOperationBusinessLogic interfaceOperationBL) {
+		List<OperationInput> operationInputs = new ArrayList<>();
+		for(OperationInputDefinition input : inputsList) {
+
+			String value = input.getValue();
+
+			// Additional UI mapping needed for other sources
+			if (StringUtils.isNotBlank(value)
+					&& !ServiceConsumptionSource.STATIC.getSource().equals(input.getSource())) {
+				uiMappingForOtherSources(value, input);
+			}
+
+			// Add Constraint for UI
+			OperationInput operationInput = new OperationInput(input);
+			operationInput.setConstraints(interfaceOperationBL.setInputConstraint(input));
+			operationInputs.add(operationInput);
+		}
+
+		return operationInputs;
+	}
+
+	private void uiMappingForOtherSources(String value, OperationInputDefinition input) {
+		try {
+			Map<String, Object> valueAsMap = (new Gson()).fromJson(value, Map.class);
+			String toscaFunction = valueAsMap.keySet().iterator().next();
+			Object consumptionValueName = valueAsMap.values().iterator().next();
+			if(consumptionValueName instanceof List) {
+				List<Object> toscaFunctionList = (List<Object>) consumptionValueName;
+				String consumptionInputValue = null;
+				if (ToscaFunctions.GET_PROPERTY.getFunctionName().equals(toscaFunction)) {
+					consumptionInputValue = String.valueOf(toscaFunctionList.get(1));
+				} else if (ToscaFunctions.GET_OPERATION_OUTPUT.getFunctionName().equals(toscaFunction)) {
+					//Return full output name
+					consumptionInputValue =
+							toscaFunctionList.get(1) + "." + toscaFunctionList.get(2) + "." +toscaFunctionList.get(3);
+				}
+				input.setValue(consumptionInputValue);
+			} else {
+				input.setValue(String.valueOf(consumptionValueName));
+			}
+		}
+		catch(JsonParseException ex){
+			log.info("This means it is static value for which no changes are needed");
+		}
+	}
 
   private Either<Map<String, List<ServiceConsumptionData>>, ResponseFormat> getServiceConsumptionData(String data,
                                                                                                       User user) {
diff --git a/catalog-be/src/main/resources/config/error-configuration.yaml b/catalog-be/src/main/resources/config/error-configuration.yaml
index d9f8ffc7e4..312d90c307 100644
--- a/catalog-be/src/main/resources/config/error-configuration.yaml
+++ b/catalog-be/src/main/resources/config/error-configuration.yaml
@@ -2262,4 +2262,10 @@ errors:
         code: 400,
         message: "Error: Given value is different than input type. Needs to be %1",
         messageId: "SVC4725"
+    }
+#---------SVC4726-----------------------------
+    INVALID_PROPERTY_VALUES: {
+        code: 400,
+        message: "Error: Invalid property values provided:\n %1",
+        messageId: "SVC4735"
     }
 \ No newline at end of file
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/datamodel/utils/PropertyValueConstraintValidationUtilTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/datamodel/utils/PropertyValueConstraintValidationUtilTest.java
new file mode 100644
index 0000000000..95020b6112
--- /dev/null
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/datamodel/utils/PropertyValueConstraintValidationUtilTest.java
@@ -0,0 +1,317 @@
+package org.openecomp.sdc.be.datamodel.utils;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.when;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.reflect.TypeToken;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.lang.reflect.Type;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+import fj.data.Either;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.mockito.Spy;
+import org.openecomp.sdc.be.components.impl.ResponseFormatManager;
+import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
+import org.openecomp.sdc.be.model.ComponentInstanceProperty;
+import org.openecomp.sdc.be.model.DataTypeDefinition;
+import org.openecomp.sdc.be.model.InputDefinition;
+import org.openecomp.sdc.be.model.PropertyConstraint;
+import org.openecomp.sdc.be.model.PropertyDefinition;
+import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
+import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
+import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
+import org.openecomp.sdc.exception.ResponseFormat;
+
+public class PropertyValueConstraintValidationUtilTest {
+
+	@Mock
+	ApplicationDataTypeCache applicationDataTypeCache;
+
+	@Mock
+	ToscaOperationFacade toscaOperationFacade;
+
+	@Spy
+	@InjectMocks
+	PropertyValueConstraintValidationUtil propertyValueConstraintValidationUtil;
+
+	private Map<String, DataTypeDefinition> dataTypeDefinitionMap;
+
+	@Before
+	public void init() {
+		MockitoAnnotations.initMocks(this);
+		ResponseFormatManager responseFormatManagerMock = Mockito.mock(ResponseFormatManager.class);
+		when(responseFormatManagerMock.getResponseFormat(any())).thenReturn(new ResponseFormat());
+		when(responseFormatManagerMock.getResponseFormat(any(), any())).thenReturn(new ResponseFormat());
+		when(responseFormatManagerMock.getResponseFormat(any(), any(), any())).thenReturn(new ResponseFormat());
+		when(propertyValueConstraintValidationUtil.getResponseFormatManager()).thenReturn(responseFormatManagerMock);
+
+		createDataTypeMap();
+	}
+
+	@Test
+	public void primitiveValueSuccessTest() {
+		Either<Map<String, DataTypeDefinition>, TitanOperationStatus> either = Either.left(dataTypeDefinitionMap);
+		Mockito.when(applicationDataTypeCache.getAll()).thenReturn(either);
+
+		PropertyDefinition propertyDefinition = new PropertyDefinition();
+		propertyDefinition.setType("integer");
+		propertyDefinition.setValue("10");
+
+		Either<Boolean, ResponseFormat> responseEither =
+				propertyValueConstraintValidationUtil.validatePropertyConstraints(
+						Collections.singletonList(propertyDefinition), applicationDataTypeCache);
+
+		Assert.assertTrue(responseEither.isLeft());
+	}
+
+	@Test
+	public void primitiveValueFailTest() {
+		Either<Map<String, DataTypeDefinition>, TitanOperationStatus> either = Either.left(dataTypeDefinitionMap);
+		Mockito.when(applicationDataTypeCache.getAll()).thenReturn(either);
+
+		PropertyDefinition propertyDefinition = new PropertyDefinition();
+		propertyDefinition.setType("integer");
+		propertyDefinition.setValue("abcd");
+
+		Either<Boolean, ResponseFormat> responseEither =
+				propertyValueConstraintValidationUtil.validatePropertyConstraints(
+						Collections.singletonList(propertyDefinition), applicationDataTypeCache);
+
+		Assert.assertTrue(responseEither.isRight());
+	}
+
+	@Test
+	public void complexWithValidValueSuccessTest() {
+		Either<Map<String, DataTypeDefinition>, TitanOperationStatus> either = Either.left(dataTypeDefinitionMap);
+		Mockito.when(applicationDataTypeCache.getAll()).thenReturn(either);
+
+		PropertyDefinition propertyDefinition = new PropertyDefinition();
+		propertyDefinition.setType("org.openecomp.datatypes.heat.network.neutron.Subnet");
+		propertyDefinition.setValue("{\"prefixlen\":\"4\"}");
+
+		Either<Boolean, ResponseFormat> responseEither =
+				propertyValueConstraintValidationUtil.validatePropertyConstraints(
+						Collections.singletonList(propertyDefinition), applicationDataTypeCache);
+
+		Assert.assertTrue(responseEither.isLeft());
+	}
+
+	@Test
+	public void complexWithValidValueFailTest() {
+		Either<Map<String, DataTypeDefinition>, TitanOperationStatus> either = Either.left(dataTypeDefinitionMap);
+		Mockito.when(applicationDataTypeCache.getAll()).thenReturn(either);
+
+		PropertyDefinition propertyDefinition = new PropertyDefinition();
+		propertyDefinition.setType("org.openecomp.datatypes.heat.network.neutron.Subnet");
+		propertyDefinition.setValue("{\"prefixlen\":\"5\"}");
+
+		Either<Boolean, ResponseFormat> responseEither =
+				propertyValueConstraintValidationUtil.validatePropertyConstraints(
+						Collections.singletonList(propertyDefinition), applicationDataTypeCache);
+
+		Assert.assertTrue(responseEither.isRight());
+	}
+
+	@Test
+	public void complexWithListWithPrimitiveValueSuccessTest() {
+		Either<Map<String, DataTypeDefinition>, TitanOperationStatus> either = Either.left(dataTypeDefinitionMap);
+		Mockito.when(applicationDataTypeCache.getAll()).thenReturn(either);
+
+		PropertyDefinition propertyDefinition = new PropertyDefinition();
+		propertyDefinition.setType("org.openecomp.datatypes.heat.network.neutron.Subnet");
+		propertyDefinition.setValue("{\"allocation_pools\":[\"slaac\"]}");
+
+		Either<Boolean, ResponseFormat> responseEither =
+				propertyValueConstraintValidationUtil.validatePropertyConstraints(
+						Collections.singletonList(propertyDefinition), applicationDataTypeCache);
+
+		Assert.assertTrue(responseEither.isLeft());
+	}
+
+	@Test
+	public void complexWithListWithPrimitiveValueFailTest() {
+		Either<Map<String, DataTypeDefinition>, TitanOperationStatus> either = Either.left(dataTypeDefinitionMap);
+		Mockito.when(applicationDataTypeCache.getAll()).thenReturn(either);
+
+		PropertyDefinition propertyDefinition = new PropertyDefinition();
+		propertyDefinition.setType("org.openecomp.datatypes.heat.network.neutron.Subnet");
+		propertyDefinition.setValue("{\"allocation_pools\":[\"value\"]}");
+
+		Either<Boolean, ResponseFormat> responseEither =
+				propertyValueConstraintValidationUtil.validatePropertyConstraints(
+						Collections.singletonList(propertyDefinition), applicationDataTypeCache);
+
+		Assert.assertTrue(responseEither.isRight());
+	}
+
+	@Test
+	public void complexWithMapWithPrimitiveValueSuccessTest() {
+		Either<Map<String, DataTypeDefinition>, TitanOperationStatus> either = Either.left(dataTypeDefinitionMap);
+		Mockito.when(applicationDataTypeCache.getAll()).thenReturn(either);
+
+		PropertyDefinition propertyDefinition = new PropertyDefinition();
+		propertyDefinition.setType("org.openecomp.datatypes.heat.network.neutron.Subnet");
+		propertyDefinition.setValue("{\"value_specs\":{\"key\":\"slaac\"}}");
+
+		Either<Boolean, ResponseFormat> responseEither =
+				propertyValueConstraintValidationUtil.validatePropertyConstraints(
+						Collections.singletonList(propertyDefinition), applicationDataTypeCache);
+
+		Assert.assertTrue(responseEither.isLeft());
+	}
+
+	@Test
+	public void complexWithMapWithPrimitiveValueFailTest() {
+		Either<Map<String, DataTypeDefinition>, TitanOperationStatus> either = Either.left(dataTypeDefinitionMap);
+		Mockito.when(applicationDataTypeCache.getAll()).thenReturn(either);
+
+		PropertyDefinition propertyDefinition = new PropertyDefinition();
+		propertyDefinition.setType("org.openecomp.datatypes.heat.network.neutron.Subnet");
+		propertyDefinition.setValue("{\"value_specs\":{\"key\":\"value\"}}");
+
+		Either<Boolean, ResponseFormat> responseEither =
+				propertyValueConstraintValidationUtil.validatePropertyConstraints(
+						Collections.singletonList(propertyDefinition), applicationDataTypeCache);
+
+		Assert.assertTrue(responseEither.isRight());
+	}
+
+	@Test
+	public void inputValidValueSuccessTest() {
+		Either<Map<String, DataTypeDefinition>, TitanOperationStatus> either = Either.left(dataTypeDefinitionMap);
+		Mockito.when(applicationDataTypeCache.getAll()).thenReturn(either);
+
+		InputDefinition inputDefinition = new InputDefinition();
+		inputDefinition.setInputPath("propetyName#ipv6_ra_mode");
+		inputDefinition.setDefaultValue("slaac");
+		inputDefinition.setType("string");
+		ComponentInstanceProperty propertyDefinition = new ComponentInstanceProperty();
+		propertyDefinition.setType("org.openecomp.datatypes.heat.network.neutron.Subnet");
+		inputDefinition.setProperties(Collections.singletonList(propertyDefinition));
+
+		Either<Boolean, ResponseFormat> responseEither =
+				propertyValueConstraintValidationUtil.validatePropertyConstraints(
+						Collections.singletonList(inputDefinition), applicationDataTypeCache);
+
+		Assert.assertTrue(responseEither.isLeft());
+	}
+
+	@Test
+	public void inputValidValueFailTest() {
+		Either<Map<String, DataTypeDefinition>, TitanOperationStatus> either = Either.left(dataTypeDefinitionMap);
+		Mockito.when(applicationDataTypeCache.getAll()).thenReturn(either);
+
+		InputDefinition inputDefinition = new InputDefinition();
+		inputDefinition.setInputPath("propetyName#ipv6_ra_mode");
+		inputDefinition.setDefaultValue("incorrectValue");
+		ComponentInstanceProperty propertyDefinition = new ComponentInstanceProperty();
+		propertyDefinition.setType("org.openecomp.datatypes.heat.network.neutron.Subnet");
+		inputDefinition.setProperties(Collections.singletonList(propertyDefinition));
+
+		Either<Boolean, ResponseFormat> responseEither =
+				propertyValueConstraintValidationUtil.validatePropertyConstraints(
+						Collections.singletonList(inputDefinition), applicationDataTypeCache);
+
+		Assert.assertTrue(responseEither.isRight());
+	}
+
+	@Test
+	public void serviceConsumptionValidValueSuccessTest() {
+		Either<Map<String, DataTypeDefinition>, TitanOperationStatus> either = Either.left(dataTypeDefinitionMap);
+		Mockito.when(applicationDataTypeCache.getAll()).thenReturn(either);
+
+		PropertyDefinition propertyDefinition = new PropertyDefinition();
+		propertyDefinition.setType("org.openecomp.datatypes.heat.network.neutron.Subnet");
+		propertyDefinition.setValue("{\"ipv6_ra_mode\":\"slaac\"}");
+		propertyDefinition.setName("ipv6_ra_mode");
+
+		Either<Boolean, ResponseFormat> responseEither =
+				propertyValueConstraintValidationUtil.validatePropertyConstraints(
+						Collections.singletonList(propertyDefinition), applicationDataTypeCache);
+
+		Assert.assertTrue(responseEither.isLeft());
+	}
+	@Test
+	public void serviceConsumptionValidValueFailTest() {
+		Either<Map<String, DataTypeDefinition>, TitanOperationStatus> either = Either.left(dataTypeDefinitionMap);
+		Mockito.when(applicationDataTypeCache.getAll()).thenReturn(either);
+
+		PropertyDefinition propertyDefinition = new PropertyDefinition();
+		propertyDefinition.setType("org.openecomp.datatypes.heat.network.neutron.Subnet");
+		propertyDefinition.setValue("{\"ipv6_ra_mode\":\"incorrectValue\"}");
+		propertyDefinition.setName("ipv6_ra_mode");
+
+		Either<Boolean, ResponseFormat> responseEither =
+				propertyValueConstraintValidationUtil.validatePropertyConstraints(
+						Collections.singletonList(propertyDefinition), applicationDataTypeCache);
+
+		Assert.assertTrue(responseEither.isRight());
+	}
+
+	private void createDataTypeMap() {
+		Type constraintType = new TypeToken<PropertyConstraint>() {}.getType();
+		Type typeOfHashMap = new TypeToken<Map<String, DataTypeDefinition>>() { }.getType();
+		Gson gson = new GsonBuilder().registerTypeAdapter(constraintType,
+				new PropertyOperation.PropertyConstraintDeserialiser()).create();
+
+		dataTypeDefinitionMap = gson.fromJson(readFile(), typeOfHashMap);
+
+		DataTypeDefinition dataTypeDefinition = dataTypeDefinitionMap.get("org.openecomp.datatypes.heat.network"
+				+ ".neutron.Subnet");
+
+		PropertyDefinition mapProperty = null;
+		PropertyDefinition listProperty = null;
+		List<PropertyConstraint> constraints = null;
+		for (PropertyDefinition propertyDefinition : dataTypeDefinition.getProperties()) {
+			if ("value_specs".equals(propertyDefinition.getName())) {
+				mapProperty = propertyDefinition;
+			} else if ("allocation_pools".equals(propertyDefinition.getName())) {
+				listProperty = propertyDefinition;
+			} else if ("ipv6_ra_mode".equals(propertyDefinition.getName())) {
+				constraints = propertyDefinition.getConstraints();
+			}
+		}
+
+		PropertyDefinition definition = new PropertyDefinition(mapProperty.getSchema().getProperty());
+		definition.setConstraints(constraints);
+		mapProperty.getSchema().setProperty(definition);
+
+		definition = new PropertyDefinition(listProperty.getSchema().getProperty());
+		definition.setConstraints(constraints);
+		listProperty.getSchema().setProperty(definition);
+	}
+
+	private static String readFile() {
+		StringBuilder stringBuilder = new StringBuilder();
+		File file = new File(Objects.requireNonNull(
+				PropertyValueConstraintValidationUtilTest.class.getClassLoader().getResource("types/datatypes"
+						+ "/constraintTest.json")).getFile());
+		Path logFile = Paths.get(file.getAbsolutePath());
+		try (BufferedReader reader = Files.newBufferedReader(logFile, StandardCharsets.UTF_8)) {
+			reader.lines().forEach(stringBuilder::append);
+		} catch (Exception e) {
+			Assert.fail(e.getMessage());
+			e.printStackTrace();
+		}
+		return stringBuilder.toString();
+	}
+
+}
diff --git a/catalog-be/src/test/resources/csars/with_groups.csar b/catalog-be/src/test/resources/csars/with_groups.csar
index 3859114aa5..3a9e9ab8e0 100644
--- a/catalog-be/src/test/resources/csars/with_groups.csar
+++ b/catalog-be/src/test/resources/csars/with_groups.csar
diff --git a/catalog-be/src/test/resources/types/datatypes/constraintTest.json b/catalog-be/src/test/resources/types/datatypes/constraintTest.json
new file mode 100644
index 0000000000..9596e92436
--- /dev/null
+++ b/catalog-be/src/test/resources/types/datatypes/constraintTest.json
@@ -0,0 +1,405 @@
+{
+  "string": {
+    "derivedFrom": {
+      "name": "tosca.datatypes.Root",
+      "uniqueId": "tosca.datatypes.Root.datatype",
+      "description": "The TOSCA root Data Type all other TOSCA base Data Types derive from",
+      "creationTime": 1550136563278,
+      "modificationTime": 1550136563278,
+      "toscaPresentation": {}
+    },
+    "name": "string",
+    "uniqueId": "string.datatype",
+    "derivedFromName": "tosca.datatypes.Root",
+    "creationTime": 1550136564103,
+    "modificationTime": 1550136564103,
+    "toscaPresentation": {}
+  },
+  "org.openecomp.datatypes.heat.network.neutron.Subnet": {
+    "derivedFrom": {
+      "name": "tosca.datatypes.Root",
+      "uniqueId": "tosca.datatypes.Root.datatype",
+      "description": "The TOSCA root Data Type all other TOSCA base Data Types derive from",
+      "creationTime": 1550136563278,
+      "modificationTime": 1550136563278,
+      "toscaPresentation": {}
+    },
+    "properties": [
+      {
+        "uniqueId": "org.openecomp.datatypes.heat.network.neutron.Subnet.datatype.tenant_id",
+        "type": "string",
+        "required": false,
+        "definition": false,
+        "description": "The ID of the tenant who owns the network",
+        "password": false,
+        "name": "tenant_id",
+        "hidden": false,
+        "immutable": false,
+        "toscaPresentation": {}
+      },
+      {
+        "uniqueId": "org.openecomp.datatypes.heat.network.neutron.Subnet.datatype.enable_dhcp",
+        "type": "boolean",
+        "required": false,
+        "definition": false,
+        "defaultValue": "true",
+        "description": "Set to true if DHCP is enabled and false if DHCP is disabled",
+        "password": false,
+        "name": "enable_dhcp",
+        "hidden": false,
+        "immutable": false,
+        "toscaPresentation": {}
+      },
+      {
+        "constraints": [
+          {
+            "validValues": [
+              "dhcpv6-stateful",
+              "dhcpv6-stateless",
+              "slaac"
+            ]
+          }
+        ],
+        "uniqueId": "org.openecomp.datatypes.heat.network.neutron.Subnet.datatype.ipv6_address_mode",
+        "type": "string",
+        "required": false,
+        "definition": false,
+        "description": "IPv6 address mode",
+        "password": false,
+        "name": "ipv6_address_mode",
+        "hidden": false,
+        "immutable": false,
+        "toscaPresentation": {}
+      },
+      {
+        "constraints": [
+          {
+            "validValues": [
+              "dhcpv6-stateful",
+              "dhcpv6-stateless",
+              "slaac"
+            ]
+          }
+        ],
+        "uniqueId": "org.openecomp.datatypes.heat.network.neutron.Subnet.datatype.ipv6_ra_mode",
+        "type": "string",
+        "required": false,
+        "definition": false,
+        "description": "IPv6 RA (Router Advertisement) mode",
+        "password": false,
+        "name": "ipv6_ra_mode",
+        "hidden": false,
+        "immutable": false,
+        "toscaPresentation": {}
+      },
+      {
+        "uniqueId": "org.openecomp.datatypes.heat.network.neutron.Subnet.datatype.value_specs",
+        "type": "map",
+        "required": false,
+        "definition": false,
+        "defaultValue": "{}",
+        "description": "Extra parameters to include in the request",
+        "schema": {
+          "property": {
+            "constraints": [
+              {
+                "validValues": [
+                  "dhcpv6-stateful",
+                  "dhcpv6-stateless",
+                  "slaac"
+                ]
+              }
+            ],
+            "type": "string",
+            "required": true,
+            "definition": false,
+            "password": false,
+            "hidden": false,
+            "immutable": false,
+            "toscaPresentation": {}
+          },
+          "toscaPresentation": {}
+        },
+        "password": false,
+        "name": "value_specs",
+        "hidden": false,
+        "immutable": false,
+        "toscaPresentation": {}
+      },
+      {
+        "uniqueId": "org.openecomp.datatypes.heat.network.neutron.Subnet.datatype.allocation_pools",
+        "type": "list",
+        "required": false,
+        "definition": false,
+        "description": "The start and end addresses for the allocation pools",
+        "schema": {
+          "property": {
+            "type": "string",
+            "required": true,
+            "definition": false,
+            "password": false,
+            "hidden": false,
+            "immutable": false,
+            "toscaPresentation": {}
+          },
+          "toscaPresentation": {}
+        },
+        "password": false,
+        "name": "allocation_pools",
+        "hidden": false,
+        "immutable": false,
+        "toscaPresentation": {}
+      },
+      {
+        "uniqueId": "org.openecomp.datatypes.heat.network.neutron.Subnet.datatype.subnetpool",
+        "type": "string",
+        "required": false,
+        "definition": false,
+        "description": "The name or ID of the subnet pool",
+        "password": false,
+        "name": "subnetpool",
+        "hidden": false,
+        "immutable": false,
+        "toscaPresentation": {}
+      },
+      {
+        "uniqueId": "org.openecomp.datatypes.heat.network.neutron.Subnet.datatype.dns_nameservers",
+        "type": "list",
+        "required": false,
+        "definition": false,
+        "defaultValue": "[]",
+        "description": "A specified set of DNS name servers to be used",
+        "schema": {
+          "property": {
+            "type": "string",
+            "required": true,
+            "definition": false,
+            "password": false,
+            "hidden": false,
+            "immutable": false,
+            "toscaPresentation": {}
+          },
+          "toscaPresentation": {}
+        },
+        "password": false,
+        "name": "dns_nameservers",
+        "hidden": false,
+        "immutable": false,
+        "toscaPresentation": {}
+      },
+      {
+        "uniqueId": "org.openecomp.datatypes.heat.network.neutron.Subnet.datatype.host_routes",
+        "type": "list",
+        "required": false,
+        "definition": false,
+        "description": "The gateway IP address",
+        "schema": {
+          "property": {
+            "type": "org.openecomp.datatypes.heat.network.subnet.HostRoute",
+            "required": true,
+            "definition": false,
+            "password": false,
+            "hidden": false,
+            "immutable": false,
+            "toscaPresentation": {}
+          },
+          "toscaPresentation": {}
+        },
+        "password": false,
+        "name": "host_routes",
+        "hidden": false,
+        "immutable": false,
+        "toscaPresentation": {}
+      },
+      {
+        "constraints": [
+          {
+            "validValues": [
+              "4",
+              "6"
+            ]
+          }
+        ],
+        "uniqueId": "org.openecomp.datatypes.heat.network.neutron.Subnet.datatype.ip_version",
+        "type": "integer",
+        "required": false,
+        "definition": false,
+        "defaultValue": "4",
+        "description": "The gateway IP address",
+        "password": false,
+        "name": "ip_version",
+        "hidden": false,
+        "immutable": false,
+        "toscaPresentation": {}
+      },
+      {
+        "uniqueId": "org.openecomp.datatypes.heat.network.neutron.Subnet.datatype.name",
+        "type": "string",
+        "required": false,
+        "definition": false,
+        "description": "The name of the subnet",
+        "password": false,
+        "name": "name",
+        "hidden": false,
+        "immutable": false,
+        "toscaPresentation": {}
+      },
+      {
+        "constraints": [
+          {
+            "greaterOrEqual": "0"
+          },
+          {
+            "validValues": [
+              "4",
+              "6"
+            ]
+          }
+        ],
+        "uniqueId": "org.openecomp.datatypes.heat.network.neutron.Subnet.datatype.prefixlen",
+        "type": "integer",
+        "required": false,
+        "definition": false,
+        "description": "Prefix length for subnet allocation from subnet pool",
+        "password": false,
+        "name": "prefixlen",
+        "hidden": false,
+        "immutable": false,
+        "toscaPresentation": {}
+      },
+      {
+        "uniqueId": "org.openecomp.datatypes.heat.network.neutron.Subnet.datatype.cidr",
+        "type": "string",
+        "required": false,
+        "definition": false,
+        "description": "The CIDR",
+        "password": false,
+        "name": "cidr",
+        "hidden": false,
+        "immutable": false,
+        "toscaPresentation": {}
+      },
+      {
+        "uniqueId": "org.openecomp.datatypes.heat.network.neutron.Subnet.datatype.gateway_ip",
+        "type": "string",
+        "required": false,
+        "definition": false,
+        "description": "The gateway IP address",
+        "password": false,
+        "name": "gateway_ip",
+        "hidden": false,
+        "immutable": false,
+        "toscaPresentation": {}
+      }
+    ],
+    "name": "org.openecomp.datatypes.heat.network.neutron.Subnet",
+    "uniqueId": "org.openecomp.datatypes.heat.network.neutron.Subnet.datatype",
+    "derivedFromName": "tosca.datatypes.Root",
+    "description": "A subnet represents an IP address block that can be used for assigning IP addresses to virtual instances",
+    "creationTime": 1550136564412,
+    "modificationTime": 1550136564464,
+    "toscaPresentation": {}
+  },
+  "org.openecomp.datatypes.heat.contrailV2.virtual.machine.subInterface.MacAddress": {
+    "derivedFrom": {
+      "name": "tosca.datatypes.Root",
+      "uniqueId": "tosca.datatypes.Root.datatype",
+      "description": "The TOSCA root Data Type all other TOSCA base Data Types derive from",
+      "creationTime": 1550136563278,
+      "modificationTime": 1550136563278,
+      "toscaPresentation": {}
+    },
+    "properties": [
+      {
+        "uniqueId": "org.openecomp.datatypes.heat.contrailV2.virtual.machine.subInterface.MacAddress.datatype.mac_address",
+        "type": "list",
+        "required": false,
+        "definition": false,
+        "description": "Mac Addresses List.",
+        "schema": {
+          "property": {
+            "type": "string",
+            "required": true,
+            "definition": false,
+            "password": false,
+            "hidden": false,
+            "immutable": false,
+            "toscaPresentation": {}
+          },
+          "toscaPresentation": {}
+        },
+        "password": false,
+        "name": "mac_address",
+        "hidden": false,
+        "immutable": false,
+        "toscaPresentation": {}
+      }
+    ],
+    "name": "org.openecomp.datatypes.heat.contrailV2.virtual.machine.subInterface.MacAddress",
+    "uniqueId": "org.openecomp.datatypes.heat.contrailV2.virtual.machine.subInterface.MacAddress.datatype",
+    "derivedFromName": "tosca.datatypes.Root",
+    "description": "Virtual Machine Sub Interface Mac Address.",
+    "creationTime": 1550136565026,
+    "modificationTime": 1550136565030,
+    "toscaPresentation": {}
+  },
+  "org.openecomp.datatypes.heat.contrailV2.network.rule.RuleList": {
+    "derivedFrom": {
+      "name": "tosca.datatypes.Root",
+      "uniqueId": "tosca.datatypes.Root.datatype",
+      "description": "The TOSCA root Data Type all other TOSCA base Data Types derive from",
+      "creationTime": 1550136563278,
+      "modificationTime": 1550136563278,
+      "toscaPresentation": {}
+    },
+    "properties": [
+      {
+        "uniqueId": "org.openecomp.datatypes.heat.contrailV2.network.rule.RuleList.datatype.network_policy_entries_policy_rule",
+        "type": "list",
+        "required": false,
+        "definition": false,
+        "description": "Contrail network rule",
+        "schema": {
+          "property": {
+            "type": "org.openecomp.datatypes.heat.contrailV2.network.rule.Rule",
+            "required": true,
+            "definition": false,
+            "password": false,
+            "hidden": false,
+            "immutable": false,
+            "toscaPresentation": {}
+          },
+          "toscaPresentation": {}
+        },
+        "password": false,
+        "name": "network_policy_entries_policy_rule",
+        "hidden": false,
+        "immutable": false,
+        "toscaPresentation": {}
+      }
+    ],
+    "name": "org.openecomp.datatypes.heat.contrailV2.network.rule.RuleList",
+    "uniqueId": "org.openecomp.datatypes.heat.contrailV2.network.rule.RuleList.datatype",
+    "derivedFromName": "tosca.datatypes.Root",
+    "description": "list of policy rules",
+    "creationTime": 1550136564716,
+    "modificationTime": 1550136564720,
+    "toscaPresentation": {}
+  },
+  "integer": {
+    "derivedFrom": {
+      "name": "tosca.datatypes.Root",
+      "uniqueId": "tosca.datatypes.Root.datatype",
+      "description": "The TOSCA root Data Type all other TOSCA base Data Types derive from",
+      "creationTime": 1550136563278,
+      "modificationTime": 1550136563278,
+      "toscaPresentation": {}
+    },
+    "name": "integer",
+    "uniqueId": "integer.datatype",
+    "derivedFromName": "tosca.datatypes.Root",
+    "creationTime": 1550136564094,
+    "modificationTime": 1550136564094,
+    "toscaPresentation": {}
+  }
+}
+\ No newline at end of file
diff --git a/catalog-dao/src/main/java/org/openecomp/sdc/be/dao/api/ActionStatus.java b/catalog-dao/src/main/java/org/openecomp/sdc/be/dao/api/ActionStatus.java
index 49ee297eca..2a36b05189 100644
--- a/catalog-dao/src/main/java/org/openecomp/sdc/be/dao/api/ActionStatus.java
+++ b/catalog-dao/src/main/java/org/openecomp/sdc/be/dao/api/ActionStatus.java
@@ -21,7 +21,8 @@
 package org.openecomp.sdc.be.dao.api;
 
 public enum ActionStatus {
-    OK, ACCEPTED, CREATED, NO_CONTENT, GENERAL_ERROR, NOT_ALLOWED, MISSING_INFORMATION, RESTRICTED_OPERATION, RESTRICTED_ACCESS, INVALID_CONTENT,
+    OK, ACCEPTED, CREATED, NO_CONTENT, GENERAL_ERROR, NOT_ALLOWED, MISSING_INFORMATION, RESTRICTED_OPERATION,
+	RESTRICTED_ACCESS, INVALID_CONTENT, INVALID_PROPERTY_VALUES,
     // User related
     USER_ALREADY_EXIST, USER_INACTIVE, USER_NOT_FOUND, USER_HAS_ACTIVE_ELEMENTS, INVALID_EMAIL_ADDRESS, INVALID_ROLE, DELETE_USER_ADMIN_CONFLICT, UPDATE_USER_ADMIN_CONFLICT, CANNOT_DELETE_USER_WITH_ACTIVE_ELEMENTS, CANNOT_UPDATE_USER_WITH_ACTIVE_ELEMENTS, INVALID_USER_ID, USER_DEFINED,
     // CapabilityType related
diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/OperationInput.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/OperationInput.java
new file mode 100644
index 0000000000..e11bf9620b
--- /dev/null
+++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/OperationInput.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright © 2016-2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.openecomp.sdc.be.model;
+
+import java.util.List;
+
+import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
+
+public class OperationInput extends OperationInputDefinition {
+    private List<PropertyConstraint> constraints;
+
+    public OperationInput(OperationInputDefinition operationInputDefinition) {
+        super(operationInputDefinition);
+    }
+
+    public List<PropertyConstraint> getConstraints() {
+        return constraints;
+    }
+
+    public void setConstraints(List<PropertyConstraint> constraints) {
+        this.constraints = constraints;
+    }
+}
diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/PropertyConstraint.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/PropertyConstraint.java
index 9a5c52dde4..ff9a6e5018 100644
--- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/PropertyConstraint.java
+++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/PropertyConstraint.java
@@ -21,6 +21,7 @@
 package org.openecomp.sdc.be.model;
 
 import org.openecomp.sdc.be.model.tosca.ToscaType;
+import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintFunctionalException;
 import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintValueDoNotMatchPropertyTypeException;
 import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintViolationException;
 
@@ -31,4 +32,6 @@ public interface PropertyConstraint {
     void validate(Object propertyValue) throws ConstraintViolationException;
 
     void validate(ToscaType toscaType, String propertyTextValue) throws ConstraintViolationException;
+
+	String getErrorMessage(ToscaType toscaType, ConstraintFunctionalException exception, String propertyName);
 }
diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaOperationFacade.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaOperationFacade.java
index 0ee7c9e5bd..10dd919fc7 100644
--- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaOperationFacade.java
+++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaOperationFacade.java
@@ -955,7 +955,7 @@ public class ToscaOperationFacade {
         }
 
         GraphVertex vertex = getVertexEither.left().value();
-        Map<String, PropertyDataDefinition> inputsMap = inputs.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new PropertyDataDefinition(e.getValue())));
+		Map<String, PropertyDefinition> inputsMap = inputs.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new PropertyDefinition(e.getValue())));
 
         StorageOperationStatus status = topologyTemplateOperation.addToscaDataToToscaElement(vertex, EdgeLabelEnum.INPUTS, VertexTypeEnum.INPUTS, inputsMap, JsonPresentationFields.NAME);
 
diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/ToscaType.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/ToscaType.java
index 92c564cad6..6384146df9 100644
--- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/ToscaType.java
+++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/ToscaType.java
@@ -20,9 +20,17 @@
 
 package org.openecomp.sdc.be.model.tosca;
 
+import java.io.IOException;
 import java.text.DateFormat;
 import java.text.ParseException;
+import java.util.List;
 import java.util.Locale;
+import java.util.Map;
+
+import org.codehaus.jackson.map.ObjectMapper;
+import org.codehaus.jackson.type.TypeReference;
+import org.openecomp.sdc.be.model.tosca.constraints.ConstraintUtil;
+import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintValueDoNotMatchPropertyTypeException;
 
 /**
  * The primitive type that TOSCA YAML supports.
@@ -30,31 +38,101 @@ import java.util.Locale;
  * @author mkv
  */
 public enum ToscaType {
-    STRING, INTEGER, FLOAT, BOOLEAN, TIMESTAMP, VERSION;
-
-    public boolean isValidValue(String value) {
-        switch (this) {
-        case BOOLEAN:
-            return value.equalsIgnoreCase("true") || value.equalsIgnoreCase("false");
-        case FLOAT:
-            return isFloat(value);
-        case INTEGER:
-            return isInteger(value);
-        case STRING:
-            return true;
-        case TIMESTAMP:
-            try {
-                DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM, Locale.US).parse(value);
-                return true;
-            } catch (ParseException e) {
-                return false;
-            }
-        case VERSION:
-            return VersionUtil.isValid(value);
-        default:
-            return false;
-        }
-    }
+	STRING("string"),
+	INTEGER("integer"),
+	FLOAT("float"),
+	BOOLEAN("boolean"),
+	TIMESTAMP("timestamp"),
+	VERSION("version"),
+	LIST("list"),
+	MAP("map"),
+	SCALAR_UNIT("scalar-unit"),
+	SCALAR_UNIT_SIZE("scalar-unit.size"),
+	SCALAR_UNIT_TIME("scalar-unit.time"),
+	SCALAR_UNIT_FREQUENCY("scalar-unit.frequency");
+
+	private String type;
+
+	ToscaType(String type) {
+		this.type = type;
+	}
+
+	public String getType() {
+		return type;
+	}
+
+	public ToscaType getToscaType(String typeName) {
+		if (typeName == null) {
+			return null;
+		}
+
+		for (ToscaType type : ToscaType.values()) {
+			if (type.getType().equals(typeName)) {
+				return type;
+			}
+		}
+		return null;
+	}
+
+	public boolean isValidValue(String value) {
+		switch (this) {
+			case BOOLEAN:
+				return value.equalsIgnoreCase("true") || value.equalsIgnoreCase("false");
+			case FLOAT:
+				return isFloat(value);
+			case INTEGER:
+				return isInteger(value);
+			case STRING:
+			case SCALAR_UNIT:
+			case SCALAR_UNIT_SIZE:
+			case SCALAR_UNIT_TIME:
+			case SCALAR_UNIT_FREQUENCY:
+				return true;
+			case TIMESTAMP:
+				try {
+					DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM, Locale.US).parse(value);
+					return true;
+				} catch (ParseException e) {
+					return false;
+				}
+			case VERSION:
+				return VersionUtil.isValid(value);
+			case LIST:
+				return isList(value);
+			case MAP:
+				return isMap(value);
+			default:
+				return false;
+		}
+	}
+
+	private boolean isList(String value) {
+		ObjectMapper objectMapper = new ObjectMapper();
+		try {
+			objectMapper.readValue(value,
+					new TypeReference<List<Object>>() {
+					});
+
+		} catch (IOException e) {
+			return false;
+		}
+
+		return true;
+	}
+
+	private boolean isMap(String value) {
+		ObjectMapper objectMapper = new ObjectMapper();
+		try {
+			objectMapper.readValue(value,
+					new TypeReference<Map<String, Object>>() {
+					});
+
+		} catch (IOException e) {
+			return false;
+		}
+
+		return true;
+	}
 
     private boolean isFloat(String value) {
         try {
@@ -74,31 +152,76 @@ public enum ToscaType {
         return true;
     }
 
-    public Object convert(String value) {
-        switch (this) {
-        case STRING:
-            return value;
-        case BOOLEAN:
-            return Boolean.valueOf(value);
-        case FLOAT:
-            return Double.valueOf(value);
-        case INTEGER:
-            return Long.valueOf(value);
-        case TIMESTAMP:
-            try {
-                return DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM, Locale.US).parse(value);
-            } catch (ParseException e) {
-                throw new IllegalArgumentException("Value must be a valid timestamp", e);
-            }
-        case VERSION:
-            return VersionUtil.parseVersion(value);
-        default:
-            return null;
-        }
-    }
+	public Object convert(String value) {
+		switch (this) {
+			case STRING:
+			case SCALAR_UNIT:
+			case SCALAR_UNIT_SIZE:
+			case SCALAR_UNIT_TIME:
+			case SCALAR_UNIT_FREQUENCY:
+				return value;
+			case BOOLEAN:
+				return Boolean.valueOf(value);
+			case FLOAT:
+				return Double.valueOf(value);
+			case INTEGER:
+				return Long.valueOf(value);
+			case TIMESTAMP:
+				try {
+					return DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM, Locale.US).parse(value);
+				} catch (ParseException e) {
+					throw new IllegalArgumentException("Value must be a valid timestamp", e);
+				}
+			case VERSION:
+				return VersionUtil.parseVersion(value);
+			case LIST:
+				try {
+					return ConstraintUtil.parseToCollection(value, new TypeReference<List<Object>>() {});
+				} catch (ConstraintValueDoNotMatchPropertyTypeException e) {
+					throw new IllegalArgumentException("Value must be a valid timestamp", e);
+				}
+			case MAP:
+				try {
+					return ConstraintUtil.parseToCollection(value, new TypeReference<Map<String, Object>>() {});
+				} catch (ConstraintValueDoNotMatchPropertyTypeException e) {
+					throw new IllegalArgumentException("Value must be a valid timestamp", e);
+				}
+			default:
+				return null;
+		}
+	}
+
+	public static boolean isPrimitiveType(String dataTypeName) {
 
-    @Override
+		if (!ToscaPropertyType.MAP.getType().equals(dataTypeName) && !ToscaPropertyType.LIST.getType()
+				.equals(dataTypeName)) {
+
+			return isValidType(dataTypeName) != null;
+		}
+
+		return false;
+	}
+
+	public static ToscaType isValidType(String typeName) {
+		if (typeName == null) {
+			return null;
+		}
+
+		for (ToscaType type : ToscaType.values()) {
+			if (type.getType().equals(typeName)) {
+				return type;
+			}
+		}
+		return null;
+	}
+
+	@Override
     public String toString() {
         return name().toLowerCase();
     }
+
+	public static boolean isCollectionType(String type) {
+		return ToscaPropertyType.MAP.getType().equals(type)
+				|| ToscaPropertyType.LIST.getType().equals(type);
+	}
 }
diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/AbstractPropertyConstraint.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/AbstractPropertyConstraint.java
index fc96373d62..041a86d283 100644
--- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/AbstractPropertyConstraint.java
+++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/AbstractPropertyConstraint.java
@@ -20,13 +20,20 @@
 
 package org.openecomp.sdc.be.model.tosca.constraints;
 
+import java.util.Arrays;
+
 import org.openecomp.sdc.be.model.PropertyConstraint;
 import org.openecomp.sdc.be.model.tosca.ToscaType;
+import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintFunctionalException;
+import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintValueDoNotMatchPropertyTypeException;
 import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintViolationException;
 import org.openecomp.sdc.be.model.tosca.version.ApplicationVersionException;
 
 public abstract class AbstractPropertyConstraint implements PropertyConstraint {
 
+    private static final String INVALID_VALUE_ERROR_MESSAGE =
+            "Unsupported value provided for %s property supported value type is %s.";
+
     @Override
     public void validate(ToscaType toscaType, String propertyTextValue) throws ConstraintViolationException {
         try {
@@ -36,4 +43,21 @@ public abstract class AbstractPropertyConstraint implements PropertyConstraint {
                     "String value [" + propertyTextValue + "] is not valid for type [" + toscaType + "]", e);
         }
     }
+
+    public String getErrorMessage(ToscaType toscaType,
+								  ConstraintFunctionalException e,
+								  String propertyName,
+								  String errorMessage,
+								  String... propertyValue) {
+        if (e instanceof ConstraintViolationException) {
+            return String.format(errorMessage, propertyName, Arrays.toString(propertyValue));
+        }
+
+        return String.format(INVALID_VALUE_ERROR_MESSAGE, propertyName, toscaType.getType());
+    }
+
+    @Override
+    public void initialize(ToscaType propertyType) throws ConstraintValueDoNotMatchPropertyTypeException {
+        //Initialization not needed for few constraints for now might be needed in future
+    }
 }
diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/ConstraintType.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/ConstraintType.java
index 6fb699124a..d1cc766525 100644
--- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/ConstraintType.java
+++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/ConstraintType.java
@@ -25,9 +25,9 @@ import java.util.List;
 
 public enum ConstraintType {
 
-    EQUAL("equal", "equal"),
+	EQUAL("equal", "equal"),
 
-    IN_RANGE("inRange"),
+	IN_RANGE("inRange","in_range"),
 
     GREATER_THAN("greaterThan", "greater_than"),
 
@@ -35,11 +35,17 @@ public enum ConstraintType {
 
     LESS_OR_EQUAL("lessOrEqual", "less_or_equal"),
 
+    LENGTH("length", "length"),
+
     MIN_LENGTH("minLength", "min_length"),
 
+    MAX_LENGTH("maxLength", "max_length"),
+
     VALID_VALUES("validValues", "valid_values"),
 
-    LESS_THAN("lessThan", "less_than");
+    LESS_THAN("lessThan", "less_than"),
+
+    SCHEMA("schema", "schema");
 
     List<String> types;
 
diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/ConstraintUtil.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/ConstraintUtil.java
index 3c1f0ab711..0bbc0f755f 100644
--- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/ConstraintUtil.java
+++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/ConstraintUtil.java
@@ -20,19 +20,26 @@
 
 package org.openecomp.sdc.be.model.tosca.constraints;
 
-import org.openecomp.sdc.be.model.tosca.ToscaType;
-import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintValueDoNotMatchPropertyTypeException;
-
 import java.beans.IntrospectionException;
 import java.beans.Introspector;
 import java.beans.PropertyDescriptor;
+import java.io.IOException;
 import java.lang.reflect.InvocationTargetException;
 
+import org.codehaus.jackson.map.ObjectMapper;
+import org.codehaus.jackson.type.TypeReference;
+import org.openecomp.sdc.be.model.tosca.ToscaType;
+import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintValueDoNotMatchPropertyTypeException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * Utility class to validate constraints types.
  */
 public final class ConstraintUtil {
 
+    private static final Logger logger = LoggerFactory.getLogger(ConstraintUtil.class);
+
     private ConstraintUtil() {
     }
 
@@ -46,7 +53,7 @@ public final class ConstraintUtil {
      *             In case the type is not {@link ToscaType#STRING}.
      */
     public static void checkStringType(ToscaType propertyType) throws ConstraintValueDoNotMatchPropertyTypeException {
-        if (!ToscaType.STRING.equals(propertyType)) {
+        if (ToscaType.STRING != propertyType) {
             throw new ConstraintValueDoNotMatchPropertyTypeException(
                     "Invalid property type <" + propertyType.toString() + ">");
         }
@@ -95,8 +102,7 @@ public final class ConstraintUtil {
      *             if the converted value is not a comparable
      */
     @SuppressWarnings("rawtypes")
-    public static Comparable convertToComparable(ToscaType propertyType, String value)
-            throws ConstraintValueDoNotMatchPropertyTypeException {
+    public static Comparable convertToComparable(ToscaType propertyType, String value) {
         Object comparableObj = propertyType.convert(value);
         if (!(comparableObj instanceof Comparable)) {
             throw new IllegalArgumentException(
@@ -142,4 +148,18 @@ public final class ConstraintUtil {
             throw new IntrospectionException("Cannot retrieve constraint reference " + e.getMessage());
         }
     }
+
+    public static <T> T parseToCollection(String value, TypeReference<T> typeReference)
+            throws ConstraintValueDoNotMatchPropertyTypeException {
+        T objectMap;
+        ObjectMapper objectMapper = new ObjectMapper();
+        try {
+            objectMap = objectMapper.readValue(value, typeReference);
+        } catch (IOException e) {
+            logger.error(e.getMessage(), e);
+            throw new ConstraintValueDoNotMatchPropertyTypeException("The value [" + value + "] is not valid");
+        }
+
+        return objectMap;
+    }
 }
diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/EqualConstraint.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/EqualConstraint.java
index 7ae64e0ccf..206fc3dc82 100644
--- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/EqualConstraint.java
+++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/EqualConstraint.java
@@ -7,9 +7,9 @@
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -20,34 +20,41 @@
 
 package org.openecomp.sdc.be.model.tosca.constraints;
 
+import java.io.Serializable;
+
 import org.openecomp.sdc.be.model.tosca.ToscaType;
+import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintFunctionalException;
 import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintValueDoNotMatchPropertyTypeException;
 import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintViolationException;
 
 import javax.validation.constraints.NotNull;
 
-public class EqualConstraint extends AbstractPropertyConstraint {
-
-    @NotNull
-    private String equal;
+@SuppressWarnings("serial")
+public class EqualConstraint extends AbstractPropertyConstraint implements Serializable {
 
-    // @JsonIgnore
+	@NotNull
+	private String constraintValue;
     private Object typed;
 
-    public EqualConstraint(String equal) {
-        super();
-        this.equal = equal;
-    }
+	public EqualConstraint(String constraintValue) {
+		super();
+		this.constraintValue = constraintValue;
+	}
 
-    @Override
-    public void initialize(ToscaType propertyType) throws ConstraintValueDoNotMatchPropertyTypeException {
-        if (propertyType.isValidValue(equal)) {
-            typed = propertyType.convert(equal);
-        } else {
-            throw new ConstraintValueDoNotMatchPropertyTypeException("equal constraint has invalid value <" + equal
-                    + "> property type is <" + propertyType.toString() + ">");
-        }
-    }
+	public String getConstraintValue() {
+		return constraintValue;
+	}
+
+	@Override
+	public void initialize(ToscaType propertyType) throws ConstraintValueDoNotMatchPropertyTypeException {
+		if (propertyType.isValidValue(constraintValue)) {
+			typed = propertyType.convert(constraintValue);
+		} else {
+            throw new ConstraintValueDoNotMatchPropertyTypeException(
+                    "constraintValue constraint has invalid value <" + constraintValue
+                            + "> property type is <" + propertyType.toString() + ">");
+		}
+	}
 
     @Override
     public void validate(Object propertyValue) throws ConstraintViolationException {
@@ -57,13 +64,20 @@ public class EqualConstraint extends AbstractPropertyConstraint {
             }
         } else if (typed == null) {
             fail(propertyValue);
+        } else if (typed instanceof Comparable && typed != propertyValue) {
+            fail(propertyValue);
         } else if (!typed.equals(propertyValue)) {
             fail(propertyValue);
         }
     }
 
-    private void fail(Object propertyValue) throws ConstraintViolationException {
-        throw new ConstraintViolationException("Equal constraint violation, the reference is <" + equal
-                + "> but the value to compare is <" + propertyValue + ">");
+	private void fail(Object propertyValue) throws ConstraintViolationException {
+		throw new ConstraintViolationException("Equal constraint violation, the reference is <" + constraintValue
+													   + "> but the value to compare is <" + propertyValue + ">");
+	}
+
+	@Override
+	public String getErrorMessage(ToscaType toscaType, ConstraintFunctionalException e, String propertyName) {
+	    return getErrorMessage(toscaType, e, propertyName, "%s property value must be %s", constraintValue);
     }
 }
diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/GreaterOrEqualConstraint.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/GreaterOrEqualConstraint.java
index 63d7ed8872..6549bbc432 100644
--- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/GreaterOrEqualConstraint.java
+++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/GreaterOrEqualConstraint.java
@@ -21,6 +21,7 @@
 package org.openecomp.sdc.be.model.tosca.constraints;
 
 import org.openecomp.sdc.be.model.tosca.ToscaType;
+import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintFunctionalException;
 import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintValueDoNotMatchPropertyTypeException;
 import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintViolationException;
 
@@ -46,4 +47,9 @@ public class GreaterOrEqualConstraint extends AbstractComparablePropertyConstrai
             throw new ConstraintViolationException(propertyValue + " <= " + greaterOrEqual);
         }
     }
+
+    @Override
+    public String getErrorMessage(ToscaType toscaType, ConstraintFunctionalException e, String propertyName) {
+        return getErrorMessage(toscaType, e, propertyName, "%f property value must be >= %f", greaterOrEqual);
+    }
 }
diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/GreaterThanConstraint.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/GreaterThanConstraint.java
index b599a16a10..a278e8c7b9 100644
--- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/GreaterThanConstraint.java
+++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/GreaterThanConstraint.java
@@ -21,6 +21,7 @@
 package org.openecomp.sdc.be.model.tosca.constraints;
 
 import org.openecomp.sdc.be.model.tosca.ToscaType;
+import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintFunctionalException;
 import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintValueDoNotMatchPropertyTypeException;
 import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintViolationException;
 
@@ -28,13 +29,13 @@ import javax.validation.constraints.NotNull;
 
 public class GreaterThanConstraint extends AbstractComparablePropertyConstraint {
 
+    @NotNull
+    private String greaterThan;
+
     public GreaterThanConstraint(String greaterThan) {
         this.greaterThan = greaterThan;
     }
 
-    @NotNull
-    private String greaterThan;
-
     @Override
     public void initialize(ToscaType propertyType) throws ConstraintValueDoNotMatchPropertyTypeException {
         initialize(greaterThan, propertyType);
@@ -55,4 +56,8 @@ public class GreaterThanConstraint extends AbstractComparablePropertyConstraint
         this.greaterThan = greaterThan;
     }
 
+    @Override
+    public String getErrorMessage(ToscaType toscaType, ConstraintFunctionalException e, String propertyName) {
+        return getErrorMessage(toscaType, e, propertyName, "%f property value must be > %f", greaterThan);
+    }
 }
diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/InRangeConstraint.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/InRangeConstraint.java
index 19a2fe4230..ad3d3525d0 100644
--- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/InRangeConstraint.java
+++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/InRangeConstraint.java
@@ -21,12 +21,15 @@
 package org.openecomp.sdc.be.model.tosca.constraints;
 
 import com.google.common.collect.Lists;
+
+import java.util.List;
+
 import org.openecomp.sdc.be.model.tosca.ToscaType;
+import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintFunctionalException;
 import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintValueDoNotMatchPropertyTypeException;
 import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintViolationException;
 
 import javax.validation.constraints.NotNull;
-import java.util.List;
 
 public class InRangeConstraint extends AbstractPropertyConstraint {
 
@@ -111,4 +114,10 @@ public class InRangeConstraint extends AbstractPropertyConstraint {
         }
     }
 
+    @Override
+    public String getErrorMessage(ToscaType toscaType, ConstraintFunctionalException e, String propertyName) {
+        return getErrorMessage(toscaType, e, propertyName, "%f property value must be between >= [%s] and <= [%s]",
+                String.valueOf(min), String.valueOf(max));
+    }
+
 }
diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/LengthConstraint.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/LengthConstraint.java
index c07ac7e2e3..0c5317b10b 100644
--- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/LengthConstraint.java
+++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/LengthConstraint.java
@@ -20,22 +20,42 @@
 
 package org.openecomp.sdc.be.model.tosca.constraints;
 
+import java.util.List;
+import java.util.Map;
+
+import org.openecomp.sdc.be.model.tosca.ToscaType;
+import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintFunctionalException;
 import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintViolationException;
 
 import javax.validation.constraints.NotNull;
 
-public class LengthConstraint extends AbstractStringPropertyConstraint {
+public class LengthConstraint extends AbstractPropertyConstraint {
 
     @NotNull
     private Integer length;
 
-    @Override
-    protected void doValidate(String propertyValue) throws ConstraintViolationException {
-        if (propertyValue.length() != length) {
+    protected void doValidate(Object propertyValue) throws ConstraintViolationException {
+        if (propertyValue instanceof String && String.valueOf(propertyValue).length() != length) {
             throw new ConstraintViolationException("The length of the value is not equals to [" + length + "]");
+        } else if (propertyValue instanceof List && ((List) propertyValue).size()  != length) {
+            throw new ConstraintViolationException("The size of the list is not equals to [" + length + "]");
+        } else if (propertyValue instanceof Map && ((Map) propertyValue).size()  != length) {
+            throw new ConstraintViolationException("The size of the map is not equals to [" + length + "]");
         }
     }
 
+    public void validate(Object propertyValue) throws ConstraintViolationException {
+        if (propertyValue == null) {
+            throw new ConstraintViolationException("Value to validate is null");
+        }
+
+        if(!(propertyValue instanceof String || propertyValue instanceof List || propertyValue instanceof Map)) {
+            throw new ConstraintViolationException("This constraint can only be applied on String/List/Map value");
+        }
+
+        doValidate(propertyValue);
+    }
+
     public Integer getLength() {
         return length;
     }
@@ -44,4 +64,9 @@ public class LengthConstraint extends AbstractStringPropertyConstraint {
         this.length = length;
     }
 
+    @Override
+    public String getErrorMessage(ToscaType toscaType, ConstraintFunctionalException e, String propertyName) {
+        return getErrorMessage(toscaType, e, propertyName, "%s length must be %s", String.valueOf(length));
+    }
+
 }
diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/LessOrEqualConstraint.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/LessOrEqualConstraint.java
index 7d61dd31df..3f085ec596 100644
--- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/LessOrEqualConstraint.java
+++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/LessOrEqualConstraint.java
@@ -21,6 +21,7 @@
 package org.openecomp.sdc.be.model.tosca.constraints;
 
 import org.openecomp.sdc.be.model.tosca.ToscaType;
+import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintFunctionalException;
 import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintValueDoNotMatchPropertyTypeException;
 import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintViolationException;
 
@@ -30,7 +31,6 @@ public class LessOrEqualConstraint extends AbstractComparablePropertyConstraint
 
     @NotNull
     private String lessOrEqual;
-
     public LessOrEqualConstraint(String lessOrEqual) {
         this.lessOrEqual = lessOrEqual;
     }
@@ -55,4 +55,8 @@ public class LessOrEqualConstraint extends AbstractComparablePropertyConstraint
         this.lessOrEqual = lessOrEqual;
     }
 
+    @Override
+    public String getErrorMessage(ToscaType toscaType, ConstraintFunctionalException e, String propertyName) {
+        return getErrorMessage(toscaType, e, propertyName, "%s property value must be <= %s", lessOrEqual);
+    }
 }
diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/LessThanConstraint.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/LessThanConstraint.java
index e2db77b45a..01eb6cdc32 100644
--- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/LessThanConstraint.java
+++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/LessThanConstraint.java
@@ -21,6 +21,7 @@
 package org.openecomp.sdc.be.model.tosca.constraints;
 
 import org.openecomp.sdc.be.model.tosca.ToscaType;
+import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintFunctionalException;
 import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintValueDoNotMatchPropertyTypeException;
 import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintViolationException;
 
@@ -47,4 +48,8 @@ public class LessThanConstraint extends AbstractComparablePropertyConstraint {
         }
     }
 
+    @Override
+    public String getErrorMessage(ToscaType toscaType, ConstraintFunctionalException e, String propertyName) {
+        return getErrorMessage(toscaType, e, propertyName, "%s value must be < %s", lessThan);
+    }
 }
diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/MaxLengthConstraint.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/MaxLengthConstraint.java
index 8b7ce49cbc..c8fef91ea6 100644
--- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/MaxLengthConstraint.java
+++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/MaxLengthConstraint.java
@@ -7,9 +7,9 @@
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -20,11 +20,16 @@
 
 package org.openecomp.sdc.be.model.tosca.constraints;
 
+import java.util.List;
+import java.util.Map;
+
+import org.openecomp.sdc.be.model.tosca.ToscaType;
+import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintFunctionalException;
 import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintViolationException;
 
 import javax.validation.constraints.NotNull;
 
-public class MaxLengthConstraint extends AbstractStringPropertyConstraint {
+public class MaxLengthConstraint extends AbstractPropertyConstraint {
 
     @NotNull
     private Integer maxLength;
@@ -37,10 +42,13 @@ public class MaxLengthConstraint extends AbstractStringPropertyConstraint {
         super();
     }
 
-    @Override
-    protected void doValidate(String propertyValue) throws ConstraintViolationException {
-        if (propertyValue.length() > maxLength) {
+    protected void doValidate(Object propertyValue) throws ConstraintViolationException {
+        if (propertyValue instanceof String && String.valueOf(propertyValue).length() > maxLength) {
             throw new ConstraintViolationException("The length of the value is greater than [" + maxLength + "]");
+        } else if (propertyValue instanceof List && ((List) propertyValue).size() > maxLength) {
+            throw new ConstraintViolationException("The size of the list is greater than [" + maxLength + "]");
+        } else if (propertyValue instanceof Map && ((Map) propertyValue).size() > maxLength) {
+            throw new ConstraintViolationException("The size of the map is greater than [" + maxLength + "]");
         }
     }
 
@@ -51,4 +59,22 @@ public class MaxLengthConstraint extends AbstractStringPropertyConstraint {
     public void setMaxLength(Integer maxLength) {
         this.maxLength = maxLength;
     }
+
+    @Override
+    public void validate(Object propertyValue) throws ConstraintViolationException {
+        if (propertyValue == null) {
+            throw new ConstraintViolationException("Value to validate is null");
+        }
+
+        if(!(propertyValue instanceof String || propertyValue instanceof List || propertyValue instanceof Map)) {
+            throw new ConstraintViolationException("This constraint can only be applied on String/List/Map value");
+        }
+
+        doValidate(propertyValue);
+    }
+
+    @Override
+    public String getErrorMessage(ToscaType toscaType, ConstraintFunctionalException e, String propertyName) {
+        return getErrorMessage(toscaType, e, propertyName, "%s maximum length must be [%s]", String.valueOf(maxLength));
+    }
 }
diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/MinLengthConstraint.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/MinLengthConstraint.java
index bc51f4fa5a..4f55970d79 100644
--- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/MinLengthConstraint.java
+++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/MinLengthConstraint.java
@@ -20,11 +20,16 @@
 
 package org.openecomp.sdc.be.model.tosca.constraints;
 
+import java.util.List;
+import java.util.Map;
+
+import org.openecomp.sdc.be.model.tosca.ToscaType;
+import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintFunctionalException;
 import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintViolationException;
 
 import javax.validation.constraints.NotNull;
 
-public class MinLengthConstraint extends AbstractStringPropertyConstraint {
+public class MinLengthConstraint extends AbstractPropertyConstraint {
 
     @NotNull
     private Integer minLength;
@@ -37,10 +42,13 @@ public class MinLengthConstraint extends AbstractStringPropertyConstraint {
         super();
     }
 
-    @Override
-    protected void doValidate(String propertyValue) throws ConstraintViolationException {
-        if (propertyValue.length() < minLength) {
+    protected void doValidate(Object propertyValue) throws ConstraintViolationException {
+        if (propertyValue instanceof String && String.valueOf(propertyValue).length() < minLength) {
             throw new ConstraintViolationException("The length of the value is less than [" + minLength + "]");
+        } else if (propertyValue instanceof List && ((List) propertyValue).size()  < minLength) {
+            throw new ConstraintViolationException("The size of the list is less than [" + minLength + "]");
+        } else if (propertyValue instanceof Map && ((Map) propertyValue).size()  < minLength) {
+            throw new ConstraintViolationException("The size of the map is less than [" + minLength + "]");
         }
     }
 
@@ -52,4 +60,19 @@ public class MinLengthConstraint extends AbstractStringPropertyConstraint {
         this.minLength = minLength;
     }
 
+    @Override
+    public void validate(Object propertyValue) throws ConstraintViolationException {
+        if (propertyValue == null) {
+            throw new ConstraintViolationException("Value to validate is null");
+        }
+        if(!(propertyValue instanceof String || propertyValue instanceof List || propertyValue instanceof Map)) {
+            throw new ConstraintViolationException("This constraint can only be applied on String/List/Map value");
+        }
+        doValidate(propertyValue);
+    }
+
+    @Override
+    public String getErrorMessage(ToscaType toscaType, ConstraintFunctionalException e, String propertyName) {
+        return getErrorMessage(toscaType, e, propertyName, "%s minimum length must be [%s]", String.valueOf(minLength));
+    }
 }
diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/PatternConstraint.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/PatternConstraint.java
index db26c33440..d3644c578d 100644
--- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/PatternConstraint.java
+++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/PatternConstraint.java
@@ -20,10 +20,13 @@
 
 package org.openecomp.sdc.be.model.tosca.constraints;
 
+import java.util.regex.Pattern;
+
+import org.openecomp.sdc.be.model.tosca.ToscaType;
+import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintFunctionalException;
 import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintViolationException;
 
 import javax.validation.constraints.NotNull;
-import java.util.regex.Pattern;
 
 public class PatternConstraint extends AbstractStringPropertyConstraint {
 
@@ -43,4 +46,10 @@ public class PatternConstraint extends AbstractStringPropertyConstraint {
             throw new ConstraintViolationException("The value do not match pattern " + pattern);
         }
     }
+
+    @Override
+    public String getErrorMessage(ToscaType toscaType, ConstraintFunctionalException e, String propertyName) {
+        return getErrorMessage(toscaType, e, propertyName, "%s property value must match the regular expression %s",
+                pattern);
+    }
 }
diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/ValidValuesConstraint.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/ValidValuesConstraint.java
index 0b35a9be8e..1ddf9c9e0e 100644
--- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/ValidValuesConstraint.java
+++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/constraints/ValidValuesConstraint.java
@@ -21,13 +21,16 @@
 package org.openecomp.sdc.be.model.tosca.constraints;
 
 import com.google.common.collect.Sets;
+
+import java.util.List;
+import java.util.Set;
+
 import org.openecomp.sdc.be.model.tosca.ToscaType;
+import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintFunctionalException;
 import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintValueDoNotMatchPropertyTypeException;
 import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintViolationException;
 
 import javax.validation.constraints.NotNull;
-import java.util.List;
-import java.util.Set;
 
 public class ValidValuesConstraint extends AbstractPropertyConstraint {
 
@@ -77,4 +80,9 @@ public class ValidValuesConstraint extends AbstractPropertyConstraint {
         this.validValues = validValues;
     }
 
+    @Override
+    public String getErrorMessage(ToscaType toscaType, ConstraintFunctionalException e, String propertyName) {
+        return getErrorMessage(toscaType, e, propertyName, "%s valid value must be one of the following: [%s]",
+                String.join(",", validValues));
+    }
 }
diff --git a/catalog-ui/src/app/models/properties-inputs/property-be-model.ts b/catalog-ui/src/app/models/properties-inputs/property-be-model.ts
index aa68551950..a1a85aa73d 100644
--- a/catalog-ui/src/app/models/properties-inputs/property-be-model.ts
+++ b/catalog-ui/src/app/models/properties-inputs/property-be-model.ts
@@ -28,12 +28,12 @@ export enum DerivedPropertyType {
 }
 
 export class PropertyBEModel {
-
+    constraints: Array<any>;
     defaultValue: string;
     definition: boolean;
     description: string;
     fromDerived: boolean;
-    getInputValues: Array<PropertyInputDetail>
+    getInputValues: Array<PropertyInputDetail>;
     name: string;
     parentUniqueId: string;
     password: boolean;
@@ -43,9 +43,12 @@ export class PropertyBEModel {
     type: string;
     uniqueId: string;
     value: string;
+    parentPropertyType: string;
+    subPropertyInputPath: string;
 
     constructor(property?: PropertyBEModel) {
         if (property) {
+            this.constraints = property.constraints;
             this.defaultValue = property.defaultValue;
             this.description = property.description;
             this.fromDerived = property.fromDerived;
@@ -60,6 +63,8 @@ export class PropertyBEModel {
             this.value = property.value;
             this.definition = property.definition;
             this.getInputValues = property.getInputValues;
+            this.parentPropertyType = property.parentPropertyType;
+            this.subPropertyInputPath = property.subPropertyInputPath;
         }
 
         if (!this.schema || !this.schema.property) {
diff --git a/catalog-ui/src/app/models/properties.ts b/catalog-ui/src/app/models/properties.ts
index a629140cb8..016c5b9f20 100644
--- a/catalog-ui/src/app/models/properties.ts
+++ b/catalog-ui/src/app/models/properties.ts
@@ -40,7 +40,6 @@ export class PropertiesGroup {
 export interface IPropertyModel extends InputPropertyBase {
 
     //server data
-    constraints:Array<Object>;
     source:string;
 
     //instance properties
@@ -60,7 +59,6 @@ export class PropertyModel extends PropertyBEModel implements IPropertyModel {
     //server data
     uniqueId:string;
     name:string;
-    constraints:Array<Object>;
     defaultValue:string;
     description:string;
     password:boolean;
@@ -93,7 +91,6 @@ export class PropertyModel extends PropertyBEModel implements IPropertyModel {
     constructor(property?:PropertyModel) {
         super(property);
         if (property) {
-            this.constraints = property.constraints;
             this.source = property.source;
             this.valueUniqueUid = property.valueUniqueUid;
             this.path = property.path;
diff --git a/catalog-ui/src/app/ng2/components/logic/inputs-table/inputs-table.component.html b/catalog-ui/src/app/ng2/components/logic/inputs-table/inputs-table.component.html
index 65873a35a5..3ef1f57bf2 100644
--- a/catalog-ui/src/app/ng2/components/logic/inputs-table/inputs-table.component.html
+++ b/catalog-ui/src/app/ng2/components/logic/inputs-table/inputs-table.component.html
@@ -57,6 +57,7 @@
                                      pattern="validationUtils.getValidationPattern(input.type)"
                                      [value]="input.defaultValueObj"
                                      [type]="input.type"
+                                     [constraints]="input.constraints"
                                      [name]="input.name"
                                      (elementChanged)="onInputChanged(input, $event)"
                                      [readonly]="readonly"
diff --git a/catalog-ui/src/app/ng2/components/logic/properties-table/dynamic-property/dynamic-property.component.html b/catalog-ui/src/app/ng2/components/logic/properties-table/dynamic-property/dynamic-property.component.html
index 3f87b070e8..c4639aeda0 100644
--- a/catalog-ui/src/app/ng2/components/logic/properties-table/dynamic-property/dynamic-property.component.html
+++ b/catalog-ui/src/app/ng2/components/logic/properties-table/dynamic-property/dynamic-property.component.html
@@ -51,6 +51,7 @@
                 [childType]="property.schema.property.type"
                 [name]="property.name"
                 [path]="property.propertiesName"
+                [constraints]="property.constraints"
                 (elementChanged)="onElementChanged($event)"
                 [readonly]="readonly || property.isDeclared || property.isDisabled"
                 [testId]="'prop-' + propertyTestsId"
diff --git a/catalog-ui/src/app/ng2/components/logic/service-consumption/service-consumption.component.ts b/catalog-ui/src/app/ng2/components/logic/service-consumption/service-consumption.component.ts
index b0f6dfb649..ef8d63df97 100644
--- a/catalog-ui/src/app/ng2/components/logic/service-consumption/service-consumption.component.ts
+++ b/catalog-ui/src/app/ng2/components/logic/service-consumption/service-consumption.component.ts
@@ -39,6 +39,7 @@ export class ConsumptionInput extends PropertyFEModel{
     type: string;
     source: string;
     value: any;
+    constraints: Array<any>;
 
     constructor(input?: any) {
         super(input);
@@ -47,6 +48,7 @@ export class ConsumptionInput extends PropertyFEModel{
             this.type = input.type;
             this.source = input.source;
             this.value = input.value || "";
+            this.constraints = input.constraints;
         }
     }
 }
diff --git a/catalog-ui/src/app/ng2/components/ui/dynamic-element/dynamic-element.component.ts b/catalog-ui/src/app/ng2/components/ui/dynamic-element/dynamic-element.component.ts
index 4f283fb3f1..049d40831a 100644
--- a/catalog-ui/src/app/ng2/components/ui/dynamic-element/dynamic-element.component.ts
+++ b/catalog-ui/src/app/ng2/components/ui/dynamic-element/dynamic-element.component.ts
@@ -22,7 +22,7 @@
 
 import * as _ from "lodash";
 import { Component, Compiler, EventEmitter, ViewContainerRef, ViewChild, Input, Output, ElementRef, ComponentRef, ComponentFactoryResolver } from '@angular/core'
-import {ValidationConfiguration} from "app/models";
+import {ValidationConfiguration, PropertyFEModel} from "app/models";
 import {IUiElementChangeEvent} from "../form-components/ui-element-base.component";
 import {UiElementInputComponent} from "../form-components/input/ui-element-input.component";
 import {UiElementPopoverInputComponent} from "../form-components/popover-input/ui-element-popover-input.component";
@@ -36,6 +36,7 @@ enum DynamicElementComponentCreatorIdentifier {
     FLOAT,
     BOOLEAN,
     SUBNETPOOLID,
+    ENUM,
     DEFAULT
 }
 
@@ -58,6 +59,7 @@ export class DynamicElementComponent {
     @Input() name: string;
     @Input() testId: string;
     @Input() readonly:boolean;
+    @Input() constraints: Array<any>;
     @Input() path:string;//optional param. used only for for subnetpoolid type
 
     @Input() value: any;
@@ -86,6 +88,9 @@ export class DynamicElementComponent {
             case this.path && this.path.toUpperCase().indexOf("SUBNETPOOLID") !== -1:
                 this.elementCreatorIdentifier = DynamicElementComponentCreatorIdentifier.SUBNETPOOLID;
                 break;
+            case this.getValidValues() !== undefined && this.getValidValues() !== null:
+                this.elementCreatorIdentifier = DynamicElementComponentCreatorIdentifier.ENUM;
+                break;
             case this.type === 'integer':
                 this.elementCreatorIdentifier = DynamicElementComponentCreatorIdentifier.INTEGER;
                 break;
@@ -153,6 +158,19 @@ export class DynamicElementComponent {
                 this.createComponent(UiElementPopoverInputComponent);
                 break;
 
+            case DynamicElementComponentCreatorIdentifier.ENUM:
+                this.createComponent(UiElementDropDownComponent);
+                let validVals:Array<DropdownValue> = [...this.getValidValues()].map(val => new DropdownValue(val, val));
+                if (this.type === 'float' || this.type === 'integer') {
+                    this.value = this.value && Number(this.value);
+                    validVals = _.map(
+                        validVals,
+                        val => new DropdownValue(Number(val.value), val.value)
+                    );
+                }
+                this.cmpRef.instance.values = validVals;
+                break;
+
             case DynamicElementComponentCreatorIdentifier.INTEGER:
                 this.createComponent(UiElementIntegerInputComponent);
                 this.cmpRef.instance.pattern = this.validation.validationPatterns.integer;
@@ -195,6 +213,14 @@ export class DynamicElementComponent {
         this.cmpRef.instance.valueChange.subscribe((event) => { this.valueChange.emit(event); });
     }
 
+    getValidValues(): Array<string> {
+        let validVals;
+        _.forEach(this.constraints, constraint => {
+            validVals = validVals || constraint.validValues;
+        });
+        return validVals;
+    }
+
     createComponent(ComponentToCreate:any):void {
         let factory = this.componentFactoryResolver.resolveComponentFactory(ComponentToCreate);
         this.cmpRef = this.target.createComponent(factory);
diff --git a/catalog-ui/src/app/ng2/pages/interface-operation/interface-operation.page.component.ts b/catalog-ui/src/app/ng2/pages/interface-operation/interface-operation.page.component.ts
index 9035b3ff50..97c7b4d959 100644
--- a/catalog-ui/src/app/ng2/pages/interface-operation/interface-operation.page.component.ts
+++ b/catalog-ui/src/app/ng2/pages/interface-operation/interface-operation.page.component.ts
@@ -136,7 +136,7 @@ export class InterfaceOperationComponent {
 
     ngOnInit(): void {
         this.isLoading = true;
-        this.workflowIsOnline = !_.isUndefined(this.PluginsService.getPluginByStateUrl('workflowDesigner'));
+        this.workflowIsOnline = false;//!_.isUndefined(this.PluginsService.getPluginByStateUrl('workflowDesigner'));
         const workflowSubscription = this.enableWorkflowAssociation && this.workflowIsOnline ? this.WorkflowServiceNg2.getWorkflows() : Promise.resolve();
         Observable.forkJoin(
             this.ComponentServiceNg2.getInterfaces(this.component),
diff --git a/catalog-ui/src/app/ng2/pages/properties-assignment/properties-assignment.page.component.ts b/catalog-ui/src/app/ng2/pages/properties-assignment/properties-assignment.page.component.ts
index 953c973d1a..615325559e 100644
--- a/catalog-ui/src/app/ng2/pages/properties-assignment/properties-assignment.page.component.ts
+++ b/catalog-ui/src/app/ng2/pages/properties-assignment/properties-assignment.page.component.ts
@@ -126,7 +126,7 @@ export class PropertiesAssignmentComponent {
         this.loadingInstances = true;
         this.loadingProperties = true;
         this.componentServiceNg2
-            .getComponentInputs(this.component)
+            .getComponentInputsWithProperties(this.component)
             .subscribe(response => {
                 _.forEach(response.inputs, (input: InputBEModel) => {
                     const newInput: InputFEModel = new InputFEModel(input);
@@ -468,7 +468,10 @@ export class PropertiesAssignmentComponent {
                         };
                     } else {
                         if (this.isSelf()) {
-                            request = this.componentServiceNg2.updateServiceProperties(this.component, changedProperties);
+                            request = this.componentServiceNg2.updateServiceProperties(this.component, _.map(changedProperties, cp => {
+                                delete cp.constraints;
+                                return cp;
+                            }));
                         } else {
                             request = this.componentInstanceServiceNg2
                                 .updateInstanceProperties(this.component, this.selectedInstanceData.uniqueId, changedProperties);
diff --git a/catalog-ui/src/app/ng2/pages/properties-assignment/property-creator/property-creator.component.ts b/catalog-ui/src/app/ng2/pages/properties-assignment/property-creator/property-creator.component.ts
index d5946d2e4a..7d76904539 100644
--- a/catalog-ui/src/app/ng2/pages/properties-assignment/property-creator/property-creator.component.ts
+++ b/catalog-ui/src/app/ng2/pages/properties-assignment/property-creator/property-creator.component.ts
@@ -46,7 +46,8 @@ export class PropertyCreatorComponent {
         let nonPrimitiveTypesValues = _.map(nonPrimitiveTypes,
             (type: string) => new DropdownValue(type,
                     type.replace("org.openecomp.datatypes.heat.",""))
-        );
+        )
+        .sort((a, b) => a.label.localeCompare(b.label));
         this.typesProperties = _.concat(this.typesProperties,nonPrimitiveTypesValues);
         this.typesSchemaProperties = _.concat(typesSimpleProperties,nonPrimitiveTypesValues);
         this.typesProperties.unshift(new DropdownValue('','Select Type...'));
diff --git a/catalog-ui/src/app/ng2/pages/service-consumption-editor/service-consumption-editor.component.html b/catalog-ui/src/app/ng2/pages/service-consumption-editor/service-consumption-editor.component.html
index 5d42fa7694..e77d880176 100644
--- a/catalog-ui/src/app/ng2/pages/service-consumption-editor/service-consumption-editor.component.html
+++ b/catalog-ui/src/app/ng2/pages/service-consumption-editor/service-consumption-editor.component.html
@@ -52,6 +52,7 @@
                                 *ngIf="consumptionInput.isSimpleType && (consumptionInput.source === SOURCE_TYPES.STATIC ||  consumptionInput.source === '')"
                                 data-tests-id="inputValue"
                                 [(value)]="consumptionInput.value"
+                                [constraints]="consumptionInput.constraints"
                                 (elementChanged)="onChange($event.value, $event.isValid, consumptionInput)"
                                 [type]="consumptionInput.type">
                         </dynamic-element>
diff --git a/catalog-ui/src/app/ng2/services/component-services/component.service.ts b/catalog-ui/src/app/ng2/services/component-services/component.service.ts
index a25fb75a41..3243291483 100644
--- a/catalog-ui/src/app/ng2/services/component-services/component.service.ts
+++ b/catalog-ui/src/app/ng2/services/component-services/component.service.ts
@@ -108,6 +108,10 @@ export class ComponentServiceNg2 {
         return this.getComponentDataByFieldsName(component.componentType, component.uniqueId, [COMPONENT_FIELDS.COMPONENT_INPUTS]);
     }
 
+    getComponentInputsWithProperties(component:Component):Observable<ComponentGenericResponse> {
+        return this.getComponentDataByFieldsName(component.componentType, component.uniqueId, [COMPONENT_FIELDS.COMPONENT_INPUTS, COMPONENT_FIELDS.COMPONENT_INSTANCES, COMPONENT_FIELDS.COMPONENT_INSTANCES_PROPERTIES, COMPONENT_FIELDS.COMPONENT_PROPERTIES]);
+    }
+
     getComponentDeploymentArtifacts(component:Component):Observable<ComponentGenericResponse> {
         return this.getComponentDataByFieldsName(component.componentType, component.uniqueId, [COMPONENT_FIELDS.COMPONENT_DEPLOYMENT_ARTIFACTS]);
     }
diff --git a/common-be/src/main/java/org/openecomp/sdc/be/datatypes/elements/OperationInputDefinition.java b/common-be/src/main/java/org/openecomp/sdc/be/datatypes/elements/OperationInputDefinition.java
index 1e8ef50564..ab3f536d63 100644
--- a/common-be/src/main/java/org/openecomp/sdc/be/datatypes/elements/OperationInputDefinition.java
+++ b/common-be/src/main/java/org/openecomp/sdc/be/datatypes/elements/OperationInputDefinition.java
@@ -38,6 +38,13 @@ public class OperationInputDefinition extends InputDataDefinition {
         setSourceProperty(sourceProperty);
     }
 
+	public OperationInputDefinition(OperationInputDefinition oid) {
+		super(oid);
+		setName(oid.getName());
+		setSource(oid.getSource());
+		setSourceProperty(oid.getSourceProperty());
+	}
+
     public OperationInputDefinition(String name, String property, Boolean mandatory, String type) {
         super();
         setName(name);
diff --git a/common-be/src/main/java/org/openecomp/sdc/be/datatypes/elements/PropertyDataDefinition.java b/common-be/src/main/java/org/openecomp/sdc/be/datatypes/elements/PropertyDataDefinition.java
index c4a78433f5..88863b2cf5 100644
--- a/common-be/src/main/java/org/openecomp/sdc/be/datatypes/elements/PropertyDataDefinition.java
+++ b/common-be/src/main/java/org/openecomp/sdc/be/datatypes/elements/PropertyDataDefinition.java
@@ -59,6 +59,8 @@ public class PropertyDataDefinition extends ToscaDataDefinition {
 	private String inputId;
 	private String instanceUniqueId;
 	private String propertyId;
+	private String parentPropertyType;
+	private String subPropertyInputPath;
 
 	private List<Annotation> annotations;
 	/**
@@ -100,11 +102,29 @@ public class PropertyDataDefinition extends ToscaDataDefinition {
 		this.setInputId(p.getInputId());
 		this.setInstanceUniqueId(p.getInstanceUniqueId());
 		this.setPropertyId(p.getPropertyId());
+		this.setParentPropertyType(p.getParentPropertyType());
+		this.setSubPropertyInputPath(p.getSubPropertyInputPath());
 		if(isNotEmpty(p.annotations)){
 		    this.setAnnotations(p.annotations);
         }
 	}
 
+	public String getParentPropertyType() {
+		return parentPropertyType;
+	}
+
+	public void setParentPropertyType(String parentPropertyType) {
+		this.parentPropertyType = parentPropertyType;
+	}
+
+	public String getSubPropertyInputPath() {
+		return subPropertyInputPath;
+	}
+
+	public void setSubPropertyInputPath(String subPropertyInputPath) {
+		this.subPropertyInputPath = subPropertyInputPath;
+	}
+
 	public String getInputPath() {
 		return inputPath;
 	}
@@ -285,7 +305,9 @@ public class PropertyDataDefinition extends ToscaDataDefinition {
 	public String toString() {
 		return "PropertyDataDefinition [uniqueId=" + uniqueId + ", type=" + type + ", required=" + required + ", definition=" + definition + ", defaultValue=" + defaultValue + ", description=" + description + ", schema=" + schema + ", password="
 				+ password + ", name=" + name + ", value=" + value + ", label=" + label + ", hidden=" + hidden + ", immutable=" + immutable + ", inputPath=" + inputPath + ", status=" + status + ", inputId=" + inputId + ", instanceUniqueId="
-				+ instanceUniqueId + ", propertyId=" + propertyId + ", parentUniqueId=" + parentUniqueId + ", getInputValues=" + getInputValues + "]";
+				+ instanceUniqueId + ", propertyId=" + propertyId + ", parentUniqueId=" + parentUniqueId + ", getInputValues=" + getInputValues
+				+  "parentPropertyType" + parentPropertyType
+				+  "subPropertyInputPath" + subPropertyInputPath +"]";
 	}
 
 	@Override
diff --git a/test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/api/Urls.java b/test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/api/Urls.java
index ad699d07ae..f85f326f03 100644
--- a/test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/api/Urls.java
+++ b/test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/api/Urls.java
@@ -361,6 +361,7 @@ public interface Urls {
 	final String GET_MODULE_BY_ID = SDC_HTTP_METHOD + "://%s:%s/sdc2/rest/v1/catalog/resources/%s/groups/%s";
 
 	// inputs
+	final String UPDATE_INPUTS = SDC_HTTP_METHOD + "://%s:%s/sdc2/rest/v1/catalog/%s/%s/update/inputs";
 	final String ADD_INPUTS = SDC_HTTP_METHOD + "://%s:%s/sdc2/rest/v1/catalog/%s/%s/create/inputs"; //{componentType}/{componentId}/create/inputs
 	final String DELETE_INPUT_BY_ID = SDC_HTTP_METHOD + "://%s:%s/sdc2/rest/v1/catalog/%s/%s/delete/%s/input"; //{componentType}/{componentId}/delete/{inputId}/input
 	final String GET_COMPONENT_INPUTS = SDC_HTTP_METHOD + "://%s:%s/sdc2/rest/v1/catalog/services/%s/inputs"; //services/{componentId}/inputs
diff --git a/test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/datatypes/PropertyReqDetails.java b/test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/datatypes/PropertyReqDetails.java
index 0898206002..64086884fa 100644
--- a/test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/datatypes/PropertyReqDetails.java
+++ b/test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/datatypes/PropertyReqDetails.java
@@ -7,9 +7,9 @@
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -23,6 +23,7 @@ package org.openecomp.sdc.ci.tests.datatypes;
 import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
 
 public class PropertyReqDetails {
+
 	String name;
 	String type;
 	Boolean required = false;
@@ -32,14 +33,18 @@ public class PropertyReqDetails {
 	String propertyRangeMax;
 	Boolean isPassword = false;
 	SchemaDefinition schema;
+	String uniqueId;
+	String parentUniqueId;
+	String value;
 
 	public PropertyReqDetails() {
 		super();
 	}
 
 	public PropertyReqDetails(String propertyName, String propertyType, Boolean propertyRequired,
-			String propertyDefaultValue, String propertyDescription, String propertyRangeMin, String propertyRangeMax,
-			Boolean propertyPassword) {
+							  String propertyDefaultValue, String propertyDescription, String propertyRangeMin,
+							  String propertyRangeMax,
+							  Boolean propertyPassword) {
 		super();
 		this.name = propertyName;
 		this.type = propertyType;
@@ -52,7 +57,7 @@ public class PropertyReqDetails {
 	}
 
 	public PropertyReqDetails(String propertyName, String propertyType, String propertyDefaultValue,
-			String propertyDescription, SchemaDefinition schema) {
+							  String propertyDescription, SchemaDefinition schema) {
 		super();
 		this.name = propertyName;
 		this.type = propertyType;
@@ -133,14 +138,42 @@ public class PropertyReqDetails {
 		this.isPassword = propertyPassword;
 	}
 
+	public String getUniqueId() {
+		return uniqueId;
+	}
+
+	public void setUniqueId(String uniqueId) {
+		this.uniqueId = uniqueId;
+	}
+
+	public String getParentUniqueId() {
+		return parentUniqueId;
+	}
+
+	public void setParentUniqueId(String parentUniqueId) {
+		this.parentUniqueId = parentUniqueId;
+	}
+
+	public String getValue() {
+		return value;
+	}
+
+	public void setValue(String value) {
+		this.value = value;
+	}
+
 	public String propertyToJsonString() {
 		String jsonString;
 		jsonString =
-                "{\"" + this.getName() + "\":{" + "\"name\":\"" + this.getName() + "\"," + "\"type\":\"" + this.getPropertyType() + "\"," + "\"required\":"
-				+ this.getPropertyRequired() + "," + "\"defaultValue\":\"" + this.getPropertyDefaultValue() + "\","
-				+ "\"description\":\"" + this.getPropertyDescription() + "\"," + "\"constraints\":[{\"inRange\":[\""
-				+ this.getPropertyRangeMin() + "\",\"" + this.getPropertyRangeMax() + "\"]}]," + "\"isPassword\":"
-				+ this.getPropertyPassword() + "}}";
+				"{\"" + this.getName() + "\":{" + "\"name\":\"" + this.getName() + "\"," + "\"type\":\"" + this
+						.getPropertyType() + "\"," + "\"required\":"
+						+ this.getPropertyRequired() + "," + "\"defaultValue\":\"" + this.getPropertyDefaultValue()
+						+ "\","
+						+ "\"description\":\"" + this.getPropertyDescription() + "\","
+						+ "\"constraints\":[{\"inRange\":[\""
+						+ this.getPropertyRangeMin() + "\",\"" + this.getPropertyRangeMax() + "\"]}],"
+						+ "\"isPassword\":"
+						+ this.getPropertyPassword() + "}}";
 		return jsonString;
 	}
 }
diff --git a/test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/execute/inputs/InputsApiTests.java b/test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/execute/inputs/InputsApiTests.java
index 91cf3b0c44..714a029fd8 100644
--- a/test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/execute/inputs/InputsApiTests.java
+++ b/test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/execute/inputs/InputsApiTests.java
@@ -7,9 +7,9 @@
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -20,37 +20,61 @@
 
 package org.openecomp.sdc.ci.tests.execute.inputs;
 
+import static org.testng.AssertJUnit.assertTrue;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
 import com.google.gson.reflect.TypeToken;
+
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
 import fj.data.Either;
 import org.apache.commons.lang3.tuple.Pair;
 import org.junit.Rule;
 import org.junit.rules.TestName;
 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
-import org.openecomp.sdc.be.model.*;
+import org.openecomp.sdc.be.model.Component;
+import org.openecomp.sdc.be.model.ComponentInstInputsMap;
+import org.openecomp.sdc.be.model.ComponentInstance;
+import org.openecomp.sdc.be.model.ComponentInstancePropInput;
+import org.openecomp.sdc.be.model.InputDefinition;
+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.Service;
+import org.openecomp.sdc.be.model.User;
+import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
 import org.openecomp.sdc.ci.tests.api.ComponentBaseTest;
+import org.openecomp.sdc.ci.tests.datatypes.PropertyReqDetails;
 import org.openecomp.sdc.ci.tests.datatypes.ServiceReqDetails;
 import org.openecomp.sdc.ci.tests.datatypes.enums.LifeCycleStatesEnum;
 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
 import org.openecomp.sdc.ci.tests.utils.general.AtomicOperationUtils;
 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
-import org.openecomp.sdc.ci.tests.utils.rest.*;
+import org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils;
+import org.openecomp.sdc.ci.tests.utils.rest.ComponentInstanceRestUtils;
+import org.openecomp.sdc.ci.tests.utils.rest.InputsRestUtils;
+import org.openecomp.sdc.ci.tests.utils.rest.PropertyRestUtils;
+import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
+import org.openecomp.sdc.ci.tests.utils.rest.ServiceRestUtils;
 import org.openecomp.sdc.ci.tests.utils.validation.BaseValidationUtils;
+import org.testng.AssertJUnit;
 import org.testng.annotations.Test;
 
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
-
-import static org.testng.AssertJUnit.assertTrue;
-
 /**
- * CI-Tests for inputs 
+ * CI-Tests for inputs
  * @author il0695
  *
  */
@@ -59,10 +83,10 @@ public class InputsApiTests extends ComponentBaseTest {
 	private static String inputCsar1 = "FCGI_with_inputs.csar";
 	private static String inputCsar2 = "LDSA1_with_inputs.csar";
 	private static User  sdncDesignerDetails = null;
-	
+
 	@Rule
 	public static TestName name = new TestName();
-	
+
 	/**
 	 * Constructor
 	 */
@@ -70,28 +94,28 @@ public class InputsApiTests extends ComponentBaseTest {
 		super(name, InputsApiTests.class.getName());
 		sdncDesignerDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 	}
-	
+
 	/**
 	 * Create VF with inputs from CSAR file
-	 * 
-	 * @throws Exception 
+	 *
+	 * @throws Exception
 	 */
 	@Test
 	public void testCreateResourceInstanceWithInputsFromCsar() throws Exception {
 		Resource vf = AtomicOperationUtils.importResourceFromCsar(ResourceTypeEnum.VF, UserRoleEnum.DESIGNER, inputCsar1);
 		assertTrue("Success creating VF from CSAR", !vf.getInputs().isEmpty());
 	}
-	
+
 	/**
 	 * Create service and add to it VF instance with inputs
-	 * 
-	 * @throws Exception 
+	 *
+	 * @throws Exception
 	 */
 	@Test
 	public void testAddVfInstanceWithInputsToService() throws Exception {
 		createServiceWithVFInstanceWithInputs();
 	}
-	
+
 	/**
 	 * General test to check most functionality of inputs
 	 * <ul>
@@ -101,33 +125,33 @@ public class InputsApiTests extends ComponentBaseTest {
 	 * 	<li>Get service inputs</li>
 	 * 	<li>Delete service inputs</li>
 	 * </ul>
-	 * 
-	 * @throws Exception 
+	 *
+	 * @throws Exception
 	 */
 	@Test
 	public void testInputsMainFunctionality() throws Exception {
 		Service service = createServiceWithVFInstanceWithInputs();
 		int totalInputsBeforeAdd = service.getInputs().size();
-		
+
 		// Get component instances
 		RestResponse getInstancesResponse = ComponentInstanceRestUtils.getComponentInstances(ComponentTypeEnum.SERVICE, service.getUniqueId(), sdncDesignerDetails);
 		BaseValidationUtils.checkSuccess(getInstancesResponse);
 		List<ComponentInstance> serviceInstances = new Gson().fromJson(getInstancesResponse.getResponse(), new TypeToken<ArrayList<ComponentInstance>>(){}.getType());
-		
+
 		// Get all inputs of first instance
 		ComponentInstance vfInstance = serviceInstances.get(0);
 		RestResponse getComponentInstanceInputsResponse = InputsRestUtils.getComponentInstanceInputs(service, vfInstance);
 		BaseValidationUtils.checkSuccess(getComponentInstanceInputsResponse);
 		List<ComponentInstancePropInput> instanceInputs = new Gson().fromJson(getComponentInstanceInputsResponse.getResponse(), new TypeToken<ArrayList<ComponentInstancePropInput>>(){}.getType());
-		
+
 		// Take only the 2 first inputs
 		List<ComponentInstancePropInput> inputsToAdd = instanceInputs.stream().limit(2).collect(Collectors.toList());
-		
+
 		// Build component instances input map to add to server
 		ComponentInstInputsMap buildComponentInstInputsMap = buildComponentInstInputsMap(vfInstance.getUniqueId(), inputsToAdd);
 		RestResponse addInputResponse = InputsRestUtils.addInput(service, buildComponentInstInputsMap, UserRoleEnum.DESIGNER);
 		BaseValidationUtils.checkSuccess(addInputResponse);
-		
+
 		// Get service inputs count
 		RestResponse getComponentInputsResponse = InputsRestUtils.getComponentInputs(service);
 		BaseValidationUtils.checkSuccess(getComponentInputsResponse);
@@ -135,11 +159,11 @@ public class InputsApiTests extends ComponentBaseTest {
 		if (serviceInputsAfterAdd.size()-totalInputsBeforeAdd!=2) {
 			assertTrue("Error adding inputs to service (service should have 2 inputs)", false);
 		}
-		
+
 		// Delete 1 input from service
 		RestResponse deleteInputFromComponentResponse = InputsRestUtils.deleteInputFromComponent(service, serviceInputsAfterAdd.get(0).getUniqueId());
 		BaseValidationUtils.checkSuccess(deleteInputFromComponentResponse);
-		
+
 		// Get service inputs count after delete
 		RestResponse getComponentInputsResponseAfterDelete = InputsRestUtils.getComponentInputs(service);
 		BaseValidationUtils.checkSuccess(getComponentInputsResponseAfterDelete);
@@ -147,14 +171,14 @@ public class InputsApiTests extends ComponentBaseTest {
 		if (serviceInputsAfterDelete.size()-totalInputsBeforeAdd!=1) {
 			assertTrue("Error deleting inputs from service (service should have 1 input)", false);
 		}
-		
+
 		assertTrue("Success testing inputs main functionality", true);
 	}
 
 	/**
 	 * Private method to create service with VF instance that has inputs
 	 * This is private method to be used by multiple tests
-	 * 
+	 *
 	 * @return {@link org.openecomp.sdc.be.model}
 	 * @throws Exception
 	 * @throws IOException
@@ -166,25 +190,25 @@ public class InputsApiTests extends ComponentBaseTest {
 			assertTrue("Error creating default service", false);
 		}
 		Service service = createDefaultServiceEither.left().value();
-		
+
 		// Create VF from CSAR file
 		Resource vfWithInputs = AtomicOperationUtils.importResourceFromCsar(ResourceTypeEnum.VF, UserRoleEnum.DESIGNER, inputCsar2);
 
 		// Certify VF
 		Pair<Component, RestResponse> changeComponentState = AtomicOperationUtils.changeComponentState(vfWithInputs, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true);
 		assertTrue("response code is BaseRestUtils.STATUS_CODE_SUCCESS, returned :" + changeComponentState.getRight().getErrorCode(), changeComponentState.getRight().getErrorCode() == BaseRestUtils.STATUS_CODE_SUCCESS);
-		
+
 		// Add VF instance to service
 		Either<ComponentInstance, RestResponse> addComponentInstanceToComponentContainerEither = AtomicOperationUtils.addComponentInstanceToComponentContainer(vfWithInputs, service, UserRoleEnum.DESIGNER, true);
 		if (addComponentInstanceToComponentContainerEither.isRight()){
 			assertTrue("Error adding VF to service", false);
 		}
-				
+
 		// Get service response
 		ServiceReqDetails serviceDetails = new ServiceReqDetails(service);
 		RestResponse getServiceResponse = ServiceRestUtils.getService(serviceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 		service = ResponseParser.parseToObjectUsingMapper(getServiceResponse.getResponse(), Service.class);
-		
+
 		// Get VF instance from service
 		ComponentInstance vfInstance = service.getComponentInstances().get(0);
 		if (vfInstance!=null){
@@ -194,10 +218,10 @@ public class InputsApiTests extends ComponentBaseTest {
 		}
 		return service;
 	}
-	
+
 	/**
 	 * Return default ComponentInstInputsMap
-	 * 
+	 *
 	 * @param addToInput
 	 * @param inputs
 	 * @return {@link org.openecomp.sdc.be.model.ComponentInstInputsMap}
@@ -206,8 +230,132 @@ public class InputsApiTests extends ComponentBaseTest {
 		Map<String, List<ComponentInstancePropInput>> map = new HashMap<>();
 		map.put(addToInput, inputs);
 		ComponentInstInputsMap componentInstInputsMap = new ComponentInstInputsMap();
-		componentInstInputsMap.setComponentInstanceInputsMap(map);		
+		componentInstInputsMap.setComponentInstanceInputsMap(map);
 		return componentInstInputsMap;
 	}
 
+
+	@Test
+	public void validateValidValueConstraintOnInputFailTest() throws Exception {
+		Either<Service, RestResponse> createDefaultServiceEither = AtomicOperationUtils.createDefaultService(UserRoleEnum.DESIGNER, true);
+		if (createDefaultServiceEither.isRight()){
+			assertTrue("Error creating default service", false);
+		}
+		Service service = createDefaultServiceEither.left().value();
+
+		String body = "{\"SubnetProp\": {\"schema\": {\"property\": {\"type\": \"\"}},\"type\": \"org.openecomp"
+				+ ".datatypes.heat.network.neutron.Subnet\",\"name\": \"SubnetProp\"}}";
+		RestResponse createPropertyResponse = PropertyRestUtils.createProperty(service.getUniqueId(), body,
+				sdncDesignerDetails);
+		AssertJUnit.assertEquals("Expected result code - 200, received - " + createPropertyResponse.getErrorCode(), 200,
+				(int) createPropertyResponse.getErrorCode());
+
+		ObjectMapper mapper = new ObjectMapper();
+		mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
+		mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
+		PropertyReqDetails propertyResponseObject = mapper.readValue(createPropertyResponse.getResponse(),
+				PropertyReqDetails.class);
+
+		PropertyDefinition input = new PropertyDefinition();
+		input.setName("ipv6_address_mode");
+		input.setType("string");
+		input.setUniqueId("org.openecomp.datatypes.heat.network.neutron.Subnet.datatype.ipv6_address_mode");
+
+		ComponentInstancePropInput componentInstancePropInput = new ComponentInstancePropInput();
+		componentInstancePropInput.setPropertiesName("SubnetProp#ipv6_address_mode");
+		componentInstancePropInput.setName("SubnetProp");
+		componentInstancePropInput.setParentUniqueId(service.getUniqueId());
+		componentInstancePropInput.setType("org.openecomp.datatypes.heat.network.neutron.Subnet");
+		componentInstancePropInput.setUniqueId(propertyResponseObject.getUniqueId());
+		componentInstancePropInput.setInput(input);
+
+		ComponentInstInputsMap componentInstInputsMap = new ComponentInstInputsMap();
+		componentInstInputsMap.setServiceProperties(Collections.singletonMap(service.getUniqueId(),
+				Collections.singletonList(componentInstancePropInput)));
+		RestResponse addInputResponse = InputsRestUtils.addInput(service, componentInstInputsMap,
+				UserRoleEnum.DESIGNER);
+
+		AssertJUnit.assertEquals("Expected result code - 200, received - " + addInputResponse.getErrorCode(),
+				200, (int) addInputResponse.getErrorCode());
+
+		Type constraintType = new TypeToken<PropertyConstraint>() {}.getType();
+		Type inDefType = new TypeToken<List<InputDefinition>>() { }.getType();
+		Gson gson = new GsonBuilder().registerTypeAdapter(constraintType, new PropertyOperation.PropertyConstraintDeserialiser()).create();
+		try {
+			List<InputDefinition> inputDefinitions = gson.fromJson(addInputResponse.getResponse(),
+					inDefType);
+
+			inputDefinitions.get(0).setDefaultValue("Fail");
+
+			RestResponse updateInputResponse = InputsRestUtils.updateInput(service, mapper.writeValueAsString(inputDefinitions),
+					UserRoleEnum.DESIGNER);
+
+			AssertJUnit.assertEquals("Expected result code - 400, received - " + addInputResponse.getErrorCode(),
+					400, (int) updateInputResponse.getErrorCode());
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	@Test
+	public void validateValidValueConstraintOnInputSuccessTest() throws Exception {
+		Either<Service, RestResponse> createDefaultServiceEither = AtomicOperationUtils.createDefaultService(UserRoleEnum.DESIGNER, true);
+		if (createDefaultServiceEither.isRight()){
+			assertTrue("Error creating default service", false);
+		}
+		Service service = createDefaultServiceEither.left().value();
+
+		String body = "{\"SubnetProp\": {\"schema\": {\"property\": {\"type\": \"\"}},\"type\": \"org.openecomp"
+				+ ".datatypes.heat.network.neutron.Subnet\",\"name\": \"SubnetProp\"}}";
+		RestResponse createPropertyResponse = PropertyRestUtils.createProperty(service.getUniqueId(), body,
+				sdncDesignerDetails);
+		AssertJUnit.assertEquals("Expected result code - 200, received - " + createPropertyResponse.getErrorCode(), 200,
+				(int) createPropertyResponse.getErrorCode());
+
+		ObjectMapper mapper = new ObjectMapper();
+		mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
+		mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
+		PropertyReqDetails propertyResponseObject = mapper.readValue(createPropertyResponse.getResponse(),
+				PropertyReqDetails.class);
+
+		PropertyDefinition input = new PropertyDefinition();
+		input.setName("ipv6_address_mode");
+		input.setType("string");
+		input.setUniqueId("org.openecomp.datatypes.heat.network.neutron.Subnet.datatype.ipv6_address_mode");
+
+		ComponentInstancePropInput componentInstancePropInput = new ComponentInstancePropInput();
+		componentInstancePropInput.setPropertiesName("SubnetProp#ipv6_address_mode");
+		componentInstancePropInput.setName("SubnetProp");
+		componentInstancePropInput.setParentUniqueId(service.getUniqueId());
+		componentInstancePropInput.setType("org.openecomp.datatypes.heat.network.neutron.Subnet");
+		componentInstancePropInput.setUniqueId(propertyResponseObject.getUniqueId());
+		componentInstancePropInput.setInput(input);
+
+		ComponentInstInputsMap componentInstInputsMap = new ComponentInstInputsMap();
+		componentInstInputsMap.setServiceProperties(Collections.singletonMap(service.getUniqueId(),
+				Collections.singletonList(componentInstancePropInput)));
+		RestResponse addInputResponse = InputsRestUtils.addInput(service, componentInstInputsMap,
+				UserRoleEnum.DESIGNER);
+
+		AssertJUnit.assertEquals("Expected result code - 200, received - " + addInputResponse.getErrorCode(),
+				200, (int) addInputResponse.getErrorCode());
+
+		Type constraintType = new TypeToken<PropertyConstraint>() {}.getType();
+		Type inDefType = new TypeToken<List<InputDefinition>>() { }.getType();
+		Gson gson = new GsonBuilder().registerTypeAdapter(constraintType, new PropertyOperation.PropertyConstraintDeserialiser()).create();
+		try {
+			List<InputDefinition> inputDefinitions = gson.fromJson(addInputResponse.getResponse(),
+					inDefType);
+
+			inputDefinitions.get(0).setDefaultValue("slaac");
+
+			RestResponse updateInputResponse = InputsRestUtils.updateInput(service, mapper.writeValueAsString(inputDefinitions),
+					UserRoleEnum.DESIGNER);
+
+			AssertJUnit.assertEquals("Expected result code - 200, received - " + addInputResponse.getErrorCode(),
+					200, (int) updateInputResponse.getErrorCode());
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
 }
diff --git a/test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/execute/property/PropertyApisTest.java b/test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/execute/property/PropertyApisTest.java
index 21e188649d..789b118419 100644
--- a/test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/execute/property/PropertyApisTest.java
+++ b/test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/execute/property/PropertyApisTest.java
@@ -7,9 +7,9 @@
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -20,6 +20,19 @@
 
 package org.openecomp.sdc.ci.tests.execute.property;
 
+import static org.testng.AssertJUnit.assertTrue;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
 import org.json.simple.JSONObject;
 import org.json.simple.JSONValue;
 import org.junit.Rule;
@@ -47,19 +60,12 @@ import org.testng.AssertJUnit;
 import org.testng.annotations.BeforeMethod;
 import org.testng.annotations.Test;
 
-import java.util.*;
-
-import static org.testng.AssertJUnit.assertTrue;
-
 public class PropertyApisTest extends SimpleOneRsrcOneServiceTest {
 
 	protected static final String RESOURCE_CATEGORY = "Generic/Databases";
 	protected Config config = Config.instance();
 	protected String contentTypeHeaderData = "application/json";
 	protected String acceptHeaderDate = "application/json";;
-
-	// protected User sdncDesignerDetails;
-	// protected ResourceReqDetails resourceDetails;
 	protected PropertyReqDetails property;
 	protected String body;
 
@@ -75,30 +81,8 @@ public class PropertyApisTest extends SimpleOneRsrcOneServiceTest {
 
 	@BeforeMethod
 	public void init() throws Exception {
-		//
-		// //Delete resource
-		//
-		// resourceDetails = new ResourceReqDetails();
-		// resourceDetails.setResourceName("testresourceDetails");
-		//
-		// resourceUtils.deleteResource_allVersions(resourceDetails,
-		// sdncDesignerDetails);
-		//
-		// //Create resource
-		// resourceDetails = createResource(sdncDesignerDetails,
-		// "testresourceDetails");
-
-		// Create property
-		// property.setPropertyName("test");
-		// property.setPropertyType("integer");
-		// property.setPropertySource("A&AI");
-		// property.setPropertyDescription("test property");
-
-		// body = gson.toJson(property);
 		property = ElementFactory.getDefaultProperty();
 		body = property.propertyToJsonString();
-		// System.out.println(body);
-		// HTTP (for negative tests)
 		headersMap.put(HttpHeaderEnum.CONTENT_TYPE.getValue(), contentTypeHeaderData);
 		headersMap.put(HttpHeaderEnum.ACCEPT.getValue(), acceptHeaderDate);
 		headersMap.put(HttpHeaderEnum.USER_ID.getValue(), sdncDesignerDetails.getUserId());
@@ -106,10 +90,75 @@ public class PropertyApisTest extends SimpleOneRsrcOneServiceTest {
 	}
 
 	@Test
-	public void testPropertyApis() throws Exception {
-		// Create property
-		// System.out.println ("---- Create Property (POST) ----");
+	public void validateValidValueConstraintFailTest() throws Exception {
+		body = "{\"SubnetProp\": {\"schema\": {\"property\": {\"type\": \"\"}},\"type\": \"org.openecomp.datatypes.heat.network.neutron.Subnet\",\"name\": \"SubnetProp\"}}";
+		RestResponse createPropertyResponse = PropertyRestUtils.createProperty(getResourceId(resourceDetails), body,
+				sdncDesignerDetails);
+		AssertJUnit.assertEquals("Expected result code - 200, received - " + createPropertyResponse.getErrorCode(), 200,
+				(int) createPropertyResponse.getErrorCode());
+
+		ObjectMapper mapper = new ObjectMapper();
+		mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
+		mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
+		try {
+			PropertyReqDetails propertyResponseObject = mapper.readValue(createPropertyResponse.getResponse(),
+					PropertyReqDetails.class);
+
+			PropertyReqDetails propertyReqDetails = new PropertyReqDetails();
+			propertyReqDetails.setPropertyType("org.openecomp.datatypes.heat.network.neutron.Subnet");
+			propertyReqDetails.setName(propertyResponseObject.getName());
+			propertyReqDetails.setValue(mapper.writeValueAsString(Collections.singletonMap("ipv6_address_mode", "Fail")));
+			propertyReqDetails.setParentUniqueId(propertyResponseObject.getParentUniqueId());
+			propertyReqDetails.setUniqueId(propertyResponseObject.getUniqueId());
+
+			body = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(Collections.singletonList(propertyReqDetails));
+			body = body.replace("propertyType", "type");
+			RestResponse addValueToPropertyResponse =
+					PropertyRestUtils.addValueToProperty(getResourceId(resourceDetails), body, sdncDesignerDetails);
+
+			AssertJUnit.assertEquals("Expected result code - 400, received - " + addValueToPropertyResponse.getErrorCode(),
+					400, (int) addValueToPropertyResponse.getErrorCode());
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
 
+	@Test
+	public void validateValidValueConstraintSuccessTest() throws Exception {
+		body = "{\"SubnetProp\": {\"schema\": {\"property\": {\"type\": \"\"}},\"type\": \"org.openecomp.datatypes.heat.network.neutron.Subnet\",\"name\": \"SubnetProp\"}}";
+		RestResponse createPropertyResponse = PropertyRestUtils.createProperty(getResourceId(resourceDetails), body,
+				sdncDesignerDetails);
+		AssertJUnit.assertEquals("Expected result code - 201, received - " + createPropertyResponse.getErrorCode(), 200,
+				(int) createPropertyResponse.getErrorCode());
+
+		ObjectMapper mapper = new ObjectMapper();
+		mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
+		mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
+		try {
+			PropertyReqDetails propertyResponseObject = mapper.readValue(createPropertyResponse.getResponse(),
+					PropertyReqDetails.class);
+
+			PropertyReqDetails propertyReqDetails = new PropertyReqDetails();
+			propertyReqDetails.setPropertyType("org.openecomp.datatypes.heat.network.neutron.Subnet");
+			propertyReqDetails.setName(propertyResponseObject.getName());
+			propertyReqDetails.setValue(mapper.writeValueAsString(Collections.singletonMap("ipv6_address_mode", "slaac")));
+			propertyReqDetails.setParentUniqueId(propertyResponseObject.getParentUniqueId());
+			propertyReqDetails.setUniqueId(propertyResponseObject.getUniqueId());
+
+			body = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(Collections.singletonList(propertyReqDetails));
+			body = body.replace("propertyType", "type");
+			RestResponse addValueToPropertyResponse =
+					PropertyRestUtils.addValueToProperty(getResourceId(resourceDetails), body, sdncDesignerDetails);
+
+			AssertJUnit.assertEquals("Expected result code - 200, received - " + addValueToPropertyResponse.getErrorCode(),
+					200, (int) addValueToPropertyResponse.getErrorCode());
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	@Test
+	public void testPropertyApis() throws Exception {
 		String propertyId = UniqueIdBuilder.buildComponentPropertyUniqueId(getResourceId(resourceDetails), property.getName());
 
 		PropertyRestUtils.deleteProperty(getResourceId(resourceDetails), propertyId, sdncDesignerDetails);
@@ -119,7 +168,6 @@ public class PropertyApisTest extends SimpleOneRsrcOneServiceTest {
 				createPropertyResponse.getErrorCode() == 201);
 
 		// Get property
-		// System.out.println ("---- Get Property (GET) ----");
 		RestResponse getPropertyResponse = PropertyRestUtils.getProperty(getResourceId(resourceDetails), propertyId,
 				sdncDesignerDetails);
 		AssertJUnit.assertTrue("Expected result code - 200, received - " + getPropertyResponse.getErrorCode(),
@@ -127,19 +175,8 @@ public class PropertyApisTest extends SimpleOneRsrcOneServiceTest {
 
 		JSONObject jsonResp = (JSONObject) JSONValue.parse(getPropertyResponse.getResponse());
 
-		// assertTrue("Wrong 'type' in the
-		// response",jsonResp.get("type").equals(property.getPropertyType()));
-		// assertTrue("Wrong 'source' in the
-		// response",jsonResp.get("name").equals(property.getPropertyName()));
-		// assertTrue("Wrong 'name' in the
-		// response",jsonResp.get("source").equals(property.getPropertySource()));
-		// assertTrue("Wrong 'description' in the
-		// response",jsonResp.get("description").equals(property.getPropertyDescription()));
-
 		// Update property
-		// System.out.println ("---- Update Property (UPDATE) ----");
 		property.setPropertyDescription("Updated description");
-		// body = gson.toJson(property);
 		body = property.propertyToJsonString();
 
 		RestResponse updatePropertyResponse = PropertyRestUtils.updateProperty(getResourceId(resourceDetails),
@@ -148,7 +185,6 @@ public class PropertyApisTest extends SimpleOneRsrcOneServiceTest {
 				updatePropertyResponse.getErrorCode() == 200);
 
 		// Get property
-		// System.out.println ("---- Get Property (GET) ----");
 		getPropertyResponse = PropertyRestUtils.getProperty(getResourceId(resourceDetails), propertyId,
 				sdncDesignerDetails);
 		AssertJUnit.assertTrue("Expected result code - 200, received - " + getPropertyResponse.getErrorCode(),
@@ -156,24 +192,13 @@ public class PropertyApisTest extends SimpleOneRsrcOneServiceTest {
 
 		jsonResp = (JSONObject) JSONValue.parse(getPropertyResponse.getResponse());
 
-		// assertTrue("Wrong 'type' in the
-		// response",jsonResp.get("type").equals(property.getPropertyType()));
-		// assertTrue("Wrong 'source' in the
-		// response",jsonResp.get("name").equals(property.getPropertyName()));
-		// assertTrue("Wrong 'name' in the
-		// response",jsonResp.get("source").equals(property.getPropertySource()));
-		// assertTrue("Wrong 'description' in the
-		// response",jsonResp.get("description").equals(property.getPropertyDescription()));
-
 		// Delete property
-		// System.out.println ("---- Delete Property (DELETE) ----");
 		RestResponse deletePropertyResponse = PropertyRestUtils.deleteProperty(getResourceId(resourceDetails),
 				propertyId, sdncDesignerDetails);
 		AssertJUnit.assertTrue("Expected result code - 204, received - " + deletePropertyResponse.getErrorCode(),
 				deletePropertyResponse.getErrorCode() == 204);
 
 		// Get property - verify that the property doesn't exist.
-		// System.out.println("---- GET - Property Not Found ----");
 		getPropertyResponse = PropertyRestUtils.getProperty(getResourceId(resourceDetails), propertyId,
 				sdncDesignerDetails);
 		List<String> variables = Arrays.asList("");
@@ -185,16 +210,10 @@ public class PropertyApisTest extends SimpleOneRsrcOneServiceTest {
 	// --------------------------------------------------------------------------------------
 
 	protected String getPropertyId(ResourceReqDetails resource, PropertyReqDetails property) {
-		// return
-		// resource.getResourceName().toLowerCase()+".0.1."+property.getPropertyName();
 		return UniqueIdBuilder.buildComponentPropertyUniqueId(resource.getUniqueId(), property.getName());
 	}
 
 	protected String getResourceId(ResourceReqDetails resource) {
-		// String resourceUid =
-		// UniqueIdBuilder.buildResourceUniqueId(resource.getResourceName(),
-		// "0.1");
-
 		return resource.getUniqueId();
 	}
 
@@ -212,7 +231,6 @@ public class PropertyApisTest extends SimpleOneRsrcOneServiceTest {
 		String description = "description";
 		ArrayList<String> resourceTags = new ArrayList<String>();
 		resourceTags.add(resourceName);
-		// String category = ResourceCategoryEnum.DATABASE.getValue();
 		ArrayList<String> derivedFrom = new ArrayList<String>();
 		derivedFrom.add("tosca.nodes.Root");
 		String vendorName = "Oracle";
@@ -224,7 +242,6 @@ public class PropertyApisTest extends SimpleOneRsrcOneServiceTest {
 				derivedFrom, vendorName, vendorRelease, contactId, icon);
 		resourceDetails.addCategoryChain(ResourceCategoryEnum.GENERIC_DATABASE.getCategory(),
 				ResourceCategoryEnum.GENERIC_DATABASE.getSubCategory());
-		// deleteResource(resourceName.toLowerCase()+".0.1",sdncUserDetails.getUserId());
 		// TODO delete by name
 		// deleteResource(UniqueIdBuilder.buildResourceUniqueId(resourceName,
 		// "0.1"), sdncUserDetails.getUserId());
@@ -239,8 +256,6 @@ public class PropertyApisTest extends SimpleOneRsrcOneServiceTest {
 
 	@Test
 	public void putReqToCreateUriNotAllowed() throws Exception {
-		// System.out.println("---- PUT request to Create uri - Not Allowed
-		// ----");
 		String url = String.format(Urls.CREATE_PROPERTY, config.getCatalogBeHost(), config.getCatalogBePort(),
 				getResourceId(resourceDetails));
 		RestResponse propertyErrorResponse = httpRequest.httpSendByMethod(url, "PUT", body, headersMap);
@@ -251,8 +266,6 @@ public class PropertyApisTest extends SimpleOneRsrcOneServiceTest {
 
 	@Test
 	public void getReqToCreateUriNotAllowed() throws Exception {
-		// System.out.println("---- GET request to Create uri - Not Allowed
-		// ----");
 		String url = String.format(Urls.CREATE_PROPERTY, config.getCatalogBeHost(), config.getCatalogBePort(),
 				getResourceId(resourceDetails));
 		RestResponse propertyErrorResponse = httpRequest.httpSendGet(url, headersMap);
@@ -263,8 +276,6 @@ public class PropertyApisTest extends SimpleOneRsrcOneServiceTest {
 
 	@Test
 	public void deleteReqToCreateUriNotAllowed() throws Exception {
-		// System.out.println("---- DELETE request to Create uri - Not Allowed
-		// ----");
 		String url = String.format(Urls.CREATE_PROPERTY, config.getCatalogBeHost(), config.getCatalogBePort(),
 				getResourceId(resourceDetails));
 		RestResponse propertyErrorResponse = httpRequest.httpSendDelete(url, headersMap);
@@ -275,8 +286,6 @@ public class PropertyApisTest extends SimpleOneRsrcOneServiceTest {
 
 	@Test
 	public void postReqToUpdateUriNotAllowed() throws Exception {
-		// System.out.println("---- POST request to Update uri - Not Allowed
-		// ----");
 		String url = String.format(Urls.UPDATE_PROPERTY, config.getCatalogBeHost(), config.getCatalogBePort(),
 				getResourceId(resourceDetails), getPropertyId(resourceDetails, property));
 		RestResponse propertyErrorResponse = httpRequest.httpSendPost(url, body, headersMap);
@@ -287,7 +296,6 @@ public class PropertyApisTest extends SimpleOneRsrcOneServiceTest {
 
 	@Test
 	public void deleteReqPropertyNotFound() throws Exception {
-		// System.out.println("---- DELETE - Property Not Found ----");
 		String unknownPropertyId = getPropertyId(resourceDetails, property) + "111";
 		String url = String.format(Urls.DELETE_PROPERTY, config.getCatalogBeHost(), config.getCatalogBePort(),
 				getResourceId(resourceDetails), unknownPropertyId);
@@ -299,7 +307,6 @@ public class PropertyApisTest extends SimpleOneRsrcOneServiceTest {
 
 	@Test
 	public void updateReqPropertyNotFound() throws Exception {
-		// System.out.println("---- PUT - Property Not Found ----");
 		String unknownPropertyId = getPropertyId(resourceDetails, property) + "111";
 		String url = String.format(Urls.UPDATE_PROPERTY, config.getCatalogBeHost(), config.getCatalogBePort(),
 				getResourceId(resourceDetails), unknownPropertyId);
@@ -311,12 +318,10 @@ public class PropertyApisTest extends SimpleOneRsrcOneServiceTest {
 
 	@Test
 	public void modifierNotTheStateOwner() throws Exception {
-		// System.out.println("---- The modifier is not the state owner -
 		// Operation Not Allowed ----");
 		User sdncUserDetails2 = createUser("tu5555", "Test", "User", "tu5555@intl.sdc.com", "DESIGNER");
 		headersMap.put(HttpHeaderEnum.USER_ID.getValue(), sdncUserDetails2.getUserId());
 		property.setPropertyDescription("new description");
-		// body = gson.toJson(property);
 		body = property.propertyToJsonString();
 		String url = String.format(Urls.UPDATE_PROPERTY, config.getCatalogBeHost(), config.getCatalogBePort(),
 				getResourceId(resourceDetails), getPropertyId(resourceDetails, property));
@@ -329,15 +334,11 @@ public class PropertyApisTest extends SimpleOneRsrcOneServiceTest {
 
 	@Test
 	public void postReqInvalidContent() throws Exception {
-		// System.out.println("---- POST - Invalid Content ----");
 		body = "invalid";
 		String url = String.format(Urls.CREATE_PROPERTY, config.getCatalogBeHost(), config.getCatalogBePort(),
 				getResourceId(resourceDetails), getPropertyId(resourceDetails, property));
 		RestResponse propertyErrorResponse = httpRequest.httpSendPost(url, body, headersMap);
 
-		// System.out.println(propertyErrorResponse.getResponse()+" "+
-		// propertyErrorResponse.getErrorCode());
-
 		List<String> variables = Arrays.asList();
 		ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_CONTENT.name(), variables,
 				propertyErrorResponse.getResponse());
@@ -347,30 +348,20 @@ public class PropertyApisTest extends SimpleOneRsrcOneServiceTest {
 	public void putReqInvalidContent() throws Exception {
 
 		// Create property
-		// System.out.println ("---- Create Property (POST) ----");
 		RestResponse createPropertyResponse = PropertyRestUtils.createProperty(getResourceId(resourceDetails), body,
 				sdncDesignerDetails);
 		assertTrue("Expected result code - 201, received - " + createPropertyResponse.getErrorCode(),
 				createPropertyResponse.getErrorCode() == 201);
 
-		// System.out.println("---- PUT - Invalid Content ----");
 		body = "invalid";
 
 		String url = String.format(Urls.UPDATE_PROPERTY, config.getCatalogBeHost(), config.getCatalogBePort(),
 				getResourceId(resourceDetails), getPropertyId(resourceDetails, property));
 
-		// System.out.println(url + "\n" + body);
-
 		RestResponse propertyErrorResponse = httpRequest.httpSendByMethod(url, "PUT", body, headersMap);
 
-		// System.out.println(propertyErrorResponse.getResponse()+" "+
-		// propertyErrorResponse.getErrorCode());
-
 		List<String> variables = Arrays.asList();
 		ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_CONTENT.name(), variables,
 				propertyErrorResponse.getResponse());
 	}
-
-	// --------------------------------------------------------------------------------------
-
 }
diff --git a/test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/utils/rest/InputsRestUtils.java b/test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/utils/rest/InputsRestUtils.java
index 521da28522..36fe6e3ea7 100644
--- a/test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/utils/rest/InputsRestUtils.java
+++ b/test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/utils/rest/InputsRestUtils.java
@@ -7,9 +7,9 @@
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -21,6 +21,7 @@
 package org.openecomp.sdc.ci.tests.utils.rest;
 
 import com.google.gson.Gson;
+
 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
 import org.openecomp.sdc.be.model.Component;
 import org.openecomp.sdc.be.model.ComponentInstInputsMap;
@@ -36,34 +37,51 @@ import org.slf4j.LoggerFactory;
 
 /**
  * RestUtils for inputs
- * 
- * @author il0695
  *
+ * @author il0695
  */
 public class InputsRestUtils extends BaseRestUtils {
 
 	@SuppressWarnings("unused")
 	private static Logger logger = LoggerFactory.getLogger(InputsRestUtils.class.getName());
-	
+
 	/**
 	 * Add inputs to service
-	 * 
+	 *
 	 * @param component
 	 * @param inputs
 	 * @param userRole
 	 * @return {@link org.openecomp.sdc.ci.tests.datatypes.http.RestResponse}
 	 * @throws Exception
 	 */
-	public static RestResponse addInput(Component component, ComponentInstInputsMap inputs, UserRoleEnum userRole) throws Exception {
+	public static RestResponse addInput(Component component, ComponentInstInputsMap inputs, UserRoleEnum userRole)
+			throws Exception {
 		Config config = Utils.getConfig();
-		String url = String.format(Urls.ADD_INPUTS, config.getCatalogBeHost(), config.getCatalogBePort(), ComponentTypeEnum.findParamByType(component.getComponentType()), component.getUniqueId());
+		String url = String.format(Urls.ADD_INPUTS, config.getCatalogBeHost(), config.getCatalogBePort(),
+				ComponentTypeEnum.findParamByType(component.getComponentType()), component.getUniqueId());
 		String json = new Gson().toJson(inputs);
 		return sendPost(url, json, userRole.getUserId(), acceptHeaderData);
 	}
 
 	/**
+	 * Update inputs to service
+	 *
+	 * @param component
+	 * @param data
+	 * @param userRole
+	 * @return {@link org.openecomp.sdc.ci.tests.datatypes.http.RestResponse}
+	 * @throws Exception
+	 */
+	public static RestResponse updateInput(Component component, String data, UserRoleEnum userRole) throws Exception {
+		Config config = Utils.getConfig();
+		String url = String.format(Urls.UPDATE_INPUTS, config.getCatalogBeHost(), config.getCatalogBePort(),
+				ComponentTypeEnum.findParamByType(component.getComponentType()), component.getUniqueId());
+		return sendPost(url, data, userRole.getUserId(), acceptHeaderData);
+	}
+
+	/**
 	 * Get all Component inputs
-	 * 
+	 *
 	 * @param component
 	 * @return {@link org.openecomp.sdc.ci.tests.datatypes.http.RestResponse}
 	 * @throws Exception
@@ -71,51 +89,60 @@ public class InputsRestUtils extends BaseRestUtils {
 	public static RestResponse getComponentInputs(Component component) throws Exception {
 		Config config = Utils.getConfig();
 		//services/{componentId}/inputs
-		String url = String.format(Urls.GET_COMPONENT_INPUTS, config.getCatalogBeHost(), config.getCatalogBePort(), component.getUniqueId());		
+		String url = String.format(Urls.GET_COMPONENT_INPUTS, config.getCatalogBeHost(), config.getCatalogBePort(),
+				component.getUniqueId());
 		return sendGet(url, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER).getUserId());
 	}
-	
+
 	/**
 	 * Get all inputs of component instance
-	 * 
+	 *
 	 * @param parentComponent
 	 * @param componentInstance
 	 * @return {@link org.openecomp.sdc.ci.tests.datatypes.http.RestResponse}
 	 * @throws Exception
 	 */
-	public static RestResponse getComponentInstanceInputs(Component parentComponent, ComponentInstance componentInstance) throws Exception {
+	public static RestResponse getComponentInstanceInputs(Component parentComponent,
+														  ComponentInstance componentInstance) throws Exception {
 		Config config = Utils.getConfig();
-		//{componentType}/{componentId}/componentInstances/{instanceId}/{originComonentUid}/inputs		
-		String url = String.format(Urls.GET_COMPONENT_INSTANCE_INPUTS, config.getCatalogBeHost(), config.getCatalogBePort(), ComponentTypeEnum.findParamByType(parentComponent.getComponentType()), parentComponent.getUniqueId(), componentInstance.getUniqueId(), componentInstance.getComponentUid());
+		//{componentType}/{componentId}/componentInstances/{instanceId}/{originComonentUid}/inputs
+		String url =
+				String.format(Urls.GET_COMPONENT_INSTANCE_INPUTS, config.getCatalogBeHost(), config.getCatalogBePort(),
+						ComponentTypeEnum.findParamByType(parentComponent.getComponentType()),
+						parentComponent.getUniqueId(), componentInstance.getUniqueId(),
+						componentInstance.getComponentUid());
 		return sendGet(url, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER).getUserId());
 	}
-	
+
 	/**
 	 * Delete input from component
-	 * 
+	 *
 	 * @param parentComponent
 	 * @param inputId
 	 * @return {@link org.openecomp.sdc.ci.tests.datatypes.http.RestResponse}
 	 * @throws Exception
 	 */
 	public static RestResponse deleteInputFromComponent(Component parentComponent, String inputId) throws Exception {
-		return deleteInputFromComponent(ComponentTypeEnum.findParamByType(parentComponent.getComponentType()), parentComponent.getUniqueId(), inputId);
+		return deleteInputFromComponent(ComponentTypeEnum.findParamByType(parentComponent.getComponentType()),
+				parentComponent.getUniqueId(), inputId);
 	}
 
 	/**
 	 * Delete input from component
-	 * 
+	 *
 	 * @param componentType
 	 * @param componentId
 	 * @param inputUniqueId
 	 * @return {@link org.openecomp.sdc.ci.tests.datatypes.http.RestResponse}
 	 * @throws Exception
 	 */
-	public static RestResponse deleteInputFromComponent(String componentType, String componentId, String inputUniqueId) throws Exception {
+	public static RestResponse deleteInputFromComponent(String componentType, String componentId, String inputUniqueId)
+			throws Exception {
 		Config config = Utils.getConfig();
 		//{componentType}/{componentId}/delete/{inputId}/input
-		String url = String.format(Urls.DELETE_INPUT_BY_ID, config.getCatalogBeHost(), config.getCatalogBePort(), componentType, componentId, inputUniqueId);
+		String url = String.format(Urls.DELETE_INPUT_BY_ID, config.getCatalogBeHost(), config.getCatalogBePort(),
+				componentType, componentId, inputUniqueId);
 		return sendDelete(url, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER).getUserId());
 	}
-	
+
 }
diff --git a/test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/utils/rest/PropertyRestUtils.java b/test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/utils/rest/PropertyRestUtils.java
index 9d2cdb50e1..34a158fe74 100644
--- a/test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/utils/rest/PropertyRestUtils.java
+++ b/test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/utils/rest/PropertyRestUtils.java
@@ -7,9 +7,9 @@
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -20,9 +20,26 @@
 
 package org.openecomp.sdc.ci.tests.utils.rest;
 
+import static org.testng.AssertJUnit.assertNotNull;
+import static org.testng.AssertJUnit.assertNull;
+import static org.testng.AssertJUnit.assertTrue;
+
 import com.google.gson.Gson;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
-import org.openecomp.sdc.be.model.*;
+import org.openecomp.sdc.be.model.Component;
+import org.openecomp.sdc.be.model.ComponentInstance;
+import org.openecomp.sdc.be.model.ComponentInstanceInput;
+import org.openecomp.sdc.be.model.ComponentInstanceProperty;
+import org.openecomp.sdc.be.model.PropertyDefinition;
+import org.openecomp.sdc.be.model.Resource;
+import org.openecomp.sdc.be.model.Service;
+import org.openecomp.sdc.be.model.User;
 import org.openecomp.sdc.ci.tests.api.Urls;
 import org.openecomp.sdc.ci.tests.config.Config;
 import org.openecomp.sdc.ci.tests.datatypes.PropertyObject;
@@ -33,334 +50,334 @@ import org.openecomp.sdc.common.util.GeneralUtility;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import static org.testng.AssertJUnit.*;
-
 public class PropertyRestUtils extends BaseRestUtils {
-    private static Logger logger = LoggerFactory.getLogger(PropertyRestUtils.class.getName());
-
-    public static RestResponse createProperty(String resourceId, String body, User user) throws Exception {
-        Config config = Config.instance();
-        String url = String.format(Urls.CREATE_PROPERTY, config.getCatalogBeHost(), config.getCatalogBePort(), resourceId);
-
-        return sendPost(url, body, user.getUserId(), acceptHeaderData);
-    }
-
-    public static RestResponse createServiceProperty(String resourceId, String body, User user) throws Exception {
-        Config config = Config.instance();
-        String url = String.format(Urls.CREATE_SERVICE_PROPERTY, config.getCatalogBeHost(), config.getCatalogBePort(),
-                resourceId);
-
-        return sendPost(url, body, user.getUserId(), acceptHeaderData);
-    }
-
-    public static RestResponse updateProperty(String resourceId, String propertyId, String body, User user)
-            throws Exception {
-        Config config = Config.instance();
-
-        String url = String.format(Urls.UPDATE_PROPERTY, config.getCatalogBeHost(), config.getCatalogBePort(),
-                resourceId, propertyId);
-        return sendPut(url, body, user.getUserId(), acceptHeaderData);
-    }
-
-    public static RestResponse updateGroupProperty(Component component, String groupId, String body, User user)
-            throws Exception {
-        Config config = Config.instance();
-
-        String url = String.format(Urls.RESOURCE_GROUP_PROPERTY, config.getCatalogBeHost(), config.getCatalogBePort(), component.getUniqueId(), groupId);
-        return sendPut(url, body, user.getUserId(), acceptHeaderData);
-    }
-
-    public static RestResponse getProperty(String resourceId, String propertyId, User user) throws Exception {
-        Config config = Config.instance();
-        String url = String.format(Urls.GET_PROPERTY, config.getCatalogBeHost(), config.getCatalogBePort(), resourceId,
-                propertyId);
-        return sendGet(url, user.getUserId());
-    }
-
-    public static RestResponse deleteProperty(String resourceId, String propertyId, User user) throws Exception {
-        Config config = Config.instance();
-        String url = String.format(Urls.DELETE_PROPERTY, config.getCatalogBeHost(), config.getCatalogBePort(),
-                resourceId, propertyId);
-
-        return sendDelete(url, user.getUserId());
-    }
-
-    public static ComponentInstanceProperty getPropFromListByPropNameAndType(List<ComponentInstanceProperty> propList,
-                                                                             String propNameToUpdate, String propTypeToUpdate) {
-        for (ComponentInstanceProperty componentInstanceProperty : propList) {
-            if (componentInstanceProperty.getName().equals(propNameToUpdate)
-                    && componentInstanceProperty.getType().equals(propTypeToUpdate)) {
-                return componentInstanceProperty;
-            }
-        }
-        return null;
-    }
-
-    public static ComponentInstanceProperty getPropFromListByPropNameTypeAndPath(
-            List<ComponentInstanceProperty> propList, String propNameToUpdate, String propTypeToUpdate,
-            List<String> path) {
-        for (ComponentInstanceProperty componentInstanceProperty : propList) {
-            if (componentInstanceProperty.getPath() == null) {
-                return getPropFromListByPropNameAndType(propList, propNameToUpdate, propTypeToUpdate);
-            }
-            if (componentInstanceProperty.getName().equals(propNameToUpdate)
-                    && componentInstanceProperty.getType().equals(propTypeToUpdate)
-                    && path.containsAll(componentInstanceProperty.getPath())) {
-                return componentInstanceProperty;
-            }
-        }
-        return null;
-    }
-
-    public static ComponentInstanceProperty getPropFromListByPropIdAndPath(List<ComponentInstanceProperty> propList,
-                                                                           String propId, List<String> path) {
-
-        for (ComponentInstanceProperty componentInstanceProperty : propList) {
-            if (path != null) {
-                if (componentInstanceProperty.getUniqueId().equals(propId)
-                        && componentInstanceProperty.getPath().equals(path)) {
-                    return componentInstanceProperty;
-                }
-            } else {
-                if (componentInstanceProperty.getUniqueId().equals(propId)) {
-                    return componentInstanceProperty;
-                }
-            }
-        }
-        return null;
-    }
-
-    public static void comparePropertyLists(List<ComponentInstanceProperty> expectedList,
-                                            List<ComponentInstanceProperty> actualList, Boolean isUpdate) {
-
-        assertTrue(
-                "list size are not equals, expected size is: " + expectedList.size() + " ,actual: " + actualList.size(),
-                expectedList.size() == actualList.size());
-        Boolean flag = false;
-        for (ComponentInstanceProperty expectedcompInstProp : expectedList) {
-            for (ComponentInstanceProperty actualcompInstProp : actualList) {
-                flag = comparePropertyObjects(expectedcompInstProp, actualcompInstProp, isUpdate);
-                if (flag) {
-                    break;
-                }
-            }
-        }
-        // System.out.println("expected: " + expectedList + ", actual: " +
-        // actualList);
-        logger.debug("expected: {}, actual: {}", expectedList, actualList);
-        assertTrue("actual lists does not contain all uniqeIds", flag);
-    }
-
-    public static Boolean comparePropertyObjects(ComponentInstanceProperty expectedCompInstProp,
-                                                 ComponentInstanceProperty actualCompInstProp, Boolean isUpdate) {
-        String uniqueId = expectedCompInstProp.getUniqueId();
-        String type = expectedCompInstProp.getType();
-        String defaulValue = expectedCompInstProp.getDefaultValue();
-        if (actualCompInstProp.getUniqueId().equals(uniqueId)
-                && actualCompInstProp.getPath().equals(expectedCompInstProp.getPath())) {
-            assertTrue("expected type is: " + type + " ,actual: " + actualCompInstProp.getType(),
-                    actualCompInstProp.getType().equals(type));
-            if (defaulValue == null) {
-                assertTrue(
-                        "expected defaulValue is: " + defaulValue + " ,actual: " + actualCompInstProp.getDefaultValue(),
-                        actualCompInstProp.getDefaultValue() == defaulValue);
-            } else {
-                assertTrue(
-                        "expected defaulValue is: " + defaulValue + " ,actual: " + actualCompInstProp.getDefaultValue(),
-                        actualCompInstProp.getDefaultValue().equals(defaulValue));
-            }
-            if (isUpdate) {
-                assertTrue(
-                        "actual [Value] parameter " + actualCompInstProp.getName()
-                                + "should equal to expected [Value]: " + actualCompInstProp.getValue() + " ,Value: "
-                                + actualCompInstProp.getValue(),
-                        actualCompInstProp.getValue().equals(expectedCompInstProp.getValue()));
-                assertNotNull("valueId is null", actualCompInstProp.getValueUniqueUid());
-            } else {
-                if (defaulValue == null) {
-                    assertTrue(
-                            "actual [Value] parameter " + actualCompInstProp.getName()
-                                    + "should equal to expected [defaultValue]: " + actualCompInstProp.getValue()
-                                    + " ,defaultValue: " + actualCompInstProp.getDefaultValue(),
-                            actualCompInstProp.getValue() == expectedCompInstProp.getDefaultValue());
-                } else {
-                    assertTrue(
-                            "actual [Value] parameter " + actualCompInstProp.getName()
-                                    + "should equal to expected [defaultValue]: " + actualCompInstProp.getValue()
-                                    + " ,defaultValue: " + actualCompInstProp.getDefaultValue(),
-                            actualCompInstProp.getValue().equals(expectedCompInstProp.getDefaultValue()));
-                }
-                assertNull("valueId is not null", actualCompInstProp.getValueUniqueUid());
-            }
-            return true;
-        }
-        return false;
-    }
-
-    public static List<ComponentInstanceProperty> addResourcePropertiesToList(Resource resource,
-                                                                              List<ComponentInstanceProperty> listToFill) {
-        for (PropertyDefinition prop : resource.getProperties()) {
-            listToFill.add(new ComponentInstanceProperty(prop, null, null));
-        }
-        return listToFill;
-    }
-
-    public static List<ComponentInstanceProperty> addComponentInstPropertiesToList(Component component,
-                                                                                   List<ComponentInstanceProperty> listToFill, String componentId) {
-
-        if (componentId != null) {
-            List<ComponentInstanceProperty> list = component.getComponentInstancesProperties().get(componentId);
-            for (ComponentInstanceProperty prop : list) {
-                ComponentInstanceProperty componentInstanceProperty = new ComponentInstanceProperty(prop, null, null);
-                componentInstanceProperty.setPath(prop.getPath());
-                componentInstanceProperty.setValueUniqueUid(prop.getValueUniqueUid());
-                componentInstanceProperty.setValue(prop.getValue());
-                listToFill.add(componentInstanceProperty);
-            }
-        } else {
-            Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = component
-                    .getComponentInstancesProperties();
-            for (Map.Entry<String, List<ComponentInstanceProperty>> componentInstanceProperties : componentInstancesProperties
-                    .entrySet()) {
-                for (ComponentInstanceProperty prop : componentInstanceProperties.getValue()) {
-                    ComponentInstanceProperty componentInstanceProperty = new ComponentInstanceProperty(prop, null,
-                            null);
-                    componentInstanceProperty.setPath(prop.getPath());
-                    componentInstanceProperty.setValueUniqueUid(prop.getValueUniqueUid());
-                    componentInstanceProperty.setValue(prop.getValue());
-                    listToFill.add(componentInstanceProperty);
-                }
-            }
-        }
-
-        if (component.getComponentType().getValue().equals("Resource")) {
-            for (PropertyDefinition prop : ((Resource) component).getProperties()) {
-                listToFill.add(new ComponentInstanceProperty(prop, null, null));
-            }
-        }
-        return listToFill;
-    }
-
-    public static ComponentInstanceProperty getCompPropInstListByInstIdAndPropName(Component component,
-                                                                                   ComponentInstance componentInstanceDetails, String name, String type) {
-        List<ComponentInstanceProperty> propList = component.getComponentInstancesProperties()
-                .get(componentInstanceDetails.getUniqueId());
-        if (propList != null) {
-            return getPropFromListByPropNameAndType(propList, name, type);
-        }
-        return null;
-    }
-
-    private static void updatePropertyListWithPathParameter(Resource resource, List<String> path,
-                                                            List<ComponentInstanceProperty> expectedPropertyList) {
-        List<PropertyDefinition> propertyList = resource.getProperties();
-        for (PropertyDefinition propertyDefinition : propertyList) {
-            ComponentInstanceProperty propDetailsToRemove = PropertyRestUtils.getPropFromListByPropNameAndType(
-                    expectedPropertyList, propertyDefinition.getName(), propertyDefinition.getType());
-            ComponentInstanceProperty propDetailsToAdd = propDetailsToRemove;
-            propDetailsToAdd.setPath(path);
-            expectedPropertyList.remove(propDetailsToRemove);
-            expectedPropertyList.add(propDetailsToAdd);
-        }
-    }
-
-    private static void updatePropertyListWithPathParameterOnCompInst(Service service, List<String> path,
-                                                                      List<ComponentInstanceProperty> expectedPropertyList) {
-        List<ComponentInstanceProperty> servicePropertyList = new ArrayList<>();
-        servicePropertyList = PropertyRestUtils.addComponentInstPropertiesToList(service, servicePropertyList,
-                path.get(0));
-
-        for (ComponentInstanceProperty serviceCompInstProperty : servicePropertyList) {
-            ComponentInstanceProperty propDetailsToRemove = PropertyRestUtils.getPropFromListByPropNameTypeAndPath(
-                    expectedPropertyList, serviceCompInstProperty.getName(), serviceCompInstProperty.getType(),
-                    serviceCompInstProperty.getPath());
-            ComponentInstanceProperty propDetailsToAdd = propDetailsToRemove;
-            List<String> tempPathList = new ArrayList<String>();
-            for (String tempPath : path) {
-                tempPathList.add(tempPath);
-            }
-            // path parameter can not contain the same service unique ID twice
-            if (propDetailsToAdd.getPath() != null
-                    && !propDetailsToAdd.getPath().get(0).contains(service.getUniqueId())) {
-                if (!propDetailsToAdd.getPath().containsAll(tempPathList)) {
-                    tempPathList.addAll(propDetailsToAdd.getPath());
-                }
-            }
-            propDetailsToAdd.setPath(tempPathList);
-            expectedPropertyList.remove(propDetailsToRemove);
-            expectedPropertyList.add(propDetailsToAdd);
-        }
-    }
-
-    public static void updatePropertyListWithPathOnResource(ComponentInstance componentInstDetails, Resource resource,
-                                                            List<ComponentInstanceProperty> list, Component container) {
-        List<String> path = new ArrayList<>();
-        if (container != null) {
-            List<ComponentInstance> componentInstances = container.getComponentInstances();
-            for (ComponentInstance componentInstance : componentInstances) {
-                if (componentInstance.getNormalizedName().equals(componentInstDetails.getNormalizedName())) {
-                    path.add(componentInstance.getUniqueId());
-                    break;
-                }
-            }
-
-        } else {
-            path.add(componentInstDetails.getUniqueId());
-        }
-        updatePropertyListWithPathParameter(resource, path, list);
-    }
-
-    public static void updatePropertyListWithPathOnComponentInstance(ComponentInstance componentInstDetails,
-                                                                     Service service, List<ComponentInstanceProperty> list) {
-        List<String> path = new ArrayList<>();
-        path.add(componentInstDetails.getUniqueId());
-        updatePropertyListWithPathParameterOnCompInst(service, path, list);
-    }
-
-    public static RestResponse declareProporties(Component componentObject, Map<String, List<ComponentInstanceInput>> componentInstancesInputs, User sdncModifierDetails)
-            throws Exception {
-        Config config = Config.instance();
-        String url = String.format(Urls.DECLARE_PROPERTIES, config.getCatalogBeHost(), config.getCatalogBePort(), ComponentTypeEnum.findParamByType(componentObject.getComponentType()), componentObject.getUniqueId());
-        String userId = sdncModifierDetails.getUserId();
-        Map<String, String> headersMap = prepareHeadersMap(userId);
-        Map<String, Object> jsonBuilder = new HashMap<>();
-        jsonBuilder.put("componentInstanceInputsMap", componentInstancesInputs);
-        Gson gson = new Gson();
-        String userBodyJson = gson.toJson(jsonBuilder);
-        String calculateMD5 = GeneralUtility.calculateMD5Base64EncodedByString(userBodyJson);
-        headersMap.put(HttpHeaderEnum.Content_MD5.getValue(), calculateMD5);
-        HttpRequest http = new HttpRequest();
-        // System.out.println(url);
-        // System.out.println(userBodyJson);
-        RestResponse declareProportiesResponse = http.httpSendPost(url, userBodyJson, headersMap);
-        if (declareProportiesResponse.getErrorCode() == STATUS_CODE_GET_SUCCESS) {
-
-        }
-        return declareProportiesResponse;
-    }
-
-    public static RestResponse updateInput(Component componentObject, PropertyObject componentInput, User sdncModifierDetails)
-            throws Exception {
-        Config config = Config.instance();
-        String url = String.format(Urls.UPDATE_INPUT, config.getCatalogBeHost(), config.getCatalogBePort(), componentObject.getUniqueId());
-        String userId = sdncModifierDetails.getUserId();
-        Map<String, String> headersMap = prepareHeadersMap(userId);
-        Gson gson = new Gson();
-        String userBodyJson = gson.toJson(componentInput);
-        String calculateMD5 = GeneralUtility.calculateMD5Base64EncodedByString(userBodyJson);
-        headersMap.put(HttpHeaderEnum.Content_MD5.getValue(), calculateMD5);
-        HttpRequest http = new HttpRequest();
-        // System.out.println(url);
-        // System.out.println(userBodyJson);
-        RestResponse declareProportiesResponse = http.httpSendPost(url, userBodyJson, headersMap);
-        if (declareProportiesResponse.getErrorCode() == STATUS_CODE_GET_SUCCESS) {
-
-        }
-        return declareProportiesResponse;
-    }
+	private static Logger logger = LoggerFactory.getLogger(PropertyRestUtils.class.getName());
+
+	public static RestResponse createProperty(String resourceId, String body, User user) throws Exception {
+		Config config = Config.instance();
+		String url = String.format(Urls.CREATE_PROPERTY, config.getCatalogBeHost(), config.getCatalogBePort(), resourceId);
+
+		return sendPost(url, body, user.getUserId(), acceptHeaderData);
+	}
+
+	public static RestResponse addValueToProperty(String resourceId, String body, User user) throws Exception {
+		Config config = Config.instance();
+		String url = String.format(Urls.CREATE_PROPERTY, config.getCatalogBeHost(), config.getCatalogBePort(), resourceId);
+
+		return sendPut(url, body, user.getUserId(), acceptHeaderData);
+	}
+
+	public static RestResponse createServiceProperty(String resourceId, String body, User user) throws Exception {
+		Config config = Config.instance();
+		String url = String.format(Urls.CREATE_SERVICE_PROPERTY, config.getCatalogBeHost(), config.getCatalogBePort(),
+				resourceId);
+
+		return sendPost(url, body, user.getUserId(), acceptHeaderData);
+	}
+
+	public static RestResponse updateProperty(String resourceId, String propertyId, String body, User user)
+			throws Exception {
+		Config config = Config.instance();
+
+		String url = String.format(Urls.UPDATE_PROPERTY, config.getCatalogBeHost(), config.getCatalogBePort(),
+				resourceId, propertyId);
+		return sendPut(url, body, user.getUserId(), acceptHeaderData);
+	}
+
+	public static RestResponse updateGroupProperty(Component component, String groupId, String body, User user)
+			throws Exception {
+		Config config = Config.instance();
+
+		String url = String.format(Urls.RESOURCE_GROUP_PROPERTY, config.getCatalogBeHost(), config.getCatalogBePort(), component.getUniqueId(), groupId);
+		return sendPut(url, body, user.getUserId(), acceptHeaderData);
+	}
+
+	public static RestResponse getProperty(String resourceId, String propertyId, User user) throws Exception {
+		Config config = Config.instance();
+		String url = String.format(Urls.GET_PROPERTY, config.getCatalogBeHost(), config.getCatalogBePort(), resourceId,
+				propertyId);
+		return sendGet(url, user.getUserId());
+	}
+
+	public static RestResponse deleteProperty(String resourceId, String propertyId, User user) throws Exception {
+		Config config = Config.instance();
+		String url = String.format(Urls.DELETE_PROPERTY, config.getCatalogBeHost(), config.getCatalogBePort(),
+				resourceId, propertyId);
+
+		return sendDelete(url, user.getUserId());
+	}
+
+	public static ComponentInstanceProperty getPropFromListByPropNameAndType(List<ComponentInstanceProperty> propList,
+																			 String propNameToUpdate, String propTypeToUpdate) {
+		for (ComponentInstanceProperty componentInstanceProperty : propList) {
+			if (componentInstanceProperty.getName().equals(propNameToUpdate)
+					&& componentInstanceProperty.getType().equals(propTypeToUpdate)) {
+				return componentInstanceProperty;
+			}
+		}
+		return null;
+	}
+
+	public static ComponentInstanceProperty getPropFromListByPropNameTypeAndPath(
+			List<ComponentInstanceProperty> propList, String propNameToUpdate, String propTypeToUpdate,
+			List<String> path) {
+		for (ComponentInstanceProperty componentInstanceProperty : propList) {
+			if (componentInstanceProperty.getPath() == null) {
+				return getPropFromListByPropNameAndType(propList, propNameToUpdate, propTypeToUpdate);
+			}
+			if (componentInstanceProperty.getName().equals(propNameToUpdate)
+					&& componentInstanceProperty.getType().equals(propTypeToUpdate)
+					&& path.containsAll(componentInstanceProperty.getPath())) {
+				return componentInstanceProperty;
+			}
+		}
+		return null;
+	}
+
+	public static ComponentInstanceProperty getPropFromListByPropIdAndPath(List<ComponentInstanceProperty> propList,
+																		   String propId, List<String> path) {
+
+		for (ComponentInstanceProperty componentInstanceProperty : propList) {
+			if (path != null) {
+				if (componentInstanceProperty.getUniqueId().equals(propId)
+						&& componentInstanceProperty.getPath().equals(path)) {
+					return componentInstanceProperty;
+				}
+			} else {
+				if (componentInstanceProperty.getUniqueId().equals(propId)) {
+					return componentInstanceProperty;
+				}
+			}
+		}
+		return null;
+	}
+
+	public static void comparePropertyLists(List<ComponentInstanceProperty> expectedList,
+											List<ComponentInstanceProperty> actualList, Boolean isUpdate) {
+
+		assertTrue(
+				"list size are not equals, expected size is: " + expectedList.size() + " ,actual: " + actualList.size(),
+				expectedList.size() == actualList.size());
+		Boolean flag = false;
+		for (ComponentInstanceProperty expectedcompInstProp : expectedList) {
+			for (ComponentInstanceProperty actualcompInstProp : actualList) {
+				flag = comparePropertyObjects(expectedcompInstProp, actualcompInstProp, isUpdate);
+				if (flag) {
+					break;
+				}
+			}
+		}
+		// System.out.println("expected: " + expectedList + ", actual: " +
+		// actualList);
+		logger.debug("expected: {}, actual: {}", expectedList, actualList);
+		assertTrue("actual lists does not contain all uniqeIds", flag);
+	}
+
+	public static Boolean comparePropertyObjects(ComponentInstanceProperty expectedCompInstProp,
+												 ComponentInstanceProperty actualCompInstProp, Boolean isUpdate) {
+		String uniqueId = expectedCompInstProp.getUniqueId();
+		String type = expectedCompInstProp.getType();
+		String defaulValue = (String) expectedCompInstProp.getDefaultValue();
+		if (actualCompInstProp.getUniqueId().equals(uniqueId)
+				&& actualCompInstProp.getPath().equals(expectedCompInstProp.getPath())) {
+			assertTrue("expected type is: " + type + " ,actual: " + actualCompInstProp.getType(),
+					actualCompInstProp.getType().equals(type));
+			if (defaulValue == null) {
+				assertTrue(
+						"expected defaulValue is: " + defaulValue + " ,actual: " + actualCompInstProp.getDefaultValue(),
+						actualCompInstProp.getDefaultValue() == defaulValue);
+			} else {
+				assertTrue(
+						"expected defaulValue is: " + defaulValue + " ,actual: " + actualCompInstProp.getDefaultValue(),
+						actualCompInstProp.getDefaultValue().equals(defaulValue));
+			}
+			if (isUpdate) {
+				assertTrue(
+						"actual [Value] parameter " + actualCompInstProp.getName()
+								+ "should equal to expected [Value]: " + actualCompInstProp.getValue() + " ,Value: "
+								+ actualCompInstProp.getValue(),
+						actualCompInstProp.getValue().equals(expectedCompInstProp.getValue()));
+				assertNotNull("valueId is null", actualCompInstProp.getValueUniqueUid());
+			} else {
+				if (defaulValue == null) {
+					assertTrue(
+							"actual [Value] parameter " + actualCompInstProp.getName()
+									+ "should equal to expected [defaultValue]: " + actualCompInstProp.getValue()
+									+ " ,defaultValue: " + actualCompInstProp.getDefaultValue(),
+							actualCompInstProp.getValue() == expectedCompInstProp.getDefaultValue());
+				} else {
+					assertTrue(
+							"actual [Value] parameter " + actualCompInstProp.getName()
+									+ "should equal to expected [defaultValue]: " + actualCompInstProp.getValue()
+									+ " ,defaultValue: " + actualCompInstProp.getDefaultValue(),
+							actualCompInstProp.getValue().equals(expectedCompInstProp.getDefaultValue()));
+				}
+				assertNull("valueId is not null", actualCompInstProp.getValueUniqueUid());
+			}
+			return true;
+		}
+		return false;
+	}
+
+	public static List<ComponentInstanceProperty> addResourcePropertiesToList(Resource resource,
+																			  List<ComponentInstanceProperty> listToFill) {
+		for (PropertyDefinition prop : resource.getProperties()) {
+			listToFill.add(new ComponentInstanceProperty(prop, null, null));
+		}
+		return listToFill;
+	}
+
+	public static List<ComponentInstanceProperty> addComponentInstPropertiesToList(Component component,
+																				   List<ComponentInstanceProperty> listToFill, String componentId) {
+
+		if (componentId != null) {
+			List<ComponentInstanceProperty> list = component.getComponentInstancesProperties().get(componentId);
+			for (ComponentInstanceProperty prop : list) {
+				ComponentInstanceProperty componentInstanceProperty = new ComponentInstanceProperty(prop, null, null);
+				componentInstanceProperty.setPath(prop.getPath());
+				componentInstanceProperty.setValueUniqueUid(prop.getValueUniqueUid());
+				componentInstanceProperty.setValue(prop.getValue());
+				listToFill.add(componentInstanceProperty);
+			}
+		} else {
+			Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = component
+					.getComponentInstancesProperties();
+			for (Map.Entry<String, List<ComponentInstanceProperty>> componentInstanceProperties : componentInstancesProperties
+					.entrySet()) {
+				for (ComponentInstanceProperty prop : componentInstanceProperties.getValue()) {
+					ComponentInstanceProperty componentInstanceProperty = new ComponentInstanceProperty(prop, null,
+							null);
+					componentInstanceProperty.setPath(prop.getPath());
+					componentInstanceProperty.setValueUniqueUid(prop.getValueUniqueUid());
+					componentInstanceProperty.setValue(prop.getValue());
+					listToFill.add(componentInstanceProperty);
+				}
+			}
+		}
+
+		if (component.getComponentType().getValue().equals("Resource")) {
+			for (PropertyDefinition prop : ((Resource) component).getProperties()) {
+				listToFill.add(new ComponentInstanceProperty(prop, null, null));
+			}
+		}
+		return listToFill;
+	}
+
+	public static ComponentInstanceProperty getCompPropInstListByInstIdAndPropName(Component component,
+																				   ComponentInstance componentInstanceDetails, String name, String type) {
+		List<ComponentInstanceProperty> propList = component.getComponentInstancesProperties()
+				.get(componentInstanceDetails.getUniqueId());
+		if (propList != null) {
+			return getPropFromListByPropNameAndType(propList, name, type);
+		}
+		return null;
+	}
+
+	private static void updatePropertyListWithPathParameter(Resource resource, List<String> path,
+															List<ComponentInstanceProperty> expectedPropertyList) {
+		List<PropertyDefinition> propertyList = resource.getProperties();
+		for (PropertyDefinition propertyDefinition : propertyList) {
+			ComponentInstanceProperty propDetailsToRemove = PropertyRestUtils.getPropFromListByPropNameAndType(
+					expectedPropertyList, propertyDefinition.getName(), propertyDefinition.getType());
+			ComponentInstanceProperty propDetailsToAdd = propDetailsToRemove;
+			propDetailsToAdd.setPath(path);
+			expectedPropertyList.remove(propDetailsToRemove);
+			expectedPropertyList.add(propDetailsToAdd);
+		}
+	}
+
+	private static void updatePropertyListWithPathParameterOnCompInst(Service service, List<String> path,
+																	  List<ComponentInstanceProperty> expectedPropertyList) {
+		List<ComponentInstanceProperty> servicePropertyList = new ArrayList<>();
+		servicePropertyList = PropertyRestUtils.addComponentInstPropertiesToList(service, servicePropertyList,
+				path.get(0));
+
+		for (ComponentInstanceProperty serviceCompInstProperty : servicePropertyList) {
+			ComponentInstanceProperty propDetailsToRemove = PropertyRestUtils.getPropFromListByPropNameTypeAndPath(
+					expectedPropertyList, serviceCompInstProperty.getName(), serviceCompInstProperty.getType(),
+					serviceCompInstProperty.getPath());
+			ComponentInstanceProperty propDetailsToAdd = propDetailsToRemove;
+			List<String> tempPathList = new ArrayList<String>();
+			for (String tempPath : path) {
+				tempPathList.add(tempPath);
+			}
+			// path parameter can not contain the same service unique ID twice
+			if (propDetailsToAdd.getPath() != null
+					&& !propDetailsToAdd.getPath().get(0).contains(service.getUniqueId())) {
+				if (!propDetailsToAdd.getPath().containsAll(tempPathList)) {
+					tempPathList.addAll(propDetailsToAdd.getPath());
+				}
+			}
+			propDetailsToAdd.setPath(tempPathList);
+			expectedPropertyList.remove(propDetailsToRemove);
+			expectedPropertyList.add(propDetailsToAdd);
+		}
+	}
+
+	public static void updatePropertyListWithPathOnResource(ComponentInstance componentInstDetails, Resource resource,
+															List<ComponentInstanceProperty> list, Component container) {
+		List<String> path = new ArrayList<>();
+		if (container != null) {
+			List<ComponentInstance> componentInstances = container.getComponentInstances();
+			for (ComponentInstance componentInstance : componentInstances) {
+				if (componentInstance.getNormalizedName().equals(componentInstDetails.getNormalizedName())) {
+					path.add(componentInstance.getUniqueId());
+					break;
+				}
+			}
+
+		} else {
+			path.add(componentInstDetails.getUniqueId());
+		}
+		updatePropertyListWithPathParameter(resource, path, list);
+	}
+
+	public static void updatePropertyListWithPathOnComponentInstance(ComponentInstance componentInstDetails,
+																	 Service service, List<ComponentInstanceProperty> list) {
+		List<String> path = new ArrayList<>();
+		path.add(componentInstDetails.getUniqueId());
+		updatePropertyListWithPathParameterOnCompInst(service, path, list);
+	}
+
+	public static RestResponse declareProporties(Component componentObject, Map<String, List<ComponentInstanceInput>> componentInstancesInputs, User sdncModifierDetails)
+			throws Exception {
+		Config config = Config.instance();
+		String url = String.format(Urls.DECLARE_PROPERTIES, config.getCatalogBeHost(), config.getCatalogBePort(), ComponentTypeEnum.findParamByType(componentObject.getComponentType()), componentObject.getUniqueId());
+		String userId = sdncModifierDetails.getUserId();
+		Map<String, String> headersMap = prepareHeadersMap(userId);
+		Map<String, Object> jsonBuilder = new HashMap<>();
+		jsonBuilder.put("componentInstanceInputsMap", componentInstancesInputs);
+		Gson gson = new Gson();
+		String userBodyJson = gson.toJson(jsonBuilder);
+		String calculateMD5 = GeneralUtility.calculateMD5Base64EncodedByString(userBodyJson);
+		headersMap.put(HttpHeaderEnum.Content_MD5.getValue(), calculateMD5);
+		HttpRequest http = new HttpRequest();
+		// System.out.println(url);
+		// System.out.println(userBodyJson);
+		RestResponse declareProportiesResponse = http.httpSendPost(url, userBodyJson, headersMap);
+		if (declareProportiesResponse.getErrorCode() == STATUS_CODE_GET_SUCCESS) {
+
+		}
+		return declareProportiesResponse;
+	}
+
+	public static RestResponse updateInput(Component componentObject, PropertyObject componentInput, User sdncModifierDetails)
+			throws Exception {
+		Config config = Config.instance();
+		String url = String.format(Urls.UPDATE_INPUT, config.getCatalogBeHost(), config.getCatalogBePort(), componentObject.getUniqueId());
+		String userId = sdncModifierDetails.getUserId();
+		Map<String, String> headersMap = prepareHeadersMap(userId);
+		Gson gson = new Gson();
+		String userBodyJson = gson.toJson(componentInput);
+		String calculateMD5 = GeneralUtility.calculateMD5Base64EncodedByString(userBodyJson);
+		headersMap.put(HttpHeaderEnum.Content_MD5.getValue(), calculateMD5);
+		HttpRequest http = new HttpRequest();
+		// System.out.println(url);
+		// System.out.println(userBodyJson);
+		RestResponse declareProportiesResponse = http.httpSendPost(url, userBodyJson, headersMap);
+		if (declareProportiesResponse.getErrorCode() == STATUS_CODE_GET_SUCCESS) {
+
+		}
+		return declareProportiesResponse;
+	}
 }
author	siddharth0905 <siddharth.singh4@amdocs.com>	2019-04-10 17:49:51 +0530
committer	Avi Gaffa <avi.gaffa@amdocs.com>	2019-04-11 07:11:04 +0000
commit	6896c1b309aaa50dca820169b9f1ae3f8af84294 (patch)
tree	8da13382863f2e4adc9724dd046b535032ae58c7
parent	4568e48647b15b5654a669651ddf536d590288b0 (diff)