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

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