Centralize TOSCA function validation

The validation happening in the component instance properties,
should also be applied for the Group instance properties and
Policy instance properties.
Fixes some other problems related to the TOSCA function.

Change-Id: I4b69da57a8444b78c72561f49146d32c6911482e
Issue-ID: SDC-4114
Signed-off-by: andre.schmid <andre.schmid@est.tech>

4 files changed, 244 insertions, 84 deletions

diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/api/IGroupOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/api/IGroupOperation.java
index ccf7148f84..04d3a0bebe 100644
--- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/api/IGroupOperation.java
+++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/api/IGroupOperation.java
@@ -23,19 +23,26 @@ import fj.data.Either;
 import java.util.List;
 import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation;
 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
+import org.openecomp.sdc.be.model.Component;
 import org.openecomp.sdc.be.model.GroupProperty;
 import org.openecomp.sdc.be.resources.data.ArtifactData;
 
 public interface IGroupOperation {
 
-    public Either<List<GraphRelation>, StorageOperationStatus> dissociateAllGroupsFromArtifactOnGraph(String componentId,
-                                                                                                      NodeTypeEnum componentTypeEnum,
-                                                                                                      String artifactId);
+    Either<List<GraphRelation>, StorageOperationStatus> dissociateAllGroupsFromArtifactOnGraph(String componentId, NodeTypeEnum componentTypeEnum,
+                                                                                               String artifactId);
 
-    public StorageOperationStatus dissociateAndAssociateGroupsFromArtifact(String componentId, NodeTypeEnum componentTypeEnum, String oldArtifactId,
-                                                                           ArtifactData newArtifact, boolean inTransaction);
+    StorageOperationStatus dissociateAndAssociateGroupsFromArtifact(String componentId, NodeTypeEnum componentTypeEnum, String oldArtifactId,
+                                                                    ArtifactData newArtifact, boolean inTransaction);
 
-    public boolean isGroupExist(String groupName, boolean inTransaction);
+    boolean isGroupExist(String groupName, boolean inTransaction);
 
-    public StorageOperationStatus validateAndUpdatePropertyValue(GroupProperty property);
+    /**
+     * Validates and updates the given property value based on the property type
+     *
+     * @param groupOwner the container component that owns the group instance that has the property
+     * @param property   the group instance property to validate
+     * @return the status of the operation
+     */
+    StorageOperationStatus validateAndUpdatePropertyValue(Component groupOwner, GroupProperty property);
 }
diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/GroupInstanceOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/GroupInstanceOperation.java
index c463af691c..67d9755808 100644
--- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/GroupInstanceOperation.java
+++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/GroupInstanceOperation.java
@@ -56,6 +56,7 @@ import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
 import org.openecomp.sdc.be.model.operations.api.IGroupInstanceOperation;
 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
 import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
+import org.openecomp.sdc.be.model.validation.ToscaFunctionValidator;
 import org.openecomp.sdc.be.resources.data.ArtifactData;
 import org.openecomp.sdc.be.resources.data.GroupInstanceData;
 import org.openecomp.sdc.be.resources.data.PropertyData;
@@ -71,12 +72,20 @@ public class GroupInstanceOperation extends AbstractOperation implements IGroupI
     private static final String UPDATE_PROPERTY_VALUE_ON_COMPONENT_INSTANCE = "UpdatePropertyValueOnComponentInstance";
     private static final String FAILED_TO_UPDATE_PROPERTY_VALUE_ON_INSTANCE_STATUS_IS = "Failed to update property value on instance. Status is ";
     private static final Logger log = Logger.getLogger(GroupInstanceOperation.class.getName());
+    private final GroupOperation groupOperation;
+    private final PropertyOperation propertyOperation;
+    private final ToscaFunctionValidator toscaFunctionValidator;
+    private final ApplicationDataTypeCache applicationDataTypeCache;
+
     @Autowired
-    GroupOperation groupOperation;
-    @Autowired
-    PropertyOperation propertyOperation;
-    @javax.annotation.Resource
-    private ApplicationDataTypeCache applicationDataTypeCache;
+    public GroupInstanceOperation(final GroupOperation groupOperation, final PropertyOperation propertyOperation,
+                                  final ToscaFunctionValidator toscaFunctionValidator,
+                                  final ApplicationDataTypeCache applicationDataTypeCache) {
+        this.groupOperation = groupOperation;
+        this.propertyOperation = propertyOperation;
+        this.toscaFunctionValidator = toscaFunctionValidator;
+        this.applicationDataTypeCache = applicationDataTypeCache;
+    }
 
     public Either<List<GroupInstance>, StorageOperationStatus> getAllGroupInstances(String parentId, NodeTypeEnum parentType) {
         Either<List<GroupInstance>, StorageOperationStatus> result = null;
@@ -358,46 +367,47 @@ public class GroupInstanceOperation extends AbstractOperation implements IGroupI
      *
      * @return
      */
-    public Either<PropertyValueData, JanusGraphOperationStatus> updatePropertyOfGroupInstance(ComponentInstanceProperty groupInstanceProerty,
+    public Either<PropertyValueData, JanusGraphOperationStatus> updatePropertyOfGroupInstance(ComponentInstanceProperty groupInstanceProperty,
                                                                                               String groupInstanceId) {
         Wrapper<JanusGraphOperationStatus> errorWrapper = new Wrapper<>();
         UpdateDataContainer<PropertyData, PropertyValueData> updateDataContainer = new UpdateDataContainer<>(GraphEdgeLabels.PROPERTY_IMPL,
             (() -> PropertyData.class), (() -> PropertyValueData.class), NodeTypeEnum.Property, NodeTypeEnum.PropertyValue);
-        preUpdateElementOfResourceInstanceValidations(updateDataContainer, groupInstanceProerty, groupInstanceId, errorWrapper);
+        preUpdateElementOfResourceInstanceValidations(updateDataContainer, groupInstanceProperty, groupInstanceId, errorWrapper);
         if (!errorWrapper.isEmpty()) {
             return Either.right(errorWrapper.getInnerElement());
+        }
+
+        String value = groupInstanceProperty.getValue();
+        // Specific Validation Logic
+        PropertyData propertyData = updateDataContainer.getDataWrapper().getInnerElement();
+        PropertyDataDefinition propDataDef = propertyData.getPropertyDataDefinition();
+        String propertyType = propDataDef.getType();
+        final ToscaPropertyType type = ToscaPropertyType.isValidType(propertyType);
+        log.debug("The type of the property {} is {}", propertyData.getUniqueId(), propertyType);
+        final Either<String, JanusGraphOperationStatus> innerTypeEither = propertyOperation.getInnerType(type, propDataDef::getSchema);
+        if (innerTypeEither.isRight()) {
+            return Either.right(innerTypeEither.right().value());
+        }
+        // Specific Update Logic
+        Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes =
+            applicationDataTypeCache.getAll(groupInstanceProperty.getModel());
+        if (allDataTypes.isRight()) {
+            JanusGraphOperationStatus status = allDataTypes.right().value();
+            BeEcompErrorManager.getInstance()
+                .logInternalFlowError(UPDATE_PROPERTY_VALUE_ON_COMPONENT_INSTANCE, FAILED_TO_UPDATE_PROPERTY_VALUE_ON_INSTANCE_STATUS_IS + status,
+                    ErrorSeverity.ERROR);
+            return Either.right(status);
+        }
+        PropertyValueData propertyValueData = updateDataContainer.getValueDataWrapper().getInnerElement();
+        if (propDataDef.isToscaFunction()) {
+            Either<GroupInstanceData, JanusGraphOperationStatus> findResInstanceRes = janusGraphGenericDao
+                .getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.GroupInstance), groupInstanceId, GroupInstanceData.class);
+            final GroupInstanceData groupInstanceData = findResInstanceRes.left().value();
+            //TODO fix
+            toscaFunctionValidator.validate(propDataDef, null);
+            propertyValueData.setValue(propDataDef.getToscaFunction().getValue());
         } else {
-            String value = groupInstanceProerty.getValue();
-            // Specific Validation Logic
-            PropertyData propertyData = updateDataContainer.getDataWrapper().getInnerElement();
-            String innerType = null;
-            PropertyDataDefinition propDataDef = propertyData.getPropertyDataDefinition();
-            String propertyType = propDataDef.getType();
-            ToscaPropertyType type = ToscaPropertyType.isValidType(propertyType);
-            log.debug("The type of the property {} is {}", propertyData.getUniqueId(), propertyType);
-            if (type == ToscaPropertyType.LIST || type == ToscaPropertyType.MAP) {
-                SchemaDefinition def = propDataDef.getSchema();
-                if (def == null) {
-                    log.debug("Schema doesn't exists for property of type {}", type);
-                    return Either.right(JanusGraphOperationStatus.ILLEGAL_ARGUMENT);
-                }
-                PropertyDataDefinition propDef = def.getProperty();
-                if (propDef == null) {
-                    log.debug("Property in Schema Definition inside property of type {} doesn't exist", type);
-                    return Either.right(JanusGraphOperationStatus.ILLEGAL_ARGUMENT);
-                }
-                innerType = propDef.getType();
-            }
-            // Specific Update Logic
-            Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes =
-                applicationDataTypeCache.getAll(groupInstanceProerty.getModel());
-            if (allDataTypes.isRight()) {
-                JanusGraphOperationStatus status = allDataTypes.right().value();
-                BeEcompErrorManager.getInstance()
-                    .logInternalFlowError(UPDATE_PROPERTY_VALUE_ON_COMPONENT_INSTANCE, FAILED_TO_UPDATE_PROPERTY_VALUE_ON_INSTANCE_STATUS_IS + status,
-                        ErrorSeverity.ERROR);
-                return Either.right(status);
-            }
+            final String innerType = innerTypeEither.left().value();
             Either<Object, Boolean> isValid = propertyOperation
                 .validateAndUpdatePropertyValue(propertyType, value, innerType, allDataTypes.left().value());
             String newValue = value;
@@ -412,25 +422,25 @@ public class GroupInstanceOperation extends AbstractOperation implements IGroupI
                     newValue = object.toString();
                 }
             }
-            PropertyValueData propertyValueData = updateDataContainer.getValueDataWrapper().getInnerElement();
             log.debug("Going to update property value from {} to {}", propertyValueData.getValue(), newValue);
             propertyValueData.setValue(newValue);
             ImmutablePair<String, Boolean> pair = propertyOperation
-                .validateAndUpdateRules(propertyType, groupInstanceProerty.getRules(), innerType, allDataTypes.left().value(), true);
+                .validateAndUpdateRules(propertyType, groupInstanceProperty.getRules(), innerType, allDataTypes.left().value(), true);
             if (pair.getRight() != null && !pair.getRight()) {
                 BeEcompErrorManager.getInstance()
-                    .logBeInvalidValueError("Add property value", pair.getLeft(), groupInstanceProerty.getName(), propertyType);
+                    .logBeInvalidValueError("Add property value", pair.getLeft(), groupInstanceProperty.getName(), propertyType);
                 return Either.right(JanusGraphOperationStatus.ILLEGAL_ARGUMENT);
             }
-            propertyOperation.updateRulesInPropertyValue(propertyValueData, groupInstanceProerty, groupInstanceId);
-            Either<PropertyValueData, JanusGraphOperationStatus> updateRes = janusGraphGenericDao
-                .updateNode(propertyValueData, PropertyValueData.class);
-            if (updateRes.isRight()) {
-                JanusGraphOperationStatus status = updateRes.right().value();
-                return Either.right(status);
-            } else {
-                return Either.left(updateRes.left().value());
-            }
+        }
+
+        propertyOperation.updateRulesInPropertyValue(propertyValueData, groupInstanceProperty, groupInstanceId);
+        Either<PropertyValueData, JanusGraphOperationStatus> updateRes = janusGraphGenericDao
+            .updateNode(propertyValueData, PropertyValueData.class);
+        if (updateRes.isRight()) {
+            JanusGraphOperationStatus status = updateRes.right().value();
+            return Either.right(status);
+        } else {
+            return Either.left(updateRes.left().value());
         }
     }
 
diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/GroupOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/GroupOperation.java
index a57f32d336..ce4696fa9f 100644
--- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/GroupOperation.java
+++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/GroupOperation.java
@@ -34,9 +34,9 @@ import org.apache.commons.lang3.tuple.ImmutablePair;
 import org.openecomp.sdc.be.config.BeEcompErrorManager;
 import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
 import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation;
+import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
-import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
 import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
 import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
@@ -44,6 +44,7 @@ import org.openecomp.sdc.be.dao.utils.MapUtil;
 import org.openecomp.sdc.be.datatypes.elements.GroupDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
+import org.openecomp.sdc.be.model.Component;
 import org.openecomp.sdc.be.model.DataTypeDefinition;
 import org.openecomp.sdc.be.model.GroupDefinition;
 import org.openecomp.sdc.be.model.GroupProperty;
@@ -62,9 +63,8 @@ import org.openecomp.sdc.be.resources.data.PropertyData;
 import org.openecomp.sdc.be.resources.data.PropertyValueData;
 import org.openecomp.sdc.be.resources.data.UniqueIdData;
 import org.openecomp.sdc.common.log.wrappers.Logger;
-import org.springframework.stereotype.Component;
 
-@Component
+@org.springframework.stereotype.Component
 public class GroupOperation extends AbstractOperation implements IGroupOperation {
 
     private static final Logger log = Logger.getLogger(GroupOperation.class.getName());
@@ -481,33 +481,20 @@ public class GroupOperation extends AbstractOperation implements IGroupOperation
         return result;
     }
 
-    public StorageOperationStatus validateAndUpdatePropertyValue(GroupProperty property) {
-        StorageOperationStatus result = null;
-        String innerType =
-            property.getSchema() == null ? null : property.getSchema().getProperty() == null ? null : property.getSchema().getProperty().getType();
+    public StorageOperationStatus validateAndUpdatePropertyValue(final Component groupOwner, final GroupProperty property) {
         Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = applicationDataTypeCache.getAll(property.getModel());
-        Either<Object, Boolean> isValid = null;
         if (allDataTypes.isRight()) {
             JanusGraphOperationStatus status = allDataTypes.right().value();
             log.debug("Failed to fetch data types from cache. Status is {}. ", status);
-            result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status);
-        }
-        if (result == null) {
-            isValid = propertyOperation.validateAndUpdatePropertyValue(property.getType(), property.getValue(), innerType,
-                allDataTypes.left().value());
-            if (isValid.isRight()) {
-                log.debug("Failed to validate property value {}. Status is {}. ", property.getValue(), StorageOperationStatus.INVALID_PROPERTY);
-                result = StorageOperationStatus.INVALID_PROPERTY;
-            }
+            return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status);
         }
-        if (result == null) {
-            if (isValid.left().value() != null) {
-                String validValue = String.valueOf(isValid.left().value());
-                property.setValue(validValue);
-            }
-            result = StorageOperationStatus.OK;
+
+        Either<Object, Boolean> isValid = propertyOperation.validateAndUpdatePropertyValue(groupOwner, property,  allDataTypes.left().value());
+        if (isValid.isRight()) {
+            log.debug("Failed to validate property value {}. Status is {}. ", property.getValue(), StorageOperationStatus.INVALID_PROPERTY);
+            return StorageOperationStatus.INVALID_PROPERTY;
         }
-        return result;
+        return StorageOperationStatus.OK;
     }
 
     public StorageOperationStatus updateGroupProperties(org.openecomp.sdc.be.model.Component containerComponent, String groupId,
diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/PropertyOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/PropertyOperation.java
index 931d5993ea..b66f6c9433 100644
--- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/PropertyOperation.java
+++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/PropertyOperation.java
@@ -76,11 +76,13 @@ import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.PropertyRule;
 import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
+import org.openecomp.sdc.be.model.Component;
 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
 import org.openecomp.sdc.be.model.DataTypeDefinition;
 import org.openecomp.sdc.be.model.IComplexDefaultValue;
 import org.openecomp.sdc.be.model.PropertyConstraint;
 import org.openecomp.sdc.be.model.PropertyDefinition;
+import org.openecomp.sdc.be.model.validation.ToscaFunctionValidator;
 import org.openecomp.sdc.be.model.operations.api.DerivedFromOperation;
 import org.openecomp.sdc.be.model.operations.api.IPropertyOperation;
 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
@@ -103,9 +105,8 @@ import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
 import org.openecomp.sdc.be.resources.data.UniqueIdData;
 import org.openecomp.sdc.common.log.wrappers.Logger;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Component;
 
-@Component("property-operation")
+@org.springframework.stereotype.Component("property-operation")
 public class PropertyOperation extends AbstractOperation implements IPropertyOperation {
 
     private static final String AFTER_RETRIEVING_DERIVED_FROM_NODE_OF_STATUS_IS = "After retrieving DERIVED_FROM node of {}. status is {}";
@@ -121,6 +122,7 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe
     private static final String UPDATE_DATA_TYPE = "UpdateDataType";
     private static final Logger log = Logger.getLogger(PropertyOperation.class.getName());
     private final DerivedFromOperation derivedFromOperation;
+    private ToscaFunctionValidator toscaFunctionValidator;
     private DataTypeOperation dataTypeOperation;
 
     @Autowired
@@ -129,6 +131,11 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe
         this.derivedFromOperation = derivedFromOperation;
     }
 
+    @Autowired
+    public void setToscaFunctionValidator(final ToscaFunctionValidator toscaFunctionValidator) {
+        this.toscaFunctionValidator = toscaFunctionValidator;
+    }
+
     //circular dependency DataTypeOperation->ModelOperation->ModelElementOperation->PropertyOperation
     @Autowired
     public void setDataTypeOperation(DataTypeOperation dataTypeOperation) {
@@ -1645,7 +1652,7 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe
     public Either<Object, Boolean> validateAndUpdatePropertyValue(String propertyType, String value, boolean isValidate, String innerType,
                                                                   Map<String, DataTypeDefinition> dataTypes) {
         log.trace("Going to validate property value and its type. type = {}, value = {}", propertyType, value);
-        ToscaPropertyType type = getType(propertyType);
+        final ToscaPropertyType type = getType(propertyType);
         if (isValidate) {
             if (type == null) {
                 DataTypeDefinition dataTypeDefinition = dataTypes.get(propertyType);
@@ -1679,6 +1686,155 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe
         return validateAndUpdatePropertyValue(propertyType, value, true, innerType, dataTypes);
     }
 
+    public Either<Object, Boolean> validateAndUpdatePropertyValue(final Component containerComponent, final PropertyDataDefinition property,
+                                                                  final Map<String, DataTypeDefinition> dataTypes) {
+        if (property.isToscaFunction()) {
+            toscaFunctionValidator.validate(property, containerComponent);
+            property.setValue(property.getToscaFunction().getValue());
+            return Either.left(property.getValue());
+        }
+        Either<String, JanusGraphOperationStatus> checkInnerType = checkInnerType(property);
+        if (checkInnerType.isRight()) {
+            return Either.right(false);
+        }
+        final String innerType = checkInnerType.left().value();
+        return validateAndUpdatePropertyValue(property.getType(), property.getValue(), true, innerType, dataTypes);
+    }
+
+//    private <T extends PropertyDefinition> void validateToscaGetFunction(T property, org.openecomp.sdc.be.model.Component parentComponent) {
+//        final ToscaGetFunctionDataDefinition toscaGetFunction = (ToscaGetFunctionDataDefinition) property.getToscaFunction();
+//        validateGetToscaFunctionAttributes(toscaGetFunction);
+//        validateGetPropertySource(toscaGetFunction.getFunctionType(), toscaGetFunction.getPropertySource());
+//        if (toscaGetFunction.getFunctionType() == ToscaGetFunctionType.GET_INPUT) {
+//            validateGetFunction(property, parentComponent.getInputs(), parentComponent.getModel());
+//            return;
+//        }
+//        if (toscaGetFunction.getFunctionType() == ToscaGetFunctionType.GET_PROPERTY) {
+//            if (toscaGetFunction.getPropertySource() == PropertySource.SELF) {
+//                validateGetFunction(property, parentComponent.getProperties(), parentComponent.getModel());
+//            } else if (toscaGetFunction.getPropertySource() == PropertySource.INSTANCE) {
+//                final ComponentInstance componentInstance =
+//                    parentComponent.getComponentInstanceById(toscaGetFunction.getSourceUniqueId())
+//                        .orElseThrow(ToscaGetFunctionExceptionSupplier.instanceNotFound(toscaGetFunction.getSourceName()));
+//                validateGetFunction(property, componentInstance.getProperties(), parentComponent.getModel());
+//            }
+//
+//            return;
+//        }
+//        if (toscaGetFunction.getFunctionType() == ToscaGetFunctionType.GET_ATTRIBUTE) {
+//            if (toscaGetFunction.getPropertySource() == PropertySource.SELF) {
+//                validateGetFunction(property, parentComponent.getAttributes(), parentComponent.getModel());
+//            } else if (toscaGetFunction.getPropertySource() == PropertySource.INSTANCE) {
+//                final ComponentInstance componentInstance =
+//                    parentComponent.getComponentInstanceById(toscaGetFunction.getSourceUniqueId())
+//                        .orElseThrow(ToscaGetFunctionExceptionSupplier.instanceNotFound(toscaGetFunction.getSourceName()));
+//                validateGetFunction(property, componentInstance.getAttributes(), parentComponent.getModel());
+//            }
+//
+//            return;
+//        }
+//
+//        throw ToscaGetFunctionExceptionSupplier.functionNotSupported(toscaGetFunction.getFunctionType()).get();
+//    }
+
+//    private <T extends PropertyDefinition> void validateGetFunction(final T property,
+//                                                                    final List<? extends ToscaPropertyData> parentProperties,
+//                                                                    final String model) {
+//        final ToscaGetFunctionDataDefinition toscaGetFunction = (ToscaGetFunctionDataDefinition) property.getToscaFunction();
+//        if (CollectionUtils.isEmpty(parentProperties)) {
+//            throw ToscaGetFunctionExceptionSupplier
+//                .propertyNotFoundOnTarget(toscaGetFunction.getPropertyName(), toscaGetFunction.getPropertySource(),
+//                    toscaGetFunction.getFunctionType()
+//                ).get();
+//        }
+//        final String getFunctionPropertyUniqueId = toscaGetFunction.getPropertyUniqueId();
+//        ToscaPropertyData referredProperty = parentProperties.stream()
+//            .filter(property1 -> getFunctionPropertyUniqueId.equals(property1.getUniqueId()))
+//            .findFirst()
+//            .orElseThrow(ToscaGetFunctionExceptionSupplier
+//                .propertyNotFoundOnTarget(toscaGetFunction.getPropertyName(), toscaGetFunction.getPropertySource()
+//                    , toscaGetFunction.getFunctionType())
+//            );
+//        if (toscaGetFunction.isSubProperty()) {
+//            referredProperty = findSubProperty(referredProperty, toscaGetFunction, model);
+//        }
+//
+//        if (!property.getType().equals(referredProperty.getType())) {
+//            throw ToscaGetFunctionExceptionSupplier
+//                .propertyTypeDiverge(toscaGetFunction.getType(), referredProperty.getType(), property.getType()).get();
+//        }
+//        if (PropertyType.typeHasSchema(referredProperty.getType()) && !referredProperty.getSchemaType().equals(property.getSchemaType())) {
+//            throw ToscaGetFunctionExceptionSupplier
+//                .propertySchemaDiverge(toscaGetFunction.getType(), referredProperty.getSchemaType(), property.getSchemaType()).get();
+//        }
+//    }
+
+//    private void validateGetToscaFunctionAttributes(final ToscaGetFunctionDataDefinition toscaGetFunction) {
+//        if (toscaGetFunction.getFunctionType() == null) {
+//            throw ToscaGetFunctionExceptionSupplier.targetFunctionTypeNotFound().get();
+//        }
+//        if (toscaGetFunction.getPropertySource() == null) {
+//            throw ToscaGetFunctionExceptionSupplier.targetPropertySourceNotFound(toscaGetFunction.getFunctionType()).get();
+//        }
+//        if (CollectionUtils.isEmpty(toscaGetFunction.getPropertyPathFromSource())) {
+//            throw ToscaGetFunctionExceptionSupplier
+//                .targetSourcePathNotFound(toscaGetFunction.getFunctionType()).get();
+//        }
+//        if (StringUtils.isEmpty(toscaGetFunction.getSourceName()) || StringUtils.isBlank(toscaGetFunction.getSourceName())) {
+//            throw ToscaGetFunctionExceptionSupplier.sourceNameNotFound(toscaGetFunction.getPropertySource()).get();
+//        }
+//        if (StringUtils.isEmpty(toscaGetFunction.getSourceUniqueId()) || StringUtils.isBlank(toscaGetFunction.getSourceUniqueId())) {
+//            throw ToscaGetFunctionExceptionSupplier.sourceIdNotFound(toscaGetFunction.getPropertySource()).get();
+//        }
+//        if (StringUtils.isEmpty(toscaGetFunction.getPropertyName()) || StringUtils.isBlank(toscaGetFunction.getPropertyName())) {
+//            throw ToscaGetFunctionExceptionSupplier.propertyNameNotFound(toscaGetFunction.getPropertySource()).get();
+//        }
+//        if (StringUtils.isEmpty(toscaGetFunction.getPropertyUniqueId()) || StringUtils.isBlank(toscaGetFunction.getPropertyUniqueId())) {
+//            throw ToscaGetFunctionExceptionSupplier.propertyIdNotFound(toscaGetFunction.getPropertySource()).get();
+//        }
+//    }
+
+//    private void validateGetPropertySource(final ToscaGetFunctionType functionType, final PropertySource propertySource) {
+//        if (functionType == ToscaGetFunctionType.GET_INPUT && propertySource != PropertySource.SELF) {
+//            throw ToscaGetFunctionExceptionSupplier
+//                .targetSourceNotSupported(functionType, propertySource).get();
+//        }
+//        if (functionType == ToscaGetFunctionType.GET_PROPERTY && !List.of(PropertySource.SELF, PropertySource.INSTANCE).contains(propertySource)) {
+//            throw ToscaGetFunctionExceptionSupplier
+//                .targetSourceNotSupported(functionType, propertySource).get();
+//        }
+//    }
+
+//    private ToscaPropertyData findSubProperty(final ToscaPropertyData referredProperty,
+//                                              final ToscaGetFunctionDataDefinition toscaGetFunction,
+//                                              final String model) {
+//        final Map<String, DataTypeDefinition> dataTypeMap = loadDataTypes(model);
+//        final List<String> propertyPathFromSource = toscaGetFunction.getPropertyPathFromSource();
+//        DataTypeDefinition dataType = dataTypeMap.get(referredProperty.getType());
+//        if (dataType == null) {
+//            throw ToscaGetFunctionExceptionSupplier
+//                .propertyDataTypeNotFound(propertyPathFromSource.get(0), referredProperty.getType(), toscaGetFunction.getFunctionType()).get();
+//        }
+//        ToscaPropertyData foundProperty = referredProperty;
+//        for (int i = 1; i < propertyPathFromSource.size(); i++) {
+//            final String currentPropertyName = propertyPathFromSource.get(i);
+//            foundProperty = dataType.getProperties().stream()
+//                .filter(propertyDefinition -> currentPropertyName.equals(propertyDefinition.getName())).findFirst()
+//                .orElseThrow(
+//                    ToscaGetFunctionExceptionSupplier
+//                        .propertyNotFoundOnTarget(propertyPathFromSource.subList(0, i), toscaGetFunction.getPropertySource(),
+//                            toscaGetFunction.getFunctionType())
+//                );
+//            dataType = dataTypeMap.get(foundProperty.getType());
+//            if (dataType == null) {
+//                throw ToscaGetFunctionExceptionSupplier
+//                    .propertyDataTypeNotFound(propertyPathFromSource.subList(0, i), foundProperty.getType(),
+//                        toscaGetFunction.getFunctionType()).get();
+//            }
+//        }
+//        return foundProperty;
+//    }
+
     public <T extends GraphNode> Either<List<PropertyDefinition>, StorageOperationStatus> getAllPropertiesRec(String uniqueId, NodeTypeEnum nodeType,
                                                                                                               Class<T> clazz) {
         return this.findPropertiesOfNode(nodeType, uniqueId).right().bind(this::handleNotFoundProperties).left()