gerrit.onap Code Review - sdc.git/blob

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