gerrit.onap Code Review - sdc.git/blob

   1 /*
   2  * Copyright © 2016-2018 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.openecomp.sdc.translator.services.heattotosca;
  18
  19 import static org.openecomp.sdc.tosca.datatypes.ToscaFunctions.GET_INPUT;
  20 import static org.openecomp.sdc.tosca.datatypes.ToscaNodeType.GROUP_TYPE_PREFIX;
  21 import static org.openecomp.sdc.tosca.datatypes.ToscaNodeType.VFC_INSTANCE_GROUP;
  22 import static org.openecomp.sdc.tosca.services.DataModelUtil.getClonedObject;
  23 import static org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionEntity.COMPUTE;
  24 import static org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionEntity.PORT;
  25 import static org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionEntity.SUB_INTERFACE;
  26 import static org.openecomp.sdc.translator.services.heattotosca.Constants.ABSTRACT_NODE_TEMPLATE_ID_PREFIX;
  27 import static org.openecomp.sdc.translator.services.heattotosca.Constants.COMPUTE_IDENTICAL_VALUE_PROPERTY_PREFIX;
  28 import static org.openecomp.sdc.translator.services.heattotosca.Constants.COMPUTE_IDENTICAL_VALUE_PROPERTY_SUFFIX;
  29 import static org.openecomp.sdc.translator.services.heattotosca.Constants.GROUP;
  30 import static org.openecomp.sdc.translator.services.heattotosca.Constants.PORT_IDENTICAL_VALUE_PROPERTY_PREFIX;
  31 import static org.openecomp.sdc.translator.services.heattotosca.Constants.SUB_INTERFACE_PROPERTY_VALUE_PREFIX;
  32 import static org.openecomp.sdc.translator.services.heattotosca.Constants.SUB_INTERFACE_ROLE;
  33 import static org.openecomp.sdc.translator.services.heattotosca.Constants.VFC_PARENT_PORT_ROLE;
  34 import static org.openecomp.sdc.translator.services.heattotosca.UnifiedCompositionUtil.getComputeTypeSuffix;
  35 import static org.openecomp.sdc.translator.services.heattotosca.UnifiedCompositionUtil.getConnectedComputeConsolidationData;
  36 import static org.openecomp.sdc.translator.services.heattotosca.UnifiedCompositionUtil.getNewComputeNodeTemplateId;
  37 import static org.openecomp.sdc.translator.services.heattotosca.UnifiedCompositionUtil.getNewPortNodeTemplateId;
  38 import static org.openecomp.sdc.translator.services.heattotosca.UnifiedCompositionUtil.getNewSubInterfaceNodeTemplateId;
  39 import static org.openecomp.sdc.translator.services.heattotosca.UnifiedCompositionUtil.getSubInterfaceTemplateConsolidationDataList;
  40 import static org.openecomp.sdc.translator.services.heattotosca.UnifiedCompositionUtil.getSubInterfaceTypeSuffix;
  41
  42 import com.google.common.collect.ArrayListMultimap;
  43 import com.google.common.collect.ListMultimap;
  44 import org.apache.commons.collections.map.HashedMap;
  45 import org.apache.commons.collections4.CollectionUtils;
  46 import org.apache.commons.collections4.MapUtils;
  47 import org.apache.commons.lang3.StringUtils;
  48 import org.apache.commons.lang3.tuple.ImmutablePair;
  49 import org.apache.commons.lang3.tuple.Pair;
  50 import org.openecomp.config.api.Configuration;
  51 import org.openecomp.config.api.ConfigurationManager;
  52 import org.openecomp.core.utilities.CommonMethods;
  53 import org.openecomp.sdc.datatypes.configuration.ImplementationConfiguration;
  54 import org.openecomp.sdc.heat.services.HeatConstants;
  55 import org.openecomp.sdc.tosca.datatypes.ToscaFunctions;
  56 import org.openecomp.sdc.tosca.datatypes.ToscaGroupType;
  57 import org.openecomp.sdc.tosca.datatypes.ToscaNodeType;
  58 import org.openecomp.sdc.tosca.datatypes.ToscaRelationshipType;
  59 import org.openecomp.sdc.tosca.datatypes.model.AttributeDefinition;
  60 import org.openecomp.sdc.tosca.datatypes.model.CapabilityDefinition;
  61 import org.openecomp.sdc.tosca.datatypes.model.Constraint;
  62 import org.openecomp.sdc.tosca.datatypes.model.EntrySchema;
  63 import org.openecomp.sdc.tosca.datatypes.model.GroupDefinition;
  64 import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate;
  65 import org.openecomp.sdc.tosca.datatypes.model.NodeType;
  66 import org.openecomp.sdc.tosca.datatypes.model.ParameterDefinition;
  67 import org.openecomp.sdc.tosca.datatypes.model.PropertyDefinition;
  68 import org.openecomp.sdc.tosca.datatypes.model.PropertyType;
  69 import org.openecomp.sdc.tosca.datatypes.model.RelationshipTemplate;
  70 import org.openecomp.sdc.tosca.datatypes.model.RequirementAssignment;
  71 import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate;
  72 import org.openecomp.sdc.tosca.datatypes.model.SubstitutionMapping;
  73 import org.openecomp.sdc.tosca.datatypes.model.heatextend.ParameterDefinitionExt;
  74 import org.openecomp.sdc.tosca.datatypes.model.heatextend.PropertyTypeExt;
  75 import org.openecomp.sdc.tosca.services.DataModelUtil;
  76 import org.openecomp.sdc.tosca.services.ToscaAnalyzerService;
  77 import org.openecomp.sdc.tosca.services.ToscaConstants;
  78 import org.openecomp.sdc.tosca.services.ToscaUtil;
  79 import org.openecomp.sdc.tosca.services.impl.ToscaAnalyzerServiceImpl;
  80 import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext;
  81 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionData;
  82 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionEntity;
  83 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionMode;
  84 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedSubstitutionData;
  85 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.commands.CommandImplNames;
  86 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.commands.UnifiedSubstitutionNodeTemplateIdGenerator;
  87 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.to.UnifiedCompositionTo;
  88 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ComputeTemplateConsolidationData;
  89 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ConsolidationData;
  90 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.EntityConsolidationData;
  91 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.FileComputeConsolidationData;
  92 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.FilePortConsolidationData;
  93 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.GetAttrFuncData;
  94 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.NestedTemplateConsolidationData;
  95 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.PortTemplateConsolidationData;
  96 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.RequirementAssignmentData;
  97 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.SubInterfaceTemplateConsolidationData;
  98 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.TypeComputeConsolidationData;
  99
 100 import java.util.ArrayList;
 101 import java.util.Collection;
 102 import java.util.EnumMap;
 103 import java.util.HashMap;
 104 import java.util.HashSet;
 105 import java.util.LinkedHashMap;
 106 import java.util.List;
 107 import java.util.Map;
 108 import java.util.Objects;
 109 import java.util.Optional;
 110 import java.util.Set;
 111 import java.util.regex.Pattern;
 112 import java.util.stream.Collectors;
 113
 114 public class UnifiedCompositionService {
 115
 116   private static final Map<String, ImplementationConfiguration> unifiedCompositionImplMap;
 117
 118   private static final EnumMap<UnifiedCompositionEntity, String> unifiedSubstitutionNodeTemplateIdGeneratorImplMap;
 119
 120   static {
 121     Configuration config = ConfigurationManager.lookup();
 122     unifiedCompositionImplMap =
 123             config.populateMap(ConfigConstants.MANDATORY_UNIFIED_MODEL_NAMESPACE,
 124                     ConfigConstants.UNIFIED_COMPOSITION_IMPL_KEY, ImplementationConfiguration.class);
 125     unifiedSubstitutionNodeTemplateIdGeneratorImplMap = new EnumMap<>(UnifiedCompositionEntity.class);
 126     initNodeTemplateIdGeneratorImplMap();
 127   }
 128
 129   private static void initNodeTemplateIdGeneratorImplMap() {
 130     unifiedSubstitutionNodeTemplateIdGeneratorImplMap.put(COMPUTE, CommandImplNames
 131             .COMPUTE_NEW_NODE_TEMPLATE_ID_GENERATOR_IMPL);
 132     unifiedSubstitutionNodeTemplateIdGeneratorImplMap.put(PORT, CommandImplNames
 133             .PORT_NEW_NODE_TEMPLATE_ID_GENERATOR_IMPL);
 134     unifiedSubstitutionNodeTemplateIdGeneratorImplMap.put(SUB_INTERFACE, CommandImplNames
 135             .SUB_INTERFACE_NEW_NODE_TEMPLATE_ID_GENERATOR_IMPL);
 136   }
 137
 138   private final ConsolidationService consolidationService = new ConsolidationService();
 139
 140   private static List<EntityConsolidationData> getPortConsolidationDataList(
 141           List<String> portIds,
 142           List<UnifiedCompositionData> unifiedCompositionDataList) {
 143     return unifiedCompositionDataList.stream()
 144             .flatMap(unifiedCompositionData -> unifiedCompositionData.getPortTemplateConsolidationDataList().stream())
 145             .filter(portTemplateConsolidationData -> portIds.contains(portTemplateConsolidationData.getNodeTemplateId()))
 146             .collect(Collectors.toList());
 147   }
 148
 149   /**
 150    * Create unified composition.
 151    *
 152    * @param serviceTemplate            the service template
 153    * @param nestedServiceTemplate      the nested service template
 154    * @param unifiedCompositionDataList the unified composition data list. In case no consolidation,
 155    *                                   one entry will be in this list, in case of having
 156    *                                   consolidation, all entries in the list are the once which
 157    *                                   need to be consolidated.
 158    * @param mode                       the mode
 159    * @param context                    the context
 160    */
 161   public void createUnifiedComposition(ServiceTemplate serviceTemplate,
 162                                        ServiceTemplate nestedServiceTemplate,
 163                                        List<UnifiedCompositionData> unifiedCompositionDataList,
 164                                        UnifiedCompositionMode mode, TranslationContext context) {
 165     Optional<UnifiedComposition> unifiedCompositionInstance = getUnifiedCompositionInstance(mode);
 166     if (!unifiedCompositionInstance.isPresent()) {
 167       return;
 168     }
 169     unifiedCompositionInstance.get()
 170             .createUnifiedComposition(serviceTemplate, nestedServiceTemplate,
 171                     unifiedCompositionDataList, context);
 172   }
 173
 174   /**
 175    * Create unified substitution service template according to the input service template, based on
 176    * the unified composition data.
 177    *
 178    * @param serviceTemplate            the service template
 179    * @param unifiedCompositionDataList the unified composition data list. In case no consolidation,
 180    *                                   one entry will be in this list, in case of having
 181    *                                   consolidation, all entries in the list are the once which
 182    *                                   need to be consolidated.
 183    * @param context                    the translation context
 184    * @return the substitution service template
 185    */
 186   public Optional<ServiceTemplate> createUnifiedSubstitutionServiceTemplate(
 187           ServiceTemplate serviceTemplate,
 188           List<UnifiedCompositionData> unifiedCompositionDataList,
 189           TranslationContext context,
 190           String substitutionNodeTypeId,
 191           Integer index) {
 192     if (CollectionUtils.isEmpty(unifiedCompositionDataList)) {
 193       return Optional.empty();
 194     }
 195     String templateName = getTemplateName(substitutionNodeTypeId, index);
 196     ServiceTemplate substitutionServiceTemplate =
 197             HeatToToscaUtil.createInitSubstitutionServiceTemplate(templateName);
 198
 199     createIndexInputParameter(substitutionServiceTemplate);
 200
 201     String computeNodeType =
 202             handleCompute(serviceTemplate, substitutionServiceTemplate, unifiedCompositionDataList,
 203                     context);
 204     handlePorts(serviceTemplate, substitutionServiceTemplate, unifiedCompositionDataList,
 205             computeNodeType, context);
 206
 207     UnifiedCompositionTo unifiedCompositionTo = new UnifiedCompositionTo(serviceTemplate,
 208             substitutionServiceTemplate, unifiedCompositionDataList, context);
 209     handleSubInterfaces(unifiedCompositionTo);
 210     createOutputParameters(unifiedCompositionTo, computeNodeType);
 211     NodeType substitutionGlobalNodeType =
 212             handleSubstitutionGlobalNodeType(serviceTemplate, substitutionServiceTemplate,
 213                     context, substitutionNodeTypeId);
 214
 215     HeatToToscaUtil.handleSubstitutionMapping(context,
 216             substitutionNodeTypeId,
 217             substitutionServiceTemplate, substitutionGlobalNodeType);
 218
 219     context.getTranslatedServiceTemplates().put(templateName, substitutionServiceTemplate);
 220     return Optional.of(substitutionServiceTemplate);
 221   }
 222
 223
 224   /**
 225    * Create abstract substitute node template that can be substituted by the input
 226    * substitutionServiceTemplate.
 227    *
 228    * @param serviceTemplate             the service template
 229    * @param substitutionServiceTemplate the subtitution service template
 230    * @param unifiedCompositionDataList  the unified composition data list. In case no consolidation,
 231    *                                    one entry will be in this list, in case of having
 232    *                                    consolidation, all entries in the list are the once which
 233    *                                    need to be consolidated.
 234    * @param context                     the translation context
 235    * @return the abstract substitute node template id
 236    */
 237   public String createAbstractSubstituteNodeTemplate(
 238           ServiceTemplate serviceTemplate,
 239           ServiceTemplate substitutionServiceTemplate,
 240           List<UnifiedCompositionData> unifiedCompositionDataList,
 241           String substituteNodeTypeId,
 242           TranslationContext context,
 243           Integer index) {
 244
 245     NodeTemplate substitutionNodeTemplate = new NodeTemplate();
 246     List<String> directiveList = new ArrayList<>();
 247     directiveList.add(ToscaConstants.NODE_TEMPLATE_DIRECTIVE_SUBSTITUTABLE);
 248     substitutionNodeTemplate.setDirectives(directiveList);
 249     substitutionNodeTemplate.setType(substituteNodeTypeId);
 250     Map<String, ParameterDefinition> substitutionTemplateInputs = DataModelUtil
 251             .getInputParameters(substitutionServiceTemplate);
 252     Optional<Map<String, Object>> abstractSubstitutionProperties = Optional.empty();
 253     if (Objects.nonNull(substitutionTemplateInputs)) {
 254       abstractSubstitutionProperties = createAbstractSubstitutionProperties(serviceTemplate,
 255               substitutionTemplateInputs, unifiedCompositionDataList, context);
 256     }
 257     abstractSubstitutionProperties.ifPresent(substitutionNodeTemplate::setProperties);
 258
 259     //Add substitution filtering property
 260     String substitutionServiceTemplateName = ToscaUtil.getServiceTemplateFileName(
 261             substitutionServiceTemplate);
 262     int count = unifiedCompositionDataList.size();
 263     DataModelUtil.addSubstitutionFilteringProperty(substitutionServiceTemplateName,
 264             substitutionNodeTemplate, count);
 265     //Add index_value property
 266     addIndexValueProperty(substitutionNodeTemplate);
 267     String substituteNodeTemplateId = getSubstituteNodeTemplateId(substituteNodeTypeId, index);
 268     //Add node template id and related abstract node template id in context
 269     addUnifiedSubstitionData(context, serviceTemplate, unifiedCompositionDataList,
 270             substituteNodeTemplateId);
 271     DataModelUtil
 272             .addNodeTemplate(serviceTemplate, substituteNodeTemplateId, substitutionNodeTemplate);
 273     return substituteNodeTemplateId;
 274
 275   }
 276
 277   public void createVfcInstanceGroup(String abstractNodeTemplateId,
 278                                      ServiceTemplate serviceTemplate,
 279                                      List<UnifiedCompositionData> unifiedCompositionDataList,
 280                                      TranslationContext context) {
 281     if (!TranslationContext.isVfcInstanceGroupingEnabled()) {
 282       return;
 283     }
 284     UnifiedCompositionTo unifiedCompositionTo = new UnifiedCompositionTo(serviceTemplate, null,
 285         unifiedCompositionDataList, context);
 286     unifiedCompositionDataList.forEach(unifiedCompositionData ->
 287         createSubInterfaceVfcInstanceGroup(abstractNodeTemplateId, unifiedCompositionTo, unifiedCompositionData));
 288   }
 289
 290   private void createSubInterfaceVfcInstanceGroup(String abstractNodeTemplateId,
 291                                                   UnifiedCompositionTo unifiedCompositionTo,
 292                                                   UnifiedCompositionData unifiedCompositionData) {
 293     List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
 294         getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
 295     for (SubInterfaceTemplateConsolidationData subInterface : subInterfaceTemplateConsolidationDataList) {
 296       Optional<String> parentPortNetworkRole;
 297       if (Objects.isNull(unifiedCompositionTo.getSubstitutionServiceTemplate())) {
 298         parentPortNetworkRole = subInterface.getParentPortNetworkRole(unifiedCompositionTo.getServiceTemplate(),
 299             unifiedCompositionTo.getContext());
 300       } else {
 301         parentPortNetworkRole = subInterface.getParentPortNetworkRole(unifiedCompositionTo
 302             .getSubstitutionServiceTemplate(), unifiedCompositionTo.getContext());
 303       }
 304       String subInterfaceNetworkRole = subInterface.getNetworkRole();
 305       if (Objects.nonNull(subInterfaceNetworkRole) && parentPortNetworkRole.isPresent()) {
 306         createVfcInstanceGroupPerSubInterfaceNetworkRole(abstractNodeTemplateId, subInterfaceNetworkRole,
 307             parentPortNetworkRole.get(), unifiedCompositionTo.getServiceTemplate());
 308       }
 309     }
 310   }
 311
 312   private void createVfcInstanceGroupPerSubInterfaceNetworkRole(String abstractNodeTemplateId,
 313                                                                 String subInterfaceNetworkRole,
 314                                                                 String parentPortNetworkRole,
 315                                                                 ServiceTemplate serviceTemplate) {
 316     String vfcNetworkRoleGroupId = getVfcNetworkRoleGroupId(subInterfaceNetworkRole);
 317     Map<String, GroupDefinition> groups = DataModelUtil.getGroups(serviceTemplate);
 318     if (!groups.containsKey(vfcNetworkRoleGroupId)) {
 319       createNewVfcInstanceGroup(serviceTemplate, parentPortNetworkRole, subInterfaceNetworkRole, vfcNetworkRoleGroupId);
 320     }
 321     DataModelUtil.addGroupMember(serviceTemplate, vfcNetworkRoleGroupId, abstractNodeTemplateId);
 322   }
 323
 324   private void createNewVfcInstanceGroup(ServiceTemplate serviceTemplate,
 325                                          String parentPortNetworkRole,
 326                                          String subInterfaceNetworkRole,
 327                                          String vfcNetworkRoleGroupId) {
 328     Map<String, Object> properties = new HashMap<>();
 329     properties.put(SUB_INTERFACE_ROLE, subInterfaceNetworkRole);
 330     properties.put(VFC_PARENT_PORT_ROLE, parentPortNetworkRole);
 331
 332     updateVfcInstanceGroupExposedProperties(subInterfaceNetworkRole,
 333         serviceTemplate, properties);
 334
 335     GroupDefinition groupDefinition = new GroupDefinition();
 336     groupDefinition.setType(GROUP_TYPE_PREFIX + VFC_INSTANCE_GROUP);
 337     groupDefinition.setProperties(properties);
 338
 339     DataModelUtil.addGroupDefinitionToTopologyTemplate(serviceTemplate,
 340         vfcNetworkRoleGroupId, groupDefinition);
 341   }
 342
 343   private void updateVfcInstanceGroupExposedProperties(String subInterfaceNetworkRole,
 344                                                        ServiceTemplate serviceTemplate,
 345                                                        Map<String, Object> properties) {
 346     List<String> exposedVfcInstanceGroupingProperties =
 347         TranslationContext.getExposedVfcInstanceGroupingProperties();
 348
 349     if (CollectionUtils.isEmpty(exposedVfcInstanceGroupingProperties)) {
 350       return;
 351     }
 352
 353     for (String propertyName : exposedVfcInstanceGroupingProperties) {
 354       Map<String, Object> getInputMap = new HashMap<>();
 355       String vfcGroupPropertyInputName = subInterfaceNetworkRole + "_" + propertyName;
 356       getInputMap.put(GET_INPUT.getDisplayName(), vfcGroupPropertyInputName);
 357       properties.put(propertyName, getInputMap);
 358
 359       addInputParameter(vfcGroupPropertyInputName, PropertyType.STRING.getDisplayName(), null,
 360           serviceTemplate);
 361     }
 362   }
 363
 364   private String getVfcNetworkRoleGroupId(String subInterfaceNetworkRole) {
 365     StringBuilder sb = new StringBuilder();
 366     sb.append(subInterfaceNetworkRole).append("_").append(GROUP);
 367     return sb.toString();
 368   }
 369
 370   /**
 371    * Update the connectivity from/to the "moved" nodes from the original service template to the new
 372    * substitution service template.
 373    *
 374    * @param serviceTemplate            the service template
 375    * @param unifiedCompositionDataList the unified composition data list. In case no consolidation,
 376    *                                   one entry will be in this list, in case of having
 377    *                                   consolidation, all entries in the list are the once which
 378    *                                   need to be consolidated.
 379    * @param context                    the translation context
 380    */
 381   public void updateCompositionConnectivity(ServiceTemplate serviceTemplate,
 382                                             List<UnifiedCompositionData> unifiedCompositionDataList,
 383                                             TranslationContext context) {
 384     updOutputParamGetAttrInConnectivity(serviceTemplate, unifiedCompositionDataList, context);
 385     updNodesGetAttrInConnectivity(serviceTemplate, unifiedCompositionDataList, context);
 386     updNodesConnectedOutConnectivity(serviceTemplate, unifiedCompositionDataList, context);
 387     updNodesConnectedInConnectivity(serviceTemplate, unifiedCompositionDataList, context);
 388     updVolumeConnectivity(serviceTemplate, unifiedCompositionDataList, context);
 389     updGroupsConnectivity(serviceTemplate, unifiedCompositionDataList, context);
 390   }
 391
 392   /**
 393    * Delete the "moved" nodes from the original service template to the new substitution service
 394    * template.
 395    *
 396    * @param serviceTemplate            the service template
 397    * @param unifiedCompositionDataList the unified composition data list. In case no consolidation,
 398    *                                   one entry will be in this list, in case of having
 399    *                                   consolidation, all entries in the list are the once which
 400    *                                   need to be consolidated.
 401    * @param context                    the translation context
 402    */
 403   public void cleanUnifiedCompositionEntities(
 404           ServiceTemplate serviceTemplate,
 405           List<UnifiedCompositionData> unifiedCompositionDataList,
 406           TranslationContext context) {
 407     for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
 408       //Clean compute node template data from top level service template
 409       ComputeTemplateConsolidationData computeTemplateConsolidationData =
 410               unifiedCompositionData.getComputeTemplateConsolidationData();
 411       cleanServiceTemplate(serviceTemplate, computeTemplateConsolidationData, context);
 412
 413       //Clean port node template data from top level service template
 414       List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
 415               getPortTemplateConsolidationDataList(unifiedCompositionData);
 416       for (PortTemplateConsolidationData portTemplateConsolidationData :
 417               portTemplateConsolidationDataList) {
 418         cleanServiceTemplate(serviceTemplate, portTemplateConsolidationData, context);
 419       }
 420
 421       //Clean sub-interface node template data from top level service template
 422       List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
 423               getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
 424       for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData :
 425               subInterfaceTemplateConsolidationDataList) {
 426         cleanServiceTemplate(serviceTemplate, subInterfaceTemplateConsolidationData, context);
 427       }
 428     }
 429   }
 430
 431   /**
 432    * Clean node types.
 433    *
 434    * @param serviceTemplate            the service template
 435    * @param unifiedCompositionDataList the unified composition data list
 436    * @param context                    the context
 437    */
 438   public void cleanNodeTypes(ServiceTemplate serviceTemplate,
 439                              List<UnifiedCompositionData> unifiedCompositionDataList,
 440                              TranslationContext context) {
 441     for (UnifiedCompositionData unifiedData : unifiedCompositionDataList) {
 442       removeCleanedNodeType(
 443               unifiedData.getComputeTemplateConsolidationData().getNodeTemplateId(), serviceTemplate,
 444               context);
 445     }
 446     if (MapUtils.isEmpty(serviceTemplate.getNode_types())) {
 447       serviceTemplate.setNode_types(null);
 448     }
 449   }
 450
 451   public void updateSubstitutionNodeTypePrefix(ServiceTemplate substitutionServiceTemplate) {
 452     Map<String, NodeTemplate> nodeTemplates =
 453             substitutionServiceTemplate.getTopology_template().getNode_templates();
 454
 455     for (Map.Entry<String, NodeTemplate> nodeTemplateEntry : nodeTemplates.entrySet()) {
 456       String nodeTypeId = nodeTemplateEntry.getValue().getType();
 457       NodeType origNodeType = substitutionServiceTemplate.getNode_types().get(nodeTypeId);
 458       if (Objects.nonNull(origNodeType)
 459               && nodeTypeId.startsWith(ToscaNodeType.VFC_TYPE_PREFIX)
 460               && origNodeType.getDerived_from().equals(ToscaNodeType.NOVA_SERVER)) {
 461         substitutionServiceTemplate.getNode_types().remove(nodeTypeId);
 462
 463         String newNodeTypeId =
 464                 nodeTypeId.replace(ToscaNodeType.VFC_TYPE_PREFIX, ToscaNodeType.COMPUTE_TYPE_PREFIX);
 465         nodeTemplateEntry.getValue().setType(newNodeTypeId);
 466         DataModelUtil
 467                 .addNodeTemplate(substitutionServiceTemplate, nodeTemplateEntry.getKey(),
 468                         nodeTemplateEntry.getValue());
 469         substitutionServiceTemplate.getNode_types().put(newNodeTypeId, origNodeType);
 470       }
 471     }
 472   }
 473
 474   /**
 475    * Update unified abstract nodes connectivity.
 476    *
 477    * @param serviceTemplate the service template
 478    * @param context         the context
 479    */
 480   public void updateUnifiedAbstractNodesConnectivity(ServiceTemplate serviceTemplate,
 481                                                      TranslationContext context) {
 482
 483
 484     String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
 485     UnifiedSubstitutionData unifiedSubstitutionData = context.getUnifiedSubstitutionData()
 486             .get(serviceTemplateFileName);
 487
 488     if (Objects.nonNull(unifiedSubstitutionData)) {
 489       //Handle get attribute in connectivity for abstarct node to abstract node templates
 490       Set<String> abstractNodeIds =
 491               new HashSet<>(unifiedSubstitutionData.getAllRelatedAbstractNodeIds());
 492       handleGetAttrInConnectivity(serviceTemplate, abstractNodeIds, context);
 493       //Handle get attribute in connectivity for abstract node templates to nested node template
 494       Set<String> nestedNodeIds =
 495               new HashSet<>(unifiedSubstitutionData.getAllUnifiedNestedNodeTemplateIds());
 496       handleGetAttrInConnectivity(serviceTemplate, nestedNodeIds, context);
 497     }
 498   }
 499
 500   /**
 501    * Handle unified nested definition.
 502    *
 503    * @param unifiedCompositionTo    the unified composition data transfer object
 504    * @param unifiedCompositionData  the unified composition data
 505    */
 506   public void handleUnifiedNestedDefinition(UnifiedCompositionTo unifiedCompositionTo,
 507                                             UnifiedCompositionData unifiedCompositionData) {
 508     handleUnifiedNestedNodeType(unifiedCompositionTo.getServiceTemplate(), unifiedCompositionTo
 509         .getSubstitutionServiceTemplate(), unifiedCompositionTo.getContext());
 510     updateUnifiedNestedTemplates(unifiedCompositionTo.getServiceTemplate(), unifiedCompositionTo
 511         .getSubstitutionServiceTemplate(), unifiedCompositionData, unifiedCompositionTo.getContext());
 512   }
 513
 514   private void handleGetAttrInConnectivity(ServiceTemplate serviceTemplate,
 515                                            Set<String> unifiedNodeIds,
 516                                            TranslationContext context) {
 517     Map<String, NodeTemplate> nodeTemplates =
 518             serviceTemplate.getTopology_template().getNode_templates();
 519     String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
 520     for (String unifiedNodeId : unifiedNodeIds) {
 521       NodeTemplate nodeTemplate = nodeTemplates.get(unifiedNodeId);
 522       handleGetAttrInAbstractNodeTemplate(serviceTemplate, context, serviceTemplateFileName,
 523               nodeTemplate);
 524     }
 525   }
 526
 527   private void handleUnifiedNestedNodeType(ServiceTemplate mainServiceTemplate,
 528                                            ServiceTemplate nestedServiceTemplate,
 529                                            TranslationContext context) {
 530
 531
 532     SubstitutionMapping substitutionMappings =
 533             nestedServiceTemplate.getTopology_template().getSubstitution_mappings();
 534     String nodeTypeId = substitutionMappings.getNode_type();
 535
 536     Optional<String> newNestedNodeTypeId = getNewNestedNodeTypeId(nestedServiceTemplate, context);
 537
 538     ServiceTemplate globalSubstitutionServiceTemplate =
 539             context.getGlobalSubstitutionServiceTemplate();
 540
 541     if (isNestedServiceTemplateWasHandled(globalSubstitutionServiceTemplate, nestedServiceTemplate,
 542             context,
 543             newNestedNodeTypeId)) {
 544       context
 545               .updateHandledComputeType(ToscaUtil.getServiceTemplateFileName(mainServiceTemplate),
 546                       newNestedNodeTypeId.get(),
 547                       ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate));
 548       return;
 549     }
 550
 551
 552     newNestedNodeTypeId.ifPresent(
 553             newNestedNodeTypeIdVal -> handleNestedNodeType(nodeTypeId, newNestedNodeTypeIdVal,
 554                     nestedServiceTemplate, mainServiceTemplate, globalSubstitutionServiceTemplate,
 555                     context));
 556
 557   }
 558
 559   private boolean isNestedServiceTemplateWasHandled(ServiceTemplate mainServiceTemplate,
 560                                                     ServiceTemplate nestedServiceTemplate,
 561                                                     TranslationContext context,
 562                                                     Optional<String> newNestedNodeTypeId) {
 563     return newNestedNodeTypeId.isPresent()
 564             && context.isNestedServiceTemplateWasHandled(
 565             ToscaUtil.getServiceTemplateFileName(mainServiceTemplate),
 566             ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate));
 567   }
 568
 569   private void handleNestedNodeType(String nodeTypeId, String newNestedNodeTypeId,
 570                                     ServiceTemplate nestedServiceTemplate,
 571                                     ServiceTemplate mainServiceTemplate,
 572                                     ServiceTemplate globalSubstitutionServiceTemplate,
 573                                     TranslationContext context) {
 574     updateNestedServiceTemplate(nestedServiceTemplate, context);
 575     updateNestedNodeType(nodeTypeId, newNestedNodeTypeId, nestedServiceTemplate,
 576             mainServiceTemplate,
 577             globalSubstitutionServiceTemplate, context);
 578
 579
 580   }
 581
 582   private void updateNestedServiceTemplate(ServiceTemplate nestedServiceTemplate,
 583                                            TranslationContext context) {
 584     enrichPortProperties(nestedServiceTemplate, context);
 585   }
 586
 587   private void enrichPortProperties(ServiceTemplate nestedServiceTemplate,
 588                                     TranslationContext context) {
 589     String nestedServiceTemplateFileName =
 590             ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate);
 591     FilePortConsolidationData filePortConsolidationData =
 592             context.getConsolidationData().getPortConsolidationData().getFilePortConsolidationData
 593                     (nestedServiceTemplateFileName);
 594
 595     if (Objects.nonNull(filePortConsolidationData)) {
 596       Set<String> portNodeTemplateIds = filePortConsolidationData.getAllPortNodeTemplateIds();
 597       if (Objects.nonNull(portNodeTemplateIds)) {
 598         for (String portNodeTemplateId : portNodeTemplateIds) {
 599           NodeTemplate portNodeTemplate = DataModelUtil.getNodeTemplate(nestedServiceTemplate,
 600                   portNodeTemplateId);
 601           List<EntityConsolidationData> portEntityConsolidationDataList = new ArrayList<>();
 602           portEntityConsolidationDataList.add(filePortConsolidationData
 603                   .getPortTemplateConsolidationData(portNodeTemplateId));
 604
 605           handleNodeTypeProperties(nestedServiceTemplate,
 606                   portEntityConsolidationDataList, portNodeTemplate, UnifiedCompositionEntity.PORT,
 607                   null, context);
 608         }
 609       }
 610     }
 611   }
 612
 613   private void updateNestedNodeType(String nodeTypeId, String newNestedNodeTypeId,
 614                                     ServiceTemplate nestedServiceTemplate,
 615                                     ServiceTemplate mainServiceTemplate,
 616                                     ServiceTemplate globalSubstitutionServiceTemplate,
 617                                     TranslationContext context) {
 618     String indexedNewNestedNodeTypeId =
 619             updateNodeTypeId(nodeTypeId, newNestedNodeTypeId, nestedServiceTemplate,
 620                     mainServiceTemplate,
 621                     globalSubstitutionServiceTemplate, context);
 622
 623     updateNodeTypeProperties(nestedServiceTemplate, globalSubstitutionServiceTemplate,
 624             indexedNewNestedNodeTypeId);
 625   }
 626
 627   private void updateNodeTypeProperties(ServiceTemplate nestedServiceTemplate,
 628                                         ServiceTemplate globalSubstitutionServiceTemplate,
 629                                         String nodeTypeId) {
 630     ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
 631     Map<String, PropertyDefinition> nodeTypePropertiesDefinition =
 632             toscaAnalyzerService.manageSubstitutionNodeTypeProperties(nestedServiceTemplate);
 633     NodeType nestedNodeType =
 634             DataModelUtil.getNodeType(globalSubstitutionServiceTemplate, nodeTypeId);
 635     nestedNodeType.setProperties(nodeTypePropertiesDefinition);
 636   }
 637
 638   private String updateNodeTypeId(String nodeTypeId, String newNestedNodeTypeId,
 639                                   ServiceTemplate nestedServiceTemplate,
 640                                   ServiceTemplate mainServiceTemplate,
 641                                   ServiceTemplate globalSubstitutionServiceTemplate,
 642                                   TranslationContext context) {
 643     String indexedNewNestedNodeTypeId =
 644             handleNestedNodeTypeInGlobalSubstitutionTemplate(nodeTypeId, newNestedNodeTypeId,
 645                     globalSubstitutionServiceTemplate, context);
 646
 647     handleSubstitutionMappingInNestedServiceTemplate(indexedNewNestedNodeTypeId,
 648             nestedServiceTemplate, context);
 649
 650     context
 651             .updateHandledComputeType(
 652                     ToscaUtil.getServiceTemplateFileName(mainServiceTemplate),
 653                     ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate),
 654                     newNestedNodeTypeId);
 655     return indexedNewNestedNodeTypeId;
 656   }
 657
 658   private String handleNestedNodeTypeInGlobalSubstitutionTemplate(String nodeTypeId,
 659                                                                   String newNestedNodeTypeId,
 660                                                                   ServiceTemplate globalSubstitutionServiceTemplate,
 661                                                                   TranslationContext context) {
 662     String indexedNodeType =
 663             getIndexedGlobalNodeTypeId(newNestedNodeTypeId, context);
 664     context.updateUsedTimesForNestedComputeNodeType(
 665             ToscaUtil.getServiceTemplateFileName(globalSubstitutionServiceTemplate),
 666             newNestedNodeTypeId);
 667     handleNestedNodeTypesInGlobalSubstituteServiceTemplate(nodeTypeId, indexedNodeType,
 668             globalSubstitutionServiceTemplate, context);
 669     return indexedNodeType;
 670   }
 671
 672   private String getIndexedGlobalNodeTypeId(String newNestedNodeTypeId,
 673                                             TranslationContext context) {
 674     int globalNodeTypeIndex =
 675             context.getGlobalNodeTypeIndex(
 676                     ToscaUtil.getServiceTemplateFileName(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME),
 677                     newNestedNodeTypeId);
 678     return globalNodeTypeIndex > 0 ? newNestedNodeTypeId + "_"
 679             + globalNodeTypeIndex : newNestedNodeTypeId;
 680   }
 681
 682   private void updateUnifiedNestedTemplates(ServiceTemplate mainServiceTemplate,
 683                                             ServiceTemplate nestedServiceTemplate,
 684                                             UnifiedCompositionData unifiedCompositionData,
 685                                             TranslationContext context) {
 686
 687     NestedTemplateConsolidationData nestedTemplateConsolidationData =
 688             unifiedCompositionData.getNestedTemplateConsolidationData();
 689     if (Objects.isNull(nestedTemplateConsolidationData)) {
 690       return;
 691     }
 692     handleNestedNodeTemplateInMainServiceTemplate(
 693         nestedTemplateConsolidationData.getNodeTemplateId(), mainServiceTemplate,
 694         nestedServiceTemplate, context);
 695   }
 696
 697   /**
 698    * Update connectivity for unified nested patterns.
 699    *
 700    * @param unifiedCompositionTo    the unified composition data transfer object
 701    * @param unifiedCompositionData  the unified composition data
 702    */
 703   public void updateUnifiedNestedConnectivity(UnifiedCompositionTo unifiedCompositionTo,
 704                                               UnifiedCompositionData unifiedCompositionData) {
 705
 706     updNestedCompositionNodesConnectedInConnectivity(unifiedCompositionTo.getServiceTemplate(), unifiedCompositionData,
 707         unifiedCompositionTo.getContext());
 708     updNestedCompositionNodesConnectedOutConnectivity(unifiedCompositionTo.getServiceTemplate(),
 709         unifiedCompositionTo.getSubstitutionServiceTemplate(), unifiedCompositionData, unifiedCompositionTo
 710             .getContext());
 711     updNestedCompositionNodesGetAttrInConnectivity(unifiedCompositionTo.getServiceTemplate(), unifiedCompositionData,
 712         unifiedCompositionTo.getContext());
 713     updNestedCompositionOutputParamGetAttrInConnectivity(unifiedCompositionTo.getServiceTemplate(),
 714         unifiedCompositionData, unifiedCompositionTo.getContext());
 715   }
 716
 717
 718   /**
 719    * Clean unified nested entities. Update the heat stack group with the new node template ids.
 720    *
 721    * @param unifiedCompositionTo        the unified composition data transfer object
 722    * @param unifiedCompositionData the unified composition data
 723    */
 724   public void cleanUnifiedNestedEntities(UnifiedCompositionTo unifiedCompositionTo,
 725                                          UnifiedCompositionData unifiedCompositionData) {
 726     EntityConsolidationData entityConsolidationData =
 727         unifiedCompositionData.getNestedTemplateConsolidationData();
 728     updateHeatStackGroupNestedComposition(unifiedCompositionTo.getServiceTemplate(), entityConsolidationData,
 729         unifiedCompositionTo.getContext());
 730
 731   }
 732
 733   public void createNestedVfcInstanceGroup(String nestedNodeTemplateId,
 734                                            UnifiedCompositionTo unifiedCompositionTo,
 735                                            UnifiedCompositionData unifiedCompositionData) {
 736     if (!TranslationContext.isVfcInstanceGroupingEnabled()) {
 737       return;
 738     }
 739     createSubInterfaceVfcInstanceGroup(nestedNodeTemplateId, unifiedCompositionTo, unifiedCompositionData);
 740   }
 741
 742   public void handleComplexVfcType(ServiceTemplate serviceTemplate, TranslationContext context) {
 743     SubstitutionMapping substitutionMapping =
 744             serviceTemplate.getTopology_template().getSubstitution_mappings();
 745
 746     if (Objects.isNull(substitutionMapping)) {
 747       return;
 748     }
 749
 750     ServiceTemplate globalSubstitutionServiceTemplate =
 751             context.getGlobalSubstitutionServiceTemplate();
 752
 753     String substitutionNT = substitutionMapping.getNode_type();
 754     if (globalSubstitutionServiceTemplate.getNode_types().containsKey(substitutionNT)) {
 755       //This needs to be done when catalog is ready for complex VFC
 756     }
 757   }
 758
 759
 760   protected void updNodesConnectedOutConnectivity(ServiceTemplate serviceTemplate,
 761                                                   List<UnifiedCompositionData>
 762                                                           unifiedCompositionDataList,
 763                                                   TranslationContext context) {
 764     for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
 765       ComputeTemplateConsolidationData computeTemplateConsolidationData = unifiedCompositionData
 766               .getComputeTemplateConsolidationData();
 767       //Add requirements in the abstract node template for nodes connected out for computes
 768       String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
 769               computeTemplateConsolidationData.getNodeTemplateId());
 770       Map<String, List<RequirementAssignmentData>> computeNodesConnectedOut =
 771               computeTemplateConsolidationData.getNodesConnectedOut();
 772       if (computeNodesConnectedOut != null) {
 773         updateRequirementInAbstractNodeTemplate(serviceTemplate, computeTemplateConsolidationData,
 774                 newComputeNodeTemplateId, computeNodesConnectedOut, context);
 775       }
 776       String computeType = getComputeTypeSuffix(serviceTemplate, computeTemplateConsolidationData
 777               .getNodeTemplateId());
 778       //Add requirements in the abstract node template for nodes connected out for ports
 779       List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
 780               getPortTemplateConsolidationDataList(unifiedCompositionData);
 781       for (PortTemplateConsolidationData portTemplateConsolidationData :
 782               portTemplateConsolidationDataList) {
 783         String newPortNodeTemplateId = getNewPortNodeTemplateId(portTemplateConsolidationData
 784                 .getNodeTemplateId(), computeType, computeTemplateConsolidationData);
 785         Map<String, List<RequirementAssignmentData>> portNodesConnectedOut =
 786                 portTemplateConsolidationData.getNodesConnectedOut();
 787         if (portNodesConnectedOut != null) {
 788           updateRequirementInAbstractNodeTemplate(serviceTemplate, portTemplateConsolidationData,
 789                   newPortNodeTemplateId, portNodesConnectedOut, context);
 790         }
 791       }
 792       //For sub-interface
 793       //Add requirements in the abstract node template for nodes connected out for ports
 794       updateSubInterfaceNodesConnectedOut(serviceTemplate, unifiedCompositionData,
 795               computeTemplateConsolidationData, computeType, context);
 796     }
 797   }
 798
 799   private void updateSubInterfaceNodesConnectedOut(ServiceTemplate serviceTemplate,
 800                                                    UnifiedCompositionData unifiedCompositionData,
 801                                                    ComputeTemplateConsolidationData computeTemplateConsolidationData,
 802                                                    String computeType,
 803                                                    TranslationContext context) {
 804     List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
 805             getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
 806     for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData :
 807             subInterfaceTemplateConsolidationDataList) {
 808       String newSubInterfaceNodeTemplateId = getNewSubInterfaceNodeTemplateId(serviceTemplate, computeType,
 809               computeTemplateConsolidationData, subInterfaceTemplateConsolidationData, context);
 810       Map<String, List<RequirementAssignmentData>> subInterfaceNodesConnectedOut =
 811               subInterfaceTemplateConsolidationData.getNodesConnectedOut();
 812       if (subInterfaceNodesConnectedOut != null) {
 813         updateRequirementInAbstractNodeTemplate(serviceTemplate, subInterfaceTemplateConsolidationData,
 814                 newSubInterfaceNodeTemplateId, subInterfaceNodesConnectedOut, context);
 815       }
 816     }
 817   }
 818
 819   private void updNestedCompositionNodesConnectedOutConnectivity(ServiceTemplate serviceTemplate,
 820                                                                  ServiceTemplate nestedServiceTemplate,
 821                                                                  UnifiedCompositionData unifiedCompositionData,
 822                                                                  TranslationContext context) {
 823     NestedTemplateConsolidationData nestedTemplateConsolidationData =
 824             unifiedCompositionData.getNestedTemplateConsolidationData();
 825     Map<String, List<RequirementAssignmentData>> nodesConnectedOut =
 826             Objects.isNull(nestedTemplateConsolidationData) ? new HashMap<>()
 827                     : nestedTemplateConsolidationData.getNodesConnectedOut();
 828
 829     FileComputeConsolidationData nestedFileComputeConsolidationData =
 830             context.getConsolidationData().getComputeConsolidationData().getFileComputeConsolidationData
 831                     (ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate));
 832
 833     if (Objects.isNull(nestedFileComputeConsolidationData)) {
 834       return;
 835     }
 836
 837     TypeComputeConsolidationData computeType =
 838             nestedFileComputeConsolidationData.getAllTypeComputeConsolidationData().iterator().next();
 839     if (Objects.isNull(computeType)) {
 840       return;
 841     }
 842
 843     String singleComputeId = computeType.getAllComputeNodeTemplateIds().iterator().next();
 844     if (Objects.nonNull(singleComputeId) && (Objects.nonNull(nestedTemplateConsolidationData))) {
 845       updateRequirementInNestedNodeTemplate(serviceTemplate, nestedTemplateConsolidationData,
 846               singleComputeId, nodesConnectedOut);
 847     }
 848   }
 849
 850   private void updNodesConnectedInConnectivity(ServiceTemplate serviceTemplate,
 851                                                List<UnifiedCompositionData>
 852                                                        unifiedCompositionDataList,
 853                                                TranslationContext context) {
 854     for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
 855       ComputeTemplateConsolidationData computeTemplateConsolidationData = unifiedCompositionData
 856               .getComputeTemplateConsolidationData();
 857       //Update requirements in the node template which pointing to the computes
 858       String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
 859               computeTemplateConsolidationData.getNodeTemplateId());
 860       updNodesConnectedInConnectivity(serviceTemplate, computeTemplateConsolidationData,
 861               newComputeNodeTemplateId, context, false);
 862
 863       String computeType = getComputeTypeSuffix(serviceTemplate, computeTemplateConsolidationData
 864               .getNodeTemplateId());
 865       //Update requirements in the node template which pointing to the ports
 866       List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
 867               getPortTemplateConsolidationDataList(unifiedCompositionData);
 868       for (PortTemplateConsolidationData portTemplateConsolidationData :
 869               portTemplateConsolidationDataList) {
 870         String newPortNodeTemplateId = getNewPortNodeTemplateId(portTemplateConsolidationData
 871                 .getNodeTemplateId(), computeType, computeTemplateConsolidationData);
 872         updNodesConnectedInConnectivity(serviceTemplate, portTemplateConsolidationData,
 873                 newPortNodeTemplateId, context, false);
 874       }
 875
 876       //Update requirements in the node template which pointing to the sub-interface
 877       updateSubInterfaceNodesConnectedIn(serviceTemplate, unifiedCompositionData,
 878               computeTemplateConsolidationData, computeType, context);
 879     }
 880   }
 881
 882   private void updNodesConnectedInConnectivity(ServiceTemplate serviceTemplate,
 883                                                EntityConsolidationData entityConsolidationData,
 884                                                String newNodeTemplateId,
 885                                                TranslationContext context,
 886                                                boolean isNested) {
 887     Map<String, List<RequirementAssignmentData>> nodesConnectedIn =
 888             entityConsolidationData.getNodesConnectedIn();
 889     if (nodesConnectedIn == null) {
 890       //No nodes connected in info
 891       return;
 892     }
 893     for (Map.Entry<String, List<RequirementAssignmentData>> entry : nodesConnectedIn
 894             .entrySet()) {
 895       List<RequirementAssignmentData> requirementAssignmentDataList = entry.getValue();
 896       for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList) {
 897         RequirementAssignment requirementAssignment = requirementAssignmentData
 898                 .getRequirementAssignment();
 899         if (!requirementAssignment.getNode().equals(entityConsolidationData
 900                 .getNodeTemplateId())) {
 901           //The requirement assignment target node should be the one which we are handling in the
 902           //consolidation object
 903           continue;
 904         }
 905         //Update the requirement assignment object in the original node template
 906         if (isNested) {
 907           updateRequirementForNestedCompositionNodesConnectedIn(serviceTemplate,
 908                   requirementAssignmentData, newNodeTemplateId);
 909         } else {
 910           updateRequirementForNodesConnectedIn(serviceTemplate, requirementAssignmentData,
 911                   entityConsolidationData, entry.getKey(), newNodeTemplateId, context);
 912         }
 913
 914       }
 915     }
 916   }
 917
 918   private void updateSubInterfaceNodesConnectedIn(ServiceTemplate serviceTemplate,
 919                                                   UnifiedCompositionData unifiedCompositionData,
 920                                                   ComputeTemplateConsolidationData computeTemplateConsolidationData,
 921                                                   String computeType,
 922                                                   TranslationContext context) {
 923     List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
 924             getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
 925     for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData :
 926             subInterfaceTemplateConsolidationDataList) {
 927       String newSubInterfaceNodeTemplateId = getNewSubInterfaceNodeTemplateId(serviceTemplate, computeType,
 928               computeTemplateConsolidationData, subInterfaceTemplateConsolidationData, context);
 929       updNodesConnectedInConnectivity(serviceTemplate, subInterfaceTemplateConsolidationData,
 930               newSubInterfaceNodeTemplateId, context, false);
 931     }
 932   }
 933
 934   protected void updNestedCompositionNodesConnectedInConnectivity(
 935           ServiceTemplate serviceTemplate,
 936           UnifiedCompositionData unifiedCompositionData,
 937           TranslationContext context) {
 938     NestedTemplateConsolidationData nestedTemplateConsolidationData = unifiedCompositionData
 939             .getNestedTemplateConsolidationData();
 940     //Update requirements in the node template which pointing to the nested nodes
 941     String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
 942     Optional<String> newNestedNodeTemplateId = context.getUnifiedNestedNodeTemplateId(
 943             serviceTemplateFileName, nestedTemplateConsolidationData.getNodeTemplateId());
 944     newNestedNodeTemplateId.ifPresent(
 945             newNestedNodeTemplateIdVal -> updNodesConnectedInConnectivity(serviceTemplate,
 946                     nestedTemplateConsolidationData,
 947                     newNestedNodeTemplateIdVal, context, true));
 948
 949   }
 950
 951   private void updVolumeConnectivity(ServiceTemplate serviceTemplate,
 952                                      List<UnifiedCompositionData>
 953                                              unifiedCompositionDataList,
 954                                      TranslationContext context) {
 955     for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
 956       ComputeTemplateConsolidationData computeTemplateConsolidationData = unifiedCompositionData
 957               .getComputeTemplateConsolidationData();
 958       //Add requirements in the abstract node template for compute volumes
 959       String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
 960               computeTemplateConsolidationData.getNodeTemplateId());
 961       Map<String, List<RequirementAssignmentData>> computeVolumes =
 962               computeTemplateConsolidationData.getVolumes();
 963       if (computeVolumes != null) {
 964         updateRequirementInAbstractNodeTemplate(serviceTemplate, computeTemplateConsolidationData,
 965                 newComputeNodeTemplateId, computeVolumes, context);
 966       }
 967     }
 968   }
 969
 970   private void updGroupsConnectivity(ServiceTemplate serviceTemplate,
 971                                      List<UnifiedCompositionData>
 972                                              unifiedCompositionDataList,
 973                                      TranslationContext context) {
 974     for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
 975       ComputeTemplateConsolidationData computeTemplateConsolidationData = unifiedCompositionData
 976               .getComputeTemplateConsolidationData();
 977       //Add requirements in the abstract node template for nodes connected in for computes
 978       updGroupsConnectivity(serviceTemplate, computeTemplateConsolidationData, context);
 979
 980       //Add requirements in the abstract node template for nodes connected in for ports
 981       List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
 982               getPortTemplateConsolidationDataList(unifiedCompositionData);
 983       for (PortTemplateConsolidationData portTemplateConsolidationData :
 984               portTemplateConsolidationDataList) {
 985         updGroupsConnectivity(serviceTemplate, portTemplateConsolidationData, context);
 986       }
 987
 988       //Add requirements in the abstract node template for nodes connected in for subInterface
 989       List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
 990               getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
 991       for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData :
 992               subInterfaceTemplateConsolidationDataList) {
 993         updGroupsConnectivity(serviceTemplate, subInterfaceTemplateConsolidationData, context);
 994       }
 995     }
 996   }
 997
 998   private void updGroupsConnectivity(ServiceTemplate serviceTemplate, EntityConsolidationData
 999           entityConsolidationData, TranslationContext context) {
1000     List<String> groupIds = entityConsolidationData.getGroupIds();
1001     if (groupIds == null) {
1002       return;
1003     }
1004     String oldNodeTemplateId = entityConsolidationData.getNodeTemplateId();
1005     String abstractNodeTemplateId = context.getUnifiedAbstractNodeTemplateId(
1006             serviceTemplate, entityConsolidationData.getNodeTemplateId());
1007     Map<String, GroupDefinition> groups = serviceTemplate.getTopology_template().getGroups();
1008     if (groups == null) {
1009       return;
1010     }
1011     for (String groupId : groupIds) {
1012       GroupDefinition groupDefinition = groups.get(groupId);
1013       if (groupDefinition == null) {
1014         continue;
1015       }
1016       List<String> groupMembers = groupDefinition.getMembers();
1017       if (groupMembers.contains(oldNodeTemplateId)) {
1018         //Replace the old node template id
1019         groupMembers.remove(oldNodeTemplateId);
1020         if (!groupMembers.contains(abstractNodeTemplateId)) {
1021           //Add the abstract node template id if not already present
1022           groupMembers.add(abstractNodeTemplateId);
1023         }
1024       }
1025     }
1026   }
1027
1028   private void updOutputParamGetAttrInConnectivity(
1029           ServiceTemplate serviceTemplate, List<UnifiedCompositionData> unifiedComposotionDataList,
1030           TranslationContext context) {
1031     for (UnifiedCompositionData unifiedCompositionData : unifiedComposotionDataList) {
1032       ComputeTemplateConsolidationData computeTemplateConsolidationData =
1033               unifiedCompositionData.getComputeTemplateConsolidationData();
1034       String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
1035               computeTemplateConsolidationData.getNodeTemplateId());
1036
1037       updOutputParamGetAttrInConnectivity(serviceTemplate, computeTemplateConsolidationData,
1038               computeTemplateConsolidationData.getNodeTemplateId(), newComputeNodeTemplateId,
1039               context, false);
1040
1041       String computeType =
1042               getComputeTypeSuffix(serviceTemplate,
1043                       computeTemplateConsolidationData.getNodeTemplateId());
1044       List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
1045               getPortTemplateConsolidationDataList(unifiedCompositionData);
1046       for (PortTemplateConsolidationData portTemplateConsolidationData :
1047               portTemplateConsolidationDataList) {
1048         String newPortNodeTemplateId =
1049                 getNewPortNodeTemplateId(portTemplateConsolidationData.getNodeTemplateId(), computeType,
1050                         computeTemplateConsolidationData);
1051
1052         updOutputParamGetAttrInConnectivity(serviceTemplate, portTemplateConsolidationData,
1053                 portTemplateConsolidationData.getNodeTemplateId(), newPortNodeTemplateId, context,
1054                 false);
1055       }
1056
1057       updateSubInterfaceOutputParamGetAttrIn(serviceTemplate, unifiedCompositionData,
1058               computeTemplateConsolidationData, computeType, context);
1059     }
1060   }
1061
1062   private void updateSubInterfaceOutputParamGetAttrIn(ServiceTemplate serviceTemplate,
1063                                                       UnifiedCompositionData unifiedCompositionData,
1064                                                       ComputeTemplateConsolidationData computeTemplateConsolidationData,
1065                                                       String computeType,
1066                                                       TranslationContext context) {
1067     List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
1068             getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
1069     for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData :
1070             subInterfaceTemplateConsolidationDataList) {
1071       String newSubInterfaceNodeTemplateId = getNewSubInterfaceNodeTemplateId(serviceTemplate, computeType,
1072               computeTemplateConsolidationData, subInterfaceTemplateConsolidationData, context);
1073       updOutputParamGetAttrInConnectivity(serviceTemplate, subInterfaceTemplateConsolidationData,
1074               subInterfaceTemplateConsolidationData.getNodeTemplateId(), newSubInterfaceNodeTemplateId, context,
1075               false);
1076     }
1077   }
1078
1079   private void updNodesGetAttrInConnectivity(
1080           ServiceTemplate serviceTemplate,
1081           List<UnifiedCompositionData> unifiedComposotionDataList,
1082           TranslationContext context) {
1083     Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType =
1084             getAllConsolidationNodeTemplateIdAndType(unifiedComposotionDataList);
1085     for (UnifiedCompositionData unifiedCompositionData : unifiedComposotionDataList) {
1086       ComputeTemplateConsolidationData computeTemplateConsolidationData =
1087               unifiedCompositionData.getComputeTemplateConsolidationData();
1088       String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
1089               computeTemplateConsolidationData.getNodeTemplateId());
1090
1091       updNodeGetAttrInConnectivity(serviceTemplate, computeTemplateConsolidationData,
1092               computeTemplateConsolidationData.getNodeTemplateId(),
1093               newComputeNodeTemplateId, context, consolidationNodeTemplateIdAndType, false);
1094
1095       String computeType =
1096               getComputeTypeSuffix(serviceTemplate,
1097                       computeTemplateConsolidationData.getNodeTemplateId());
1098
1099       List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
1100               getPortTemplateConsolidationDataList(unifiedCompositionData);
1101       for (PortTemplateConsolidationData portTemplateConsolidationData :
1102               portTemplateConsolidationDataList) {
1103         String newPotNodeTemplateId =
1104                 getNewPortNodeTemplateId(portTemplateConsolidationData.getNodeTemplateId(), computeType,
1105                         computeTemplateConsolidationData);
1106
1107         updNodeGetAttrInConnectivity(serviceTemplate, portTemplateConsolidationData,
1108                 portTemplateConsolidationData.getNodeTemplateId(),
1109                 newPotNodeTemplateId, context, consolidationNodeTemplateIdAndType, false);
1110       }
1111
1112       updateSubInterfaceNodesGetAttrIn(serviceTemplate, unifiedCompositionData,
1113               computeTemplateConsolidationData, computeType, consolidationNodeTemplateIdAndType, context);
1114     }
1115   }
1116
1117   private void updateSubInterfaceNodesGetAttrIn(ServiceTemplate serviceTemplate,
1118                                                 UnifiedCompositionData unifiedCompositionData,
1119                                                 ComputeTemplateConsolidationData computeTemplateConsolidationData,
1120                                                 String computeType,
1121                                                 Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType,
1122                                                 TranslationContext context) {
1123     List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
1124             getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
1125     for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData :
1126             subInterfaceTemplateConsolidationDataList) {
1127       String newSubInterfaceNodeTemplateId = getNewSubInterfaceNodeTemplateId(serviceTemplate, computeType,
1128               computeTemplateConsolidationData, subInterfaceTemplateConsolidationData, context);
1129       updNodeGetAttrInConnectivity(serviceTemplate, subInterfaceTemplateConsolidationData,
1130               subInterfaceTemplateConsolidationData.getNodeTemplateId(),
1131               newSubInterfaceNodeTemplateId, context,
1132               consolidationNodeTemplateIdAndType, false);
1133     }
1134   }
1135
1136   protected void updNestedCompositionOutputParamGetAttrInConnectivity(
1137           ServiceTemplate serviceTemplate, UnifiedCompositionData unifiedCompositionData,
1138           TranslationContext context) {
1139     NestedTemplateConsolidationData nestedTemplateConsolidationData =
1140             unifiedCompositionData.getNestedTemplateConsolidationData();
1141     if (Objects.isNull(nestedTemplateConsolidationData)) {
1142       return;
1143     }
1144     String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
1145     Optional<String> newNestedNodeTemplateId = context.getUnifiedNestedNodeTemplateId(
1146             serviceTemplateFileName, nestedTemplateConsolidationData.getNodeTemplateId());
1147
1148     newNestedNodeTemplateId.ifPresent(
1149             newNestedNodeTemplateIdVal -> updOutputParamGetAttrInConnectivity(serviceTemplate,
1150                     nestedTemplateConsolidationData, nestedTemplateConsolidationData.getNodeTemplateId(),
1151                     newNestedNodeTemplateIdVal, context, true));
1152   }
1153
1154   protected void updNestedCompositionNodesGetAttrInConnectivity(
1155           ServiceTemplate serviceTemplate,
1156           UnifiedCompositionData unifiedCompositionData,
1157           TranslationContext context) {
1158     NestedTemplateConsolidationData nestedTemplateConsolidationData =
1159             unifiedCompositionData.getNestedTemplateConsolidationData();
1160     if (Objects.isNull(nestedTemplateConsolidationData)) {
1161       return;
1162     }
1163     String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
1164     Optional<String> newNestedNodeTemplateId = context.getUnifiedNestedNodeTemplateId(
1165             serviceTemplateFileName, nestedTemplateConsolidationData.getNodeTemplateId());
1166
1167     newNestedNodeTemplateId.ifPresent(
1168             newNestedNodeTemplateIdVal -> updNodeGetAttrInConnectivity(serviceTemplate,
1169                     nestedTemplateConsolidationData, nestedTemplateConsolidationData.getNodeTemplateId(),
1170                     newNestedNodeTemplateIdVal, context, null, true));
1171   }
1172
1173   private void updateRequirementForNodesConnectedIn(
1174           ServiceTemplate serviceTemplate,
1175           RequirementAssignmentData requirementAssignmentData,
1176           EntityConsolidationData entityConsolidationData,
1177           String originalNodeTemplateId,
1178           String newNodeTemplateId,
1179           TranslationContext context) {
1180     ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
1181     RequirementAssignment requirementAssignment = requirementAssignmentData
1182             .getRequirementAssignment();
1183     String newAbstractUnifiedNodeTemplateId = context.getUnifiedAbstractNodeTemplateId(
1184             serviceTemplate, entityConsolidationData.getNodeTemplateId());
1185     NodeTemplate abstractUnifiedNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
1186             newAbstractUnifiedNodeTemplateId);
1187     Optional<String> newCapabilityId = getNewCapabilityForNodesConnectedIn(serviceTemplate,
1188             abstractUnifiedNodeTemplate, requirementAssignment, newNodeTemplateId, context);
1189     if (newCapabilityId.isPresent()) {
1190       //Creating a copy of the requirement object and checking if it already exists in the
1191       // original node template
1192       RequirementAssignment requirementAssignmentCopy = (RequirementAssignment) getClonedObject(
1193               requirementAssignmentData.getRequirementAssignment(), RequirementAssignment.class);
1194       NodeTemplate originalNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
1195               originalNodeTemplateId);
1196       requirementAssignmentCopy.setCapability(newCapabilityId.get());
1197       requirementAssignmentCopy.setNode(newAbstractUnifiedNodeTemplateId);
1198       if (!toscaAnalyzerService.isRequirementExistInNodeTemplate(originalNodeTemplate,
1199               requirementAssignmentData.getRequirementId(), requirementAssignmentCopy)) {
1200         //Update the existing requirement
1201         requirementAssignmentData.getRequirementAssignment().setCapability(newCapabilityId
1202                 .get());
1203         requirementAssignmentData.getRequirementAssignment()
1204                 .setNode(newAbstractUnifiedNodeTemplateId);
1205       } else {
1206         //The updated requirement already exists in the node template so simply remove the
1207         // current one
1208         DataModelUtil.removeRequirementAssignment(originalNodeTemplate, requirementAssignmentData
1209                 .getRequirementId(), requirementAssignmentData.getRequirementAssignment());
1210       }
1211     }
1212   }
1213
1214   private void updateRequirementForNestedCompositionNodesConnectedIn(
1215           ServiceTemplate serviceTemplate,
1216           RequirementAssignmentData requirementAssignmentData,
1217           String newNodeTemplateId) {
1218     ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
1219     String newAbstractUnifiedNodeTemplateId = newNodeTemplateId;
1220     RequirementAssignment requirementAssignment = requirementAssignmentData
1221             .getRequirementAssignment();
1222     //Creating a copy of the requirement object and checking if it already exists in the
1223     // original node template
1224     RequirementAssignment requirementAssignmentCopy = (RequirementAssignment) getClonedObject(
1225             requirementAssignmentData.getRequirementAssignment(), RequirementAssignment.class);
1226     NodeTemplate unifiedAbstractNestedNodeTemplate = DataModelUtil
1227             .getNodeTemplate(serviceTemplate, newAbstractUnifiedNodeTemplateId);
1228     requirementAssignmentCopy.setCapability(requirementAssignment.getCapability());
1229     requirementAssignmentCopy.setNode(newAbstractUnifiedNodeTemplateId);
1230     if (!toscaAnalyzerService.isRequirementExistInNodeTemplate(unifiedAbstractNestedNodeTemplate,
1231             requirementAssignmentData.getRequirementId(), requirementAssignmentCopy)) {
1232       //Update the existing requirement
1233       requirementAssignmentData.getRequirementAssignment()
1234               .setNode(newAbstractUnifiedNodeTemplateId);
1235     } else {
1236       //The updated requirement already exists in the node template so simply remove the
1237       // current one
1238       DataModelUtil.removeRequirementAssignment(unifiedAbstractNestedNodeTemplate,
1239               requirementAssignmentData.getRequirementId(), requirementAssignmentData
1240                       .getRequirementAssignment());
1241     }
1242   }
1243
1244   private Optional<String> getNewCapabilityForNodesConnectedIn(ServiceTemplate serviceTemplate,
1245                                                                NodeTemplate unifiedNodeTemplate,
1246                                                                RequirementAssignment
1247                                                                        requirementAssignment,
1248                                                                String newNodeTemplateId,
1249                                                                TranslationContext context) {
1250     ServiceTemplate globalSubstitutionServiceTemplate =
1251             HeatToToscaUtil.fetchGlobalSubstitutionServiceTemplate(serviceTemplate, context);
1252     Map<String, NodeType> nodeTypes = globalSubstitutionServiceTemplate.getNode_types();
1253     String unifiedNodeTemplateType = unifiedNodeTemplate.getType();
1254     NodeType unifiedNodeType = nodeTypes.get(unifiedNodeTemplateType);
1255     Map<String, CapabilityDefinition> abstractNodeTypeCapabilities = unifiedNodeType
1256             .getCapabilities();
1257     for (Map.Entry<String, CapabilityDefinition> entry : abstractNodeTypeCapabilities.entrySet()) {
1258       String capabilityId = entry.getKey();
1259       CapabilityDefinition capabilityDefinition = entry.getValue();
1260       String capabilityType = capabilityDefinition.getType();
1261       if (capabilityType.equals(requirementAssignment.getCapability())
1262               && capabilityId.endsWith(newNodeTemplateId)) {
1263         //Matching capability type found..Check if the id ends with new node template id
1264         return Optional.ofNullable(capabilityId);
1265       }
1266     }
1267     return Optional.empty();
1268   }
1269
1270
1271   private void updateRequirementInAbstractNodeTemplate(ServiceTemplate serviceTemplate,
1272                                                        EntityConsolidationData
1273                                                                entityConsolidationData,
1274                                                        String newNodeTemplateId,
1275                                                        Map<String, List<RequirementAssignmentData>>
1276                                                                requirementAssignmentDataMap,
1277                                                        TranslationContext context) {
1278     ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
1279     for (Map.Entry<String, List<RequirementAssignmentData>> entry : requirementAssignmentDataMap
1280             .entrySet()) {
1281       String abstractNodeTemplateId = context.getUnifiedAbstractNodeTemplateId(
1282               serviceTemplate, entityConsolidationData.getNodeTemplateId());
1283       NodeTemplate abstractNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
1284               abstractNodeTemplateId);
1285       if (abstractNodeTemplate == null) {
1286         //The abstract node template is not found from id in the context
1287         return;
1288       }
1289       List<RequirementAssignmentData> requirementAssignmentDataList = entry.getValue();
1290       for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList) {
1291         String oldRequirementId = requirementAssignmentData.getRequirementId();
1292         RequirementAssignment abstractRequirementAssignment = (RequirementAssignment)
1293                 getClonedObject(requirementAssignmentData.getRequirementAssignment(),
1294                         RequirementAssignment.class);
1295         String newRequirementId = oldRequirementId + "_" + newNodeTemplateId;
1296         //Check if the requirement is not already present in the list of requirements of the
1297         // abstract node template
1298         if (!toscaAnalyzerService.isRequirementExistInNodeTemplate(abstractNodeTemplate,
1299                 newRequirementId, abstractRequirementAssignment)) {
1300           DataModelUtil.addRequirementAssignment(abstractNodeTemplate, newRequirementId,
1301                   abstractRequirementAssignment);
1302           //Update the volume relationship template if required
1303           updateVolumeRelationshipTemplate(serviceTemplate, abstractRequirementAssignment
1304                   .getRelationship(), context);
1305         }
1306       }
1307     }
1308   }
1309
1310   private void updateRequirementInNestedNodeTemplate(ServiceTemplate serviceTemplate,
1311                                                      EntityConsolidationData
1312                                                              entityConsolidationData,
1313                                                      String newNodeTemplateId,
1314                                                      Map<String, List<RequirementAssignmentData>>
1315                                                              requirementAssignmentDataMap) {
1316     ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
1317
1318     if (MapUtils.isEmpty(requirementAssignmentDataMap)) {
1319       return;
1320     }
1321
1322     for (Map.Entry<String, List<RequirementAssignmentData>> entry : requirementAssignmentDataMap
1323             .entrySet()) {
1324       String nodeTemplateId = entityConsolidationData.getNodeTemplateId();
1325       NodeTemplate nodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate, nodeTemplateId);
1326       if (nodeTemplate == null) {
1327         //The node template is not found from id in the context
1328         return;
1329       }
1330       List<RequirementAssignmentData> requirementAssignmentDataList = entry.getValue();
1331       for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList) {
1332         String oldRequirementId = requirementAssignmentData.getRequirementId();
1333         RequirementAssignment clonedRequirementAssignment = (RequirementAssignment)
1334                 getClonedObject(requirementAssignmentData.getRequirementAssignment(),
1335                         RequirementAssignment.class);
1336         String newRequirementId = oldRequirementId + "_" + newNodeTemplateId;
1337         //Check if the requirement is not already present in the list of requirements of the
1338         // node template
1339         if (!toscaAnalyzerService.isRequirementExistInNodeTemplate(nodeTemplate,
1340                 newRequirementId, clonedRequirementAssignment)) {
1341           DataModelUtil.removeRequirementAssignment(nodeTemplate, oldRequirementId,
1342                   requirementAssignmentData.getRequirementAssignment());
1343           DataModelUtil.addRequirementAssignment(nodeTemplate, newRequirementId,
1344                   clonedRequirementAssignment);
1345         }
1346       }
1347     }
1348   }
1349
1350   private void updNodeGetAttrInConnectivity(
1351           ServiceTemplate serviceTemplate,
1352           EntityConsolidationData entityConsolidationData,
1353           String oldNodeTemplateId, String newNodeTemplateId,
1354           TranslationContext context,
1355           Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType,
1356           boolean isNested) {
1357     Map<String, List<GetAttrFuncData>> nodesGetAttrIn = entityConsolidationData.getNodesGetAttrIn();
1358     if (MapUtils.isEmpty(nodesGetAttrIn)) {
1359       return;
1360     }
1361
1362     for (Map.Entry<String, List<GetAttrFuncData>> nodesGetAttrInEntry : nodesGetAttrIn.entrySet()) {
1363       String sourceNodeTemplateId = nodesGetAttrInEntry.getKey();
1364       NodeTemplate sourceNodeTemplate =
1365               DataModelUtil.getNodeTemplate(serviceTemplate, sourceNodeTemplateId);
1366       if (!isNested && consolidationNodeTemplateIdAndType.keySet().contains(sourceNodeTemplateId)) {
1367         continue;
1368       }
1369       List<GetAttrFuncData> getAttrFuncDataList = nodesGetAttrInEntry.getValue();
1370       for (GetAttrFuncData getAttrFuncData : getAttrFuncDataList) {
1371         Object propertyValue =
1372                 DataModelUtil.getPropertyValue(sourceNodeTemplate, getAttrFuncData.getFieldName());
1373         String newAttrName = null;
1374         String newGetAttrAbstractNodeTemplateId = newNodeTemplateId;
1375         if (!isNested) {
1376           newGetAttrAbstractNodeTemplateId =
1377                   context.getUnifiedAbstractNodeTemplateId(serviceTemplate, oldNodeTemplateId);
1378           newAttrName = getNewSubstitutionOutputParameterId(newNodeTemplateId, getAttrFuncData
1379                   .getAttributeName());
1380         }
1381         List<List<Object>> getAttrFuncValueList = extractGetAttrFunction(propertyValue);
1382         updateGetAttrValue(oldNodeTemplateId, getAttrFuncData, newGetAttrAbstractNodeTemplateId,
1383                 newAttrName, getAttrFuncValueList, isNested);
1384       }
1385     }
1386   }
1387
1388   private void updateGetAttrValue(String oldNodeTemplateId, GetAttrFuncData getAttrFuncData,
1389                                   String newNodeTemplateId, String newAttrName,
1390                                   List<List<Object>> getAttrFuncValueList, boolean isNested) {
1391     for (List<Object> getAttrFuncValue : getAttrFuncValueList) {
1392       if (oldNodeTemplateId.equals(getAttrFuncValue.get(0))
1393               && getAttrFuncData.getAttributeName().equals(getAttrFuncValue.get(1))) {
1394         getAttrFuncValue.set(0, newNodeTemplateId);
1395         if (!isNested) {
1396           getAttrFuncValue.set(1, newAttrName);
1397         }
1398       }
1399     }
1400   }
1401
1402   private String getTemplateName(String nodeTypeId,
1403                                  Integer index) {
1404     String computeType = getComputeTypeSuffix(nodeTypeId);
1405     String templateName = "Nested_" + computeType;
1406     if (Objects.nonNull(index)) {
1407       templateName = templateName + "_" + index.toString();
1408     }
1409     return templateName;
1410   }
1411
1412   private void updOutputParamGetAttrInConnectivity(ServiceTemplate serviceTemplate,
1413                                                    EntityConsolidationData entityConsolidationData,
1414                                                    String oldNodeTemplateId,
1415                                                    String newNodeTemplateId,
1416                                                    TranslationContext context,
1417                                                    boolean isNested) {
1418     List<GetAttrFuncData> outputParametersGetAttrIn =
1419             entityConsolidationData.getOutputParametersGetAttrIn();
1420     if (CollectionUtils.isEmpty(outputParametersGetAttrIn)) {
1421       return;
1422     }
1423     for (GetAttrFuncData getAttrFuncData : outputParametersGetAttrIn) {
1424       Object outputParamValue =
1425               DataModelUtil.getOuputParameter(serviceTemplate, getAttrFuncData.getFieldName())
1426                       .getValue();
1427       String newAttrName = null;
1428       String newGetAttrAbstractNodeTemplateId = newNodeTemplateId;
1429       if (!isNested) {
1430         newGetAttrAbstractNodeTemplateId =
1431                 context.getUnifiedAbstractNodeTemplateId(serviceTemplate, oldNodeTemplateId);
1432         newAttrName = getNewSubstitutionOutputParameterId(newNodeTemplateId, getAttrFuncData
1433                 .getAttributeName());
1434       }
1435       List<List<Object>> getAttrFuncValueList = extractGetAttrFunction(outputParamValue);
1436       updateGetAttrValue(oldNodeTemplateId, getAttrFuncData, newGetAttrAbstractNodeTemplateId,
1437               newAttrName,
1438               getAttrFuncValueList, isNested);
1439     }
1440
1441   }
1442
1443   private List<List<Object>> extractGetAttrFunction(Object valueObject) {
1444
1445     List<List<Object>> getAttrValueList = new ArrayList<>();
1446
1447     if (valueObject instanceof Map) {
1448       if (((Map) valueObject).containsKey(ToscaFunctions.GET_ATTRIBUTE.getDisplayName())) {
1449         getAttrValueList.add(
1450                 (List<Object>) ((Map) valueObject).get(ToscaFunctions.GET_ATTRIBUTE.getDisplayName()));
1451       }
1452
1453       for (Object key : ((Map) valueObject).keySet()) {
1454         getAttrValueList.addAll(extractGetAttrFunction(((Map) valueObject).get(key)));
1455       }
1456
1457
1458     } else if (valueObject instanceof List) {
1459       for (Object valueEntity : (List) valueObject) {
1460         getAttrValueList.addAll(extractGetAttrFunction(valueEntity));
1461       }
1462     }
1463     return getAttrValueList;
1464   }
1465
1466   private boolean isIncludeToscaFunc(Object valueObject, ToscaFunctions toscaFunction) {
1467     if (valueObject instanceof Map) {
1468       if (((Map) valueObject).containsKey(toscaFunction.getDisplayName())) {
1469         return true;
1470       }
1471
1472       Set<Map.Entry<String, Object>> entries = ((Map<String, Object>) valueObject).entrySet();
1473       for (Map.Entry<String, Object> valueObjectEntry : entries) {
1474         if (isIncludeToscaFunc(valueObjectEntry.getValue(), toscaFunction)) {
1475           return true;
1476         }
1477       }
1478     } else if (valueObject instanceof List) {
1479       for (Object valueEntity : (List) valueObject) {
1480         if (isIncludeToscaFunc(valueEntity, toscaFunction)) {
1481           return true;
1482         }
1483       }
1484     }
1485     return false;
1486   }
1487
1488   private void createOutputParameters(UnifiedCompositionTo unifiedCompositionTo,
1489                                       String computeNodeType) {
1490
1491     createOutputParametersForCompute(unifiedCompositionTo.getServiceTemplate(),
1492             unifiedCompositionTo.getSubstitutionServiceTemplate(), unifiedCompositionTo.getUnifiedCompositionDataList(),
1493             unifiedCompositionTo.getContext());
1494     createOutputParameterForPorts(unifiedCompositionTo.getSubstitutionServiceTemplate(),
1495             unifiedCompositionTo.getUnifiedCompositionDataList(), computeNodeType, unifiedCompositionTo.getContext());
1496     createOutputParameterForSubInterfaces(unifiedCompositionTo, computeNodeType);
1497   }
1498
1499   private void createOutputParameterForPorts(
1500           ServiceTemplate substitutionServiceTemplate,
1501           List<UnifiedCompositionData> unifiedCompositionDataList,
1502           String connectedComputeNodeType,
1503           TranslationContext context) {
1504     for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
1505       List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
1506               getPortTemplateConsolidationDataList(unifiedCompositionData);
1507       if (CollectionUtils.isEmpty(portTemplateConsolidationDataList)) {
1508         return;
1509       }
1510
1511       for (PortTemplateConsolidationData portTemplateConsolidationData :
1512               portTemplateConsolidationDataList) {
1513         String newPortNodeTemplateId =
1514                 getNewPortNodeTemplateId(portTemplateConsolidationData.getNodeTemplateId(),
1515                         connectedComputeNodeType,
1516                         unifiedCompositionData.getComputeTemplateConsolidationData());
1517         addOutputParameters(portTemplateConsolidationData, newPortNodeTemplateId,
1518                 substitutionServiceTemplate, unifiedCompositionDataList, context);
1519       }
1520     }
1521   }
1522
1523   private void createOutputParameterForSubInterfaces(UnifiedCompositionTo unifiedCompositionTo,
1524                                                      String connectedComputeNodeType) {
1525     for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionTo.getUnifiedCompositionDataList()) {
1526       List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
1527               getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
1528       if (CollectionUtils.isEmpty(subInterfaceTemplateConsolidationDataList)) {
1529         return;
1530       }
1531
1532       for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData :
1533               subInterfaceTemplateConsolidationDataList) {
1534         String newSubInterfaceNodeTemplateId = getNewSubInterfaceNodeTemplateId(unifiedCompositionTo
1535                         .getServiceTemplate(), connectedComputeNodeType, unifiedCompositionData
1536                         .getComputeTemplateConsolidationData(), subInterfaceTemplateConsolidationData,
1537                 unifiedCompositionTo.getContext());
1538         addOutputParameters(subInterfaceTemplateConsolidationData, newSubInterfaceNodeTemplateId,
1539                 unifiedCompositionTo.getSubstitutionServiceTemplate(), unifiedCompositionTo.getUnifiedCompositionDataList(),
1540                 unifiedCompositionTo.getContext());
1541       }
1542     }
1543   }
1544
1545   private void createOutputParametersForCompute(
1546           ServiceTemplate serviceTemplate,
1547           ServiceTemplate substitutionServiceTemplate,
1548           List<UnifiedCompositionData>
1549                   unifiedCompositionDataList,
1550           TranslationContext context) {
1551     List<EntityConsolidationData> computeConsolidationDataList =
1552             getComputeConsolidationDataList(unifiedCompositionDataList);
1553
1554     for (EntityConsolidationData computeTemplateConsolidationData : computeConsolidationDataList) {
1555       String newComputeNodeTemplateId =
1556               getNewComputeNodeTemplateId(serviceTemplate,
1557                       computeTemplateConsolidationData.getNodeTemplateId());
1558       addOutputParameters(computeTemplateConsolidationData, newComputeNodeTemplateId,
1559               substitutionServiceTemplate, unifiedCompositionDataList, context);
1560     }
1561   }
1562
1563   private void addOutputParameters(EntityConsolidationData entityConsolidationData,
1564                                    String newNodeTemplateId,
1565                                    ServiceTemplate substitutionServiceTemplate,
1566                                    List<UnifiedCompositionData> unifiedCompositionDataList,
1567                                    TranslationContext context) {
1568     handleNodesGetAttrIn(entityConsolidationData, newNodeTemplateId, substitutionServiceTemplate,
1569             unifiedCompositionDataList, context);
1570
1571     handleOutputParamGetAttrIn(entityConsolidationData, newNodeTemplateId,
1572             substitutionServiceTemplate, context);
1573   }
1574
1575   private void handleOutputParamGetAttrIn(EntityConsolidationData entityConsolidationData,
1576                                           String newNodeTemplateId,
1577                                           ServiceTemplate substitutionServiceTemplate,
1578                                           TranslationContext context) {
1579     List<GetAttrFuncData> outputParametersGetAttrIn =
1580             entityConsolidationData.getOutputParametersGetAttrIn();
1581     if (!CollectionUtils.isEmpty(outputParametersGetAttrIn)) {
1582       for (GetAttrFuncData getAttrFuncData : outputParametersGetAttrIn) {
1583         createAndAddOutputParameter(newNodeTemplateId,
1584                 substitutionServiceTemplate, getAttrFuncData, context);
1585       }
1586     }
1587   }
1588
1589   private void handleNodesGetAttrIn(EntityConsolidationData entityConsolidationData,
1590                                     String newNodeTemplateId,
1591                                     ServiceTemplate substitutionServiceTemplate,
1592                                     List<UnifiedCompositionData> unifiedCompositionDataList,
1593                                     TranslationContext context) {
1594     Map<String, List<GetAttrFuncData>> getAttrIn = entityConsolidationData.getNodesGetAttrIn();
1595     if (MapUtils.isEmpty(getAttrIn)) {
1596       return;
1597     }
1598     Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType =
1599             getAllConsolidationNodeTemplateIdAndType(unifiedCompositionDataList);
1600     for (Map.Entry<String, List<GetAttrFuncData>> getAttrInEntry : getAttrIn.entrySet()) {
1601       String sourceNodeTemplateId = getAttrInEntry.getKey();
1602       if (!consolidationNodeTemplateIdAndType.keySet().contains(sourceNodeTemplateId)) {
1603         List<GetAttrFuncData> getAttrFuncDataList = getAttrInEntry.getValue();
1604         for (GetAttrFuncData getAttrFuncData : getAttrFuncDataList) {
1605           createAndAddOutputParameter(newNodeTemplateId,
1606                   substitutionServiceTemplate, getAttrFuncData, context);
1607         }
1608       }
1609     }
1610   }
1611
1612   private void createAndAddOutputParameter(String newNodeTemplateId,
1613                                            ServiceTemplate substitutionServiceTemplate,
1614                                            GetAttrFuncData getAttrFuncData,
1615                                            TranslationContext context) {
1616     Map<String, List<Object>> parameterValue = new HashMap<>();
1617     List<Object> valueList = new ArrayList<>();
1618     valueList.add(newNodeTemplateId);
1619     valueList.add(getAttrFuncData.getAttributeName());
1620     parameterValue.put(ToscaFunctions.GET_ATTRIBUTE.getDisplayName(), valueList);
1621     ParameterDefinition outputParameter = new ParameterDefinition();
1622     outputParameter.setValue(parameterValue);
1623     setOutputParameterType(substitutionServiceTemplate, newNodeTemplateId, getAttrFuncData
1624             .getAttributeName(), outputParameter, context);
1625     DataModelUtil.addOutputParameterToTopologyTemplate(substitutionServiceTemplate,
1626             getNewSubstitutionOutputParameterId(newNodeTemplateId, getAttrFuncData.getAttributeName()),
1627             outputParameter);
1628   }
1629
1630   private void setOutputParameterType(ServiceTemplate substitutionServiceTemplate,
1631                                       String newNodeTemplateId,
1632                                       String outputParameterName,
1633                                       ParameterDefinition outputParameter,
1634                                       TranslationContext context) {
1635     NodeTemplate nodeTemplate = DataModelUtil.getNodeTemplate(substitutionServiceTemplate,
1636             newNodeTemplateId);
1637     //Get the type and entry schema of the output parameter from the node type flat hierarchy
1638     String outputParameterType;
1639     EntrySchema outputParameterEntrySchema;
1640     NodeType nodeTypeWithFlatHierarchy =
1641             HeatToToscaUtil.getNodeTypeWithFlatHierarchy(nodeTemplate.getType(),
1642                     substitutionServiceTemplate, context);
1643     //Check if the parameter is present in the attributes
1644     AttributeDefinition outputParameterDefinitionFromAttributes =
1645             getOutputParameterDefinitionFromAttributes(nodeTypeWithFlatHierarchy, outputParameterName);
1646     if (Objects.nonNull(outputParameterDefinitionFromAttributes)) {
1647       outputParameterType = outputParameterDefinitionFromAttributes.getType();
1648       outputParameterEntrySchema = outputParameterDefinitionFromAttributes.getEntry_schema();
1649     } else {
1650       //If the below fails due to null pointer then we need to check if the heatToToscaMapping
1651       // properties and global types are in sync. Ideally the parameter should be found in either
1652       // properties or attributes collected from global types
1653       PropertyDefinition outputParameterDefinitionFromProperties =
1654               nodeTypeWithFlatHierarchy.getProperties().get(outputParameterName);
1655       outputParameterType = outputParameterDefinitionFromProperties.getType();
1656       outputParameterEntrySchema = outputParameterDefinitionFromProperties.getEntry_schema();
1657     }
1658     //Set the type and entry schema for the output param obtained from the node type hierarchy
1659     outputParameter.setType(outputParameterType);
1660     outputParameter.setEntry_schema(outputParameterEntrySchema);
1661   }
1662
1663   private AttributeDefinition getOutputParameterDefinitionFromAttributes(NodeType
1664                                                                                  nodeTypeWithFlatHierarchy,
1665                                                                          String outputParameterName) {
1666     AttributeDefinition outputParameterDefinition = null;
1667     if ((Objects.nonNull(nodeTypeWithFlatHierarchy.getAttributes()))
1668             && (nodeTypeWithFlatHierarchy.getAttributes().containsKey(outputParameterName))) {
1669       outputParameterDefinition =
1670               nodeTypeWithFlatHierarchy.getAttributes().get(outputParameterName);
1671     }
1672     return outputParameterDefinition;
1673   }
1674
1675   private String getNewSubstitutionOutputParameterId(String newNodeTemplateId,
1676                                                      String attributeName) {
1677     return newNodeTemplateId + "_" + attributeName;
1678   }
1679
1680   private void addUnifiedSubstitionData(TranslationContext context, ServiceTemplate
1681           serviceTemplate, List<UnifiedCompositionData> unifiedCompositionDataList, String
1682                                                 substituteNodeTemplateId) {
1683     String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
1684     for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
1685       //Add compute node template mapping information
1686       ComputeTemplateConsolidationData computeTemplateConsolidationData =
1687               unifiedCompositionData.getComputeTemplateConsolidationData();
1688       String computeNodeTemplateId = computeTemplateConsolidationData.getNodeTemplateId();
1689       context.addUnifiedSubstitutionData(serviceTemplateFileName, computeNodeTemplateId,
1690               substituteNodeTemplateId);
1691       //Add Port template mapping information
1692       List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
1693               getPortTemplateConsolidationDataList(unifiedCompositionData);
1694
1695       if (CollectionUtils.isNotEmpty(portTemplateConsolidationDataList)) {
1696         for (PortTemplateConsolidationData portTemplateConsolidationData :
1697                 portTemplateConsolidationDataList) {
1698           String oldPortNodeTemplateId = portTemplateConsolidationData.getNodeTemplateId();
1699           context.addUnifiedSubstitutionData(serviceTemplateFileName, oldPortNodeTemplateId,
1700                   substituteNodeTemplateId);
1701         }
1702       }
1703       //Add Sub-interface template mapping information
1704       List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
1705               getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
1706       if (CollectionUtils.isNotEmpty(subInterfaceTemplateConsolidationDataList)) {
1707         for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData :
1708                 subInterfaceTemplateConsolidationDataList) {
1709           context.addUnifiedSubstitutionData(serviceTemplateFileName,
1710                   subInterfaceTemplateConsolidationData.getNodeTemplateId(), substituteNodeTemplateId);
1711         }
1712       }
1713     }
1714   }
1715
1716   private void addIndexValueProperty(NodeTemplate nodeTemplate) {
1717     List<String> indexValueGetPropertyValue = new ArrayList<>();
1718     indexValueGetPropertyValue.add(ToscaConstants.MODELABLE_ENTITY_NAME_SELF);
1719     indexValueGetPropertyValue.add(ToscaConstants.SERVICE_TEMPLATE_FILTER_PROPERTY_NAME);
1720     indexValueGetPropertyValue.add(ToscaConstants.INDEX_VALUE_PROPERTY_NAME);
1721
1722     Map<String, Object> indexPropertyValue = new HashMap<>();
1723     Map<String, Object> properties = nodeTemplate.getProperties();
1724     indexPropertyValue.put(ToscaFunctions.GET_PROPERTY.getDisplayName(),
1725             indexValueGetPropertyValue);
1726     properties.put(ToscaConstants.INDEX_VALUE_PROPERTY_NAME,
1727             indexPropertyValue);
1728     nodeTemplate.setProperties(properties);
1729   }
1730
1731   private String getSubstituteNodeTemplateId(String nodeTypeId,
1732                                              Integer index) {
1733     String nodeTemplateId = ABSTRACT_NODE_TEMPLATE_ID_PREFIX + DataModelUtil
1734             .getNamespaceSuffix(nodeTypeId);
1735     if (Objects.nonNull(index)) {
1736       nodeTemplateId = nodeTemplateId + "_" + index.toString();
1737     }
1738     return nodeTemplateId;
1739   }
1740
1741   /**
1742    * Gets substitution node type id.
1743    *
1744    * @param serviceTemplate        the service template
1745    * @param unifiedCompositionData the unified composition data
1746    * @param index                  the index
1747    * @return the substitution node type id
1748    */
1749   public String getSubstitutionNodeTypeId(ServiceTemplate serviceTemplate,
1750                                           UnifiedCompositionData unifiedCompositionData,
1751                                           Integer index,
1752                                           TranslationContext context) {
1753     String computeNodeTemplateId =
1754             unifiedCompositionData.getComputeTemplateConsolidationData().getNodeTemplateId();
1755     NodeTemplate computeNodeTemplate =
1756             DataModelUtil.getNodeTemplate(serviceTemplate, computeNodeTemplateId);
1757     String computeType = computeNodeTemplate.getType();
1758     String globalSTName = ToscaUtil.getServiceTemplateFileName(Constants
1759             .GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME);
1760
1761     String nodeTypeId = ToscaNodeType.ABSTRACT_NODE_TYPE_PREFIX
1762             + DataModelUtil.getNamespaceSuffix(getIndexedGlobalNodeTypeId(computeType, context));
1763
1764     context.updateUsedTimesForNestedComputeNodeType(globalSTName, computeType);
1765
1766     if (Objects.nonNull(index)) {
1767       nodeTypeId = nodeTypeId + "_" + index.toString();
1768     }
1769     return nodeTypeId;
1770   }
1771
1772   private NodeType handleSubstitutionGlobalNodeType(ServiceTemplate serviceTemplate,
1773                                                     ServiceTemplate substitutionServiceTemplate,
1774                                                     TranslationContext context,
1775                                                     String substitutionNodeTypeId) {
1776     NodeType substitutionNodeType = new ToscaAnalyzerServiceImpl()
1777             .createInitSubstitutionNodeType(substitutionServiceTemplate,
1778                     ToscaNodeType.VFC_ABSTRACT_SUBSTITUTE);
1779     ServiceTemplate globalSubstitutionServiceTemplate =
1780             HeatToToscaUtil.fetchGlobalSubstitutionServiceTemplate(serviceTemplate, context);
1781     DataModelUtil.addNodeType(globalSubstitutionServiceTemplate, substitutionNodeTypeId,
1782             substitutionNodeType);
1783
1784     return substitutionNodeType;
1785   }
1786
1787   private void handlePorts(ServiceTemplate serviceTemplate,
1788                            ServiceTemplate substitutionServiceTemplate,
1789                            List<UnifiedCompositionData> unifiedCompositionDataList,
1790                            String connectedComputeNodeType,
1791                            TranslationContext context) {
1792
1793     if (unifiedCompositionDataList.size() > 1) {
1794       handleConsolidationPorts(serviceTemplate, substitutionServiceTemplate,
1795               unifiedCompositionDataList, connectedComputeNodeType, context);
1796     } else {
1797       handleSinglePorts(serviceTemplate, substitutionServiceTemplate, connectedComputeNodeType,
1798               unifiedCompositionDataList, context);
1799     }
1800   }
1801
1802   private void handleSinglePorts(ServiceTemplate serviceTemplate,
1803                                  ServiceTemplate substitutionServiceTemplate,
1804                                  String connectedComputeNodeType,
1805                                  List<UnifiedCompositionData> unifiedCompositionDataList,
1806                                  TranslationContext context) {
1807     UnifiedCompositionData unifiedCompositionData = unifiedCompositionDataList.get(0);
1808     List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
1809             getPortTemplateConsolidationDataList(unifiedCompositionData);
1810     if (CollectionUtils.isEmpty(portTemplateConsolidationDataList)) {
1811       return;
1812     }
1813     for (PortTemplateConsolidationData portTemplateConsolidationData :
1814             portTemplateConsolidationDataList) {
1815       List<EntityConsolidationData> portConsolidationDataList = new ArrayList<>();
1816       portConsolidationDataList.add(portTemplateConsolidationData);
1817       handlePortNodeTemplate(serviceTemplate, substitutionServiceTemplate,
1818               portConsolidationDataList, connectedComputeNodeType,
1819               unifiedCompositionData.getComputeTemplateConsolidationData(),
1820               unifiedCompositionDataList, context);
1821     }
1822   }
1823
1824   private void handleConsolidationPorts(ServiceTemplate serviceTemplate,
1825                                         ServiceTemplate substitutionServiceTemplate,
1826                                         List<UnifiedCompositionData> unifiedCompositionDataList,
1827                                         String connectedComputeNodeType,
1828                                         TranslationContext context) {
1829     Collection<ComputeTemplateConsolidationData> computeConsolidationDataList =
1830             (Collection) getComputeConsolidationDataList(unifiedCompositionDataList);
1831
1832     Map<String, List<String>> portIdsPerPortType = UnifiedCompositionUtil
1833             .collectAllPortsFromEachTypesFromComputes(computeConsolidationDataList);
1834
1835     for (Map.Entry<String, List<String>> portIdsPerPortTypeEntry : portIdsPerPortType.entrySet()) {
1836       List<EntityConsolidationData> portTemplateConsolidationDataList =
1837               getPortConsolidationDataList(portIdsPerPortTypeEntry.getValue(),
1838                       unifiedCompositionDataList);
1839       if (CollectionUtils.isEmpty(portTemplateConsolidationDataList)) {
1840         continue;
1841       }
1842
1843       handlePortNodeTemplate(serviceTemplate, substitutionServiceTemplate,
1844               portTemplateConsolidationDataList, connectedComputeNodeType,
1845               unifiedCompositionDataList.get(0).getComputeTemplateConsolidationData(),
1846               unifiedCompositionDataList, context);
1847     }
1848   }
1849
1850   private void handlePortNodeTemplate(
1851           ServiceTemplate serviceTemplate,
1852           ServiceTemplate substitutionServiceTemplate,
1853           List<EntityConsolidationData> portTemplateConsolidationDataList,
1854           String connectedComputeNodeType,
1855           ComputeTemplateConsolidationData computeTemplateConsolidationData,
1856           List<UnifiedCompositionData> unifiedCompositionDataList,
1857           TranslationContext context) {
1858     EntityConsolidationData portTemplateConsolidationData =
1859             portTemplateConsolidationDataList.get(0);
1860     NodeTemplate newPortNodeTemplate = getNodeTemplate(
1861             portTemplateConsolidationData.getNodeTemplateId(), serviceTemplate, context).clone();
1862
1863     removeConnectivityOut(portTemplateConsolidationData, newPortNodeTemplate);
1864     handleProperties(serviceTemplate, newPortNodeTemplate,
1865             substitutionServiceTemplate, UnifiedCompositionEntity.PORT,
1866             portTemplateConsolidationDataList, computeTemplateConsolidationData,
1867             unifiedCompositionDataList, context);
1868
1869     String newPortNodeTemplateId =
1870             getNewPortNodeTemplateId(portTemplateConsolidationData
1871                             .getNodeTemplateId(), connectedComputeNodeType,
1872                     computeTemplateConsolidationData);
1873     //Update requirements for relationships between the consolidation entities
1874     handleConsolidationEntitiesRequirementConnectivity(newPortNodeTemplate,
1875             serviceTemplate, context);
1876     DataModelUtil.addNodeTemplate(substitutionServiceTemplate, newPortNodeTemplateId,
1877             newPortNodeTemplate);
1878
1879     //Add the node template mapping in the context for handling requirement updation
1880     for (EntityConsolidationData data : portTemplateConsolidationDataList) {
1881       String newPortTemplateId = getNewPortNodeTemplateId(data.getNodeTemplateId(),
1882               connectedComputeNodeType, computeTemplateConsolidationData);
1883       context.addSubstitutionServiceTemplateUnifiedSubstitutionData(ToscaUtil
1884                       .getServiceTemplateFileName(serviceTemplate), data.getNodeTemplateId(),
1885               newPortTemplateId);
1886     }
1887
1888   }
1889
1890   private void handleSubInterfaces(UnifiedCompositionTo unifiedCompositionTo) {
1891     if (unifiedCompositionTo.getUnifiedCompositionDataList().size() > 1) {
1892       handleConsolidationSubInterfaces(unifiedCompositionTo);
1893     } else {
1894       handleSingleSubInterfaces(unifiedCompositionTo);
1895     }
1896   }
1897
1898   private void handleSingleSubInterfaces(UnifiedCompositionTo unifiedCompositionTo) {
1899     UnifiedCompositionData unifiedCompositionData = unifiedCompositionTo.getUnifiedCompositionDataList().get(0);
1900     List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
1901             getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
1902     for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData :
1903             subInterfaceTemplateConsolidationDataList) {
1904       List<SubInterfaceTemplateConsolidationData> subInterfaceDataList = new ArrayList<>();
1905       subInterfaceDataList.add(subInterfaceTemplateConsolidationData);
1906       createSubInterfaceSubstitutionNodeTemplate(unifiedCompositionTo, subInterfaceDataList);
1907     }
1908   }
1909
1910   private void handleConsolidationSubInterfaces(UnifiedCompositionTo unifiedCompositionTo) {
1911     Collection<ComputeTemplateConsolidationData> computeConsolidationDataList =
1912             (Collection) getComputeConsolidationDataList(unifiedCompositionTo.getUnifiedCompositionDataList());
1913
1914     Map<String, List<String>> portIdsPerPortType = UnifiedCompositionUtil
1915             .collectAllPortsFromEachTypesFromComputes(computeConsolidationDataList);
1916
1917     for (Map.Entry<String, List<String>> portIdsPerPortTypeEntry : portIdsPerPortType.entrySet()) {
1918       List<EntityConsolidationData> portEntityConsolidationDataList =
1919               getPortConsolidationDataList(portIdsPerPortTypeEntry.getValue(),
1920                       unifiedCompositionTo.getUnifiedCompositionDataList());
1921       if (CollectionUtils.isEmpty(portEntityConsolidationDataList)) {
1922         continue;
1923       }
1924
1925       List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
1926               portEntityConsolidationDataList.stream()
1927                       .map(data -> (PortTemplateConsolidationData) data)
1928                       .collect(Collectors.toList());
1929
1930       ListMultimap<String, SubInterfaceTemplateConsolidationData> subInterfacesByType = UnifiedCompositionUtil
1931               .collectAllSubInterfacesOfEachTypesFromPorts(portTemplateConsolidationDataList);
1932       Set<String> subInterfaceTypes = subInterfacesByType.keySet();
1933       for (String subInterfaceType: subInterfaceTypes) {
1934         List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
1935                 subInterfacesByType.get(subInterfaceType);
1936         createSubInterfaceSubstitutionNodeTemplate(unifiedCompositionTo, subInterfaceTemplateConsolidationDataList);
1937       }
1938     }
1939   }
1940
1941   private void createSubInterfaceSubstitutionNodeTemplate(UnifiedCompositionTo unifiedCompositionTo,
1942                                                           List<SubInterfaceTemplateConsolidationData>
1943                                                                   subInterfaceTemplateConsolidationDataList) {
1944     SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData =
1945             subInterfaceTemplateConsolidationDataList.get(0);
1946     Optional<PortTemplateConsolidationData> portTemplateConsolidationDataOptional =
1947         subInterfaceTemplateConsolidationData.getParentPortTemplateConsolidationData(unifiedCompositionTo
1948                 .getServiceTemplate(), unifiedCompositionTo.getContext());
1949     if (!portTemplateConsolidationDataOptional.isPresent()) {
1950       return;
1951     }
1952     PortTemplateConsolidationData portTemplateConsolidationData = portTemplateConsolidationDataOptional.get();
1953     String originalSubInterfaceNodeTemplateId = subInterfaceTemplateConsolidationDataList.get(0)
1954             .getNodeTemplateId();
1955     NodeTemplate originalSubInterfaceNodeTemplate = DataModelUtil.getNodeTemplate(unifiedCompositionTo
1956             .getServiceTemplate(), originalSubInterfaceNodeTemplateId);
1957     if (Objects.isNull(originalSubInterfaceNodeTemplate)) {
1958       return;
1959     }
1960     NodeTemplate newSubInterfaceNodeTemplate = originalSubInterfaceNodeTemplate.clone();
1961     ComputeTemplateConsolidationData connectedComputeConsolidationData =
1962             getConnectedComputeConsolidationData(unifiedCompositionTo.getUnifiedCompositionDataList(),
1963                     portTemplateConsolidationData.getNodeTemplateId());
1964     if (Objects.nonNull(connectedComputeConsolidationData)) {
1965       NodeTemplate connectedComputeNodeTemplate = DataModelUtil.getNodeTemplate(unifiedCompositionTo
1966               .getServiceTemplate(), connectedComputeConsolidationData.getNodeTemplateId());
1967       String newSubInterfaceNodeTemplateId = getNewSubInterfaceNodeTemplateId(unifiedCompositionTo
1968                       .getServiceTemplate(), connectedComputeNodeTemplate.getType(), connectedComputeConsolidationData,
1969               subInterfaceTemplateConsolidationData, unifiedCompositionTo.getContext());
1970       DataModelUtil.addNodeTemplate(unifiedCompositionTo.getSubstitutionServiceTemplate(),
1971               newSubInterfaceNodeTemplateId, newSubInterfaceNodeTemplate);
1972       List<EntityConsolidationData> entityConsolidationDataList =
1973               new ArrayList<>(subInterfaceTemplateConsolidationDataList);
1974       //Remove all the existing properties as we are going to create new based on the
1975       // naming convention for the substitution
1976       handleSubInterfaceProperties(unifiedCompositionTo, newSubInterfaceNodeTemplate, entityConsolidationDataList,
1977               portTemplateConsolidationData);
1978       //Update requirements for relationships between the consolidation entities
1979       handleConsolidationEntitiesRequirementConnectivity(newSubInterfaceNodeTemplate, unifiedCompositionTo
1980               .getServiceTemplate(), unifiedCompositionTo.getContext());
1981       removeConnectivityOut(subInterfaceTemplateConsolidationData,newSubInterfaceNodeTemplate);
1982     }
1983   }
1984
1985   private void handleSubInterfaceProperties(UnifiedCompositionTo unifiedCompositionTo,
1986                                             NodeTemplate newSubInterfaceNodeTemplate,
1987                                             List<EntityConsolidationData>
1988                                                     entityConsolidationDataList,
1989                                             PortTemplateConsolidationData
1990                                                     portTemplateConsolidationData) {
1991     UnifiedCompositionData unifiedCompositionData = unifiedCompositionTo.getUnifiedCompositionDataList().get(0);
1992     ServiceTemplate serviceTemplate = unifiedCompositionTo.getServiceTemplate();
1993     TranslationContext context = unifiedCompositionTo.getContext();
1994     newSubInterfaceNodeTemplate.setProperties(new HashMap<>());
1995     for (EntityConsolidationData entityConsolidationData : entityConsolidationDataList) {
1996       String nodeTemplateId = entityConsolidationData.getNodeTemplateId();
1997       Optional<List<String>> indexVarProperties =
1998               context.getIndexVarProperties(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
1999                       nodeTemplateId);
2000       Map<String, Object> properties =
2001               DataModelUtil.getNodeTemplateProperties(serviceTemplate, nodeTemplateId);
2002       if (MapUtils.isEmpty(properties)) {
2003         continue;
2004       }
2005
2006       for (Map.Entry<String, Object> propertyEntry : properties.entrySet()) {
2007         NodeType nodeTypeWithFlatHierarchy =
2008                 HeatToToscaUtil.getNodeTypeWithFlatHierarchy(newSubInterfaceNodeTemplate.getType(),
2009                         serviceTemplate, context);
2010         PropertyDefinition propertyDefinition =
2011                 nodeTypeWithFlatHierarchy.getProperties().get(propertyEntry.getKey());
2012         String propertyType = propertyDefinition.getType();
2013         //Handle service_template_filter property for subinterface as we should not create inputs
2014         // for this property
2015         if (propertyEntry.getKey().equals(ToscaConstants.SERVICE_TEMPLATE_FILTER_PROPERTY_NAME)) {
2016           handleSubInterfaceServiceTemplateFilterProperty(newSubInterfaceNodeTemplate,
2017                   propertyEntry.getKey(), propertyEntry.getValue(), serviceTemplate,
2018                   unifiedCompositionTo.getSubstitutionServiceTemplate());
2019         } else if (indexVarProperties.isPresent()
2020                 && indexVarProperties.get().contains(propertyEntry.getKey())) {
2021           //Handle index property
2022           handleIndexVarProperty(propertyEntry.getKey(), propertyEntry.getValue(),
2023                   newSubInterfaceNodeTemplate);
2024         } else {
2025           Optional<String> parameterId =
2026                   updateProperty(serviceTemplate, nodeTemplateId, newSubInterfaceNodeTemplate,
2027                           propertyEntry, UnifiedCompositionEntity.SUB_INTERFACE, unifiedCompositionData
2028                                   .getComputeTemplateConsolidationData(), portTemplateConsolidationData,
2029                           unifiedCompositionTo.getUnifiedCompositionDataList(), context);
2030           parameterId.ifPresent(
2031                   parameterIdValue -> addPropertyInputParameter(propertyType,
2032                           unifiedCompositionTo.getSubstitutionServiceTemplate(),
2033                           propertyDefinition.getEntry_schema(), parameterIdValue));
2034         }
2035       }
2036     }
2037   }
2038
2039   private NodeTemplate getNodeTemplate(String nodeTemplateId, ServiceTemplate serviceTemplate,
2040                                        TranslationContext context) {
2041
2042     NodeTemplate nodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate, nodeTemplateId);
2043
2044     if (Objects.isNull(nodeTemplate)) {
2045       nodeTemplate = context
2046               .getCleanedNodeTemplate(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
2047                       nodeTemplateId);
2048
2049     }
2050     return nodeTemplate;
2051   }
2052
2053
2054   private String handleCompute(ServiceTemplate serviceTemplate,
2055                                ServiceTemplate substitutionServiceTemplate,
2056                                List<UnifiedCompositionData> unifiedCompositionDataList,
2057                                TranslationContext context) {
2058     ComputeTemplateConsolidationData computeTemplateConsolidationData =
2059             unifiedCompositionDataList.get(0).getComputeTemplateConsolidationData();
2060     handleComputeNodeTemplate(serviceTemplate, substitutionServiceTemplate,
2061             unifiedCompositionDataList, context);
2062     return handleComputeNodeType(serviceTemplate, substitutionServiceTemplate,
2063             computeTemplateConsolidationData);
2064   }
2065
2066   private String handleComputeNodeType(
2067           ServiceTemplate serviceTemplate,
2068           ServiceTemplate substitutionServiceTemplate,
2069           ComputeTemplateConsolidationData computeTemplateConsolidationData) {
2070     NodeTemplate computeNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
2071             computeTemplateConsolidationData.getNodeTemplateId());
2072     String computeNodeTypeId = computeNodeTemplate.getType();
2073     NodeType computeNodeType =
2074             DataModelUtil.getNodeType(serviceTemplate, computeNodeTypeId);
2075     DataModelUtil
2076             .addNodeType(substitutionServiceTemplate, computeNodeTypeId, computeNodeType);
2077
2078     return computeNodeTypeId;
2079   }
2080
2081   private void handleComputeNodeTemplate(ServiceTemplate serviceTemplate,
2082                                          ServiceTemplate substitutionServiceTemplate,
2083                                          List<UnifiedCompositionData> unifiedCompositionDataList,
2084                                          TranslationContext context) {
2085     ComputeTemplateConsolidationData computeTemplateConsolidationData =
2086             unifiedCompositionDataList.get(0).getComputeTemplateConsolidationData();
2087     NodeTemplate newComputeNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
2088             computeTemplateConsolidationData.getNodeTemplateId()).clone();
2089
2090     removeConnectivityOut(computeTemplateConsolidationData, newComputeNodeTemplate);
2091     removeVolumeConnectivity(computeTemplateConsolidationData, newComputeNodeTemplate);
2092
2093     List<EntityConsolidationData> computeConsolidationDataList =
2094             getComputeConsolidationDataList(unifiedCompositionDataList);
2095
2096     handleProperties(serviceTemplate, newComputeNodeTemplate,
2097             substitutionServiceTemplate, COMPUTE,
2098             computeConsolidationDataList, computeTemplateConsolidationData, unifiedCompositionDataList,
2099             context);
2100
2101     String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
2102             computeTemplateConsolidationData.getNodeTemplateId());
2103     //Update requirements for relationships between the consolidation entities
2104     handleConsolidationEntitiesRequirementConnectivity(
2105             newComputeNodeTemplate,
2106             serviceTemplate, context);
2107     DataModelUtil
2108             .addNodeTemplate(substitutionServiceTemplate,
2109                     newComputeNodeTemplateId, newComputeNodeTemplate);
2110     //Add the node template mapping in the context for handling requirement updation
2111     for (EntityConsolidationData data : computeConsolidationDataList) {
2112       String newComputeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
2113               computeTemplateConsolidationData.getNodeTemplateId());
2114       context.addSubstitutionServiceTemplateUnifiedSubstitutionData(ToscaUtil
2115                       .getServiceTemplateFileName(serviceTemplate), data.getNodeTemplateId(),
2116               newComputeTemplateId);
2117     }
2118   }
2119
2120   private List<EntityConsolidationData> getComputeConsolidationDataList(
2121           List<UnifiedCompositionData> unifiedCompositionDataList) {
2122     return unifiedCompositionDataList.stream()
2123             .map(UnifiedCompositionData::getComputeTemplateConsolidationData)
2124             .collect(Collectors.toList());
2125   }
2126
2127
2128   private void handleProperties(ServiceTemplate serviceTemplate,
2129                                 NodeTemplate nodeTemplate,
2130                                 ServiceTemplate substitutionServiceTemplate,
2131                                 UnifiedCompositionEntity unifiedCompositionEntity,
2132                                 List<EntityConsolidationData> entityConsolidationDataList,
2133                                 ComputeTemplateConsolidationData computeTemplateConsolidationData,
2134                                 List<UnifiedCompositionData> unifiedCompositionDataList,
2135                                 TranslationContext context) {
2136     nodeTemplate.setProperties(new HashedMap());
2137     handleNodeTemplateProperties(serviceTemplate, nodeTemplate, substitutionServiceTemplate,
2138             unifiedCompositionEntity, entityConsolidationDataList, computeTemplateConsolidationData,
2139             unifiedCompositionDataList, context);
2140     //Add enrich properties from openecomp node type as input to global and substitution ST
2141     handleNodeTypeProperties(substitutionServiceTemplate,
2142             entityConsolidationDataList, nodeTemplate, unifiedCompositionEntity,
2143             computeTemplateConsolidationData, context);
2144
2145   }
2146
2147   private void handleNodeTemplateProperties(ServiceTemplate serviceTemplate,
2148                                             NodeTemplate nodeTemplate,
2149                                             ServiceTemplate substitutionServiceTemplate,
2150                                             UnifiedCompositionEntity unifiedCompositionEntity,
2151                                             List<EntityConsolidationData>
2152                                                     entityConsolidationDataList,
2153                                             ComputeTemplateConsolidationData
2154                                                     computeTemplateConsolidationData,
2155                                             List<UnifiedCompositionData> unifiedCompositionDataList,
2156                                             TranslationContext context) {
2157     List<String> propertiesWithIdenticalVal =
2158             consolidationService.getPropertiesWithIdenticalVal(unifiedCompositionEntity);
2159
2160     for (EntityConsolidationData entityConsolidationData : entityConsolidationDataList) {
2161       String nodeTemplateId = entityConsolidationData.getNodeTemplateId();
2162       Optional<List<String>> indexVarProperties =
2163               context.getIndexVarProperties(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
2164                       nodeTemplateId);
2165       Map<String, Object> properties =
2166               DataModelUtil.getNodeTemplateProperties(serviceTemplate, nodeTemplateId);
2167       if (MapUtils.isEmpty(properties)) {
2168         continue;
2169       }
2170
2171       for (Map.Entry<String, Object> propertyEntry : properties.entrySet()) {
2172         NodeType nodeTypeWithFlatHierarchy =
2173                 HeatToToscaUtil.getNodeTypeWithFlatHierarchy(nodeTemplate.getType(), serviceTemplate,
2174                         context);
2175         PropertyDefinition propertyDefinition =
2176                 nodeTypeWithFlatHierarchy.getProperties().get(propertyEntry.getKey());
2177         String propertyType = propertyDefinition.getType();
2178
2179         if (propertiesWithIdenticalVal.contains(propertyEntry.getKey())) {
2180           String parameterId =
2181                   updateIdenticalProperty(nodeTemplateId, propertyEntry.getKey(), nodeTemplate,
2182                           unifiedCompositionEntity, unifiedCompositionDataList);
2183
2184           addInputParameter(
2185                   parameterId, propertyType,
2186                   propertyType.equals(PropertyType.LIST.getDisplayName()) ? propertyDefinition
2187                           .getEntry_schema() : null,
2188                   substitutionServiceTemplate);
2189         } else if (indexVarProperties.isPresent()
2190                 && indexVarProperties.get().contains(propertyEntry.getKey())) {
2191           //Handle index property
2192           handleIndexVarProperty(propertyEntry.getKey(), propertyEntry.getValue(), nodeTemplate);
2193         } else {
2194           Optional<String> parameterId =
2195                   updateProperty(serviceTemplate, nodeTemplateId, nodeTemplate, propertyEntry,
2196                           unifiedCompositionEntity, computeTemplateConsolidationData, null,
2197                           unifiedCompositionDataList,
2198                           context);
2199           parameterId.ifPresent(
2200                   parameterIdValue -> addPropertyInputParameter(propertyType,
2201                           substitutionServiceTemplate,
2202                           propertyDefinition.getEntry_schema(), parameterIdValue));
2203         }
2204       }
2205     }
2206   }
2207
2208   private void handleIndexVarProperty(String propertyKey, Object propertyValue,
2209                                       NodeTemplate nodeTemplate) {
2210     //Retain properties translated from %index% value in heat
2211     nodeTemplate.getProperties().put(propertyKey, propertyValue);
2212   }
2213
2214   private void handleSubInterfaceServiceTemplateFilterProperty(NodeTemplate nodeTemplate,
2215                                                                String propertyKey,
2216                                                                Object propertyValue,
2217                                                                ServiceTemplate serviceTemplate,
2218                                                                ServiceTemplate substitutionServiceTemplate) {
2219     //Retain service_template_filter (Can be present in a sub-interface resource-def)
2220     nodeTemplate.getProperties().put(propertyKey, propertyValue);
2221     Object serviceTemplateFilterProperty =
2222             nodeTemplate.getProperties().get(ToscaConstants.SERVICE_TEMPLATE_FILTER_PROPERTY_NAME);
2223     if (!(serviceTemplateFilterProperty instanceof Map)) {
2224       return;
2225     }
2226     Map<String, Object> serviceTemplatePropertyMap = (Map<String, Object>)
2227             serviceTemplateFilterProperty;
2228     Object countPropertyVal = serviceTemplatePropertyMap.get(ToscaConstants.COUNT_PROPERTY_NAME);
2229     //Check if the value of the count property is a tosca function
2230     if (!isPropertyContainsToscaFunction(countPropertyVal)) {
2231       return;
2232     }
2233     Map<String, Object> countPropertyValMap = (Map<String, Object>) countPropertyVal;
2234     //If the value is in the form of get_input add an input parameter in current service
2235     // template
2236     if (countPropertyValMap.keySet().contains(ToscaFunctions.GET_INPUT.getDisplayName())) {
2237       String countPropertyInputName = countPropertyValMap.get(ToscaFunctions.GET_INPUT
2238               .getDisplayName()).toString();
2239       //Get the input parameter definition from top level where the resource group was present
2240       ParameterDefinitionExt parameterDefinition = (ParameterDefinitionExt)
2241               DataModelUtil.getInputParameters(serviceTemplate).get(countPropertyInputName);
2242       if (Objects.nonNull(parameterDefinition)) {
2243         //Remove annotations if any for the nested service template
2244         parameterDefinition.setAnnotations(null);
2245         DataModelUtil.getInputParameters(substitutionServiceTemplate)
2246                 .put(countPropertyInputName, parameterDefinition);
2247         if (Objects.nonNull(countPropertyInputName)) {
2248           //Remove the input from top level
2249           DataModelUtil.getInputParameters(serviceTemplate).remove(countPropertyInputName);
2250         }
2251       }
2252     }
2253   }
2254
2255   private void handleNodeTypeProperties(ServiceTemplate substitutionServiceTemplate,
2256                                         List<EntityConsolidationData> entityConsolidationDataList,
2257                                         NodeTemplate nodeTemplate,
2258                                         UnifiedCompositionEntity compositionEntity,
2259                                         ComputeTemplateConsolidationData
2260                                                 computeTemplateConsolidationData,
2261                                         TranslationContext context) {
2262     ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
2263     Optional<NodeType> enrichNodeType;
2264     List<String> enrichProperties;
2265
2266     if (compositionEntity.equals(UnifiedCompositionEntity.PORT)) {
2267       enrichNodeType =
2268               toscaAnalyzerService.fetchNodeType(ToscaNodeType.NETWORK_PORT,
2269                       context.getGlobalServiceTemplates().values());
2270       enrichProperties = TranslationContext.getEnrichPortResourceProperties();
2271       if (!enrichNodeType.isPresent() || Objects.isNull(enrichProperties)) {
2272         return;
2273       }
2274     } else {
2275       return;
2276     }
2277
2278     Map<String, Object> nodeTemplateProperties = nodeTemplate.getProperties();
2279     Map<String, PropertyDefinition> enrichNodeTypeProperties = enrichNodeType.get().getProperties();
2280     if (Objects.nonNull(enrichNodeTypeProperties)) {
2281       for (String enrichPropertyName : enrichProperties) {
2282         handleEntityConsolidationDataNodeTypeProperties(
2283                 enrichPropertyName, substitutionServiceTemplate,
2284                 enrichNodeType.get(), nodeTemplate, compositionEntity, computeTemplateConsolidationData,
2285                 entityConsolidationDataList, nodeTemplateProperties, context);
2286       }
2287     }
2288   }
2289
2290   private void handleEntityConsolidationDataNodeTypeProperties(String enrichPropertyName,
2291                                                                ServiceTemplate substitutionServiceTemplate,
2292                                                                NodeType enrichNodeType,
2293                                                                NodeTemplate nodeTemplate,
2294                                                                UnifiedCompositionEntity compositionEntity,
2295                                                                ComputeTemplateConsolidationData computeTemplateConsolidationData,
2296                                                                List<EntityConsolidationData> entityConsolidationDataList,
2297                                                                Map<String, Object> nodeTemplateProperties,
2298                                                                TranslationContext context) {
2299
2300     String propertyType;
2301
2302     for (EntityConsolidationData entityConsolidationData : entityConsolidationDataList) {
2303       String nodeTemplateId = entityConsolidationData.getNodeTemplateId();
2304
2305       String inputParamId =
2306               getParameterId(nodeTemplateId, nodeTemplate, enrichPropertyName,
2307                       compositionEntity, computeTemplateConsolidationData, null);
2308       Map<String, String> propertyValMap = new HashMap<>();
2309
2310       context
2311               .addNewPropertyIdToNodeTemplate(
2312                       ToscaUtil.getServiceTemplateFileName(substitutionServiceTemplate),
2313                       inputParamId, nodeTemplateProperties.get(enrichPropertyName));
2314
2315       if (nodeTemplateProperties.containsKey(enrichPropertyName)) {
2316         handleExistingEnrichedProperty(enrichPropertyName, nodeTemplateProperties, inputParamId);
2317       } else {
2318         propertyValMap.put(ToscaFunctions.GET_INPUT.getDisplayName(), inputParamId);
2319         nodeTemplate.getProperties().put(enrichPropertyName, propertyValMap);
2320       }
2321       propertyType =
2322               enrichNodeType.getProperties().get(enrichPropertyName).getType();
2323
2324       addPropertyInputParameter(propertyType, substitutionServiceTemplate, enrichNodeType
2325                       .getProperties().get(enrichPropertyName).getEntry_schema(),
2326               inputParamId);
2327
2328     }
2329   }
2330
2331   private void handleExistingEnrichedProperty(String enrichPropertyName,
2332                                               Map<String, Object> nodeTemplateProperties,
2333                                               String inputParamId) {
2334     Object enrichedProperty = nodeTemplateProperties.get(enrichPropertyName);
2335     if (!isPropertyContainsToscaFunction(enrichedProperty)) {
2336       Map<String, Object> propertyWithGetInput = new HashMap<>();
2337       propertyWithGetInput.put(ToscaFunctions.GET_INPUT.getDisplayName(), inputParamId);
2338       nodeTemplateProperties.put(enrichPropertyName, propertyWithGetInput);
2339     }
2340   }
2341
2342
2343   private boolean isPropertyContainsToscaFunction(Object propertyValue) {
2344     ToscaFunctions[] values = ToscaFunctions.values();
2345     for (ToscaFunctions toscaFunction : values) {
2346       if (isIncludeToscaFunc(propertyValue, toscaFunction)) {
2347         return true;
2348       }
2349     }
2350
2351     return false;
2352   }
2353
2354
2355   private void addPropertyInputParameter(String propertyType,
2356                                          ServiceTemplate substitutionServiceTemplate,
2357                                          EntrySchema entrySchema, String parameterId) {
2358     if (Objects.isNull(propertyType)) {
2359       return;
2360     }
2361     if (isParameterBelongsToEnrichedPortProperties(parameterId)) {
2362       addInputParameter(parameterId,
2363               propertyType,
2364               propertyType.equals(PropertyType.LIST.getDisplayName()) ? entrySchema : null,
2365               substitutionServiceTemplate);
2366     } else if (isPropertySimpleType(propertyType)) {
2367       addInputParameter(parameterId, PropertyType.LIST.getDisplayName(),
2368               DataModelUtil.createEntrySchema(propertyType.toLowerCase(), null, null),
2369               substitutionServiceTemplate);
2370
2371     } else if (propertyType.equals(PropertyTypeExt.JSON.getDisplayName()) ||
2372             (Objects.nonNull(entrySchema) && isPropertySimpleType(entrySchema.getType()))) {
2373       addInputParameter(parameterId, PropertyType.LIST.getDisplayName(),
2374               DataModelUtil.createEntrySchema(PropertyTypeExt.JSON.getDisplayName(), null, null),
2375               substitutionServiceTemplate);
2376     } else {
2377       addInputParameter(parameterId, analyzeParameterType(propertyType), DataModelUtil
2378                       .createEntrySchema(analyzeEntrySchemaType(propertyType, entrySchema), null, null),
2379               substitutionServiceTemplate);
2380     }
2381   }
2382
2383   private boolean isParameterBelongsToEnrichedPortProperties(String parameterId) {
2384     List enrichPortResourceProperties = TranslationContext.getEnrichPortResourceProperties();
2385
2386     for (int i = 0; i < enrichPortResourceProperties.size(); i++) {
2387       if (parameterId.contains((CharSequence) enrichPortResourceProperties.get(i))) {
2388         return true;
2389       }
2390     }
2391
2392     return false;
2393   }
2394
2395   private boolean isPropertySimpleType(String propertyType) {
2396     return !Objects.isNull(propertyType)
2397             && (PropertyType.getSimplePropertyTypes().contains(propertyType.toLowerCase()));
2398   }
2399
2400   private String analyzeParameterType(String propertyType) {
2401     return propertyType.equalsIgnoreCase(PropertyType.LIST.getDisplayName()) ? PropertyType.LIST
2402             .getDisplayName() : propertyType;
2403   }
2404
2405   private String analyzeEntrySchemaType(String propertyType, EntrySchema entrySchema) {
2406     return propertyType.equalsIgnoreCase(PropertyType.LIST.getDisplayName()) && entrySchema != null ?
2407             entrySchema.getType() : null;
2408   }
2409
2410   private void handleConsolidationEntitiesRequirementConnectivity(NodeTemplate nodeTemplate,
2411                                                                   ServiceTemplate serviceTemplate,
2412                                                                   TranslationContext context) {
2413     List<Map<String, RequirementAssignment>> nodeTemplateRequirements = DataModelUtil
2414             .getNodeTemplateRequirementList(nodeTemplate);
2415     if (CollectionUtils.isEmpty(nodeTemplateRequirements)) {
2416       return;
2417     }
2418
2419     for (Map<String, RequirementAssignment> requirement : nodeTemplateRequirements) {
2420       for (Map.Entry<String, RequirementAssignment> entry : requirement.entrySet()) {
2421         RequirementAssignment requirementAssignment = entry.getValue();
2422         String requirementNode = requirementAssignment.getNode();
2423         String unifiedNodeTemplateId =
2424                 context.getUnifiedSubstitutionNodeTemplateId(serviceTemplate,
2425                         requirementNode);
2426         if (unifiedNodeTemplateId != null) {
2427           //Update the node id in the requirement
2428           requirementAssignment.setNode(unifiedNodeTemplateId);
2429         }
2430       }
2431     }
2432     nodeTemplate.setRequirements(nodeTemplateRequirements);
2433   }
2434
2435   /**
2436    * Update the node references in the volume relationship templates.
2437    *
2438    * @param serviceTemplate the service template
2439    * @param context         the context
2440    */
2441   private void updateVolumeRelationshipTemplate(ServiceTemplate serviceTemplate,
2442                                                 String relationshipId,
2443                                                 TranslationContext context) {
2444     Map<String, RelationshipTemplate> relationshipTemplates = DataModelUtil
2445             .getRelationshipTemplates(serviceTemplate);
2446     if (relationshipTemplates != null) {
2447       RelationshipTemplate relationshipTemplate = relationshipTemplates.get(relationshipId);
2448       if (relationshipTemplate != null) {
2449         String relationshipTemplateType = relationshipTemplate.getType();
2450         if (relationshipTemplateType.equals(ToscaRelationshipType.CINDER_VOLUME_ATTACHES_TO)) {
2451           handleCinderVolumeAttachmentRelationshipTemplate(serviceTemplate,
2452                   relationshipTemplate, context);
2453         }
2454       }
2455     }
2456   }
2457
2458
2459   private void handleCinderVolumeAttachmentRelationshipTemplate(ServiceTemplate
2460                                                                         substitutionServiceTemplate,
2461                                                                 RelationshipTemplate
2462                                                                         relationshipTemplate,
2463                                                                 TranslationContext context) {
2464     Map<String, Object> properties = relationshipTemplate.getProperties();
2465     properties.computeIfPresent(HeatConstants.INSTANCE_UUID_PROPERTY_NAME, (key, value) ->
2466             context.getUnifiedAbstractNodeTemplateId(substitutionServiceTemplate,
2467                     (String) value));
2468   }
2469
2470   private String updateIdenticalProperty(String nodeTemplateId, String propertyId,
2471                                          NodeTemplate nodeTemplate,
2472                                          UnifiedCompositionEntity unifiedCompositionEntity,
2473                                          List<UnifiedCompositionData> unifiedCompositionDataList) {
2474
2475     String inputParamId = null;
2476     Map<String, Object> propertyVal = new HashMap<>();
2477
2478     switch (unifiedCompositionEntity) {
2479       case COMPUTE:
2480         inputParamId = COMPUTE_IDENTICAL_VALUE_PROPERTY_PREFIX + propertyId
2481                 + COMPUTE_IDENTICAL_VALUE_PROPERTY_SUFFIX;
2482         propertyVal.put(ToscaFunctions.GET_INPUT.getDisplayName(), inputParamId);
2483         nodeTemplate.getProperties().put(propertyId, propertyVal);
2484         break;
2485       case PORT:
2486         String portType = ConsolidationDataUtil.getPortType(nodeTemplateId);
2487         ComputeTemplateConsolidationData computeTemplateConsolidationData =
2488                 getConnectedComputeConsolidationData(unifiedCompositionDataList, nodeTemplateId);
2489         inputParamId = getInputParamIdForPort(nodeTemplateId, propertyId, portType, computeTemplateConsolidationData);
2490         propertyVal.put(ToscaFunctions.GET_INPUT.getDisplayName(), inputParamId);
2491         nodeTemplate.getProperties().put(propertyId, propertyVal);
2492         break;
2493       default:
2494         break;
2495     }
2496     return inputParamId;
2497   }
2498
2499   private String getInputParamIdForPort(String nodeTemplateId, String propertyId, String portType,
2500                                         ComputeTemplateConsolidationData computeTemplateConsolidationData) {
2501     String inputParamId;
2502     if (Objects.isNull(computeTemplateConsolidationData)
2503             || computeTemplateConsolidationData.getPorts().get(portType).size() > 1) {
2504       inputParamId =
2505               UnifiedCompositionEntity.PORT.getDisplayName().toLowerCase() + "_" + nodeTemplateId + "_" +
2506                       propertyId;
2507
2508     } else {
2509       inputParamId =
2510               UnifiedCompositionEntity.PORT.getDisplayName().toLowerCase() + "_" + portType + "_"
2511                       + propertyId;
2512     }
2513     return inputParamId;
2514   }
2515
2516   private void addInputParameter(String parameterId,
2517                                  String parameterType,
2518                                  EntrySchema entrySchema,
2519                                  ServiceTemplate serviceTemplate) {
2520
2521     ParameterDefinition parameterDefinition = DataModelUtil.createParameterDefinition
2522             (parameterType, null, null,
2523                     true, null, null,
2524                     entrySchema, null);
2525
2526
2527     DataModelUtil
2528             .addInputParameterToTopologyTemplate(serviceTemplate, parameterId, parameterDefinition);
2529   }
2530
2531   // Return the input parameter Id which is used in the new property value if there is one
2532   private Optional<String> updateProperty(
2533           ServiceTemplate serviceTemplate,
2534           String nodeTemplateId, NodeTemplate nodeTemplate,
2535           Map.Entry<String, Object> propertyEntry,
2536           UnifiedCompositionEntity compositionEntity,
2537           ComputeTemplateConsolidationData computeTemplateConsolidationData,
2538           PortTemplateConsolidationData portTemplateConsolidationData,
2539           List<UnifiedCompositionData> unifiedCompositionDataList,
2540           TranslationContext context) {
2541
2542     if (handleGetAttrFromConsolidationNodes(serviceTemplate, nodeTemplateId, nodeTemplate,
2543             propertyEntry, unifiedCompositionDataList, context)) {
2544       return Optional.empty();
2545     }
2546
2547
2548     String inputParamId =
2549             getParameterId(nodeTemplateId, nodeTemplate, propertyEntry.getKey(), compositionEntity,
2550                     computeTemplateConsolidationData, portTemplateConsolidationData);
2551     Map<String, List<String>> propertyVal = getPropertyValueInputParam(inputParamId);
2552     nodeTemplate.getProperties().put(propertyEntry.getKey(), propertyVal);
2553     return Optional.of(inputParamId);
2554   }
2555
2556   private Map<String, List<String>> getPropertyValueInputParam(String inputParamId) {
2557     Map<String, List<String>> propertyVal = new HashMap<>();
2558     List<String> getInputFuncParams = new ArrayList<>();
2559     getInputFuncParams.add(inputParamId);
2560     getInputFuncParams.add(ToscaConstants.INDEX_VALUE_PROPERTY_NAME);
2561     propertyVal.put(ToscaFunctions.GET_INPUT.getDisplayName(), getInputFuncParams);
2562     return propertyVal;
2563   }
2564
2565   private boolean handleGetAttrFromConsolidationNodes(
2566           ServiceTemplate serviceTemplate,
2567           String nodeTemplateId, NodeTemplate nodeTemplate,
2568           Map.Entry<String, Object> propertyEntry,
2569           List<UnifiedCompositionData> unifiedCompositionDataList,
2570           TranslationContext context) {
2571     Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType =
2572             getAllConsolidationNodeTemplateIdAndType(unifiedCompositionDataList);
2573
2574     Set<String> consolidationNodeTemplateIds = consolidationNodeTemplateIdAndType.keySet();
2575     Map<String, String> entityIdToType = ConsolidationService.getConsolidationEntityIdToType(
2576             serviceTemplate, context.getConsolidationData());
2577     boolean includeGetAttrFromConsolidationNodes = false;
2578     boolean includeGetAttrFromOutsideNodes = false;
2579     boolean isGetAttrFromConsolidationIsFromSameType = false;
2580     List<List<Object>> getAttrFunctionList = extractGetAttrFunction(propertyEntry.getValue());
2581     for (List<Object> getAttrFunc : getAttrFunctionList) {
2582       String getAttrNodeId = (String) getAttrFunc.get(0);
2583       if (consolidationNodeTemplateIds.contains(getAttrNodeId)) {
2584         includeGetAttrFromConsolidationNodes = true;
2585         if (isGetAttrNodeTemplateFromSameType(nodeTemplateId, getAttrNodeId, entityIdToType)) {
2586           isGetAttrFromConsolidationIsFromSameType = true;
2587         }
2588       } else {
2589         includeGetAttrFromOutsideNodes = true;
2590       }
2591     }
2592     if ((includeGetAttrFromConsolidationNodes && includeGetAttrFromOutsideNodes)
2593             ||
2594             (includeGetAttrFromConsolidationNodes && isIncludeToscaFunc(propertyEntry.getValue(),
2595                     ToscaFunctions.GET_INPUT))) {
2596       //This case is currently not supported - this property will be ignored
2597       return true;
2598     } else if (includeGetAttrFromConsolidationNodes && !isGetAttrFromConsolidationIsFromSameType) {
2599       Object clonedPropertyValue = getClonedPropertyValue(propertyEntry);
2600       List<List<Object>> clonedGetAttrFuncList = extractGetAttrFunction(clonedPropertyValue);
2601       for (List<Object> getAttrFunc : clonedGetAttrFuncList) {
2602         String targetNodeTemplateId = (String) getAttrFunc.get(0);
2603         if (consolidationNodeTemplateIds.contains(targetNodeTemplateId)) {
2604           updatePropertyGetAttrFunc(serviceTemplate, unifiedCompositionDataList,
2605                   consolidationNodeTemplateIdAndType, targetNodeTemplateId, getAttrFunc, context);
2606         }
2607       }
2608       nodeTemplate.getProperties().put(propertyEntry.getKey(), clonedPropertyValue);
2609       return true;
2610     }
2611     return false;
2612   }
2613
2614   private boolean isGetAttrNodeTemplateFromSameType(String sourceNodeTemplateId,
2615                                                     String targetNodeTemplateId,
2616                                                     Map<String, String> nodeTemplateIdToType) {
2617
2618     if (Objects.isNull(nodeTemplateIdToType.get(sourceNodeTemplateId))
2619             || Objects.isNull(nodeTemplateIdToType.get(targetNodeTemplateId))) {
2620       return false;
2621     }
2622
2623     return nodeTemplateIdToType.get(sourceNodeTemplateId).equals(nodeTemplateIdToType
2624             .get(targetNodeTemplateId));
2625   }
2626
2627   private void updatePropertyGetAttrFunc(
2628           ServiceTemplate serviceTemplate,
2629           List<UnifiedCompositionData> unifiedCompositionDataList,
2630           Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType,
2631           String targetNodeTemplateId,
2632           List<Object> getAttrFunc, TranslationContext context) {
2633     UnifiedCompositionEntity targetCompositionEntity =
2634             consolidationNodeTemplateIdAndType.get(targetNodeTemplateId);
2635     String targetNewNodeTemplateId =
2636             getNewNodeTemplateId(serviceTemplate, unifiedCompositionDataList, targetNodeTemplateId,
2637                     targetCompositionEntity, context);
2638     getAttrFunc.set(0, targetNewNodeTemplateId);
2639   }
2640
2641   private String getNewNodeTemplateId(ServiceTemplate serviceTemplate,
2642                                       List<UnifiedCompositionData> unifiedCompositionDataList,
2643                                       String nodeTemplateId,
2644                                       UnifiedCompositionEntity compositionEntity,
2645                                       TranslationContext context) {
2646     String newNodeTemplateId = nodeTemplateId;
2647     String nodeTemplateIdGeneratorImpl = unifiedSubstitutionNodeTemplateIdGeneratorImplMap.get(compositionEntity);
2648     UnifiedSubstitutionNodeTemplateIdGenerator nodeTemplateIdGenerator =
2649             CommonMethods.newInstance(nodeTemplateIdGeneratorImpl, UnifiedSubstitutionNodeTemplateIdGenerator.class);
2650     UnifiedCompositionTo unifiedCompositionTo = new UnifiedCompositionTo(serviceTemplate, null,
2651             unifiedCompositionDataList, context);
2652     Optional<String> generatedNodeTemplateId = nodeTemplateIdGenerator.generate(unifiedCompositionTo, nodeTemplateId);
2653     if (generatedNodeTemplateId.isPresent()) {
2654       newNodeTemplateId = generatedNodeTemplateId.get();
2655     }
2656     return newNodeTemplateId;
2657   }
2658
2659   private String getNewNodeTemplateId(String origNodeTemplateId,
2660                                       String serviceTemplateFileName,
2661                                       ServiceTemplate serviceTemplate,
2662                                       TranslationContext context) {
2663     ConsolidationData consolidationData = context.getConsolidationData();
2664
2665     if (isIdIsOfExpectedType(origNodeTemplateId, UnifiedCompositionEntity.PORT,
2666             serviceTemplateFileName,
2667             context)) {
2668       return handleIdOfPort(origNodeTemplateId, serviceTemplateFileName, consolidationData);
2669     } else if (isIdIsOfExpectedType(origNodeTemplateId, COMPUTE,
2670             serviceTemplateFileName, context)) {
2671       NodeTemplate nodeTemplate =
2672               getComputeNodeTemplate(origNodeTemplateId, serviceTemplate, context);
2673       return getComputeTypeSuffix(nodeTemplate.getType());
2674     }
2675
2676     return null;
2677   }
2678
2679   private Object getClonedPropertyValue(Map.Entry<String, Object> propertyEntry) {
2680     if (propertyEntry.getValue() instanceof Map) {
2681       return getClonedObject(propertyEntry.getValue(), Map.class);
2682     } else if (propertyEntry.getValue() instanceof List) {
2683       return getClonedObject(propertyEntry.getValue(), List.class);
2684     }
2685     return propertyEntry.getValue();
2686   }
2687
2688
2689   private String getParameterId(String nodeTemplateId, NodeTemplate nodeTemplate, String propertyId,
2690                                 UnifiedCompositionEntity unifiedCompositionEntity,
2691                                 ComputeTemplateConsolidationData
2692                                         computeTemplateConsolidationData,
2693                                 PortTemplateConsolidationData portTemplateConsolidationData) {
2694     String paramterId = propertyId;
2695     switch (unifiedCompositionEntity) {
2696       case COMPUTE:
2697         paramterId = COMPUTE.getDisplayName().toLowerCase() + "_"
2698                 + getComputeTypeSuffix(nodeTemplate.getType()) + "_" + propertyId;
2699         break;
2700       case PORT:
2701         String portType = ConsolidationDataUtil.getPortType(nodeTemplateId);
2702         if (Objects.isNull(computeTemplateConsolidationData)
2703                 || computeTemplateConsolidationData.getPorts().get(portType).size() > 1) {
2704           paramterId = UnifiedCompositionEntity.PORT.getDisplayName().toLowerCase() + "_"
2705                   + nodeTemplateId + "_" + propertyId;
2706         } else {
2707           paramterId = UnifiedCompositionEntity.PORT.getDisplayName().toLowerCase() + "_" + portType + "_"
2708                   + propertyId;
2709         }
2710         break;
2711       case SUB_INTERFACE:
2712         String subInterfaceType = getSubInterfaceTypeSuffix(nodeTemplate.getType());
2713         if (Objects.isNull(portTemplateConsolidationData)
2714                 || portTemplateConsolidationData.isSubInterfaceNodeTemplateIdParameter(nodeTemplate.getType())) {
2715           paramterId = UnifiedCompositionEntity.SUB_INTERFACE.getDisplayName().toLowerCase() + "_"
2716                   + nodeTemplateId + "_" + propertyId;
2717         } else {
2718           paramterId = UnifiedCompositionEntity.SUB_INTERFACE.getDisplayName().toLowerCase() + "_"
2719                   + subInterfaceType + "_" + propertyId;
2720         }
2721         break;
2722       default:
2723         break;
2724     }
2725     return paramterId;
2726   }
2727
2728   private void removeConnectivityOut(EntityConsolidationData entityConsolidationData,
2729                                      NodeTemplate nodeTemplate) {
2730     if (MapUtils.isEmpty(entityConsolidationData.getNodesConnectedOut())) {
2731       return;
2732     }
2733
2734     for (List<RequirementAssignmentData> requirementAssignmentDataList : entityConsolidationData
2735             .getNodesConnectedOut().values()) {
2736       for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList) {
2737         DataModelUtil.removeRequirementsAssignment(nodeTemplate.getRequirements(),
2738                 requirementAssignmentData.getRequirementId());
2739       }
2740       if (nodeTemplate.getRequirements().isEmpty()) {
2741         nodeTemplate.setRequirements(null);
2742       }
2743     }
2744   }
2745
2746   private void removeVolumeConnectivity(
2747           ComputeTemplateConsolidationData computeTemplateConsolidationData,
2748           NodeTemplate computeNodeTemplate) {
2749     if (MapUtils.isEmpty(computeTemplateConsolidationData.getVolumes())) {
2750       return;
2751     }
2752     Collection<List<RequirementAssignmentData>> volumeCollection =
2753             computeTemplateConsolidationData.getVolumes().values();
2754     for (List<RequirementAssignmentData> requirementAssignmentDataList : volumeCollection) {
2755       for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList) {
2756         DataModelUtil.removeRequirementsAssignment(computeNodeTemplate.getRequirements(),
2757                 requirementAssignmentData.getRequirementId());
2758       }
2759     }
2760     if (computeNodeTemplate.getRequirements().isEmpty()) {
2761       computeNodeTemplate.setRequirements(null);
2762     }
2763   }
2764
2765   private void createIndexInputParameter(ServiceTemplate substitutionServiceTemplate) {
2766     ParameterDefinition indexParameterDefinition =
2767             DataModelUtil.createParameterDefinition(PropertyType.INTEGER.getDisplayName(),
2768                     "Index value of this substitution service template runtime instance", null,
2769                     false, createIndexValueConstraint(), null, null, 0);
2770     DataModelUtil.addInputParameterToTopologyTemplate(substitutionServiceTemplate,
2771             ToscaConstants.INDEX_VALUE_PROPERTY_NAME, indexParameterDefinition);
2772   }
2773
2774
2775   private List<Constraint> createIndexValueConstraint() {
2776     List<Constraint> constraints;
2777     constraints = new ArrayList<>();
2778     Constraint constraint = new Constraint();
2779     constraint.setGreater_or_equal(0);
2780     constraints.add(constraint);
2781     return constraints;
2782   }
2783
2784   private Optional<UnifiedComposition> getUnifiedCompositionInstance(UnifiedCompositionMode mode) {
2785     String unifiedCompositionImplClassName =
2786             unifiedCompositionImplMap.get(mode.name()).getImplementationClass();
2787     if (StringUtils.isEmpty(unifiedCompositionImplClassName)) {
2788       return Optional.empty();
2789     }
2790     return Optional
2791             .of(CommonMethods.newInstance(unifiedCompositionImplClassName, UnifiedComposition.class));
2792   }
2793
2794   private Optional<Map<String, Object>> createAbstractSubstitutionProperties(
2795           ServiceTemplate serviceTemplate,
2796           Map<String, ParameterDefinition> substitutionTemplateInputs,
2797           List<UnifiedCompositionData> unifiedCompositionDataList,
2798           TranslationContext context) {
2799     Map<String, Object> abstractSubstituteProperties = new LinkedHashMap<>();
2800     //Since all the computes have the same type fetching the type from the first entry
2801     NodeTemplate firstComputeNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
2802             unifiedCompositionDataList.get(0)
2803                     .getComputeTemplateConsolidationData().getNodeTemplateId());
2804     String computeType = getComputeTypeSuffix(firstComputeNodeTemplate.getType());
2805     for (Map.Entry<String, ParameterDefinition> input : substitutionTemplateInputs.entrySet()) {
2806       String substitutionTemplateInputName = input.getKey();
2807       ParameterDefinition inputParameterDefinition = input.getValue();
2808       String inputType = inputParameterDefinition.getType();
2809       UnifiedCompositionEntity inputUnifiedCompositionEntity =
2810               getInputCompositionEntity(substitutionTemplateInputName);
2811
2812       if (!inputType.equalsIgnoreCase(PropertyType.LIST.getDisplayName())) {
2813         if (isIdenticalValueProperty(
2814                 substitutionTemplateInputName, inputUnifiedCompositionEntity)) {
2815           //Handle identical value properties
2816           Optional<String> identicalValuePropertyName =
2817                   getIdenticalValuePropertyName(substitutionTemplateInputName,
2818                           inputUnifiedCompositionEntity);
2819
2820           identicalValuePropertyName.ifPresent(propertyName -> updateIdenticalPropertyValue(propertyName,
2821                   substitutionTemplateInputName, inputUnifiedCompositionEntity,
2822                   unifiedCompositionDataList.get(0), serviceTemplate, abstractSubstituteProperties,
2823                   context));
2824         }
2825         continue;
2826       }
2827
2828       //Check if the input is of type compute or port
2829       List<Object> abstractPropertyValue = new ArrayList<>();
2830       switch (inputUnifiedCompositionEntity) {
2831         case COMPUTE:
2832           createAbstractComputeProperties(unifiedCompositionDataList,
2833                   substitutionTemplateInputName, serviceTemplate, abstractPropertyValue);
2834           break;
2835         case PORT:
2836           createAbstractPortProperties(unifiedCompositionDataList, substitutionTemplateInputName,
2837                   computeType, serviceTemplate, abstractPropertyValue);
2838           break;
2839         case SUB_INTERFACE:
2840           createAbstractSubInterfaceProperties(unifiedCompositionDataList,
2841                   substitutionTemplateInputName, serviceTemplate, abstractPropertyValue);
2842           break;
2843         default:
2844           break;
2845       }
2846       //Add the property only if it has at least one non-null value
2847       if (abstractPropertyValue.stream().anyMatch(Objects::nonNull)) {
2848         updateAbstractPropertyValue(substitutionTemplateInputName, inputParameterDefinition,
2849                 abstractPropertyValue, abstractSubstituteProperties);
2850       }
2851     }
2852     return Optional.ofNullable(abstractSubstituteProperties);
2853   }
2854
2855   private void createAbstractComputeProperties(List<UnifiedCompositionData>
2856                                                        unifiedCompositionDataList,
2857                                                String substitutionTemplateInputName,
2858                                                ServiceTemplate serviceTemplate,
2859                                                List<Object> abstractPropertyValue) {
2860     for (UnifiedCompositionData compositionData : unifiedCompositionDataList) {
2861       ComputeTemplateConsolidationData computeTemplateConsolidationData =
2862               compositionData.getComputeTemplateConsolidationData();
2863       Object propertyValue = getComputePropertyValue(substitutionTemplateInputName,
2864               serviceTemplate, computeTemplateConsolidationData);
2865       if (!(propertyValue instanceof Optional)) {
2866         abstractPropertyValue.add(propertyValue);
2867       }
2868     }
2869   }
2870
2871   private void createAbstractPortProperties(List<UnifiedCompositionData>
2872                                                     unifiedCompositionDataList,
2873                                             String substitutionTemplateInputName,
2874                                             String computeType,
2875                                             ServiceTemplate serviceTemplate,
2876                                             List<Object> abstractPropertyValue) {
2877     for (UnifiedCompositionData compositionData : unifiedCompositionDataList) {
2878       List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
2879               getPortTemplateConsolidationDataList(compositionData);
2880       //Get the input type for this input whether it is of type
2881       // port_<port_node_template_id>_<property_name> or port_<port_type>_<property_name>
2882       PropertyInputType portInputType = getPortInputType(substitutionTemplateInputName,
2883               compositionData);
2884       for (PortTemplateConsolidationData portTemplateConsolidationData :
2885               portTemplateConsolidationDataList) {
2886         //Get the port property value
2887         String portNodeTemplateId = portTemplateConsolidationData.getNodeTemplateId();
2888         Object propertyValue = getPortPropertyValue(substitutionTemplateInputName,
2889                 computeType, portInputType, serviceTemplate,
2890                 portNodeTemplateId);
2891         //If the value object is Optional.empty it implies that the property name was not
2892         // found in the input name
2893         if (!(propertyValue instanceof Optional)) {
2894           abstractPropertyValue.add(propertyValue);
2895         }
2896       }
2897     }
2898   }
2899
2900   private void createAbstractSubInterfaceProperties(List<UnifiedCompositionData>
2901                                                             unifiedCompositionDataList,
2902                                                     String substitutionTemplateInputName,
2903                                                     ServiceTemplate serviceTemplate,
2904                                                     List<Object> abstractPropertyValue) {
2905     for (UnifiedCompositionData compositionData : unifiedCompositionDataList) {
2906       List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
2907               getSubInterfaceTemplateConsolidationDataList(compositionData);
2908       //Get the input type for this input whether it is of type
2909       // subInterface_<subinterface_node_template_id>_<property_name> or
2910       // subInterface_<subinterface_type>_<property_name>
2911       PropertyInputType subInterfaceInputType =
2912               getSubInterfaceInputType(substitutionTemplateInputName, compositionData);
2913       for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData :
2914               subInterfaceTemplateConsolidationDataList) {
2915         //Get the subInterface property value
2916         String subInterfaceNodeTemplateId = subInterfaceTemplateConsolidationData
2917                 .getNodeTemplateId();
2918         NodeTemplate subInterfaceNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
2919                 subInterfaceNodeTemplateId);
2920         String subInterfaceType = getSubInterfaceTypeSuffix(subInterfaceNodeTemplate
2921                 .getType());
2922         Object propertyValue = getSubInterfacePropertyValue(substitutionTemplateInputName,
2923                 subInterfaceType, subInterfaceInputType, serviceTemplate,
2924                 subInterfaceNodeTemplateId);
2925         //If the value object is Optional.empty it implies that the property name was not
2926         // found in the input name
2927         if (!(propertyValue instanceof Optional)) {
2928           abstractPropertyValue.add(propertyValue);
2929         }
2930       }
2931     }
2932   }
2933
2934   private void updateAbstractPropertyValue(String substitutionTemplateInputName,
2935                                            ParameterDefinition parameterDefinition,
2936                                            List<Object> abstractPropertyValue,
2937                                            Map<String, Object> abstractSubstituteProperties) {
2938     if (abstractPropertyValue.size() > 1) {
2939       abstractSubstituteProperties.put(substitutionTemplateInputName, abstractPropertyValue);
2940     } else {
2941       Object propertyValue = abstractPropertyValue.get(0);
2942       String entrySchemaType = parameterDefinition.getEntry_schema().getType();
2943       if (PropertyType.getSimplePropertyTypes().contains(entrySchemaType.toLowerCase())
2944               || entrySchemaType.equals(PropertyTypeExt.JSON.getDisplayName())) {
2945         abstractSubstituteProperties.put(substitutionTemplateInputName, abstractPropertyValue);
2946       } else {
2947         abstractSubstituteProperties.put(substitutionTemplateInputName, propertyValue);
2948       }
2949     }
2950   }
2951
2952   private void updateIdenticalPropertyValue(String identicalValuePropertyName,
2953                                             String substitutionTemplateInputName,
2954                                             UnifiedCompositionEntity entity,
2955                                             UnifiedCompositionData unifiedCompositionData,
2956                                             ServiceTemplate serviceTemplate,
2957                                             Map<String, Object> abstractSubstituteProperties,
2958                                             TranslationContext context) {
2959     Optional<Object> identicalPropertyValueByType =
2960             getIdenticalPropertyValueByType(identicalValuePropertyName, substitutionTemplateInputName,
2961                     entity, unifiedCompositionData, serviceTemplate, context);
2962
2963     if (identicalPropertyValueByType.isPresent()) {
2964       abstractSubstituteProperties
2965               .put(substitutionTemplateInputName, identicalPropertyValueByType.get());
2966
2967     }
2968
2969
2970   }
2971
2972   private Optional<Object> getIdenticalPropertyValueByType(String identicalValuePropertyName,
2973                                                            String substitutionTemplateInputName,
2974                                                            UnifiedCompositionEntity entity,
2975                                                            UnifiedCompositionData
2976                                                                    unifiedCompositionData,
2977                                                            ServiceTemplate serviceTemplate,
2978                                                            TranslationContext context) {
2979
2980     ComputeTemplateConsolidationData computeTemplateConsolidationData =
2981             unifiedCompositionData.getComputeTemplateConsolidationData();
2982
2983     Optional<Object> identicalPropertyValue = Optional.empty();
2984     switch (entity) {
2985       case COMPUTE:
2986         identicalPropertyValue =
2987                 getIdenticalPropertyValue(identicalValuePropertyName, serviceTemplate,
2988                         computeTemplateConsolidationData, context);
2989         break;
2990       case OTHER:
2991         identicalPropertyValue =
2992                 getIdenticalPropertyValue(identicalValuePropertyName, serviceTemplate,
2993                         computeTemplateConsolidationData, context);
2994         break;
2995       case PORT:
2996         PropertyInputType portInputType = getPortInputType(substitutionTemplateInputName,
2997                                          unifiedCompositionData);
2998         Optional <PortTemplateConsolidationData>  portTemplateConsolidationData =
2999                 unifiedCompositionData.getPortTemplateConsolidationDataList()
3000                         .stream()
3001                         .filter(s -> substitutionTemplateInputName.
3002                                 contains(getPropertyInputPrefix(s.getNodeTemplateId(),
3003                                 ConsolidationDataUtil.getPortType(s.getNodeTemplateId()),
3004                                 portInputType, UnifiedCompositionEntity.PORT)))
3005                         .findFirst();
3006
3007         if(portTemplateConsolidationData.isPresent()) {
3008           return getIdenticalPropertyValue(identicalValuePropertyName, serviceTemplate,
3009                   portTemplateConsolidationData.get(), context);
3010         }
3011         break;
3012       default:
3013         break;
3014     }
3015     return identicalPropertyValue;
3016   }
3017
3018
3019   private PropertyInputType getPortInputType(String inputName,
3020                                              UnifiedCompositionData unifiedCompositionData) {
3021     String portInputPrefix = UnifiedCompositionEntity.PORT.getDisplayName().toLowerCase() + "_";
3022     ComputeTemplateConsolidationData computeTemplateConsolidationData = unifiedCompositionData
3023             .getComputeTemplateConsolidationData();
3024     List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
3025             getPortTemplateConsolidationDataList(unifiedCompositionData);
3026     //Scan the available port node template ids to check if the input is of the form
3027     // "port_<port_node_template_id>_<property_name>"
3028     if (portTemplateConsolidationDataList.stream().map(EntityConsolidationData::getNodeTemplateId)
3029             .map(portNodeTemplateId -> portInputPrefix + portNodeTemplateId).anyMatch(inputName::startsWith)) {
3030       return PropertyInputType.NODE_TEMPLATE_ID;
3031     }
3032     //Check whether the input is of the form "port_<port_type>_<property_name>"
3033     Set<String> portTypes = computeTemplateConsolidationData.getPorts().keySet();
3034     if (portTypes.stream().map(portType -> portInputPrefix + portType + "_").anyMatch(inputName::startsWith)) {
3035       return PropertyInputType.TYPE;
3036     }
3037     return PropertyInputType.OTHER;
3038   }
3039
3040   private PropertyInputType getSubInterfaceInputType(String inputName,
3041                                                      UnifiedCompositionData unifiedCompositionData) {
3042     String subInterfaceInputPrefix = UnifiedCompositionEntity.SUB_INTERFACE.getDisplayName().toLowerCase()
3043             + "_";
3044     List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
3045             getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
3046     //Scan the available port node template ids to check if the input is of the form
3047     // "subinterface_<subinterface_node_template_id>_<property_name>"
3048     if (subInterfaceTemplateConsolidationDataList.stream().map(EntityConsolidationData::getNodeTemplateId)
3049             .map(subInterfaceNodeTemplateId -> subInterfaceInputPrefix
3050                     + subInterfaceNodeTemplateId)
3051             .anyMatch(inputName::startsWith)) {
3052       return PropertyInputType.NODE_TEMPLATE_ID;
3053     }
3054     //Check whether the input is of the form "subinterface_<subinterface_type>_<property_name>"
3055     Set<String> subInterfaceTypes = new HashSet<>();
3056     List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
3057             getPortTemplateConsolidationDataList(unifiedCompositionData);
3058     for (PortTemplateConsolidationData portTemplateConsolidationData :
3059             portTemplateConsolidationDataList) {
3060       ListMultimap<String, SubInterfaceTemplateConsolidationData> subInterfaceTypeToEntity = ArrayListMultimap.create();
3061       portTemplateConsolidationData.copyMappedInto(subInterfaceTypeToEntity);
3062       subInterfaceTypes.addAll(subInterfaceTypeToEntity.keySet());
3063     }
3064
3065     if (subInterfaceTypes.stream().map(UnifiedCompositionUtil::getSubInterfaceTypeSuffix)
3066             .map(subInterfaceTypeSuffix -> subInterfaceInputPrefix + subInterfaceTypeSuffix + "_")
3067             .anyMatch(inputName::startsWith)) {
3068       return PropertyInputType.TYPE;
3069     }
3070     return PropertyInputType.OTHER;
3071   }
3072
3073   private void cleanServiceTemplate(ServiceTemplate serviceTemplate,
3074                                     EntityConsolidationData entity,
3075                                     TranslationContext context) {
3076     removeNodeTemplateFromServiceTemplate(serviceTemplate, entity, context);
3077     updateHeatStackGroup(serviceTemplate, entity, context);
3078     updateSubstitutionMapping(serviceTemplate, context);
3079   }
3080
3081   private void removeNodeTemplateFromServiceTemplate(ServiceTemplate serviceTemplate,
3082                                                      EntityConsolidationData entity,
3083                                                      TranslationContext context) {
3084     String nodeTemplateIdToRemove = entity.getNodeTemplateId();
3085     Map<String, NodeTemplate> nodeTemplates =
3086             serviceTemplate.getTopology_template().getNode_templates();
3087     NodeTemplate nodeTemplateToRemove =
3088             nodeTemplates.get(nodeTemplateIdToRemove);
3089     nodeTemplates.remove(nodeTemplateIdToRemove);
3090
3091     context.addCleanedNodeTemplate(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
3092             nodeTemplateIdToRemove,
3093             entity.getClass() == ComputeTemplateConsolidationData.class
3094                     ? COMPUTE
3095                     : UnifiedCompositionEntity.PORT,
3096             nodeTemplateToRemove);
3097
3098   }
3099
3100   private void removeCleanedNodeType(String cleanedNodeTemplateId,
3101                                      ServiceTemplate serviceTemplate,
3102                                      TranslationContext context) {
3103     NodeTemplate cleanedNodeTemplate =
3104             context
3105                     .getCleanedNodeTemplate(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
3106                             cleanedNodeTemplateId);
3107     String typeToRemove = cleanedNodeTemplate.getType();
3108
3109     if (Objects.nonNull(typeToRemove)
3110             && serviceTemplate.getNode_types().containsKey(typeToRemove)) {
3111       serviceTemplate.getNode_types().remove(typeToRemove);
3112     }
3113   }
3114
3115   private void updateHeatStackGroup(ServiceTemplate serviceTemplate,
3116                                     EntityConsolidationData entity,
3117                                     TranslationContext context) {
3118     Map<String, GroupDefinition> groups = serviceTemplate.getTopology_template()
3119             .getGroups() == null ? new HashMap<>()
3120             : serviceTemplate.getTopology_template().getGroups();
3121     String nodeRelatedAbstractNodeId =
3122             context.getUnifiedAbstractNodeTemplateId(serviceTemplate, entity.getNodeTemplateId());
3123
3124     for (Map.Entry<String, GroupDefinition> groupEntry : groups.entrySet()) {
3125       GroupDefinition groupDefinition = groupEntry.getValue();
3126       if (isHeatStackGroup(groupDefinition.getType())) {
3127         updateGroupMembersWithNewUnifiedNodeTemplateId(entity, nodeRelatedAbstractNodeId,
3128                 groupEntry);
3129       }
3130     }
3131   }
3132
3133   private void updateGroupMembersWithNewUnifiedNodeTemplateId(
3134           EntityConsolidationData entity,
3135           String newNodetemplateId,
3136           Map.Entry<String, GroupDefinition> groupEntry) {
3137     List<String> members = groupEntry.getValue().getMembers();
3138     if (members.contains(entity.getNodeTemplateId())) {
3139       members.remove(entity.getNodeTemplateId());
3140       if (!members.contains(newNodetemplateId)) {
3141         members.add(newNodetemplateId);
3142       }
3143     }
3144     groupEntry.getValue().setMembers(members);
3145   }
3146
3147   private void updateSubstitutionMapping(ServiceTemplate serviceTemplate,
3148                                          TranslationContext context) {
3149     SubstitutionMapping substitutionMappings =
3150             DataModelUtil.getSubstitutionMappings(serviceTemplate);
3151     if (Objects.nonNull(substitutionMappings)) {
3152
3153       if (Objects.nonNull(substitutionMappings.getRequirements())) {
3154         updateSubstitutionMappingRequirements(substitutionMappings.getRequirements(),
3155                 serviceTemplate, context);
3156       }
3157
3158       if (Objects.nonNull(substitutionMappings.getCapabilities())) {
3159         updateSubstitutionMappingCapabilities(substitutionMappings.getCapabilities(),
3160                 serviceTemplate, context);
3161       }
3162     }
3163   }
3164
3165   private void updateSubstitutionMappingRequirements(Map<String, List<String>>
3166                                                              substitutionMappingRequirements,
3167                                                      ServiceTemplate serviceTemplate,
3168                                                      TranslationContext context) {
3169     for (Map.Entry<String, List<String>> entry : substitutionMappingRequirements.entrySet()) {
3170       List<String> requirement = entry.getValue();
3171       String oldNodeTemplateId = requirement.get(0);
3172       String newAbstractNodeTemplateId = context.getUnifiedAbstractNodeTemplateId(serviceTemplate,
3173               requirement.get(0));
3174       String newSubstitutionNodeTemplateId = context.getUnifiedSubstitutionNodeTemplateId(
3175               serviceTemplate, oldNodeTemplateId);
3176       if (Objects.nonNull(newAbstractNodeTemplateId)
3177               && Objects.nonNull(newSubstitutionNodeTemplateId)) {
3178         requirement.set(0, newAbstractNodeTemplateId);
3179         String newRequirementValue = requirement.get(1) + "_" + newSubstitutionNodeTemplateId;
3180         requirement.set(1, newRequirementValue);
3181       }
3182     }
3183   }
3184
3185   private void updateSubstitutionMappingCapabilities(Map<String, List<String>>
3186                                                              substitutionMappingCapabilities,
3187                                                      ServiceTemplate serviceTemplate,
3188                                                      TranslationContext context) {
3189     for (Map.Entry<String, List<String>> entry : substitutionMappingCapabilities.entrySet()) {
3190       List<String> capability = entry.getValue();
3191       String oldNodeTemplateId = capability.get(0);
3192       String newAbstractNodeTemplateId = context.getUnifiedAbstractNodeTemplateId(serviceTemplate,
3193               capability.get(0));
3194       String newSubstitutionNodeTemplateId = context.getUnifiedSubstitutionNodeTemplateId(
3195               serviceTemplate, oldNodeTemplateId);
3196       if (Objects.nonNull(newAbstractNodeTemplateId)
3197               && Objects.nonNull(newSubstitutionNodeTemplateId)) {
3198         capability.set(0, newAbstractNodeTemplateId);
3199         String newRequirementValue = capability.get(1) + "_" + newSubstitutionNodeTemplateId;
3200         capability.set(1, newRequirementValue);
3201       }
3202     }
3203   }
3204
3205   private void updateHeatStackGroupNestedComposition(ServiceTemplate serviceTemplate,
3206                                                      EntityConsolidationData entity,
3207                                                      TranslationContext context) {
3208     Map<String, GroupDefinition> groups = serviceTemplate.getTopology_template()
3209             .getGroups() == null ? new HashMap<>() : serviceTemplate.getTopology_template().getGroups();
3210     String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
3211     Optional<String> nestedNodeTemplateId =
3212             context.getUnifiedNestedNodeTemplateId(serviceTemplateFileName, entity.getNodeTemplateId());
3213     if (nestedNodeTemplateId.isPresent()) {
3214       for (Map.Entry<String, GroupDefinition> groupEntry : groups.entrySet()) {
3215         GroupDefinition groupDefinition = groupEntry.getValue();
3216         if (isHeatStackGroup(groupDefinition.getType())) {
3217           updateGroupMembersWithNewUnifiedNodeTemplateId(entity, nestedNodeTemplateId.get(),
3218                   groupEntry);
3219         }
3220       }
3221     }
3222   }
3223
3224   private void handleNestedNodeTemplateInMainServiceTemplate(String nestedNodeTemplateId,
3225                                                              ServiceTemplate mainServiceTemplate,
3226                                                              ServiceTemplate nestedServiceTemplate,
3227                                                              TranslationContext context) {
3228     NodeTemplate nestedNodeTemplate = DataModelUtil.getNodeTemplate(mainServiceTemplate,
3229             nestedNodeTemplateId);
3230     if (Objects.isNull(nestedNodeTemplate)) {
3231       return;
3232     }
3233
3234     updateNestedNodeTemplateProperties(nestedServiceTemplate, nestedNodeTemplate, context);
3235
3236     Optional<String> unifiedNestedNodeTypeId = context
3237             .getUnifiedNestedNodeTypeId(
3238                     ToscaUtil.getServiceTemplateFileName(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME),
3239                     nestedNodeTemplate.getType());
3240     unifiedNestedNodeTypeId
3241             .ifPresent(unifiedNestedNodeTypeIdVal -> updateNestedNodeTemplate(
3242                     unifiedNestedNodeTypeIdVal, nestedNodeTemplateId, nestedNodeTemplate,
3243                     mainServiceTemplate, context));
3244   }
3245
3246   private void updateNestedNodeTemplateProperties(ServiceTemplate nestedServiceTemplate,
3247                                                   NodeTemplate nestedNodeTemplate,
3248                                                   TranslationContext context) {
3249
3250     Map<String, Object> newPropertyInputParamIds =
3251             context.getAllNewPropertyInputParamIdsPerNodeTenplateId(ToscaUtil
3252                     .getServiceTemplateFileName(nestedServiceTemplate));
3253
3254     for (Map.Entry<String, Object> entry : newPropertyInputParamIds.entrySet()) {
3255       if (Objects.nonNull(entry.getValue())) {
3256         Object value = getClonedObject(entry.getValue());
3257         nestedNodeTemplate.getProperties().put(entry.getKey(), value);
3258       }
3259     }
3260
3261     String subNodeType =
3262             nestedServiceTemplate.getTopology_template().getSubstitution_mappings().getNode_type();
3263     nestedNodeTemplate.setType(subNodeType);
3264
3265   }
3266
3267   private void handleSubstitutionMappingInNestedServiceTemplate(
3268           String newNestedNodeType,
3269           ServiceTemplate nestedServiceTemplate,
3270           TranslationContext context) {
3271     if (Objects.isNull(newNestedNodeType)) {
3272       return;
3273     }
3274
3275     Set<String> relatedNestedNodeTypeIds =
3276             context.getAllRelatedNestedNodeTypeIds();
3277
3278     SubstitutionMapping substitutionMappings =
3279             nestedServiceTemplate.getTopology_template().getSubstitution_mappings();
3280     if (!relatedNestedNodeTypeIds.contains(substitutionMappings.getNode_type())) {
3281       substitutionMappings.setNode_type(newNestedNodeType);
3282     }
3283   }
3284
3285   private void updateNestedNodeTemplate(String newNestedNodeTypeId,
3286                                         String nestedNodeTemplateId,
3287                                         NodeTemplate nestedNodeTemplate,
3288                                         ServiceTemplate mainServiceTemplate,
3289                                         TranslationContext context) {
3290     String mainSTName = ToscaUtil.getServiceTemplateFileName(mainServiceTemplate);
3291     String globalSTName =
3292             ToscaUtil.getServiceTemplateFileName(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME);
3293     int index =
3294             context.getHandledNestedComputeNodeTemplateIndex(globalSTName, newNestedNodeTypeId);
3295     String newNodeTemplateId =
3296             Constants.ABSTRACT_NODE_TEMPLATE_ID_PREFIX + getComputeTypeSuffix(newNestedNodeTypeId)
3297                     + "_" + index;
3298
3299     nestedNodeTemplate.setType(newNestedNodeTypeId);
3300     mainServiceTemplate.getTopology_template().getNode_templates().remove(nestedNodeTemplateId);
3301     mainServiceTemplate.getTopology_template().getNode_templates()
3302             .put(newNodeTemplateId, nestedNodeTemplate);
3303
3304     context.addUnifiedNestedNodeTemplateId(mainSTName, nestedNodeTemplateId, newNodeTemplateId);
3305   }
3306
3307   private void handleNestedNodeTypesInGlobalSubstituteServiceTemplate(
3308           String origNestedNodeTypeId,
3309           String newNestedNodeTypeId,
3310           ServiceTemplate globalSubstitutionServiceTemplate,
3311           TranslationContext context) {
3312     Set<String> relatedNestedNodeTypeIds =
3313             context.getAllRelatedNestedNodeTypeIds();
3314
3315     Map<String, NodeType> nodeTypes = globalSubstitutionServiceTemplate.getNode_types();
3316     if (!relatedNestedNodeTypeIds.contains(origNestedNodeTypeId)) {
3317       NodeType nested = DataModelUtil.getNodeType(globalSubstitutionServiceTemplate,
3318               origNestedNodeTypeId);
3319       setNewValuesForNestedNodeType(origNestedNodeTypeId, newNestedNodeTypeId, nested, nodeTypes);
3320     } else {
3321       NodeType nested =
3322               (NodeType) DataModelUtil.getClonedObject(
3323                       DataModelUtil.getNodeType(globalSubstitutionServiceTemplate, origNestedNodeTypeId));
3324       nested.setDerived_from(ToscaNodeType.VFC_ABSTRACT_SUBSTITUTE);
3325       nodeTypes.put(newNestedNodeTypeId, nested);
3326     }
3327     context.addUnifiedNestedNodeTypeId(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME,
3328             origNestedNodeTypeId, newNestedNodeTypeId);
3329   }
3330
3331   private void setNewValuesForNestedNodeType(String origNestedNodeType,
3332                                              String newNestedNodeTypeId,
3333                                              NodeType nested,
3334                                              Map<String, NodeType> nodeTypes) {
3335     if (Objects.nonNull(nested)) {
3336       nested.setDerived_from(ToscaNodeType.VFC_ABSTRACT_SUBSTITUTE);
3337       nodeTypes.remove(origNestedNodeType);
3338       nodeTypes.put(newNestedNodeTypeId, nested);
3339     }
3340   }
3341
3342   private Optional<String> getNewNestedNodeTypeId(ServiceTemplate nestedServiceTemplate,
3343                                                   TranslationContext context) {
3344     FileComputeConsolidationData fileComputeConsolidationData =
3345             context.getConsolidationData().getComputeConsolidationData()
3346                     .getFileComputeConsolidationData(
3347                             ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate));
3348
3349     if (Objects.nonNull(fileComputeConsolidationData)) {
3350       String nestedNodeTypePrefix = ToscaNodeType.ABSTRACT_NODE_TYPE_PREFIX + "heat.";
3351       return Optional
3352               .of(nestedNodeTypePrefix + getComputeTypeInNestedFile(fileComputeConsolidationData));
3353     }
3354     return Optional.empty();
3355   }
3356
3357   private String getComputeTypeInNestedFile(
3358           FileComputeConsolidationData fileComputeConsolidationData) {
3359     List<TypeComputeConsolidationData> typeComputeConsolidationDatas =
3360             new ArrayList<>(fileComputeConsolidationData.getAllTypeComputeConsolidationData());
3361     if (typeComputeConsolidationDatas.isEmpty()) {
3362       return null;
3363     } else {
3364       String computeNodeType = fileComputeConsolidationData.getAllComputeTypes().iterator().next();
3365       return getComputeTypeSuffix(computeNodeType);
3366     }
3367   }
3368
3369   private void handleGetAttrInAbstractNodeTemplate(ServiceTemplate serviceTemplate,
3370                                                    TranslationContext context,
3371                                                    String serviceTemplateFileName,
3372                                                    NodeTemplate abstractNodeTemplate) {
3373     Map<String, Object> properties =
3374             abstractNodeTemplate == null || abstractNodeTemplate.getProperties() == null
3375                     ? new HashMap<>()
3376                     : abstractNodeTemplate.getProperties();
3377     for (Object propertyValue : properties.values()) {
3378       List<List<Object>> getAttrList = extractGetAttrFunction(propertyValue);
3379       for (List<Object> getAttrFuncValue : getAttrList) {
3380         String origNodeTemplateId = (String) getAttrFuncValue.get(0);
3381         Optional<String> nestedNodeTemplateId = context.getUnifiedNestedNodeTemplateId(ToscaUtil
3382                 .getServiceTemplateFileName(serviceTemplate), origNodeTemplateId);
3383         if (nestedNodeTemplateId.isPresent()) {
3384           getAttrFuncValue.set(0, nestedNodeTemplateId.get());
3385         } else {
3386           replaceGetAttrNodeIdAndAttrName(serviceTemplate, context, serviceTemplateFileName,
3387                   getAttrFuncValue);
3388         }
3389       }
3390     }
3391   }
3392
3393   private void replaceGetAttrNodeIdAndAttrName(ServiceTemplate serviceTemplate,
3394                                                TranslationContext context,
3395                                                String serviceTemplateFileName,
3396                                                List<Object> getAttrFuncValue) {
3397     String origNodeTemplateId = (String) getAttrFuncValue.get(0);
3398     String attributeName = (String) getAttrFuncValue.get(1);
3399
3400     String unifiedAbstractNodeTemplateId =
3401             context.getUnifiedAbstractNodeTemplateId(serviceTemplate, origNodeTemplateId);
3402
3403     if (Objects.isNull(unifiedAbstractNodeTemplateId)) {
3404       return;
3405     }
3406
3407     String newNodeTemplateId =
3408             getNewNodeTemplateId(origNodeTemplateId, serviceTemplateFileName, serviceTemplate, context);
3409
3410     String newSubstitutionOutputParameterId =
3411             getNewSubstitutionOutputParameterId(newNodeTemplateId, attributeName);
3412
3413     getAttrFuncValue.set(0, unifiedAbstractNodeTemplateId);
3414     getAttrFuncValue.set(1, newSubstitutionOutputParameterId);
3415   }
3416
3417   private NodeTemplate getComputeNodeTemplate(String origNodeTemplateId,
3418                                               ServiceTemplate serviceTemplate,
3419                                               TranslationContext context) {
3420     NodeTemplate computeNodeTemplate =
3421             DataModelUtil.getNodeTemplate(serviceTemplate, origNodeTemplateId);
3422     if (computeNodeTemplate == null) {
3423       computeNodeTemplate =
3424               context.getCleanedNodeTemplate(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
3425                       origNodeTemplateId);
3426     }
3427     return computeNodeTemplate;
3428   }
3429
3430   private String handleIdOfPort(String origNodeTemplateId, String serviceTemplateFileName,
3431                                 ConsolidationData consolidationData) {
3432     Optional<Pair<String, ComputeTemplateConsolidationData>>
3433             computeTypeAndComputeTemplateByPortId =
3434             getComputeTypeAndComputeTemplateByPortId(origNodeTemplateId, serviceTemplateFileName,
3435                     consolidationData);
3436     if (computeTypeAndComputeTemplateByPortId.isPresent()) {
3437       Pair<String, ComputeTemplateConsolidationData> computeIdToComputeData =
3438               computeTypeAndComputeTemplateByPortId.get();
3439       return getNewPortNodeTemplateId(origNodeTemplateId, computeIdToComputeData.getKey(),
3440               computeIdToComputeData.getValue());
3441     }
3442
3443     return null;
3444   }
3445
3446   private Optional<Pair<String, ComputeTemplateConsolidationData>>
3447   getComputeTypeAndComputeTemplateByPortId(String portId, String serviceTemplateFileName,
3448                                            ConsolidationData consolidationData) {
3449     FileComputeConsolidationData fileComputeConsolidationData =
3450             consolidationData.getComputeConsolidationData()
3451                     .getFileComputeConsolidationData(serviceTemplateFileName);
3452     Set<String> computeTypes =
3453             fileComputeConsolidationData.getAllComputeTypes();
3454
3455     for (String computeType : computeTypes) {
3456       Collection<ComputeTemplateConsolidationData> computeTemplateConsolidationDatas =
3457               fileComputeConsolidationData.getTypeComputeConsolidationData(computeType)
3458                       .getAllComputeTemplateConsolidationData();
3459
3460       for (ComputeTemplateConsolidationData compute : computeTemplateConsolidationDatas) {
3461         if (ConsolidationDataUtil.isComputeReferenceToPortId(compute, portId)) {
3462           return Optional.of(new ImmutablePair<>(computeType, compute));
3463         }
3464       }
3465     }
3466
3467     return Optional.empty();
3468   }
3469
3470   private boolean isIdIsOfExpectedType(String id,
3471                                        UnifiedCompositionEntity expectedUnifiedCompositionEntity,
3472                                        String serviceTemplateFileName,
3473                                        TranslationContext context) {
3474     UnifiedSubstitutionData unifiedSubstitutionData =
3475             context.getUnifiedSubstitutionData().get(serviceTemplateFileName);
3476     if (Objects.isNull(unifiedSubstitutionData)) {
3477       return false;
3478     }
3479
3480     UnifiedCompositionEntity actualUnifiedCompositionEntity =
3481             unifiedSubstitutionData.getCleanedNodeTemplateCompositionEntity(id);
3482
3483     return actualUnifiedCompositionEntity == null ? false
3484             : actualUnifiedCompositionEntity.equals(expectedUnifiedCompositionEntity);
3485   }
3486
3487   private boolean isHeatStackGroup(String groupType) {
3488     return groupType.equals(ToscaGroupType.HEAT_STACK);
3489   }
3490
3491   private Object getPortPropertyValue(String inputName,
3492                                       String computeType,
3493                                       PropertyInputType portInputType,
3494                                       ServiceTemplate serviceTemplate,
3495                                       String portNodeTemplateId) {
3496     //Get the input prefix to extract the property name from the input name
3497     String portType = ConsolidationDataUtil.getPortType(portNodeTemplateId);
3498     String portInputPrefix = getPropertyInputPrefix(
3499             portNodeTemplateId, portType, portInputType, UnifiedCompositionEntity.PORT);
3500     //Get the property name from the input
3501     Optional<String> propertyName = getPropertyNameFromInput(inputName,
3502             UnifiedCompositionEntity.PORT, computeType, portInputPrefix);
3503     //Get the property value from the node template
3504     if (propertyName.isPresent()) {
3505       NodeTemplate portNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
3506               portNodeTemplateId);
3507       if (Objects.nonNull(portNodeTemplate)) {
3508         return getPropertyValueFromNodeTemplate(propertyName.get(), portNodeTemplate);
3509       }
3510     }
3511     return Optional.empty();
3512   }
3513
3514   private Object getComputePropertyValue(
3515           String inputName,
3516           ServiceTemplate serviceTemplate,
3517           ComputeTemplateConsolidationData computeTemplateConsolidationData) {
3518     NodeTemplate nodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
3519             computeTemplateConsolidationData.getNodeTemplateId());
3520     String nodeType = getComputeTypeSuffix(nodeTemplate.getType());
3521     Optional<String> propertyName =
3522             getPropertyNameFromInput(inputName, COMPUTE, nodeType, null);
3523     if (propertyName.isPresent()) {
3524       return getPropertyValueFromNodeTemplate(propertyName.get(), nodeTemplate);
3525     }
3526     return Optional.empty();
3527   }
3528
3529   private Object getSubInterfacePropertyValue(String inputName,
3530                                               String subInterfaceTypeSuffix,
3531                                               PropertyInputType propertyInputType,
3532                                               ServiceTemplate serviceTemplate,
3533                                               String subInterfaceNodeTemplateId) {
3534     //Get the input prefix to extract the property name from the input name
3535     String propertyInputPrefix = getPropertyInputPrefix(subInterfaceNodeTemplateId,
3536             subInterfaceTypeSuffix, propertyInputType, UnifiedCompositionEntity.SUB_INTERFACE);
3537     //Get the property name from the input
3538     Optional<String> propertyName = getPropertyNameFromInput(inputName,
3539             UnifiedCompositionEntity.SUB_INTERFACE, null, propertyInputPrefix);
3540     //Get the property value from the node template
3541     if (propertyName.isPresent()) {
3542       NodeTemplate subInterfaceNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
3543               subInterfaceNodeTemplateId);
3544       if (Objects.nonNull(subInterfaceNodeTemplate)) {
3545         return getPropertyValueFromNodeTemplate(propertyName.get(), subInterfaceNodeTemplate);
3546       }
3547     }
3548     return Optional.empty();
3549   }
3550
3551   private Optional<Object> getIdenticalPropertyValue(String identicalValuePropertyName,
3552                                                      ServiceTemplate serviceTemplate,
3553                                                      EntityConsolidationData entity,
3554                                                      TranslationContext context) {
3555     NodeTemplate nodeTemplate =
3556             getNodeTemplate(entity.getNodeTemplateId(), serviceTemplate, context);
3557
3558     Object propertyValueFromNodeTemplate =
3559             getPropertyValueFromNodeTemplate(identicalValuePropertyName, nodeTemplate);
3560
3561     return Objects.isNull(propertyValueFromNodeTemplate) ? Optional.empty()
3562             : Optional.of(propertyValueFromNodeTemplate);
3563   }
3564
3565   private UnifiedCompositionEntity getInputCompositionEntity(String inputName) {
3566     UnifiedCompositionEntity inputCompositionEntity = UnifiedCompositionEntity.OTHER;
3567     if (inputName.indexOf('_') != -1) {
3568       String inputType = inputName.substring(0, inputName.indexOf('_'));
3569       if (inputType.equalsIgnoreCase(COMPUTE.getDisplayName())) {
3570         inputCompositionEntity = COMPUTE;
3571       } else if (inputType.equalsIgnoreCase(UnifiedCompositionEntity.PORT.getDisplayName())) {
3572         inputCompositionEntity = UnifiedCompositionEntity.PORT;
3573       } else if (inputType.equalsIgnoreCase(UnifiedCompositionEntity.SUB_INTERFACE
3574               .getDisplayName())) {
3575         inputCompositionEntity = UnifiedCompositionEntity.SUB_INTERFACE;
3576       }
3577     }
3578     return inputCompositionEntity;
3579   }
3580
3581   private Optional<String> getPropertyNameFromInput(
3582           String inputName,
3583           UnifiedCompositionEntity compositionEntity,
3584           String entityType, String propertyInputPrefix) {
3585     String propertyName = null;
3586     switch (compositionEntity) {
3587       case COMPUTE:
3588         propertyName = inputName.substring(inputName.lastIndexOf(entityType)
3589                 + entityType.length() + 1);
3590         break;
3591       case PORT:
3592       case SUB_INTERFACE:
3593         if (inputName.startsWith(propertyInputPrefix)) {
3594           propertyName = inputName.split(propertyInputPrefix)[1];
3595         }
3596         break;
3597       default:
3598         break;
3599     }
3600     return Optional.ofNullable(propertyName);
3601   }
3602
3603   private String getPropertyInputPrefix(String nodeTemplateId,
3604                                         String propertyEntityType,
3605                                         PropertyInputType propertyInputType,
3606                                         UnifiedCompositionEntity unifiedCompositionEntity) {
3607     String propertyInputPrefix = unifiedCompositionEntity.getDisplayName().toLowerCase() + "_";
3608     if (propertyInputType == PropertyInputType.NODE_TEMPLATE_ID) {
3609       propertyInputPrefix += nodeTemplateId + "_";
3610     } else if (propertyInputType == PropertyInputType.TYPE) {
3611       propertyInputPrefix += propertyEntityType + "_";
3612     }
3613     return propertyInputPrefix;
3614   }
3615
3616   private boolean isIdenticalValueProperty(String inputName,
3617                                            UnifiedCompositionEntity unifiedCompositionEntity) {
3618
3619     List<String> identicalValuePropertyList =
3620             consolidationService.getPropertiesWithIdenticalVal(unifiedCompositionEntity);
3621
3622     StringBuilder builder = getPropertyValueStringBuilder(unifiedCompositionEntity);
3623     if (Objects.isNull(builder)) {
3624       return false;
3625     }
3626
3627     boolean isMatchingProperty = Pattern.matches(builder.toString(), inputName);
3628     return isMatchingProperty
3629             && isPropertyFromIdenticalValuesList(inputName, unifiedCompositionEntity,
3630             identicalValuePropertyList);
3631   }
3632
3633   private boolean isPropertyFromIdenticalValuesList(String inputName,
3634                                                     UnifiedCompositionEntity unifiedCompositionEntity,
3635                                                     List<String> identicalValuePropertyList) {
3636     switch (unifiedCompositionEntity) {
3637       case COMPUTE:
3638         return identicalValuePropertyList.contains(getIdenticalValuePropertyName(inputName,
3639                 unifiedCompositionEntity).get());
3640
3641       case OTHER:
3642         return identicalValuePropertyList.contains(getIdenticalValuePropertyName(inputName,
3643                 unifiedCompositionEntity).get());
3644
3645       case PORT:
3646         return getPortPropertyNameFromInput(inputName, identicalValuePropertyList).isPresent();
3647
3648       default:
3649         return false;
3650     }
3651   }
3652
3653   private Optional<String> getPortPropertyNameFromInput(String inputName,
3654                                                         List<String> identicalValuePropertyList) {
3655     for (String identicalProperty : identicalValuePropertyList) {
3656       if (inputName.contains(identicalProperty)) {
3657         return Optional.of(identicalProperty);
3658       }
3659     }
3660     return Optional.empty();
3661   }
3662
3663   private StringBuilder getPropertyValueStringBuilder(
3664           UnifiedCompositionEntity unifiedCompositionEntity) {
3665
3666     switch (unifiedCompositionEntity) {
3667       case COMPUTE:
3668         return getComputePropertyValueStringBuilder();
3669
3670       case OTHER:
3671         return getComputePropertyValueStringBuilder();
3672
3673       case PORT:
3674         return getPortPropertyValueStringBuilder();
3675
3676       case SUB_INTERFACE:
3677         return getSubInterfacePropertyValueStringBuilder();
3678
3679       default:
3680         return null;
3681     }
3682   }
3683
3684   private StringBuilder getPortPropertyValueStringBuilder() {
3685     StringBuilder builder;
3686     builder = new StringBuilder(PORT_IDENTICAL_VALUE_PROPERTY_PREFIX);
3687     builder.append(".+");
3688     return builder;
3689   }
3690
3691   private StringBuilder getComputePropertyValueStringBuilder() {
3692     StringBuilder builder;
3693     builder = new StringBuilder(COMPUTE_IDENTICAL_VALUE_PROPERTY_PREFIX);
3694     builder.append("[a-z]+");
3695     builder.append(COMPUTE_IDENTICAL_VALUE_PROPERTY_SUFFIX);
3696     return builder;
3697   }
3698
3699   private StringBuilder getSubInterfacePropertyValueStringBuilder() {
3700     StringBuilder builder;
3701     builder = new StringBuilder(SUB_INTERFACE_PROPERTY_VALUE_PREFIX);
3702     builder.append(".+");
3703     return builder;
3704   }
3705
3706   private Optional<String> getIdenticalValuePropertyName(String input,
3707                                                          UnifiedCompositionEntity
3708                                                                  unifiedCompositionEntity) {
3709     switch (unifiedCompositionEntity) {
3710       case COMPUTE:
3711         return Optional.of(input.split("_")[1]);
3712
3713       case OTHER:
3714         return Optional.of(input.split("_")[1]);
3715
3716       case PORT:
3717         return getPortPropertyNameFromInput(input, consolidationService
3718                 .getPropertiesWithIdenticalVal(unifiedCompositionEntity));
3719
3720       default:
3721         return Optional.empty();
3722     }
3723   }
3724
3725   private Object getPropertyValueFromNodeTemplate(String propertyName, NodeTemplate nodeTemplate) {
3726     Map<String, Object> nodeTemplateProperties = nodeTemplate.getProperties();
3727     if (nodeTemplateProperties != null) {
3728       Object propertyValue = nodeTemplateProperties.get(propertyName);
3729       propertyValue = getClonedObject(propertyValue);
3730       return propertyValue;
3731     }
3732     return null;
3733   }
3734
3735   private Map<String, UnifiedCompositionEntity> getAllConsolidationNodeTemplateIdAndType(
3736           List<UnifiedCompositionData> unifiedCompositionDataList) {
3737
3738     Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType = new HashMap<>();
3739     for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
3740       ComputeTemplateConsolidationData computeTemplateConsolidationData =
3741               unifiedCompositionData.getComputeTemplateConsolidationData();
3742       if (Objects.nonNull(computeTemplateConsolidationData)) {
3743         consolidationNodeTemplateIdAndType
3744                 .put(computeTemplateConsolidationData.getNodeTemplateId(),
3745                         COMPUTE);
3746       }
3747       List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
3748               getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
3749       for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData :
3750               subInterfaceTemplateConsolidationDataList) {
3751         consolidationNodeTemplateIdAndType.put(subInterfaceTemplateConsolidationData.getNodeTemplateId(),
3752                 UnifiedCompositionEntity.SUB_INTERFACE);
3753       }
3754       List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
3755               getPortTemplateConsolidationDataList(unifiedCompositionData);
3756       for (PortTemplateConsolidationData portTemplateConsolidationData :
3757               portTemplateConsolidationDataList) {
3758         consolidationNodeTemplateIdAndType.put(portTemplateConsolidationData.getNodeTemplateId(),
3759                 UnifiedCompositionEntity.PORT);
3760       }
3761       NestedTemplateConsolidationData nestedTemplateConsolidationData =
3762               unifiedCompositionData.getNestedTemplateConsolidationData();
3763       if (Objects.nonNull(nestedTemplateConsolidationData)) {
3764         consolidationNodeTemplateIdAndType
3765                 .put(nestedTemplateConsolidationData.getNodeTemplateId(),
3766                         UnifiedCompositionEntity.NESTED);
3767       }
3768     }
3769     return consolidationNodeTemplateIdAndType;
3770   }
3771
3772   private List<PortTemplateConsolidationData> getPortTemplateConsolidationDataList(
3773           UnifiedCompositionData unifiedCompositionData) {
3774     return unifiedCompositionData.getPortTemplateConsolidationDataList() == null ? new
3775             ArrayList<>() : unifiedCompositionData.getPortTemplateConsolidationDataList();
3776   }
3777
3778   private enum PropertyInputType {
3779     NODE_TEMPLATE_ID,
3780     TYPE,
3781     OTHER
3782   }
3783 }