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

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