gerrit.onap Code Review - sdc.git/blob

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