openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/UnifiedCompositionService.java

   1 /*
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.translator.services.heattotosca;
  22
  23 import org.apache.commons.collections.map.HashedMap;
  24 import org.apache.commons.collections4.CollectionUtils;
  25 import org.apache.commons.collections4.MapUtils;
  26 import org.apache.commons.lang3.StringUtils;
  27 import org.apache.commons.lang3.tuple.ImmutablePair;
  28 import org.apache.commons.lang3.tuple.Pair;
  29 import org.openecomp.config.api.Configuration;
  30 import org.openecomp.config.api.ConfigurationManager;
  31 import org.openecomp.core.utilities.CommonMethods;
  32 import org.openecomp.core.utilities.yaml.YamlUtil;
  33 import org.openecomp.sdc.datatypes.configuration.ImplementationConfiguration;
  34 import org.openecomp.sdc.heat.services.HeatConstants;
  35 import org.openecomp.sdc.logging.api.Logger;
  36 import org.openecomp.sdc.logging.api.LoggerFactory;
  37 import org.openecomp.sdc.logging.context.impl.MdcDataDebugMessage;
  38 import org.openecomp.sdc.tosca.datatypes.ToscaFunctions;
  39 import org.openecomp.sdc.tosca.datatypes.ToscaGroupType;
  40 import org.openecomp.sdc.tosca.datatypes.ToscaNodeType;
  41 import org.openecomp.sdc.tosca.datatypes.ToscaRelationshipType;
  42 import org.openecomp.sdc.tosca.datatypes.model.CapabilityDefinition;
  43 import org.openecomp.sdc.tosca.datatypes.model.Constraint;
  44 import org.openecomp.sdc.tosca.datatypes.model.EntrySchema;
  45 import org.openecomp.sdc.tosca.datatypes.model.GroupDefinition;
  46 import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate;
  47 import org.openecomp.sdc.tosca.datatypes.model.NodeType;
  48 import org.openecomp.sdc.tosca.datatypes.model.ParameterDefinition;
  49 import org.openecomp.sdc.tosca.datatypes.model.PropertyDefinition;
  50 import org.openecomp.sdc.tosca.datatypes.model.PropertyType;
  51 import org.openecomp.sdc.tosca.datatypes.model.RelationshipTemplate;
  52 import org.openecomp.sdc.tosca.datatypes.model.RequirementAssignment;
  53 import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate;
  54 import org.openecomp.sdc.tosca.datatypes.model.SubstitutionMapping;
  55 import org.openecomp.sdc.tosca.datatypes.model.heatextend.PropertyTypeExt;
  56 import org.openecomp.sdc.tosca.services.DataModelUtil;
  57 import org.openecomp.sdc.tosca.services.ToscaAnalyzerService;
  58 import org.openecomp.sdc.tosca.services.ToscaConstants;
  59 import org.openecomp.sdc.tosca.services.ToscaUtil;
  60 import org.openecomp.sdc.tosca.services.impl.ToscaAnalyzerServiceImpl;
  61 import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext;
  62 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionData;
  63 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionEntity;
  64 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionMode;
  65 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedSubstitutionData;
  66 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ComputeTemplateConsolidationData;
  67 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ConsolidationData;
  68 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.EntityConsolidationData;
  69 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.FileComputeConsolidationData;
  70 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.FilePortConsolidationData;
  71 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.GetAttrFuncData;
  72 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.NestedTemplateConsolidationData;
  73 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.PortTemplateConsolidationData;
  74 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.RequirementAssignmentData;
  75 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.TypeComputeConsolidationData;
  76
  77 import java.io.ByteArrayInputStream;
  78 import java.io.ByteArrayOutputStream;
  79 import java.io.IOException;
  80 import java.io.NotSerializableException;
  81 import java.io.ObjectInputStream;
  82 import java.io.ObjectOutputStream;
  83 import java.util.ArrayList;
  84 import java.util.Collection;
  85 import java.util.HashMap;
  86 import java.util.HashSet;
  87 import java.util.LinkedHashMap;
  88 import java.util.List;
  89 import java.util.Map;
  90 import java.util.Objects;
  91 import java.util.Optional;
  92 import java.util.Set;
  93 import java.util.regex.Pattern;
  94
  95 import static org.openecomp.sdc.translator.services.heattotosca.Constants.ABSTRACT_NODE_TEMPLATE_ID_PREFIX;
  96 import static org.openecomp.sdc.translator.services.heattotosca.Constants.COMPUTE_IDENTICAL_VALUE_PROPERTY_PREFIX;
  97 import static org.openecomp.sdc.translator.services.heattotosca.Constants.COMPUTE_IDENTICAL_VALUE_PROPERTY_SUFFIX;
  98 import static org.openecomp.sdc.translator.services.heattotosca.Constants.PORT_IDENTICAL_VALUE_PROPERTY_PREFIX;
  99
 100 public class UnifiedCompositionService {
 101
 102   protected static Logger logger =
 103       (Logger) LoggerFactory.getLogger(UnifiedCompositionService.class);
 104   protected static MdcDataDebugMessage mdcDataDebugMessage = new MdcDataDebugMessage();
 105   private static Map<String, ImplementationConfiguration> unifiedCompositionImplMap;
 106
 107   static {
 108     Configuration config = ConfigurationManager.lookup();
 109     unifiedCompositionImplMap =
 110         config.populateMap(ConfigConstants.MANDATORY_UNIFIED_MODEL_NAMESPACE,
 111             ConfigConstants.UNIFIED_COMPOSITION_IMPL_KEY, ImplementationConfiguration.class);
 112
 113   }
 114
 115   private ConsolidationService consolidationService = new ConsolidationService();
 116
 117   private static List<EntityConsolidationData> getPortConsolidationDataList(
 118       Set<String> portIds,
 119       List<UnifiedCompositionData> unifiedCompositionDataList) {
 120     List<EntityConsolidationData> portConsolidationDataList = new ArrayList<>();
 121     for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
 122       for (PortTemplateConsolidationData portTemplateConsolidationData : unifiedCompositionData
 123           .getPortTemplateConsolidationDataList()) {
 124         if (portIds.contains(portTemplateConsolidationData.getNodeTemplateId())) {
 125           portConsolidationDataList.add(portTemplateConsolidationData);
 126         }
 127       }
 128     }
 129     return portConsolidationDataList;
 130   }
 131
 132   /**
 133    * Create unified composition.
 134    *
 135    * @param serviceTemplate            the service template
 136    * @param nestedServiceTemplate      the nested service template
 137    * @param unifiedCompositionDataList the unified composition data list. In case no consolidation,
 138    *                                   one entry will be in this list, in case of having
 139    *                                   consolidation, all entries in the list are the once which
 140    *                                   need to be consolidated.
 141    * @param mode                       the mode
 142    * @param context                    the context
 143    */
 144   public void createUnifiedComposition(ServiceTemplate serviceTemplate,
 145                                        ServiceTemplate nestedServiceTemplate,
 146                                        List<UnifiedCompositionData> unifiedCompositionDataList,
 147                                        UnifiedCompositionMode mode, TranslationContext context) {
 148     mdcDataDebugMessage.debugEntryMessage(null, null);
 149     Optional<UnifiedComposition> unifiedCompositionInstance = getUnifiedCompositionInstance(mode);
 150     if (!unifiedCompositionInstance.isPresent()) {
 151       return;
 152     }
 153     unifiedCompositionInstance.get()
 154         .createUnifiedComposition(serviceTemplate, nestedServiceTemplate,
 155             unifiedCompositionDataList, context);
 156     mdcDataDebugMessage.debugExitMessage(null, null);
 157   }
 158
 159   /**
 160    * Create unified substitution service template according to the input service template, based on
 161    * the unified composition data.
 162    *
 163    * @param serviceTemplate            the service template
 164    * @param unifiedCompositionDataList the unified composition data list. In case no consolidation,
 165    *                                   one entry will be in this list, in case of having
 166    *                                   consolidation, all entries in the list are the once which
 167    *                                   need to be consolidated.
 168    * @param context                    the translation context
 169    * @return the substitution service template
 170    */
 171   public Optional<ServiceTemplate> createUnifiedSubstitutionServiceTemplate(
 172       ServiceTemplate serviceTemplate, List<UnifiedCompositionData> unifiedCompositionDataList,
 173       TranslationContext context, Integer index) {
 174     if (CollectionUtils.isEmpty(unifiedCompositionDataList)) {
 175       return Optional.empty();
 176     }
 177     UnifiedCompositionData unifiedCompositionData = unifiedCompositionDataList.get(0);
 178     String templateName =
 179         getTemplateName(serviceTemplate, unifiedCompositionData, index);
 180     ServiceTemplate substitutionServiceTemplate =
 181         HeatToToscaUtil.createInitSubstitutionServiceTemplate(templateName);
 182
 183     createIndexInputParameter(substitutionServiceTemplate);
 184
 185     String computeNodeType =
 186         handleCompute(serviceTemplate, substitutionServiceTemplate, unifiedCompositionDataList,
 187             context);
 188     handlePorts(serviceTemplate, substitutionServiceTemplate, unifiedCompositionDataList,
 189         computeNodeType, context);
 190     createOutputParameters(serviceTemplate, substitutionServiceTemplate, unifiedCompositionDataList,
 191         computeNodeType);
 192     NodeType substitutionGlobalNodeType =
 193         handleSubstitutionGlobalNodeType(serviceTemplate, substitutionServiceTemplate,
 194             context, unifiedCompositionData, index);
 195
 196     HeatToToscaUtil.handleSubstitutionMapping(context,
 197         getSubstitutionNodeTypeId(serviceTemplate, unifiedCompositionData, index),
 198         substitutionServiceTemplate, substitutionGlobalNodeType);
 199
 200     context.getTranslatedServiceTemplates().put(templateName, substitutionServiceTemplate);
 201     return Optional.of(substitutionServiceTemplate);
 202   }
 203
 204   /**
 205    * Create abstract substitute node template that can be substituted by the input
 206    * substitutionServiceTemplate.
 207    *
 208    * @param serviceTemplate             the service template
 209    * @param substitutionServiceTemplate the subtitution service template
 210    * @param unifiedCompositionDataList  the unified composition data list. In case no consolidation,
 211    *                                    one entry will be in this list, in case of having
 212    *                                    consolidation, all entries in the list are the once which
 213    *                                    need to be consolidated.
 214    * @param context                     the translation context
 215    * @return the abstract substitute node template id
 216    */
 217   public String createAbstractSubstituteNodeTemplate(
 218       ServiceTemplate serviceTemplate,
 219       ServiceTemplate substitutionServiceTemplate,
 220       List<UnifiedCompositionData> unifiedCompositionDataList,
 221       TranslationContext context,
 222       Integer index) {
 223
 224     NodeTemplate substitutionNodeTemplate = new NodeTemplate();
 225     List<String> directiveList = new ArrayList<>();
 226     directiveList.add(ToscaConstants.NODE_TEMPLATE_DIRECTIVE_SUBSTITUTABLE);
 227     substitutionNodeTemplate.setDirectives(directiveList);
 228     String substituteNodeTemplateType =
 229         getSubstitutionNodeTypeId(serviceTemplate, unifiedCompositionDataList.get(0), index);
 230     substitutionNodeTemplate.setType(substituteNodeTemplateType);
 231     Optional<Map<String, Object>> abstractSubstitutionProperties =
 232         createAbstractSubstitutionProperties(serviceTemplate,
 233             substitutionServiceTemplate, unifiedCompositionDataList, context);
 234     abstractSubstitutionProperties.ifPresent(substitutionNodeTemplate::setProperties);
 235
 236     //Add substitution filtering property
 237     String substitutionServiceTemplateName = ToscaUtil.getServiceTemplateFileName(
 238         substitutionServiceTemplate);
 239     int count = unifiedCompositionDataList.size();
 240     addSubstitutionFilteringProperty(substitutionServiceTemplateName, substitutionNodeTemplate,
 241         count);
 242     //Add index_value property
 243     addIndexValueProperty(substitutionNodeTemplate);
 244     String substituteNodeTemplateId =
 245         getSubstituteNodeTemplateId(serviceTemplate, unifiedCompositionDataList.get(0), index);
 246     //Add node template id and related abstract node template id in context
 247     addUnifiedSubstitionData(context, serviceTemplate, unifiedCompositionDataList,
 248         substituteNodeTemplateId);
 249     DataModelUtil
 250         .addNodeTemplate(serviceTemplate, substituteNodeTemplateId, substitutionNodeTemplate);
 251     return substituteNodeTemplateId;
 252
 253   }
 254
 255   /**
 256    * Update the connectivity from/to the "moved" nodes from the original service template to the new
 257    * substitution service template.
 258    *
 259    * @param serviceTemplate            the service template
 260    * @param unifiedCompositionDataList the unified composition data list. In case no consolidation,
 261    *                                   one entry will be in this list, in case of having
 262    *                                   consolidation, all entries in the list are the once which
 263    *                                   need to be consolidated.
 264    * @param context                    the translation context
 265    */
 266   public void updateCompositionConnectivity(ServiceTemplate serviceTemplate,
 267                                             List<UnifiedCompositionData> unifiedCompositionDataList,
 268                                             TranslationContext context) {
 269     updOutputParamGetAttrInConnectivity(serviceTemplate, unifiedCompositionDataList, context);
 270     updNodesGetAttrInConnectivity(serviceTemplate, unifiedCompositionDataList, context);
 271     updNodesConnectedOutConnectivity(serviceTemplate, unifiedCompositionDataList, context);
 272     updNodesConnectedInConnectivity(serviceTemplate, unifiedCompositionDataList, context);
 273     updVolumeConnectivity(serviceTemplate, unifiedCompositionDataList, context);
 274     updGroupsConnectivity(serviceTemplate, unifiedCompositionDataList, context);
 275   }
 276
 277   /**
 278    * Delete the "moved" nodes from the original service template to the new substitution service
 279    * template.
 280    *
 281    * @param serviceTemplate            the service template
 282    * @param unifiedCompositionDataList the unified composition data list. In case no consolidation,
 283    *                                   one entry will be in this list, in case of having
 284    *                                   consolidation, all entries in the list are the once which
 285    *                                   need to be consolidated.
 286    * @param context                    the translation context
 287    */
 288   public void cleanUnifiedCompositionEntities(
 289       ServiceTemplate serviceTemplate,
 290       List<UnifiedCompositionData> unifiedCompositionDataList,
 291       TranslationContext context) {
 292     for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
 293       ComputeTemplateConsolidationData computeTemplateConsolidationData =
 294           unifiedCompositionData.getComputeTemplateConsolidationData();
 295       cleanServiceTemplate(serviceTemplate, computeTemplateConsolidationData, context);
 296
 297       List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
 298           getPortTemplateConsolidationDataList(unifiedCompositionData);
 299       for (PortTemplateConsolidationData portTemplateConsolidationData :
 300           portTemplateConsolidationDataList) {
 301         cleanServiceTemplate(serviceTemplate, portTemplateConsolidationData, context);
 302       }
 303     }
 304
 305   }
 306
 307   public void cleanNodeTypes(ServiceTemplate serviceTemplate,
 308                              List<UnifiedCompositionData> unifiedCompositionDataList,
 309                              TranslationContext context) {
 310     for (UnifiedCompositionData unifiedData : unifiedCompositionDataList) {
 311       removeCleanedNodeType(
 312           unifiedData.getComputeTemplateConsolidationData().getNodeTemplateId(), serviceTemplate,
 313           context);
 314     }
 315
 316     if (MapUtils.isEmpty(serviceTemplate.getNode_types())) {
 317       serviceTemplate.setNode_types(null);
 318     }
 319   }
 320
 321   /**
 322    * Update unified abstract nodes connectivity.
 323    *
 324    * @param serviceTemplate the service template
 325    * @param context         the context
 326    */
 327   public void updateUnifiedAbstractNodesConnectivity(ServiceTemplate serviceTemplate,
 328                                                      TranslationContext context) {
 329
 330
 331     String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
 332     UnifiedSubstitutionData unifiedSubstitutionData = context.getUnifiedSubstitutionData()
 333         .get(serviceTemplateFileName);
 334
 335     if (Objects.nonNull(unifiedSubstitutionData)) {
 336       //Handle get attribute in connectivity for abstarct node to abstract node templates
 337       Set<String> abstractNodeIds =
 338           new HashSet<>(unifiedSubstitutionData.getAllRelatedAbstractNodeIds());
 339       handleGetAttrInConnectivity(serviceTemplate, abstractNodeIds, context);
 340       //Handle get attribute in connectivity for abstract node templates to nested node template
 341       Set<String> nestedNodeIds =
 342           new HashSet<>(unifiedSubstitutionData.getAllUnifiedNestedNodeTemplateIds());
 343       handleGetAttrInConnectivity(serviceTemplate, nestedNodeIds, context);
 344     }
 345   }
 346
 347   public void handleUnifiedNestedDefinition(ServiceTemplate mainServiceTemplate,
 348                                             ServiceTemplate nestedServiceTemplate,
 349                                             List<UnifiedCompositionData> unifiedCompositionDataList,
 350                                             TranslationContext context) {
 351     handleUnifiedNestedNodeType(mainServiceTemplate, nestedServiceTemplate, context);
 352     updateUnifiedNestedTemplates(mainServiceTemplate, nestedServiceTemplate,
 353         unifiedCompositionDataList, context);
 354   }
 355
 356   private void handleGetAttrInConnectivity(ServiceTemplate serviceTemplate,
 357                                            Set<String> unifiedNodeIds,
 358                                            TranslationContext context) {
 359     Map<String, NodeTemplate> nodeTemplates =
 360         serviceTemplate.getTopology_template().getNode_templates();
 361     String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
 362     for (String unifiedNodeId : unifiedNodeIds) {
 363       NodeTemplate nodeTemplate = nodeTemplates.get(unifiedNodeId);
 364       handleGetAttrInAbstractNodeTemplate(serviceTemplate, context, serviceTemplateFileName,
 365           nodeTemplate);
 366     }
 367   }
 368
 369   private void handleUnifiedNestedNodeType(ServiceTemplate mainServiceTemplate,
 370                                            ServiceTemplate nestedServiceTemplate,
 371                                            TranslationContext context) {
 372
 373
 374     SubstitutionMapping substitutionMappings =
 375         nestedServiceTemplate.getTopology_template().getSubstitution_mappings();
 376     String nodeTypeId = substitutionMappings.getNode_type();
 377
 378     Optional<String> newNestedNodeTypeId =
 379         getNewNestedNodeTypeId(mainServiceTemplate, nestedServiceTemplate, context);
 380
 381     if (isNestedServiceTemplateWasHandled(mainServiceTemplate, nestedServiceTemplate, context,
 382         newNestedNodeTypeId)) {
 383       context.updateHandledComputeType(
 384           ToscaUtil.getServiceTemplateFileName(mainServiceTemplate),
 385           ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate),
 386           newNestedNodeTypeId.get());
 387       return;
 388     }
 389
 390     ServiceTemplate globalSubstitutionServiceTemplate =
 391         context.getGlobalSubstitutionServiceTemplate();
 392
 393     newNestedNodeTypeId.ifPresent(
 394         newNestedNodeTypeIdVal -> handleNestedNodeType(nodeTypeId, newNestedNodeTypeIdVal,
 395             nestedServiceTemplate, mainServiceTemplate, globalSubstitutionServiceTemplate,
 396             context));
 397
 398   }
 399
 400   private boolean isNestedServiceTemplateWasHandled(ServiceTemplate mainServiceTemplate,
 401                                                     ServiceTemplate nestedServiceTemplate,
 402                                                     TranslationContext context,
 403                                                     Optional<String> newNestedNodeTypeId) {
 404     return newNestedNodeTypeId.isPresent()
 405         && context.isNestedServiceTemplateWasHandled(
 406         ToscaUtil.getServiceTemplateFileName(mainServiceTemplate),
 407         ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate));
 408   }
 409
 410   private void handleNestedNodeType(String nodeTypeId, String newNestedNodeTypeId,
 411                                     ServiceTemplate nestedServiceTemplate,
 412                                     ServiceTemplate mainServiceTemplate,
 413                                     ServiceTemplate globalSubstitutionServiceTemplate,
 414                                     TranslationContext context) {
 415     updateNestedServiceTemplate(nestedServiceTemplate, context);
 416     updateNestedNodeType(nodeTypeId, newNestedNodeTypeId, nestedServiceTemplate,
 417         mainServiceTemplate,
 418         globalSubstitutionServiceTemplate, context);
 419
 420
 421   }
 422
 423   private void updateNestedServiceTemplate(ServiceTemplate nestedServiceTemplate,
 424                                            TranslationContext context) {
 425     enrichPortProperties(nestedServiceTemplate, context);
 426   }
 427
 428   private void enrichPortProperties(ServiceTemplate nestedServiceTemplate,
 429                                     TranslationContext context) {
 430     String nestedServiceTemplateFileName =
 431         ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate);
 432     FilePortConsolidationData filePortConsolidationData =
 433         context.getConsolidationData().getPortConsolidationData().getFilePortConsolidationData
 434             (nestedServiceTemplateFileName);
 435
 436     if (Objects.nonNull(filePortConsolidationData)) {
 437       Set<String> portNodeTemplateIds = filePortConsolidationData.getAllPortNodeTemplateIds();
 438       if (Objects.nonNull(portNodeTemplateIds)) {
 439         for (String portNodeTemplateId : portNodeTemplateIds) {
 440           NodeTemplate portNodeTemplate = DataModelUtil.getNodeTemplate(nestedServiceTemplate,
 441               portNodeTemplateId);
 442           List<EntityConsolidationData> portEntityConsolidationDataList = new ArrayList<>();
 443           portEntityConsolidationDataList.add(filePortConsolidationData
 444               .getPortTemplateConsolidationData(portNodeTemplateId));
 445
 446           handleNodeTypeProperties(nestedServiceTemplate,
 447               portEntityConsolidationDataList, portNodeTemplate, UnifiedCompositionEntity.Port,
 448               null, context);
 449         }
 450       }
 451     }
 452   }
 453
 454   private void updateNestedNodeType(String nodeTypeId, String newNestedNodeTypeId,
 455                                     ServiceTemplate nestedServiceTemplate,
 456                                     ServiceTemplate mainServiceTemplate,
 457                                     ServiceTemplate globalSubstitutionServiceTemplate,
 458                                     TranslationContext context) {
 459     String indexedNewNestedNodeTypeId =
 460         updateNodeTypeId(nodeTypeId, newNestedNodeTypeId, nestedServiceTemplate,
 461             mainServiceTemplate,
 462             globalSubstitutionServiceTemplate, context);
 463
 464     updateNodeTypeProperties(nestedServiceTemplate, globalSubstitutionServiceTemplate,
 465         indexedNewNestedNodeTypeId);
 466   }
 467
 468   private void updateNodeTypeProperties(ServiceTemplate nestedServiceTemplate,
 469                                         ServiceTemplate globalSubstitutionServiceTemplate,
 470                                         String nodeTypeId) {
 471     ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
 472     Map<String, PropertyDefinition> nodeTypePropertiesDefinition =
 473         toscaAnalyzerService.manageSubstitutionNodeTypeProperties(nestedServiceTemplate);
 474     NodeType nestedNodeType =
 475         DataModelUtil.getNodeType(globalSubstitutionServiceTemplate, nodeTypeId);
 476     nestedNodeType.setProperties(nodeTypePropertiesDefinition);
 477   }
 478
 479   private String updateNodeTypeId(String nodeTypeId, String newNestedNodeTypeId,
 480                                   ServiceTemplate nestedServiceTemplate,
 481                                   ServiceTemplate mainServiceTemplate,
 482                                   ServiceTemplate globalSubstitutionServiceTemplate,
 483                                   TranslationContext context) {
 484     context.addNestedFileToUsedNestedComputeType(
 485         ToscaUtil.getServiceTemplateFileName(mainServiceTemplate),
 486         ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate),
 487         newNestedNodeTypeId);
 488     String indexedNewNestedNodeTypeId =
 489         handleNestedNodeTypeInGlobalSubstitutionTemplate(nodeTypeId, newNestedNodeTypeId,
 490             mainServiceTemplate, globalSubstitutionServiceTemplate, context);
 491
 492     handleSubstitutionMappingInNestedServiceTemplate(indexedNewNestedNodeTypeId,
 493         nestedServiceTemplate);
 494
 495     context
 496         .updateHandledComputeType(
 497             ToscaUtil.getServiceTemplateFileName(mainServiceTemplate),
 498             ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate),
 499             newNestedNodeTypeId);
 500     return indexedNewNestedNodeTypeId;
 501   }
 502
 503   private String handleNestedNodeTypeInGlobalSubstitutionTemplate(String nodeTypeId,
 504                                                                   String newNestedNodeTypeId,
 505                                                                   ServiceTemplate mainServiceTemplate,
 506                                                                   ServiceTemplate globalSubstitutionServiceTemplate,
 507                                                                   TranslationContext context) {
 508     String indexedNodeType =
 509         getIndexedGlobalNodeTypeId(newNestedNodeTypeId, mainServiceTemplate, context);
 510     handleNestedNodeTypesInGlobalSubstituteServiceTemplate(nodeTypeId, indexedNodeType,
 511         globalSubstitutionServiceTemplate, context);
 512     return indexedNodeType;
 513   }
 514
 515   private String getIndexedGlobalNodeTypeId(String newNestedNodeTypeId,
 516                                             ServiceTemplate mainServiceTemplate,
 517                                             TranslationContext context) {
 518     int globalNodeTypeIndex =
 519         context.getGlobalNodeTypeIndex(ToscaUtil.getServiceTemplateFileName(mainServiceTemplate),
 520             newNestedNodeTypeId);
 521     return globalNodeTypeIndex > 0 ?
 522         newNestedNodeTypeId + "_" + String.valueOf(globalNodeTypeIndex) : newNestedNodeTypeId;
 523   }
 524
 525   private void updateUnifiedNestedTemplates(ServiceTemplate mainServiceTemplate,
 526                                             ServiceTemplate nestedServiceTemplate,
 527                                             List<UnifiedCompositionData> unifiedCompositionDataList,
 528                                             TranslationContext context) {
 529
 530     for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
 531       NestedTemplateConsolidationData nestedTemplateConsolidationData =
 532           unifiedCompositionData.getNestedTemplateConsolidationData();
 533       if (Objects.isNull(nestedTemplateConsolidationData)) {
 534         continue;
 535       }
 536       handleNestedNodeTemplateInMainServiceTemplate(
 537           nestedTemplateConsolidationData.getNodeTemplateId(), mainServiceTemplate,
 538           nestedServiceTemplate, context);
 539     }
 540   }
 541
 542   /**
 543    * Update connectivity for unified nested patterns.
 544    *
 545    * @param serviceTemplate            the service template
 546    * @param nestedServiceTemplate      the nested service template
 547    * @param unifiedCompositionDataList the unified composition data list
 548    * @param context                    the context
 549    */
 550   public void updateUnifiedNestedConnectivity(ServiceTemplate serviceTemplate,
 551                                               ServiceTemplate nestedServiceTemplate,
 552                                               List<UnifiedCompositionData>
 553                                                   unifiedCompositionDataList,
 554                                               TranslationContext context) {
 555
 556     updNestedCompositionNodesConnectedInConnectivity(serviceTemplate, unifiedCompositionDataList,
 557         context);
 558     updNestedCompositionNodesGetAttrInConnectivity(serviceTemplate, unifiedCompositionDataList,
 559         context);
 560     updNestedCompositionOutputParamGetAttrInConnectivity(serviceTemplate,
 561         unifiedCompositionDataList, context);
 562   }
 563
 564
 565   /**
 566    * Clean unified nested entities. Update the heat stack group with the new node template ids.
 567    *
 568    * @param serviceTemplate            the service template
 569    * @param unifiedCompositionDataList the unified composition data list
 570    * @param context                    the context
 571    */
 572   public void cleanUnifiedNestedEntities(ServiceTemplate serviceTemplate,
 573                                          List<UnifiedCompositionData> unifiedCompositionDataList,
 574                                          TranslationContext context) {
 575     EntityConsolidationData entityConsolidationData = unifiedCompositionDataList.get(0)
 576         .getNestedTemplateConsolidationData();
 577     updateHeatStackGroupNestedComposition(serviceTemplate, entityConsolidationData, context);
 578
 579   }
 580
 581   protected void updNodesConnectedOutConnectivity(ServiceTemplate serviceTemplate,
 582                                                   List<UnifiedCompositionData>
 583                                                       unifiedCompositionDataList,
 584                                                   TranslationContext context) {
 585     for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
 586       ComputeTemplateConsolidationData computeTemplateConsolidationData = unifiedCompositionData
 587           .getComputeTemplateConsolidationData();
 588       //Add requirements in the abstract node template for nodes connected out for computes
 589       String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
 590           computeTemplateConsolidationData.getNodeTemplateId());
 591       Map<String, List<RequirementAssignmentData>> computeNodesConnectedOut =
 592           computeTemplateConsolidationData.getNodesConnectedOut();
 593       if (computeNodesConnectedOut != null) {
 594         updateRequirementInAbstractNodeTemplate(serviceTemplate, computeTemplateConsolidationData,
 595             newComputeNodeTemplateId, computeNodesConnectedOut, context);
 596       }
 597       String computeType = getComputeTypeSuffix(serviceTemplate, computeTemplateConsolidationData
 598           .getNodeTemplateId());
 599       //Add requirements in the abstract node template for nodes connected out for ports
 600       List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
 601           getPortTemplateConsolidationDataList(unifiedCompositionData);
 602       for (PortTemplateConsolidationData portTemplateConsolidationData :
 603           portTemplateConsolidationDataList) {
 604         String newPortNodeTemplateId = getNewPortNodeTemplateId(portTemplateConsolidationData
 605             .getNodeTemplateId(), computeType, computeTemplateConsolidationData);
 606         Map<String, List<RequirementAssignmentData>> portNodesConnectedOut =
 607             portTemplateConsolidationData.getNodesConnectedOut();
 608         if (portNodesConnectedOut != null) {
 609           updateRequirementInAbstractNodeTemplate(serviceTemplate, portTemplateConsolidationData,
 610               newPortNodeTemplateId, portNodesConnectedOut, context);
 611         }
 612       }
 613     }
 614   }
 615
 616   protected void updNodesConnectedInConnectivity(ServiceTemplate serviceTemplate,
 617                                                  List<UnifiedCompositionData>
 618                                                      unifiedCompositionDataList,
 619                                                  TranslationContext context) {
 620     for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
 621       ComputeTemplateConsolidationData computeTemplateConsolidationData = unifiedCompositionData
 622           .getComputeTemplateConsolidationData();
 623       //Update requirements in the node template which pointing to the computes
 624       String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
 625           computeTemplateConsolidationData.getNodeTemplateId());
 626       updNodesConnectedInConnectivity(serviceTemplate, computeTemplateConsolidationData,
 627           newComputeNodeTemplateId, context, false);
 628
 629       String computeType = getComputeTypeSuffix(serviceTemplate, computeTemplateConsolidationData
 630           .getNodeTemplateId());
 631       //Update requirements in the node template which pointing to the ports
 632       List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
 633           getPortTemplateConsolidationDataList(unifiedCompositionData);
 634       for (PortTemplateConsolidationData portTemplateConsolidationData :
 635           portTemplateConsolidationDataList) {
 636         String newPortNodeTemplateId = getNewPortNodeTemplateId(portTemplateConsolidationData
 637             .getNodeTemplateId(), computeType, computeTemplateConsolidationData);
 638         updNodesConnectedInConnectivity(serviceTemplate, portTemplateConsolidationData,
 639             newPortNodeTemplateId, context, false);
 640       }
 641     }
 642   }
 643
 644   private void updNodesConnectedInConnectivity(ServiceTemplate serviceTemplate,
 645                                                EntityConsolidationData entityConsolidationData,
 646                                                String newNodeTemplateId,
 647                                                TranslationContext context,
 648                                                boolean isNested) {
 649     Map<String, List<RequirementAssignmentData>> nodesConnectedIn =
 650         entityConsolidationData.getNodesConnectedIn();
 651     if (nodesConnectedIn == null) {
 652       //No nodes connected in info
 653       return;
 654     }
 655     for (Map.Entry<String, List<RequirementAssignmentData>> entry : nodesConnectedIn
 656         .entrySet()) {
 657       List<RequirementAssignmentData> requirementAssignmentDataList = entry.getValue();
 658       for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList) {
 659         RequirementAssignment requirementAssignment = requirementAssignmentData
 660             .getRequirementAssignment();
 661         if (!requirementAssignment.getNode().equals(entityConsolidationData
 662             .getNodeTemplateId())) {
 663           //The requirement assignment target node should be the one which we are handling in the
 664           //consolidation object
 665           continue;
 666         }
 667         //Update the requirement assignment object in the original node template
 668         if (isNested) {
 669           updateRequirementForNestedCompositionNodesConnectedIn(serviceTemplate,
 670               requirementAssignmentData, entityConsolidationData, newNodeTemplateId, context);
 671         } else {
 672           updateRequirementForNodesConnectedIn(serviceTemplate, requirementAssignmentData,
 673               entityConsolidationData, entry.getKey(), newNodeTemplateId, context);
 674         }
 675
 676       }
 677     }
 678   }
 679
 680   protected void updNestedCompositionNodesConnectedInConnectivity(ServiceTemplate serviceTemplate,
 681                                                                   List<UnifiedCompositionData>
 682                                                                       unifiedCompositionDataList,
 683                                                                   TranslationContext context) {
 684     for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
 685       NestedTemplateConsolidationData nestedTemplateConsolidationData = unifiedCompositionData
 686           .getNestedTemplateConsolidationData();
 687       //Update requirements in the node template which pointing to the nested nodes
 688       String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
 689       Optional<String> newNestedNodeTemplateId = context.getUnifiedNestedNodeTemplateId(
 690           serviceTemplateFileName, nestedTemplateConsolidationData.getNodeTemplateId());
 691       newNestedNodeTemplateId.ifPresent(
 692           newNestedNodeTemplateIdVal -> updNodesConnectedInConnectivity(serviceTemplate,
 693               nestedTemplateConsolidationData,
 694               newNestedNodeTemplateIdVal, context, true));
 695     }
 696   }
 697
 698   protected void updVolumeConnectivity(ServiceTemplate serviceTemplate,
 699                                        List<UnifiedCompositionData>
 700                                            unifiedCompositionDataList,
 701                                        TranslationContext context) {
 702     for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
 703       ComputeTemplateConsolidationData computeTemplateConsolidationData = unifiedCompositionData
 704           .getComputeTemplateConsolidationData();
 705       //Add requirements in the abstract node template for compute volumes
 706       String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
 707           computeTemplateConsolidationData.getNodeTemplateId());
 708       Map<String, List<RequirementAssignmentData>> computeVolumes =
 709           computeTemplateConsolidationData.getVolumes();
 710       if (computeVolumes != null) {
 711         updateRequirementInAbstractNodeTemplate(serviceTemplate, computeTemplateConsolidationData,
 712             newComputeNodeTemplateId, computeVolumes, context);
 713       }
 714     }
 715   }
 716
 717   protected void updGroupsConnectivity(ServiceTemplate serviceTemplate,
 718                                        List<UnifiedCompositionData>
 719                                            unifiedCompositionDataList,
 720                                        TranslationContext context) {
 721     for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
 722       ComputeTemplateConsolidationData computeTemplateConsolidationData = unifiedCompositionData
 723           .getComputeTemplateConsolidationData();
 724       //Add requirements in the abstract node template for nodes connected in for computes
 725       String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
 726           computeTemplateConsolidationData.getNodeTemplateId());
 727       updGroupsConnectivity(serviceTemplate, computeTemplateConsolidationData, context);
 728
 729       String computeType = getComputeTypeSuffix(serviceTemplate, computeTemplateConsolidationData
 730           .getNodeTemplateId());
 731       //Add requirements in the abstract node template for nodes connected in for ports
 732       List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
 733           getPortTemplateConsolidationDataList(unifiedCompositionData);
 734       for (PortTemplateConsolidationData portTemplateConsolidationData :
 735           portTemplateConsolidationDataList) {
 736         String newPortNodeTemplateId = getNewPortNodeTemplateId(portTemplateConsolidationData
 737             .getNodeTemplateId(), computeType, computeTemplateConsolidationData);
 738         updGroupsConnectivity(serviceTemplate, portTemplateConsolidationData, context);
 739       }
 740     }
 741   }
 742
 743   private void updGroupsConnectivity(ServiceTemplate serviceTemplate, EntityConsolidationData
 744       entityConsolidationData, TranslationContext context) {
 745     List<String> groupIds = entityConsolidationData.getGroupIds();
 746     if (groupIds == null) {
 747       return;
 748     }
 749     String oldNodeTemplateId = entityConsolidationData.getNodeTemplateId();
 750     String abstractNodeTemplateId = context.getUnifiedAbstractNodeTemplateId(
 751         serviceTemplate, entityConsolidationData.getNodeTemplateId());
 752     Map<String, GroupDefinition> groups = serviceTemplate.getTopology_template().getGroups();
 753     if (groups != null) {
 754       for (String groupId : groupIds) {
 755         GroupDefinition groupDefinition = groups.get(groupId);
 756         if (groupDefinition != null) {
 757           List<String> groupMembers = groupDefinition.getMembers();
 758           if (groupMembers.contains(oldNodeTemplateId)) {
 759             //Replace the old node template id
 760             groupMembers.remove(oldNodeTemplateId);
 761             if (!groupMembers.contains(abstractNodeTemplateId)) {
 762               //Add the abstract node template id if not already present
 763               groupMembers.add(abstractNodeTemplateId);
 764             }
 765           }
 766         }
 767       }
 768     }
 769   }
 770
 771   protected void updOutputParamGetAttrInConnectivity(
 772       ServiceTemplate serviceTemplate, List<UnifiedCompositionData> unifiedComposotionDataList,
 773       TranslationContext context) {
 774     for (UnifiedCompositionData unifiedCompositionData : unifiedComposotionDataList) {
 775       ComputeTemplateConsolidationData computeTemplateConsolidationData =
 776           unifiedCompositionData.getComputeTemplateConsolidationData();
 777       String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
 778           computeTemplateConsolidationData.getNodeTemplateId());
 779
 780       updOutputParamGetAttrInConnectivity(serviceTemplate, computeTemplateConsolidationData,
 781           computeTemplateConsolidationData.getNodeTemplateId(), newComputeNodeTemplateId,
 782           context, false);
 783
 784       String computeType =
 785           getComputeTypeSuffix(serviceTemplate,
 786               computeTemplateConsolidationData.getNodeTemplateId());
 787       List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
 788           getPortTemplateConsolidationDataList(unifiedCompositionData);
 789       for (PortTemplateConsolidationData portTemplateConsolidationData :
 790           portTemplateConsolidationDataList) {
 791         String newPortNodeTemplateId =
 792             getNewPortNodeTemplateId(portTemplateConsolidationData.getNodeTemplateId(), computeType,
 793                 computeTemplateConsolidationData);
 794
 795         updOutputParamGetAttrInConnectivity(serviceTemplate, portTemplateConsolidationData,
 796             portTemplateConsolidationData.getNodeTemplateId(), newPortNodeTemplateId, context,
 797             false);
 798       }
 799     }
 800   }
 801
 802   protected void updNodesGetAttrInConnectivity(
 803       ServiceTemplate serviceTemplate,
 804       List<UnifiedCompositionData> unifiedComposotionDataList,
 805       TranslationContext context) {
 806     Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType =
 807         getAllConsolidationNodeTemplateIdAndType(unifiedComposotionDataList);
 808     for (UnifiedCompositionData unifiedCompositionData : unifiedComposotionDataList) {
 809       ComputeTemplateConsolidationData computeTemplateConsolidationData =
 810           unifiedCompositionData.getComputeTemplateConsolidationData();
 811       String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
 812           computeTemplateConsolidationData.getNodeTemplateId());
 813
 814       updNodeGetAttrInConnectivity(serviceTemplate, computeTemplateConsolidationData,
 815           computeTemplateConsolidationData.getNodeTemplateId(),
 816           newComputeNodeTemplateId, context, consolidationNodeTemplateIdAndType, false);
 817
 818       String computeType =
 819           getComputeTypeSuffix(serviceTemplate,
 820               computeTemplateConsolidationData.getNodeTemplateId());
 821
 822       List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
 823           getPortTemplateConsolidationDataList(unifiedCompositionData);
 824       for (PortTemplateConsolidationData portTemplateConsolidationData :
 825           portTemplateConsolidationDataList) {
 826         String newPotNodeTemplateId =
 827             getNewPortNodeTemplateId(portTemplateConsolidationData.getNodeTemplateId(), computeType,
 828                 computeTemplateConsolidationData);
 829
 830         updNodeGetAttrInConnectivity(serviceTemplate, portTemplateConsolidationData,
 831             portTemplateConsolidationData.getNodeTemplateId(),
 832             newPotNodeTemplateId, context, consolidationNodeTemplateIdAndType, false);
 833       }
 834     }
 835   }
 836
 837   protected void updNestedCompositionOutputParamGetAttrInConnectivity(
 838       ServiceTemplate serviceTemplate, List<UnifiedCompositionData> unifiedComposotionDataList,
 839       TranslationContext context) {
 840     for (UnifiedCompositionData unifiedCompositionData : unifiedComposotionDataList) {
 841       NestedTemplateConsolidationData nestedTemplateConsolidationData =
 842           unifiedCompositionData.getNestedTemplateConsolidationData();
 843       if (Objects.isNull(nestedTemplateConsolidationData)) {
 844         continue;
 845       }
 846       String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
 847       Optional<String> newNestedNodeTemplateId = context.getUnifiedNestedNodeTemplateId(
 848           serviceTemplateFileName, nestedTemplateConsolidationData.getNodeTemplateId());
 849
 850       newNestedNodeTemplateId.ifPresent(
 851           newNestedNodeTemplateIdVal -> updOutputParamGetAttrInConnectivity(serviceTemplate,
 852               nestedTemplateConsolidationData, nestedTemplateConsolidationData.getNodeTemplateId(),
 853               newNestedNodeTemplateIdVal, context, true));
 854     }
 855   }
 856
 857   protected void updNestedCompositionNodesGetAttrInConnectivity(
 858       ServiceTemplate serviceTemplate,
 859       List<UnifiedCompositionData> unifiedCompositionDataList,
 860       TranslationContext context) {
 861     for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
 862       NestedTemplateConsolidationData nestedTemplateConsolidationData =
 863           unifiedCompositionData.getNestedTemplateConsolidationData();
 864       if (Objects.isNull(nestedTemplateConsolidationData)) {
 865         continue;
 866       }
 867       String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
 868       Optional<String> newNestedNodeTemplateId = context.getUnifiedNestedNodeTemplateId(
 869           serviceTemplateFileName, nestedTemplateConsolidationData.getNodeTemplateId());
 870
 871       newNestedNodeTemplateId.ifPresent(
 872           newNestedNodeTemplateIdVal -> updNodeGetAttrInConnectivity(serviceTemplate,
 873               nestedTemplateConsolidationData, nestedTemplateConsolidationData.getNodeTemplateId(),
 874               newNestedNodeTemplateIdVal, context, null, true));
 875     }
 876   }
 877
 878   private void updateRequirementForNodesConnectedIn(
 879       ServiceTemplate serviceTemplate,
 880       RequirementAssignmentData requirementAssignmentData,
 881       EntityConsolidationData entityConsolidationData,
 882       String originalNodeTemplateId,
 883       String newNodeTemplateId,
 884       TranslationContext context) {
 885     ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
 886     RequirementAssignment requirementAssignment = requirementAssignmentData
 887         .getRequirementAssignment();
 888     String newAbstractUnifiedNodeTemplateId = context.getUnifiedAbstractNodeTemplateId(
 889         serviceTemplate, entityConsolidationData.getNodeTemplateId());
 890     NodeTemplate abstractUnifiedNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
 891         newAbstractUnifiedNodeTemplateId);
 892     Optional<String> newCapabilityId = getNewCapabilityForNodesConnectedIn(serviceTemplate,
 893         abstractUnifiedNodeTemplate, requirementAssignment, newNodeTemplateId, context);
 894     if (newCapabilityId.isPresent()) {
 895       //Creating a copy of the requirement object and checking if it already exists in the
 896       // original node template
 897       RequirementAssignment requirementAssignmentCopy = (RequirementAssignment) getClonedObject(
 898           requirementAssignmentData.getRequirementAssignment(), RequirementAssignment.class);
 899       NodeTemplate originalNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
 900           originalNodeTemplateId);
 901       requirementAssignmentCopy.setCapability(newCapabilityId.get());
 902       requirementAssignmentCopy.setNode(newAbstractUnifiedNodeTemplateId);
 903       if (!toscaAnalyzerService.isRequirementExistInNodeTemplate(originalNodeTemplate,
 904           requirementAssignmentData.getRequirementId(), requirementAssignmentCopy)) {
 905         //Update the existing requirement
 906         requirementAssignmentData.getRequirementAssignment().setCapability(newCapabilityId
 907             .get());
 908         requirementAssignmentData.getRequirementAssignment()
 909             .setNode(newAbstractUnifiedNodeTemplateId);
 910       } else {
 911         //The updated requirement already exists in the node template so simply remove the
 912         // current one
 913         DataModelUtil.removeRequirementAssignment(originalNodeTemplate, requirementAssignmentData
 914             .getRequirementId(), requirementAssignmentData.getRequirementAssignment());
 915       }
 916     }
 917   }
 918
 919   private void updateRequirementForNestedCompositionNodesConnectedIn(
 920       ServiceTemplate serviceTemplate,
 921       RequirementAssignmentData requirementAssignmentData,
 922       EntityConsolidationData entityConsolidationData,
 923       String newNodeTemplateId,
 924       TranslationContext context) {
 925     ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
 926     String newAbstractUnifiedNodeTemplateId = newNodeTemplateId;
 927     RequirementAssignment requirementAssignment = requirementAssignmentData
 928         .getRequirementAssignment();
 929     //Creating a copy of the requirement object and checking if it already exists in the
 930     // original node template
 931     RequirementAssignment requirementAssignmentCopy = (RequirementAssignment) getClonedObject(
 932         requirementAssignmentData.getRequirementAssignment(), RequirementAssignment.class);
 933     NodeTemplate unifiedAbstractNestedNodeTemplate = DataModelUtil
 934         .getNodeTemplate(serviceTemplate, newAbstractUnifiedNodeTemplateId);
 935     requirementAssignmentCopy.setCapability(requirementAssignment.getCapability());
 936     requirementAssignmentCopy.setNode(newAbstractUnifiedNodeTemplateId);
 937     if (!toscaAnalyzerService.isRequirementExistInNodeTemplate(unifiedAbstractNestedNodeTemplate,
 938         requirementAssignmentData.getRequirementId(), requirementAssignmentCopy)) {
 939       //Update the existing requirement
 940       requirementAssignmentData.getRequirementAssignment()
 941           .setNode(newAbstractUnifiedNodeTemplateId);
 942     } else {
 943       //The updated requirement already exists in the node template so simply remove the
 944       // current one
 945       DataModelUtil.removeRequirementAssignment(unifiedAbstractNestedNodeTemplate,
 946           requirementAssignmentData.getRequirementId(), requirementAssignmentData
 947               .getRequirementAssignment());
 948     }
 949   }
 950
 951   private Optional<String> getNewCapabilityForNodesConnectedIn(ServiceTemplate serviceTemplate,
 952                                                                NodeTemplate unifiedNodeTemplate,
 953                                                                RequirementAssignment
 954                                                                    requirementAssignment,
 955                                                                String newNodeTemplateId,
 956                                                                TranslationContext context) {
 957     ServiceTemplate globalSubstitutionServiceTemplate =
 958         HeatToToscaUtil.fetchGlobalSubstitutionServiceTemplate(serviceTemplate, context);
 959     Map<String, NodeType> nodeTypes = globalSubstitutionServiceTemplate.getNode_types();
 960     String unifiedNodeTemplateType = unifiedNodeTemplate.getType();
 961     NodeType unifiedNodeType = nodeTypes.get(unifiedNodeTemplateType);
 962     Map<String, CapabilityDefinition> abstractNodeTypeCapabilities = unifiedNodeType
 963         .getCapabilities();
 964     for (Map.Entry<String, CapabilityDefinition> entry : abstractNodeTypeCapabilities.entrySet()) {
 965       String capabilityId = entry.getKey();
 966       CapabilityDefinition capabilityDefinition = entry.getValue();
 967       String capabilityType = capabilityDefinition.getType();
 968       if (capabilityType.equals(requirementAssignment.getCapability())) {
 969         //Matching capability type found..Check if the id ends with new node template id
 970         if (capabilityId.endsWith(newNodeTemplateId)) {
 971           return Optional.ofNullable(capabilityId);
 972         }
 973       }
 974     }
 975     return Optional.empty();
 976   }
 977
 978
 979   private void updateRequirementInAbstractNodeTemplate(ServiceTemplate serviceTemplate,
 980                                                        EntityConsolidationData
 981                                                            entityConsolidationData,
 982                                                        String newNodeTemplateId,
 983                                                        Map<String, List<RequirementAssignmentData>>
 984                                                            requirementAssignmentDataMap,
 985                                                        TranslationContext context) {
 986     ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
 987     for (Map.Entry<String, List<RequirementAssignmentData>> entry : requirementAssignmentDataMap
 988         .entrySet()) {
 989       String abstractNodeTemplateId = context.getUnifiedAbstractNodeTemplateId(
 990           serviceTemplate, entityConsolidationData.getNodeTemplateId());
 991       NodeTemplate abstractNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
 992           abstractNodeTemplateId);
 993       if (abstractNodeTemplate == null) {
 994         //The abstract node template is not found from id in the context
 995         return;
 996       }
 997       List<RequirementAssignmentData> requirementAssignmentDataList = entry.getValue();
 998       for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList) {
 999         String oldRequirementId = requirementAssignmentData.getRequirementId();
1000         RequirementAssignment abstractRequirementAssignment = (RequirementAssignment)
1001             getClonedObject(requirementAssignmentData.getRequirementAssignment(),
1002                 RequirementAssignment.class);
1003         String newRequirementId = oldRequirementId + "_" + newNodeTemplateId;
1004         //Check if the requirement is not already present in the list of requirements of the
1005         // abstract node template
1006         if (!toscaAnalyzerService.isRequirementExistInNodeTemplate(abstractNodeTemplate,
1007             newRequirementId, abstractRequirementAssignment)) {
1008           DataModelUtil.addRequirementAssignment(abstractNodeTemplate, newRequirementId,
1009               abstractRequirementAssignment);
1010           //Update the volume relationship template if required
1011           updateVolumeRelationshipTemplate(serviceTemplate, abstractRequirementAssignment
1012               .getRelationship(), context);
1013         }
1014       }
1015     }
1016   }
1017
1018   private NodeTemplate getAbstractNodeTemplate(
1019       ServiceTemplate serviceTemplate,
1020       UnifiedCompositionEntity unifiedCompositionEntity,
1021       ComputeTemplateConsolidationData computeTemplateConsolidationData,
1022       PortTemplateConsolidationData portTemplateConsolidationData,
1023       TranslationContext context) {
1024     String abstractNodeTemplateId =
1025         getAbstractNodeTemplateId(serviceTemplate, unifiedCompositionEntity,
1026             computeTemplateConsolidationData, portTemplateConsolidationData, context);
1027
1028     return DataModelUtil.getNodeTemplate(serviceTemplate,
1029         abstractNodeTemplateId);
1030   }
1031
1032   private String getAbstractNodeTemplateId(
1033       ServiceTemplate serviceTemplate,
1034       UnifiedCompositionEntity unifiedCompositionEntity,
1035       ComputeTemplateConsolidationData computeTemplateConsolidationData,
1036       PortTemplateConsolidationData portTemplateConsolidationData,
1037       TranslationContext context) {
1038     switch (unifiedCompositionEntity) {
1039       case Compute:
1040         return context.getUnifiedAbstractNodeTemplateId(serviceTemplate,
1041             computeTemplateConsolidationData.getNodeTemplateId());
1042       case Port:
1043         return context.getUnifiedAbstractNodeTemplateId(serviceTemplate,
1044             portTemplateConsolidationData.getNodeTemplateId());
1045       default:
1046         return null;
1047     }
1048   }
1049
1050   private void updNodeGetAttrInConnectivity(
1051       ServiceTemplate serviceTemplate,
1052       EntityConsolidationData entityConsolidationData,
1053       String oldNodeTemplateId, String newNodeTemplateId,
1054       TranslationContext context,
1055       Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType,
1056       boolean isNested) {
1057     Map<String, List<GetAttrFuncData>> nodesGetAttrIn = entityConsolidationData.getNodesGetAttrIn();
1058     if (MapUtils.isEmpty(nodesGetAttrIn)) {
1059       return;
1060     }
1061
1062     for (String sourceNodeTemplateId : nodesGetAttrIn.keySet()) {
1063       NodeTemplate sourceNodeTemplate =
1064           DataModelUtil.getNodeTemplate(serviceTemplate, sourceNodeTemplateId);
1065       if (!isNested && consolidationNodeTemplateIdAndType.keySet().contains(sourceNodeTemplateId)) {
1066         continue;
1067       }
1068       List<GetAttrFuncData> getAttrFuncDataList = nodesGetAttrIn.get(sourceNodeTemplateId);
1069       for (GetAttrFuncData getAttrFuncData : getAttrFuncDataList) {
1070         Object propertyValue =
1071             DataModelUtil.getPropertyValue(sourceNodeTemplate, getAttrFuncData.getFieldName());
1072         String newAttrName = null;
1073         String newGetAttrAbstractNodeTemplateId = newNodeTemplateId;
1074         if (!isNested) {
1075           newGetAttrAbstractNodeTemplateId =
1076               context.getUnifiedAbstractNodeTemplateId(serviceTemplate, oldNodeTemplateId);
1077           newAttrName = getNewSubstitutionOutputParameterId(newNodeTemplateId, getAttrFuncData
1078               .getAttributeName());
1079         }
1080         List<List<Object>> getAttrFuncValueList = extractGetAttrFunction(propertyValue);
1081         updateGetAttrValue(oldNodeTemplateId, getAttrFuncData, newGetAttrAbstractNodeTemplateId,
1082             newAttrName, getAttrFuncValueList, isNested);
1083       }
1084     }
1085   }
1086
1087   private void updateGetAttrValue(String oldNodeTemplateId, GetAttrFuncData getAttrFuncData,
1088                                   String newNodeTemplateId, String newAttrName,
1089                                   List<List<Object>> getAttrFuncValueList, boolean isNested) {
1090     for (List<Object> getAttrFuncValue : getAttrFuncValueList) {
1091       if (oldNodeTemplateId.equals(getAttrFuncValue.get(0))
1092           && getAttrFuncData.getAttributeName().equals(getAttrFuncValue.get(1))) {
1093         getAttrFuncValue.set(0, newNodeTemplateId);
1094         if (!isNested) {
1095           getAttrFuncValue.set(1, newAttrName);
1096         }
1097       }
1098     }
1099   }
1100
1101   private String getTemplateName(ServiceTemplate serviceTemplate,
1102                                  UnifiedCompositionData unifiedCompositionData,
1103                                  Integer index) {
1104     ComputeTemplateConsolidationData computeTemplateConsolidationData =
1105         unifiedCompositionData.getComputeTemplateConsolidationData();
1106     String computeType =
1107         getComputeTypeSuffix(serviceTemplate, computeTemplateConsolidationData.getNodeTemplateId());
1108     String templateName = "Nested_" + computeType;
1109     if (Objects.nonNull(index)) {
1110       templateName = templateName + "_" + index.toString();
1111     }
1112     return templateName;
1113   }
1114
1115   private String getComputeTypeSuffix(ServiceTemplate serviceTemplate,
1116                                       String computeNodeTemplateId) {
1117     NodeTemplate computeNodeTemplate =
1118         DataModelUtil.getNodeTemplate(serviceTemplate, computeNodeTemplateId);
1119     return getComputeTypeSuffix(computeNodeTemplate.getType());
1120   }
1121
1122   /**
1123    * Gets compute type.
1124    *
1125    * @param computeType the compute node type abc.def.vFSB
1126    * @return the compute type e.g.:vFSB
1127    */
1128   private String getComputeTypeSuffix(String computeType) {
1129     return DataModelUtil.getNamespaceSuffix(computeType);
1130   }
1131
1132   private void updOutputParamGetAttrInConnectivity(ServiceTemplate serviceTemplate,
1133                                                    EntityConsolidationData entityConsolidationData,
1134                                                    String oldNodeTemplateId,
1135                                                    String newNodeTemplateId,
1136                                                    TranslationContext context,
1137                                                    boolean isNested) {
1138     List<GetAttrFuncData> outputParametersGetAttrIn =
1139         entityConsolidationData.getOutputParametersGetAttrIn();
1140     if (CollectionUtils.isEmpty(outputParametersGetAttrIn)) {
1141       return;
1142     }
1143     for (GetAttrFuncData getAttrFuncData : outputParametersGetAttrIn) {
1144       Object outputParamValue =
1145           DataModelUtil.getOuputParameter(serviceTemplate, getAttrFuncData.getFieldName())
1146               .getValue();
1147       String newAttrName = null;
1148       String newGetAttrAbstractNodeTemplateId = newNodeTemplateId;
1149       if (!isNested) {
1150         newGetAttrAbstractNodeTemplateId =
1151             context.getUnifiedAbstractNodeTemplateId(serviceTemplate, oldNodeTemplateId);
1152         newAttrName = getNewSubstitutionOutputParameterId(newNodeTemplateId, getAttrFuncData
1153             .getAttributeName());
1154       }
1155       List<List<Object>> getAttrFuncValueList = extractGetAttrFunction(outputParamValue);
1156       updateGetAttrValue(oldNodeTemplateId, getAttrFuncData, newGetAttrAbstractNodeTemplateId,
1157           newAttrName,
1158           getAttrFuncValueList, isNested);
1159     }
1160
1161   }
1162
1163   private List<List<Object>> extractGetAttrFunction(Object valueObject) {
1164
1165     List<List<Object>> getAttrValueList = new ArrayList<>();
1166
1167     if (valueObject instanceof Map) {
1168       if (((Map) valueObject).containsKey(ToscaFunctions.GET_ATTRIBUTE.getDisplayName())) {
1169         getAttrValueList.add(
1170             (List<Object>) ((Map) valueObject).get(ToscaFunctions.GET_ATTRIBUTE.getDisplayName()));
1171       }
1172
1173       for (Object key : ((Map) valueObject).keySet()) {
1174         getAttrValueList.addAll(extractGetAttrFunction(((Map) valueObject).get(key)));
1175       }
1176
1177
1178     } else if (valueObject instanceof List) {
1179       for (Object valueEntity : (List) valueObject) {
1180         getAttrValueList.addAll(extractGetAttrFunction(valueEntity));
1181       }
1182     }
1183     return getAttrValueList;
1184   }
1185
1186   private boolean isIncludeGetInputFunc(Object valueObject) {
1187     if (valueObject instanceof Map) {
1188       if (((Map) valueObject).containsKey(ToscaFunctions.GET_INPUT.getDisplayName())) {
1189         return true;
1190       }
1191       Map.Entry<String, Object> functionMapEntry =
1192           (Map.Entry<String, Object>) ((Map) valueObject).entrySet().iterator().next();
1193       return isIncludeGetInputFunc(functionMapEntry.getValue());
1194
1195     } else if (valueObject instanceof List) {
1196       for (Object valueEntity : (List) valueObject) {
1197         if (isIncludeGetInputFunc(valueEntity) == true) {
1198           return true;
1199         }
1200       }
1201     }
1202     return false;
1203   }
1204
1205   private void createOutputParameters(ServiceTemplate serviceTemplate,
1206                                       ServiceTemplate substitutionServiceTemplate,
1207                                       List<UnifiedCompositionData> unifiedCompositionDataList,
1208                                       String computeNodeType) {
1209
1210     createOutputParametersForCompute(serviceTemplate, substitutionServiceTemplate,
1211         unifiedCompositionDataList);
1212     createOutputParameterForPorts(serviceTemplate, substitutionServiceTemplate,
1213         unifiedCompositionDataList, computeNodeType);
1214   }
1215
1216   private void createOutputParameterForPorts(
1217       ServiceTemplate serviceTemplate,
1218       ServiceTemplate substitutionServiceTemplate,
1219       List<UnifiedCompositionData> unifiedCompositionDataList,
1220       String connectedComputeNodeType) {
1221     for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
1222       List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
1223           getPortTemplateConsolidationDataList(unifiedCompositionData);
1224       if (CollectionUtils.isEmpty(portTemplateConsolidationDataList)) {
1225         return;
1226       }
1227
1228       for (PortTemplateConsolidationData portTemplateConsolidationData :
1229           portTemplateConsolidationDataList) {
1230         String newPortNodeTemplateId =
1231             getNewPortNodeTemplateId(portTemplateConsolidationData.getNodeTemplateId(),
1232                 connectedComputeNodeType,
1233                 unifiedCompositionData.getComputeTemplateConsolidationData());
1234         addOutputParameters(portTemplateConsolidationData, newPortNodeTemplateId,
1235             substitutionServiceTemplate, unifiedCompositionDataList);
1236       }
1237     }
1238   }
1239
1240   //The ID should be <vm_type>_<port_type> or <vm_type>_<portNodeTemplateId>
1241   private String getNewPortNodeTemplateId(
1242       String portNodeTemplateId,
1243       String connectedComputeNodeType,
1244       ComputeTemplateConsolidationData computeTemplateConsolidationData) {
1245
1246     StringBuilder newPortNodeTemplateId = new StringBuilder();
1247     String portType = ConsolidationDataUtil.getPortType(portNodeTemplateId);
1248     newPortNodeTemplateId.append(DataModelUtil.getNamespaceSuffix(connectedComputeNodeType));
1249     if (computeTemplateConsolidationData.getPorts().get(portType).size() > 1) {
1250       //single port
1251       newPortNodeTemplateId.append("_").append(portNodeTemplateId);
1252     } else {
1253       //consolidation port
1254       newPortNodeTemplateId.append("_").append(portType);
1255     }
1256     return newPortNodeTemplateId.toString();
1257   }
1258
1259   private void createOutputParametersForCompute(
1260       ServiceTemplate serviceTemplate,
1261       ServiceTemplate substitutionServiceTemplate,
1262       List<UnifiedCompositionData>
1263           unifiedCompositionDataList) {
1264     List<EntityConsolidationData> computeConsolidationDataList =
1265         getComputeConsolidationDataList(unifiedCompositionDataList);
1266
1267     for (EntityConsolidationData computeTemplateConsolidationData : computeConsolidationDataList) {
1268       String newComputeNodeTemplateId =
1269           getNewComputeNodeTemplateId(serviceTemplate,
1270               computeTemplateConsolidationData.getNodeTemplateId());
1271       addOutputParameters(computeTemplateConsolidationData, newComputeNodeTemplateId,
1272           substitutionServiceTemplate, unifiedCompositionDataList);
1273     }
1274   }
1275
1276   private void addOutputParameters(EntityConsolidationData entityConsolidationData,
1277                                    String newNodeTemplateId,
1278                                    ServiceTemplate substitutionServiceTemplate,
1279                                    List<UnifiedCompositionData> unifiedCompositionDataList) {
1280     handleNodesGetAttrIn(entityConsolidationData, newNodeTemplateId, substitutionServiceTemplate,
1281         unifiedCompositionDataList);
1282
1283     handleOutputParamGetAttrIn(entityConsolidationData, newNodeTemplateId,
1284         substitutionServiceTemplate);
1285   }
1286
1287   private void handleOutputParamGetAttrIn(EntityConsolidationData entityConsolidationData,
1288                                           String newNodeTemplateId,
1289                                           ServiceTemplate substitutionServiceTemplate) {
1290     List<GetAttrFuncData> outputParametersGetAttrIn =
1291         entityConsolidationData.getOutputParametersGetAttrIn();
1292     if (!CollectionUtils.isEmpty(outputParametersGetAttrIn)) {
1293       for (GetAttrFuncData getAttrFuncData : outputParametersGetAttrIn) {
1294         createAndAddOutputParameter(entityConsolidationData, newNodeTemplateId,
1295             substitutionServiceTemplate, getAttrFuncData);
1296       }
1297     }
1298   }
1299
1300   private void handleNodesGetAttrIn(EntityConsolidationData entityConsolidationData,
1301                                     String newNodeTemplateId,
1302                                     ServiceTemplate substitutionServiceTemplate,
1303                                     List<UnifiedCompositionData> unifiedCompositionDataList) {
1304     Map<String, List<GetAttrFuncData>> getAttrIn = entityConsolidationData.getNodesGetAttrIn();
1305
1306     if (!MapUtils.isEmpty(getAttrIn)) {
1307       Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType =
1308           getAllConsolidationNodeTemplateIdAndType(unifiedCompositionDataList);
1309       for (String sourceNodeTemplateId : getAttrIn.keySet()) {
1310         if (!consolidationNodeTemplateIdAndType.keySet().contains(sourceNodeTemplateId)) {
1311           List<GetAttrFuncData> getAttrFuncDataList = getAttrIn.get(sourceNodeTemplateId);
1312           for (GetAttrFuncData getAttrFuncData : getAttrFuncDataList) {
1313             createAndAddOutputParameter(entityConsolidationData, newNodeTemplateId,
1314                 substitutionServiceTemplate, getAttrFuncData);
1315           }
1316         }
1317       }
1318     }
1319   }
1320
1321   private void createAndAddOutputParameter(EntityConsolidationData entityConsolidationData,
1322                                            String newNodeTemplateId,
1323                                            ServiceTemplate substitutionServiceTemplate,
1324                                            GetAttrFuncData getAttrFuncData) {
1325     Map<String, List<Object>> parameterValue = new HashMap<>();
1326     List<Object> valueList = new ArrayList<>();
1327     valueList.add(newNodeTemplateId);
1328     valueList.add(getAttrFuncData.getAttributeName());
1329     parameterValue.put(ToscaFunctions.GET_ATTRIBUTE.getDisplayName(), valueList);
1330     ParameterDefinition outputParameter = new ParameterDefinition();
1331     outputParameter.setValue(parameterValue);
1332     //todo - the type need to be change based on the attribute type in the accordingly node type
1333     // of this node template - XXX, instead of list of string, list of XXXX,
1334     outputParameter.setType(PropertyType.LIST.getDisplayName());
1335     outputParameter.setEntry_schema(
1336         DataModelUtil.createEntrySchema(PropertyType.STRING.getDisplayName(), null, null));
1337     DataModelUtil.addOutputParameterToTopologyTemplate(substitutionServiceTemplate,
1338         getNewSubstitutionOutputParameterId(newNodeTemplateId, getAttrFuncData.getAttributeName()),
1339         outputParameter);
1340   }
1341
1342   private String getNewSubstitutionOutputParameterId(String newNodeTemplateId,
1343                                                      String attributeName) {
1344     return newNodeTemplateId + "_" + attributeName;
1345   }
1346
1347   private void addUnifiedSubstitionData(TranslationContext context, ServiceTemplate
1348       serviceTemplate, List<UnifiedCompositionData> unifiedCompositionDataList, String
1349                                             substituteNodeTemplateId) {
1350     String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
1351     for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
1352       //Add compute node template mapping information
1353       ComputeTemplateConsolidationData computeTemplateConsolidationData =
1354           unifiedCompositionData.getComputeTemplateConsolidationData();
1355       String computeNodeTemplateId = computeTemplateConsolidationData.getNodeTemplateId();
1356       context.addUnifiedSubstitutionData(serviceTemplateFileName, computeNodeTemplateId,
1357           substituteNodeTemplateId);
1358       //Add Port template mapping information
1359       List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
1360           getPortTemplateConsolidationDataList(unifiedCompositionData);
1361
1362       if (CollectionUtils.isNotEmpty(portTemplateConsolidationDataList)) {
1363         for (PortTemplateConsolidationData portTemplateConsolidationData :
1364             portTemplateConsolidationDataList) {
1365           String oldPortNodeTemplateId = portTemplateConsolidationData.getNodeTemplateId();
1366           context.addUnifiedSubstitutionData(serviceTemplateFileName, oldPortNodeTemplateId,
1367               substituteNodeTemplateId);
1368         }
1369       }
1370     }
1371   }
1372
1373   private void addSubstitutionFilteringProperty(String templateName, NodeTemplate nodeTemplate,
1374                                                 int count) {
1375     Map<String, Object> serviceTemplateFilterPropertyValue = new HashMap<>();
1376     Map<String, Object> properties = nodeTemplate.getProperties();
1377     serviceTemplateFilterPropertyValue.put(ToscaConstants
1378         .SUBSTITUTE_SERVICE_TEMPLATE_PROPERTY_NAME, templateName);
1379     serviceTemplateFilterPropertyValue.put(ToscaConstants.COUNT_PROPERTY_NAME, count);
1380     properties.put(ToscaConstants.SERVICE_TEMPLATE_FILTER_PROPERTY_NAME,
1381         serviceTemplateFilterPropertyValue);
1382     nodeTemplate.setProperties(properties);
1383   }
1384
1385   private void addIndexValueProperty(NodeTemplate nodeTemplate) {
1386     List<String> indexValueGetPropertyValue = new ArrayList<>();
1387     indexValueGetPropertyValue.add(ToscaConstants.MODELABLE_ENTITY_NAME_SELF);
1388     indexValueGetPropertyValue.add(ToscaConstants.SERVICE_TEMPLATE_FILTER_PROPERTY_NAME);
1389     indexValueGetPropertyValue.add(ToscaConstants.INDEX_VALUE_PROPERTY_NAME);
1390
1391     Map<String, Object> indexPropertyValue = new HashMap<>();
1392     Map<String, Object> properties = nodeTemplate.getProperties();
1393     indexPropertyValue.put(ToscaFunctions.GET_PROPERTY.getDisplayName(),
1394         indexValueGetPropertyValue);
1395     properties.put(ToscaConstants.INDEX_VALUE_PROPERTY_NAME,
1396         indexPropertyValue);
1397     nodeTemplate.setProperties(properties);
1398   }
1399
1400   private String getSubstituteNodeTemplateId(ServiceTemplate serviceTemplate,
1401                                              UnifiedCompositionData unifiedCompositionData,
1402                                              Integer index) {
1403     String computeNodeTemplateId =
1404         unifiedCompositionData.getComputeTemplateConsolidationData().getNodeTemplateId();
1405     NodeTemplate computeNodeTemplate =
1406         DataModelUtil.getNodeTemplate(serviceTemplate, computeNodeTemplateId);
1407     String nodeTemplateId = ABSTRACT_NODE_TEMPLATE_ID_PREFIX + DataModelUtil
1408         .getNamespaceSuffix(computeNodeTemplate.getType());
1409     if (Objects.nonNull(index)) {
1410       nodeTemplateId = nodeTemplateId + "_" + index.toString();
1411     }
1412     return nodeTemplateId;
1413   }
1414
1415   private String getSubstitutionNodeTypeId(ServiceTemplate serviceTemplate,
1416                                            UnifiedCompositionData unifiedCompositionData,
1417                                            Integer index) {
1418     String computeNodeTemplateId =
1419         unifiedCompositionData.getComputeTemplateConsolidationData().getNodeTemplateId();
1420     NodeTemplate computeNodeTemplate =
1421         DataModelUtil.getNodeTemplate(serviceTemplate, computeNodeTemplateId);
1422     String nodeTypeId = ToscaNodeType.ABSTRACT_NODE_TYPE_PREFIX
1423         + DataModelUtil.getNamespaceSuffix(computeNodeTemplate.getType());
1424     if (Objects.nonNull(index)) {
1425       nodeTypeId = nodeTypeId + "_" + index.toString();
1426     }
1427     return nodeTypeId;
1428   }
1429
1430   private String getNewComputeNodeTemplateId(
1431       ServiceTemplate serviceTemplate,
1432       String computeNodeTemplateId) {
1433     return getComputeTypeSuffix(serviceTemplate, computeNodeTemplateId);
1434   }
1435
1436   private NodeType handleSubstitutionGlobalNodeType(ServiceTemplate serviceTemplate,
1437                                                     ServiceTemplate substitutionServiceTemplate,
1438                                                     TranslationContext context,
1439                                                     UnifiedCompositionData unifiedCompositionData,
1440                                                     Integer index) {
1441     String substitutionNodeTypeId =
1442         getSubstitutionNodeTypeId(serviceTemplate, unifiedCompositionData, index);
1443     NodeType substitutionNodeType = new ToscaAnalyzerServiceImpl()
1444         .createInitSubstitutionNodeType(substitutionServiceTemplate,
1445             ToscaNodeType.VFC_ABSTRACT_SUBSTITUTE);
1446     ServiceTemplate globalSubstitutionServiceTemplate =
1447         HeatToToscaUtil.fetchGlobalSubstitutionServiceTemplate(serviceTemplate, context);
1448     DataModelUtil.addNodeType(globalSubstitutionServiceTemplate, substitutionNodeTypeId,
1449         substitutionNodeType);
1450
1451     return substitutionNodeType;
1452   }
1453
1454   private void handlePorts(ServiceTemplate serviceTemplate,
1455                            ServiceTemplate substitutionServiceTemplate,
1456                            List<UnifiedCompositionData> unifiedCompositionDataList,
1457                            String connectedComputeNodeType,
1458                            TranslationContext context) {
1459
1460     if (unifiedCompositionDataList.size() > 1) {
1461       handleConsolidationPorts(serviceTemplate, substitutionServiceTemplate,
1462           unifiedCompositionDataList, connectedComputeNodeType, context);
1463     } else {
1464       handleSinglePorts(serviceTemplate, substitutionServiceTemplate, connectedComputeNodeType,
1465           unifiedCompositionDataList, context);
1466     }
1467   }
1468
1469   private void handleSinglePorts(ServiceTemplate serviceTemplate,
1470                                  ServiceTemplate substitutionServiceTemplate,
1471                                  String connectedComputeNodeType,
1472                                  List<UnifiedCompositionData> unifiedCompositionDataList,
1473                                  TranslationContext context) {
1474     UnifiedCompositionData unifiedCompositionData = unifiedCompositionDataList.get(0);
1475     List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
1476         getPortTemplateConsolidationDataList(unifiedCompositionData);
1477     if (CollectionUtils.isEmpty(portTemplateConsolidationDataList)) {
1478       return;
1479     }
1480     for (PortTemplateConsolidationData portTemplateConsolidationData :
1481         portTemplateConsolidationDataList) {
1482       List<EntityConsolidationData> portConsolidationDataList = new ArrayList<>();
1483       portConsolidationDataList.add(portTemplateConsolidationData);
1484       handlePortNodeTemplate(serviceTemplate, substitutionServiceTemplate,
1485           portConsolidationDataList, connectedComputeNodeType,
1486           unifiedCompositionData.getComputeTemplateConsolidationData(),
1487           unifiedCompositionDataList, context);
1488     }
1489   }
1490
1491   private void handleConsolidationPorts(ServiceTemplate serviceTemplate,
1492                                         ServiceTemplate substitutionServiceTemplate,
1493                                         List<UnifiedCompositionData> unifiedCompositionDataList,
1494                                         String connectedComputeNodeType,
1495                                         TranslationContext context) {
1496     Collection<ComputeTemplateConsolidationData> computeConsolidationDataList =
1497         (Collection) getComputeConsolidationDataList(unifiedCompositionDataList);
1498
1499     Map<String, Set<String>> portIdsPerPortType = UnifiedCompositionUtil
1500         .collectAllPortsFromEachTypesFromComputes(computeConsolidationDataList);
1501
1502     for (String portType : portIdsPerPortType.keySet()) {
1503       List<EntityConsolidationData> portTemplateConsolidationDataList =
1504           getPortConsolidationDataList(portIdsPerPortType.get(portType),
1505               unifiedCompositionDataList);
1506       if (CollectionUtils.isEmpty(portTemplateConsolidationDataList)) {
1507         continue;
1508       }
1509
1510       handlePortNodeTemplate(serviceTemplate, substitutionServiceTemplate,
1511           portTemplateConsolidationDataList, connectedComputeNodeType,
1512           unifiedCompositionDataList.get(0).getComputeTemplateConsolidationData(),
1513           unifiedCompositionDataList, context);
1514     }
1515   }
1516
1517   private void handlePortNodeTemplate(
1518       ServiceTemplate serviceTemplate,
1519       ServiceTemplate substitutionServiceTemplate,
1520       List<EntityConsolidationData> portTemplateConsolidationDataList,
1521       String connectedComputeNodeType,
1522       ComputeTemplateConsolidationData computeTemplateConsolidationData,
1523       List<UnifiedCompositionData> unifiedCompositionDataList,
1524       TranslationContext context) {
1525     EntityConsolidationData portTemplateConsolidationData =
1526         portTemplateConsolidationDataList.get(0);
1527     NodeTemplate newPortNodeTemplate = getNodeTemplate(
1528         portTemplateConsolidationData.getNodeTemplateId(), serviceTemplate, context).clone();
1529
1530     removeConnectivityOut(portTemplateConsolidationData, newPortNodeTemplate);
1531     handleProperties(serviceTemplate, newPortNodeTemplate,
1532         substitutionServiceTemplate, UnifiedCompositionEntity.Port,
1533         portTemplateConsolidationDataList, computeTemplateConsolidationData,
1534         unifiedCompositionDataList, context);
1535
1536     String newPortNodeTemplateId =
1537         getNewPortNodeTemplateId(portTemplateConsolidationData
1538                 .getNodeTemplateId(), connectedComputeNodeType,
1539             computeTemplateConsolidationData);
1540     //Update requirements for relationships between the consolidation entities
1541     handleConsolidationEntitiesRequirementConnectivity(newPortNodeTemplateId, newPortNodeTemplate,
1542         substitutionServiceTemplate, context);
1543     DataModelUtil.addNodeTemplate(substitutionServiceTemplate, newPortNodeTemplateId,
1544         newPortNodeTemplate);
1545
1546     //Add the node template mapping in the context for handling requirement updation
1547     context.addSubstitutionServiceTemplateUnifiedSubstitutionData(ToscaUtil
1548             .getServiceTemplateFileName(substitutionServiceTemplate),
1549         portTemplateConsolidationData.getNodeTemplateId(), newPortNodeTemplateId);
1550   }
1551
1552
1553   private NodeTemplate getNodeTemplate(String nodeTemplateId, ServiceTemplate serviceTemplate,
1554                                        TranslationContext context) {
1555
1556     NodeTemplate nodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate, nodeTemplateId);
1557
1558     if (Objects.isNull(nodeTemplate)) {
1559       nodeTemplate = context
1560           .getCleanedNodeTemplate(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
1561               nodeTemplateId);
1562
1563     }
1564     return nodeTemplate;
1565   }
1566
1567
1568   private String handleCompute(ServiceTemplate serviceTemplate,
1569                                ServiceTemplate substitutionServiceTemplate,
1570                                List<UnifiedCompositionData> unifiedCompositionDataList,
1571                                TranslationContext context) {
1572     ComputeTemplateConsolidationData computeTemplateConsolidationData =
1573         unifiedCompositionDataList.get(0).getComputeTemplateConsolidationData();
1574     handleComputeNodeTemplate(serviceTemplate, substitutionServiceTemplate,
1575         unifiedCompositionDataList, context);
1576     return handleComputeNodeType(serviceTemplate, substitutionServiceTemplate,
1577         computeTemplateConsolidationData);
1578   }
1579
1580   private String handleComputeNodeType(
1581       ServiceTemplate serviceTemplate,
1582       ServiceTemplate substitutionServiceTemplate,
1583       ComputeTemplateConsolidationData computeTemplateConsolidationData) {
1584     NodeTemplate computeNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
1585         computeTemplateConsolidationData.getNodeTemplateId());
1586     NodeType computeNodeType =
1587         DataModelUtil.getNodeType(serviceTemplate, computeNodeTemplate.getType());
1588     DataModelUtil
1589         .addNodeType(substitutionServiceTemplate, computeNodeTemplate.getType(), computeNodeType);
1590
1591     return computeNodeTemplate.getType();
1592   }
1593
1594   private void handleComputeNodeTemplate(ServiceTemplate serviceTemplate,
1595                                          ServiceTemplate substitutionServiceTemplate,
1596                                          List<UnifiedCompositionData> unifiedCompositionDataList,
1597                                          TranslationContext context) {
1598     ComputeTemplateConsolidationData computeTemplateConsolidationData =
1599         unifiedCompositionDataList.get(0).getComputeTemplateConsolidationData();
1600     NodeTemplate newComputeNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
1601         computeTemplateConsolidationData.getNodeTemplateId()).clone();
1602
1603     removeConnectivityOut(computeTemplateConsolidationData, newComputeNodeTemplate);
1604     removeVolumeConnectivity(computeTemplateConsolidationData, newComputeNodeTemplate);
1605
1606     List<EntityConsolidationData> computeConsoliadtionDataList =
1607         getComputeConsolidationDataList(unifiedCompositionDataList);
1608
1609     handleProperties(serviceTemplate, newComputeNodeTemplate,
1610         substitutionServiceTemplate, UnifiedCompositionEntity.Compute,
1611         computeConsoliadtionDataList, computeTemplateConsolidationData, unifiedCompositionDataList,
1612         context);
1613
1614     String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
1615         computeTemplateConsolidationData.getNodeTemplateId());
1616     //Update requirements for relationships between the consolidation entities
1617     handleConsolidationEntitiesRequirementConnectivity(newComputeNodeTemplateId,
1618         newComputeNodeTemplate,
1619         substitutionServiceTemplate, context);
1620     DataModelUtil
1621         .addNodeTemplate(substitutionServiceTemplate,
1622             newComputeNodeTemplateId, newComputeNodeTemplate);
1623     //Add the node template mapping in the context for handling requirement updation
1624     context.addSubstitutionServiceTemplateUnifiedSubstitutionData(ToscaUtil
1625             .getServiceTemplateFileName(substitutionServiceTemplate),
1626         computeTemplateConsolidationData.getNodeTemplateId(), newComputeNodeTemplateId);
1627
1628   }
1629
1630   private List<EntityConsolidationData> getComputeConsolidationDataList(
1631       List<UnifiedCompositionData> unifiedCompositionDataList) {
1632     List<EntityConsolidationData> computeConsolidationDataList = new ArrayList<>();
1633     for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
1634       computeConsolidationDataList
1635           .add(unifiedCompositionData.getComputeTemplateConsolidationData());
1636     }
1637     return computeConsolidationDataList;
1638   }
1639
1640
1641   private void handleProperties(ServiceTemplate serviceTemplate,
1642                                 NodeTemplate nodeTemplate,
1643                                 ServiceTemplate substitutionServiceTemplate,
1644                                 UnifiedCompositionEntity unifiedCompositionEntity,
1645                                 List<EntityConsolidationData> entityConsolidationDataList,
1646                                 ComputeTemplateConsolidationData computeTemplateConsolidationData,
1647                                 List<UnifiedCompositionData> unifiedCompositionDataList,
1648                                 TranslationContext context) {
1649
1650     nodeTemplate.setProperties(new HashedMap());
1651     handleNodeTemplateProperties(serviceTemplate, nodeTemplate, substitutionServiceTemplate,
1652         unifiedCompositionEntity, entityConsolidationDataList, computeTemplateConsolidationData,
1653         unifiedCompositionDataList, context);
1654     //Add enrich properties from openecomp node type as input to global and substitution ST
1655     handleNodeTypeProperties(substitutionServiceTemplate,
1656         entityConsolidationDataList, nodeTemplate, unifiedCompositionEntity,
1657         computeTemplateConsolidationData, context);
1658
1659   }
1660
1661   private void handleNodeTemplateProperties(ServiceTemplate serviceTemplate,
1662                                             NodeTemplate nodeTemplate,
1663                                             ServiceTemplate substitutionServiceTemplate,
1664                                             UnifiedCompositionEntity unifiedCompositionEntity,
1665                                             List<EntityConsolidationData>
1666                                                 entityConsolidationDataList,
1667                                             ComputeTemplateConsolidationData
1668                                                 computeTemplateConsolidationData,
1669                                             List<UnifiedCompositionData> unifiedCompositionDataList,
1670                                             TranslationContext context) {
1671     List<String> propertiesWithIdenticalVal =
1672         consolidationService.getPropertiesWithIdenticalVal(unifiedCompositionEntity, context);
1673
1674     for (EntityConsolidationData entityConsolidationData : entityConsolidationDataList) {
1675       String nodeTemplateId = entityConsolidationData.getNodeTemplateId();
1676       Map<String, Object> properties =
1677           DataModelUtil.getNodeTemplateProperties(serviceTemplate, nodeTemplateId);
1678       if (MapUtils.isEmpty(properties)) {
1679         continue;
1680       }
1681
1682       for (Map.Entry<String, Object> propertyEntry : properties.entrySet()) {
1683         NodeType nodeTypeWithFlatHierarchy =
1684             HeatToToscaUtil.getNodeTypeWithFlatHierarchy(nodeTemplate.getType(), serviceTemplate,
1685                 context);
1686         PropertyDefinition propertyDefinition =
1687             nodeTypeWithFlatHierarchy.getProperties().get(propertyEntry.getKey());
1688         String propertyType = propertyDefinition.getType();
1689
1690         if (propertiesWithIdenticalVal.contains(propertyEntry.getKey())) {
1691           String parameterId =
1692               updateIdenticalProperty(nodeTemplateId, propertyEntry.getKey(), nodeTemplate,
1693                   unifiedCompositionEntity, unifiedCompositionDataList);
1694
1695           addInputParameter(
1696               parameterId, propertyType,
1697               propertyType.equals(PropertyType.LIST.getDisplayName()) ? propertyDefinition
1698                   .getEntry_schema() : null,
1699               substitutionServiceTemplate);
1700         } else {
1701           Optional<String> parameterId =
1702               updateProperty(serviceTemplate, nodeTemplateId, nodeTemplate, propertyEntry,
1703                   unifiedCompositionEntity, computeTemplateConsolidationData,
1704                   unifiedCompositionDataList,
1705                   context);
1706           //todo - define list of type which will match the node property type (instead of string)
1707           addPropertyInputParameter(propertyType, substitutionServiceTemplate, parameterId);
1708         }
1709       }
1710     }
1711   }
1712
1713   private void handleNodeTypeProperties(ServiceTemplate substitutionServiceTemplate,
1714                                         List<EntityConsolidationData> entityConsolidationDataList,
1715                                         NodeTemplate nodeTemplate,
1716                                         UnifiedCompositionEntity compositionEntity,
1717                                         ComputeTemplateConsolidationData
1718                                             computeTemplateConsolidationData,
1719                                         TranslationContext context) {
1720     ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
1721     Optional<NodeType> enrichNodeType = Optional.empty();
1722     List<String> enrichProperties = new ArrayList<>();
1723
1724     if (compositionEntity.equals(UnifiedCompositionEntity.Port)) {
1725       enrichNodeType =
1726           toscaAnalyzerService.fetchNodeType(ToscaNodeType.NETWORK_PORT,
1727               context.getGlobalServiceTemplates().values());
1728       enrichProperties = context.getEnrichPortResourceProperties();
1729       if (!enrichNodeType.isPresent() || Objects.isNull(enrichProperties)) {
1730         return;
1731       }
1732     } else {
1733       return;
1734     }
1735
1736     Map<String, Object> nodeTemplateProperties = nodeTemplate.getProperties();
1737     Map<String, PropertyDefinition> enrichNodeTypeProperties = enrichNodeType.get().getProperties();
1738     if (Objects.nonNull(enrichNodeTypeProperties)) {
1739       for (String enrichPropertyName : enrichProperties) {
1740         if (!nodeTemplateProperties.containsKey(enrichPropertyName)) {
1741           for (EntityConsolidationData entityConsolidationData : entityConsolidationDataList) {
1742             String nodeTemplateId = entityConsolidationData.getNodeTemplateId();
1743             String inputParamId =
1744                 getParameterId(nodeTemplateId, nodeTemplate, enrichPropertyName,
1745                     compositionEntity, computeTemplateConsolidationData);
1746             Map<String, List<String>> propertyVal = getPropertyValueInputParam(nodeTemplateId,
1747                 nodeTemplate, inputParamId);
1748             nodeTemplate.getProperties().put(enrichPropertyName, propertyVal);
1749             String propertyType =
1750                 enrichNodeType.get().getProperties().get(enrichPropertyName).getType();
1751             addPropertyInputParameter(propertyType, substitutionServiceTemplate,
1752                 Optional.of(inputParamId));
1753           }
1754         }
1755       }
1756     }
1757   }
1758
1759
1760   private void addPropertyInputParameter(String propertyType,
1761                                          ServiceTemplate substitutionServiceTemplate,
1762                                          Optional<String> parameterId) {
1763     if (propertyType.equalsIgnoreCase(PropertyType.STRING.getDisplayName())
1764         || propertyType.equalsIgnoreCase(PropertyType.INTEGER.getDisplayName())
1765         || propertyType.equalsIgnoreCase(PropertyType.FLOAT.getDisplayName())
1766         || propertyType.equalsIgnoreCase(PropertyType.BOOLEAN.getDisplayName())) {
1767       parameterId
1768           .ifPresent(parameterIdValue -> addInputParameter(parameterIdValue,
1769               PropertyType.LIST.getDisplayName(),
1770               DataModelUtil
1771                   .createEntrySchema(propertyType.toLowerCase(), null, null),
1772               substitutionServiceTemplate));
1773     } else {
1774       parameterId
1775           .ifPresent(parameterIdValue -> addInputParameter(parameterIdValue,
1776               PropertyType.LIST.getDisplayName(),
1777               DataModelUtil
1778                   .createEntrySchema(PropertyTypeExt.JSON.getDisplayName(), null, null),
1779               substitutionServiceTemplate));
1780     }
1781   }
1782
1783   private void handleConsolidationEntitiesRequirementConnectivity(String nodeTemplateId,
1784                                                                   NodeTemplate nodeTemplate,
1785                                                                   ServiceTemplate
1786                                                                       substitutionServiceTemplate,
1787                                                                   TranslationContext context) {
1788     Map<String, RequirementAssignment> updatedNodeTemplateRequirements = new HashMap<>();
1789     List<Map<String, RequirementAssignment>> nodeTemplateRequirements = DataModelUtil
1790         .getNodeTemplateRequirementList(nodeTemplate);
1791     if (CollectionUtils.isEmpty(nodeTemplateRequirements)) {
1792       return;
1793     }
1794
1795     for (Map<String, RequirementAssignment> requirement : nodeTemplateRequirements) {
1796       for (Map.Entry<String, RequirementAssignment> entry : requirement.entrySet()) {
1797         RequirementAssignment requirementAssignment = entry.getValue();
1798         String requirementNode = requirementAssignment.getNode();
1799         String unifiedNodeTemplateId =
1800             context.getUnifiedSubstitutionNodeTemplateId(substitutionServiceTemplate,
1801                 requirementNode);
1802         if (unifiedNodeTemplateId != null) {
1803           //Update the node id in the requirement
1804           requirementAssignment.setNode(unifiedNodeTemplateId);
1805         }
1806       }
1807     }
1808     nodeTemplate.setRequirements(nodeTemplateRequirements);
1809   }
1810
1811   /**
1812    * Update the node references in the volume relationship templates.
1813    *
1814    * @param serviceTemplate the service template
1815    * @param context         the context
1816    */
1817   private void updateVolumeRelationshipTemplate(ServiceTemplate serviceTemplate,
1818                                                 String relationshipId,
1819                                                 TranslationContext context) {
1820     Map<String, RelationshipTemplate> relationshipTemplates = DataModelUtil
1821         .getRelationshipTemplates(serviceTemplate);
1822     if (relationshipTemplates != null) {
1823       RelationshipTemplate relationshipTemplate = relationshipTemplates.get(relationshipId);
1824       if (relationshipTemplate != null) {
1825         String relationshipTemplateType = relationshipTemplate.getType();
1826         if (relationshipTemplateType.equals(ToscaRelationshipType.CINDER_VOLUME_ATTACHES_TO)) {
1827           handleCinderVolumeAttachmentRelationshipTemplate(serviceTemplate,
1828               relationshipTemplate, context);
1829         }
1830       }
1831     }
1832   }
1833
1834
1835   private void handleCinderVolumeAttachmentRelationshipTemplate(ServiceTemplate
1836                                                                     substitutionServiceTemplate,
1837                                                                 RelationshipTemplate
1838                                                                     relationshipTemplate,
1839                                                                 TranslationContext context) {
1840     Map<String, Object> properties = relationshipTemplate.getProperties();
1841     properties.computeIfPresent(HeatConstants.INSTANCE_UUID_PROPERTY_NAME, (key, value) ->
1842         context.getUnifiedAbstractNodeTemplateId(substitutionServiceTemplate,
1843             (String) value));
1844   }
1845
1846   private String updateIdenticalProperty(String nodeTemplateId, String propertyId,
1847                                          NodeTemplate nodeTemplate,
1848                                          UnifiedCompositionEntity unifiedCompositionEntity,
1849                                          List<UnifiedCompositionData> unifiedCompositionDataList) {
1850
1851     String inputParamId;
1852     Map<String, Object> propertyVal = new HashMap<>();
1853
1854     switch (unifiedCompositionEntity) {
1855       case Compute:
1856         inputParamId = COMPUTE_IDENTICAL_VALUE_PROPERTY_PREFIX + propertyId
1857             + COMPUTE_IDENTICAL_VALUE_PROPERTY_SUFFIX;
1858
1859         propertyVal.put(ToscaFunctions.GET_INPUT.getDisplayName(), inputParamId);
1860         nodeTemplate.getProperties().put(propertyId, propertyVal);
1861
1862         return inputParamId;
1863
1864       case Port:
1865         String portType = ConsolidationDataUtil.getPortType(nodeTemplateId);
1866         ComputeTemplateConsolidationData computeTemplateConsolidationData =
1867             getConnectedComputeConsolidationData(unifiedCompositionDataList, nodeTemplateId);
1868         inputParamId = getInputParamIdForPort(nodeTemplateId, propertyId, portType,
1869             computeTemplateConsolidationData);
1870
1871         propertyVal.put(ToscaFunctions.GET_INPUT.getDisplayName(), inputParamId);
1872         nodeTemplate.getProperties().put(propertyId, propertyVal);
1873
1874         return inputParamId;
1875
1876       default:
1877         return null;
1878     }
1879   }
1880
1881   private String getInputParamIdForPort(String nodeTemplateId, String propertyId, String portType,
1882                                         ComputeTemplateConsolidationData computeTemplateConsolidationData) {
1883     String inputParamId;
1884     if (Objects.isNull(computeTemplateConsolidationData)
1885         || computeTemplateConsolidationData.getPorts().get(portType).size() > 1) {
1886       inputParamId =
1887           UnifiedCompositionEntity.Port.name().toLowerCase() + "_" + nodeTemplateId + "_" +
1888               propertyId;
1889
1890     } else {
1891       inputParamId =
1892           UnifiedCompositionEntity.Port.name().toLowerCase() + "_" + portType + "_"
1893               + propertyId;
1894     }
1895     return inputParamId;
1896   }
1897
1898   private void addInputParameter(String parameterId,
1899                                  String parameterType,
1900                                  EntrySchema entrySchema,
1901                                  ServiceTemplate serviceTemplate) {
1902
1903     ParameterDefinition parameterDefinition =
1904         DataModelUtil.createParameterDefinition(parameterType, null, null,
1905             true, null, null, entrySchema, null);
1906     DataModelUtil
1907         .addInputParameterToTopologyTemplate(serviceTemplate, parameterId, parameterDefinition);
1908   }
1909
1910   // Return the input parameter Id which is used in the new property value if there is one
1911   private Optional<String> updateProperty(
1912       ServiceTemplate serviceTemplate,
1913       String nodeTemplateId, NodeTemplate nodeTemplate,
1914       Map.Entry<String, Object> propertyEntry,
1915       UnifiedCompositionEntity compositionEntity,
1916       ComputeTemplateConsolidationData computeTemplateConsolidationData,
1917       List<UnifiedCompositionData> unifiedCompositionDataList,
1918       TranslationContext context) {
1919
1920     if (handleGetAttrFromConsolidationNodes(serviceTemplate, nodeTemplate, propertyEntry,
1921         unifiedCompositionDataList, context)) {
1922       return Optional.empty();
1923     }
1924     String inputParamId =
1925         getParameterId(nodeTemplateId, nodeTemplate, propertyEntry.getKey(), compositionEntity,
1926             computeTemplateConsolidationData);
1927     Map<String, List<String>> propertyVal = getPropertyValueInputParam(nodeTemplateId,
1928         nodeTemplate, inputParamId);
1929     nodeTemplate.getProperties().put(propertyEntry.getKey(), propertyVal);
1930     return Optional.of(inputParamId);
1931   }
1932
1933   private Map<String, List<String>> getPropertyValueInputParam(String nodeTemplateId,
1934                                                                NodeTemplate nodeTemplate,
1935                                                                String inputParamId) {
1936     Map<String, List<String>> propertyVal = new HashMap<>();
1937     List<String> getInputFuncParams = new ArrayList<>();
1938     getInputFuncParams.add(inputParamId);
1939     getInputFuncParams.add(ToscaConstants.INDEX_VALUE_PROPERTY_NAME);
1940     propertyVal.put(ToscaFunctions.GET_INPUT.getDisplayName(), getInputFuncParams);
1941     return propertyVal;
1942   }
1943
1944   private boolean handleGetAttrFromConsolidationNodes(
1945       ServiceTemplate serviceTemplate,
1946       NodeTemplate nodeTemplate,
1947       Map.Entry<String, Object> propertyEntry,
1948       List<UnifiedCompositionData> unifiedCompositionDataList,
1949       TranslationContext context) {
1950     Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType =
1951         getAllConsolidationNodeTemplateIdAndType(unifiedCompositionDataList);
1952
1953     Set<String> consolidationNodeTemplateIds = consolidationNodeTemplateIdAndType.keySet();
1954     boolean includeGetAttrFromConsolidationNodes = false;
1955     boolean includeGetAttrFromOutsideNodes = false;
1956     List<List<Object>> getAttrFunctionList = extractGetAttrFunction(propertyEntry.getValue());
1957     for (List<Object> getAttrFunc : getAttrFunctionList) {
1958       if (consolidationNodeTemplateIds.contains(getAttrFunc.get(0))) {
1959         includeGetAttrFromConsolidationNodes = true;
1960       } else {
1961         includeGetAttrFromOutsideNodes = true;
1962       }
1963     }
1964     if ((includeGetAttrFromConsolidationNodes && includeGetAttrFromOutsideNodes)
1965         ||
1966         (includeGetAttrFromConsolidationNodes && isIncludeGetInputFunc(propertyEntry.getValue()))) {
1967       //This case is currently not supported - this property will be ignored
1968       return true;
1969     } else if (includeGetAttrFromConsolidationNodes) {
1970       Object clonedPropertyValue = getClonedPropertyValue(propertyEntry);
1971       List<List<Object>> clonedGetAttrFuncList = extractGetAttrFunction(clonedPropertyValue);
1972       for (List<Object> getAttrFunc : clonedGetAttrFuncList) {
1973         String targetNodeTemplateId = (String) getAttrFunc.get(0);
1974         if (consolidationNodeTemplateIds.contains(targetNodeTemplateId)) {
1975           updatePropertyGetAttrFunc(serviceTemplate, unifiedCompositionDataList, context,
1976               consolidationNodeTemplateIdAndType, targetNodeTemplateId, getAttrFunc);
1977         }
1978       }
1979       nodeTemplate.getProperties().put(propertyEntry.getKey(), clonedPropertyValue);
1980       return true;
1981     }
1982     return false;
1983   }
1984
1985   private void updatePropertyGetAttrFunc(
1986       ServiceTemplate serviceTemplate,
1987       List<UnifiedCompositionData> unifiedCompositionDataList,
1988       TranslationContext context,
1989       Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType,
1990       String targetNodeTemplateId,
1991       List<Object> getAttrFunc) {
1992     UnifiedCompositionEntity targetCompositionEntity =
1993         consolidationNodeTemplateIdAndType.get(targetNodeTemplateId);
1994     String targetNewNodeTemplateId =
1995         getNewNodeTemplateId(serviceTemplate, unifiedCompositionDataList, targetNodeTemplateId,
1996             targetCompositionEntity);
1997     getAttrFunc.set(0, targetNewNodeTemplateId);
1998   }
1999
2000   private String getNewNodeTemplateId(ServiceTemplate serviceTemplate,
2001                                       List<UnifiedCompositionData> unifiedCompositionDataList,
2002                                       String nodeTemplateId,
2003                                       UnifiedCompositionEntity compositionEntity) {
2004     switch (compositionEntity) {
2005       case Compute:
2006         return getNewComputeNodeTemplateId(serviceTemplate, nodeTemplateId);
2007       case Port:
2008         ComputeTemplateConsolidationData connectedComputeConsolidationData =
2009             getConnectedComputeConsolidationData(
2010                 unifiedCompositionDataList, nodeTemplateId);
2011         NodeTemplate connectedComputeNodeTemplate =
2012             DataModelUtil.getNodeTemplate(serviceTemplate,
2013                 connectedComputeConsolidationData.getNodeTemplateId());
2014         return getNewPortNodeTemplateId(nodeTemplateId, connectedComputeNodeTemplate.getType(),
2015             connectedComputeConsolidationData);
2016       default:
2017         return null;
2018     }
2019   }
2020
2021   private String getNewNodeTemplateId(String origNodeTemplateId,
2022                                       String serviceTemplateFileName,
2023                                       ServiceTemplate serviceTemplate,
2024                                       TranslationContext context) {
2025     ConsolidationData consolidationData = context.getConsolidationData();
2026
2027     if (isIdIsOfExpectedType(origNodeTemplateId, UnifiedCompositionEntity.Port,
2028         serviceTemplateFileName,
2029         context)) {
2030       return handleIdOfPort(origNodeTemplateId, serviceTemplateFileName, consolidationData);
2031     } else if (isIdIsOfExpectedType(origNodeTemplateId, UnifiedCompositionEntity.Compute,
2032         serviceTemplateFileName, context)) {
2033       NodeTemplate nodeTemplate =
2034           getComputeNodeTemplate(origNodeTemplateId, serviceTemplate, context);
2035       return getComputeTypeSuffix(nodeTemplate.getType());
2036     }
2037
2038     return null;
2039   }
2040
2041   private ComputeTemplateConsolidationData getConnectedComputeConsolidationData(
2042       List<UnifiedCompositionData> unifiedCompositionDataList,
2043       String portNodeTemplateId) {
2044     for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
2045       Collection<List<String>> portsCollection =
2046           unifiedCompositionData.getComputeTemplateConsolidationData().getPorts().values();
2047       for (List<String> portIdList : portsCollection) {
2048         if (portIdList.contains(portNodeTemplateId)) {
2049           return unifiedCompositionData.getComputeTemplateConsolidationData();
2050         }
2051 //        for (String portId : portIdList) {
2052 //          if (portId.equals(portNodeTemplateId)) {
2053 //            return unifiedCompositionData.getComputeTemplateConsolidationData();
2054 //          }
2055 //        }
2056       }
2057     }
2058     return null;
2059   }
2060
2061   private Object getClonedPropertyValue(Map.Entry<String, Object> propertyEntry) {
2062     if (propertyEntry.getValue() instanceof Map) {
2063       return getClonedObject(propertyEntry.getValue(), Map.class);
2064     } else if (propertyEntry.getValue() instanceof List) {
2065       return getClonedObject(propertyEntry.getValue(), List.class);
2066     }
2067     return propertyEntry.getValue();
2068   }
2069
2070
2071   private String getParameterId(String nodeTemplateId, NodeTemplate nodeTemplate, String propertyId,
2072                                 UnifiedCompositionEntity unifiedCompositionEntity,
2073                                 ComputeTemplateConsolidationData computeTemplateConsolidationData) {
2074     switch (unifiedCompositionEntity) {
2075       case Compute:
2076         return UnifiedCompositionEntity.Compute.name().toLowerCase() + "_"
2077             + getComputeTypeSuffix(nodeTemplate.getType()) + "_" + propertyId;
2078       case Port:
2079         String portType = ConsolidationDataUtil.getPortType(nodeTemplateId);
2080         if (Objects.isNull(computeTemplateConsolidationData)
2081             || computeTemplateConsolidationData.getPorts().get(portType).size() > 1) {
2082           return UnifiedCompositionEntity.Port.name().toLowerCase() + "_" + nodeTemplateId + "_"
2083               + propertyId;
2084         }
2085         return UnifiedCompositionEntity.Port.name().toLowerCase() + "_" + portType + "_"
2086             + propertyId;
2087       default:
2088         return propertyId;
2089     }
2090   }
2091
2092   private void removeConnectivityOut(EntityConsolidationData entityConsolidationData,
2093                                      NodeTemplate nodeTemplate) {
2094     if (MapUtils.isEmpty(entityConsolidationData.getNodesConnectedOut())) {
2095       return;
2096     }
2097
2098     for (List<RequirementAssignmentData> requirementAssignmentDataList : entityConsolidationData
2099         .getNodesConnectedOut().values()) {
2100       for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList) {
2101         DataModelUtil.removeRequirementsAssignment(nodeTemplate.getRequirements(),
2102             requirementAssignmentData.getRequirementId());
2103       }
2104       if (nodeTemplate.getRequirements().isEmpty()) {
2105         nodeTemplate.setRequirements(null);
2106       }
2107     }
2108   }
2109
2110   private void removeVolumeConnectivity(
2111       ComputeTemplateConsolidationData computeTemplateConsolidationData,
2112       NodeTemplate computeNodeTemplate) {
2113     if (MapUtils.isEmpty(computeTemplateConsolidationData.getVolumes())) {
2114       return;
2115     }
2116     Collection<List<RequirementAssignmentData>> volumeCollection =
2117         computeTemplateConsolidationData.getVolumes().values();
2118     for (List<RequirementAssignmentData> requirementAssignmentDataList : volumeCollection) {
2119       for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList) {
2120         DataModelUtil.removeRequirementsAssignment(computeNodeTemplate.getRequirements(),
2121             requirementAssignmentData.getRequirementId());
2122       }
2123     }
2124     if (computeNodeTemplate.getRequirements().isEmpty()) {
2125       computeNodeTemplate.setRequirements(null);
2126     }
2127   }
2128
2129   private void createIndexInputParameter(ServiceTemplate substitutionServiceTemplate) {
2130     ParameterDefinition indexParameterDefinition =
2131         DataModelUtil.createParameterDefinition(PropertyType.INTEGER.getDisplayName(),
2132             "Index value of this substitution service template runtime instance", null,
2133             false, createIndexValueConstraint(), null, null, 0);
2134     DataModelUtil.addInputParameterToTopologyTemplate(substitutionServiceTemplate,
2135         ToscaConstants.INDEX_VALUE_PROPERTY_NAME, indexParameterDefinition);
2136   }
2137
2138
2139   private List<Constraint> createIndexValueConstraint() {
2140     List<Constraint> constraints;
2141     constraints = new ArrayList<>();
2142     Constraint constraint = new Constraint();
2143     constraint.setGreater_or_equal(0);
2144     constraints.add(constraint);
2145     return constraints;
2146   }
2147
2148   private Optional<UnifiedComposition> getUnifiedCompositionInstance(UnifiedCompositionMode mode) {
2149     String unifiedCompositionImplClassName =
2150         unifiedCompositionImplMap.get(mode.name()).getImplementationClass();
2151     if (StringUtils.isEmpty(unifiedCompositionImplClassName)) {
2152       return Optional.empty();
2153     }
2154     return Optional
2155         .of(CommonMethods.newInstance(unifiedCompositionImplClassName, UnifiedComposition.class));
2156   }
2157
2158   private Optional<Map<String, Object>> createAbstractSubstitutionProperties(
2159       ServiceTemplate serviceTemplate,
2160       ServiceTemplate substitutionServiceTemplate,
2161       List<UnifiedCompositionData> unifiedCompositionDataList,
2162       TranslationContext context) {
2163     Map<String, Object> abstractSubstituteProperties = new LinkedHashMap<>();
2164     Map<String, ParameterDefinition> substitutionTemplateInputs = DataModelUtil
2165         .getInputParameters(substitutionServiceTemplate);
2166     if (substitutionTemplateInputs == null) {
2167       return Optional.empty();
2168     }
2169     //Since all the computes have the same type fetching the type from the first entry
2170     NodeTemplate firstComputeNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
2171         unifiedCompositionDataList.get(0)
2172             .getComputeTemplateConsolidationData().getNodeTemplateId());
2173     String computeType = getComputeTypeSuffix(firstComputeNodeTemplate.getType());
2174     for (Map.Entry<String, ParameterDefinition> input : substitutionTemplateInputs.entrySet()) {
2175       String substitutionTemplateInputName = input.getKey();
2176       ParameterDefinition inputParameterDefinition = input.getValue();
2177       String inputType = inputParameterDefinition.getType();
2178       UnifiedCompositionEntity inputUnifiedCompositionEntity =
2179           getInputCompositionEntity(substitutionTemplateInputName);
2180
2181       if (!inputType.equalsIgnoreCase(PropertyType.LIST.getDisplayName())) {
2182         if (isIdenticalValueProperty(
2183             substitutionTemplateInputName, inputUnifiedCompositionEntity, context)) {
2184           //Handle identical value properties
2185           Optional<String> identicalValuePropertyName =
2186               getIdenticalValuePropertyName(substitutionTemplateInputName,
2187                   inputUnifiedCompositionEntity, context);
2188
2189           if (identicalValuePropertyName.isPresent()) {
2190             updateIdenticalPropertyValue(identicalValuePropertyName.get(),
2191                 substitutionTemplateInputName, computeType, inputUnifiedCompositionEntity,
2192                 unifiedCompositionDataList.get(0), serviceTemplate, abstractSubstituteProperties);
2193           }
2194         }
2195         continue;
2196       }
2197
2198       //Check if the input is of type compute or port
2199       List<Object> abstractPropertyValue = new ArrayList<>();
2200       Object propertyValue = null;
2201       switch (inputUnifiedCompositionEntity) {
2202         case Compute:
2203           for (UnifiedCompositionData compositionData : unifiedCompositionDataList) {
2204             ComputeTemplateConsolidationData computeTemplateConsolidationData =
2205                 compositionData.getComputeTemplateConsolidationData();
2206             propertyValue = getComputePropertyValue(substitutionTemplateInputName,
2207                 serviceTemplate, computeTemplateConsolidationData);
2208             if (!(propertyValue instanceof Optional)) {
2209               abstractPropertyValue.add(propertyValue);
2210             }
2211           }
2212           break;
2213         case Port:
2214           for (UnifiedCompositionData compositionData : unifiedCompositionDataList) {
2215             List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
2216                 getPortTemplateConsolidationDataList(compositionData);
2217             //Get the input type for this input whether it is of type
2218             // port_<port_node_template_id>_<property_name> or port_<port_type>_<property_name>
2219             PortInputType portInputType = getPortInputType(substitutionTemplateInputName,
2220                 compositionData);
2221             for (PortTemplateConsolidationData portTemplateConsolidationData :
2222                 portTemplateConsolidationDataList) {
2223               //Get the port property value
2224               String portNodeTemplateId = portTemplateConsolidationData.getNodeTemplateId();
2225               propertyValue = getPortPropertyValue(substitutionTemplateInputName,
2226                   computeType, portInputType, serviceTemplate,
2227                   portNodeTemplateId);
2228               //If the value object is Optional.empty it implies that the property name was not
2229               // found in the input name
2230               if (!(propertyValue instanceof Optional)) {
2231                 abstractPropertyValue.add(propertyValue);
2232               }
2233             }
2234           }
2235           break;
2236         default:
2237           break;
2238       }
2239       //Add the property only if it has at least one non-null value
2240       for (Object val : abstractPropertyValue) {
2241         if (Objects.nonNull(val)) {
2242           abstractSubstituteProperties.put(substitutionTemplateInputName, abstractPropertyValue);
2243           break;
2244         }
2245       }
2246     }
2247     return Optional.ofNullable(abstractSubstituteProperties);
2248   }
2249
2250   private void updateIdenticalPropertyValue(String identicalValuePropertyName,
2251                                             String substitutionTemplateInputName,
2252                                             String computeType,
2253                                             UnifiedCompositionEntity entity,
2254                                             UnifiedCompositionData unifiedCompositionData,
2255                                             ServiceTemplate serviceTemplate,
2256                                             Map<String, Object> abstractSubstituteProperties){
2257     Optional<Object> identicalPropertyValueByType =
2258         getIdenticalPropertyValueByType(identicalValuePropertyName, substitutionTemplateInputName,
2259             computeType, entity, unifiedCompositionData, serviceTemplate);
2260
2261     if(identicalPropertyValueByType.isPresent()){
2262       abstractSubstituteProperties
2263           .put(substitutionTemplateInputName, identicalPropertyValueByType.get());
2264
2265     }
2266
2267
2268   }
2269
2270   private Optional<Object> getIdenticalPropertyValueByType(String identicalValuePropertyName,
2271                                                            String substitutionTemplateInputName,
2272                                                            String computeType,
2273                                                            UnifiedCompositionEntity entity,
2274                                                            UnifiedCompositionData unifiedCompositionData,
2275                                                            ServiceTemplate serviceTemplate) {
2276
2277     ComputeTemplateConsolidationData computeTemplateConsolidationData =
2278         unifiedCompositionData.getComputeTemplateConsolidationData();
2279
2280     Optional<Object> computeIdenticalPropertyValue;
2281     switch (entity) {
2282       case Compute:
2283         computeIdenticalPropertyValue =
2284             getIdenticalPropertyValue(identicalValuePropertyName, serviceTemplate,
2285                 entity, computeTemplateConsolidationData);
2286         return computeIdenticalPropertyValue.isPresent() ? Optional.of(
2287             computeIdenticalPropertyValue.get()) : Optional.empty();
2288
2289       case Other:
2290         computeIdenticalPropertyValue =
2291             getIdenticalPropertyValue(identicalValuePropertyName, serviceTemplate,
2292                 entity, computeTemplateConsolidationData);
2293         return computeIdenticalPropertyValue.isPresent() ? Optional.of(
2294             computeIdenticalPropertyValue.get()) : Optional.empty();
2295
2296       case Port:
2297         List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
2298             unifiedCompositionData.getPortTemplateConsolidationDataList();
2299         for (PortTemplateConsolidationData portTemplateConsolidationData : portTemplateConsolidationDataList) {
2300           String portType =
2301               ConsolidationDataUtil.getPortType(portTemplateConsolidationData.getNodeTemplateId());
2302           if (substitutionTemplateInputName.contains(portType)) {
2303             return getIdenticalPropertyValue(identicalValuePropertyName, serviceTemplate,
2304                 entity, portTemplateConsolidationData);
2305           }
2306         }
2307     }
2308
2309     return Optional.empty();
2310
2311   }
2312
2313
2314   private PortInputType getPortInputType(String inputName,
2315                                          UnifiedCompositionData unifiedCompositionData) {
2316     String portInputPrefix = UnifiedCompositionEntity.Port.name().toLowerCase() + "_";
2317     ComputeTemplateConsolidationData computeTemplateConsolidationData = unifiedCompositionData
2318         .getComputeTemplateConsolidationData();
2319     List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
2320         getPortTemplateConsolidationDataList(unifiedCompositionData);
2321     //Scan the available port node template ids to check if the input is of the form
2322     // "port_<port_node_template_id>_<property_name>"
2323     for (PortTemplateConsolidationData portTemplateConsolidationData :
2324         portTemplateConsolidationDataList) {
2325       String portNodeTemplateId = portTemplateConsolidationData.getNodeTemplateId();
2326       String portNodeTemplateIdPrefix = portInputPrefix + portNodeTemplateId;
2327       if (inputName.startsWith(portNodeTemplateIdPrefix)) {
2328         return PortInputType.NodeTemplateId;
2329       }
2330     }
2331     //Check whether the input is of the form "port_<port_type>_<property_name>"
2332     Set<String> portTypes = computeTemplateConsolidationData.getPorts().keySet();
2333     for (String portType : portTypes) {
2334       String expectedPortTypeSusbtring = portInputPrefix + portType + "_";
2335       if (inputName.startsWith(expectedPortTypeSusbtring)) {
2336         return PortInputType.PortType;
2337       }
2338     }
2339     return PortInputType.Other;
2340   }
2341
2342   private void cleanServiceTemplate(ServiceTemplate serviceTemplate,
2343                                     EntityConsolidationData entity,
2344                                     TranslationContext context) {
2345     removeNodeTemplateFromServiceTemplate(serviceTemplate, entity, context);
2346     updateHeatStackGroup(serviceTemplate, entity, context);
2347   }
2348
2349   private void removeNodeTemplateFromServiceTemplate(ServiceTemplate serviceTemplate,
2350                                                      EntityConsolidationData entity,
2351                                                      TranslationContext context) {
2352     String nodeTemplateIdToRemove = entity.getNodeTemplateId();
2353     Map<String, NodeTemplate> nodeTemplates =
2354         serviceTemplate.getTopology_template().getNode_templates();
2355     NodeTemplate nodeTemplateToRemove =
2356         nodeTemplates.get(nodeTemplateIdToRemove);
2357     nodeTemplates.remove(nodeTemplateIdToRemove);
2358
2359     context.addCleanedNodeTemplate(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
2360         nodeTemplateIdToRemove,
2361         entity.getClass() == ComputeTemplateConsolidationData.class
2362             ? UnifiedCompositionEntity.Compute
2363             : UnifiedCompositionEntity.Port,
2364         nodeTemplateToRemove);
2365
2366   }
2367
2368   private void removeCleanedNodeType(String cleanedNodeTemplateId,
2369                                      ServiceTemplate serviceTemplate,
2370                                      TranslationContext context) {
2371     NodeTemplate cleanedNodeTemplate =
2372         context
2373             .getCleanedNodeTemplate(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
2374                 cleanedNodeTemplateId);
2375     String typeToRemove = cleanedNodeTemplate.getType();
2376
2377     if (Objects.nonNull(typeToRemove)
2378         && serviceTemplate.getNode_types().containsKey(typeToRemove)) {
2379       serviceTemplate.getNode_types().remove(typeToRemove);
2380     }
2381   }
2382
2383   private void updateHeatStackGroup(ServiceTemplate serviceTemplate,
2384                                     EntityConsolidationData entity,
2385                                     TranslationContext context) {
2386     Map<String, GroupDefinition> groups = serviceTemplate.getTopology_template()
2387         .getGroups() == null ? new HashMap<>()
2388         : serviceTemplate.getTopology_template().getGroups();
2389     String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
2390     String nodeRelatedAbstractNodeId =
2391         context.getUnifiedAbstractNodeTemplateId(serviceTemplate, entity.getNodeTemplateId());
2392
2393     for (Map.Entry<String, GroupDefinition> groupEntry : groups.entrySet()) {
2394       GroupDefinition groupDefinition = groupEntry.getValue();
2395       if (isHeatStackGroup(groupDefinition.getType())) {
2396         updateGroupMembersWithNewUnifiedNodeTemplateId(entity, nodeRelatedAbstractNodeId,
2397             groupEntry);
2398       }
2399     }
2400   }
2401
2402   private void updateGroupMembersWithNewUnifiedNodeTemplateId(
2403       EntityConsolidationData entity,
2404       String newNodetemplateId,
2405       Map.Entry<String, GroupDefinition> groupEntry) {
2406     List<String> members = groupEntry.getValue().getMembers();
2407     if (members.contains(entity.getNodeTemplateId())) {
2408       members.remove(entity.getNodeTemplateId());
2409       if (!members.contains(newNodetemplateId)) {
2410         members.add(newNodetemplateId);
2411       }
2412     }
2413     groupEntry.getValue().setMembers(members);
2414   }
2415
2416   private void updateHeatStackGroupNestedComposition(ServiceTemplate serviceTemplate,
2417                                                      EntityConsolidationData entity,
2418                                                      TranslationContext context) {
2419     Map<String, GroupDefinition> groups = serviceTemplate.getTopology_template()
2420         .getGroups() == null ? new HashMap<>() : serviceTemplate.getTopology_template().getGroups();
2421     String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
2422     Optional<String> nestedNodeTemplateId =
2423         context.getUnifiedNestedNodeTemplateId(serviceTemplateFileName, entity.getNodeTemplateId());
2424     if (nestedNodeTemplateId.isPresent()) {
2425       for (Map.Entry<String, GroupDefinition> groupEntry : groups.entrySet()) {
2426         GroupDefinition groupDefinition = groupEntry.getValue();
2427         if (isHeatStackGroup(groupDefinition.getType())) {
2428           updateGroupMembersWithNewUnifiedNodeTemplateId(entity, nestedNodeTemplateId.get(),
2429               groupEntry);
2430         }
2431       }
2432     }
2433   }
2434
2435   private void handleNestedNodeTemplateInMainServiceTemplate(String nestedNodeTemplateId,
2436                                                              ServiceTemplate mainServiceTemplate,
2437                                                              ServiceTemplate nestedServiceTemplate,
2438                                                              TranslationContext context) {
2439     NodeTemplate nestedNodeTemplate = DataModelUtil.getNodeTemplate(mainServiceTemplate,
2440         nestedNodeTemplateId);
2441     if (Objects.isNull(nestedNodeTemplate)) {
2442       return;
2443     }
2444
2445     Optional<String> unifiedNestedNodeTypeId = context
2446         .getUnifiedNestedNodeTypeId(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME,
2447             nestedNodeTemplate.getType());
2448     unifiedNestedNodeTypeId
2449         .ifPresent(unifiedNestedNodeTypeIdVal -> updateNestedNodeTemplate(
2450             unifiedNestedNodeTypeIdVal, nestedNodeTemplateId, nestedNodeTemplate,
2451             mainServiceTemplate, nestedServiceTemplate, context));
2452   }
2453
2454   private void handleSubstitutionMappingInNestedServiceTemplate(
2455       String newNestedNodeType,
2456       ServiceTemplate nestedServiceTemplate) {
2457     if (Objects.isNull(newNestedNodeType)) {
2458       return;
2459     }
2460
2461     SubstitutionMapping substitutionMappings =
2462         nestedServiceTemplate.getTopology_template().getSubstitution_mappings();
2463     substitutionMappings.setNode_type(newNestedNodeType);
2464   }
2465
2466   private void updateNestedNodeTemplate(String newNestedNodeTypeId,
2467                                         String nestedNodeTemplateId,
2468                                         NodeTemplate nestedNodeTemplate,
2469                                         ServiceTemplate mainServiceTemplate,
2470                                         ServiceTemplate nestedServiceTemplate,
2471                                         TranslationContext context) {
2472     String mainServiceTemplateName = ToscaUtil.getServiceTemplateFileName(mainServiceTemplate);
2473     int index =
2474         context.getHandledNestedComputeNodeTemplateIndex(mainServiceTemplateName,
2475             newNestedNodeTypeId);
2476     String newNodeTemplateId =
2477         Constants.ABSTRACT_NODE_TEMPLATE_ID_PREFIX + getComputeTypeSuffix(newNestedNodeTypeId) +
2478             "_" + index;
2479
2480     nestedNodeTemplate.setType(newNestedNodeTypeId);
2481     mainServiceTemplate.getTopology_template().getNode_templates().remove(nestedNodeTemplateId);
2482     mainServiceTemplate.getTopology_template().getNode_templates()
2483         .put(newNodeTemplateId, nestedNodeTemplate);
2484
2485     context
2486         .addUnifiedNestedNodeTemplateId(mainServiceTemplateName,
2487             nestedNodeTemplateId, newNodeTemplateId);
2488   }
2489
2490   private void handleNestedNodeTypesInGlobalSubstituteServiceTemplate(
2491       String origNestedNodeTypeId,
2492       String newNestedNodeTypeId,
2493       ServiceTemplate globalSubstitutionServiceTemplate,
2494       TranslationContext context) {
2495     Map<String, NodeType> nodeTypes = globalSubstitutionServiceTemplate.getNode_types();
2496     NodeType nested = DataModelUtil.getNodeType(globalSubstitutionServiceTemplate,
2497         origNestedNodeTypeId);
2498     setNewValuesForNestedNodeType(origNestedNodeTypeId, newNestedNodeTypeId, nested, nodeTypes);
2499     context.addUnifiedNestedNodeTypeId(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME,
2500         origNestedNodeTypeId, newNestedNodeTypeId);
2501   }
2502
2503   private void setNewValuesForNestedNodeType(String origNestedNodeType,
2504                                              String newNestedNodeTypeId,
2505                                              NodeType nested,
2506                                              Map<String, NodeType> nodeTypes) {
2507     if (Objects.nonNull(nested)) {
2508       nested.setDerived_from(ToscaNodeType.VFC_ABSTRACT_SUBSTITUTE);
2509       nodeTypes.remove(origNestedNodeType);
2510       nodeTypes.put(newNestedNodeTypeId, nested);
2511     }
2512   }
2513
2514   private Optional<String> getNewNestedNodeTypeId(ServiceTemplate mainServiceTemplate,
2515                                                   ServiceTemplate nestedServiceTemplate,
2516                                                   TranslationContext context) {
2517     FileComputeConsolidationData fileComputeConsolidationData =
2518         context.getConsolidationData().getComputeConsolidationData()
2519             .getFileComputeConsolidationData(
2520                 ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate));
2521
2522     if (Objects.nonNull(fileComputeConsolidationData)) {
2523       String nestedNodeTypePrefix = ToscaNodeType.ABSTRACT_NODE_TYPE_PREFIX + "heat.";
2524       return Optional
2525           .of(nestedNodeTypePrefix + getComputeTypeInNestedFile(fileComputeConsolidationData));
2526     }
2527     return Optional.empty();
2528   }
2529
2530   private String getComputeTypeInNestedFile(
2531       FileComputeConsolidationData fileComputeConsolidationData) {
2532     List<TypeComputeConsolidationData> typeComputeConsolidationDatas =
2533         new ArrayList<>(fileComputeConsolidationData.getAllTypeComputeConsolidationData());
2534     if (typeComputeConsolidationDatas.size() == 0) {
2535       return null;
2536     } else {
2537       String computeNodeType = fileComputeConsolidationData.getAllComputeTypes().iterator().next();
2538       return getComputeTypeSuffix(computeNodeType);
2539     }
2540   }
2541
2542   private void handleGetAttrInAbstractNodeTemplate(ServiceTemplate serviceTemplate,
2543                                                    TranslationContext context,
2544                                                    String serviceTemplateFileName,
2545                                                    NodeTemplate abstractNodeTemplate) {
2546     Map<String, Object> properties =
2547         abstractNodeTemplate == null || abstractNodeTemplate.getProperties() == null
2548             ? new HashMap<>()
2549             : abstractNodeTemplate.getProperties();
2550     for (Object propertyValue : properties.values()) {
2551       List<List<Object>> getAttrList = extractGetAttrFunction(propertyValue);
2552       for (List<Object> getAttrFuncValue : getAttrList) {
2553         String origNodeTemplateId = (String) getAttrFuncValue.get(0);
2554         Optional<String> nestedNodeTemplateId = context.getUnifiedNestedNodeTemplateId(ToscaUtil
2555             .getServiceTemplateFileName(serviceTemplate), origNodeTemplateId);
2556         if (nestedNodeTemplateId.isPresent()) {
2557           getAttrFuncValue.set(0, nestedNodeTemplateId.get());
2558         } else {
2559           replaceGetAttrNodeIdAndAttrName(serviceTemplate, context, serviceTemplateFileName,
2560               getAttrFuncValue);
2561         }
2562       }
2563     }
2564   }
2565
2566   private void replaceGetAttrNodeIdAndAttrName(ServiceTemplate serviceTemplate,
2567                                                TranslationContext context,
2568                                                String serviceTemplateFileName,
2569                                                List<Object> getAttrFuncValue) {
2570     String origNodeTemplateId = (String) getAttrFuncValue.get(0);
2571     String attributeName = (String) getAttrFuncValue.get(1);
2572
2573     String unifiedAbstractNodeTemplateId =
2574         context.getUnifiedAbstractNodeTemplateId(serviceTemplate, origNodeTemplateId);
2575
2576     if (Objects.isNull(unifiedAbstractNodeTemplateId)) {
2577       return;
2578     }
2579
2580     String newNodeTemplateId =
2581         getNewNodeTemplateId(origNodeTemplateId, serviceTemplateFileName, serviceTemplate, context);
2582
2583     String newSubstitutionOutputParameterId =
2584         getNewSubstitutionOutputParameterId(newNodeTemplateId, attributeName);
2585
2586     getAttrFuncValue.set(0, unifiedAbstractNodeTemplateId);
2587     getAttrFuncValue.set(1, newSubstitutionOutputParameterId);
2588   }
2589
2590   private NodeTemplate getComputeNodeTemplate(String origNodeTemplateId,
2591                                               ServiceTemplate serviceTemplate,
2592                                               TranslationContext context) {
2593     NodeTemplate computeNodeTemplate =
2594         DataModelUtil.getNodeTemplate(serviceTemplate, origNodeTemplateId);
2595     if (computeNodeTemplate == null) {
2596       computeNodeTemplate =
2597           context.getCleanedNodeTemplate(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
2598               origNodeTemplateId);
2599     }
2600     return computeNodeTemplate;
2601   }
2602
2603   private String handleIdOfPort(String origNodeTemplateId, String serviceTemplateFileName,
2604                                 ConsolidationData consolidationData) {
2605     Optional<Pair<String, ComputeTemplateConsolidationData>>
2606         computeTypeAndComputeTemplateByPortId =
2607         getComputeTypeAndComputeTemplateByPortId(origNodeTemplateId, serviceTemplateFileName,
2608             consolidationData);
2609     if (computeTypeAndComputeTemplateByPortId.isPresent()) {
2610       Pair<String, ComputeTemplateConsolidationData> computeIdToComputeData =
2611           computeTypeAndComputeTemplateByPortId.get();
2612       return getNewPortNodeTemplateId(origNodeTemplateId, computeIdToComputeData.getKey(),
2613           computeIdToComputeData.getValue());
2614     }
2615
2616     return null;
2617   }
2618
2619   private Optional<Pair<String, ComputeTemplateConsolidationData>>
2620   getComputeTypeAndComputeTemplateByPortId(String portId, String serviceTemplateFileName,
2621                                            ConsolidationData consolidationData) {
2622     FileComputeConsolidationData fileComputeConsolidationData =
2623         consolidationData.getComputeConsolidationData()
2624             .getFileComputeConsolidationData(serviceTemplateFileName);
2625     Set<String> computeTypes =
2626         fileComputeConsolidationData.getAllComputeTypes();
2627
2628     for (String computeType : computeTypes) {
2629       Collection<ComputeTemplateConsolidationData> computeTemplateConsolidationDatas =
2630           fileComputeConsolidationData.getTypeComputeConsolidationData(computeType)
2631               .getAllComputeTemplateConsolidationData();
2632
2633       for (ComputeTemplateConsolidationData compute : computeTemplateConsolidationDatas) {
2634         if (ConsolidationDataUtil.isComputeReferenceToPortId(compute, portId)) {
2635           return Optional.of(new ImmutablePair<>(computeType, compute));
2636         }
2637       }
2638     }
2639
2640     return Optional.empty();
2641   }
2642
2643   private boolean isIdIsOfExpectedType(String id,
2644                                        UnifiedCompositionEntity expectedUnifiedCompositionEntity,
2645                                        String serviceTemplateFileName,
2646                                        TranslationContext context) {
2647     UnifiedSubstitutionData unifiedSubstitutionData =
2648         context.getUnifiedSubstitutionData().get(serviceTemplateFileName);
2649     if (Objects.isNull(unifiedSubstitutionData)) {
2650       return false;
2651     }
2652
2653     UnifiedCompositionEntity actualUnifiedCompositionEntity =
2654         unifiedSubstitutionData.getCleanedNodeTemplateCompositionEntity(id);
2655
2656     return actualUnifiedCompositionEntity == null ? false
2657         : actualUnifiedCompositionEntity.equals(expectedUnifiedCompositionEntity);
2658   }
2659
2660   private boolean isHeatStackGroup(String groupType) {
2661     return groupType.equals(ToscaGroupType.HEAT_STACK);
2662   }
2663
2664   private Object getPortPropertyValue(String inputName,
2665                                       String computeType,
2666                                       PortInputType portInputType,
2667                                       ServiceTemplate serviceTemplate,
2668                                       String portNodeTemplateId) {
2669     //Get the input prefix to extract the property name from the input name
2670     String portInputPrefix = getPortInputPrefix(
2671         portNodeTemplateId, portInputType);
2672     //Get the property name from the input
2673     Optional<String> propertyName = getPropertyNameFromInput(inputName,
2674         UnifiedCompositionEntity.Port, computeType, portInputPrefix);
2675     //Get the property value from the node template
2676     if (propertyName.isPresent()) {
2677       NodeTemplate portNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
2678           portNodeTemplateId);
2679       if (Objects.nonNull(portNodeTemplate)) {
2680         return getPropertyValueFromNodeTemplate(propertyName.get(), portNodeTemplate);
2681       }
2682     }
2683     return Optional.empty();
2684   }
2685
2686   private Optional<String> getPortTypeFromInput(
2687       String inputName,
2688       String portNodeTemplateId,
2689       ComputeTemplateConsolidationData computeTemplateConsolidationData) {
2690     String portTypeFromInput = null;
2691     String portInputPrefix = UnifiedCompositionEntity.Port.name().toLowerCase() + "_";
2692     String portNodeTemplateIdPrefix = portInputPrefix + portNodeTemplateId;
2693     if (inputName.startsWith(portNodeTemplateIdPrefix)) {
2694       return Optional.empty();
2695     }
2696     Set<String> portTypes = computeTemplateConsolidationData.getPorts().keySet();
2697     for (String portType : portTypes) {
2698       String expectedPortTypeSusbtring = "_" + portType + "_";
2699       if (inputName.contains(expectedPortTypeSusbtring)) {
2700         portTypeFromInput = portType;
2701         break;
2702       }
2703     }
2704     return Optional.ofNullable(portTypeFromInput);
2705   }
2706
2707   private Object getComputePropertyValue(
2708       String inputName,
2709       ServiceTemplate serviceTemplate,
2710       ComputeTemplateConsolidationData computeTemplateConsolidationData) {
2711     NodeTemplate nodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
2712         computeTemplateConsolidationData.getNodeTemplateId());
2713     String nodeType = getComputeTypeSuffix(nodeTemplate.getType());
2714     Optional<String> propertyName =
2715         getPropertyNameFromInput(inputName, UnifiedCompositionEntity.Compute, nodeType, null);
2716     if (propertyName.isPresent()) {
2717       return getPropertyValueFromNodeTemplate(propertyName.get(), nodeTemplate);
2718     }
2719     return Optional.empty();
2720   }
2721
2722   private Optional<Object> getIdenticalPropertyValue(String identicalValuePropertyName,
2723                                                      ServiceTemplate serviceTemplate,
2724                                                      UnifiedCompositionEntity unifiedCompositionEntity,
2725                                                      EntityConsolidationData entity){
2726     NodeTemplate nodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
2727         entity.getNodeTemplateId());
2728
2729     Object propertyValueFromNodeTemplate =
2730         getPropertyValueFromNodeTemplate(identicalValuePropertyName, nodeTemplate);
2731
2732     return Objects.isNull(propertyValueFromNodeTemplate) ? Optional.empty()
2733     :Optional.of(propertyValueFromNodeTemplate);
2734   }
2735
2736   private UnifiedCompositionEntity getInputCompositionEntity(String inputName) {
2737     UnifiedCompositionEntity inputCompositionEntity = UnifiedCompositionEntity.Other;
2738     String inputType = inputName.substring(0, inputName.indexOf('_'));
2739     if (inputType.equals(UnifiedCompositionEntity.Compute.name().toLowerCase())) {
2740       inputCompositionEntity = UnifiedCompositionEntity.Compute;
2741     } else if (inputType.equals(UnifiedCompositionEntity.Port.name().toLowerCase())) {
2742       inputCompositionEntity = UnifiedCompositionEntity.Port;
2743     }
2744     return inputCompositionEntity;
2745   }
2746
2747   private Optional<String> getPropertyNameFromInput(
2748       String inputName,
2749       UnifiedCompositionEntity compositionEntity,
2750       String computeType, String portInputPrefix) {
2751     String propertyName = null;
2752     switch (compositionEntity) {
2753       case Compute:
2754         propertyName = inputName.substring(inputName.lastIndexOf(computeType)
2755             + computeType.length() + 1);
2756         break;
2757       case Port:
2758         if (inputName.startsWith(portInputPrefix)) {
2759           propertyName = inputName.split(portInputPrefix)[1];
2760         }
2761         break;
2762       default:
2763         break;
2764     }
2765     return Optional.ofNullable(propertyName);
2766   }
2767
2768   private String getPortInputPrefix(
2769       String portNodeTemplateId,
2770       PortInputType portInputType) {
2771     String portInputPrefix = UnifiedCompositionEntity.Port.name().toLowerCase() + "_";
2772     String portType = ConsolidationDataUtil.getPortType(portNodeTemplateId);
2773     if (portInputType == PortInputType.NodeTemplateId) {
2774       portInputPrefix += portNodeTemplateId + "_";
2775     } else if (portInputType == PortInputType.PortType) {
2776       portInputPrefix += portType + "_";
2777     }
2778     return portInputPrefix;
2779   }
2780
2781   private boolean isIdenticalValueProperty(String inputName,
2782                                            UnifiedCompositionEntity unifiedCompositionEntity,
2783                                            TranslationContext context) {
2784
2785     List<String> identicalValuePropertyList =
2786         consolidationService.getPropertiesWithIdenticalVal(unifiedCompositionEntity, context);
2787
2788     StringBuilder builder = getPropertyValueStringBuilder(unifiedCompositionEntity);
2789
2790     boolean isMatchingProperty = Pattern.matches(builder.toString(), inputName);
2791     return (isMatchingProperty
2792         && isPropertyFromIdenticalValuesList(inputName, unifiedCompositionEntity,
2793         identicalValuePropertyList));
2794   }
2795
2796   private boolean isPropertyFromIdenticalValuesList(String inputName,
2797                                                     UnifiedCompositionEntity unifiedCompositionEntity,
2798                                                     List<String> identicalValuePropertyList) {
2799     switch (unifiedCompositionEntity) {
2800       case Compute:
2801         return identicalValuePropertyList.contains(getIdenticalValuePropertyName(inputName,
2802             unifiedCompositionEntity, null).get());
2803
2804       case Other:
2805         return identicalValuePropertyList.contains(getIdenticalValuePropertyName(inputName,
2806             unifiedCompositionEntity, null).get());
2807
2808       case Port:
2809         return getPortPropertyNameFromInput(inputName, identicalValuePropertyList).isPresent();
2810
2811       default:
2812         return false;
2813     }
2814   }
2815
2816   private Optional<String> getPortPropertyNameFromInput(String inputName,
2817                                                         List<String> identicalValuePropertyList) {
2818     for (String identicalProperty : identicalValuePropertyList) {
2819       if (inputName.contains(identicalProperty)) {
2820         return Optional.of(identicalProperty);
2821       }
2822     }
2823     return Optional.empty();
2824   }
2825
2826   private StringBuilder getPropertyValueStringBuilder(
2827       UnifiedCompositionEntity unifiedCompositionEntity) {
2828
2829     switch (unifiedCompositionEntity) {
2830       case Compute:
2831         return getComputePropertyValueStringBuilder();
2832
2833       case Other:
2834         return getComputePropertyValueStringBuilder();
2835
2836       case Port:
2837         return getPortPropertyValueStringBuilder();
2838
2839       default:
2840         return null;
2841     }
2842   }
2843
2844   private StringBuilder getPortPropertyValueStringBuilder() {
2845     StringBuilder builder;
2846     builder = new StringBuilder(PORT_IDENTICAL_VALUE_PROPERTY_PREFIX);
2847     builder.append(".+");
2848     return builder;
2849   }
2850
2851   private StringBuilder getComputePropertyValueStringBuilder() {
2852     StringBuilder builder;
2853     builder = new StringBuilder(COMPUTE_IDENTICAL_VALUE_PROPERTY_PREFIX);
2854     builder.append("[a-z]+");
2855     builder.append(COMPUTE_IDENTICAL_VALUE_PROPERTY_SUFFIX);
2856     return builder;
2857   }
2858
2859   private Optional<String> getIdenticalValuePropertyName(String input,
2860                                                          UnifiedCompositionEntity unifiedCompositionEntity,
2861                                                          TranslationContext context) {
2862     switch (unifiedCompositionEntity) {
2863       case Compute:
2864         return Optional.of(input.split("_")[1]);
2865
2866       case Other:
2867         return Optional.of(input.split("_")[1]);
2868
2869       case Port:
2870         return getPortPropertyNameFromInput(input, consolidationService
2871             .getPropertiesWithIdenticalVal(unifiedCompositionEntity, context));
2872
2873       default:
2874         return Optional.empty();
2875     }
2876   }
2877
2878   private Object getPropertyValueFromNodeTemplate(String propertyName, NodeTemplate nodeTemplate) {
2879     Map<String, Object> nodeTemplateProperties = nodeTemplate.getProperties();
2880     if (nodeTemplateProperties != null) {
2881       Object propertyValue = nodeTemplateProperties.get(propertyName);
2882       propertyValue = getClonedObject(propertyValue);
2883       return propertyValue;
2884     }
2885     return null;
2886   }
2887
2888   private <T> Object getClonedObject(Object objectValue, Class<T> clazz) {
2889     YamlUtil yamlUtil = new YamlUtil();
2890     Object clonedObjectValue;
2891     String objectToYaml = yamlUtil.objectToYaml(objectValue);
2892     clonedObjectValue = yamlUtil.yamlToObject(objectToYaml, clazz);
2893     return clonedObjectValue;
2894   }
2895
2896   private Object getClonedObject(Object objectValue) {
2897     Object clonedObjectValue;
2898     try {
2899       ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
2900       ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
2901       objectOutputStream.writeObject(objectValue);
2902
2903       ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream
2904           .toByteArray());
2905       ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
2906       clonedObjectValue = objectInputStream.readObject();
2907     } catch (NotSerializableException ex) {
2908       return getClonedObject(objectValue, objectValue.getClass());
2909     } catch (IOException ioe) {
2910       return null;
2911     } catch (ClassNotFoundException cnfe) {
2912       return null;
2913     }
2914     return clonedObjectValue;
2915   }
2916
2917   private Map<String, UnifiedCompositionEntity> getAllConsolidationNodeTemplateIdAndType(
2918       List<UnifiedCompositionData> unifiedCompositionDataList) {
2919
2920     Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType = new HashMap<>();
2921     for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
2922       ComputeTemplateConsolidationData computeTemplateConsolidationData =
2923           unifiedCompositionData.getComputeTemplateConsolidationData();
2924       if (Objects.nonNull(computeTemplateConsolidationData)) {
2925         consolidationNodeTemplateIdAndType
2926             .put(computeTemplateConsolidationData.getNodeTemplateId(),
2927                 UnifiedCompositionEntity.Compute);
2928       }
2929       List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
2930           getPortTemplateConsolidationDataList(unifiedCompositionData);
2931       for (PortTemplateConsolidationData portTemplateConsolidationData :
2932           portTemplateConsolidationDataList) {
2933         consolidationNodeTemplateIdAndType.put(portTemplateConsolidationData.getNodeTemplateId(),
2934             UnifiedCompositionEntity.Port);
2935       }
2936       NestedTemplateConsolidationData nestedTemplateConsolidationData =
2937           unifiedCompositionData.getNestedTemplateConsolidationData();
2938       if (Objects.nonNull(nestedTemplateConsolidationData)) {
2939         consolidationNodeTemplateIdAndType
2940             .put(nestedTemplateConsolidationData.getNodeTemplateId(),
2941                 UnifiedCompositionEntity.Nested);
2942       }
2943     }
2944     return consolidationNodeTemplateIdAndType;
2945   }
2946
2947   private enum PortInputType {
2948     NodeTemplateId,
2949     PortType,
2950     Other;
2951   }
2952
2953   private List<PortTemplateConsolidationData> getPortTemplateConsolidationDataList(
2954       UnifiedCompositionData unifiedCompositionData) {
2955     return unifiedCompositionData.getPortTemplateConsolidationDataList() == null ? new
2956         ArrayList<>() : unifiedCompositionData.getPortTemplateConsolidationDataList();
2957   }
2958 }