Multiple ports (extCP) with wrong network-role

E2E/Internal Defect - multiple ports (extCP) with wrong network-role

Change-Id: Ic3896287347978ad3e89ac14fb07916ea201d8fa
Issue-ID: SDC-1113
Signed-off-by: eleonorali <eleonoral@amdocs.com>

7 files changed, 851 insertions, 837 deletions

diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/UnifiedCompositionService.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/UnifiedCompositionService.java
index 84a9dcf442..ae48ccf156 100644
--- a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/UnifiedCompositionService.java
+++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/UnifiedCompositionService.java
@@ -114,30 +114,30 @@ public class UnifiedCompositionService {
   static {
     Configuration config = ConfigurationManager.lookup();
     unifiedCompositionImplMap =
-        config.populateMap(ConfigConstants.MANDATORY_UNIFIED_MODEL_NAMESPACE,
-            ConfigConstants.UNIFIED_COMPOSITION_IMPL_KEY, ImplementationConfiguration.class);
+            config.populateMap(ConfigConstants.MANDATORY_UNIFIED_MODEL_NAMESPACE,
+                    ConfigConstants.UNIFIED_COMPOSITION_IMPL_KEY, ImplementationConfiguration.class);
     unifiedSubstitutionNodeTemplateIdGeneratorImplMap = new EnumMap<>(UnifiedCompositionEntity.class);
     initNodeTemplateIdGeneratorImplMap();
   }
 
   private static void initNodeTemplateIdGeneratorImplMap() {
     unifiedSubstitutionNodeTemplateIdGeneratorImplMap.put(COMPUTE, CommandImplNames
-        .COMPUTE_NEW_NODE_TEMPLATE_ID_GENERATOR_IMPL);
+            .COMPUTE_NEW_NODE_TEMPLATE_ID_GENERATOR_IMPL);
     unifiedSubstitutionNodeTemplateIdGeneratorImplMap.put(PORT, CommandImplNames
-        .PORT_NEW_NODE_TEMPLATE_ID_GENERATOR_IMPL);
+            .PORT_NEW_NODE_TEMPLATE_ID_GENERATOR_IMPL);
     unifiedSubstitutionNodeTemplateIdGeneratorImplMap.put(SUB_INTERFACE, CommandImplNames
-        .SUB_INTERFACE_NEW_NODE_TEMPLATE_ID_GENERATOR_IMPL);
+            .SUB_INTERFACE_NEW_NODE_TEMPLATE_ID_GENERATOR_IMPL);
   }
 
   private final ConsolidationService consolidationService = new ConsolidationService();
 
   private static List<EntityConsolidationData> getPortConsolidationDataList(
-      List<String> portIds,
-      List<UnifiedCompositionData> unifiedCompositionDataList) {
+          List<String> portIds,
+          List<UnifiedCompositionData> unifiedCompositionDataList) {
     return unifiedCompositionDataList.stream()
-        .flatMap(unifiedCompositionData -> unifiedCompositionData.getPortTemplateConsolidationDataList().stream())
-        .filter(portTemplateConsolidationData -> portIds.contains(portTemplateConsolidationData.getNodeTemplateId()))
-        .collect(Collectors.toList());
+            .flatMap(unifiedCompositionData -> unifiedCompositionData.getPortTemplateConsolidationDataList().stream())
+            .filter(portTemplateConsolidationData -> portIds.contains(portTemplateConsolidationData.getNodeTemplateId()))
+            .collect(Collectors.toList());
   }
 
   /**
@@ -161,8 +161,8 @@ public class UnifiedCompositionService {
       return;
     }
     unifiedCompositionInstance.get()
-        .createUnifiedComposition(serviceTemplate, nestedServiceTemplate,
-            unifiedCompositionDataList, context);
+            .createUnifiedComposition(serviceTemplate, nestedServiceTemplate,
+                    unifiedCompositionDataList, context);
   }
 
   /**
@@ -178,37 +178,37 @@ public class UnifiedCompositionService {
    * @return the substitution service template
    */
   public Optional<ServiceTemplate> createUnifiedSubstitutionServiceTemplate(
-      ServiceTemplate serviceTemplate,
-      List<UnifiedCompositionData> unifiedCompositionDataList,
-      TranslationContext context,
-      String substitutionNodeTypeId,
-      Integer index) {
+          ServiceTemplate serviceTemplate,
+          List<UnifiedCompositionData> unifiedCompositionDataList,
+          TranslationContext context,
+          String substitutionNodeTypeId,
+          Integer index) {
     if (CollectionUtils.isEmpty(unifiedCompositionDataList)) {
       return Optional.empty();
     }
     String templateName = getTemplateName(substitutionNodeTypeId, index);
     ServiceTemplate substitutionServiceTemplate =
-        HeatToToscaUtil.createInitSubstitutionServiceTemplate(templateName);
+            HeatToToscaUtil.createInitSubstitutionServiceTemplate(templateName);
 
     createIndexInputParameter(substitutionServiceTemplate);
 
     String computeNodeType =
-        handleCompute(serviceTemplate, substitutionServiceTemplate, unifiedCompositionDataList,
-            context);
+            handleCompute(serviceTemplate, substitutionServiceTemplate, unifiedCompositionDataList,
+                    context);
     handlePorts(serviceTemplate, substitutionServiceTemplate, unifiedCompositionDataList,
-        computeNodeType, context);
+            computeNodeType, context);
 
     UnifiedCompositionTo unifiedCompositionTo = new UnifiedCompositionTo(serviceTemplate,
-        substitutionServiceTemplate, unifiedCompositionDataList, context);
+            substitutionServiceTemplate, unifiedCompositionDataList, context);
     handleSubInterfaces(unifiedCompositionTo);
     createOutputParameters(unifiedCompositionTo, computeNodeType);
     NodeType substitutionGlobalNodeType =
-        handleSubstitutionGlobalNodeType(serviceTemplate, substitutionServiceTemplate,
-            context, substitutionNodeTypeId);
+            handleSubstitutionGlobalNodeType(serviceTemplate, substitutionServiceTemplate,
+                    context, substitutionNodeTypeId);
 
     HeatToToscaUtil.handleSubstitutionMapping(context,
-        substitutionNodeTypeId,
-        substitutionServiceTemplate, substitutionGlobalNodeType);
+            substitutionNodeTypeId,
+            substitutionServiceTemplate, substitutionGlobalNodeType);
 
     context.getTranslatedServiceTemplates().put(templateName, substitutionServiceTemplate);
     return Optional.of(substitutionServiceTemplate);
@@ -229,12 +229,12 @@ public class UnifiedCompositionService {
    * @return the abstract substitute node template id
    */
   public String createAbstractSubstituteNodeTemplate(
-      ServiceTemplate serviceTemplate,
-      ServiceTemplate substitutionServiceTemplate,
-      List<UnifiedCompositionData> unifiedCompositionDataList,
-      String substituteNodeTypeId,
-      TranslationContext context,
-      Integer index) {
+          ServiceTemplate serviceTemplate,
+          ServiceTemplate substitutionServiceTemplate,
+          List<UnifiedCompositionData> unifiedCompositionDataList,
+          String substituteNodeTypeId,
+          TranslationContext context,
+          Integer index) {
 
     NodeTemplate substitutionNodeTemplate = new NodeTemplate();
     List<String> directiveList = new ArrayList<>();
@@ -242,28 +242,28 @@ public class UnifiedCompositionService {
     substitutionNodeTemplate.setDirectives(directiveList);
     substitutionNodeTemplate.setType(substituteNodeTypeId);
     Map<String, ParameterDefinition> substitutionTemplateInputs = DataModelUtil
-        .getInputParameters(substitutionServiceTemplate);
+            .getInputParameters(substitutionServiceTemplate);
     Optional<Map<String, Object>> abstractSubstitutionProperties = Optional.empty();
     if (Objects.nonNull(substitutionTemplateInputs)) {
       abstractSubstitutionProperties = createAbstractSubstitutionProperties(serviceTemplate,
-          substitutionTemplateInputs, unifiedCompositionDataList, context);
+              substitutionTemplateInputs, unifiedCompositionDataList, context);
     }
     abstractSubstitutionProperties.ifPresent(substitutionNodeTemplate::setProperties);
 
     //Add substitution filtering property
     String substitutionServiceTemplateName = ToscaUtil.getServiceTemplateFileName(
-        substitutionServiceTemplate);
+            substitutionServiceTemplate);
     int count = unifiedCompositionDataList.size();
     DataModelUtil.addSubstitutionFilteringProperty(substitutionServiceTemplateName,
-        substitutionNodeTemplate, count);
+            substitutionNodeTemplate, count);
     //Add index_value property
     addIndexValueProperty(substitutionNodeTemplate);
     String substituteNodeTemplateId = getSubstituteNodeTemplateId(substituteNodeTypeId, index);
     //Add node template id and related abstract node template id in context
     addUnifiedSubstitionData(context, serviceTemplate, unifiedCompositionDataList,
-        substituteNodeTemplateId);
+            substituteNodeTemplateId);
     DataModelUtil
-        .addNodeTemplate(serviceTemplate, substituteNodeTemplateId, substitutionNodeTemplate);
+            .addNodeTemplate(serviceTemplate, substituteNodeTemplateId, substitutionNodeTemplate);
     return substituteNodeTemplateId;
 
   }
@@ -302,28 +302,28 @@ public class UnifiedCompositionService {
    * @param context                    the translation context
    */
   public void cleanUnifiedCompositionEntities(
-      ServiceTemplate serviceTemplate,
-      List<UnifiedCompositionData> unifiedCompositionDataList,
-      TranslationContext context) {
+          ServiceTemplate serviceTemplate,
+          List<UnifiedCompositionData> unifiedCompositionDataList,
+          TranslationContext context) {
     for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
       //Clean compute node template data from top level service template
       ComputeTemplateConsolidationData computeTemplateConsolidationData =
-          unifiedCompositionData.getComputeTemplateConsolidationData();
+              unifiedCompositionData.getComputeTemplateConsolidationData();
       cleanServiceTemplate(serviceTemplate, computeTemplateConsolidationData, context);
 
       //Clean port node template data from top level service template
       List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
-          getPortTemplateConsolidationDataList(unifiedCompositionData);
+              getPortTemplateConsolidationDataList(unifiedCompositionData);
       for (PortTemplateConsolidationData portTemplateConsolidationData :
-          portTemplateConsolidationDataList) {
+              portTemplateConsolidationDataList) {
         cleanServiceTemplate(serviceTemplate, portTemplateConsolidationData, context);
       }
 
       //Clean sub-interface node template data from top level service template
       List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
-          getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
+              getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
       for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData :
-          subInterfaceTemplateConsolidationDataList) {
+              subInterfaceTemplateConsolidationDataList) {
         cleanServiceTemplate(serviceTemplate, subInterfaceTemplateConsolidationData, context);
       }
     }
@@ -341,8 +341,8 @@ public class UnifiedCompositionService {
                              TranslationContext context) {
     for (UnifiedCompositionData unifiedData : unifiedCompositionDataList) {
       removeCleanedNodeType(
-          unifiedData.getComputeTemplateConsolidationData().getNodeTemplateId(), serviceTemplate,
-          context);
+              unifiedData.getComputeTemplateConsolidationData().getNodeTemplateId(), serviceTemplate,
+              context);
     }
     if (MapUtils.isEmpty(serviceTemplate.getNode_types())) {
       serviceTemplate.setNode_types(null);
@@ -351,22 +351,22 @@ public class UnifiedCompositionService {
 
   public void updateSubstitutionNodeTypePrefix(ServiceTemplate substitutionServiceTemplate) {
     Map<String, NodeTemplate> nodeTemplates =
-        substitutionServiceTemplate.getTopology_template().getNode_templates();
+            substitutionServiceTemplate.getTopology_template().getNode_templates();
 
     for (Map.Entry<String, NodeTemplate> nodeTemplateEntry : nodeTemplates.entrySet()) {
       String nodeTypeId = nodeTemplateEntry.getValue().getType();
       NodeType origNodeType = substitutionServiceTemplate.getNode_types().get(nodeTypeId);
       if (Objects.nonNull(origNodeType)
-          && nodeTypeId.startsWith(ToscaNodeType.VFC_TYPE_PREFIX)
-          && origNodeType.getDerived_from().equals(ToscaNodeType.NOVA_SERVER)) {
+              && nodeTypeId.startsWith(ToscaNodeType.VFC_TYPE_PREFIX)
+              && origNodeType.getDerived_from().equals(ToscaNodeType.NOVA_SERVER)) {
         substitutionServiceTemplate.getNode_types().remove(nodeTypeId);
 
         String newNodeTypeId =
-            nodeTypeId.replace(ToscaNodeType.VFC_TYPE_PREFIX, ToscaNodeType.COMPUTE_TYPE_PREFIX);
+                nodeTypeId.replace(ToscaNodeType.VFC_TYPE_PREFIX, ToscaNodeType.COMPUTE_TYPE_PREFIX);
         nodeTemplateEntry.getValue().setType(newNodeTypeId);
         DataModelUtil
-            .addNodeTemplate(substitutionServiceTemplate, nodeTemplateEntry.getKey(),
-                nodeTemplateEntry.getValue());
+                .addNodeTemplate(substitutionServiceTemplate, nodeTemplateEntry.getKey(),
+                        nodeTemplateEntry.getValue());
         substitutionServiceTemplate.getNode_types().put(newNodeTypeId, origNodeType);
       }
     }
@@ -384,16 +384,16 @@ public class UnifiedCompositionService {
 
     String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
     UnifiedSubstitutionData unifiedSubstitutionData = context.getUnifiedSubstitutionData()
-        .get(serviceTemplateFileName);
+            .get(serviceTemplateFileName);
 
     if (Objects.nonNull(unifiedSubstitutionData)) {
       //Handle get attribute in connectivity for abstarct node to abstract node templates
       Set<String> abstractNodeIds =
-          new HashSet<>(unifiedSubstitutionData.getAllRelatedAbstractNodeIds());
+              new HashSet<>(unifiedSubstitutionData.getAllRelatedAbstractNodeIds());
       handleGetAttrInConnectivity(serviceTemplate, abstractNodeIds, context);
       //Handle get attribute in connectivity for abstract node templates to nested node template
       Set<String> nestedNodeIds =
-          new HashSet<>(unifiedSubstitutionData.getAllUnifiedNestedNodeTemplateIds());
+              new HashSet<>(unifiedSubstitutionData.getAllUnifiedNestedNodeTemplateIds());
       handleGetAttrInConnectivity(serviceTemplate, nestedNodeIds, context);
     }
   }
@@ -412,19 +412,19 @@ public class UnifiedCompositionService {
                                             TranslationContext context) {
     handleUnifiedNestedNodeType(mainServiceTemplate, nestedServiceTemplate, context);
     updateUnifiedNestedTemplates(mainServiceTemplate, nestedServiceTemplate,
-        unifiedCompositionData, context);
+            unifiedCompositionData, context);
   }
 
   private void handleGetAttrInConnectivity(ServiceTemplate serviceTemplate,
                                            Set<String> unifiedNodeIds,
                                            TranslationContext context) {
     Map<String, NodeTemplate> nodeTemplates =
-        serviceTemplate.getTopology_template().getNode_templates();
+            serviceTemplate.getTopology_template().getNode_templates();
     String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
     for (String unifiedNodeId : unifiedNodeIds) {
       NodeTemplate nodeTemplate = nodeTemplates.get(unifiedNodeId);
       handleGetAttrInAbstractNodeTemplate(serviceTemplate, context, serviceTemplateFileName,
-          nodeTemplate);
+              nodeTemplate);
     }
   }
 
@@ -434,29 +434,29 @@ public class UnifiedCompositionService {
 
 
     SubstitutionMapping substitutionMappings =
-        nestedServiceTemplate.getTopology_template().getSubstitution_mappings();
+            nestedServiceTemplate.getTopology_template().getSubstitution_mappings();
     String nodeTypeId = substitutionMappings.getNode_type();
 
     Optional<String> newNestedNodeTypeId = getNewNestedNodeTypeId(nestedServiceTemplate, context);
 
     ServiceTemplate globalSubstitutionServiceTemplate =
-        context.getGlobalSubstitutionServiceTemplate();
+            context.getGlobalSubstitutionServiceTemplate();
 
     if (isNestedServiceTemplateWasHandled(globalSubstitutionServiceTemplate, nestedServiceTemplate,
-        context,
-        newNestedNodeTypeId)) {
+            context,
+            newNestedNodeTypeId)) {
       context
-          .updateHandledComputeType(ToscaUtil.getServiceTemplateFileName(mainServiceTemplate),
-              newNestedNodeTypeId.get(),
-              ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate));
+              .updateHandledComputeType(ToscaUtil.getServiceTemplateFileName(mainServiceTemplate),
+                      newNestedNodeTypeId.get(),
+                      ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate));
       return;
     }
 
 
     newNestedNodeTypeId.ifPresent(
-        newNestedNodeTypeIdVal -> handleNestedNodeType(nodeTypeId, newNestedNodeTypeIdVal,
-            nestedServiceTemplate, mainServiceTemplate, globalSubstitutionServiceTemplate,
-            context));
+            newNestedNodeTypeIdVal -> handleNestedNodeType(nodeTypeId, newNestedNodeTypeIdVal,
+                    nestedServiceTemplate, mainServiceTemplate, globalSubstitutionServiceTemplate,
+                    context));
 
   }
 
@@ -465,9 +465,9 @@ public class UnifiedCompositionService {
                                                     TranslationContext context,
                                                     Optional<String> newNestedNodeTypeId) {
     return newNestedNodeTypeId.isPresent()
-        && context.isNestedServiceTemplateWasHandled(
-        ToscaUtil.getServiceTemplateFileName(mainServiceTemplate),
-        ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate));
+            && context.isNestedServiceTemplateWasHandled(
+            ToscaUtil.getServiceTemplateFileName(mainServiceTemplate),
+            ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate));
   }
 
   private void handleNestedNodeType(String nodeTypeId, String newNestedNodeTypeId,
@@ -477,8 +477,8 @@ public class UnifiedCompositionService {
                                     TranslationContext context) {
     updateNestedServiceTemplate(nestedServiceTemplate, context);
     updateNestedNodeType(nodeTypeId, newNestedNodeTypeId, nestedServiceTemplate,
-        mainServiceTemplate,
-        globalSubstitutionServiceTemplate, context);
+            mainServiceTemplate,
+            globalSubstitutionServiceTemplate, context);
 
 
   }
@@ -491,24 +491,24 @@ public class UnifiedCompositionService {
   private void enrichPortProperties(ServiceTemplate nestedServiceTemplate,
                                     TranslationContext context) {
     String nestedServiceTemplateFileName =
-        ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate);
+            ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate);
     FilePortConsolidationData filePortConsolidationData =
-        context.getConsolidationData().getPortConsolidationData().getFilePortConsolidationData
-            (nestedServiceTemplateFileName);
+            context.getConsolidationData().getPortConsolidationData().getFilePortConsolidationData
+                    (nestedServiceTemplateFileName);
 
     if (Objects.nonNull(filePortConsolidationData)) {
       Set<String> portNodeTemplateIds = filePortConsolidationData.getAllPortNodeTemplateIds();
       if (Objects.nonNull(portNodeTemplateIds)) {
         for (String portNodeTemplateId : portNodeTemplateIds) {
           NodeTemplate portNodeTemplate = DataModelUtil.getNodeTemplate(nestedServiceTemplate,
-              portNodeTemplateId);
+                  portNodeTemplateId);
           List<EntityConsolidationData> portEntityConsolidationDataList = new ArrayList<>();
           portEntityConsolidationDataList.add(filePortConsolidationData
-              .getPortTemplateConsolidationData(portNodeTemplateId));
+                  .getPortTemplateConsolidationData(portNodeTemplateId));
 
           handleNodeTypeProperties(nestedServiceTemplate,
-              portEntityConsolidationDataList, portNodeTemplate, UnifiedCompositionEntity.PORT,
-              null, context);
+                  portEntityConsolidationDataList, portNodeTemplate, UnifiedCompositionEntity.PORT,
+                  null, context);
         }
       }
     }
@@ -520,12 +520,12 @@ public class UnifiedCompositionService {
                                     ServiceTemplate globalSubstitutionServiceTemplate,
                                     TranslationContext context) {
     String indexedNewNestedNodeTypeId =
-        updateNodeTypeId(nodeTypeId, newNestedNodeTypeId, nestedServiceTemplate,
-            mainServiceTemplate,
-            globalSubstitutionServiceTemplate, context);
+            updateNodeTypeId(nodeTypeId, newNestedNodeTypeId, nestedServiceTemplate,
+                    mainServiceTemplate,
+                    globalSubstitutionServiceTemplate, context);
 
     updateNodeTypeProperties(nestedServiceTemplate, globalSubstitutionServiceTemplate,
-        indexedNewNestedNodeTypeId);
+            indexedNewNestedNodeTypeId);
   }
 
   private void updateNodeTypeProperties(ServiceTemplate nestedServiceTemplate,
@@ -533,9 +533,9 @@ public class UnifiedCompositionService {
                                         String nodeTypeId) {
     ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
     Map<String, PropertyDefinition> nodeTypePropertiesDefinition =
-        toscaAnalyzerService.manageSubstitutionNodeTypeProperties(nestedServiceTemplate);
+            toscaAnalyzerService.manageSubstitutionNodeTypeProperties(nestedServiceTemplate);
     NodeType nestedNodeType =
-        DataModelUtil.getNodeType(globalSubstitutionServiceTemplate, nodeTypeId);
+            DataModelUtil.getNodeType(globalSubstitutionServiceTemplate, nodeTypeId);
     nestedNodeType.setProperties(nodeTypePropertiesDefinition);
   }
 
@@ -545,17 +545,17 @@ public class UnifiedCompositionService {
                                   ServiceTemplate globalSubstitutionServiceTemplate,
                                   TranslationContext context) {
     String indexedNewNestedNodeTypeId =
-        handleNestedNodeTypeInGlobalSubstitutionTemplate(nodeTypeId, newNestedNodeTypeId,
-            globalSubstitutionServiceTemplate, context);
+            handleNestedNodeTypeInGlobalSubstitutionTemplate(nodeTypeId, newNestedNodeTypeId,
+                    globalSubstitutionServiceTemplate, context);
 
     handleSubstitutionMappingInNestedServiceTemplate(indexedNewNestedNodeTypeId,
-        nestedServiceTemplate, context);
+            nestedServiceTemplate, context);
 
     context
-        .updateHandledComputeType(
-            ToscaUtil.getServiceTemplateFileName(mainServiceTemplate),
-            ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate),
-            newNestedNodeTypeId);
+            .updateHandledComputeType(
+                    ToscaUtil.getServiceTemplateFileName(mainServiceTemplate),
+                    ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate),
+                    newNestedNodeTypeId);
     return indexedNewNestedNodeTypeId;
   }
 
@@ -564,23 +564,23 @@ public class UnifiedCompositionService {
                                                                   ServiceTemplate globalSubstitutionServiceTemplate,
                                                                   TranslationContext context) {
     String indexedNodeType =
-        getIndexedGlobalNodeTypeId(newNestedNodeTypeId, context);
+            getIndexedGlobalNodeTypeId(newNestedNodeTypeId, context);
     context.updateUsedTimesForNestedComputeNodeType(
-        ToscaUtil.getServiceTemplateFileName(globalSubstitutionServiceTemplate),
-        newNestedNodeTypeId);
+            ToscaUtil.getServiceTemplateFileName(globalSubstitutionServiceTemplate),
+            newNestedNodeTypeId);
     handleNestedNodeTypesInGlobalSubstituteServiceTemplate(nodeTypeId, indexedNodeType,
-        globalSubstitutionServiceTemplate, context);
+            globalSubstitutionServiceTemplate, context);
     return indexedNodeType;
   }
 
   private String getIndexedGlobalNodeTypeId(String newNestedNodeTypeId,
                                             TranslationContext context) {
     int globalNodeTypeIndex =
-        context.getGlobalNodeTypeIndex(
-            ToscaUtil.getServiceTemplateFileName(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME),
-            newNestedNodeTypeId);
+            context.getGlobalNodeTypeIndex(
+                    ToscaUtil.getServiceTemplateFileName(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME),
+                    newNestedNodeTypeId);
     return globalNodeTypeIndex > 0 ? newNestedNodeTypeId + "_"
-        + globalNodeTypeIndex : newNestedNodeTypeId;
+            + globalNodeTypeIndex : newNestedNodeTypeId;
   }
 
   private void updateUnifiedNestedTemplates(ServiceTemplate mainServiceTemplate,
@@ -589,13 +589,13 @@ public class UnifiedCompositionService {
                                             TranslationContext context) {
 
     NestedTemplateConsolidationData nestedTemplateConsolidationData =
-        unifiedCompositionData.getNestedTemplateConsolidationData();
+            unifiedCompositionData.getNestedTemplateConsolidationData();
     if (Objects.isNull(nestedTemplateConsolidationData)) {
       return;
     }
     handleNestedNodeTemplateInMainServiceTemplate(
-        nestedTemplateConsolidationData.getNodeTemplateId(), mainServiceTemplate,
-        nestedServiceTemplate, context);
+            nestedTemplateConsolidationData.getNodeTemplateId(), mainServiceTemplate,
+            nestedServiceTemplate, context);
 
   }
 
@@ -613,13 +613,13 @@ public class UnifiedCompositionService {
                                               TranslationContext context) {
 
     updNestedCompositionNodesConnectedInConnectivity(serviceTemplate, unifiedCompositionData,
-        context);
+            context);
     updNestedCompositionNodesConnectedOutConnectivity(serviceTemplate, nestedServiceTemplate,
-        unifiedCompositionData, context);
+            unifiedCompositionData, context);
     updNestedCompositionNodesGetAttrInConnectivity(serviceTemplate, unifiedCompositionData,
-        context);
+            context);
     updNestedCompositionOutputParamGetAttrInConnectivity(serviceTemplate,
-        unifiedCompositionData, context);
+            unifiedCompositionData, context);
   }
 
 
@@ -634,21 +634,21 @@ public class UnifiedCompositionService {
                                          UnifiedCompositionData unifiedCompositionData,
                                          TranslationContext context) {
     EntityConsolidationData entityConsolidationData =
-        unifiedCompositionData.getNestedTemplateConsolidationData();
+            unifiedCompositionData.getNestedTemplateConsolidationData();
     updateHeatStackGroupNestedComposition(serviceTemplate, entityConsolidationData, context);
 
   }
 
   public void handleComplexVfcType(ServiceTemplate serviceTemplate, TranslationContext context) {
     SubstitutionMapping substitutionMapping =
-        serviceTemplate.getTopology_template().getSubstitution_mappings();
+            serviceTemplate.getTopology_template().getSubstitution_mappings();
 
     if (Objects.isNull(substitutionMapping)) {
       return;
     }
 
     ServiceTemplate globalSubstitutionServiceTemplate =
-        context.getGlobalSubstitutionServiceTemplate();
+            context.getGlobalSubstitutionServiceTemplate();
 
     String substitutionNT = substitutionMapping.getNode_type();
     if (globalSubstitutionServiceTemplate.getNode_types().containsKey(substitutionNT)) {
@@ -659,40 +659,40 @@ public class UnifiedCompositionService {
 
   protected void updNodesConnectedOutConnectivity(ServiceTemplate serviceTemplate,
                                                   List<UnifiedCompositionData>
-                                                      unifiedCompositionDataList,
+                                                          unifiedCompositionDataList,
                                                   TranslationContext context) {
     for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
       ComputeTemplateConsolidationData computeTemplateConsolidationData = unifiedCompositionData
-          .getComputeTemplateConsolidationData();
+              .getComputeTemplateConsolidationData();
       //Add requirements in the abstract node template for nodes connected out for computes
       String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
-          computeTemplateConsolidationData.getNodeTemplateId());
+              computeTemplateConsolidationData.getNodeTemplateId());
       Map<String, List<RequirementAssignmentData>> computeNodesConnectedOut =
-          computeTemplateConsolidationData.getNodesConnectedOut();
+              computeTemplateConsolidationData.getNodesConnectedOut();
       if (computeNodesConnectedOut != null) {
         updateRequirementInAbstractNodeTemplate(serviceTemplate, computeTemplateConsolidationData,
-            newComputeNodeTemplateId, computeNodesConnectedOut, context);
+                newComputeNodeTemplateId, computeNodesConnectedOut, context);
       }
       String computeType = getComputeTypeSuffix(serviceTemplate, computeTemplateConsolidationData
-          .getNodeTemplateId());
+              .getNodeTemplateId());
       //Add requirements in the abstract node template for nodes connected out for ports
       List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
-          getPortTemplateConsolidationDataList(unifiedCompositionData);
+              getPortTemplateConsolidationDataList(unifiedCompositionData);
       for (PortTemplateConsolidationData portTemplateConsolidationData :
-          portTemplateConsolidationDataList) {
+              portTemplateConsolidationDataList) {
         String newPortNodeTemplateId = getNewPortNodeTemplateId(portTemplateConsolidationData
-            .getNodeTemplateId(), computeType, computeTemplateConsolidationData);
+                .getNodeTemplateId(), computeType, computeTemplateConsolidationData);
         Map<String, List<RequirementAssignmentData>> portNodesConnectedOut =
-            portTemplateConsolidationData.getNodesConnectedOut();
+                portTemplateConsolidationData.getNodesConnectedOut();
         if (portNodesConnectedOut != null) {
           updateRequirementInAbstractNodeTemplate(serviceTemplate, portTemplateConsolidationData,
-              newPortNodeTemplateId, portNodesConnectedOut, context);
+                  newPortNodeTemplateId, portNodesConnectedOut, context);
         }
       }
       //For sub-interface
       //Add requirements in the abstract node template for nodes connected out for ports
       updateSubInterfaceNodesConnectedOut(serviceTemplate, unifiedCompositionData,
-          computeTemplateConsolidationData, computeType, context);
+              computeTemplateConsolidationData, computeType, context);
     }
   }
 
@@ -702,16 +702,16 @@ public class UnifiedCompositionService {
                                                    String computeType,
                                                    TranslationContext context) {
     List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
-        getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
+            getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
     for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData :
-        subInterfaceTemplateConsolidationDataList) {
+            subInterfaceTemplateConsolidationDataList) {
       String newSubInterfaceNodeTemplateId = getNewSubInterfaceNodeTemplateId(serviceTemplate, computeType,
-          computeTemplateConsolidationData, subInterfaceTemplateConsolidationData, context);
+              computeTemplateConsolidationData, subInterfaceTemplateConsolidationData, context);
       Map<String, List<RequirementAssignmentData>> subInterfaceNodesConnectedOut =
-          subInterfaceTemplateConsolidationData.getNodesConnectedOut();
+              subInterfaceTemplateConsolidationData.getNodesConnectedOut();
       if (subInterfaceNodesConnectedOut != null) {
         updateRequirementInAbstractNodeTemplate(serviceTemplate, subInterfaceTemplateConsolidationData,
-            newSubInterfaceNodeTemplateId, subInterfaceNodesConnectedOut, context);
+                newSubInterfaceNodeTemplateId, subInterfaceNodesConnectedOut, context);
       }
     }
   }
@@ -721,21 +721,21 @@ public class UnifiedCompositionService {
                                                                  UnifiedCompositionData unifiedCompositionData,
                                                                  TranslationContext context) {
     NestedTemplateConsolidationData nestedTemplateConsolidationData =
-        unifiedCompositionData.getNestedTemplateConsolidationData();
+            unifiedCompositionData.getNestedTemplateConsolidationData();
     Map<String, List<RequirementAssignmentData>> nodesConnectedOut =
-        Objects.isNull(nestedTemplateConsolidationData) ? new HashMap<>()
-            : nestedTemplateConsolidationData.getNodesConnectedOut();
+            Objects.isNull(nestedTemplateConsolidationData) ? new HashMap<>()
+                    : nestedTemplateConsolidationData.getNodesConnectedOut();
 
     FileComputeConsolidationData nestedFileComputeConsolidationData =
-        context.getConsolidationData().getComputeConsolidationData().getFileComputeConsolidationData
-            (ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate));
+            context.getConsolidationData().getComputeConsolidationData().getFileComputeConsolidationData
+                    (ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate));
 
     if (Objects.isNull(nestedFileComputeConsolidationData)) {
       return;
     }
 
     TypeComputeConsolidationData computeType =
-        nestedFileComputeConsolidationData.getAllTypeComputeConsolidationData().iterator().next();
+            nestedFileComputeConsolidationData.getAllTypeComputeConsolidationData().iterator().next();
     if (Objects.isNull(computeType)) {
       return;
     }
@@ -743,39 +743,39 @@ public class UnifiedCompositionService {
     String singleComputeId = computeType.getAllComputeNodeTemplateIds().iterator().next();
     if (Objects.nonNull(singleComputeId) && (Objects.nonNull(nestedTemplateConsolidationData))) {
       updateRequirementInNestedNodeTemplate(serviceTemplate, nestedTemplateConsolidationData,
-          singleComputeId, nodesConnectedOut);
+              singleComputeId, nodesConnectedOut);
     }
   }
 
   private void updNodesConnectedInConnectivity(ServiceTemplate serviceTemplate,
-                                                 List<UnifiedCompositionData>
-                                                     unifiedCompositionDataList,
-                                                 TranslationContext context) {
+                                               List<UnifiedCompositionData>
+                                                       unifiedCompositionDataList,
+                                               TranslationContext context) {
     for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
       ComputeTemplateConsolidationData computeTemplateConsolidationData = unifiedCompositionData
-          .getComputeTemplateConsolidationData();
+              .getComputeTemplateConsolidationData();
       //Update requirements in the node template which pointing to the computes
       String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
-          computeTemplateConsolidationData.getNodeTemplateId());
+              computeTemplateConsolidationData.getNodeTemplateId());
       updNodesConnectedInConnectivity(serviceTemplate, computeTemplateConsolidationData,
-          newComputeNodeTemplateId, context, false);
+              newComputeNodeTemplateId, context, false);
 
       String computeType = getComputeTypeSuffix(serviceTemplate, computeTemplateConsolidationData
-          .getNodeTemplateId());
+              .getNodeTemplateId());
       //Update requirements in the node template which pointing to the ports
       List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
-          getPortTemplateConsolidationDataList(unifiedCompositionData);
+              getPortTemplateConsolidationDataList(unifiedCompositionData);
       for (PortTemplateConsolidationData portTemplateConsolidationData :
-          portTemplateConsolidationDataList) {
+              portTemplateConsolidationDataList) {
         String newPortNodeTemplateId = getNewPortNodeTemplateId(portTemplateConsolidationData
-            .getNodeTemplateId(), computeType, computeTemplateConsolidationData);
+                .getNodeTemplateId(), computeType, computeTemplateConsolidationData);
         updNodesConnectedInConnectivity(serviceTemplate, portTemplateConsolidationData,
-            newPortNodeTemplateId, context, false);
+                newPortNodeTemplateId, context, false);
       }
 
       //Update requirements in the node template which pointing to the sub-interface
       updateSubInterfaceNodesConnectedIn(serviceTemplate, unifiedCompositionData,
-          computeTemplateConsolidationData, computeType, context);
+              computeTemplateConsolidationData, computeType, context);
     }
   }
 
@@ -785,19 +785,19 @@ public class UnifiedCompositionService {
                                                TranslationContext context,
                                                boolean isNested) {
     Map<String, List<RequirementAssignmentData>> nodesConnectedIn =
-        entityConsolidationData.getNodesConnectedIn();
+            entityConsolidationData.getNodesConnectedIn();
     if (nodesConnectedIn == null) {
       //No nodes connected in info
       return;
     }
     for (Map.Entry<String, List<RequirementAssignmentData>> entry : nodesConnectedIn
-        .entrySet()) {
+            .entrySet()) {
       List<RequirementAssignmentData> requirementAssignmentDataList = entry.getValue();
       for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList) {
         RequirementAssignment requirementAssignment = requirementAssignmentData
-            .getRequirementAssignment();
+                .getRequirementAssignment();
         if (!requirementAssignment.getNode().equals(entityConsolidationData
-            .getNodeTemplateId())) {
+                .getNodeTemplateId())) {
           //The requirement assignment target node should be the one which we are handling in the
           //consolidation object
           continue;
@@ -805,10 +805,10 @@ public class UnifiedCompositionService {
         //Update the requirement assignment object in the original node template
         if (isNested) {
           updateRequirementForNestedCompositionNodesConnectedIn(serviceTemplate,
-              requirementAssignmentData, newNodeTemplateId);
+                  requirementAssignmentData, newNodeTemplateId);
         } else {
           updateRequirementForNodesConnectedIn(serviceTemplate, requirementAssignmentData,
-              entityConsolidationData, entry.getKey(), newNodeTemplateId, context);
+                  entityConsolidationData, entry.getKey(), newNodeTemplateId, context);
         }
 
       }
@@ -821,89 +821,89 @@ public class UnifiedCompositionService {
                                                   String computeType,
                                                   TranslationContext context) {
     List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
-        getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
+            getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
     for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData :
-        subInterfaceTemplateConsolidationDataList) {
+            subInterfaceTemplateConsolidationDataList) {
       String newSubInterfaceNodeTemplateId = getNewSubInterfaceNodeTemplateId(serviceTemplate, computeType,
-          computeTemplateConsolidationData, subInterfaceTemplateConsolidationData, context);
+              computeTemplateConsolidationData, subInterfaceTemplateConsolidationData, context);
       updNodesConnectedInConnectivity(serviceTemplate, subInterfaceTemplateConsolidationData,
-          newSubInterfaceNodeTemplateId, context, false);
+              newSubInterfaceNodeTemplateId, context, false);
     }
   }
 
   protected void updNestedCompositionNodesConnectedInConnectivity(
-      ServiceTemplate serviceTemplate,
-      UnifiedCompositionData unifiedCompositionData,
-      TranslationContext context) {
+          ServiceTemplate serviceTemplate,
+          UnifiedCompositionData unifiedCompositionData,
+          TranslationContext context) {
     NestedTemplateConsolidationData nestedTemplateConsolidationData = unifiedCompositionData
-        .getNestedTemplateConsolidationData();
+            .getNestedTemplateConsolidationData();
     //Update requirements in the node template which pointing to the nested nodes
     String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
     Optional<String> newNestedNodeTemplateId = context.getUnifiedNestedNodeTemplateId(
-        serviceTemplateFileName, nestedTemplateConsolidationData.getNodeTemplateId());
+            serviceTemplateFileName, nestedTemplateConsolidationData.getNodeTemplateId());
     newNestedNodeTemplateId.ifPresent(
-        newNestedNodeTemplateIdVal -> updNodesConnectedInConnectivity(serviceTemplate,
-            nestedTemplateConsolidationData,
-            newNestedNodeTemplateIdVal, context, true));
+            newNestedNodeTemplateIdVal -> updNodesConnectedInConnectivity(serviceTemplate,
+                    nestedTemplateConsolidationData,
+                    newNestedNodeTemplateIdVal, context, true));
 
   }
 
   private void updVolumeConnectivity(ServiceTemplate serviceTemplate,
-                                       List<UnifiedCompositionData>
-                                           unifiedCompositionDataList,
-                                       TranslationContext context) {
+                                     List<UnifiedCompositionData>
+                                             unifiedCompositionDataList,
+                                     TranslationContext context) {
     for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
       ComputeTemplateConsolidationData computeTemplateConsolidationData = unifiedCompositionData
-          .getComputeTemplateConsolidationData();
+              .getComputeTemplateConsolidationData();
       //Add requirements in the abstract node template for compute volumes
       String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
-          computeTemplateConsolidationData.getNodeTemplateId());
+              computeTemplateConsolidationData.getNodeTemplateId());
       Map<String, List<RequirementAssignmentData>> computeVolumes =
-          computeTemplateConsolidationData.getVolumes();
+              computeTemplateConsolidationData.getVolumes();
       if (computeVolumes != null) {
         updateRequirementInAbstractNodeTemplate(serviceTemplate, computeTemplateConsolidationData,
-            newComputeNodeTemplateId, computeVolumes, context);
+                newComputeNodeTemplateId, computeVolumes, context);
       }
     }
   }
 
   private void updGroupsConnectivity(ServiceTemplate serviceTemplate,
-                                       List<UnifiedCompositionData>
-                                           unifiedCompositionDataList,
-                                       TranslationContext context) {
+                                     List<UnifiedCompositionData>
+                                             unifiedCompositionDataList,
+                                     TranslationContext context) {
     for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
       ComputeTemplateConsolidationData computeTemplateConsolidationData = unifiedCompositionData
-          .getComputeTemplateConsolidationData();
+              .getComputeTemplateConsolidationData();
       //Add requirements in the abstract node template for nodes connected in for computes
       updGroupsConnectivity(serviceTemplate, computeTemplateConsolidationData, context);
 
       //Add requirements in the abstract node template for nodes connected in for ports
       List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
-          getPortTemplateConsolidationDataList(unifiedCompositionData);
+              getPortTemplateConsolidationDataList(unifiedCompositionData);
       for (PortTemplateConsolidationData portTemplateConsolidationData :
-          portTemplateConsolidationDataList) {
+              portTemplateConsolidationDataList) {
         updGroupsConnectivity(serviceTemplate, portTemplateConsolidationData, context);
       }
 
       //Add requirements in the abstract node template for nodes connected in for subInterface
       List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
-          getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
+              getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
       for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData :
-          subInterfaceTemplateConsolidationDataList) {
+              subInterfaceTemplateConsolidationDataList) {
         updGroupsConnectivity(serviceTemplate, subInterfaceTemplateConsolidationData, context);
       }
     }
   }
 
   private void updGroupsConnectivity(ServiceTemplate serviceTemplate, EntityConsolidationData
-      entityConsolidationData, TranslationContext context) {
+          entityConsolidationData, TranslationContext context) {
     List<String> groupIds = entityConsolidationData.getGroupIds();
     if (groupIds == null) {
       return;
     }
     String oldNodeTemplateId = entityConsolidationData.getNodeTemplateId();
     String abstractNodeTemplateId = context.getUnifiedAbstractNodeTemplateId(
-        serviceTemplate, entityConsolidationData.getNodeTemplateId());
+            serviceTemplate, entityConsolidationData.getNodeTemplateId());
     Map<String, GroupDefinition> groups = serviceTemplate.getTopology_template().getGroups();
     if (groups == null) {
       return;
@@ -926,36 +926,36 @@ public class UnifiedCompositionService {
   }
 
   private void updOutputParamGetAttrInConnectivity(
-      ServiceTemplate serviceTemplate, List<UnifiedCompositionData> unifiedComposotionDataList,
-      TranslationContext context) {
+          ServiceTemplate serviceTemplate, List<UnifiedCompositionData> unifiedComposotionDataList,
+          TranslationContext context) {
     for (UnifiedCompositionData unifiedCompositionData : unifiedComposotionDataList) {
       ComputeTemplateConsolidationData computeTemplateConsolidationData =
-          unifiedCompositionData.getComputeTemplateConsolidationData();
+              unifiedCompositionData.getComputeTemplateConsolidationData();
       String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
-          computeTemplateConsolidationData.getNodeTemplateId());
+              computeTemplateConsolidationData.getNodeTemplateId());
 
       updOutputParamGetAttrInConnectivity(serviceTemplate, computeTemplateConsolidationData,
-          computeTemplateConsolidationData.getNodeTemplateId(), newComputeNodeTemplateId,
-          context, false);
+              computeTemplateConsolidationData.getNodeTemplateId(), newComputeNodeTemplateId,
+              context, false);
 
       String computeType =
-          getComputeTypeSuffix(serviceTemplate,
-              computeTemplateConsolidationData.getNodeTemplateId());
+              getComputeTypeSuffix(serviceTemplate,
+                      computeTemplateConsolidationData.getNodeTemplateId());
       List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
-          getPortTemplateConsolidationDataList(unifiedCompositionData);
+              getPortTemplateConsolidationDataList(unifiedCompositionData);
       for (PortTemplateConsolidationData portTemplateConsolidationData :
-          portTemplateConsolidationDataList) {
+              portTemplateConsolidationDataList) {
         String newPortNodeTemplateId =
-            getNewPortNodeTemplateId(portTemplateConsolidationData.getNodeTemplateId(), computeType,
-                computeTemplateConsolidationData);
+                getNewPortNodeTemplateId(portTemplateConsolidationData.getNodeTemplateId(), computeType,
+                        computeTemplateConsolidationData);
 
         updOutputParamGetAttrInConnectivity(serviceTemplate, portTemplateConsolidationData,
-            portTemplateConsolidationData.getNodeTemplateId(), newPortNodeTemplateId, context,
-            false);
+                portTemplateConsolidationData.getNodeTemplateId(), newPortNodeTemplateId, context,
+                false);
       }
 
       updateSubInterfaceOutputParamGetAttrIn(serviceTemplate, unifiedCompositionData,
-          computeTemplateConsolidationData, computeType, context);
+              computeTemplateConsolidationData, computeType, context);
     }
   }
 
@@ -965,52 +965,52 @@ public class UnifiedCompositionService {
                                                       String computeType,
                                                       TranslationContext context) {
     List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
-        getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
+            getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
     for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData :
-        subInterfaceTemplateConsolidationDataList) {
+            subInterfaceTemplateConsolidationDataList) {
       String newSubInterfaceNodeTemplateId = getNewSubInterfaceNodeTemplateId(serviceTemplate, computeType,
-          computeTemplateConsolidationData, subInterfaceTemplateConsolidationData, context);
+              computeTemplateConsolidationData, subInterfaceTemplateConsolidationData, context);
       updOutputParamGetAttrInConnectivity(serviceTemplate, subInterfaceTemplateConsolidationData,
-          subInterfaceTemplateConsolidationData.getNodeTemplateId(), newSubInterfaceNodeTemplateId, context,
-          false);
+              subInterfaceTemplateConsolidationData.getNodeTemplateId(), newSubInterfaceNodeTemplateId, context,
+              false);
     }
   }
 
   private void updNodesGetAttrInConnectivity(
-      ServiceTemplate serviceTemplate,
-      List<UnifiedCompositionData> unifiedComposotionDataList,
-      TranslationContext context) {
+          ServiceTemplate serviceTemplate,
+          List<UnifiedCompositionData> unifiedComposotionDataList,
+          TranslationContext context) {
     Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType =
-        getAllConsolidationNodeTemplateIdAndType(unifiedComposotionDataList);
+            getAllConsolidationNodeTemplateIdAndType(unifiedComposotionDataList);
     for (UnifiedCompositionData unifiedCompositionData : unifiedComposotionDataList) {
       ComputeTemplateConsolidationData computeTemplateConsolidationData =
-          unifiedCompositionData.getComputeTemplateConsolidationData();
+              unifiedCompositionData.getComputeTemplateConsolidationData();
       String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
-          computeTemplateConsolidationData.getNodeTemplateId());
+              computeTemplateConsolidationData.getNodeTemplateId());
 
       updNodeGetAttrInConnectivity(serviceTemplate, computeTemplateConsolidationData,
-          computeTemplateConsolidationData.getNodeTemplateId(),
-          newComputeNodeTemplateId, context, consolidationNodeTemplateIdAndType, false);
+              computeTemplateConsolidationData.getNodeTemplateId(),
+              newComputeNodeTemplateId, context, consolidationNodeTemplateIdAndType, false);
 
       String computeType =
-          getComputeTypeSuffix(serviceTemplate,
-              computeTemplateConsolidationData.getNodeTemplateId());
+              getComputeTypeSuffix(serviceTemplate,
+                      computeTemplateConsolidationData.getNodeTemplateId());
 
       List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
-          getPortTemplateConsolidationDataList(unifiedCompositionData);
+              getPortTemplateConsolidationDataList(unifiedCompositionData);
       for (PortTemplateConsolidationData portTemplateConsolidationData :
-          portTemplateConsolidationDataList) {
+              portTemplateConsolidationDataList) {
         String newPotNodeTemplateId =
-            getNewPortNodeTemplateId(portTemplateConsolidationData.getNodeTemplateId(), computeType,
-                computeTemplateConsolidationData);
+                getNewPortNodeTemplateId(portTemplateConsolidationData.getNodeTemplateId(), computeType,
+                        computeTemplateConsolidationData);
 
         updNodeGetAttrInConnectivity(serviceTemplate, portTemplateConsolidationData,
-            portTemplateConsolidationData.getNodeTemplateId(),
-            newPotNodeTemplateId, context, consolidationNodeTemplateIdAndType, false);
+                portTemplateConsolidationData.getNodeTemplateId(),
+                newPotNodeTemplateId, context, consolidationNodeTemplateIdAndType, false);
       }
 
       updateSubInterfaceNodesGetAttrIn(serviceTemplate, unifiedCompositionData,
-          computeTemplateConsolidationData, computeType, consolidationNodeTemplateIdAndType, context);
+              computeTemplateConsolidationData, computeType, consolidationNodeTemplateIdAndType, context);
     }
   }
 
@@ -1021,145 +1021,145 @@ public class UnifiedCompositionService {
                                                 Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType,
                                                 TranslationContext context) {
     List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
-        getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
+            getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
     for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData :
-        subInterfaceTemplateConsolidationDataList) {
+            subInterfaceTemplateConsolidationDataList) {
       String newSubInterfaceNodeTemplateId = getNewSubInterfaceNodeTemplateId(serviceTemplate, computeType,
-          computeTemplateConsolidationData, subInterfaceTemplateConsolidationData, context);
+              computeTemplateConsolidationData, subInterfaceTemplateConsolidationData, context);
       updNodeGetAttrInConnectivity(serviceTemplate, subInterfaceTemplateConsolidationData,
-          subInterfaceTemplateConsolidationData.getNodeTemplateId(),
-          newSubInterfaceNodeTemplateId, context,
-          consolidationNodeTemplateIdAndType, false);
+              subInterfaceTemplateConsolidationData.getNodeTemplateId(),
+              newSubInterfaceNodeTemplateId, context,
+              consolidationNodeTemplateIdAndType, false);
     }
   }
 
   protected void updNestedCompositionOutputParamGetAttrInConnectivity(
-      ServiceTemplate serviceTemplate, UnifiedCompositionData unifiedCompositionData,
-      TranslationContext context) {
+          ServiceTemplate serviceTemplate, UnifiedCompositionData unifiedCompositionData,
+          TranslationContext context) {
     NestedTemplateConsolidationData nestedTemplateConsolidationData =
-        unifiedCompositionData.getNestedTemplateConsolidationData();
+            unifiedCompositionData.getNestedTemplateConsolidationData();
     if (Objects.isNull(nestedTemplateConsolidationData)) {
       return;
     }
     String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
     Optional<String> newNestedNodeTemplateId = context.getUnifiedNestedNodeTemplateId(
-        serviceTemplateFileName, nestedTemplateConsolidationData.getNodeTemplateId());
+            serviceTemplateFileName, nestedTemplateConsolidationData.getNodeTemplateId());
 
     newNestedNodeTemplateId.ifPresent(
-        newNestedNodeTemplateIdVal -> updOutputParamGetAttrInConnectivity(serviceTemplate,
-            nestedTemplateConsolidationData, nestedTemplateConsolidationData.getNodeTemplateId(),
-            newNestedNodeTemplateIdVal, context, true));
+            newNestedNodeTemplateIdVal -> updOutputParamGetAttrInConnectivity(serviceTemplate,
+                    nestedTemplateConsolidationData, nestedTemplateConsolidationData.getNodeTemplateId(),
+                    newNestedNodeTemplateIdVal, context, true));
   }
 
   protected void updNestedCompositionNodesGetAttrInConnectivity(
-      ServiceTemplate serviceTemplate,
-      UnifiedCompositionData unifiedCompositionData,
-      TranslationContext context) {
+          ServiceTemplate serviceTemplate,
+          UnifiedCompositionData unifiedCompositionData,
+          TranslationContext context) {
     NestedTemplateConsolidationData nestedTemplateConsolidationData =
-        unifiedCompositionData.getNestedTemplateConsolidationData();
+            unifiedCompositionData.getNestedTemplateConsolidationData();
     if (Objects.isNull(nestedTemplateConsolidationData)) {
       return;
     }
     String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
     Optional<String> newNestedNodeTemplateId = context.getUnifiedNestedNodeTemplateId(
-        serviceTemplateFileName, nestedTemplateConsolidationData.getNodeTemplateId());
+            serviceTemplateFileName, nestedTemplateConsolidationData.getNodeTemplateId());
 
     newNestedNodeTemplateId.ifPresent(
-        newNestedNodeTemplateIdVal -> updNodeGetAttrInConnectivity(serviceTemplate,
-            nestedTemplateConsolidationData, nestedTemplateConsolidationData.getNodeTemplateId(),
-            newNestedNodeTemplateIdVal, context, null, true));
+            newNestedNodeTemplateIdVal -> updNodeGetAttrInConnectivity(serviceTemplate,
+                    nestedTemplateConsolidationData, nestedTemplateConsolidationData.getNodeTemplateId(),
+                    newNestedNodeTemplateIdVal, context, null, true));
   }
 
   private void updateRequirementForNodesConnectedIn(
-      ServiceTemplate serviceTemplate,
-      RequirementAssignmentData requirementAssignmentData,
-      EntityConsolidationData entityConsolidationData,
-      String originalNodeTemplateId,
-      String newNodeTemplateId,
-      TranslationContext context) {
+          ServiceTemplate serviceTemplate,
+          RequirementAssignmentData requirementAssignmentData,
+          EntityConsolidationData entityConsolidationData,
+          String originalNodeTemplateId,
+          String newNodeTemplateId,
+          TranslationContext context) {
     ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
     RequirementAssignment requirementAssignment = requirementAssignmentData
-        .getRequirementAssignment();
+            .getRequirementAssignment();
     String newAbstractUnifiedNodeTemplateId = context.getUnifiedAbstractNodeTemplateId(
-        serviceTemplate, entityConsolidationData.getNodeTemplateId());
+            serviceTemplate, entityConsolidationData.getNodeTemplateId());
     NodeTemplate abstractUnifiedNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
-        newAbstractUnifiedNodeTemplateId);
+            newAbstractUnifiedNodeTemplateId);
     Optional<String> newCapabilityId = getNewCapabilityForNodesConnectedIn(serviceTemplate,
-        abstractUnifiedNodeTemplate, requirementAssignment, newNodeTemplateId, context);
+            abstractUnifiedNodeTemplate, requirementAssignment, newNodeTemplateId, context);
     if (newCapabilityId.isPresent()) {
       //Creating a copy of the requirement object and checking if it already exists in the
       // original node template
       RequirementAssignment requirementAssignmentCopy = (RequirementAssignment) getClonedObject(
-          requirementAssignmentData.getRequirementAssignment(), RequirementAssignment.class);
+              requirementAssignmentData.getRequirementAssignment(), RequirementAssignment.class);
       NodeTemplate originalNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
-          originalNodeTemplateId);
+              originalNodeTemplateId);
       requirementAssignmentCopy.setCapability(newCapabilityId.get());
       requirementAssignmentCopy.setNode(newAbstractUnifiedNodeTemplateId);
       if (!toscaAnalyzerService.isRequirementExistInNodeTemplate(originalNodeTemplate,
-          requirementAssignmentData.getRequirementId(), requirementAssignmentCopy)) {
+              requirementAssignmentData.getRequirementId(), requirementAssignmentCopy)) {
         //Update the existing requirement
         requirementAssignmentData.getRequirementAssignment().setCapability(newCapabilityId
-            .get());
+                .get());
         requirementAssignmentData.getRequirementAssignment()
-            .setNode(newAbstractUnifiedNodeTemplateId);
+                .setNode(newAbstractUnifiedNodeTemplateId);
       } else {
         //The updated requirement already exists in the node template so simply remove the
         // current one
         DataModelUtil.removeRequirementAssignment(originalNodeTemplate, requirementAssignmentData
-            .getRequirementId(), requirementAssignmentData.getRequirementAssignment());
+                .getRequirementId(), requirementAssignmentData.getRequirementAssignment());
       }
     }
   }
 
   private void updateRequirementForNestedCompositionNodesConnectedIn(
-      ServiceTemplate serviceTemplate,
-      RequirementAssignmentData requirementAssignmentData,
-      String newNodeTemplateId) {
+          ServiceTemplate serviceTemplate,
+          RequirementAssignmentData requirementAssignmentData,
+          String newNodeTemplateId) {
     ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
     String newAbstractUnifiedNodeTemplateId = newNodeTemplateId;
     RequirementAssignment requirementAssignment = requirementAssignmentData
-        .getRequirementAssignment();
+            .getRequirementAssignment();
     //Creating a copy of the requirement object and checking if it already exists in the
     // original node template
     RequirementAssignment requirementAssignmentCopy = (RequirementAssignment) getClonedObject(
-        requirementAssignmentData.getRequirementAssignment(), RequirementAssignment.class);
+            requirementAssignmentData.getRequirementAssignment(), RequirementAssignment.class);
     NodeTemplate unifiedAbstractNestedNodeTemplate = DataModelUtil
-        .getNodeTemplate(serviceTemplate, newAbstractUnifiedNodeTemplateId);
+            .getNodeTemplate(serviceTemplate, newAbstractUnifiedNodeTemplateId);
     requirementAssignmentCopy.setCapability(requirementAssignment.getCapability());
     requirementAssignmentCopy.setNode(newAbstractUnifiedNodeTemplateId);
     if (!toscaAnalyzerService.isRequirementExistInNodeTemplate(unifiedAbstractNestedNodeTemplate,
-        requirementAssignmentData.getRequirementId(), requirementAssignmentCopy)) {
+            requirementAssignmentData.getRequirementId(), requirementAssignmentCopy)) {
       //Update the existing requirement
       requirementAssignmentData.getRequirementAssignment()
-          .setNode(newAbstractUnifiedNodeTemplateId);
+              .setNode(newAbstractUnifiedNodeTemplateId);
     } else {
       //The updated requirement already exists in the node template so simply remove the
       // current one
       DataModelUtil.removeRequirementAssignment(unifiedAbstractNestedNodeTemplate,
-          requirementAssignmentData.getRequirementId(), requirementAssignmentData
-              .getRequirementAssignment());
+              requirementAssignmentData.getRequirementId(), requirementAssignmentData
+                      .getRequirementAssignment());
     }
   }
 
   private Optional<String> getNewCapabilityForNodesConnectedIn(ServiceTemplate serviceTemplate,
                                                                NodeTemplate unifiedNodeTemplate,
                                                                RequirementAssignment
-                                                                   requirementAssignment,
+                                                                       requirementAssignment,
                                                                String newNodeTemplateId,
                                                                TranslationContext context) {
     ServiceTemplate globalSubstitutionServiceTemplate =
-        HeatToToscaUtil.fetchGlobalSubstitutionServiceTemplate(serviceTemplate, context);
+            HeatToToscaUtil.fetchGlobalSubstitutionServiceTemplate(serviceTemplate, context);
     Map<String, NodeType> nodeTypes = globalSubstitutionServiceTemplate.getNode_types();
     String unifiedNodeTemplateType = unifiedNodeTemplate.getType();
     NodeType unifiedNodeType = nodeTypes.get(unifiedNodeTemplateType);
     Map<String, CapabilityDefinition> abstractNodeTypeCapabilities = unifiedNodeType
-        .getCapabilities();
+            .getCapabilities();
     for (Map.Entry<String, CapabilityDefinition> entry : abstractNodeTypeCapabilities.entrySet()) {
       String capabilityId = entry.getKey();
       CapabilityDefinition capabilityDefinition = entry.getValue();
       String capabilityType = capabilityDefinition.getType();
       if (capabilityType.equals(requirementAssignment.getCapability())
-          && capabilityId.endsWith(newNodeTemplateId)) {
+              && capabilityId.endsWith(newNodeTemplateId)) {
         //Matching capability type found..Check if the id ends with new node template id
         return Optional.ofNullable(capabilityId);
       }
@@ -1170,18 +1170,18 @@ public class UnifiedCompositionService {
 
   private void updateRequirementInAbstractNodeTemplate(ServiceTemplate serviceTemplate,
                                                        EntityConsolidationData
-                                                           entityConsolidationData,
+                                                               entityConsolidationData,
                                                        String newNodeTemplateId,
                                                        Map<String, List<RequirementAssignmentData>>
-                                                           requirementAssignmentDataMap,
+                                                               requirementAssignmentDataMap,
                                                        TranslationContext context) {
     ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
     for (Map.Entry<String, List<RequirementAssignmentData>> entry : requirementAssignmentDataMap
-        .entrySet()) {
+            .entrySet()) {
       String abstractNodeTemplateId = context.getUnifiedAbstractNodeTemplateId(
-          serviceTemplate, entityConsolidationData.getNodeTemplateId());
+              serviceTemplate, entityConsolidationData.getNodeTemplateId());
       NodeTemplate abstractNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
-          abstractNodeTemplateId);
+              abstractNodeTemplateId);
       if (abstractNodeTemplate == null) {
         //The abstract node template is not found from id in the context
         return;
@@ -1190,18 +1190,18 @@ public class UnifiedCompositionService {
       for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList) {
         String oldRequirementId = requirementAssignmentData.getRequirementId();
         RequirementAssignment abstractRequirementAssignment = (RequirementAssignment)
-            getClonedObject(requirementAssignmentData.getRequirementAssignment(),
-                RequirementAssignment.class);
+                getClonedObject(requirementAssignmentData.getRequirementAssignment(),
+                        RequirementAssignment.class);
         String newRequirementId = oldRequirementId + "_" + newNodeTemplateId;
         //Check if the requirement is not already present in the list of requirements of the
         // abstract node template
         if (!toscaAnalyzerService.isRequirementExistInNodeTemplate(abstractNodeTemplate,
-            newRequirementId, abstractRequirementAssignment)) {
+                newRequirementId, abstractRequirementAssignment)) {
           DataModelUtil.addRequirementAssignment(abstractNodeTemplate, newRequirementId,
-              abstractRequirementAssignment);
+                  abstractRequirementAssignment);
           //Update the volume relationship template if required
           updateVolumeRelationshipTemplate(serviceTemplate, abstractRequirementAssignment
-              .getRelationship(), context);
+                  .getRelationship(), context);
         }
       }
     }
@@ -1209,10 +1209,10 @@ public class UnifiedCompositionService {
 
   private void updateRequirementInNestedNodeTemplate(ServiceTemplate serviceTemplate,
                                                      EntityConsolidationData
-                                                         entityConsolidationData,
+                                                             entityConsolidationData,
                                                      String newNodeTemplateId,
                                                      Map<String, List<RequirementAssignmentData>>
-                                                         requirementAssignmentDataMap) {
+                                                             requirementAssignmentDataMap) {
     ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
 
     if (MapUtils.isEmpty(requirementAssignmentDataMap)) {
@@ -1220,7 +1220,7 @@ public class UnifiedCompositionService {
     }
 
     for (Map.Entry<String, List<RequirementAssignmentData>> entry : requirementAssignmentDataMap
-        .entrySet()) {
+            .entrySet()) {
       String nodeTemplateId = entityConsolidationData.getNodeTemplateId();
       NodeTemplate nodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate, nodeTemplateId);
       if (nodeTemplate == null) {
@@ -1231,29 +1231,29 @@ public class UnifiedCompositionService {
       for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList) {
         String oldRequirementId = requirementAssignmentData.getRequirementId();
         RequirementAssignment clonedRequirementAssignment = (RequirementAssignment)
-            getClonedObject(requirementAssignmentData.getRequirementAssignment(),
-                RequirementAssignment.class);
+                getClonedObject(requirementAssignmentData.getRequirementAssignment(),
+                        RequirementAssignment.class);
         String newRequirementId = oldRequirementId + "_" + newNodeTemplateId;
         //Check if the requirement is not already present in the list of requirements of the
         // node template
         if (!toscaAnalyzerService.isRequirementExistInNodeTemplate(nodeTemplate,
-            newRequirementId, clonedRequirementAssignment)) {
+                newRequirementId, clonedRequirementAssignment)) {
           DataModelUtil.removeRequirementAssignment(nodeTemplate, oldRequirementId,
-              requirementAssignmentData.getRequirementAssignment());
+                  requirementAssignmentData.getRequirementAssignment());
           DataModelUtil.addRequirementAssignment(nodeTemplate, newRequirementId,
-              clonedRequirementAssignment);
+                  clonedRequirementAssignment);
         }
       }
     }
   }
 
   private void updNodeGetAttrInConnectivity(
-      ServiceTemplate serviceTemplate,
-      EntityConsolidationData entityConsolidationData,
-      String oldNodeTemplateId, String newNodeTemplateId,
-      TranslationContext context,
-      Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType,
-      boolean isNested) {
+          ServiceTemplate serviceTemplate,
+          EntityConsolidationData entityConsolidationData,
+          String oldNodeTemplateId, String newNodeTemplateId,
+          TranslationContext context,
+          Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType,
+          boolean isNested) {
     Map<String, List<GetAttrFuncData>> nodesGetAttrIn = entityConsolidationData.getNodesGetAttrIn();
     if (MapUtils.isEmpty(nodesGetAttrIn)) {
       return;
@@ -1262,25 +1262,25 @@ public class UnifiedCompositionService {
     for (Map.Entry<String, List<GetAttrFuncData>> nodesGetAttrInEntry : nodesGetAttrIn.entrySet()) {
       String sourceNodeTemplateId = nodesGetAttrInEntry.getKey();
       NodeTemplate sourceNodeTemplate =
-          DataModelUtil.getNodeTemplate(serviceTemplate, sourceNodeTemplateId);
+              DataModelUtil.getNodeTemplate(serviceTemplate, sourceNodeTemplateId);
       if (!isNested && consolidationNodeTemplateIdAndType.keySet().contains(sourceNodeTemplateId)) {
         continue;
       }
       List<GetAttrFuncData> getAttrFuncDataList = nodesGetAttrInEntry.getValue();
       for (GetAttrFuncData getAttrFuncData : getAttrFuncDataList) {
         Object propertyValue =
-            DataModelUtil.getPropertyValue(sourceNodeTemplate, getAttrFuncData.getFieldName());
+                DataModelUtil.getPropertyValue(sourceNodeTemplate, getAttrFuncData.getFieldName());
         String newAttrName = null;
         String newGetAttrAbstractNodeTemplateId = newNodeTemplateId;
         if (!isNested) {
           newGetAttrAbstractNodeTemplateId =
-              context.getUnifiedAbstractNodeTemplateId(serviceTemplate, oldNodeTemplateId);
+                  context.getUnifiedAbstractNodeTemplateId(serviceTemplate, oldNodeTemplateId);
           newAttrName = getNewSubstitutionOutputParameterId(newNodeTemplateId, getAttrFuncData
-              .getAttributeName());
+                  .getAttributeName());
         }
         List<List<Object>> getAttrFuncValueList = extractGetAttrFunction(propertyValue);
         updateGetAttrValue(oldNodeTemplateId, getAttrFuncData, newGetAttrAbstractNodeTemplateId,
-            newAttrName, getAttrFuncValueList, isNested);
+                newAttrName, getAttrFuncValueList, isNested);
       }
     }
   }
@@ -1290,7 +1290,7 @@ public class UnifiedCompositionService {
                                   List<List<Object>> getAttrFuncValueList, boolean isNested) {
     for (List<Object> getAttrFuncValue : getAttrFuncValueList) {
       if (oldNodeTemplateId.equals(getAttrFuncValue.get(0))
-          && getAttrFuncData.getAttributeName().equals(getAttrFuncValue.get(1))) {
+              && getAttrFuncData.getAttributeName().equals(getAttrFuncValue.get(1))) {
         getAttrFuncValue.set(0, newNodeTemplateId);
         if (!isNested) {
           getAttrFuncValue.set(1, newAttrName);
@@ -1316,26 +1316,26 @@ public class UnifiedCompositionService {
                                                    TranslationContext context,
                                                    boolean isNested) {
     List<GetAttrFuncData> outputParametersGetAttrIn =
-        entityConsolidationData.getOutputParametersGetAttrIn();
+            entityConsolidationData.getOutputParametersGetAttrIn();
     if (CollectionUtils.isEmpty(outputParametersGetAttrIn)) {
       return;
     }
     for (GetAttrFuncData getAttrFuncData : outputParametersGetAttrIn) {
       Object outputParamValue =
-          DataModelUtil.getOuputParameter(serviceTemplate, getAttrFuncData.getFieldName())
-              .getValue();
+              DataModelUtil.getOuputParameter(serviceTemplate, getAttrFuncData.getFieldName())
+                      .getValue();
       String newAttrName = null;
       String newGetAttrAbstractNodeTemplateId = newNodeTemplateId;
       if (!isNested) {
         newGetAttrAbstractNodeTemplateId =
-            context.getUnifiedAbstractNodeTemplateId(serviceTemplate, oldNodeTemplateId);
+                context.getUnifiedAbstractNodeTemplateId(serviceTemplate, oldNodeTemplateId);
         newAttrName = getNewSubstitutionOutputParameterId(newNodeTemplateId, getAttrFuncData
-            .getAttributeName());
+                .getAttributeName());
       }
       List<List<Object>> getAttrFuncValueList = extractGetAttrFunction(outputParamValue);
       updateGetAttrValue(oldNodeTemplateId, getAttrFuncData, newGetAttrAbstractNodeTemplateId,
-          newAttrName,
-          getAttrFuncValueList, isNested);
+              newAttrName,
+              getAttrFuncValueList, isNested);
     }
 
   }
@@ -1347,7 +1347,7 @@ public class UnifiedCompositionService {
     if (valueObject instanceof Map) {
       if (((Map) valueObject).containsKey(ToscaFunctions.GET_ATTRIBUTE.getDisplayName())) {
         getAttrValueList.add(
-            (List<Object>) ((Map) valueObject).get(ToscaFunctions.GET_ATTRIBUTE.getDisplayName()));
+                (List<Object>) ((Map) valueObject).get(ToscaFunctions.GET_ATTRIBUTE.getDisplayName()));
       }
 
       for (Object key : ((Map) valueObject).keySet()) {
@@ -1389,33 +1389,33 @@ public class UnifiedCompositionService {
                                       String computeNodeType) {
 
     createOutputParametersForCompute(unifiedCompositionTo.getServiceTemplate(),
-        unifiedCompositionTo.getSubstitutionServiceTemplate(), unifiedCompositionTo.getUnifiedCompositionDataList(),
-        unifiedCompositionTo.getContext());
+            unifiedCompositionTo.getSubstitutionServiceTemplate(), unifiedCompositionTo.getUnifiedCompositionDataList(),
+            unifiedCompositionTo.getContext());
     createOutputParameterForPorts(unifiedCompositionTo.getSubstitutionServiceTemplate(),
-        unifiedCompositionTo.getUnifiedCompositionDataList(), computeNodeType, unifiedCompositionTo.getContext());
+            unifiedCompositionTo.getUnifiedCompositionDataList(), computeNodeType, unifiedCompositionTo.getContext());
     createOutputParameterForSubInterfaces(unifiedCompositionTo, computeNodeType);
   }
 
   private void createOutputParameterForPorts(
-      ServiceTemplate substitutionServiceTemplate,
-      List<UnifiedCompositionData> unifiedCompositionDataList,
-      String connectedComputeNodeType,
-      TranslationContext context) {
+          ServiceTemplate substitutionServiceTemplate,
+          List<UnifiedCompositionData> unifiedCompositionDataList,
+          String connectedComputeNodeType,
+          TranslationContext context) {
     for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
       List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
-          getPortTemplateConsolidationDataList(unifiedCompositionData);
+              getPortTemplateConsolidationDataList(unifiedCompositionData);
       if (CollectionUtils.isEmpty(portTemplateConsolidationDataList)) {
         return;
       }
 
       for (PortTemplateConsolidationData portTemplateConsolidationData :
-          portTemplateConsolidationDataList) {
+              portTemplateConsolidationDataList) {
         String newPortNodeTemplateId =
-            getNewPortNodeTemplateId(portTemplateConsolidationData.getNodeTemplateId(),
-                connectedComputeNodeType,
-                unifiedCompositionData.getComputeTemplateConsolidationData());
+                getNewPortNodeTemplateId(portTemplateConsolidationData.getNodeTemplateId(),
+                        connectedComputeNodeType,
+                        unifiedCompositionData.getComputeTemplateConsolidationData());
         addOutputParameters(portTemplateConsolidationData, newPortNodeTemplateId,
-            substitutionServiceTemplate, unifiedCompositionDataList, context);
+                substitutionServiceTemplate, unifiedCompositionDataList, context);
       }
     }
   }
@@ -1424,39 +1424,39 @@ public class UnifiedCompositionService {
                                                      String connectedComputeNodeType) {
     for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionTo.getUnifiedCompositionDataList()) {
       List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
-          getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
+              getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
       if (CollectionUtils.isEmpty(subInterfaceTemplateConsolidationDataList)) {
         return;
       }
 
       for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData :
-          subInterfaceTemplateConsolidationDataList) {
+              subInterfaceTemplateConsolidationDataList) {
         String newSubInterfaceNodeTemplateId = getNewSubInterfaceNodeTemplateId(unifiedCompositionTo
-                .getServiceTemplate(), connectedComputeNodeType, unifiedCompositionData
-                .getComputeTemplateConsolidationData(), subInterfaceTemplateConsolidationData,
-            unifiedCompositionTo.getContext());
+                        .getServiceTemplate(), connectedComputeNodeType, unifiedCompositionData
+                        .getComputeTemplateConsolidationData(), subInterfaceTemplateConsolidationData,
+                unifiedCompositionTo.getContext());
         addOutputParameters(subInterfaceTemplateConsolidationData, newSubInterfaceNodeTemplateId,
-            unifiedCompositionTo.getSubstitutionServiceTemplate(), unifiedCompositionTo.getUnifiedCompositionDataList(),
-            unifiedCompositionTo.getContext());
+                unifiedCompositionTo.getSubstitutionServiceTemplate(), unifiedCompositionTo.getUnifiedCompositionDataList(),
+                unifiedCompositionTo.getContext());
       }
     }
   }
 
   private void createOutputParametersForCompute(
-      ServiceTemplate serviceTemplate,
-      ServiceTemplate substitutionServiceTemplate,
-      List<UnifiedCompositionData>
-          unifiedCompositionDataList,
-      TranslationContext context) {
+          ServiceTemplate serviceTemplate,
+          ServiceTemplate substitutionServiceTemplate,
+          List<UnifiedCompositionData>
+                  unifiedCompositionDataList,
+          TranslationContext context) {
     List<EntityConsolidationData> computeConsolidationDataList =
-        getComputeConsolidationDataList(unifiedCompositionDataList);
+            getComputeConsolidationDataList(unifiedCompositionDataList);
 
     for (EntityConsolidationData computeTemplateConsolidationData : computeConsolidationDataList) {
       String newComputeNodeTemplateId =
-          getNewComputeNodeTemplateId(serviceTemplate,
-              computeTemplateConsolidationData.getNodeTemplateId());
+              getNewComputeNodeTemplateId(serviceTemplate,
+                      computeTemplateConsolidationData.getNodeTemplateId());
       addOutputParameters(computeTemplateConsolidationData, newComputeNodeTemplateId,
-           substitutionServiceTemplate, unifiedCompositionDataList, context);
+              substitutionServiceTemplate, unifiedCompositionDataList, context);
     }
   }
 
@@ -1466,10 +1466,10 @@ public class UnifiedCompositionService {
                                    List<UnifiedCompositionData> unifiedCompositionDataList,
                                    TranslationContext context) {
     handleNodesGetAttrIn(entityConsolidationData, newNodeTemplateId, substitutionServiceTemplate,
-        unifiedCompositionDataList, context);
+            unifiedCompositionDataList, context);
 
     handleOutputParamGetAttrIn(entityConsolidationData, newNodeTemplateId,
-        substitutionServiceTemplate, context);
+            substitutionServiceTemplate, context);
   }
 
   private void handleOutputParamGetAttrIn(EntityConsolidationData entityConsolidationData,
@@ -1477,11 +1477,11 @@ public class UnifiedCompositionService {
                                           ServiceTemplate substitutionServiceTemplate,
                                           TranslationContext context) {
     List<GetAttrFuncData> outputParametersGetAttrIn =
-        entityConsolidationData.getOutputParametersGetAttrIn();
+            entityConsolidationData.getOutputParametersGetAttrIn();
     if (!CollectionUtils.isEmpty(outputParametersGetAttrIn)) {
       for (GetAttrFuncData getAttrFuncData : outputParametersGetAttrIn) {
         createAndAddOutputParameter(newNodeTemplateId,
-            substitutionServiceTemplate, getAttrFuncData, context);
+                substitutionServiceTemplate, getAttrFuncData, context);
       }
     }
   }
@@ -1496,14 +1496,14 @@ public class UnifiedCompositionService {
       return;
     }
     Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType =
-        getAllConsolidationNodeTemplateIdAndType(unifiedCompositionDataList);
+            getAllConsolidationNodeTemplateIdAndType(unifiedCompositionDataList);
     for (Map.Entry<String, List<GetAttrFuncData>> getAttrInEntry : getAttrIn.entrySet()) {
       String sourceNodeTemplateId = getAttrInEntry.getKey();
       if (!consolidationNodeTemplateIdAndType.keySet().contains(sourceNodeTemplateId)) {
         List<GetAttrFuncData> getAttrFuncDataList = getAttrInEntry.getValue();
         for (GetAttrFuncData getAttrFuncData : getAttrFuncDataList) {
           createAndAddOutputParameter(newNodeTemplateId,
-              substitutionServiceTemplate, getAttrFuncData, context);
+                  substitutionServiceTemplate, getAttrFuncData, context);
         }
       }
     }
@@ -1521,10 +1521,10 @@ public class UnifiedCompositionService {
     ParameterDefinition outputParameter = new ParameterDefinition();
     outputParameter.setValue(parameterValue);
     setOutputParameterType(substitutionServiceTemplate, newNodeTemplateId, getAttrFuncData
-        .getAttributeName(), outputParameter, context);
+            .getAttributeName(), outputParameter, context);
     DataModelUtil.addOutputParameterToTopologyTemplate(substitutionServiceTemplate,
-        getNewSubstitutionOutputParameterId(newNodeTemplateId, getAttrFuncData.getAttributeName()),
-        outputParameter);
+            getNewSubstitutionOutputParameterId(newNodeTemplateId, getAttrFuncData.getAttributeName()),
+            outputParameter);
   }
 
   private void setOutputParameterType(ServiceTemplate substitutionServiceTemplate,
@@ -1533,16 +1533,16 @@ public class UnifiedCompositionService {
                                       ParameterDefinition outputParameter,
                                       TranslationContext context) {
     NodeTemplate nodeTemplate = DataModelUtil.getNodeTemplate(substitutionServiceTemplate,
-        newNodeTemplateId);
+            newNodeTemplateId);
     //Get the type and entry schema of the output parameter from the node type flat hierarchy
     String outputParameterType;
     EntrySchema outputParameterEntrySchema;
     NodeType nodeTypeWithFlatHierarchy =
-        HeatToToscaUtil.getNodeTypeWithFlatHierarchy(nodeTemplate.getType(),
-            substitutionServiceTemplate, context);
+            HeatToToscaUtil.getNodeTypeWithFlatHierarchy(nodeTemplate.getType(),
+                    substitutionServiceTemplate, context);
     //Check if the parameter is present in the attributes
     AttributeDefinition outputParameterDefinitionFromAttributes =
-        getOutputParameterDefinitionFromAttributes(nodeTypeWithFlatHierarchy, outputParameterName);
+            getOutputParameterDefinitionFromAttributes(nodeTypeWithFlatHierarchy, outputParameterName);
     if (Objects.nonNull(outputParameterDefinitionFromAttributes)) {
       outputParameterType = outputParameterDefinitionFromAttributes.getType();
       outputParameterEntrySchema = outputParameterDefinitionFromAttributes.getEntry_schema();
@@ -1551,7 +1551,7 @@ public class UnifiedCompositionService {
       // properties and global types are in sync. Ideally the parameter should be found in either
       // properties or attributes collected from global types
       PropertyDefinition outputParameterDefinitionFromProperties =
-          nodeTypeWithFlatHierarchy.getProperties().get(outputParameterName);
+              nodeTypeWithFlatHierarchy.getProperties().get(outputParameterName);
       outputParameterType = outputParameterDefinitionFromProperties.getType();
       outputParameterEntrySchema = outputParameterDefinitionFromProperties.getEntry_schema();
     }
@@ -1561,13 +1561,13 @@ public class UnifiedCompositionService {
   }
 
   private AttributeDefinition getOutputParameterDefinitionFromAttributes(NodeType
-                                                                             nodeTypeWithFlatHierarchy,
+                                                                                 nodeTypeWithFlatHierarchy,
                                                                          String outputParameterName) {
     AttributeDefinition outputParameterDefinition = null;
     if ((Objects.nonNull(nodeTypeWithFlatHierarchy.getAttributes()))
-        && (nodeTypeWithFlatHierarchy.getAttributes().containsKey(outputParameterName))) {
+            && (nodeTypeWithFlatHierarchy.getAttributes().containsKey(outputParameterName))) {
       outputParameterDefinition =
-          nodeTypeWithFlatHierarchy.getAttributes().get(outputParameterName);
+              nodeTypeWithFlatHierarchy.getAttributes().get(outputParameterName);
     }
     return outputParameterDefinition;
   }
@@ -1578,36 +1578,36 @@ public class UnifiedCompositionService {
   }
 
   private void addUnifiedSubstitionData(TranslationContext context, ServiceTemplate
-      serviceTemplate, List<UnifiedCompositionData> unifiedCompositionDataList, String
-                                            substituteNodeTemplateId) {
+          serviceTemplate, List<UnifiedCompositionData> unifiedCompositionDataList, String
+                                                substituteNodeTemplateId) {
     String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
     for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
       //Add compute node template mapping information
       ComputeTemplateConsolidationData computeTemplateConsolidationData =
-          unifiedCompositionData.getComputeTemplateConsolidationData();
+              unifiedCompositionData.getComputeTemplateConsolidationData();
       String computeNodeTemplateId = computeTemplateConsolidationData.getNodeTemplateId();
       context.addUnifiedSubstitutionData(serviceTemplateFileName, computeNodeTemplateId,
-          substituteNodeTemplateId);
+              substituteNodeTemplateId);
       //Add Port template mapping information
       List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
-          getPortTemplateConsolidationDataList(unifiedCompositionData);
+              getPortTemplateConsolidationDataList(unifiedCompositionData);
 
       if (CollectionUtils.isNotEmpty(portTemplateConsolidationDataList)) {
         for (PortTemplateConsolidationData portTemplateConsolidationData :
-            portTemplateConsolidationDataList) {
+                portTemplateConsolidationDataList) {
           String oldPortNodeTemplateId = portTemplateConsolidationData.getNodeTemplateId();
           context.addUnifiedSubstitutionData(serviceTemplateFileName, oldPortNodeTemplateId,
-              substituteNodeTemplateId);
+                  substituteNodeTemplateId);
         }
       }
       //Add Sub-interface template mapping information
       List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
-          getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
+              getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
       if (CollectionUtils.isNotEmpty(subInterfaceTemplateConsolidationDataList)) {
         for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData :
-            subInterfaceTemplateConsolidationDataList) {
+                subInterfaceTemplateConsolidationDataList) {
           context.addUnifiedSubstitutionData(serviceTemplateFileName,
-              subInterfaceTemplateConsolidationData.getNodeTemplateId(), substituteNodeTemplateId);
+                  subInterfaceTemplateConsolidationData.getNodeTemplateId(), substituteNodeTemplateId);
         }
       }
     }
@@ -1622,16 +1622,16 @@ public class UnifiedCompositionService {
     Map<String, Object> indexPropertyValue = new HashMap<>();
     Map<String, Object> properties = nodeTemplate.getProperties();
     indexPropertyValue.put(ToscaFunctions.GET_PROPERTY.getDisplayName(),
-        indexValueGetPropertyValue);
+            indexValueGetPropertyValue);
     properties.put(ToscaConstants.INDEX_VALUE_PROPERTY_NAME,
-        indexPropertyValue);
+            indexPropertyValue);
     nodeTemplate.setProperties(properties);
   }
 
   private String getSubstituteNodeTemplateId(String nodeTypeId,
                                              Integer index) {
     String nodeTemplateId = ABSTRACT_NODE_TEMPLATE_ID_PREFIX + DataModelUtil
-        .getNamespaceSuffix(nodeTypeId);
+            .getNamespaceSuffix(nodeTypeId);
     if (Objects.nonNull(index)) {
       nodeTemplateId = nodeTemplateId + "_" + index.toString();
     }
@@ -1651,15 +1651,15 @@ public class UnifiedCompositionService {
                                           Integer index,
                                           TranslationContext context) {
     String computeNodeTemplateId =
-        unifiedCompositionData.getComputeTemplateConsolidationData().getNodeTemplateId();
+            unifiedCompositionData.getComputeTemplateConsolidationData().getNodeTemplateId();
     NodeTemplate computeNodeTemplate =
-        DataModelUtil.getNodeTemplate(serviceTemplate, computeNodeTemplateId);
+            DataModelUtil.getNodeTemplate(serviceTemplate, computeNodeTemplateId);
     String computeType = computeNodeTemplate.getType();
     String globalSTName = ToscaUtil.getServiceTemplateFileName(Constants
-        .GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME);
+            .GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME);
 
     String nodeTypeId = ToscaNodeType.ABSTRACT_NODE_TYPE_PREFIX
-        + DataModelUtil.getNamespaceSuffix(getIndexedGlobalNodeTypeId(computeType, context));
+            + DataModelUtil.getNamespaceSuffix(getIndexedGlobalNodeTypeId(computeType, context));
 
     context.updateUsedTimesForNestedComputeNodeType(globalSTName, computeType);
 
@@ -1674,12 +1674,12 @@ public class UnifiedCompositionService {
                                                     TranslationContext context,
                                                     String substitutionNodeTypeId) {
     NodeType substitutionNodeType = new ToscaAnalyzerServiceImpl()
-        .createInitSubstitutionNodeType(substitutionServiceTemplate,
-            ToscaNodeType.VFC_ABSTRACT_SUBSTITUTE);
+            .createInitSubstitutionNodeType(substitutionServiceTemplate,
+                    ToscaNodeType.VFC_ABSTRACT_SUBSTITUTE);
     ServiceTemplate globalSubstitutionServiceTemplate =
-        HeatToToscaUtil.fetchGlobalSubstitutionServiceTemplate(serviceTemplate, context);
+            HeatToToscaUtil.fetchGlobalSubstitutionServiceTemplate(serviceTemplate, context);
     DataModelUtil.addNodeType(globalSubstitutionServiceTemplate, substitutionNodeTypeId,
-        substitutionNodeType);
+            substitutionNodeType);
 
     return substitutionNodeType;
   }
@@ -1692,10 +1692,10 @@ public class UnifiedCompositionService {
 
     if (unifiedCompositionDataList.size() > 1) {
       handleConsolidationPorts(serviceTemplate, substitutionServiceTemplate,
-          unifiedCompositionDataList, connectedComputeNodeType, context);
+              unifiedCompositionDataList, connectedComputeNodeType, context);
     } else {
       handleSinglePorts(serviceTemplate, substitutionServiceTemplate, connectedComputeNodeType,
-          unifiedCompositionDataList, context);
+              unifiedCompositionDataList, context);
     }
   }
 
@@ -1706,18 +1706,18 @@ public class UnifiedCompositionService {
                                  TranslationContext context) {
     UnifiedCompositionData unifiedCompositionData = unifiedCompositionDataList.get(0);
     List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
-        getPortTemplateConsolidationDataList(unifiedCompositionData);
+            getPortTemplateConsolidationDataList(unifiedCompositionData);
     if (CollectionUtils.isEmpty(portTemplateConsolidationDataList)) {
       return;
     }
     for (PortTemplateConsolidationData portTemplateConsolidationData :
-        portTemplateConsolidationDataList) {
+            portTemplateConsolidationDataList) {
       List<EntityConsolidationData> portConsolidationDataList = new ArrayList<>();
       portConsolidationDataList.add(portTemplateConsolidationData);
       handlePortNodeTemplate(serviceTemplate, substitutionServiceTemplate,
-          portConsolidationDataList, connectedComputeNodeType,
-          unifiedCompositionData.getComputeTemplateConsolidationData(),
-          unifiedCompositionDataList, context);
+              portConsolidationDataList, connectedComputeNodeType,
+              unifiedCompositionData.getComputeTemplateConsolidationData(),
+              unifiedCompositionDataList, context);
     }
   }
 
@@ -1727,62 +1727,62 @@ public class UnifiedCompositionService {
                                         String connectedComputeNodeType,
                                         TranslationContext context) {
     Collection<ComputeTemplateConsolidationData> computeConsolidationDataList =
-        (Collection) getComputeConsolidationDataList(unifiedCompositionDataList);
+            (Collection) getComputeConsolidationDataList(unifiedCompositionDataList);
 
     Map<String, List<String>> portIdsPerPortType = UnifiedCompositionUtil
-        .collectAllPortsFromEachTypesFromComputes(computeConsolidationDataList);
+            .collectAllPortsFromEachTypesFromComputes(computeConsolidationDataList);
 
     for (Map.Entry<String, List<String>> portIdsPerPortTypeEntry : portIdsPerPortType.entrySet()) {
       List<EntityConsolidationData> portTemplateConsolidationDataList =
-          getPortConsolidationDataList(portIdsPerPortTypeEntry.getValue(),
-              unifiedCompositionDataList);
+              getPortConsolidationDataList(portIdsPerPortTypeEntry.getValue(),
+                      unifiedCompositionDataList);
       if (CollectionUtils.isEmpty(portTemplateConsolidationDataList)) {
         continue;
       }
 
       handlePortNodeTemplate(serviceTemplate, substitutionServiceTemplate,
-          portTemplateConsolidationDataList, connectedComputeNodeType,
-          unifiedCompositionDataList.get(0).getComputeTemplateConsolidationData(),
-          unifiedCompositionDataList, context);
+              portTemplateConsolidationDataList, connectedComputeNodeType,
+              unifiedCompositionDataList.get(0).getComputeTemplateConsolidationData(),
+              unifiedCompositionDataList, context);
     }
   }
 
   private void handlePortNodeTemplate(
-      ServiceTemplate serviceTemplate,
-      ServiceTemplate substitutionServiceTemplate,
-      List<EntityConsolidationData> portTemplateConsolidationDataList,
-      String connectedComputeNodeType,
-      ComputeTemplateConsolidationData computeTemplateConsolidationData,
-      List<UnifiedCompositionData> unifiedCompositionDataList,
-      TranslationContext context) {
+          ServiceTemplate serviceTemplate,
+          ServiceTemplate substitutionServiceTemplate,
+          List<EntityConsolidationData> portTemplateConsolidationDataList,
+          String connectedComputeNodeType,
+          ComputeTemplateConsolidationData computeTemplateConsolidationData,
+          List<UnifiedCompositionData> unifiedCompositionDataList,
+          TranslationContext context) {
     EntityConsolidationData portTemplateConsolidationData =
-        portTemplateConsolidationDataList.get(0);
+            portTemplateConsolidationDataList.get(0);
     NodeTemplate newPortNodeTemplate = getNodeTemplate(
-        portTemplateConsolidationData.getNodeTemplateId(), serviceTemplate, context).clone();
+            portTemplateConsolidationData.getNodeTemplateId(), serviceTemplate, context).clone();
 
     removeConnectivityOut(portTemplateConsolidationData, newPortNodeTemplate);
     handleProperties(serviceTemplate, newPortNodeTemplate,
-        substitutionServiceTemplate, UnifiedCompositionEntity.PORT,
-        portTemplateConsolidationDataList, computeTemplateConsolidationData,
-        unifiedCompositionDataList, context);
+            substitutionServiceTemplate, UnifiedCompositionEntity.PORT,
+            portTemplateConsolidationDataList, computeTemplateConsolidationData,
+            unifiedCompositionDataList, context);
 
     String newPortNodeTemplateId =
-        getNewPortNodeTemplateId(portTemplateConsolidationData
-                .getNodeTemplateId(), connectedComputeNodeType,
-            computeTemplateConsolidationData);
+            getNewPortNodeTemplateId(portTemplateConsolidationData
+                            .getNodeTemplateId(), connectedComputeNodeType,
+                    computeTemplateConsolidationData);
     //Update requirements for relationships between the consolidation entities
     handleConsolidationEntitiesRequirementConnectivity(newPortNodeTemplate,
-        serviceTemplate, context);
+            serviceTemplate, context);
     DataModelUtil.addNodeTemplate(substitutionServiceTemplate, newPortNodeTemplateId,
-        newPortNodeTemplate);
+            newPortNodeTemplate);
 
     //Add the node template mapping in the context for handling requirement updation
     for (EntityConsolidationData data : portTemplateConsolidationDataList) {
       String newPortTemplateId = getNewPortNodeTemplateId(data.getNodeTemplateId(),
-          connectedComputeNodeType, computeTemplateConsolidationData);
+              connectedComputeNodeType, computeTemplateConsolidationData);
       context.addSubstitutionServiceTemplateUnifiedSubstitutionData(ToscaUtil
-              .getServiceTemplateFileName(serviceTemplate), data.getNodeTemplateId(),
-          newPortTemplateId);
+                      .getServiceTemplateFileName(serviceTemplate), data.getNodeTemplateId(),
+              newPortTemplateId);
     }
 
   }
@@ -1798,9 +1798,9 @@ public class UnifiedCompositionService {
   private void handleSingleSubInterfaces(UnifiedCompositionTo unifiedCompositionTo) {
     UnifiedCompositionData unifiedCompositionData = unifiedCompositionTo.getUnifiedCompositionDataList().get(0);
     List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
-        getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
+            getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
     for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData :
-        subInterfaceTemplateConsolidationDataList) {
+            subInterfaceTemplateConsolidationDataList) {
       List<SubInterfaceTemplateConsolidationData> subInterfaceDataList = new ArrayList<>();
       subInterfaceDataList.add(subInterfaceTemplateConsolidationData);
       createSubInterfaceSubstitutionNodeTemplate(unifiedCompositionTo, subInterfaceDataList);
@@ -1809,30 +1809,30 @@ public class UnifiedCompositionService {
 
   private void handleConsolidationSubInterfaces(UnifiedCompositionTo unifiedCompositionTo) {
     Collection<ComputeTemplateConsolidationData> computeConsolidationDataList =
-        (Collection) getComputeConsolidationDataList(unifiedCompositionTo.getUnifiedCompositionDataList());
+            (Collection) getComputeConsolidationDataList(unifiedCompositionTo.getUnifiedCompositionDataList());
 
     Map<String, List<String>> portIdsPerPortType = UnifiedCompositionUtil
-        .collectAllPortsFromEachTypesFromComputes(computeConsolidationDataList);
+            .collectAllPortsFromEachTypesFromComputes(computeConsolidationDataList);
 
     for (Map.Entry<String, List<String>> portIdsPerPortTypeEntry : portIdsPerPortType.entrySet()) {
       List<EntityConsolidationData> portEntityConsolidationDataList =
-          getPortConsolidationDataList(portIdsPerPortTypeEntry.getValue(),
-              unifiedCompositionTo.getUnifiedCompositionDataList());
+              getPortConsolidationDataList(portIdsPerPortTypeEntry.getValue(),
+                      unifiedCompositionTo.getUnifiedCompositionDataList());
       if (CollectionUtils.isEmpty(portEntityConsolidationDataList)) {
         continue;
       }
 
       List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
-      portEntityConsolidationDataList.stream()
-          .map(data -> (PortTemplateConsolidationData) data)
-          .collect(Collectors.toList());
+              portEntityConsolidationDataList.stream()
+                      .map(data -> (PortTemplateConsolidationData) data)
+                      .collect(Collectors.toList());
 
       ListMultimap<String, SubInterfaceTemplateConsolidationData> subInterfacesByType = UnifiedCompositionUtil
-          .collectAllSubInterfacesOfEachTypesFromPorts(portTemplateConsolidationDataList);
+              .collectAllSubInterfacesOfEachTypesFromPorts(portTemplateConsolidationDataList);
       Set<String> subInterfaceTypes = subInterfacesByType.keySet();
       for (String subInterfaceType: subInterfaceTypes) {
         List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
-            subInterfacesByType.get(subInterfaceType);
+                subInterfacesByType.get(subInterfaceType);
         createSubInterfaceSubstitutionNodeTemplate(unifiedCompositionTo, subInterfaceTemplateConsolidationDataList);
       }
     }
@@ -1840,45 +1840,45 @@ public class UnifiedCompositionService {
 
   private void createSubInterfaceSubstitutionNodeTemplate(UnifiedCompositionTo unifiedCompositionTo,
                                                           List<SubInterfaceTemplateConsolidationData>
-                                                              subInterfaceTemplateConsolidationDataList) {
+                                                                  subInterfaceTemplateConsolidationDataList) {
     SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData =
-        subInterfaceTemplateConsolidationDataList.get(0);
+            subInterfaceTemplateConsolidationDataList.get(0);
     PortTemplateConsolidationData portTemplateConsolidationData =
-        getSubInterfacePortTemplateConsolidationData(unifiedCompositionTo.getServiceTemplate(),
-            subInterfaceTemplateConsolidationData, unifiedCompositionTo.getContext());
+            getSubInterfacePortTemplateConsolidationData(unifiedCompositionTo.getServiceTemplate(),
+                    subInterfaceTemplateConsolidationData, unifiedCompositionTo.getContext());
 
     if (Objects.isNull(portTemplateConsolidationData)) {
       return;
     }
 
     String originalSubInterfaceNodeTemplateId = subInterfaceTemplateConsolidationDataList.get(0)
-        .getNodeTemplateId();
+            .getNodeTemplateId();
     NodeTemplate originalSubInterfaceNodeTemplate =
-        DataModelUtil.getNodeTemplate(unifiedCompositionTo.getServiceTemplate(), originalSubInterfaceNodeTemplateId);
+            DataModelUtil.getNodeTemplate(unifiedCompositionTo.getServiceTemplate(), originalSubInterfaceNodeTemplateId);
     if (Objects.isNull(originalSubInterfaceNodeTemplate)) {
       return;
     }
     NodeTemplate newSubInterfaceNodeTemplate = originalSubInterfaceNodeTemplate.clone();
     ComputeTemplateConsolidationData connectedComputeConsolidationData =
-        getConnectedComputeConsolidationData(unifiedCompositionTo.getUnifiedCompositionDataList(),
-            portTemplateConsolidationData.getNodeTemplateId());
+            getConnectedComputeConsolidationData(unifiedCompositionTo.getUnifiedCompositionDataList(),
+                    portTemplateConsolidationData.getNodeTemplateId());
     if (Objects.nonNull(connectedComputeConsolidationData)) {
       NodeTemplate connectedComputeNodeTemplate = DataModelUtil.getNodeTemplate(unifiedCompositionTo
               .getServiceTemplate(), connectedComputeConsolidationData.getNodeTemplateId());
       String newSubInterfaceNodeTemplateId = getNewSubInterfaceNodeTemplateId(unifiedCompositionTo
-              .getServiceTemplate(), connectedComputeNodeTemplate.getType(), connectedComputeConsolidationData,
-          subInterfaceTemplateConsolidationData, unifiedCompositionTo.getContext());
+                      .getServiceTemplate(), connectedComputeNodeTemplate.getType(), connectedComputeConsolidationData,
+              subInterfaceTemplateConsolidationData, unifiedCompositionTo.getContext());
       DataModelUtil.addNodeTemplate(unifiedCompositionTo.getSubstitutionServiceTemplate(),
-          newSubInterfaceNodeTemplateId, newSubInterfaceNodeTemplate);
+              newSubInterfaceNodeTemplateId, newSubInterfaceNodeTemplate);
       List<EntityConsolidationData> entityConsolidationDataList =
-          new ArrayList<>(subInterfaceTemplateConsolidationDataList);
+              new ArrayList<>(subInterfaceTemplateConsolidationDataList);
       //Remove all the existing properties as we are going to create new based on the
       // naming convention for the substitution
       handleSubInterfaceProperties(unifiedCompositionTo, newSubInterfaceNodeTemplate, entityConsolidationDataList,
-          portTemplateConsolidationData);
+              portTemplateConsolidationData);
       //Update requirements for relationships between the consolidation entities
       handleConsolidationEntitiesRequirementConnectivity(newSubInterfaceNodeTemplate, unifiedCompositionTo
-          .getServiceTemplate(), unifiedCompositionTo.getContext());
+              .getServiceTemplate(), unifiedCompositionTo.getContext());
       removeConnectivityOut(subInterfaceTemplateConsolidationData,newSubInterfaceNodeTemplate);
     }
   }
@@ -1886,9 +1886,9 @@ public class UnifiedCompositionService {
   private void handleSubInterfaceProperties(UnifiedCompositionTo unifiedCompositionTo,
                                             NodeTemplate newSubInterfaceNodeTemplate,
                                             List<EntityConsolidationData>
-                                                entityConsolidationDataList,
+                                                    entityConsolidationDataList,
                                             PortTemplateConsolidationData
-                                                portTemplateConsolidationData) {
+                                                    portTemplateConsolidationData) {
     UnifiedCompositionData unifiedCompositionData = unifiedCompositionTo.getUnifiedCompositionDataList().get(0);
     ServiceTemplate serviceTemplate = unifiedCompositionTo.getServiceTemplate();
     TranslationContext context = unifiedCompositionTo.getContext();
@@ -1896,42 +1896,42 @@ public class UnifiedCompositionService {
     for (EntityConsolidationData entityConsolidationData : entityConsolidationDataList) {
       String nodeTemplateId = entityConsolidationData.getNodeTemplateId();
       Optional<List<String>> indexVarProperties =
-          context.getIndexVarProperties(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
-              nodeTemplateId);
+              context.getIndexVarProperties(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
+                      nodeTemplateId);
       Map<String, Object> properties =
-          DataModelUtil.getNodeTemplateProperties(serviceTemplate, nodeTemplateId);
+              DataModelUtil.getNodeTemplateProperties(serviceTemplate, nodeTemplateId);
       if (MapUtils.isEmpty(properties)) {
         continue;
       }
 
       for (Map.Entry<String, Object> propertyEntry : properties.entrySet()) {
         NodeType nodeTypeWithFlatHierarchy =
-            HeatToToscaUtil.getNodeTypeWithFlatHierarchy(newSubInterfaceNodeTemplate.getType(),
-                serviceTemplate, context);
+                HeatToToscaUtil.getNodeTypeWithFlatHierarchy(newSubInterfaceNodeTemplate.getType(),
+                        serviceTemplate, context);
         PropertyDefinition propertyDefinition =
-            nodeTypeWithFlatHierarchy.getProperties().get(propertyEntry.getKey());
+                nodeTypeWithFlatHierarchy.getProperties().get(propertyEntry.getKey());
         String propertyType = propertyDefinition.getType();
         //Handle service_template_filter property for subinterface as we should not create inputs
         // for this property
         if (propertyEntry.getKey().equals(ToscaConstants.SERVICE_TEMPLATE_FILTER_PROPERTY_NAME)) {
           handleSubInterfaceServiceTemplateFilterProperty(newSubInterfaceNodeTemplate,
-              propertyEntry.getKey(), propertyEntry.getValue(), serviceTemplate,
-              unifiedCompositionTo.getSubstitutionServiceTemplate());
+                  propertyEntry.getKey(), propertyEntry.getValue(), serviceTemplate,
+                  unifiedCompositionTo.getSubstitutionServiceTemplate());
         } else if (indexVarProperties.isPresent()
-            && indexVarProperties.get().contains(propertyEntry.getKey())) {
+                && indexVarProperties.get().contains(propertyEntry.getKey())) {
           //Handle index property
           handleIndexVarProperty(propertyEntry.getKey(), propertyEntry.getValue(),
-              newSubInterfaceNodeTemplate);
+                  newSubInterfaceNodeTemplate);
         } else {
           Optional<String> parameterId =
-              updateProperty(serviceTemplate, nodeTemplateId, newSubInterfaceNodeTemplate,
-                  propertyEntry, UnifiedCompositionEntity.SUB_INTERFACE, unifiedCompositionData
-                      .getComputeTemplateConsolidationData(), portTemplateConsolidationData,
-                  unifiedCompositionTo.getUnifiedCompositionDataList(), context);
+                  updateProperty(serviceTemplate, nodeTemplateId, newSubInterfaceNodeTemplate,
+                          propertyEntry, UnifiedCompositionEntity.SUB_INTERFACE, unifiedCompositionData
+                                  .getComputeTemplateConsolidationData(), portTemplateConsolidationData,
+                          unifiedCompositionTo.getUnifiedCompositionDataList(), context);
           parameterId.ifPresent(
-              parameterIdValue -> addPropertyInputParameter(propertyType,
-                  unifiedCompositionTo.getSubstitutionServiceTemplate(),
-                  propertyDefinition.getEntry_schema(), parameterIdValue));
+                  parameterIdValue -> addPropertyInputParameter(propertyType,
+                          unifiedCompositionTo.getSubstitutionServiceTemplate(),
+                          propertyDefinition.getEntry_schema(), parameterIdValue));
         }
       }
     }
@@ -1944,8 +1944,8 @@ public class UnifiedCompositionService {
 
     if (Objects.isNull(nodeTemplate)) {
       nodeTemplate = context
-          .getCleanedNodeTemplate(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
-              nodeTemplateId);
+              .getCleanedNodeTemplate(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
+                      nodeTemplateId);
 
     }
     return nodeTemplate;
@@ -1957,24 +1957,24 @@ public class UnifiedCompositionService {
                                List<UnifiedCompositionData> unifiedCompositionDataList,
                                TranslationContext context) {
     ComputeTemplateConsolidationData computeTemplateConsolidationData =
-        unifiedCompositionDataList.get(0).getComputeTemplateConsolidationData();
+            unifiedCompositionDataList.get(0).getComputeTemplateConsolidationData();
     handleComputeNodeTemplate(serviceTemplate, substitutionServiceTemplate,
-        unifiedCompositionDataList, context);
+            unifiedCompositionDataList, context);
     return handleComputeNodeType(serviceTemplate, substitutionServiceTemplate,
-        computeTemplateConsolidationData);
+            computeTemplateConsolidationData);
   }
 
   private String handleComputeNodeType(
-      ServiceTemplate serviceTemplate,
-      ServiceTemplate substitutionServiceTemplate,
-      ComputeTemplateConsolidationData computeTemplateConsolidationData) {
+          ServiceTemplate serviceTemplate,
+          ServiceTemplate substitutionServiceTemplate,
+          ComputeTemplateConsolidationData computeTemplateConsolidationData) {
     NodeTemplate computeNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
-        computeTemplateConsolidationData.getNodeTemplateId());
+            computeTemplateConsolidationData.getNodeTemplateId());
     String computeNodeTypeId = computeNodeTemplate.getType();
     NodeType computeNodeType =
-        DataModelUtil.getNodeType(serviceTemplate, computeNodeTypeId);
+            DataModelUtil.getNodeType(serviceTemplate, computeNodeTypeId);
     DataModelUtil
-        .addNodeType(substitutionServiceTemplate, computeNodeTypeId, computeNodeType);
+            .addNodeType(substitutionServiceTemplate, computeNodeTypeId, computeNodeType);
 
     return computeNodeTypeId;
   }
@@ -1984,45 +1984,45 @@ public class UnifiedCompositionService {
                                          List<UnifiedCompositionData> unifiedCompositionDataList,
                                          TranslationContext context) {
     ComputeTemplateConsolidationData computeTemplateConsolidationData =
-        unifiedCompositionDataList.get(0).getComputeTemplateConsolidationData();
+            unifiedCompositionDataList.get(0).getComputeTemplateConsolidationData();
     NodeTemplate newComputeNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
-        computeTemplateConsolidationData.getNodeTemplateId()).clone();
+            computeTemplateConsolidationData.getNodeTemplateId()).clone();
 
     removeConnectivityOut(computeTemplateConsolidationData, newComputeNodeTemplate);
     removeVolumeConnectivity(computeTemplateConsolidationData, newComputeNodeTemplate);
 
     List<EntityConsolidationData> computeConsolidationDataList =
-        getComputeConsolidationDataList(unifiedCompositionDataList);
+            getComputeConsolidationDataList(unifiedCompositionDataList);
 
     handleProperties(serviceTemplate, newComputeNodeTemplate,
-        substitutionServiceTemplate, COMPUTE,
-        computeConsolidationDataList, computeTemplateConsolidationData, unifiedCompositionDataList,
-        context);
+            substitutionServiceTemplate, COMPUTE,
+            computeConsolidationDataList, computeTemplateConsolidationData, unifiedCompositionDataList,
+            context);
 
     String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
-        computeTemplateConsolidationData.getNodeTemplateId());
+            computeTemplateConsolidationData.getNodeTemplateId());
     //Update requirements for relationships between the consolidation entities
     handleConsolidationEntitiesRequirementConnectivity(
-        newComputeNodeTemplate,
-        serviceTemplate, context);
+            newComputeNodeTemplate,
+            serviceTemplate, context);
     DataModelUtil
-        .addNodeTemplate(substitutionServiceTemplate,
-            newComputeNodeTemplateId, newComputeNodeTemplate);
+            .addNodeTemplate(substitutionServiceTemplate,
+                    newComputeNodeTemplateId, newComputeNodeTemplate);
     //Add the node template mapping in the context for handling requirement updation
     for (EntityConsolidationData data : computeConsolidationDataList) {
       String newComputeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
-          computeTemplateConsolidationData.getNodeTemplateId());
+              computeTemplateConsolidationData.getNodeTemplateId());
       context.addSubstitutionServiceTemplateUnifiedSubstitutionData(ToscaUtil
-              .getServiceTemplateFileName(serviceTemplate), data.getNodeTemplateId(),
-          newComputeTemplateId);
+                      .getServiceTemplateFileName(serviceTemplate), data.getNodeTemplateId(),
+              newComputeTemplateId);
     }
   }
 
   private List<EntityConsolidationData> getComputeConsolidationDataList(
-      List<UnifiedCompositionData> unifiedCompositionDataList) {
+          List<UnifiedCompositionData> unifiedCompositionDataList) {
     return unifiedCompositionDataList.stream()
-        .map(UnifiedCompositionData::getComputeTemplateConsolidationData)
-        .collect(Collectors.toList());
+            .map(UnifiedCompositionData::getComputeTemplateConsolidationData)
+            .collect(Collectors.toList());
   }
 
 
@@ -2036,12 +2036,12 @@ public class UnifiedCompositionService {
                                 TranslationContext context) {
     nodeTemplate.setProperties(new HashedMap());
     handleNodeTemplateProperties(serviceTemplate, nodeTemplate, substitutionServiceTemplate,
-        unifiedCompositionEntity, entityConsolidationDataList, computeTemplateConsolidationData,
-        unifiedCompositionDataList, context);
+            unifiedCompositionEntity, entityConsolidationDataList, computeTemplateConsolidationData,
+            unifiedCompositionDataList, context);
     //Add enrich properties from openecomp node type as input to global and substitution ST
     handleNodeTypeProperties(substitutionServiceTemplate,
-        entityConsolidationDataList, nodeTemplate, unifiedCompositionEntity,
-        computeTemplateConsolidationData, context);
+            entityConsolidationDataList, nodeTemplate, unifiedCompositionEntity,
+            computeTemplateConsolidationData, context);
 
   }
 
@@ -2050,57 +2050,57 @@ public class UnifiedCompositionService {
                                             ServiceTemplate substitutionServiceTemplate,
                                             UnifiedCompositionEntity unifiedCompositionEntity,
                                             List<EntityConsolidationData>
-                                                entityConsolidationDataList,
+                                                    entityConsolidationDataList,
                                             ComputeTemplateConsolidationData
-                                                computeTemplateConsolidationData,
+                                                    computeTemplateConsolidationData,
                                             List<UnifiedCompositionData> unifiedCompositionDataList,
                                             TranslationContext context) {
     List<String> propertiesWithIdenticalVal =
-        consolidationService.getPropertiesWithIdenticalVal(unifiedCompositionEntity);
+            consolidationService.getPropertiesWithIdenticalVal(unifiedCompositionEntity);
 
     for (EntityConsolidationData entityConsolidationData : entityConsolidationDataList) {
       String nodeTemplateId = entityConsolidationData.getNodeTemplateId();
       Optional<List<String>> indexVarProperties =
-          context.getIndexVarProperties(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
-              nodeTemplateId);
+              context.getIndexVarProperties(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
+                      nodeTemplateId);
       Map<String, Object> properties =
-          DataModelUtil.getNodeTemplateProperties(serviceTemplate, nodeTemplateId);
+              DataModelUtil.getNodeTemplateProperties(serviceTemplate, nodeTemplateId);
       if (MapUtils.isEmpty(properties)) {
         continue;
       }
 
       for (Map.Entry<String, Object> propertyEntry : properties.entrySet()) {
         NodeType nodeTypeWithFlatHierarchy =
-            HeatToToscaUtil.getNodeTypeWithFlatHierarchy(nodeTemplate.getType(), serviceTemplate,
-                context);
+                HeatToToscaUtil.getNodeTypeWithFlatHierarchy(nodeTemplate.getType(), serviceTemplate,
+                        context);
         PropertyDefinition propertyDefinition =
-            nodeTypeWithFlatHierarchy.getProperties().get(propertyEntry.getKey());
+                nodeTypeWithFlatHierarchy.getProperties().get(propertyEntry.getKey());
         String propertyType = propertyDefinition.getType();
 
         if (propertiesWithIdenticalVal.contains(propertyEntry.getKey())) {
           String parameterId =
-              updateIdenticalProperty(nodeTemplateId, propertyEntry.getKey(), nodeTemplate,
-                  unifiedCompositionEntity, unifiedCompositionDataList);
+                  updateIdenticalProperty(nodeTemplateId, propertyEntry.getKey(), nodeTemplate,
+                          unifiedCompositionEntity, unifiedCompositionDataList);
 
           addInputParameter(
-              parameterId, propertyType,
-              propertyType.equals(PropertyType.LIST.getDisplayName()) ? propertyDefinition
-                  .getEntry_schema() : null,
-              substitutionServiceTemplate);
+                  parameterId, propertyType,
+                  propertyType.equals(PropertyType.LIST.getDisplayName()) ? propertyDefinition
+                          .getEntry_schema() : null,
+                  substitutionServiceTemplate);
         } else if (indexVarProperties.isPresent()
-            && indexVarProperties.get().contains(propertyEntry.getKey())) {
+                && indexVarProperties.get().contains(propertyEntry.getKey())) {
           //Handle index property
           handleIndexVarProperty(propertyEntry.getKey(), propertyEntry.getValue(), nodeTemplate);
         } else {
           Optional<String> parameterId =
-              updateProperty(serviceTemplate, nodeTemplateId, nodeTemplate, propertyEntry,
-                  unifiedCompositionEntity, computeTemplateConsolidationData, null,
-                  unifiedCompositionDataList,
-                  context);
+                  updateProperty(serviceTemplate, nodeTemplateId, nodeTemplate, propertyEntry,
+                          unifiedCompositionEntity, computeTemplateConsolidationData, null,
+                          unifiedCompositionDataList,
+                          context);
           parameterId.ifPresent(
-              parameterIdValue -> addPropertyInputParameter(propertyType,
-                  substitutionServiceTemplate,
-                  propertyDefinition.getEntry_schema(), parameterIdValue));
+                  parameterIdValue -> addPropertyInputParameter(propertyType,
+                          substitutionServiceTemplate,
+                          propertyDefinition.getEntry_schema(), parameterIdValue));
         }
       }
     }
@@ -2113,19 +2113,19 @@ public class UnifiedCompositionService {
   }
 
   private void handleSubInterfaceServiceTemplateFilterProperty(NodeTemplate nodeTemplate,
-                                                   String propertyKey,
-                                                   Object propertyValue,
-                                                   ServiceTemplate serviceTemplate,
-                                                   ServiceTemplate substitutionServiceTemplate) {
+                                                               String propertyKey,
+                                                               Object propertyValue,
+                                                               ServiceTemplate serviceTemplate,
+                                                               ServiceTemplate substitutionServiceTemplate) {
     //Retain service_template_filter (Can be present in a sub-interface resource-def)
     nodeTemplate.getProperties().put(propertyKey, propertyValue);
     Object serviceTemplateFilterProperty =
-        nodeTemplate.getProperties().get(ToscaConstants.SERVICE_TEMPLATE_FILTER_PROPERTY_NAME);
+            nodeTemplate.getProperties().get(ToscaConstants.SERVICE_TEMPLATE_FILTER_PROPERTY_NAME);
     if (!(serviceTemplateFilterProperty instanceof Map)) {
       return;
     }
     Map<String, Object> serviceTemplatePropertyMap = (Map<String, Object>)
-        serviceTemplateFilterProperty;
+            serviceTemplateFilterProperty;
     Object countPropertyVal = serviceTemplatePropertyMap.get(ToscaConstants.COUNT_PROPERTY_NAME);
     //Check if the value of the count property is a tosca function
     if (!isPropertyContainsToscaFunction(countPropertyVal)) {
@@ -2136,15 +2136,15 @@ public class UnifiedCompositionService {
     // template
     if (countPropertyValMap.keySet().contains(ToscaFunctions.GET_INPUT.getDisplayName())) {
       String countPropertyInputName = countPropertyValMap.get(ToscaFunctions.GET_INPUT
-          .getDisplayName()).toString();
+              .getDisplayName()).toString();
       //Get the input parameter definition from top level where the resource group was present
       ParameterDefinitionExt parameterDefinition = (ParameterDefinitionExt)
-          DataModelUtil.getInputParameters(serviceTemplate).get(countPropertyInputName);
+              DataModelUtil.getInputParameters(serviceTemplate).get(countPropertyInputName);
       if (Objects.nonNull(parameterDefinition)) {
         //Remove annotations if any for the nested service template
         parameterDefinition.setAnnotations(null);
         DataModelUtil.getInputParameters(substitutionServiceTemplate)
-            .put(countPropertyInputName, parameterDefinition);
+                .put(countPropertyInputName, parameterDefinition);
         if (Objects.nonNull(countPropertyInputName)) {
           //Remove the input from top level
           DataModelUtil.getInputParameters(serviceTemplate).remove(countPropertyInputName);
@@ -2158,7 +2158,7 @@ public class UnifiedCompositionService {
                                         NodeTemplate nodeTemplate,
                                         UnifiedCompositionEntity compositionEntity,
                                         ComputeTemplateConsolidationData
-                                            computeTemplateConsolidationData,
+                                                computeTemplateConsolidationData,
                                         TranslationContext context) {
     ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
     Optional<NodeType> enrichNodeType;
@@ -2166,8 +2166,8 @@ public class UnifiedCompositionService {
 
     if (compositionEntity.equals(UnifiedCompositionEntity.PORT)) {
       enrichNodeType =
-          toscaAnalyzerService.fetchNodeType(ToscaNodeType.NETWORK_PORT,
-              context.getGlobalServiceTemplates().values());
+              toscaAnalyzerService.fetchNodeType(ToscaNodeType.NETWORK_PORT,
+                      context.getGlobalServiceTemplates().values());
       enrichProperties = TranslationContext.getEnrichPortResourceProperties();
       if (!enrichNodeType.isPresent() || Objects.isNull(enrichProperties)) {
         return;
@@ -2181,9 +2181,9 @@ public class UnifiedCompositionService {
     if (Objects.nonNull(enrichNodeTypeProperties)) {
       for (String enrichPropertyName : enrichProperties) {
         handleEntityConsolidationDataNodeTypeProperties(
-            enrichPropertyName, substitutionServiceTemplate,
-            enrichNodeType.get(), nodeTemplate, compositionEntity, computeTemplateConsolidationData,
-            entityConsolidationDataList, nodeTemplateProperties, context);
+                enrichPropertyName, substitutionServiceTemplate,
+                enrichNodeType.get(), nodeTemplate, compositionEntity, computeTemplateConsolidationData,
+                entityConsolidationDataList, nodeTemplateProperties, context);
       }
     }
   }
@@ -2204,14 +2204,14 @@ public class UnifiedCompositionService {
       String nodeTemplateId = entityConsolidationData.getNodeTemplateId();
 
       String inputParamId =
-          getParameterId(nodeTemplateId, nodeTemplate, enrichPropertyName,
-              compositionEntity, computeTemplateConsolidationData, null);
+              getParameterId(nodeTemplateId, nodeTemplate, enrichPropertyName,
+                      compositionEntity, computeTemplateConsolidationData, null);
       Map<String, String> propertyValMap = new HashMap<>();
 
       context
-          .addNewPropertyIdToNodeTemplate(
-              ToscaUtil.getServiceTemplateFileName(substitutionServiceTemplate),
-              inputParamId, nodeTemplateProperties.get(enrichPropertyName));
+              .addNewPropertyIdToNodeTemplate(
+                      ToscaUtil.getServiceTemplateFileName(substitutionServiceTemplate),
+                      inputParamId, nodeTemplateProperties.get(enrichPropertyName));
 
       if (nodeTemplateProperties.containsKey(enrichPropertyName)) {
         handleExistingEnrichedProperty(enrichPropertyName, nodeTemplateProperties, inputParamId);
@@ -2220,11 +2220,11 @@ public class UnifiedCompositionService {
         nodeTemplate.getProperties().put(enrichPropertyName, propertyValMap);
       }
       propertyType =
-          enrichNodeType.getProperties().get(enrichPropertyName).getType();
+              enrichNodeType.getProperties().get(enrichPropertyName).getType();
 
       addPropertyInputParameter(propertyType, substitutionServiceTemplate, enrichNodeType
-              .getProperties().get(enrichPropertyName).getEntry_schema(),
-          inputParamId);
+                      .getProperties().get(enrichPropertyName).getEntry_schema(),
+              inputParamId);
 
     }
   }
@@ -2261,23 +2261,23 @@ public class UnifiedCompositionService {
     }
     if (isParameterBelongsToEnrichedPortProperties(parameterId)) {
       addInputParameter(parameterId,
-          propertyType,
-          propertyType.equals(PropertyType.LIST.getDisplayName()) ? entrySchema : null,
-          substitutionServiceTemplate);
+              propertyType,
+              propertyType.equals(PropertyType.LIST.getDisplayName()) ? entrySchema : null,
+              substitutionServiceTemplate);
     } else if (isPropertySimpleType(propertyType)) {
       addInputParameter(parameterId, PropertyType.LIST.getDisplayName(),
-          DataModelUtil.createEntrySchema(propertyType.toLowerCase(), null, null),
-          substitutionServiceTemplate);
+              DataModelUtil.createEntrySchema(propertyType.toLowerCase(), null, null),
+              substitutionServiceTemplate);
 
     } else if (propertyType.equals(PropertyTypeExt.JSON.getDisplayName()) ||
-        (Objects.nonNull(entrySchema) && isPropertySimpleType(entrySchema.getType()))) {
+            (Objects.nonNull(entrySchema) && isPropertySimpleType(entrySchema.getType()))) {
       addInputParameter(parameterId, PropertyType.LIST.getDisplayName(),
-          DataModelUtil.createEntrySchema(PropertyTypeExt.JSON.getDisplayName(), null, null),
-          substitutionServiceTemplate);
+              DataModelUtil.createEntrySchema(PropertyTypeExt.JSON.getDisplayName(), null, null),
+              substitutionServiceTemplate);
     } else {
       addInputParameter(parameterId, analyzeParameterType(propertyType), DataModelUtil
-              .createEntrySchema(analyzeEntrySchemaType(propertyType, entrySchema), null, null),
-          substitutionServiceTemplate);
+                      .createEntrySchema(analyzeEntrySchemaType(propertyType, entrySchema), null, null),
+              substitutionServiceTemplate);
     }
   }
 
@@ -2295,24 +2295,24 @@ public class UnifiedCompositionService {
 
   private boolean isPropertySimpleType(String propertyType) {
     return !Objects.isNull(propertyType)
-        && (PropertyType.getSimplePropertyTypes().contains(propertyType.toLowerCase()));
+            && (PropertyType.getSimplePropertyTypes().contains(propertyType.toLowerCase()));
   }
 
   private String analyzeParameterType(String propertyType) {
     return propertyType.equalsIgnoreCase(PropertyType.LIST.getDisplayName()) ? PropertyType.LIST
-        .getDisplayName() : propertyType;
+            .getDisplayName() : propertyType;
   }
 
   private String analyzeEntrySchemaType(String propertyType, EntrySchema entrySchema) {
     return propertyType.equalsIgnoreCase(PropertyType.LIST.getDisplayName()) && entrySchema != null ?
-        entrySchema.getType() : null;
+            entrySchema.getType() : null;
   }
 
   private void handleConsolidationEntitiesRequirementConnectivity(NodeTemplate nodeTemplate,
                                                                   ServiceTemplate serviceTemplate,
                                                                   TranslationContext context) {
     List<Map<String, RequirementAssignment>> nodeTemplateRequirements = DataModelUtil
-        .getNodeTemplateRequirementList(nodeTemplate);
+            .getNodeTemplateRequirementList(nodeTemplate);
     if (CollectionUtils.isEmpty(nodeTemplateRequirements)) {
       return;
     }
@@ -2322,8 +2322,8 @@ public class UnifiedCompositionService {
         RequirementAssignment requirementAssignment = entry.getValue();
         String requirementNode = requirementAssignment.getNode();
         String unifiedNodeTemplateId =
-            context.getUnifiedSubstitutionNodeTemplateId(serviceTemplate,
-                requirementNode);
+                context.getUnifiedSubstitutionNodeTemplateId(serviceTemplate,
+                        requirementNode);
         if (unifiedNodeTemplateId != null) {
           //Update the node id in the requirement
           requirementAssignment.setNode(unifiedNodeTemplateId);
@@ -2343,14 +2343,14 @@ public class UnifiedCompositionService {
                                                 String relationshipId,
                                                 TranslationContext context) {
     Map<String, RelationshipTemplate> relationshipTemplates = DataModelUtil
-        .getRelationshipTemplates(serviceTemplate);
+            .getRelationshipTemplates(serviceTemplate);
     if (relationshipTemplates != null) {
       RelationshipTemplate relationshipTemplate = relationshipTemplates.get(relationshipId);
       if (relationshipTemplate != null) {
         String relationshipTemplateType = relationshipTemplate.getType();
         if (relationshipTemplateType.equals(ToscaRelationshipType.CINDER_VOLUME_ATTACHES_TO)) {
           handleCinderVolumeAttachmentRelationshipTemplate(serviceTemplate,
-              relationshipTemplate, context);
+                  relationshipTemplate, context);
         }
       }
     }
@@ -2358,14 +2358,14 @@ public class UnifiedCompositionService {
 
 
   private void handleCinderVolumeAttachmentRelationshipTemplate(ServiceTemplate
-                                                                    substitutionServiceTemplate,
+                                                                        substitutionServiceTemplate,
                                                                 RelationshipTemplate
-                                                                    relationshipTemplate,
+                                                                        relationshipTemplate,
                                                                 TranslationContext context) {
     Map<String, Object> properties = relationshipTemplate.getProperties();
     properties.computeIfPresent(HeatConstants.INSTANCE_UUID_PROPERTY_NAME, (key, value) ->
-        context.getUnifiedAbstractNodeTemplateId(substitutionServiceTemplate,
-            (String) value));
+            context.getUnifiedAbstractNodeTemplateId(substitutionServiceTemplate,
+                    (String) value));
   }
 
   private String updateIdenticalProperty(String nodeTemplateId, String propertyId,
@@ -2379,14 +2379,14 @@ public class UnifiedCompositionService {
     switch (unifiedCompositionEntity) {
       case COMPUTE:
         inputParamId = COMPUTE_IDENTICAL_VALUE_PROPERTY_PREFIX + propertyId
-            + COMPUTE_IDENTICAL_VALUE_PROPERTY_SUFFIX;
+                + COMPUTE_IDENTICAL_VALUE_PROPERTY_SUFFIX;
         propertyVal.put(ToscaFunctions.GET_INPUT.getDisplayName(), inputParamId);
         nodeTemplate.getProperties().put(propertyId, propertyVal);
         break;
       case PORT:
         String portType = ConsolidationDataUtil.getPortType(nodeTemplateId);
         ComputeTemplateConsolidationData computeTemplateConsolidationData =
-            getConnectedComputeConsolidationData(unifiedCompositionDataList, nodeTemplateId);
+                getConnectedComputeConsolidationData(unifiedCompositionDataList, nodeTemplateId);
         inputParamId = getInputParamIdForPort(nodeTemplateId, propertyId, portType, computeTemplateConsolidationData);
         propertyVal.put(ToscaFunctions.GET_INPUT.getDisplayName(), inputParamId);
         nodeTemplate.getProperties().put(propertyId, propertyVal);
@@ -2401,15 +2401,15 @@ public class UnifiedCompositionService {
                                         ComputeTemplateConsolidationData computeTemplateConsolidationData) {
     String inputParamId;
     if (Objects.isNull(computeTemplateConsolidationData)
-        || computeTemplateConsolidationData.getPorts().get(portType).size() > 1) {
+            || computeTemplateConsolidationData.getPorts().get(portType).size() > 1) {
       inputParamId =
-          UnifiedCompositionEntity.PORT.getDisplayName().toLowerCase() + "_" + nodeTemplateId + "_" +
-              propertyId;
+              UnifiedCompositionEntity.PORT.getDisplayName().toLowerCase() + "_" + nodeTemplateId + "_" +
+                      propertyId;
 
     } else {
       inputParamId =
-          UnifiedCompositionEntity.PORT.getDisplayName().toLowerCase() + "_" + portType + "_"
-              + propertyId;
+              UnifiedCompositionEntity.PORT.getDisplayName().toLowerCase() + "_" + portType + "_"
+                      + propertyId;
     }
     return inputParamId;
   }
@@ -2420,35 +2420,35 @@ public class UnifiedCompositionService {
                                  ServiceTemplate serviceTemplate) {
 
     ParameterDefinition parameterDefinition = DataModelUtil.createParameterDefinition
-        (parameterType, null, null,
-            true, null, null,
-            entrySchema, null);
+            (parameterType, null, null,
+                    true, null, null,
+                    entrySchema, null);
 
 
     DataModelUtil
-        .addInputParameterToTopologyTemplate(serviceTemplate, parameterId, parameterDefinition);
+            .addInputParameterToTopologyTemplate(serviceTemplate, parameterId, parameterDefinition);
   }
 
   // Return the input parameter Id which is used in the new property value if there is one
   private Optional<String> updateProperty(
-      ServiceTemplate serviceTemplate,
-      String nodeTemplateId, NodeTemplate nodeTemplate,
-      Map.Entry<String, Object> propertyEntry,
-      UnifiedCompositionEntity compositionEntity,
-      ComputeTemplateConsolidationData computeTemplateConsolidationData,
-      PortTemplateConsolidationData portTemplateConsolidationData,
-      List<UnifiedCompositionData> unifiedCompositionDataList,
-      TranslationContext context) {
+          ServiceTemplate serviceTemplate,
+          String nodeTemplateId, NodeTemplate nodeTemplate,
+          Map.Entry<String, Object> propertyEntry,
+          UnifiedCompositionEntity compositionEntity,
+          ComputeTemplateConsolidationData computeTemplateConsolidationData,
+          PortTemplateConsolidationData portTemplateConsolidationData,
+          List<UnifiedCompositionData> unifiedCompositionDataList,
+          TranslationContext context) {
 
     if (handleGetAttrFromConsolidationNodes(serviceTemplate, nodeTemplateId, nodeTemplate,
-        propertyEntry, unifiedCompositionDataList, context)) {
+            propertyEntry, unifiedCompositionDataList, context)) {
       return Optional.empty();
     }
 
 
     String inputParamId =
-        getParameterId(nodeTemplateId, nodeTemplate, propertyEntry.getKey(), compositionEntity,
-            computeTemplateConsolidationData, portTemplateConsolidationData);
+            getParameterId(nodeTemplateId, nodeTemplate, propertyEntry.getKey(), compositionEntity,
+                    computeTemplateConsolidationData, portTemplateConsolidationData);
     Map<String, List<String>> propertyVal = getPropertyValueInputParam(inputParamId);
     nodeTemplate.getProperties().put(propertyEntry.getKey(), propertyVal);
     return Optional.of(inputParamId);
@@ -2464,17 +2464,17 @@ public class UnifiedCompositionService {
   }
 
   private boolean handleGetAttrFromConsolidationNodes(
-      ServiceTemplate serviceTemplate,
-      String nodeTemplateId, NodeTemplate nodeTemplate,
-      Map.Entry<String, Object> propertyEntry,
-      List<UnifiedCompositionData> unifiedCompositionDataList,
-      TranslationContext context) {
+          ServiceTemplate serviceTemplate,
+          String nodeTemplateId, NodeTemplate nodeTemplate,
+          Map.Entry<String, Object> propertyEntry,
+          List<UnifiedCompositionData> unifiedCompositionDataList,
+          TranslationContext context) {
     Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType =
-        getAllConsolidationNodeTemplateIdAndType(unifiedCompositionDataList);
+            getAllConsolidationNodeTemplateIdAndType(unifiedCompositionDataList);
 
     Set<String> consolidationNodeTemplateIds = consolidationNodeTemplateIdAndType.keySet();
     Map<String, String> entityIdToType = ConsolidationService.getConsolidationEntityIdToType(
-        serviceTemplate, context.getConsolidationData());
+            serviceTemplate, context.getConsolidationData());
     boolean includeGetAttrFromConsolidationNodes = false;
     boolean includeGetAttrFromOutsideNodes = false;
     boolean isGetAttrFromConsolidationIsFromSameType = false;
@@ -2491,9 +2491,9 @@ public class UnifiedCompositionService {
       }
     }
     if ((includeGetAttrFromConsolidationNodes && includeGetAttrFromOutsideNodes)
-        ||
-        (includeGetAttrFromConsolidationNodes && isIncludeToscaFunc(propertyEntry.getValue(),
-            ToscaFunctions.GET_INPUT))) {
+            ||
+            (includeGetAttrFromConsolidationNodes && isIncludeToscaFunc(propertyEntry.getValue(),
+                    ToscaFunctions.GET_INPUT))) {
       //This case is currently not supported - this property will be ignored
       return true;
     } else if (includeGetAttrFromConsolidationNodes && !isGetAttrFromConsolidationIsFromSameType) {
@@ -2503,7 +2503,7 @@ public class UnifiedCompositionService {
         String targetNodeTemplateId = (String) getAttrFunc.get(0);
         if (consolidationNodeTemplateIds.contains(targetNodeTemplateId)) {
           updatePropertyGetAttrFunc(serviceTemplate, unifiedCompositionDataList,
-              consolidationNodeTemplateIdAndType, targetNodeTemplateId, getAttrFunc, context);
+                  consolidationNodeTemplateIdAndType, targetNodeTemplateId, getAttrFunc, context);
         }
       }
       nodeTemplate.getProperties().put(propertyEntry.getKey(), clonedPropertyValue);
@@ -2517,25 +2517,25 @@ public class UnifiedCompositionService {
                                                     Map<String, String> nodeTemplateIdToType) {
 
     if (Objects.isNull(nodeTemplateIdToType.get(sourceNodeTemplateId))
-        || Objects.isNull(nodeTemplateIdToType.get(targetNodeTemplateId))) {
+            || Objects.isNull(nodeTemplateIdToType.get(targetNodeTemplateId))) {
       return false;
     }
 
     return nodeTemplateIdToType.get(sourceNodeTemplateId).equals(nodeTemplateIdToType
-        .get(targetNodeTemplateId));
+            .get(targetNodeTemplateId));
   }
 
   private void updatePropertyGetAttrFunc(
-      ServiceTemplate serviceTemplate,
-      List<UnifiedCompositionData> unifiedCompositionDataList,
-      Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType,
-      String targetNodeTemplateId,
-      List<Object> getAttrFunc, TranslationContext context) {
+          ServiceTemplate serviceTemplate,
+          List<UnifiedCompositionData> unifiedCompositionDataList,
+          Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType,
+          String targetNodeTemplateId,
+          List<Object> getAttrFunc, TranslationContext context) {
     UnifiedCompositionEntity targetCompositionEntity =
-        consolidationNodeTemplateIdAndType.get(targetNodeTemplateId);
+            consolidationNodeTemplateIdAndType.get(targetNodeTemplateId);
     String targetNewNodeTemplateId =
-        getNewNodeTemplateId(serviceTemplate, unifiedCompositionDataList, targetNodeTemplateId,
-            targetCompositionEntity, context);
+            getNewNodeTemplateId(serviceTemplate, unifiedCompositionDataList, targetNodeTemplateId,
+                    targetCompositionEntity, context);
     getAttrFunc.set(0, targetNewNodeTemplateId);
   }
 
@@ -2547,9 +2547,9 @@ public class UnifiedCompositionService {
     String newNodeTemplateId = nodeTemplateId;
     String nodeTemplateIdGeneratorImpl = unifiedSubstitutionNodeTemplateIdGeneratorImplMap.get(compositionEntity);
     UnifiedSubstitutionNodeTemplateIdGenerator nodeTemplateIdGenerator =
-        CommonMethods.newInstance(nodeTemplateIdGeneratorImpl, UnifiedSubstitutionNodeTemplateIdGenerator.class);
+            CommonMethods.newInstance(nodeTemplateIdGeneratorImpl, UnifiedSubstitutionNodeTemplateIdGenerator.class);
     UnifiedCompositionTo unifiedCompositionTo = new UnifiedCompositionTo(serviceTemplate, null,
-        unifiedCompositionDataList, context);
+            unifiedCompositionDataList, context);
     Optional<String> generatedNodeTemplateId = nodeTemplateIdGenerator.generate(unifiedCompositionTo, nodeTemplateId);
     if (generatedNodeTemplateId.isPresent()) {
       newNodeTemplateId = generatedNodeTemplateId.get();
@@ -2564,13 +2564,13 @@ public class UnifiedCompositionService {
     ConsolidationData consolidationData = context.getConsolidationData();
 
     if (isIdIsOfExpectedType(origNodeTemplateId, UnifiedCompositionEntity.PORT,
-        serviceTemplateFileName,
-        context)) {
+            serviceTemplateFileName,
+            context)) {
       return handleIdOfPort(origNodeTemplateId, serviceTemplateFileName, consolidationData);
     } else if (isIdIsOfExpectedType(origNodeTemplateId, COMPUTE,
-        serviceTemplateFileName, context)) {
+            serviceTemplateFileName, context)) {
       NodeTemplate nodeTemplate =
-          getComputeNodeTemplate(origNodeTemplateId, serviceTemplate, context);
+              getComputeNodeTemplate(origNodeTemplateId, serviceTemplate, context);
       return getComputeTypeSuffix(nodeTemplate.getType());
     }
 
@@ -2590,34 +2590,34 @@ public class UnifiedCompositionService {
   private String getParameterId(String nodeTemplateId, NodeTemplate nodeTemplate, String propertyId,
                                 UnifiedCompositionEntity unifiedCompositionEntity,
                                 ComputeTemplateConsolidationData
-                                    computeTemplateConsolidationData,
+                                        computeTemplateConsolidationData,
                                 PortTemplateConsolidationData portTemplateConsolidationData) {
     String paramterId = propertyId;
     switch (unifiedCompositionEntity) {
       case COMPUTE:
         paramterId = COMPUTE.getDisplayName().toLowerCase() + "_"
-            + getComputeTypeSuffix(nodeTemplate.getType()) + "_" + propertyId;
+                + getComputeTypeSuffix(nodeTemplate.getType()) + "_" + propertyId;
         break;
       case PORT:
         String portType = ConsolidationDataUtil.getPortType(nodeTemplateId);
         if (Objects.isNull(computeTemplateConsolidationData)
-            || computeTemplateConsolidationData.getPorts().get(portType).size() > 1) {
+                || computeTemplateConsolidationData.getPorts().get(portType).size() > 1) {
           paramterId = UnifiedCompositionEntity.PORT.getDisplayName().toLowerCase() + "_"
-              + nodeTemplateId + "_" + propertyId;
+                  + nodeTemplateId + "_" + propertyId;
         } else {
           paramterId = UnifiedCompositionEntity.PORT.getDisplayName().toLowerCase() + "_" + portType + "_"
-              + propertyId;
+                  + propertyId;
         }
         break;
       case SUB_INTERFACE:
         String subInterfaceType = getSubInterfaceTypeSuffix(nodeTemplate.getType());
         if (Objects.isNull(portTemplateConsolidationData)
-            || isSubInterfaceNodeTemplateIdParameter(portTemplateConsolidationData, nodeTemplate)) {
+                || isSubInterfaceNodeTemplateIdParameter(portTemplateConsolidationData, nodeTemplate)) {
           paramterId = UnifiedCompositionEntity.SUB_INTERFACE.getDisplayName().toLowerCase() + "_"
-              + nodeTemplateId + "_" + propertyId;
+                  + nodeTemplateId + "_" + propertyId;
         } else {
           paramterId = UnifiedCompositionEntity.SUB_INTERFACE.getDisplayName().toLowerCase() + "_"
-              + subInterfaceType + "_" + propertyId;
+                  + subInterfaceType + "_" + propertyId;
         }
         break;
       default:
@@ -2629,9 +2629,9 @@ public class UnifiedCompositionService {
   private boolean isSubInterfaceNodeTemplateIdParameter(PortTemplateConsolidationData portTemplateConsolidationData,
                                                         NodeTemplate nodeTemplate) {
     List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
-        portTemplateConsolidationData.getSubInterfaceConsolidationData(nodeTemplate.getType());
+            portTemplateConsolidationData.getSubInterfaceConsolidationData(nodeTemplate.getType());
     return (Objects.nonNull(subInterfaceTemplateConsolidationDataList)
-        && subInterfaceTemplateConsolidationDataList.size() > 1) ;
+            && subInterfaceTemplateConsolidationDataList.size() > 1) ;
   }
 
   private void removeConnectivityOut(EntityConsolidationData entityConsolidationData,
@@ -2641,10 +2641,10 @@ public class UnifiedCompositionService {
     }
 
     for (List<RequirementAssignmentData> requirementAssignmentDataList : entityConsolidationData
-        .getNodesConnectedOut().values()) {
+            .getNodesConnectedOut().values()) {
       for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList) {
         DataModelUtil.removeRequirementsAssignment(nodeTemplate.getRequirements(),
-            requirementAssignmentData.getRequirementId());
+                requirementAssignmentData.getRequirementId());
       }
       if (nodeTemplate.getRequirements().isEmpty()) {
         nodeTemplate.setRequirements(null);
@@ -2653,17 +2653,17 @@ public class UnifiedCompositionService {
   }
 
   private void removeVolumeConnectivity(
-      ComputeTemplateConsolidationData computeTemplateConsolidationData,
-      NodeTemplate computeNodeTemplate) {
+          ComputeTemplateConsolidationData computeTemplateConsolidationData,
+          NodeTemplate computeNodeTemplate) {
     if (MapUtils.isEmpty(computeTemplateConsolidationData.getVolumes())) {
       return;
     }
     Collection<List<RequirementAssignmentData>> volumeCollection =
-        computeTemplateConsolidationData.getVolumes().values();
+            computeTemplateConsolidationData.getVolumes().values();
     for (List<RequirementAssignmentData> requirementAssignmentDataList : volumeCollection) {
       for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList) {
         DataModelUtil.removeRequirementsAssignment(computeNodeTemplate.getRequirements(),
-            requirementAssignmentData.getRequirementId());
+                requirementAssignmentData.getRequirementId());
       }
     }
     if (computeNodeTemplate.getRequirements().isEmpty()) {
@@ -2673,11 +2673,11 @@ public class UnifiedCompositionService {
 
   private void createIndexInputParameter(ServiceTemplate substitutionServiceTemplate) {
     ParameterDefinition indexParameterDefinition =
-        DataModelUtil.createParameterDefinition(PropertyType.INTEGER.getDisplayName(),
-            "Index value of this substitution service template runtime instance", null,
-            false, createIndexValueConstraint(), null, null, 0);
+            DataModelUtil.createParameterDefinition(PropertyType.INTEGER.getDisplayName(),
+                    "Index value of this substitution service template runtime instance", null,
+                    false, createIndexValueConstraint(), null, null, 0);
     DataModelUtil.addInputParameterToTopologyTemplate(substitutionServiceTemplate,
-        ToscaConstants.INDEX_VALUE_PROPERTY_NAME, indexParameterDefinition);
+            ToscaConstants.INDEX_VALUE_PROPERTY_NAME, indexParameterDefinition);
   }
 
 
@@ -2692,44 +2692,44 @@ public class UnifiedCompositionService {
 
   private Optional<UnifiedComposition> getUnifiedCompositionInstance(UnifiedCompositionMode mode) {
     String unifiedCompositionImplClassName =
-        unifiedCompositionImplMap.get(mode.name()).getImplementationClass();
+            unifiedCompositionImplMap.get(mode.name()).getImplementationClass();
     if (StringUtils.isEmpty(unifiedCompositionImplClassName)) {
       return Optional.empty();
     }
     return Optional
-        .of(CommonMethods.newInstance(unifiedCompositionImplClassName, UnifiedComposition.class));
+            .of(CommonMethods.newInstance(unifiedCompositionImplClassName, UnifiedComposition.class));
   }
 
   private Optional<Map<String, Object>> createAbstractSubstitutionProperties(
-      ServiceTemplate serviceTemplate,
-      Map<String, ParameterDefinition> substitutionTemplateInputs,
-      List<UnifiedCompositionData> unifiedCompositionDataList,
-      TranslationContext context) {
+          ServiceTemplate serviceTemplate,
+          Map<String, ParameterDefinition> substitutionTemplateInputs,
+          List<UnifiedCompositionData> unifiedCompositionDataList,
+          TranslationContext context) {
     Map<String, Object> abstractSubstituteProperties = new LinkedHashMap<>();
     //Since all the computes have the same type fetching the type from the first entry
     NodeTemplate firstComputeNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
-        unifiedCompositionDataList.get(0)
-            .getComputeTemplateConsolidationData().getNodeTemplateId());
+            unifiedCompositionDataList.get(0)
+                    .getComputeTemplateConsolidationData().getNodeTemplateId());
     String computeType = getComputeTypeSuffix(firstComputeNodeTemplate.getType());
     for (Map.Entry<String, ParameterDefinition> input : substitutionTemplateInputs.entrySet()) {
       String substitutionTemplateInputName = input.getKey();
       ParameterDefinition inputParameterDefinition = input.getValue();
       String inputType = inputParameterDefinition.getType();
       UnifiedCompositionEntity inputUnifiedCompositionEntity =
-          getInputCompositionEntity(substitutionTemplateInputName);
+              getInputCompositionEntity(substitutionTemplateInputName);
 
       if (!inputType.equalsIgnoreCase(PropertyType.LIST.getDisplayName())) {
         if (isIdenticalValueProperty(
-            substitutionTemplateInputName, inputUnifiedCompositionEntity)) {
+                substitutionTemplateInputName, inputUnifiedCompositionEntity)) {
           //Handle identical value properties
           Optional<String> identicalValuePropertyName =
-              getIdenticalValuePropertyName(substitutionTemplateInputName,
-                  inputUnifiedCompositionEntity);
+                  getIdenticalValuePropertyName(substitutionTemplateInputName,
+                          inputUnifiedCompositionEntity);
 
           identicalValuePropertyName.ifPresent(propertyName -> updateIdenticalPropertyValue(propertyName,
-              substitutionTemplateInputName, inputUnifiedCompositionEntity,
-              unifiedCompositionDataList.get(0), serviceTemplate, abstractSubstituteProperties,
-              context));
+                  substitutionTemplateInputName, inputUnifiedCompositionEntity,
+                  unifiedCompositionDataList.get(0), serviceTemplate, abstractSubstituteProperties,
+                  context));
         }
         continue;
       }
@@ -2739,15 +2739,15 @@ public class UnifiedCompositionService {
       switch (inputUnifiedCompositionEntity) {
         case COMPUTE:
           createAbstractComputeProperties(unifiedCompositionDataList,
-              substitutionTemplateInputName, serviceTemplate, abstractPropertyValue);
+                  substitutionTemplateInputName, serviceTemplate, abstractPropertyValue);
           break;
         case PORT:
           createAbstractPortProperties(unifiedCompositionDataList, substitutionTemplateInputName,
-              computeType, serviceTemplate, abstractPropertyValue);
+                  computeType, serviceTemplate, abstractPropertyValue);
           break;
         case SUB_INTERFACE:
           createAbstractSubInterfaceProperties(unifiedCompositionDataList,
-              substitutionTemplateInputName, serviceTemplate, abstractPropertyValue);
+                  substitutionTemplateInputName, serviceTemplate, abstractPropertyValue);
           break;
         default:
           break;
@@ -2755,22 +2755,22 @@ public class UnifiedCompositionService {
       //Add the property only if it has at least one non-null value
       if (abstractPropertyValue.stream().anyMatch(Objects::nonNull)) {
         updateAbstractPropertyValue(substitutionTemplateInputName, inputParameterDefinition,
-            abstractPropertyValue, abstractSubstituteProperties);
+                abstractPropertyValue, abstractSubstituteProperties);
       }
     }
     return Optional.ofNullable(abstractSubstituteProperties);
   }
 
   private void createAbstractComputeProperties(List<UnifiedCompositionData>
-                                                   unifiedCompositionDataList,
+                                                       unifiedCompositionDataList,
                                                String substitutionTemplateInputName,
                                                ServiceTemplate serviceTemplate,
                                                List<Object> abstractPropertyValue) {
     for (UnifiedCompositionData compositionData : unifiedCompositionDataList) {
       ComputeTemplateConsolidationData computeTemplateConsolidationData =
-          compositionData.getComputeTemplateConsolidationData();
+              compositionData.getComputeTemplateConsolidationData();
       Object propertyValue = getComputePropertyValue(substitutionTemplateInputName,
-          serviceTemplate, computeTemplateConsolidationData);
+              serviceTemplate, computeTemplateConsolidationData);
       if (!(propertyValue instanceof Optional)) {
         abstractPropertyValue.add(propertyValue);
       }
@@ -2778,25 +2778,25 @@ public class UnifiedCompositionService {
   }
 
   private void createAbstractPortProperties(List<UnifiedCompositionData>
-                                                unifiedCompositionDataList,
+                                                    unifiedCompositionDataList,
                                             String substitutionTemplateInputName,
                                             String computeType,
                                             ServiceTemplate serviceTemplate,
                                             List<Object> abstractPropertyValue) {
     for (UnifiedCompositionData compositionData : unifiedCompositionDataList) {
       List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
-          getPortTemplateConsolidationDataList(compositionData);
+              getPortTemplateConsolidationDataList(compositionData);
       //Get the input type for this input whether it is of type
       // port_<port_node_template_id>_<property_name> or port_<port_type>_<property_name>
       PropertyInputType portInputType = getPortInputType(substitutionTemplateInputName,
-          compositionData);
+              compositionData);
       for (PortTemplateConsolidationData portTemplateConsolidationData :
-          portTemplateConsolidationDataList) {
+              portTemplateConsolidationDataList) {
         //Get the port property value
         String portNodeTemplateId = portTemplateConsolidationData.getNodeTemplateId();
         Object propertyValue = getPortPropertyValue(substitutionTemplateInputName,
-            computeType, portInputType, serviceTemplate,
-            portNodeTemplateId);
+                computeType, portInputType, serviceTemplate,
+                portNodeTemplateId);
         //If the value object is Optional.empty it implies that the property name was not
         // found in the input name
         if (!(propertyValue instanceof Optional)) {
@@ -2807,30 +2807,30 @@ public class UnifiedCompositionService {
   }
 
   private void createAbstractSubInterfaceProperties(List<UnifiedCompositionData>
-                                                        unifiedCompositionDataList,
+                                                            unifiedCompositionDataList,
                                                     String substitutionTemplateInputName,
                                                     ServiceTemplate serviceTemplate,
                                                     List<Object> abstractPropertyValue) {
     for (UnifiedCompositionData compositionData : unifiedCompositionDataList) {
       List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
-          getSubInterfaceTemplateConsolidationDataList(compositionData);
+              getSubInterfaceTemplateConsolidationDataList(compositionData);
       //Get the input type for this input whether it is of type
       // subInterface_<subinterface_node_template_id>_<property_name> or
       // subInterface_<subinterface_type>_<property_name>
       PropertyInputType subInterfaceInputType =
-          getSubInterfaceInputType(substitutionTemplateInputName, compositionData);
+              getSubInterfaceInputType(substitutionTemplateInputName, compositionData);
       for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData :
-          subInterfaceTemplateConsolidationDataList) {
+              subInterfaceTemplateConsolidationDataList) {
         //Get the subInterface property value
         String subInterfaceNodeTemplateId = subInterfaceTemplateConsolidationData
-            .getNodeTemplateId();
+                .getNodeTemplateId();
         NodeTemplate subInterfaceNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
-            subInterfaceNodeTemplateId);
+                subInterfaceNodeTemplateId);
         String subInterfaceType = getSubInterfaceTypeSuffix(subInterfaceNodeTemplate
-            .getType());
+                .getType());
         Object propertyValue = getSubInterfacePropertyValue(substitutionTemplateInputName,
-            subInterfaceType, subInterfaceInputType, serviceTemplate,
-            subInterfaceNodeTemplateId);
+                subInterfaceType, subInterfaceInputType, serviceTemplate,
+                subInterfaceNodeTemplateId);
         //If the value object is Optional.empty it implies that the property name was not
         // found in the input name
         if (!(propertyValue instanceof Optional)) {
@@ -2850,7 +2850,7 @@ public class UnifiedCompositionService {
       Object propertyValue = abstractPropertyValue.get(0);
       String entrySchemaType = parameterDefinition.getEntry_schema().getType();
       if (PropertyType.getSimplePropertyTypes().contains(entrySchemaType.toLowerCase())
-          || entrySchemaType.equals(PropertyTypeExt.JSON.getDisplayName())) {
+              || entrySchemaType.equals(PropertyTypeExt.JSON.getDisplayName())) {
         abstractSubstituteProperties.put(substitutionTemplateInputName, abstractPropertyValue);
       } else {
         abstractSubstituteProperties.put(substitutionTemplateInputName, propertyValue);
@@ -2866,12 +2866,12 @@ public class UnifiedCompositionService {
                                             Map<String, Object> abstractSubstituteProperties,
                                             TranslationContext context) {
     Optional<Object> identicalPropertyValueByType =
-        getIdenticalPropertyValueByType(identicalValuePropertyName, substitutionTemplateInputName,
-            entity, unifiedCompositionData, serviceTemplate, context);
+            getIdenticalPropertyValueByType(identicalValuePropertyName, substitutionTemplateInputName,
+                    entity, unifiedCompositionData, serviceTemplate, context);
 
     if (identicalPropertyValueByType.isPresent()) {
       abstractSubstituteProperties
-          .put(substitutionTemplateInputName, identicalPropertyValueByType.get());
+              .put(substitutionTemplateInputName, identicalPropertyValueByType.get());
 
     }
 
@@ -2882,35 +2882,40 @@ public class UnifiedCompositionService {
                                                            String substitutionTemplateInputName,
                                                            UnifiedCompositionEntity entity,
                                                            UnifiedCompositionData
-                                                               unifiedCompositionData,
+                                                                   unifiedCompositionData,
                                                            ServiceTemplate serviceTemplate,
                                                            TranslationContext context) {
 
     ComputeTemplateConsolidationData computeTemplateConsolidationData =
-        unifiedCompositionData.getComputeTemplateConsolidationData();
+            unifiedCompositionData.getComputeTemplateConsolidationData();
 
     Optional<Object> identicalPropertyValue = Optional.empty();
     switch (entity) {
       case COMPUTE:
         identicalPropertyValue =
-            getIdenticalPropertyValue(identicalValuePropertyName, serviceTemplate,
-                 computeTemplateConsolidationData, context);
+                getIdenticalPropertyValue(identicalValuePropertyName, serviceTemplate,
+                        computeTemplateConsolidationData, context);
         break;
       case OTHER:
         identicalPropertyValue =
-            getIdenticalPropertyValue(identicalValuePropertyName, serviceTemplate,
-                 computeTemplateConsolidationData, context);
+                getIdenticalPropertyValue(identicalValuePropertyName, serviceTemplate,
+                        computeTemplateConsolidationData, context);
         break;
       case PORT:
-        List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
-            unifiedCompositionData.getPortTemplateConsolidationDataList();
-        for (PortTemplateConsolidationData portTemplateConsolidationData : portTemplateConsolidationDataList) {
-          String portType =
-              ConsolidationDataUtil.getPortType(portTemplateConsolidationData.getNodeTemplateId());
-          if (substitutionTemplateInputName.contains(portType)) {
-            return getIdenticalPropertyValue(identicalValuePropertyName,
-                serviceTemplate, portTemplateConsolidationData, context);
-          }
+        PropertyInputType portInputType = getPortInputType(substitutionTemplateInputName,
+                                         unifiedCompositionData);
+        Optional <PortTemplateConsolidationData>  portTemplateConsolidationData =
+                unifiedCompositionData.getPortTemplateConsolidationDataList()
+                        .stream()
+                        .filter(s -> substitutionTemplateInputName.
+                                contains(getPropertyInputPrefix(s.getNodeTemplateId(),
+                                ConsolidationDataUtil.getPortType(s.getNodeTemplateId()),
+                                portInputType, UnifiedCompositionEntity.PORT)))
+                        .findFirst();
+
+        if(portTemplateConsolidationData.isPresent()) {
+          return getIdenticalPropertyValue(identicalValuePropertyName, serviceTemplate,
+                  portTemplateConsolidationData.get(), context);
         }
         break;
       default:
@@ -2924,13 +2929,13 @@ public class UnifiedCompositionService {
                                              UnifiedCompositionData unifiedCompositionData) {
     String portInputPrefix = UnifiedCompositionEntity.PORT.getDisplayName().toLowerCase() + "_";
     ComputeTemplateConsolidationData computeTemplateConsolidationData = unifiedCompositionData
-        .getComputeTemplateConsolidationData();
+            .getComputeTemplateConsolidationData();
     List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
-        getPortTemplateConsolidationDataList(unifiedCompositionData);
+            getPortTemplateConsolidationDataList(unifiedCompositionData);
     //Scan the available port node template ids to check if the input is of the form
     // "port_<port_node_template_id>_<property_name>"
     if (portTemplateConsolidationDataList.stream().map(EntityConsolidationData::getNodeTemplateId)
-        .map(portNodeTemplateId -> portInputPrefix + portNodeTemplateId).anyMatch(inputName::startsWith)) {
+            .map(portNodeTemplateId -> portInputPrefix + portNodeTemplateId).anyMatch(inputName::startsWith)) {
       return PropertyInputType.NODE_TEMPLATE_ID;
     }
     //Check whether the input is of the form "port_<port_type>_<property_name>"
@@ -2942,31 +2947,31 @@ public class UnifiedCompositionService {
   }
 
   private PropertyInputType getSubInterfaceInputType(String inputName,
-                                             UnifiedCompositionData unifiedCompositionData) {
+                                                     UnifiedCompositionData unifiedCompositionData) {
     String subInterfaceInputPrefix = UnifiedCompositionEntity.SUB_INTERFACE.getDisplayName().toLowerCase()
-        + "_";
+            + "_";
     List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
-        getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
+            getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
     //Scan the available port node template ids to check if the input is of the form
     // "subinterface_<subinterface_node_template_id>_<property_name>"
     if (subInterfaceTemplateConsolidationDataList.stream().map(EntityConsolidationData::getNodeTemplateId)
-        .map(subInterfaceNodeTemplateId -> subInterfaceInputPrefix
-            + subInterfaceNodeTemplateId)
-        .anyMatch(inputName::startsWith)) {
+            .map(subInterfaceNodeTemplateId -> subInterfaceInputPrefix
+                    + subInterfaceNodeTemplateId)
+            .anyMatch(inputName::startsWith)) {
       return PropertyInputType.NODE_TEMPLATE_ID;
     }
     //Check whether the input is of the form "subinterface_<subinterface_type>_<property_name>"
     Set<String> subInterfaceTypes = new HashSet<>();
     List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
-        getPortTemplateConsolidationDataList(unifiedCompositionData);
+            getPortTemplateConsolidationDataList(unifiedCompositionData);
     for (PortTemplateConsolidationData portTemplateConsolidationData :
-        portTemplateConsolidationDataList) {
+            portTemplateConsolidationDataList) {
       subInterfaceTypes.addAll(portTemplateConsolidationData.getAllSubInterfaceNodeTypes());
     }
 
     if (subInterfaceTypes.stream().map(UnifiedCompositionUtil::getSubInterfaceTypeSuffix)
-        .map(subInterfaceTypeSuffix -> subInterfaceInputPrefix + subInterfaceTypeSuffix + "_")
-        .anyMatch(inputName::startsWith)) {
+            .map(subInterfaceTypeSuffix -> subInterfaceInputPrefix + subInterfaceTypeSuffix + "_")
+            .anyMatch(inputName::startsWith)) {
       return PropertyInputType.TYPE;
     }
     return PropertyInputType.OTHER;
@@ -2985,17 +2990,17 @@ public class UnifiedCompositionService {
                                                      TranslationContext context) {
     String nodeTemplateIdToRemove = entity.getNodeTemplateId();
     Map<String, NodeTemplate> nodeTemplates =
-        serviceTemplate.getTopology_template().getNode_templates();
+            serviceTemplate.getTopology_template().getNode_templates();
     NodeTemplate nodeTemplateToRemove =
-        nodeTemplates.get(nodeTemplateIdToRemove);
+            nodeTemplates.get(nodeTemplateIdToRemove);
     nodeTemplates.remove(nodeTemplateIdToRemove);
 
     context.addCleanedNodeTemplate(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
-        nodeTemplateIdToRemove,
-        entity.getClass() == ComputeTemplateConsolidationData.class
-            ? COMPUTE
-            : UnifiedCompositionEntity.PORT,
-        nodeTemplateToRemove);
+            nodeTemplateIdToRemove,
+            entity.getClass() == ComputeTemplateConsolidationData.class
+                    ? COMPUTE
+                    : UnifiedCompositionEntity.PORT,
+            nodeTemplateToRemove);
 
   }
 
@@ -3003,13 +3008,13 @@ public class UnifiedCompositionService {
                                      ServiceTemplate serviceTemplate,
                                      TranslationContext context) {
     NodeTemplate cleanedNodeTemplate =
-        context
-            .getCleanedNodeTemplate(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
-                cleanedNodeTemplateId);
+            context
+                    .getCleanedNodeTemplate(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
+                            cleanedNodeTemplateId);
     String typeToRemove = cleanedNodeTemplate.getType();
 
     if (Objects.nonNull(typeToRemove)
-        && serviceTemplate.getNode_types().containsKey(typeToRemove)) {
+            && serviceTemplate.getNode_types().containsKey(typeToRemove)) {
       serviceTemplate.getNode_types().remove(typeToRemove);
     }
   }
@@ -3018,24 +3023,24 @@ public class UnifiedCompositionService {
                                     EntityConsolidationData entity,
                                     TranslationContext context) {
     Map<String, GroupDefinition> groups = serviceTemplate.getTopology_template()
-        .getGroups() == null ? new HashMap<>()
-        : serviceTemplate.getTopology_template().getGroups();
+            .getGroups() == null ? new HashMap<>()
+            : serviceTemplate.getTopology_template().getGroups();
     String nodeRelatedAbstractNodeId =
-        context.getUnifiedAbstractNodeTemplateId(serviceTemplate, entity.getNodeTemplateId());
+            context.getUnifiedAbstractNodeTemplateId(serviceTemplate, entity.getNodeTemplateId());
 
     for (Map.Entry<String, GroupDefinition> groupEntry : groups.entrySet()) {
       GroupDefinition groupDefinition = groupEntry.getValue();
       if (isHeatStackGroup(groupDefinition.getType())) {
         updateGroupMembersWithNewUnifiedNodeTemplateId(entity, nodeRelatedAbstractNodeId,
-            groupEntry);
+                groupEntry);
       }
     }
   }
 
   private void updateGroupMembersWithNewUnifiedNodeTemplateId(
-      EntityConsolidationData entity,
-      String newNodetemplateId,
-      Map.Entry<String, GroupDefinition> groupEntry) {
+          EntityConsolidationData entity,
+          String newNodetemplateId,
+          Map.Entry<String, GroupDefinition> groupEntry) {
     List<String> members = groupEntry.getValue().getMembers();
     if (members.contains(entity.getNodeTemplateId())) {
       members.remove(entity.getNodeTemplateId());
@@ -3049,34 +3054,34 @@ public class UnifiedCompositionService {
   private void updateSubstitutionMapping(ServiceTemplate serviceTemplate,
                                          TranslationContext context) {
     SubstitutionMapping substitutionMappings =
-        DataModelUtil.getSubstitutionMappings(serviceTemplate);
+            DataModelUtil.getSubstitutionMappings(serviceTemplate);
     if (Objects.nonNull(substitutionMappings)) {
 
       if (Objects.nonNull(substitutionMappings.getRequirements())) {
         updateSubstitutionMappingRequirements(substitutionMappings.getRequirements(),
-            serviceTemplate, context);
+                serviceTemplate, context);
       }
 
       if (Objects.nonNull(substitutionMappings.getCapabilities())) {
         updateSubstitutionMappingCapabilities(substitutionMappings.getCapabilities(),
-            serviceTemplate, context);
+                serviceTemplate, context);
       }
     }
   }
 
   private void updateSubstitutionMappingRequirements(Map<String, List<String>>
-                                                         substitutionMappingRequirements,
+                                                             substitutionMappingRequirements,
                                                      ServiceTemplate serviceTemplate,
                                                      TranslationContext context) {
     for (Map.Entry<String, List<String>> entry : substitutionMappingRequirements.entrySet()) {
       List<String> requirement = entry.getValue();
       String oldNodeTemplateId = requirement.get(0);
       String newAbstractNodeTemplateId = context.getUnifiedAbstractNodeTemplateId(serviceTemplate,
-          requirement.get(0));
+              requirement.get(0));
       String newSubstitutionNodeTemplateId = context.getUnifiedSubstitutionNodeTemplateId(
-          serviceTemplate, oldNodeTemplateId);
+              serviceTemplate, oldNodeTemplateId);
       if (Objects.nonNull(newAbstractNodeTemplateId)
-          && Objects.nonNull(newSubstitutionNodeTemplateId)) {
+              && Objects.nonNull(newSubstitutionNodeTemplateId)) {
         requirement.set(0, newAbstractNodeTemplateId);
         String newRequirementValue = requirement.get(1) + "_" + newSubstitutionNodeTemplateId;
         requirement.set(1, newRequirementValue);
@@ -3085,18 +3090,18 @@ public class UnifiedCompositionService {
   }
 
   private void updateSubstitutionMappingCapabilities(Map<String, List<String>>
-                                                         substitutionMappingCapabilities,
+                                                             substitutionMappingCapabilities,
                                                      ServiceTemplate serviceTemplate,
                                                      TranslationContext context) {
     for (Map.Entry<String, List<String>> entry : substitutionMappingCapabilities.entrySet()) {
       List<String> capability = entry.getValue();
       String oldNodeTemplateId = capability.get(0);
       String newAbstractNodeTemplateId = context.getUnifiedAbstractNodeTemplateId(serviceTemplate,
-          capability.get(0));
+              capability.get(0));
       String newSubstitutionNodeTemplateId = context.getUnifiedSubstitutionNodeTemplateId(
-          serviceTemplate, oldNodeTemplateId);
+              serviceTemplate, oldNodeTemplateId);
       if (Objects.nonNull(newAbstractNodeTemplateId)
-          && Objects.nonNull(newSubstitutionNodeTemplateId)) {
+              && Objects.nonNull(newSubstitutionNodeTemplateId)) {
         capability.set(0, newAbstractNodeTemplateId);
         String newRequirementValue = capability.get(1) + "_" + newSubstitutionNodeTemplateId;
         capability.set(1, newRequirementValue);
@@ -3108,16 +3113,16 @@ public class UnifiedCompositionService {
                                                      EntityConsolidationData entity,
                                                      TranslationContext context) {
     Map<String, GroupDefinition> groups = serviceTemplate.getTopology_template()
-        .getGroups() == null ? new HashMap<>() : serviceTemplate.getTopology_template().getGroups();
+            .getGroups() == null ? new HashMap<>() : serviceTemplate.getTopology_template().getGroups();
     String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
     Optional<String> nestedNodeTemplateId =
-        context.getUnifiedNestedNodeTemplateId(serviceTemplateFileName, entity.getNodeTemplateId());
+            context.getUnifiedNestedNodeTemplateId(serviceTemplateFileName, entity.getNodeTemplateId());
     if (nestedNodeTemplateId.isPresent()) {
       for (Map.Entry<String, GroupDefinition> groupEntry : groups.entrySet()) {
         GroupDefinition groupDefinition = groupEntry.getValue();
         if (isHeatStackGroup(groupDefinition.getType())) {
           updateGroupMembersWithNewUnifiedNodeTemplateId(entity, nestedNodeTemplateId.get(),
-              groupEntry);
+                  groupEntry);
         }
       }
     }
@@ -3128,7 +3133,7 @@ public class UnifiedCompositionService {
                                                              ServiceTemplate nestedServiceTemplate,
                                                              TranslationContext context) {
     NodeTemplate nestedNodeTemplate = DataModelUtil.getNodeTemplate(mainServiceTemplate,
-        nestedNodeTemplateId);
+            nestedNodeTemplateId);
     if (Objects.isNull(nestedNodeTemplate)) {
       return;
     }
@@ -3136,13 +3141,13 @@ public class UnifiedCompositionService {
     updateNestedNodeTemplateProperties(nestedServiceTemplate, nestedNodeTemplate, context);
 
     Optional<String> unifiedNestedNodeTypeId = context
-        .getUnifiedNestedNodeTypeId(
-            ToscaUtil.getServiceTemplateFileName(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME),
-            nestedNodeTemplate.getType());
+            .getUnifiedNestedNodeTypeId(
+                    ToscaUtil.getServiceTemplateFileName(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME),
+                    nestedNodeTemplate.getType());
     unifiedNestedNodeTypeId
-        .ifPresent(unifiedNestedNodeTypeIdVal -> updateNestedNodeTemplate(
-            unifiedNestedNodeTypeIdVal, nestedNodeTemplateId, nestedNodeTemplate,
-            mainServiceTemplate, context));
+            .ifPresent(unifiedNestedNodeTypeIdVal -> updateNestedNodeTemplate(
+                    unifiedNestedNodeTypeIdVal, nestedNodeTemplateId, nestedNodeTemplate,
+                    mainServiceTemplate, context));
   }
 
   private void updateNestedNodeTemplateProperties(ServiceTemplate nestedServiceTemplate,
@@ -3150,8 +3155,8 @@ public class UnifiedCompositionService {
                                                   TranslationContext context) {
 
     Map<String, Object> newPropertyInputParamIds =
-        context.getAllNewPropertyInputParamIdsPerNodeTenplateId(ToscaUtil
-            .getServiceTemplateFileName(nestedServiceTemplate));
+            context.getAllNewPropertyInputParamIdsPerNodeTenplateId(ToscaUtil
+                    .getServiceTemplateFileName(nestedServiceTemplate));
 
     for (Map.Entry<String, Object> entry : newPropertyInputParamIds.entrySet()) {
       if (Objects.nonNull(entry.getValue())) {
@@ -3161,24 +3166,24 @@ public class UnifiedCompositionService {
     }
 
     String subNodeType =
-        nestedServiceTemplate.getTopology_template().getSubstitution_mappings().getNode_type();
+            nestedServiceTemplate.getTopology_template().getSubstitution_mappings().getNode_type();
     nestedNodeTemplate.setType(subNodeType);
 
   }
 
   private void handleSubstitutionMappingInNestedServiceTemplate(
-      String newNestedNodeType,
-      ServiceTemplate nestedServiceTemplate,
-      TranslationContext context) {
+          String newNestedNodeType,
+          ServiceTemplate nestedServiceTemplate,
+          TranslationContext context) {
     if (Objects.isNull(newNestedNodeType)) {
       return;
     }
 
     Set<String> relatedNestedNodeTypeIds =
-        context.getAllRelatedNestedNodeTypeIds();
+            context.getAllRelatedNestedNodeTypeIds();
 
     SubstitutionMapping substitutionMappings =
-        nestedServiceTemplate.getTopology_template().getSubstitution_mappings();
+            nestedServiceTemplate.getTopology_template().getSubstitution_mappings();
     if (!relatedNestedNodeTypeIds.contains(substitutionMappings.getNode_type())) {
       substitutionMappings.setNode_type(newNestedNodeType);
     }
@@ -3191,43 +3196,43 @@ public class UnifiedCompositionService {
                                         TranslationContext context) {
     String mainSTName = ToscaUtil.getServiceTemplateFileName(mainServiceTemplate);
     String globalSTName =
-        ToscaUtil.getServiceTemplateFileName(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME);
+            ToscaUtil.getServiceTemplateFileName(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME);
     int index =
-        context.getHandledNestedComputeNodeTemplateIndex(globalSTName, newNestedNodeTypeId);
+            context.getHandledNestedComputeNodeTemplateIndex(globalSTName, newNestedNodeTypeId);
     String newNodeTemplateId =
-        Constants.ABSTRACT_NODE_TEMPLATE_ID_PREFIX + getComputeTypeSuffix(newNestedNodeTypeId)
-            + "_" + index;
+            Constants.ABSTRACT_NODE_TEMPLATE_ID_PREFIX + getComputeTypeSuffix(newNestedNodeTypeId)
+                    + "_" + index;
 
     nestedNodeTemplate.setType(newNestedNodeTypeId);
     mainServiceTemplate.getTopology_template().getNode_templates().remove(nestedNodeTemplateId);
     mainServiceTemplate.getTopology_template().getNode_templates()
-        .put(newNodeTemplateId, nestedNodeTemplate);
+            .put(newNodeTemplateId, nestedNodeTemplate);
 
     context.addUnifiedNestedNodeTemplateId(mainSTName, nestedNodeTemplateId, newNodeTemplateId);
   }
 
   private void handleNestedNodeTypesInGlobalSubstituteServiceTemplate(
-      String origNestedNodeTypeId,
-      String newNestedNodeTypeId,
-      ServiceTemplate globalSubstitutionServiceTemplate,
-      TranslationContext context) {
+          String origNestedNodeTypeId,
+          String newNestedNodeTypeId,
+          ServiceTemplate globalSubstitutionServiceTemplate,
+          TranslationContext context) {
     Set<String> relatedNestedNodeTypeIds =
-        context.getAllRelatedNestedNodeTypeIds();
+            context.getAllRelatedNestedNodeTypeIds();
 
     Map<String, NodeType> nodeTypes = globalSubstitutionServiceTemplate.getNode_types();
     if (!relatedNestedNodeTypeIds.contains(origNestedNodeTypeId)) {
       NodeType nested = DataModelUtil.getNodeType(globalSubstitutionServiceTemplate,
-          origNestedNodeTypeId);
+              origNestedNodeTypeId);
       setNewValuesForNestedNodeType(origNestedNodeTypeId, newNestedNodeTypeId, nested, nodeTypes);
     } else {
       NodeType nested =
-          (NodeType) DataModelUtil.getClonedObject(
-              DataModelUtil.getNodeType(globalSubstitutionServiceTemplate, origNestedNodeTypeId));
+              (NodeType) DataModelUtil.getClonedObject(
+                      DataModelUtil.getNodeType(globalSubstitutionServiceTemplate, origNestedNodeTypeId));
       nested.setDerived_from(ToscaNodeType.VFC_ABSTRACT_SUBSTITUTE);
       nodeTypes.put(newNestedNodeTypeId, nested);
     }
     context.addUnifiedNestedNodeTypeId(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME,
-        origNestedNodeTypeId, newNestedNodeTypeId);
+            origNestedNodeTypeId, newNestedNodeTypeId);
   }
 
   private void setNewValuesForNestedNodeType(String origNestedNodeType,
@@ -3244,22 +3249,22 @@ public class UnifiedCompositionService {
   private Optional<String> getNewNestedNodeTypeId(ServiceTemplate nestedServiceTemplate,
                                                   TranslationContext context) {
     FileComputeConsolidationData fileComputeConsolidationData =
-        context.getConsolidationData().getComputeConsolidationData()
-            .getFileComputeConsolidationData(
-                ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate));
+            context.getConsolidationData().getComputeConsolidationData()
+                    .getFileComputeConsolidationData(
+                            ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate));
 
     if (Objects.nonNull(fileComputeConsolidationData)) {
       String nestedNodeTypePrefix = ToscaNodeType.ABSTRACT_NODE_TYPE_PREFIX + "heat.";
       return Optional
-          .of(nestedNodeTypePrefix + getComputeTypeInNestedFile(fileComputeConsolidationData));
+              .of(nestedNodeTypePrefix + getComputeTypeInNestedFile(fileComputeConsolidationData));
     }
     return Optional.empty();
   }
 
   private String getComputeTypeInNestedFile(
-      FileComputeConsolidationData fileComputeConsolidationData) {
+          FileComputeConsolidationData fileComputeConsolidationData) {
     List<TypeComputeConsolidationData> typeComputeConsolidationDatas =
-        new ArrayList<>(fileComputeConsolidationData.getAllTypeComputeConsolidationData());
+            new ArrayList<>(fileComputeConsolidationData.getAllTypeComputeConsolidationData());
     if (typeComputeConsolidationDatas.isEmpty()) {
       return null;
     } else {
@@ -3273,20 +3278,20 @@ public class UnifiedCompositionService {
                                                    String serviceTemplateFileName,
                                                    NodeTemplate abstractNodeTemplate) {
     Map<String, Object> properties =
-        abstractNodeTemplate == null || abstractNodeTemplate.getProperties() == null
-            ? new HashMap<>()
-            : abstractNodeTemplate.getProperties();
+            abstractNodeTemplate == null || abstractNodeTemplate.getProperties() == null
+                    ? new HashMap<>()
+                    : abstractNodeTemplate.getProperties();
     for (Object propertyValue : properties.values()) {
       List<List<Object>> getAttrList = extractGetAttrFunction(propertyValue);
       for (List<Object> getAttrFuncValue : getAttrList) {
         String origNodeTemplateId = (String) getAttrFuncValue.get(0);
         Optional<String> nestedNodeTemplateId = context.getUnifiedNestedNodeTemplateId(ToscaUtil
-            .getServiceTemplateFileName(serviceTemplate), origNodeTemplateId);
+                .getServiceTemplateFileName(serviceTemplate), origNodeTemplateId);
         if (nestedNodeTemplateId.isPresent()) {
           getAttrFuncValue.set(0, nestedNodeTemplateId.get());
         } else {
           replaceGetAttrNodeIdAndAttrName(serviceTemplate, context, serviceTemplateFileName,
-              getAttrFuncValue);
+                  getAttrFuncValue);
         }
       }
     }
@@ -3300,17 +3305,17 @@ public class UnifiedCompositionService {
     String attributeName = (String) getAttrFuncValue.get(1);
 
     String unifiedAbstractNodeTemplateId =
-        context.getUnifiedAbstractNodeTemplateId(serviceTemplate, origNodeTemplateId);
+            context.getUnifiedAbstractNodeTemplateId(serviceTemplate, origNodeTemplateId);
 
     if (Objects.isNull(unifiedAbstractNodeTemplateId)) {
       return;
     }
 
     String newNodeTemplateId =
-        getNewNodeTemplateId(origNodeTemplateId, serviceTemplateFileName, serviceTemplate, context);
+            getNewNodeTemplateId(origNodeTemplateId, serviceTemplateFileName, serviceTemplate, context);
 
     String newSubstitutionOutputParameterId =
-        getNewSubstitutionOutputParameterId(newNodeTemplateId, attributeName);
+            getNewSubstitutionOutputParameterId(newNodeTemplateId, attributeName);
 
     getAttrFuncValue.set(0, unifiedAbstractNodeTemplateId);
     getAttrFuncValue.set(1, newSubstitutionOutputParameterId);
@@ -3320,11 +3325,11 @@ public class UnifiedCompositionService {
                                               ServiceTemplate serviceTemplate,
                                               TranslationContext context) {
     NodeTemplate computeNodeTemplate =
-        DataModelUtil.getNodeTemplate(serviceTemplate, origNodeTemplateId);
+            DataModelUtil.getNodeTemplate(serviceTemplate, origNodeTemplateId);
     if (computeNodeTemplate == null) {
       computeNodeTemplate =
-          context.getCleanedNodeTemplate(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
-              origNodeTemplateId);
+              context.getCleanedNodeTemplate(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
+                      origNodeTemplateId);
     }
     return computeNodeTemplate;
   }
@@ -3332,14 +3337,14 @@ public class UnifiedCompositionService {
   private String handleIdOfPort(String origNodeTemplateId, String serviceTemplateFileName,
                                 ConsolidationData consolidationData) {
     Optional<Pair<String, ComputeTemplateConsolidationData>>
-        computeTypeAndComputeTemplateByPortId =
-        getComputeTypeAndComputeTemplateByPortId(origNodeTemplateId, serviceTemplateFileName,
-            consolidationData);
+            computeTypeAndComputeTemplateByPortId =
+            getComputeTypeAndComputeTemplateByPortId(origNodeTemplateId, serviceTemplateFileName,
+                    consolidationData);
     if (computeTypeAndComputeTemplateByPortId.isPresent()) {
       Pair<String, ComputeTemplateConsolidationData> computeIdToComputeData =
-          computeTypeAndComputeTemplateByPortId.get();
+              computeTypeAndComputeTemplateByPortId.get();
       return getNewPortNodeTemplateId(origNodeTemplateId, computeIdToComputeData.getKey(),
-          computeIdToComputeData.getValue());
+              computeIdToComputeData.getValue());
     }
 
     return null;
@@ -3349,15 +3354,15 @@ public class UnifiedCompositionService {
   getComputeTypeAndComputeTemplateByPortId(String portId, String serviceTemplateFileName,
                                            ConsolidationData consolidationData) {
     FileComputeConsolidationData fileComputeConsolidationData =
-        consolidationData.getComputeConsolidationData()
-            .getFileComputeConsolidationData(serviceTemplateFileName);
+            consolidationData.getComputeConsolidationData()
+                    .getFileComputeConsolidationData(serviceTemplateFileName);
     Set<String> computeTypes =
-        fileComputeConsolidationData.getAllComputeTypes();
+            fileComputeConsolidationData.getAllComputeTypes();
 
     for (String computeType : computeTypes) {
       Collection<ComputeTemplateConsolidationData> computeTemplateConsolidationDatas =
-          fileComputeConsolidationData.getTypeComputeConsolidationData(computeType)
-              .getAllComputeTemplateConsolidationData();
+              fileComputeConsolidationData.getTypeComputeConsolidationData(computeType)
+                      .getAllComputeTemplateConsolidationData();
 
       for (ComputeTemplateConsolidationData compute : computeTemplateConsolidationDatas) {
         if (ConsolidationDataUtil.isComputeReferenceToPortId(compute, portId)) {
@@ -3374,16 +3379,16 @@ public class UnifiedCompositionService {
                                        String serviceTemplateFileName,
                                        TranslationContext context) {
     UnifiedSubstitutionData unifiedSubstitutionData =
-        context.getUnifiedSubstitutionData().get(serviceTemplateFileName);
+            context.getUnifiedSubstitutionData().get(serviceTemplateFileName);
     if (Objects.isNull(unifiedSubstitutionData)) {
       return false;
     }
 
     UnifiedCompositionEntity actualUnifiedCompositionEntity =
-        unifiedSubstitutionData.getCleanedNodeTemplateCompositionEntity(id);
+            unifiedSubstitutionData.getCleanedNodeTemplateCompositionEntity(id);
 
     return actualUnifiedCompositionEntity == null ? false
-        : actualUnifiedCompositionEntity.equals(expectedUnifiedCompositionEntity);
+            : actualUnifiedCompositionEntity.equals(expectedUnifiedCompositionEntity);
   }
 
   private boolean isHeatStackGroup(String groupType) {
@@ -3398,14 +3403,14 @@ public class UnifiedCompositionService {
     //Get the input prefix to extract the property name from the input name
     String portType = ConsolidationDataUtil.getPortType(portNodeTemplateId);
     String portInputPrefix = getPropertyInputPrefix(
-        portNodeTemplateId, portType, portInputType, UnifiedCompositionEntity.PORT);
+            portNodeTemplateId, portType, portInputType, UnifiedCompositionEntity.PORT);
     //Get the property name from the input
     Optional<String> propertyName = getPropertyNameFromInput(inputName,
-        UnifiedCompositionEntity.PORT, computeType, portInputPrefix);
+            UnifiedCompositionEntity.PORT, computeType, portInputPrefix);
     //Get the property value from the node template
     if (propertyName.isPresent()) {
       NodeTemplate portNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
-          portNodeTemplateId);
+              portNodeTemplateId);
       if (Objects.nonNull(portNodeTemplate)) {
         return getPropertyValueFromNodeTemplate(propertyName.get(), portNodeTemplate);
       }
@@ -3414,14 +3419,14 @@ public class UnifiedCompositionService {
   }
 
   private Object getComputePropertyValue(
-      String inputName,
-      ServiceTemplate serviceTemplate,
-      ComputeTemplateConsolidationData computeTemplateConsolidationData) {
+          String inputName,
+          ServiceTemplate serviceTemplate,
+          ComputeTemplateConsolidationData computeTemplateConsolidationData) {
     NodeTemplate nodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
-        computeTemplateConsolidationData.getNodeTemplateId());
+            computeTemplateConsolidationData.getNodeTemplateId());
     String nodeType = getComputeTypeSuffix(nodeTemplate.getType());
     Optional<String> propertyName =
-        getPropertyNameFromInput(inputName, COMPUTE, nodeType, null);
+            getPropertyNameFromInput(inputName, COMPUTE, nodeType, null);
     if (propertyName.isPresent()) {
       return getPropertyValueFromNodeTemplate(propertyName.get(), nodeTemplate);
     }
@@ -3429,20 +3434,20 @@ public class UnifiedCompositionService {
   }
 
   private Object getSubInterfacePropertyValue(String inputName,
-                                      String subInterfaceTypeSuffix,
-                                      PropertyInputType propertyInputType,
-                                      ServiceTemplate serviceTemplate,
-                                      String subInterfaceNodeTemplateId) {
+                                              String subInterfaceTypeSuffix,
+                                              PropertyInputType propertyInputType,
+                                              ServiceTemplate serviceTemplate,
+                                              String subInterfaceNodeTemplateId) {
     //Get the input prefix to extract the property name from the input name
     String propertyInputPrefix = getPropertyInputPrefix(subInterfaceNodeTemplateId,
-        subInterfaceTypeSuffix, propertyInputType, UnifiedCompositionEntity.SUB_INTERFACE);
+            subInterfaceTypeSuffix, propertyInputType, UnifiedCompositionEntity.SUB_INTERFACE);
     //Get the property name from the input
     Optional<String> propertyName = getPropertyNameFromInput(inputName,
-        UnifiedCompositionEntity.SUB_INTERFACE, null, propertyInputPrefix);
+            UnifiedCompositionEntity.SUB_INTERFACE, null, propertyInputPrefix);
     //Get the property value from the node template
     if (propertyName.isPresent()) {
       NodeTemplate subInterfaceNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
-          subInterfaceNodeTemplateId);
+              subInterfaceNodeTemplateId);
       if (Objects.nonNull(subInterfaceNodeTemplate)) {
         return getPropertyValueFromNodeTemplate(propertyName.get(), subInterfaceNodeTemplate);
       }
@@ -3455,13 +3460,13 @@ public class UnifiedCompositionService {
                                                      EntityConsolidationData entity,
                                                      TranslationContext context) {
     NodeTemplate nodeTemplate =
-        getNodeTemplate(entity.getNodeTemplateId(), serviceTemplate, context);
+            getNodeTemplate(entity.getNodeTemplateId(), serviceTemplate, context);
 
     Object propertyValueFromNodeTemplate =
-        getPropertyValueFromNodeTemplate(identicalValuePropertyName, nodeTemplate);
+            getPropertyValueFromNodeTemplate(identicalValuePropertyName, nodeTemplate);
 
     return Objects.isNull(propertyValueFromNodeTemplate) ? Optional.empty()
-        : Optional.of(propertyValueFromNodeTemplate);
+            : Optional.of(propertyValueFromNodeTemplate);
   }
 
   private UnifiedCompositionEntity getInputCompositionEntity(String inputName) {
@@ -3473,7 +3478,7 @@ public class UnifiedCompositionService {
       } else if (inputType.equalsIgnoreCase(UnifiedCompositionEntity.PORT.getDisplayName())) {
         inputCompositionEntity = UnifiedCompositionEntity.PORT;
       } else if (inputType.equalsIgnoreCase(UnifiedCompositionEntity.SUB_INTERFACE
-          .getDisplayName())) {
+              .getDisplayName())) {
         inputCompositionEntity = UnifiedCompositionEntity.SUB_INTERFACE;
       }
     }
@@ -3481,14 +3486,14 @@ public class UnifiedCompositionService {
   }
 
   private Optional<String> getPropertyNameFromInput(
-      String inputName,
-      UnifiedCompositionEntity compositionEntity,
-      String entityType, String propertyInputPrefix) {
+          String inputName,
+          UnifiedCompositionEntity compositionEntity,
+          String entityType, String propertyInputPrefix) {
     String propertyName = null;
     switch (compositionEntity) {
       case COMPUTE:
         propertyName = inputName.substring(inputName.lastIndexOf(entityType)
-            + entityType.length() + 1);
+                + entityType.length() + 1);
         break;
       case PORT:
       case SUB_INTERFACE:
@@ -3519,7 +3524,7 @@ public class UnifiedCompositionService {
                                            UnifiedCompositionEntity unifiedCompositionEntity) {
 
     List<String> identicalValuePropertyList =
-        consolidationService.getPropertiesWithIdenticalVal(unifiedCompositionEntity);
+            consolidationService.getPropertiesWithIdenticalVal(unifiedCompositionEntity);
 
     StringBuilder builder = getPropertyValueStringBuilder(unifiedCompositionEntity);
     if (Objects.isNull(builder)) {
@@ -3528,8 +3533,8 @@ public class UnifiedCompositionService {
 
     boolean isMatchingProperty = Pattern.matches(builder.toString(), inputName);
     return isMatchingProperty
-        && isPropertyFromIdenticalValuesList(inputName, unifiedCompositionEntity,
-        identicalValuePropertyList);
+            && isPropertyFromIdenticalValuesList(inputName, unifiedCompositionEntity,
+            identicalValuePropertyList);
   }
 
   private boolean isPropertyFromIdenticalValuesList(String inputName,
@@ -3538,11 +3543,11 @@ public class UnifiedCompositionService {
     switch (unifiedCompositionEntity) {
       case COMPUTE:
         return identicalValuePropertyList.contains(getIdenticalValuePropertyName(inputName,
-            unifiedCompositionEntity).get());
+                unifiedCompositionEntity).get());
 
       case OTHER:
         return identicalValuePropertyList.contains(getIdenticalValuePropertyName(inputName,
-            unifiedCompositionEntity).get());
+                unifiedCompositionEntity).get());
 
       case PORT:
         return getPortPropertyNameFromInput(inputName, identicalValuePropertyList).isPresent();
@@ -3563,7 +3568,7 @@ public class UnifiedCompositionService {
   }
 
   private StringBuilder getPropertyValueStringBuilder(
-      UnifiedCompositionEntity unifiedCompositionEntity) {
+          UnifiedCompositionEntity unifiedCompositionEntity) {
 
     switch (unifiedCompositionEntity) {
       case COMPUTE:
@@ -3607,7 +3612,7 @@ public class UnifiedCompositionService {
 
   private Optional<String> getIdenticalValuePropertyName(String input,
                                                          UnifiedCompositionEntity
-                                                             unifiedCompositionEntity) {
+                                                                 unifiedCompositionEntity) {
     switch (unifiedCompositionEntity) {
       case COMPUTE:
         return Optional.of(input.split("_")[1]);
@@ -3617,7 +3622,7 @@ public class UnifiedCompositionService {
 
       case PORT:
         return getPortPropertyNameFromInput(input, consolidationService
-            .getPropertiesWithIdenticalVal(unifiedCompositionEntity));
+                .getPropertiesWithIdenticalVal(unifiedCompositionEntity));
 
       default:
         return Optional.empty();
@@ -3635,46 +3640,46 @@ public class UnifiedCompositionService {
   }
 
   private Map<String, UnifiedCompositionEntity> getAllConsolidationNodeTemplateIdAndType(
-      List<UnifiedCompositionData> unifiedCompositionDataList) {
+          List<UnifiedCompositionData> unifiedCompositionDataList) {
 
     Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType = new HashMap<>();
     for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
       ComputeTemplateConsolidationData computeTemplateConsolidationData =
-          unifiedCompositionData.getComputeTemplateConsolidationData();
+              unifiedCompositionData.getComputeTemplateConsolidationData();
       if (Objects.nonNull(computeTemplateConsolidationData)) {
         consolidationNodeTemplateIdAndType
-            .put(computeTemplateConsolidationData.getNodeTemplateId(),
-                COMPUTE);
+                .put(computeTemplateConsolidationData.getNodeTemplateId(),
+                        COMPUTE);
       }
       List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
-          getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
+              getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
       for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData :
-          subInterfaceTemplateConsolidationDataList) {
+              subInterfaceTemplateConsolidationDataList) {
         consolidationNodeTemplateIdAndType.put(subInterfaceTemplateConsolidationData.getNodeTemplateId(),
-            UnifiedCompositionEntity.SUB_INTERFACE);
+                UnifiedCompositionEntity.SUB_INTERFACE);
       }
       List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
-          getPortTemplateConsolidationDataList(unifiedCompositionData);
+              getPortTemplateConsolidationDataList(unifiedCompositionData);
       for (PortTemplateConsolidationData portTemplateConsolidationData :
-          portTemplateConsolidationDataList) {
+              portTemplateConsolidationDataList) {
         consolidationNodeTemplateIdAndType.put(portTemplateConsolidationData.getNodeTemplateId(),
-            UnifiedCompositionEntity.PORT);
+                UnifiedCompositionEntity.PORT);
       }
       NestedTemplateConsolidationData nestedTemplateConsolidationData =
-          unifiedCompositionData.getNestedTemplateConsolidationData();
+              unifiedCompositionData.getNestedTemplateConsolidationData();
       if (Objects.nonNull(nestedTemplateConsolidationData)) {
         consolidationNodeTemplateIdAndType
-            .put(nestedTemplateConsolidationData.getNodeTemplateId(),
-                UnifiedCompositionEntity.NESTED);
+                .put(nestedTemplateConsolidationData.getNodeTemplateId(),
+                        UnifiedCompositionEntity.NESTED);
       }
     }
     return consolidationNodeTemplateIdAndType;
   }
 
   private List<PortTemplateConsolidationData> getPortTemplateConsolidationDataList(
-      UnifiedCompositionData unifiedCompositionData) {
+          UnifiedCompositionData unifiedCompositionData) {
     return unifiedCompositionData.getPortTemplateConsolidationDataList() == null ? new
-        ArrayList<>() : unifiedCompositionData.getPortTemplateConsolidationDataList();
+            ArrayList<>() : unifiedCompositionData.getPortTemplateConsolidationDataList();
   }
 
   private enum PropertyInputType {
diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/test/resources/mock/services/heattotosca/fulltest/mixPatterns/connectivityBetweenPatterns/out/nested-no_vfc_v0.1ServiceTemplate.yaml b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/test/resources/mock/services/heattotosca/fulltest/mixPatterns/connectivityBetweenPatterns/out/nested-no_vfc_v0.1ServiceTemplate.yaml
index bbb3a4b6a0..c6ff74820a 100644
--- a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/test/resources/mock/services/heattotosca/fulltest/mixPatterns/connectivityBetweenPatterns/out/nested-no_vfc_v0.1ServiceTemplate.yaml
+++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/test/resources/mock/services/heattotosca/fulltest/mixPatterns/connectivityBetweenPatterns/out/nested-no_vfc_v0.1ServiceTemplate.yaml
@@ -112,7 +112,7 @@ topology_template:
       directives:
       - substitutable
       properties:
-        port_pcm_port_1_network_role_tag: cps
+        port_pcm_port_1_network_role_tag: oam
         port_pcm_port_0_fixed_ips:
         - ip_address:
             get_input: cps_net_ip
@@ -211,7 +211,7 @@ topology_template:
         port_pcm_port_2_mac_requirements:
           mac_count_required:
             is_required: false
-        port_pcm_port_3_network_role_tag: cps
+        port_pcm_port_3_network_role_tag: oam
         compute_pcma_server_config_drive:
         - true
         port_pcm_port_3_fixed_ips:
diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/test/resources/mock/services/heattotosca/fulltest/mixPatterns/oneAppearancePerPattern/out/nested-no_vfc_v0.1ServiceTemplate.yaml b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/test/resources/mock/services/heattotosca/fulltest/mixPatterns/oneAppearancePerPattern/out/nested-no_vfc_v0.1ServiceTemplate.yaml
index 3fbee137b8..bbc0a64921 100644
--- a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/test/resources/mock/services/heattotosca/fulltest/mixPatterns/oneAppearancePerPattern/out/nested-no_vfc_v0.1ServiceTemplate.yaml
+++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/test/resources/mock/services/heattotosca/fulltest/mixPatterns/oneAppearancePerPattern/out/nested-no_vfc_v0.1ServiceTemplate.yaml
@@ -108,7 +108,7 @@ topology_template:
       directives:
       - substitutable
       properties:
-        port_pcm_port_1_network_role_tag: cps
+        port_pcm_port_1_network_role_tag: oam
         port_pcm_port_0_fixed_ips:
         - ip_address:
             get_input: cps_net_ip
@@ -207,7 +207,7 @@ topology_template:
         port_pcm_port_2_mac_requirements:
           mac_count_required:
             is_required: false
-        port_pcm_port_3_network_role_tag: cps
+        port_pcm_port_3_network_role_tag: oam
         compute_pcma_server_config_drive:
         - true
         port_pcm_port_3_fixed_ips:
diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/test/resources/mock/services/heattotosca/fulltest/mixPatterns/twoAppearancePerPatternWithConnectivities/out/nested-no_vfc_v0.1ServiceTemplate.yaml b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/test/resources/mock/services/heattotosca/fulltest/mixPatterns/twoAppearancePerPatternWithConnectivities/out/nested-no_vfc_v0.1ServiceTemplate.yaml
index bbb3a4b6a0..c6ff74820a 100644
--- a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/test/resources/mock/services/heattotosca/fulltest/mixPatterns/twoAppearancePerPatternWithConnectivities/out/nested-no_vfc_v0.1ServiceTemplate.yaml
+++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/test/resources/mock/services/heattotosca/fulltest/mixPatterns/twoAppearancePerPatternWithConnectivities/out/nested-no_vfc_v0.1ServiceTemplate.yaml
@@ -112,7 +112,7 @@ topology_template:
       directives:
       - substitutable
       properties:
-        port_pcm_port_1_network_role_tag: cps
+        port_pcm_port_1_network_role_tag: oam
         port_pcm_port_0_fixed_ips:
         - ip_address:
             get_input: cps_net_ip
@@ -211,7 +211,7 @@ topology_template:
         port_pcm_port_2_mac_requirements:
           mac_count_required:
             is_required: false
-        port_pcm_port_3_network_role_tag: cps
+        port_pcm_port_3_network_role_tag: oam
         compute_pcma_server_config_drive:
         - true
         port_pcm_port_3_fixed_ips:
diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/test/resources/mock/services/heattotosca/fulltest/singleSubstitution/computewithtwosameporttypes2/out/MainServiceTemplate.yaml b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/test/resources/mock/services/heattotosca/fulltest/singleSubstitution/computewithtwosameporttypes2/out/MainServiceTemplate.yaml
index d30f10451e..195972522d 100644
--- a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/test/resources/mock/services/heattotosca/fulltest/singleSubstitution/computewithtwosameporttypes2/out/MainServiceTemplate.yaml
+++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/test/resources/mock/services/heattotosca/fulltest/singleSubstitution/computewithtwosameporttypes2/out/MainServiceTemplate.yaml
@@ -846,6 +846,9 @@ topology_template:
           get_input: pd_flavor_name
         vm_image_name:
           get_input: pd_image_name
+        port_pd_1_port_0_mac_requirements:
+          mac_count_required:
+            is_required: false
         port_pd_1_port_0_ip_requirements:
         - ip_version: 4
           ip_count_required:
@@ -857,6 +860,10 @@ topology_template:
             is_required: false
           floating_ip_count_required:
             is_required: false
+        port_pd_1_port_0_network_role_tag: oam
+        port_pd_2_port_1_mac_requirements:
+          mac_count_required:
+            is_required: false
         port_pd_2_port_1_ip_requirements:
         - ip_version: 4
           ip_count_required:
@@ -868,6 +875,7 @@ topology_template:
             is_required: false
           floating_ip_count_required:
             is_required: false
+        port_pd_2_port_1_network_role_tag: oam
         compute_pd_server_user_data_format:
         - RAW
         service_template_filter:
diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/test/resources/mock/services/heattotosca/fulltest/singleSubstitution/oneComputeSamePortTypesAndGetAttOut/out/MainServiceTemplate.yaml b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/test/resources/mock/services/heattotosca/fulltest/singleSubstitution/oneComputeSamePortTypesAndGetAttOut/out/MainServiceTemplate.yaml
index 039c1240e8..07a63f0802 100644
--- a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/test/resources/mock/services/heattotosca/fulltest/singleSubstitution/oneComputeSamePortTypesAndGetAttOut/out/MainServiceTemplate.yaml
+++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/test/resources/mock/services/heattotosca/fulltest/singleSubstitution/oneComputeSamePortTypesAndGetAttOut/out/MainServiceTemplate.yaml
@@ -137,6 +137,7 @@ topology_template:
             is_required: false
         vm_image_name:
           get_input: pd_image_name
+        port_pd01_port_1_network_role_tag: oam
         port_pd01_port_1_network:
         - get_input: oam_net_name
         compute_pd_server_user_data_format:
diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/test/resources/mock/services/heattotosca/unifiedComposition/createAbstractSubstitute/oneComputeMultiplePortsSameType/out/MainServiceTemplate.yaml b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/test/resources/mock/services/heattotosca/unifiedComposition/createAbstractSubstitute/oneComputeMultiplePortsSameType/out/MainServiceTemplate.yaml
index 9fa9796f84..6305a7cae6 100644
--- a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/test/resources/mock/services/heattotosca/unifiedComposition/createAbstractSubstitute/oneComputeMultiplePortsSameType/out/MainServiceTemplate.yaml
+++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/test/resources/mock/services/heattotosca/unifiedComposition/createAbstractSubstitute/oneComputeMultiplePortsSameType/out/MainServiceTemplate.yaml
@@ -169,7 +169,7 @@ topology_template:
         port_FSB1_Internal_1_network:
         - Internal1-net
         port_FSB1_Internal_2_mac_address:
-          get_input: fsb1-Internal1-mac
+          get_input: fsb1-Internal2-mac
         port_FSB1_Internal_2_network:
         - Internal2-net
         compute_FSB_metadata: