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