gerrit.onap Code Review - sdc.git/blob

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