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