openecomp-be/lib/openecomp-tosca-lib/src/main/java/org/openecomp/sdc/tosca/services/DataModelUtil.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.tosca.services;
  22
  23 import org.apache.commons.collections4.CollectionUtils;
  24 import org.apache.commons.collections4.MapUtils;
  25 import org.openecomp.core.utilities.CommonMethods;
  26 import org.openecomp.core.utilities.yaml.YamlUtil;
  27 import org.openecomp.sdc.common.errors.CoreException;
  28 import org.openecomp.sdc.datatypes.error.ErrorLevel;
  29 import org.openecomp.sdc.logging.context.impl.MdcDataDebugMessage;
  30 import org.openecomp.sdc.logging.context.impl.MdcDataErrorMessage;
  31 import org.openecomp.sdc.logging.types.LoggerConstants;
  32 import org.openecomp.sdc.logging.types.LoggerErrorCode;
  33 import org.openecomp.sdc.logging.types.LoggerErrorDescription;
  34 import org.openecomp.sdc.logging.types.LoggerTragetServiceName;
  35 import org.openecomp.sdc.tosca.datatypes.ToscaFunctions;
  36 import org.openecomp.sdc.tosca.datatypes.model.AttributeDefinition;
  37 import org.openecomp.sdc.tosca.datatypes.model.CapabilityDefinition;
  38 import org.openecomp.sdc.tosca.datatypes.model.CapabilityType;
  39 import org.openecomp.sdc.tosca.datatypes.model.Constraint;
  40 import org.openecomp.sdc.tosca.datatypes.model.EntrySchema;
  41 import org.openecomp.sdc.tosca.datatypes.model.GroupDefinition;
  42 import org.openecomp.sdc.tosca.datatypes.model.Import;
  43 import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate;
  44 import org.openecomp.sdc.tosca.datatypes.model.NodeType;
  45 import org.openecomp.sdc.tosca.datatypes.model.ParameterDefinition;
  46 import org.openecomp.sdc.tosca.datatypes.model.PolicyDefinition;
  47 import org.openecomp.sdc.tosca.datatypes.model.PropertyDefinition;
  48 import org.openecomp.sdc.tosca.datatypes.model.RelationshipTemplate;
  49 import org.openecomp.sdc.tosca.datatypes.model.RequirementAssignment;
  50 import org.openecomp.sdc.tosca.datatypes.model.RequirementDefinition;
  51 import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate;
  52 import org.openecomp.sdc.tosca.datatypes.model.Status;
  53 import org.openecomp.sdc.tosca.datatypes.model.SubstitutionMapping;
  54 import org.openecomp.sdc.tosca.datatypes.model.TopologyTemplate;
  55 import org.openecomp.sdc.tosca.datatypes.model.heatextend.ParameterDefinitionExt;
  56 import org.openecomp.sdc.tosca.errors.InvalidAddActionNullEntityErrorBuilder;
  57 import org.openecomp.sdc.tosca.errors.InvalidRequirementAssignmentErrorBuilder;
  58 import org.openecomp.sdc.tosca.services.impl.ToscaAnalyzerServiceImpl;
  59 import org.openecomp.sdc.tosca.services.yamlutil.ToscaExtensionYamlUtil;
  60
  61 import java.util.ArrayList;
  62 import java.util.Arrays;
  63 import java.util.Collections;
  64 import java.util.HashMap;
  65 import java.util.List;
  66 import java.util.ListIterator;
  67 import java.util.Map;
  68 import java.util.Objects;
  69 import java.util.Optional;
  70
  71 /**
  72  * The type Data model util.
  73  */
  74 public class DataModelUtil {
  75
  76   /**
  77    * Add substitution mapping.
  78    */
  79
  80   private static MdcDataDebugMessage mdcDataDebugMessage = new MdcDataDebugMessage();
  81
  82   /**
  83    * Add substitution mapping.
  84    *
  85    * @param serviceTemplate     the service template
  86    * @param substitutionMapping the substitution mapping
  87    */
  88   public static void addSubstitutionMapping(ServiceTemplate serviceTemplate,
  89                                             SubstitutionMapping substitutionMapping) {
  90     mdcDataDebugMessage.debugEntryMessage(null, null);
  91
  92     if (serviceTemplate == null) {
  93       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
  94           LoggerTragetServiceName.ADD_ENTITIES_TO_TOSCA, ErrorLevel.ERROR.name(),
  95           LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_ADD_ACTION);
  96       throw new CoreException(
  97           new InvalidAddActionNullEntityErrorBuilder("Substitution Mapping", "Service Template")
  98               .build());
  99     }
 100
 101     if (serviceTemplate.getTopology_template() == null) {
 102       serviceTemplate.setTopology_template(new TopologyTemplate());
 103     }
 104     serviceTemplate.getTopology_template().setSubstitution_mappings(substitutionMapping);
 105
 106     mdcDataDebugMessage.debugExitMessage(null, null);
 107   }
 108
 109   /**
 110    * Add substitution mapping req.
 111    *
 112    * @param serviceTemplate                    the service template
 113    * @param substitutionMappingRequirementId   the substitution mapping requirement id
 114    * @param substitutionMappingRequirementList the substitution mapping requirement list
 115    */
 116   public static void addSubstitutionMappingReq(ServiceTemplate serviceTemplate,
 117                                                String substitutionMappingRequirementId,
 118                                                List<String> substitutionMappingRequirementList) {
 119
 120
 121     mdcDataDebugMessage.debugEntryMessage(null, null);
 122
 123     if (serviceTemplate == null) {
 124       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 125           LoggerTragetServiceName.ADD_ENTITIES_TO_TOSCA, ErrorLevel.ERROR.name(),
 126           LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_ADD_ACTION);
 127       throw new CoreException(
 128           new InvalidAddActionNullEntityErrorBuilder("Substitution Mapping Requirements",
 129               "Service Template").build());
 130     }
 131
 132     if (serviceTemplate.getTopology_template() == null) {
 133       serviceTemplate.setTopology_template(new TopologyTemplate());
 134     }
 135     if (serviceTemplate.getTopology_template().getSubstitution_mappings() == null) {
 136       serviceTemplate.getTopology_template().setSubstitution_mappings(new SubstitutionMapping());
 137     }
 138     if (serviceTemplate.getTopology_template().getSubstitution_mappings().getRequirements()
 139         == null) {
 140       serviceTemplate.getTopology_template().getSubstitution_mappings()
 141           .setRequirements(new HashMap<>());
 142     }
 143
 144     serviceTemplate.getTopology_template().getSubstitution_mappings().getRequirements()
 145         .put(substitutionMappingRequirementId, substitutionMappingRequirementList);
 146
 147     mdcDataDebugMessage.debugExitMessage(null, null);
 148   }
 149
 150   /**
 151    * Add node template.
 152    *
 153    * @param serviceTemplate the service template
 154    * @param nodeTemplateId  the node template id
 155    * @param nodeTemplate    the node template
 156    */
 157   public static void addNodeTemplate(ServiceTemplate serviceTemplate, String nodeTemplateId,
 158                                      NodeTemplate nodeTemplate) {
 159
 160
 161     mdcDataDebugMessage.debugEntryMessage(null, null);
 162
 163     if (serviceTemplate == null) {
 164       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 165           LoggerTragetServiceName.ADD_ENTITIES_TO_TOSCA, ErrorLevel.ERROR.name(),
 166           LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_ADD_ACTION);
 167       throw new CoreException(
 168           new InvalidAddActionNullEntityErrorBuilder("Node Template", "Service Template").build());
 169     }
 170     TopologyTemplate topologyTemplate = serviceTemplate.getTopology_template();
 171     if (Objects.isNull(topologyTemplate)) {
 172       topologyTemplate = new TopologyTemplate();
 173       serviceTemplate.setTopology_template(topologyTemplate);
 174     }
 175     if (topologyTemplate.getNode_templates() == null) {
 176       topologyTemplate.setNode_templates(new HashMap<>());
 177     }
 178     topologyTemplate.getNode_templates().put(nodeTemplateId, nodeTemplate);
 179
 180     mdcDataDebugMessage.debugExitMessage(null, null);
 181
 182   }
 183
 184   /**
 185    * Add capability def.
 186    *
 187    * @param nodeType             the node type
 188    * @param capabilityId         the capability id
 189    * @param capabilityDefinition the capability definition
 190    */
 191   public static void addCapabilityDef(NodeType nodeType, String capabilityId,
 192                                       CapabilityDefinition capabilityDefinition) {
 193
 194
 195     mdcDataDebugMessage.debugEntryMessage(null, null);
 196
 197     if (nodeType == null) {
 198       throw new CoreException(
 199           new InvalidAddActionNullEntityErrorBuilder("Capability Definition", "Node Type").build());
 200     }
 201     if (Objects.isNull(nodeType.getCapabilities())) {
 202       nodeType.setCapabilities(new HashMap<>());
 203     }
 204     nodeType.getCapabilities().put(capabilityId, capabilityDefinition);
 205
 206     mdcDataDebugMessage.debugExitMessage(null, null);
 207   }
 208
 209   /**
 210    * Add capabilities def to node type.
 211    *
 212    * @param nodeType     the node type
 213    * @param capabilities the capability definitions
 214    */
 215   public static void addNodeTypeCapabilitiesDef(NodeType nodeType,
 216                                                 Map<String, CapabilityDefinition> capabilities) {
 217     mdcDataDebugMessage.debugEntryMessage(null, null);
 218
 219     if (capabilities == null || capabilities.entrySet().size() == 0) {
 220       return;
 221     }
 222
 223     if (nodeType == null) {
 224       throw new CoreException(
 225           new InvalidAddActionNullEntityErrorBuilder("Capability Definition", "Node Type").build());
 226     }
 227
 228     if (MapUtils.isEmpty(nodeType.getCapabilities())) {
 229       nodeType.setCapabilities(new HashMap<>());
 230     }
 231     if (capabilities.size() > 0) {
 232       nodeType.setCapabilities(new HashMap<>());
 233     }
 234     for (Map.Entry<String, CapabilityDefinition> entry : capabilities.entrySet()) {
 235       nodeType.getCapabilities().put(entry.getKey(), entry.getValue());
 236     }
 237
 238     mdcDataDebugMessage.debugExitMessage(null, null);
 239   }
 240
 241   /**
 242    * Add policy definition.
 243    *
 244    * @param serviceTemplate  the service template
 245    * @param policyId         the policy id
 246    * @param policyDefinition the policy definition
 247    */
 248   public static void addPolicyDefinition(ServiceTemplate serviceTemplate, String policyId,
 249                                          PolicyDefinition policyDefinition) {
 250
 251
 252     mdcDataDebugMessage.debugEntryMessage(null, null);
 253
 254     if (serviceTemplate == null) {
 255       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 256           LoggerTragetServiceName.ADD_ENTITIES_TO_TOSCA, ErrorLevel.ERROR.name(),
 257           LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_ADD_ACTION);
 258       throw new CoreException(
 259           new InvalidAddActionNullEntityErrorBuilder("Policy Definition", "Service Template")
 260               .build());
 261     }
 262     TopologyTemplate topologyTemplate = serviceTemplate.getTopology_template();
 263     if (Objects.isNull(topologyTemplate)) {
 264       topologyTemplate = new TopologyTemplate();
 265       serviceTemplate.setTopology_template(topologyTemplate);
 266     }
 267     if (topologyTemplate.getPolicies() == null) {
 268       topologyTemplate.setPolicies(new HashMap<>());
 269     }
 270     topologyTemplate.getPolicies().put(policyId, policyDefinition);
 271
 272     mdcDataDebugMessage.debugExitMessage(null, null);
 273   }
 274
 275   /**
 276    * Add node type.
 277    *
 278    * @param serviceTemplate the service template
 279    * @param nodeTypeId      the node type id
 280    * @param nodeType        the node type
 281    */
 282   public static void addNodeType(ServiceTemplate serviceTemplate, String nodeTypeId,
 283                                  NodeType nodeType) {
 284
 285
 286     mdcDataDebugMessage.debugEntryMessage(null, null);
 287
 288     if (serviceTemplate == null) {
 289       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 290           LoggerTragetServiceName.ADD_ENTITIES_TO_TOSCA, ErrorLevel.ERROR.name(),
 291           LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_ADD_ACTION);
 292       throw new CoreException(
 293           new InvalidAddActionNullEntityErrorBuilder("Node Type", "Service Template").build());
 294     }
 295     if (serviceTemplate.getNode_types() == null) {
 296       serviceTemplate.setNode_types(new HashMap<>());
 297     }
 298     serviceTemplate.getNode_types().put(nodeTypeId, nodeType);
 299
 300     mdcDataDebugMessage.debugExitMessage(null, null);
 301   }
 302
 303   /**
 304    * Add relationship template.
 305    *
 306    * @param serviceTemplate        the service template
 307    * @param relationshipTemplateId the relationship template id
 308    * @param relationshipTemplate   the relationship template
 309    */
 310   public static void addRelationshipTemplate(ServiceTemplate serviceTemplate,
 311                                              String relationshipTemplateId,
 312                                              RelationshipTemplate relationshipTemplate) {
 313
 314
 315     mdcDataDebugMessage.debugEntryMessage(null, null);
 316
 317     if (serviceTemplate == null) {
 318       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 319           LoggerTragetServiceName.ADD_ENTITIES_TO_TOSCA, ErrorLevel.ERROR.name(),
 320           LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_ADD_ACTION);
 321       throw new CoreException(
 322           new InvalidAddActionNullEntityErrorBuilder("Relationship Template", "Service Template")
 323               .build());
 324     }
 325     if (serviceTemplate.getTopology_template() == null) {
 326       serviceTemplate.setTopology_template(new TopologyTemplate());
 327     }
 328     if (serviceTemplate.getTopology_template().getRelationship_templates() == null) {
 329       serviceTemplate.getTopology_template().setRelationship_templates(new HashMap<>());
 330     }
 331     serviceTemplate.getTopology_template().getRelationship_templates()
 332         .put(relationshipTemplateId, relationshipTemplate);
 333
 334     mdcDataDebugMessage.debugExitMessage(null, null);
 335   }
 336
 337   /**
 338    * Add requirement assignment.
 339    *
 340    * @param nodeTemplate          the node template
 341    * @param requirementId         the requirement id
 342    * @param requirementAssignment the requirement assignment
 343    */
 344   public static void addRequirementAssignment(NodeTemplate nodeTemplate, String requirementId,
 345                                               RequirementAssignment requirementAssignment) {
 346
 347
 348     mdcDataDebugMessage.debugEntryMessage(null, null);
 349
 350     if (nodeTemplate == null) {
 351       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 352           LoggerTragetServiceName.ADD_ENTITIES_TO_TOSCA, ErrorLevel.ERROR.name(),
 353           LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_ADD_ACTION);
 354       throw new CoreException(
 355           new InvalidAddActionNullEntityErrorBuilder("Requirement Assignment", "Node Template")
 356               .build());
 357     }
 358     if (requirementAssignment.getNode() == null) {
 359       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 360           LoggerTragetServiceName.ADD_ENTITIES_TO_TOSCA, ErrorLevel.ERROR.name(),
 361           LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_ADD_ACTION);
 362       throw new CoreException(new InvalidRequirementAssignmentErrorBuilder(requirementId).build());
 363     }
 364
 365     if (nodeTemplate.getRequirements() == null) {
 366       nodeTemplate.setRequirements(new ArrayList<>());
 367     }
 368     Map<String, RequirementAssignment> requirement = new HashMap<>();
 369     requirement.put(requirementId, requirementAssignment);
 370     nodeTemplate.getRequirements().add(requirement);
 371
 372     mdcDataDebugMessage.debugExitMessage(null, null);
 373   }
 374
 375   /**
 376    * Gets node template.
 377    *
 378    * @param serviceTemplate the service template
 379    * @param nodeTemplateId  the node template id
 380    * @return the node template
 381    */
 382   public static NodeTemplate getNodeTemplate(ServiceTemplate serviceTemplate,
 383                                              String nodeTemplateId) {
 384
 385     mdcDataDebugMessage.debugEntryMessage(null, null);
 386
 387     if (serviceTemplate == null
 388         || serviceTemplate.getTopology_template() == null
 389         || serviceTemplate.getTopology_template().getNode_templates() == null) {
 390       return null;
 391     }
 392
 393     mdcDataDebugMessage.debugExitMessage(null, null);
 394     return serviceTemplate.getTopology_template().getNode_templates().get(nodeTemplateId);
 395   }
 396
 397   /**
 398    * Gets node type.
 399    *
 400    * @param serviceTemplate the service template
 401    * @param nodeTypeId      the node type id
 402    * @return the node type
 403    */
 404   public static NodeType getNodeType(ServiceTemplate serviceTemplate, String nodeTypeId) {
 405
 406
 407     mdcDataDebugMessage.debugEntryMessage(null, null);
 408     if (serviceTemplate == null || serviceTemplate.getNode_types() == null) {
 409       return null;
 410     }
 411
 412     mdcDataDebugMessage.debugExitMessage(null, null);
 413     return serviceTemplate.getNode_types().get(nodeTypeId);
 414   }
 415
 416   /**
 417    * Gets requirement definition.
 418    *
 419    * @param nodeType                the node type
 420    * @param requirementDefinitionId the requirement definition id
 421    * @return the requirement definition
 422    */
 423   public static Optional<RequirementDefinition> getRequirementDefinition(
 424       NodeType nodeType,
 425       String requirementDefinitionId) {
 426
 427
 428     mdcDataDebugMessage.debugEntryMessage(null, null);
 429
 430     if (nodeType == null || nodeType.getRequirements() == null || requirementDefinitionId == null) {
 431       return Optional.empty();
 432     }
 433     for (Map<String, RequirementDefinition> reqMap : nodeType.getRequirements()) {
 434       if (reqMap.containsKey(requirementDefinitionId)) {
 435         return Optional.of(reqMap.get(requirementDefinitionId));
 436       }
 437     }
 438
 439     mdcDataDebugMessage.debugExitMessage(null, null);
 440     return Optional.empty();
 441   }
 442
 443   /**
 444    * get requirement defenition from requirement defenition list by req key.
 445    *
 446    * @param requirementsDefinitionList requirement defenition list
 447    * @param requirementKey             requirement key
 448    */
 449   public static Optional<RequirementDefinition> getRequirementDefinition(
 450       List<Map<String, RequirementDefinition>> requirementsDefinitionList,
 451       String requirementKey) {
 452     mdcDataDebugMessage.debugEntryMessage(null, null);
 453     if (CollectionUtils.isEmpty(requirementsDefinitionList)) {
 454       return Optional.empty();
 455     }
 456
 457     for (Map<String, RequirementDefinition> requirementMap : requirementsDefinitionList) {
 458       if (requirementMap.containsKey(requirementKey)) {
 459         mdcDataDebugMessage.debugExitMessage(null, null);
 460         return Optional.of(requirementMap.get(requirementKey));
 461       }
 462     }
 463
 464     mdcDataDebugMessage.debugExitMessage(null, null);
 465     return Optional.empty();
 466   }
 467
 468   /**
 469    * Gets capability definition.
 470    *
 471    * @param nodeType               the node type
 472    * @param capabilityDefinitionId the capability definition id
 473    * @return the capability definition
 474    */
 475   public static Optional<CapabilityDefinition> getCapabilityDefinition(
 476       NodeType nodeType,
 477       String capabilityDefinitionId) {
 478
 479
 480     mdcDataDebugMessage.debugEntryMessage(null, null);
 481
 482     if (nodeType == null || nodeType.getCapabilities() == null || capabilityDefinitionId == null) {
 483       return Optional.empty();
 484     }
 485
 486     mdcDataDebugMessage.debugExitMessage(null, null);
 487     return Optional.ofNullable(nodeType.getCapabilities().get(capabilityDefinitionId));
 488   }
 489
 490   /**
 491    * Add group definition to topology template.
 492    *
 493    * @param serviceTemplate the service template
 494    * @param groupName       the group name
 495    * @param group           the group
 496    */
 497   public static void addGroupDefinitionToTopologyTemplate(ServiceTemplate serviceTemplate,
 498                                                           String groupName, GroupDefinition group) {
 499
 500
 501     mdcDataDebugMessage.debugEntryMessage(null, null);
 502
 503     if (serviceTemplate == null) {
 504       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 505           LoggerTragetServiceName.ADD_ENTITIES_TO_TOSCA, ErrorLevel.ERROR.name(),
 506           LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_ADD_ACTION);
 507       throw new CoreException(
 508           new InvalidAddActionNullEntityErrorBuilder("Group Definition", "Service Template")
 509               .build());
 510     }
 511
 512     TopologyTemplate topologyTemplate = serviceTemplate.getTopology_template();
 513     if (Objects.isNull(topologyTemplate)) {
 514       topologyTemplate = new TopologyTemplate();
 515       serviceTemplate.setTopology_template(topologyTemplate);
 516     }
 517     if (topologyTemplate.getGroups() == null) {
 518       topologyTemplate.setGroups(new HashMap<>());
 519     }
 520     if (serviceTemplate.getTopology_template().getGroups() == null) {
 521       Map<String, GroupDefinition> groups = new HashMap<>();
 522       serviceTemplate.getTopology_template().setGroups(groups);
 523     }
 524
 525     serviceTemplate.getTopology_template().getGroups().put(groupName, group);
 526     mdcDataDebugMessage.debugExitMessage(null, null);
 527   }
 528
 529   /**
 530    * Create property definition property definition.
 531    *
 532    * @param type        the type
 533    * @param description the description
 534    * @param required    the required
 535    * @param constraints the constraints
 536    * @param status      the status
 537    * @param entrySchema the entry schema
 538    * @param defaultVal  the default val
 539    * @return the property definition
 540    */
 541   public static PropertyDefinition createPropertyDefinition(String type, String description,
 542                                                             boolean required,
 543                                                             List<Constraint> constraints,
 544                                                             Status status,
 545                                                             EntrySchema entrySchema,
 546                                                             Object defaultVal) {
 547
 548
 549     mdcDataDebugMessage.debugEntryMessage(null, null);
 550
 551     PropertyDefinition propDef = new PropertyDefinition();
 552     propDef.setType(type);
 553     propDef.setDescription(description);
 554     propDef.setRequired(required);
 555     propDef.setConstraints(constraints);
 556     if (status != null) {
 557       propDef.setStatus(status);
 558     }
 559     propDef.setEntry_schema(entrySchema);
 560     propDef.set_default(defaultVal);
 561
 562     mdcDataDebugMessage.debugExitMessage(null, null);
 563     return propDef;
 564   }
 565
 566   /**
 567    * Create parameter definition property definition.
 568    *
 569    * @param type        the type
 570    * @param description the description
 571    * @param value       the value
 572    * @param required    the required
 573    * @param constraints the constraints
 574    * @param status      the status
 575    * @param entrySchema the entry schema
 576    * @param defaultVal  the default val
 577    * @return the property definition
 578    */
 579   public static ParameterDefinition createParameterDefinition(String type, String description,
 580                                                               Object value, boolean required,
 581                                                               List<Constraint> constraints,
 582                                                               Status status,
 583                                                               EntrySchema entrySchema,
 584                                                               Object defaultVal) {
 585
 586
 587     mdcDataDebugMessage.debugEntryMessage(null, null);
 588
 589     ParameterDefinition paramDef = new ParameterDefinition();
 590     paramDef.setType(type);
 591     paramDef.setDescription(description);
 592     paramDef.setValue(value);
 593     paramDef.setRequired(required);
 594     paramDef.setConstraints(constraints);
 595     if (status != null) {
 596       paramDef.setStatus(status);
 597     }
 598     paramDef.setEntry_schema(entrySchema == null ? null : entrySchema.clone());
 599     paramDef.set_default(defaultVal);
 600
 601     mdcDataDebugMessage.debugExitMessage(null, null);
 602     return paramDef;
 603   }
 604
 605   /**
 606    * Create requirement requirement definition.
 607    *
 608    * @param capability   the capability
 609    * @param node         the node
 610    * @param relationship the relationship
 611    * @param occurrences  the occurrences
 612    * @return the requirement definition
 613    */
 614   public static RequirementDefinition createRequirement(String capability, String node,
 615                                                         String relationship, Object[] occurrences) {
 616
 617
 618     mdcDataDebugMessage.debugEntryMessage(null, null);
 619
 620     RequirementDefinition requirementDefinition = new RequirementDefinition();
 621     requirementDefinition.setCapability(capability);
 622     requirementDefinition.setNode(node);
 623     requirementDefinition.setRelationship(relationship);
 624     if (occurrences != null) {
 625       requirementDefinition.setOccurrences(occurrences);
 626     }
 627
 628     mdcDataDebugMessage.debugExitMessage(null, null);
 629     return requirementDefinition;
 630   }
 631
 632   /**
 633    * Create attribute definition attribute definition.
 634    *
 635    * @param type        the type
 636    * @param description the description
 637    * @param status      the status
 638    * @param entrySchema the entry schema
 639    * @param defaultVal  the default val
 640    * @return the attribute definition
 641    */
 642   public static AttributeDefinition createAttributeDefinition(String type, String description,
 643                                                               Status status,
 644                                                               EntrySchema entrySchema,
 645                                                               Object defaultVal) {
 646
 647
 648     mdcDataDebugMessage.debugEntryMessage(null, null);
 649
 650     AttributeDefinition attributeDef = new AttributeDefinition();
 651     attributeDef.setType(type);
 652
 653     if (description != null) {
 654       attributeDef.setDescription(description);
 655     }
 656     if (status != null) {
 657       attributeDef.setStatus(status);
 658     }
 659     attributeDef.setEntry_schema(entrySchema);
 660     attributeDef.set_default(defaultVal);
 661
 662     mdcDataDebugMessage.debugExitMessage(null, null);
 663     return attributeDef;
 664   }
 665
 666   /**
 667    * Create valid values constraint constraint.
 668    *
 669    * @param values the values
 670    * @return the constraint
 671    */
 672   public static Constraint createValidValuesConstraint(Object... values) {
 673
 674
 675     mdcDataDebugMessage.debugEntryMessage(null, null);
 676
 677     Constraint validValues = new Constraint();
 678     for (Object value : values) {
 679       validValues.addValidValue(value);
 680     }
 681
 682     mdcDataDebugMessage.debugExitMessage(null, null);
 683     return validValues;
 684   }
 685
 686   /**
 687    * Create metadata metadata.
 688    *
 689    * @param templateName    the template name
 690    * @param templateVersion the template version
 691    * @param templateAuthor  the template author
 692    * @return the metadata
 693    */
 694   public static Map<String, String> createMetadata(String templateName, String templateVersion,
 695                                         String templateAuthor) {
 696
 697
 698     mdcDataDebugMessage.debugEntryMessage(null, null);
 699     Map<String, String> metadata = new HashMap<>();
 700     metadata.put(ToscaConstants.ST_METADATA_TEMPLATE_NAME, templateName);
 701     metadata.put("template_version", templateVersion);
 702     metadata.put("template_author", templateAuthor);
 703
 704     mdcDataDebugMessage.debugExitMessage(null, null);
 705     return metadata;
 706   }
 707
 708   /**
 709    * Create entry schema entry schema.
 710    *
 711    * @param type        the type
 712    * @param description the description
 713    * @param constraints the constraints
 714    * @return the entry schema
 715    */
 716   public static EntrySchema createEntrySchema(String type, String description,
 717                                               List<Constraint> constraints) {
 718
 719
 720     mdcDataDebugMessage.debugEntryMessage(null, null);
 721
 722     if(Objects.isNull(type) && Objects.isNull(description) && CollectionUtils.isEmpty(constraints)){
 723       return null;
 724     }
 725
 726     EntrySchema entrySchema = new EntrySchema();
 727     entrySchema.setType(type);
 728     entrySchema.setDescription(description);
 729     entrySchema.setConstraints(constraints);
 730
 731     mdcDataDebugMessage.debugExitMessage(null, null);
 732     return entrySchema;
 733   }
 734
 735   /**
 736    * Create valid values constraints list list.
 737    *
 738    * @param values the values
 739    * @return the list
 740    */
 741   public static List<Constraint> createValidValuesConstraintsList(String... values) {
 742
 743
 744     mdcDataDebugMessage.debugEntryMessage(null, null);
 745
 746     List<Constraint> constraints;
 747     Constraint validValues;
 748     constraints = new ArrayList<>();
 749     validValues = DataModelUtil.createValidValuesConstraint(values);
 750     constraints.add(validValues);
 751
 752     mdcDataDebugMessage.debugExitMessage(null, null);
 753     return constraints;
 754   }
 755
 756   /**
 757    * Create greater or equal constrain constraint.
 758    *
 759    * @param value the value
 760    * @return the constraint
 761    */
 762   public static Constraint createGreaterOrEqualConstrain(Object value) {
 763     mdcDataDebugMessage.debugEntryMessage(null, null);
 764
 765     Constraint constraint = new Constraint();
 766     constraint.setGreater_or_equal(value);
 767
 768     mdcDataDebugMessage.debugExitMessage(null, null);
 769     return constraint;
 770   }
 771
 772   /**
 773    * Gets constrain list.
 774    *
 775    * @param constrains the constrains
 776    * @return the constrain list
 777    */
 778   public static List<Constraint> getConstrainList(Constraint... constrains) {
 779     return Arrays.asList(constrains);
 780
 781   }
 782
 783   /**
 784    * Create get input property value from list parameter map.
 785    *
 786    * @param inputPropertyListName the input property list name
 787    * @param indexInTheList        the index in the list
 788    * @param nestedPropertyName    the nested property name
 789    * @return the map
 790    */
 791   public static Map createGetInputPropertyValueFromListParameter(String inputPropertyListName,
 792                                                                  int indexInTheList,
 793                                                                  String... nestedPropertyName) {
 794
 795
 796     mdcDataDebugMessage.debugEntryMessage(null, null);
 797
 798     List propertyList = new ArrayList<>();
 799     propertyList.add(inputPropertyListName);
 800     propertyList.add(indexInTheList);
 801     if (nestedPropertyName != null) {
 802       Collections.addAll(propertyList, nestedPropertyName);
 803     }
 804     Map getInputProperty = new HashMap<>();
 805     getInputProperty.put(ToscaFunctions.GET_INPUT.getDisplayName(), propertyList);
 806
 807     mdcDataDebugMessage.debugExitMessage(null, null);
 808     return getInputProperty;
 809   }
 810
 811   /**
 812    * Convert property def to parameter def parameter definition ext.
 813    *
 814    * @param propertyDefinition the property definition
 815    * @return the parameter definition ext
 816    */
 817   public static ParameterDefinitionExt convertPropertyDefToParameterDef(
 818       PropertyDefinition propertyDefinition) {
 819
 820
 821     mdcDataDebugMessage.debugEntryMessage(null, null);
 822
 823     if (propertyDefinition == null) {
 824       return null;
 825     }
 826
 827     ParameterDefinitionExt parameterDefinition = new ParameterDefinitionExt();
 828     parameterDefinition.setType(propertyDefinition.getType());
 829     parameterDefinition.setDescription(propertyDefinition.getDescription());
 830     parameterDefinition.setRequired(propertyDefinition.getRequired());
 831     parameterDefinition.set_default(propertyDefinition.get_default());
 832     parameterDefinition.setStatus(propertyDefinition.getStatus());
 833     parameterDefinition.setConstraints(propertyDefinition.getConstraints());
 834     parameterDefinition.setEntry_schema(Objects.isNull(propertyDefinition.getEntry_schema()) ? null
 835         : propertyDefinition.getEntry_schema().clone());
 836     parameterDefinition.setHidden(false);
 837     parameterDefinition.setImmutable(false);
 838
 839     mdcDataDebugMessage.debugExitMessage(null, null);
 840     return parameterDefinition;
 841   }
 842
 843   /**
 844    * Convert attribute def to parameter def parameter definition ext.
 845    *
 846    * @param attributeDefinition the attribute definition
 847    * @param outputValue         the output value
 848    * @return the parameter definition ext
 849    */
 850   public static ParameterDefinitionExt convertAttributeDefToParameterDef(
 851       AttributeDefinition attributeDefinition, Map<String, List> outputValue) {
 852
 853
 854     mdcDataDebugMessage.debugEntryMessage(null, null);
 855
 856     if (attributeDefinition == null) {
 857       return null;
 858     }
 859     ParameterDefinitionExt parameterDefinition = new ParameterDefinitionExt();
 860     parameterDefinition.setDescription(attributeDefinition.getDescription());
 861     parameterDefinition.setValue(outputValue);
 862
 863     mdcDataDebugMessage.debugExitMessage(null, null);
 864     return parameterDefinition;
 865   }
 866
 867   /**
 868    * Convert capability type to capability definition capability definition.
 869    *
 870    * @param capabilityTypeId the capability type id
 871    * @param capabilityType   the capability type
 872    * @param properties       the properties
 873    * @return the capability definition
 874    */
 875   public static CapabilityDefinition convertCapabilityTypeToCapabilityDefinition(
 876       String capabilityTypeId, CapabilityType capabilityType, Map<String, Object> properties) {
 877
 878
 879     mdcDataDebugMessage.debugEntryMessage(null, null);
 880
 881     CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
 882     capabilityDefinition.setAttributes(cloneAttributeDefinitionMap(capabilityType.getAttributes()));
 883     capabilityDefinition.setProperties(clonePropertyDefinitionMap(capabilityType.getProperties()));
 884     capabilityDefinition.setDescription(capabilityType.getDescription());
 885     capabilityDefinition.setType(capabilityTypeId);
 886
 887     capabilityDefinition.getProperties()
 888         .entrySet()
 889         .stream()
 890         .filter(entry -> properties.containsKey(entry.getKey()))
 891         .forEach(entry -> entry.getValue()
 892             .set_default(properties.get(entry.getKey())));
 893
 894     mdcDataDebugMessage.debugExitMessage(null, null);
 895     return capabilityDefinition;
 896   }
 897
 898   /**
 899    * Clone property definition map map.
 900    *
 901    * @param propertyDefinitionMap the property definition map
 902    * @return the map
 903    */
 904   public static Map clonePropertyDefinitionMap(
 905       Map<String, PropertyDefinition> propertyDefinitionMap) {
 906
 907
 908     mdcDataDebugMessage.debugEntryMessage(null, null);
 909
 910     Map outMap = new HashMap<>();
 911     for (String propertyDefKey : propertyDefinitionMap.keySet()) {
 912       PropertyDefinition propertyDefValue = propertyDefinitionMap.get(propertyDefKey);
 913       outMap.put(new String(propertyDefKey), propertyDefValue.clone());
 914     }
 915
 916     mdcDataDebugMessage.debugExitMessage(null, null);
 917     return outMap;
 918   }
 919
 920   /**
 921    * Clone attribute definition map map.
 922    *
 923    * @param attributeDefinitionMap the attribute definition map
 924    * @return the map
 925    */
 926   public static Map cloneAttributeDefinitionMap(
 927       Map<String, AttributeDefinition> attributeDefinitionMap) {
 928
 929
 930     mdcDataDebugMessage.debugEntryMessage(null, null);
 931
 932     Map outMap = new HashMap<>();
 933     for (String attributeDefKey : attributeDefinitionMap.keySet()) {
 934       AttributeDefinition attributeDefinition = attributeDefinitionMap.get(attributeDefKey);
 935       outMap.put(new String(attributeDefKey), attributeDefinition.clone());
 936     }
 937
 938     mdcDataDebugMessage.debugExitMessage(null, null);
 939     return outMap;
 940   }
 941
 942   public static boolean isNodeTemplate(String entryId, ServiceTemplate serviceTemplate) {
 943     return serviceTemplate.getTopology_template().getNode_templates() != null
 944         && serviceTemplate.getTopology_template().getNode_templates().get(entryId) != null;
 945   }
 946
 947   /**
 948    * Add Input parameter.
 949    *
 950    * @param serviceTemplate       the service template
 951    * @param parameterDefinitionId the parameter definition id
 952    * @param parameterDefinition   the parameter definition
 953    */
 954   public static void addInputParameterToTopologyTemplate(ServiceTemplate serviceTemplate,
 955                                                          String parameterDefinitionId,
 956                                                          ParameterDefinition parameterDefinition) {
 957
 958
 959     mdcDataDebugMessage.debugEntryMessage(null, null);
 960
 961     if (Objects.isNull(serviceTemplate)) {
 962       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 963           LoggerTragetServiceName.ADD_ENTITIES_TO_TOSCA, ErrorLevel.ERROR.name(),
 964           LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_ADD_ACTION);
 965       throw new CoreException(
 966           new InvalidAddActionNullEntityErrorBuilder("Topology Template Input Parameter",
 967               "Service Template").build());
 968     }
 969     TopologyTemplate topologyTemplate = serviceTemplate.getTopology_template();
 970     if (Objects.isNull(topologyTemplate)) {
 971       topologyTemplate = new TopologyTemplate();
 972       serviceTemplate.setTopology_template(topologyTemplate);
 973     }
 974     if (topologyTemplate.getInputs() == null) {
 975       topologyTemplate.setInputs(new HashMap<>());
 976     }
 977     topologyTemplate.getInputs().put(parameterDefinitionId, parameterDefinition);
 978
 979     mdcDataDebugMessage.debugExitMessage(null, null);
 980
 981   }
 982
 983   /**
 984    * Add Output parameter.
 985    *
 986    * @param serviceTemplate       the service template
 987    * @param parameterDefinitionId the parameter definition id
 988    * @param parameterDefinition   the parameter definition
 989    */
 990   public static void addOutputParameterToTopologyTemplate(ServiceTemplate serviceTemplate,
 991                                                           String parameterDefinitionId,
 992                                                           ParameterDefinition parameterDefinition) {
 993
 994
 995     mdcDataDebugMessage.debugEntryMessage(null, null);
 996
 997     if (Objects.isNull(serviceTemplate)) {
 998       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 999           LoggerTragetServiceName.ADD_ENTITIES_TO_TOSCA, ErrorLevel.ERROR.name(),
1000           LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_ADD_ACTION);
1001       throw new CoreException(
1002           new InvalidAddActionNullEntityErrorBuilder("Topology Template Ouput Parameter",
1003               "Service Template").build());
1004     }
1005     TopologyTemplate topologyTemplate = serviceTemplate.getTopology_template();
1006     if (Objects.isNull(topologyTemplate)) {
1007       topologyTemplate = new TopologyTemplate();
1008       serviceTemplate.setTopology_template(topologyTemplate);
1009     }
1010     if (topologyTemplate.getOutputs() == null) {
1011       topologyTemplate.setOutputs(new HashMap<>());
1012     }
1013     topologyTemplate.getOutputs().put(parameterDefinitionId, parameterDefinition);
1014
1015     mdcDataDebugMessage.debugExitMessage(null, null);
1016
1017   }
1018
1019   /**
1020    * Add requirement def to requirement def list.
1021    *
1022    * @param requirementList requirement list
1023    * @param requirementDef  added requirement def
1024    */
1025   public static void addRequirementToList(List<Map<String, RequirementDefinition>> requirementList,
1026                                           Map<String, RequirementDefinition> requirementDef) {
1027     if (requirementDef == null) {
1028       return;
1029     }
1030     if (requirementList == null) {
1031       requirementList = new ArrayList<Map<String, RequirementDefinition>>();
1032     }
1033
1034     for (Map.Entry<String, RequirementDefinition> entry : requirementDef.entrySet()) {
1035       CommonMethods.mergeEntryInList(entry.getKey(), entry.getValue(), requirementList);
1036     }
1037   }
1038
1039   /**
1040    * get node template requirement.
1041    *
1042    * @param nodeTemplate node template
1043    */
1044   public static Map<String, RequirementAssignment> getNodeTemplateRequirements(
1045       NodeTemplate nodeTemplate) {
1046     mdcDataDebugMessage.debugEntryMessage(null, null);
1047
1048     if (Objects.isNull(nodeTemplate)) {
1049       return null;
1050     }
1051     List<Map<String, RequirementAssignment>> templateRequirements = nodeTemplate.getRequirements();
1052
1053     Map<String, RequirementAssignment> nodeTemplateRequirementsAssignment = new HashMap<>();
1054     if (CollectionUtils.isEmpty(templateRequirements)) {
1055       return nodeTemplateRequirementsAssignment;
1056     }
1057     YamlUtil yamlUtil = new YamlUtil();
1058     for (Map<String, RequirementAssignment> requirementAssignmentMap : templateRequirements) {
1059       for (Map.Entry<String, RequirementAssignment> requirementEntry : requirementAssignmentMap
1060           .entrySet()) {
1061         RequirementAssignment requirementAssignment = (yamlUtil
1062             .yamlToObject(yamlUtil.objectToYaml(requirementEntry.getValue()),
1063                 RequirementAssignment.class));
1064         nodeTemplateRequirementsAssignment
1065             .put(requirementEntry.getKey(), requirementAssignment);
1066       }
1067     }
1068
1069     mdcDataDebugMessage.debugExitMessage(null, null);
1070     return nodeTemplateRequirementsAssignment;
1071   }
1072
1073   /**
1074    * Gets the list of requirements for the node template.
1075    *
1076    * @param nodeTemplate the node template
1077    * @return the node template requirement list and null if the node has no requirements
1078    */
1079   public static List<Map<String, RequirementAssignment>> getNodeTemplateRequirementList(
1080       NodeTemplate nodeTemplate) {
1081     mdcDataDebugMessage.debugEntryMessage(null, null);
1082     ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
1083     //Creating concrete objects
1084     List<Map<String, RequirementAssignment>> requirements = nodeTemplate.getRequirements();
1085     List<Map<String, RequirementAssignment>> concreteRequirementList = null;
1086     if (requirements != null) {
1087       concreteRequirementList = new ArrayList<>();
1088       ListIterator<Map<String, RequirementAssignment>> reqListIterator = requirements
1089           .listIterator();
1090       while (reqListIterator.hasNext()) {
1091         Map<String, RequirementAssignment> requirement = reqListIterator.next();
1092         Map<String, RequirementAssignment> concreteRequirement = new HashMap<>();
1093         for (Map.Entry<String, RequirementAssignment> reqEntry : requirement.entrySet()) {
1094           RequirementAssignment requirementAssignment = (toscaExtensionYamlUtil
1095               .yamlToObject(toscaExtensionYamlUtil.objectToYaml(reqEntry.getValue()),
1096                   RequirementAssignment.class));
1097           concreteRequirement.put(reqEntry.getKey(), requirementAssignment);
1098           concreteRequirementList.add(concreteRequirement);
1099           reqListIterator.remove();
1100         }
1101       }
1102       requirements.clear();
1103       requirements.addAll(concreteRequirementList);
1104       nodeTemplate.setRequirements(requirements);
1105     }
1106     mdcDataDebugMessage.debugExitMessage(null, null);
1107     return concreteRequirementList;
1108   }
1109
1110   /**
1111    * get requirement assignment from requirement assignment list by req key.
1112    *
1113    * @param requirementsAssignmentList requirement defenition list
1114    * @param requirementKey             requirement key
1115    */
1116   public static Optional<List<RequirementAssignment>> getRequirementAssignment(
1117       List<Map<String, RequirementAssignment>> requirementsAssignmentList,
1118       String requirementKey) {
1119
1120     mdcDataDebugMessage.debugEntryMessage(null, null);
1121     if (CollectionUtils.isEmpty(requirementsAssignmentList)) {
1122       return Optional.empty();
1123     }
1124
1125     List<RequirementAssignment> matchRequirementAssignmentList = new ArrayList<>();
1126     for (Map<String, RequirementAssignment> requirementMap : requirementsAssignmentList) {
1127       if (requirementMap.containsKey(requirementKey)) {
1128         YamlUtil yamlUtil = new YamlUtil();
1129         RequirementAssignment requirementAssignment = (yamlUtil
1130             .yamlToObject(yamlUtil.objectToYaml(requirementMap.get(requirementKey)),
1131                 RequirementAssignment.class));
1132         matchRequirementAssignmentList.add(requirementAssignment);
1133       }
1134     }
1135
1136     mdcDataDebugMessage.debugExitMessage(null, null);
1137     return Optional.ofNullable(matchRequirementAssignmentList);
1138   }
1139
1140   /**
1141    * remove requirement defenition from requirement defenition list by req key.
1142    *
1143    * @param requirementsDefinitionList requirement defenition list
1144    * @param requirementKey             requirement key
1145    */
1146   public static void removeRequirementsDefinition(
1147       List<Map<String, RequirementDefinition>> requirementsDefinitionList,
1148       String requirementKey) {
1149     mdcDataDebugMessage.debugEntryMessage(null, null);
1150     if (requirementsDefinitionList == null) {
1151       return;
1152     }
1153
1154     List<Map<String, RequirementDefinition>> mapToBeRemoved = new ArrayList<>();
1155     for (Map<String, RequirementDefinition> reqMap : requirementsDefinitionList) {
1156       reqMap.remove(requirementKey);
1157       if (reqMap.isEmpty()) {
1158         mapToBeRemoved.add(reqMap);
1159       }
1160     }
1161     for (Map<String, RequirementDefinition> removeMap : mapToBeRemoved) {
1162       requirementsDefinitionList.remove(removeMap);
1163     }
1164
1165     mdcDataDebugMessage.debugExitMessage(null, null);
1166   }
1167
1168   /**
1169    * remove requirement assignment from requirement defenition list by req key.
1170    *
1171    * @param requirementsAssignmentList requirement Assignment list
1172    * @param requirementKey             requirement key
1173    */
1174   public static void removeRequirementsAssignment(
1175       List<Map<String, RequirementAssignment>> requirementsAssignmentList,
1176       String requirementKey) {
1177     mdcDataDebugMessage.debugEntryMessage(null, null);
1178     if (requirementsAssignmentList == null) {
1179       return;
1180     }
1181
1182     List<Map<String, RequirementAssignment>> mapToBeRemoved = new ArrayList<>();
1183     for (Map<String, RequirementAssignment> reqMap : requirementsAssignmentList) {
1184       reqMap.remove(requirementKey);
1185       if (reqMap.isEmpty()) {
1186         mapToBeRemoved.add(reqMap);
1187       }
1188     }
1189     for (Map<String, RequirementAssignment> removeMap : mapToBeRemoved) {
1190       requirementsAssignmentList.remove(removeMap);
1191     }
1192
1193     mdcDataDebugMessage.debugExitMessage(null, null);
1194   }
1195
1196
1197   /**
1198    * Remove requirement assignment.
1199    *
1200    * @param nodeTemplate                     the node template
1201    * @param requirementKey                   the requirement key
1202    * @param requirementAssignmentToBeDeleted the requirement assignment to be deleted
1203    */
1204   public static void removeRequirementAssignment(
1205       NodeTemplate nodeTemplate,
1206       String requirementKey,
1207       RequirementAssignment requirementAssignmentToBeDeleted) {
1208     mdcDataDebugMessage.debugEntryMessage(null, null);
1209     ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
1210     List<Map<String, RequirementAssignment>> nodeTemplateRequirements = nodeTemplate
1211         .getRequirements();
1212     if (nodeTemplateRequirements == null) {
1213       return;
1214     }
1215
1216     Map<String, RequirementAssignment> mapToBeRemoved = new HashMap<>();
1217     ListIterator<Map<String, RequirementAssignment>> iter = nodeTemplateRequirements.listIterator();
1218     while (iter.hasNext()) {
1219       Map<String, RequirementAssignment> reqMap = iter.next();
1220       RequirementAssignment requirementAssignment = reqMap.get(requirementKey);
1221       if (requirementAssignment != null) {
1222         boolean isDesiredRequirementAssignment = toscaAnalyzerService
1223             .isDesiredRequirementAssignment(requirementAssignment,
1224                 requirementAssignmentToBeDeleted.getCapability(),
1225                 requirementAssignmentToBeDeleted.getNode(),
1226                 requirementAssignmentToBeDeleted.getRelationship());
1227         if (isDesiredRequirementAssignment) {
1228           iter.remove();
1229         }
1230       }
1231     }
1232
1233     mdcDataDebugMessage.debugExitMessage(null, null);
1234   }
1235
1236   /**
1237    * Return the suffix of the input namespace
1238    * For an exmpale - for abc.sdf.vsrx, retrun vsrx
1239    *
1240    * @param namespace namespace
1241    * @return String namespace suffix
1242    */
1243   public static String getNamespaceSuffix(String namespace) {
1244     if (namespace == null) {
1245       return null;
1246     }
1247     String delimiterChar = ".";
1248     if (namespace.contains(delimiterChar)) {
1249       return namespace.substring(namespace.lastIndexOf(delimiterChar) + 1);
1250     }
1251     return namespace;
1252   }
1253
1254   /**
1255    * Return true if the input import exist in the input imports list.
1256    *
1257    * @param imports  namespace
1258    * @param importId namespace
1259    * @return true if exist, flase if not exist
1260    */
1261   public static boolean isImportAddedToServiceTemplate(List<Map<String, Import>> imports,
1262                                                        String importId) {
1263     for (Map<String, Import> anImport : imports) {
1264       if (anImport.containsKey(importId)) {
1265         return true;
1266       }
1267     }
1268     return false;
1269   }
1270
1271   /**
1272    * Get output parameter according to the input outputParameterId.
1273    *
1274    * @param serviceTemplate   service template
1275    * @param outputParameterId output parameter id
1276    * @return ParameterDefinition - output parameter
1277    */
1278   public static ParameterDefinition getOuputParameter(ServiceTemplate serviceTemplate,
1279                                                       String outputParameterId) {
1280     mdcDataDebugMessage.debugEntryMessage(null, null);
1281
1282     if (serviceTemplate == null
1283         || serviceTemplate.getTopology_template() == null
1284         || serviceTemplate.getTopology_template().getOutputs() == null) {
1285       return null;
1286     }
1287
1288     mdcDataDebugMessage.debugExitMessage(null, null);
1289     return serviceTemplate.getTopology_template().getOutputs().get(outputParameterId);
1290   }
1291
1292   /**
1293    * Gets input parameters in a service template.
1294    *
1295    * @param serviceTemplate the service template
1296    * @return the input parameters
1297    */
1298   public static Map<String, ParameterDefinition> getInputParameters(ServiceTemplate
1299                                                                         serviceTemplate) {
1300     if (serviceTemplate == null
1301         || serviceTemplate.getTopology_template() == null
1302         || serviceTemplate.getTopology_template().getInputs() == null) {
1303       return null;
1304     }
1305     return serviceTemplate.getTopology_template().getInputs();
1306   }
1307
1308   /**
1309    * Gets relationship templates in a service template.
1310    *
1311    * @param serviceTemplate the service template
1312    * @return the relationship template
1313    */
1314   public static Map<String, RelationshipTemplate> getRelationshipTemplates(ServiceTemplate
1315                                                                         serviceTemplate) {
1316     if (serviceTemplate == null
1317         || serviceTemplate.getTopology_template() == null
1318         || serviceTemplate.getTopology_template().getRelationship_templates() == null) {
1319       return null;
1320     }
1321     return serviceTemplate.getTopology_template().getRelationship_templates();
1322   }
1323
1324   /**
1325    * Get property value according to the input propertyId.
1326    *
1327    * @param nodeTemplate node template
1328    * @param propertyId   property id
1329    * @return Object        property Value
1330    */
1331   public static Object getPropertyValue(NodeTemplate nodeTemplate,
1332                                         String propertyId) {
1333     mdcDataDebugMessage.debugEntryMessage(null, null);
1334
1335     if (nodeTemplate == null
1336         || nodeTemplate.getProperties() == null) {
1337       return null;
1338     }
1339
1340     mdcDataDebugMessage.debugExitMessage(null, null);
1341     return nodeTemplate.getProperties().get(propertyId);
1342   }
1343
1344   /**
1345    * Get node template properties according to the input node template id.
1346    *
1347    * @param serviceTemplate       service template
1348    * @param nodeTemplateId        node template id
1349    * @return node template properties
1350    */
1351   public static Map<String, Object> getNodeTemplateProperties(ServiceTemplate serviceTemplate,
1352                                                               String nodeTemplateId) {
1353     mdcDataDebugMessage.debugEntryMessage(null, null);
1354
1355     if (serviceTemplate == null
1356         || serviceTemplate.getTopology_template() == null
1357         || serviceTemplate.getTopology_template().getNode_templates() == null
1358         || serviceTemplate.getTopology_template().getNode_templates().get(nodeTemplateId) == null) {
1359       return null;
1360     }
1361
1362     mdcDataDebugMessage.debugExitMessage(null, null);
1363     return serviceTemplate.getTopology_template().getNode_templates().get(nodeTemplateId)
1364         .getProperties();
1365   }
1366
1367   /**
1368    * Compare two requirement assignment objects for equality.
1369    *
1370    * @param first  the first requirement assignement object
1371    * @param second the second  requirement assignement object
1372    * @return true if objects are equal and false otherwise
1373    */
1374   public static boolean compareRequirementAssignment(RequirementAssignment first,
1375                                                      RequirementAssignment second) {
1376     if (first.getCapability().equals(second.getCapability())
1377         && first.getNode().equals(second.getNode())
1378         && first.getRelationship().equals(second.getRelationship())) {
1379       return true;
1380     }
1381     return false;
1382   }
1383 }