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

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