Retrieve data types based on component model

Issue-ID: SDC-3660
Signed-off-by: aribeiro <anderson.ribeiro@est.tech>
Change-Id: I09c533eb39277532b29e581e4dd57e9df952e8e6

8 files changed, 236 insertions, 94 deletions

diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/DataTypeDefinition.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/DataTypeDefinition.java
index 01f6cd1b40..bf9f4d79a6 100644
--- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/DataTypeDefinition.java
+++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/DataTypeDefinition.java
@@ -36,7 +36,6 @@ public class DataTypeDefinition extends DataTypeDataDefinition {
     private DataTypeDefinition derivedFrom;
     private List<PropertyConstraint> constraints;
     private List<PropertyDefinition> properties;
-    private String model;
 
     public DataTypeDefinition(final DataTypeDataDefinition dataTypeDataDefinition) {
         super(dataTypeDataDefinition);
diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/cache/ApplicationCache.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/cache/ApplicationCache.java
index d0a071909c..bfb20a2f14 100644
--- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/cache/ApplicationCache.java
+++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/cache/ApplicationCache.java
@@ -22,10 +22,11 @@ package org.openecomp.sdc.be.model.cache;
 import fj.data.Either;
 import java.util.Map;
 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
+import org.openecomp.sdc.be.model.DataTypeDefinition;
 
 public interface ApplicationCache<T> {
 
-    Either<Map<String, T>, JanusGraphOperationStatus> getAll();
+    Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> getAll(final String model);
 
-    Either<T, JanusGraphOperationStatus> get(String uniqueId);
+    Either<T, JanusGraphOperationStatus> get(final String model, final String uniqueId);
 }
diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/cache/ApplicationDataTypeCache.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/cache/ApplicationDataTypeCache.java
index a1bafbc6f2..070ebf72e3 100644
--- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/cache/ApplicationDataTypeCache.java
+++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/cache/ApplicationDataTypeCache.java
@@ -20,6 +20,7 @@
 package org.openecomp.sdc.be.model.cache;
 
 import fj.data.Either;
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
@@ -43,6 +44,7 @@ import org.openecomp.sdc.be.config.Configuration.ApplicationL1CacheInfo;
 import org.openecomp.sdc.be.config.ConfigurationManager;
 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
 import org.openecomp.sdc.be.model.DataTypeDefinition;
+import org.openecomp.sdc.be.model.operations.impl.DataTypeOperation;
 import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
 import org.openecomp.sdc.be.resources.data.DataTypeData;
 import org.openecomp.sdc.common.log.enums.EcompLoggerErrorCode;
@@ -64,13 +66,16 @@ public class ApplicationDataTypeCache implements ApplicationCache<DataTypeDefini
     private final ScheduledExecutorService scheduledPollingService;
     @Getter(AccessLevel.PACKAGE)
     private ScheduledFuture<?> scheduledFuture = null;
-    private Map<String, DataTypeDefinition> dataTypesCacheMap = new HashMap<>();
+    private Map<String, Map<String, DataTypeDefinition>> dataTypesByModelCacheMap = new HashMap<>();
+    private final DataTypeOperation dataTypeOperation;
     private int firstRunDelayInSec = 30;
     private int pollingIntervalInSec = 60;
 
-    public ApplicationDataTypeCache(final PropertyOperation propertyOperation, final ApplicationEventPublisher applicationEventPublisher) {
+    public ApplicationDataTypeCache(final PropertyOperation propertyOperation, final ApplicationEventPublisher applicationEventPublisher,
+                                    final DataTypeOperation dataTypeOperation) {
         this.propertyOperation = propertyOperation;
         this.applicationEventPublisher = applicationEventPublisher;
+        this.dataTypeOperation = dataTypeOperation;
         scheduledPollingService = Executors
             .newScheduledThreadPool(1, new BasicThreadFactory.Builder().namingPattern("ApplicationDataTypeCacheThread-%d").build());
     }
@@ -156,32 +161,34 @@ public class ApplicationDataTypeCache implements ApplicationCache<DataTypeDefini
         }
     }
 
-    private Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> getAllDataTypesFromGraph() {
+    private Either<Map<String, Map<String, DataTypeDefinition>>, JanusGraphOperationStatus> getAllDataTypesFromGraph() {
         return propertyOperation.getAllDataTypes();
     }
 
-    @Override
-    public Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> getAll() {
+    public Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> getAll(final String model) {
         try {
             readWriteLock.readLock().lock();
-            if (MapUtils.isEmpty(dataTypesCacheMap)) {
-                return getAllDataTypesFromGraph();
+            if (MapUtils.isEmpty(dataTypesByModelCacheMap)) {
+                final var dataTypesFound = getAllDataTypesFromGraph();
+                if (dataTypesFound.isRight()) {
+                    return Either.right(dataTypesFound.right().value());
+                }
+                dataTypesByModelCacheMap = dataTypesFound.left().value();
             }
-            return Either.left(new HashMap<>(dataTypesCacheMap));
+            return Either.left(getDataTypeDefinitionMapByModel(model));
         } finally {
             readWriteLock.readLock().unlock();
         }
     }
 
     @Override
-    public Either<DataTypeDefinition, JanusGraphOperationStatus> get(String uniqueId) {
+    public Either<DataTypeDefinition, JanusGraphOperationStatus> get(final String model, final String uniqueId) {
         try {
             readWriteLock.readLock().lock();
-            if (MapUtils.isEmpty(dataTypesCacheMap)) {
+            if (MapUtils.isEmpty(dataTypesByModelCacheMap)) {
                 return propertyOperation.getDataTypeByUid(uniqueId);
             }
-
-            final Optional<DataTypeDefinition> dataTypeDefinition = dataTypesCacheMap.values().stream()
+            final Optional<DataTypeDefinition> dataTypeDefinition = getDataTypeDefinitionMapByModel(model).values().stream()
                 .filter(p -> p.getUniqueId().equals(uniqueId)).findFirst();
             if (dataTypeDefinition.isEmpty()) {
                 return propertyOperation.getDataTypeByUid(uniqueId);
@@ -192,6 +199,10 @@ public class ApplicationDataTypeCache implements ApplicationCache<DataTypeDefini
         }
     }
 
+    private Map<String, DataTypeDefinition> getDataTypeDefinitionMapByModel(final String model) {
+        return dataTypesByModelCacheMap.containsKey(model) ? dataTypesByModelCacheMap.get(model) : new HashMap<>();
+    }
+
     @Override
     public void run() {
         try {
@@ -218,10 +229,9 @@ public class ApplicationDataTypeCache implements ApplicationCache<DataTypeDefini
 
     private boolean hasDataTypesChanged() {
         final List<DataTypeData> dataTypeListFromDatabase = findAllDataTypesLazy();
-        final Map<String, DataTypeDefinition> dataTypesCacheCopyMap = copyDataTypeCache();
-
-        if (dataTypeListFromDatabase.size() != dataTypesCacheCopyMap.size()) {
-            log.debug("Total of cached data types '{}' differs from the actual '{}'", dataTypeListFromDatabase.size(),  dataTypesCacheCopyMap.size());
+        final int dataTypesCacheCopyMap = dataTypesCacheMapSize();
+        if (dataTypeListFromDatabase.size() != dataTypesCacheCopyMap) {
+            log.debug("Total of cached data types '{}' differs from the actual '{}'", dataTypeListFromDatabase.size(),  dataTypesCacheCopyMap);
             return true;
         }
 
@@ -230,13 +240,23 @@ public class ApplicationDataTypeCache implements ApplicationCache<DataTypeDefini
             return false;
         }
 
-        return hasDataTypesChanged(dataTypeListFromDatabase, dataTypesCacheCopyMap);
+        return hasDataTypesChanged(dataTypeListFromDatabase, copyDataTypeCache());
     }
 
-    private boolean hasDataTypesChanged(final List<DataTypeData> dataTypeListFromDatabase, final Map<String, DataTypeDefinition> dataTypesCacheCopyMap) {
+    private int dataTypesCacheMapSize() {
+        var count = 0;
+        for (var i = 0; i < copyDataTypeCache().size(); i++) {
+            count += new ArrayList<>(copyDataTypeCache().values()).get(i).size();
+
+        }
+        return count;
+    }
+
+    private boolean hasDataTypesChanged(final List<DataTypeData> dataTypeListFromDatabase, final Map<String, Map<String, DataTypeDefinition>> dataTypesCacheCopyMap) {
         return dataTypeListFromDatabase.stream().map(DataTypeData::getDataTypeDataDefinition).anyMatch(actualDataTypeDefinition -> {
             final String dataTypeName = actualDataTypeDefinition.getName();
-            final DataTypeDefinition cachedDataTypeDefinition = dataTypesCacheCopyMap.get(dataTypeName);
+            final String model = actualDataTypeDefinition.getModel();
+            final DataTypeDefinition cachedDataTypeDefinition = dataTypesCacheCopyMap.get(model).get(dataTypeName);
             if (cachedDataTypeDefinition == null) {
                 log.debug("Datatype '{}' is not present in the cache. ", dataTypeName);
                 return true;
@@ -245,8 +265,8 @@ public class ApplicationDataTypeCache implements ApplicationCache<DataTypeDefini
             final long cachedCreationTime = cachedDataTypeDefinition.getCreationTime() == null ? 0 : cachedDataTypeDefinition.getCreationTime();
             final long actualCreationTime = actualDataTypeDefinition.getCreationTime() == null ? 0 : actualDataTypeDefinition.getCreationTime();
             if (cachedCreationTime != actualCreationTime) {
-                log.debug("Datatype '{}' was updated. Cache/database creation time '{}'/'{}'.",
-                    dataTypeName, cachedCreationTime, actualCreationTime);
+                log.debug("Datatype '{}' with model '{}' was updated. Cache/database creation time '{}'/'{}'.",
+                    dataTypeName, model, cachedCreationTime, actualCreationTime);
                 return true;
             }
             final long cachedModificationTime =
@@ -263,23 +283,23 @@ public class ApplicationDataTypeCache implements ApplicationCache<DataTypeDefini
         });
     }
 
-    private Map<String, DataTypeDefinition> copyDataTypeCache() {
+    private Map<String, Map<String, DataTypeDefinition>> copyDataTypeCache() {
         try {
             readWriteLock.readLock().lock();
-            return new HashMap<>(this.dataTypesCacheMap);
+            return new HashMap<>(this.dataTypesByModelCacheMap);
         } finally {
             readWriteLock.readLock().unlock();
         }
     }
 
     private void refreshDataTypesCache() {
-        final Map<String, DataTypeDefinition> dataTypesDefinitionMap = findAllDataTypesEager();
+        final Map<String, Map<String, DataTypeDefinition>> dataTypesDefinitionMap = findAllDataTypesEager();
         if (dataTypesDefinitionMap.isEmpty()) {
             return;
         }
         try {
             readWriteLock.writeLock().lock();
-            dataTypesCacheMap = dataTypesDefinitionMap;
+            dataTypesByModelCacheMap = dataTypesDefinitionMap;
             onDataChangeEventEmit();
             BeEcompErrorManager.getInstance()
                 .logInternalFlowError("ReplaceDataTypesCache", "Succeed to replace the data types cache", ErrorSeverity.INFO);
@@ -288,10 +308,10 @@ public class ApplicationDataTypeCache implements ApplicationCache<DataTypeDefini
         }
     }
 
-    private Map<String, DataTypeDefinition> findAllDataTypesEager() {
+    private Map<String, Map<String, DataTypeDefinition>> findAllDataTypesEager() {
         log.trace("Fetching data types from database, eager mode");
         final long startTime = System.currentTimeMillis();
-        final Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = propertyOperation.getAllDataTypes();
+        final Either<Map<String, Map<String, DataTypeDefinition>>, JanusGraphOperationStatus> allDataTypes = propertyOperation.getAllDataTypes();
         log.trace("Finish fetching data types from database. Took {}ms", (System.currentTimeMillis() - startTime));
         if (allDataTypes.isRight()) {
             final JanusGraphOperationStatus status = allDataTypes.right().value();
@@ -306,16 +326,9 @@ public class ApplicationDataTypeCache implements ApplicationCache<DataTypeDefini
     private List<DataTypeData> findAllDataTypesLazy() {
         log.trace("Fetching data types from database, lazy mode");
         final long startTime = System.currentTimeMillis();
-        final Either<List<DataTypeData>, JanusGraphOperationStatus> allDataTypes = propertyOperation.getAllDataTypeNodes();
+        final List<DataTypeData> allDataTypes = dataTypeOperation.getAllDataTypeNodes();
         log.trace("Finish fetching data types from database. Took {}ms", (System.currentTimeMillis() - startTime));
-        if (allDataTypes.isRight()) {
-            final JanusGraphOperationStatus status = allDataTypes.right().value();
-            var errorMsg= String.format("Failed to fetch data types from database. Status is %s", status);
-            log.error(EcompLoggerErrorCode.UNKNOWN_ERROR, ApplicationDataTypeCache.class.getName(), errorMsg);
-            BeEcompErrorManager.getInstance().logInternalConnectionError(APPLICATION_DATA_TYPES_CACHE, errorMsg, ErrorSeverity.ERROR);
-            return Collections.emptyList();
-        }
-        return allDataTypes.left().value();
+        return allDataTypes;
     }
 
     private void onDataChangeEventEmit() {
@@ -329,9 +342,9 @@ public class ApplicationDataTypeCache implements ApplicationCache<DataTypeDefini
     public static class DataTypesCacheChangedEvent extends ApplicationEvent {
 
         @Getter
-        private final Map<String, DataTypeDefinition> newData;
+        private final Map<String,  Map<String, DataTypeDefinition>> newData;
 
-        public DataTypesCacheChangedEvent(final Object source, final Map<String, DataTypeDefinition> newData) {
+        public DataTypesCacheChangedEvent(final Object source, final Map<String,  Map<String, DataTypeDefinition>> newData) {
             super(source);
             this.newData = newData;
         }
diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/ComponentInstanceOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/ComponentInstanceOperation.java
index 1097e5d204..97dd3ea718 100644
--- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/ComponentInstanceOperation.java
+++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/ComponentInstanceOperation.java
@@ -70,7 +70,7 @@ public class ComponentInstanceOperation extends AbstractOperation {
     @Autowired
     private IInputsOperation inputOperation;
     @Autowired
-    private ApplicationDataTypeCache dataTypeCache;
+    private ApplicationDataTypeCache applicationDataTypeCache;
 
     public ComponentInstanceOperation() {
         super();
@@ -408,7 +408,8 @@ public class ComponentInstanceOperation extends AbstractOperation {
                 innerType = propDef.getType();
             }
             log.debug("Before validateAndUpdatePropertyValue");
-            Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = dataTypeCache.getAll();
+            Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes =
+                applicationDataTypeCache.getAll(resourceInstanceInput.getModel());
             if (allDataTypes.isRight()) {
                 JanusGraphOperationStatus status = allDataTypes.right().value();
                 BeEcompErrorManager.getInstance().logInternalFlowError("UpdatePropertyValueOnComponentInstance",
diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/DataTypeOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/DataTypeOperation.java
new file mode 100644
index 0000000000..158cb2569b
--- /dev/null
+++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/DataTypeOperation.java
@@ -0,0 +1,126 @@
+/*
+ * ============LICENSE_START=======================================================
+ *  Copyright (C) 2021 Nordix Foundation
+ *  ================================================================================
+ *  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.
+ *
+ *  SPDX-License-Identifier: Apache-2.0
+ *  ============LICENSE_END=========================================================
+ */
+package org.openecomp.sdc.be.model.operations.impl;
+
+import fj.data.Either;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.collections4.MapUtils;
+import org.openecomp.sdc.be.config.BeEcompErrorManager;
+import org.openecomp.sdc.be.config.BeEcompErrorManager.ErrorSeverity;
+import org.openecomp.sdc.be.dao.janusgraph.HealingJanusGraphGenericDao;
+import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
+import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
+import org.openecomp.sdc.be.model.DataTypeDefinition;
+import org.openecomp.sdc.be.resources.data.DataTypeData;
+import org.openecomp.sdc.common.log.enums.EcompLoggerErrorCode;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component("dataType-operation")
+public class DataTypeOperation extends AbstractOperation {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(DataTypeOperation.class);
+
+    private final ModelOperation modelOperation;
+
+    @Autowired
+    public DataTypeOperation(final HealingJanusGraphGenericDao janusGraphGenericDao,
+                             final ModelOperation modelOperation) {
+        this.janusGraphGenericDao = janusGraphGenericDao;
+        this.modelOperation = modelOperation;
+    }
+
+    public List<DataTypeData> getAllDataTypeNodes() {
+        final List<DataTypeData> dataTypesFound = new ArrayList<>();
+        final Either<List<DataTypeData>, JanusGraphOperationStatus> getAllDataTypesWithNullModel =
+            janusGraphGenericDao.getByCriteria(NodeTypeEnum.DataType, null, DataTypeData.class);
+
+        final var dataTypesValidated = validateDataType(getAllDataTypesWithNullModel, null);
+        if (CollectionUtils.isNotEmpty(dataTypesValidated)) {
+            dataTypesFound.addAll(dataTypesValidated);
+        }
+
+        final List<DataTypeData> allDataTypeNodesWithModel = getAllDataTypesWithModel();
+        if(CollectionUtils.isNotEmpty(allDataTypeNodesWithModel)) {
+            dataTypesFound.addAll(allDataTypeNodesWithModel);
+        }
+        return dataTypesFound;
+    }
+
+    public List<DataTypeData> getAllDataTypesWithModel() {
+        final List<DataTypeData> dataTypesWithModel = new ArrayList<>();
+        modelOperation.findAllModels()
+            .forEach(model -> {
+                final var modelName = model.getName();
+                final Either<List<DataTypeData>, JanusGraphOperationStatus> getAllDataTypesByModel = janusGraphGenericDao
+                    .getByCriteriaForModel(NodeTypeEnum.DataType, null, modelName, DataTypeData.class);
+                final var dataTypesValidated = validateDataType(getAllDataTypesByModel, modelName);
+                dataTypesWithModel.addAll(dataTypesValidated);
+            });
+        return dataTypesWithModel;
+    }
+
+    private List<DataTypeData> validateDataType(final Either<List<DataTypeData>, JanusGraphOperationStatus> getDataTypes, final String modelName) {
+        if (getDataTypes.isRight() && getDataTypes.right().value() == JanusGraphOperationStatus.NOT_FOUND) {
+            return Collections.emptyList();
+        }
+        if (getDataTypes.isRight()) {
+            final var status = getDataTypes.right().value();
+            if (LOGGER.isErrorEnabled()) {
+                final var errorMsg= String.format("Failed to fetch data types from database with model %s. Status is %s", modelName, status);
+                LOGGER.error(String.valueOf(EcompLoggerErrorCode.UNKNOWN_ERROR), DataTypeOperation.class.getName(), errorMsg);
+                BeEcompErrorManager.getInstance().logInternalConnectionError(DataTypeOperation.class.getName(), errorMsg, ErrorSeverity.ERROR);
+            }
+            return Collections.emptyList();
+        }
+        return getDataTypes.left().value();
+    }
+
+    public Map<String, Map<String, DataTypeDefinition>> mapDataTypesDefinitionByModel(final Map<String, DataTypeDefinition> allDataTypes) {
+        final Map<String, DataTypeDefinition> dataTypesWithNullModelMap = new HashMap<>();
+        final Map<String, DataTypeDefinition> dataTypesWithModelMap = new HashMap<>();
+        final Map<String, Map<String, DataTypeDefinition>> dataTypesMappedByModel = new HashMap<>();
+        allDataTypes.values().stream().forEach(dataTypeDefinition -> {
+            final var model = dataTypeDefinition.getModel();
+            final var dataTypeDefinitionName = dataTypeDefinition.getName();
+            if (model == null) {
+                dataTypesWithNullModelMap.put(dataTypeDefinitionName, dataTypeDefinition);
+            } else {
+                dataTypesWithModelMap.put(dataTypeDefinitionName, dataTypeDefinition);
+                if (dataTypesMappedByModel.containsKey(model)) {
+                    dataTypesMappedByModel.get(model).put(dataTypeDefinitionName, dataTypeDefinition);
+                } else {
+                    dataTypesMappedByModel.put(model, dataTypesWithModelMap);
+                }
+            }
+        });
+        if(MapUtils.isNotEmpty(dataTypesWithNullModelMap)) {
+            dataTypesMappedByModel.put(null, dataTypesWithNullModelMap);
+        }
+        return dataTypesMappedByModel;
+    }
+
+}
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 45df37c4b8..c463af691c 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
@@ -76,7 +76,7 @@ public class GroupInstanceOperation extends AbstractOperation implements IGroupI
     @Autowired
     PropertyOperation propertyOperation;
     @javax.annotation.Resource
-    private ApplicationDataTypeCache dataTypeCache;
+    private ApplicationDataTypeCache applicationDataTypeCache;
 
     public Either<List<GroupInstance>, StorageOperationStatus> getAllGroupInstances(String parentId, NodeTypeEnum parentType) {
         Either<List<GroupInstance>, StorageOperationStatus> result = null;
@@ -285,7 +285,8 @@ public class GroupInstanceOperation extends AbstractOperation implements IGroupI
                 innerType = propDef.getType();
             }
             log.debug("Before validateAndUpdatePropertyValue");
-            Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = dataTypeCache.getAll();
+            Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes =
+                applicationDataTypeCache.getAll(groupInstanceProperty.getModel());
             if (allDataTypes.isRight()) {
                 JanusGraphOperationStatus status = allDataTypes.right().value();
                 BeEcompErrorManager.getInstance()
@@ -388,7 +389,8 @@ public class GroupInstanceOperation extends AbstractOperation implements IGroupI
                 innerType = propDef.getType();
             }
             // Specific Update Logic
-            Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = dataTypeCache.getAll();
+            Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes =
+                applicationDataTypeCache.getAll(groupInstanceProerty.getModel());
             if (allDataTypes.isRight()) {
                 JanusGraphOperationStatus status = allDataTypes.right().value();
                 BeEcompErrorManager.getInstance()
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 effdbebf4c..b9378b8eca 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
@@ -72,15 +72,15 @@ public class GroupOperation extends AbstractOperation implements IGroupOperation
     private final TopologyTemplateOperation topologyTemplateOperation;
     private final PropertyOperation propertyOperation;
     private final GroupTypeOperation groupTypeOperation;
-    private final ApplicationDataTypeCache dataTypeCache;
+    private final ApplicationDataTypeCache applicationDataTypeCache;
 
     public GroupOperation(JanusGraphDao janusGraphDao, TopologyTemplateOperation topologyTemplateOperation, PropertyOperation propertyOperation,
-                          GroupTypeOperation groupTypeOperation, ApplicationDataTypeCache dataTypeCache) {
+                          GroupTypeOperation groupTypeOperation, ApplicationDataTypeCache applicationDataTypeCache) {
         this.janusGraphDao = janusGraphDao;
         this.topologyTemplateOperation = topologyTemplateOperation;
         this.propertyOperation = propertyOperation;
         this.groupTypeOperation = groupTypeOperation;
-        this.dataTypeCache = dataTypeCache;
+        this.applicationDataTypeCache = applicationDataTypeCache;
     }
 
     private GroupDefinition convertGroupDataToGroupDefinition(GroupData groupData) {
@@ -485,7 +485,7 @@ public class GroupOperation extends AbstractOperation implements IGroupOperation
         StorageOperationStatus result = null;
         String innerType =
             property.getSchema() == null ? null : property.getSchema().getProperty() == null ? null : property.getSchema().getProperty().getType();
-        Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = dataTypeCache.getAll();
+        Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = applicationDataTypeCache.getAll(property.getModel());
         Either<Object, Boolean> isValid = null;
         if (allDataTypes.isRight()) {
             JanusGraphOperationStatus status = allDataTypes.right().value();
@@ -493,8 +493,8 @@ public class GroupOperation extends AbstractOperation implements IGroupOperation
             result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status);
         }
         if (result == null) {
-            isValid = propertyOperation
-                .validateAndUpdatePropertyValue(property.getType(), property.getValue(), innerType, allDataTypes.left().value());
+            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;
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 1f4fca0685..726efcf847 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
@@ -21,6 +21,20 @@ package org.openecomp.sdc.be.model.operations.impl;
 
 import static org.openecomp.sdc.common.log.enums.EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR;
 
+import com.fasterxml.jackson.core.ObjectCodec;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.google.common.collect.Maps;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParseException;
+import com.google.gson.JsonParser;
+import com.google.gson.JsonSerializationContext;
+import com.google.gson.JsonSerializer;
+import fj.data.Either;
 import java.io.IOException;
 import java.lang.reflect.Type;
 import java.util.ArrayList;
@@ -82,6 +96,7 @@ import org.openecomp.sdc.be.model.tosca.constraints.ValidValuesConstraint;
 import org.openecomp.sdc.be.model.tosca.converters.PropertyValueConverter;
 import org.openecomp.sdc.be.resources.data.ComponentInstanceData;
 import org.openecomp.sdc.be.resources.data.DataTypeData;
+import org.openecomp.sdc.be.resources.data.ModelData;
 import org.openecomp.sdc.be.resources.data.PropertyData;
 import org.openecomp.sdc.be.resources.data.PropertyValueData;
 import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
@@ -89,20 +104,6 @@ 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;
-import com.fasterxml.jackson.core.ObjectCodec;
-import com.fasterxml.jackson.databind.DeserializationContext;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.google.common.collect.Maps;
-import com.google.gson.JsonArray;
-import com.google.gson.JsonDeserializationContext;
-import com.google.gson.JsonDeserializer;
-import com.google.gson.JsonElement;
-import com.google.gson.JsonObject;
-import com.google.gson.JsonParseException;
-import com.google.gson.JsonParser;
-import com.google.gson.JsonSerializationContext;
-import com.google.gson.JsonSerializer;
-import fj.data.Either;
 
 @Component("property-operation")
 public class PropertyOperation extends AbstractOperation implements IPropertyOperation {
@@ -120,11 +121,14 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe
     private static final String UPDATE_DATA_TYPE = "UpdateDataType";
     private static Logger log = Logger.getLogger(PropertyOperation.class.getName());
     private DerivedFromOperation derivedFromOperation;
+    private DataTypeOperation dataTypeOperation;
 
     @Autowired
-    public PropertyOperation(HealingJanusGraphGenericDao janusGraphGenericDao, DerivedFromOperation derivedFromOperation) {
+    public PropertyOperation(HealingJanusGraphGenericDao janusGraphGenericDao, DerivedFromOperation derivedFromOperation,
+                             DataTypeOperation dataTypeOperation) {
         this.janusGraphGenericDao = janusGraphGenericDao;
         this.derivedFromOperation = derivedFromOperation;
+        this.dataTypeOperation = dataTypeOperation;
     }
 
     public PropertyDefinition convertPropertyDataToPropertyDefinition(PropertyData propertyDataResult, String propertyName, String resourceId) {
@@ -1506,28 +1510,21 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe
         return Either.left(true);
     }
 
-    public Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> getAllDataTypes() {
-        Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
-        Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> result = Either.left(dataTypes);
-        Either<List<DataTypeData>, JanusGraphOperationStatus> getAllDataTypes = janusGraphGenericDao
-            .getByCriteria(NodeTypeEnum.DataType, null, DataTypeData.class);
-        if (getAllDataTypes.isRight()) {
-            JanusGraphOperationStatus status = getAllDataTypes.right().value();
-            if (status != JanusGraphOperationStatus.NOT_FOUND) {
-                return Either.right(status);
-            } else {
-                return result;
-            }
-        }
-        List<DataTypeData> list = getAllDataTypes.left().value();
+    public Either<Map<String, Map<String, DataTypeDefinition>>, JanusGraphOperationStatus> getAllDataTypes() {
+        final Map<String, Map<String, DataTypeDefinition>> dataTypes = new HashMap<>();
+        Either<Map<String, Map<String, DataTypeDefinition>>, JanusGraphOperationStatus> result = Either.left(dataTypes);
+        final Map<String, DataTypeDefinition> allDataTypesFound = new HashMap<>();
+        final List<DataTypeData> list = dataTypeOperation.getAllDataTypeNodes();
         if (list != null) {
             log.trace("Number of data types to load is {}", list.size());
             List<String> collect = list.stream().map(p -> p.getDataTypeDataDefinition().getName()).collect(Collectors.toList());
             log.trace("The data types to load are {}", collect);
             for (DataTypeData dataTypeData : list) {
-                log.trace("Going to fetch data type {}. uid is {}", dataTypeData.getDataTypeDataDefinition().getName(), dataTypeData.getUniqueId());
+                final String dataTypeName = dataTypeData.getDataTypeDataDefinition().getName();
+                final String dataTypeUniqueId = dataTypeData.getUniqueId();
+                log.trace("Going to fetch data type {}. uid is {}", dataTypeName, dataTypeUniqueId);
                 Either<DataTypeDefinition, JanusGraphOperationStatus> dataTypeByUid = this
-                    .getAndAddDataTypeByUid(dataTypeData.getUniqueId(), dataTypes);
+                    .getAndAddDataTypeByUid(dataTypeUniqueId, allDataTypesFound);
                 if (dataTypeByUid.isRight()) {
                     JanusGraphOperationStatus status = dataTypeByUid.right().value();
                     if (status == JanusGraphOperationStatus.NOT_FOUND) {
@@ -1535,13 +1532,14 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe
                     }
                     return Either.right(status);
                 }
+                result = Either.left(dataTypeOperation.mapDataTypesDefinitionByModel(allDataTypesFound));
             }
         }
         if (log.isTraceEnabled()) {
             if (result.isRight()) {
                 log.trace("After fetching all data types {}", result);
             } else {
-                Map<String, DataTypeDefinition> map = result.left().value();
+                Map<String, Map<String, DataTypeDefinition>> map = result.left().value();
                 if (map != null) {
                     String types = map.keySet().stream().collect(Collectors.joining(",", "[", "]"));
                     log.trace("After fetching all data types {} ", types);
@@ -1577,7 +1575,7 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe
             log.error(FAILED_TO_FETCH_PROPERTIES_OF_DATA_TYPE, uniqueId);
             return Either.right(propertiesStatus);
         }
-        allDataTypes.put(dataTypeDefinition.getName(), dataTypeDefinition);
+        allDataTypes.put(dataTypeDefinition.getUniqueId(), dataTypeDefinition);
         String derivedFrom = dataTypeDefinition.getDerivedFromName();
         if (allDataTypes.containsKey(derivedFrom)) {
             DataTypeDefinition parentDataTypeDefinition = allDataTypes.get(derivedFrom);
@@ -1606,26 +1604,28 @@ public class PropertyOperation extends AbstractOperation implements IPropertyOpe
             }
             DataTypeDefinition parentDataTypeDefinition = dataTypeByUid.left().value();
             dataTypeDefinition.setDerivedFrom(parentDataTypeDefinition);
+            final var model = getModel(uniqueId);
+            if (StringUtils.isNotEmpty(model)) {
+                dataTypeDefinition.setModel(model);
+            }
         }
         result = Either.left(dataTypeDefinition);
         return result;
     }
 
+    private String getModel(final String uniqueId) {
+        final Either<ImmutablePair<ModelData, GraphEdge>, JanusGraphOperationStatus> model = janusGraphGenericDao.getParentNode(
+            UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.DataType), uniqueId, GraphEdgeLabels.MODEL_ELEMENT,
+            NodeTypeEnum.Model, ModelData.class);
+        return model.isLeft() ? model.left().value().getLeft().getName() : StringUtils.EMPTY;
+    }
+
     public Either<String, JanusGraphOperationStatus> checkInnerType(PropertyDataDefinition propDataDef) {
         String propertyType = propDataDef.getType();
         ToscaPropertyType type = ToscaPropertyType.isValidType(propertyType);
         return getInnerType(type, propDataDef::getSchema);
     }
 
-    public Either<List<DataTypeData>, JanusGraphOperationStatus> getAllDataTypeNodes() {
-        final Either<List<DataTypeData>, JanusGraphOperationStatus> getAllDataTypes =
-            janusGraphGenericDao.getByCriteria(NodeTypeEnum.DataType, null, DataTypeData.class);
-        if (getAllDataTypes.isRight() && getAllDataTypes.right().value() == JanusGraphOperationStatus.NOT_FOUND) {
-            return Either.left(Collections.emptyList());
-        }
-        return getAllDataTypes;
-    }
-
     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);