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.vendorsoftwareproduct.impl;
  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.json.JsonSchemaDataGenerator;
  27 import org.openecomp.core.utilities.json.JsonUtil;
  28 import org.openecomp.sdc.common.errors.CoreException;
  29 import org.openecomp.sdc.common.errors.ErrorCategory;
  30 import org.openecomp.sdc.common.errors.ErrorCode;
  31 import org.openecomp.sdc.logging.api.Logger;
  32 import org.openecomp.sdc.logging.api.LoggerFactory;
  33 import org.openecomp.sdc.vendorsoftwareproduct.CompositionEntityDataManager;
  34 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDao;
  35 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComputeDao;
  36 import org.openecomp.sdc.vendorsoftwareproduct.dao.DeploymentFlavorDao;
  37 import org.openecomp.sdc.vendorsoftwareproduct.dao.ImageDao;
  38 import org.openecomp.sdc.vendorsoftwareproduct.dao.NetworkDao;
  39 import org.openecomp.sdc.vendorsoftwareproduct.dao.NicDao;
  40 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
  41 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentEntity;
  42 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.CompositionEntity;
  43 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComputeEntity;
  44 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.DeploymentFlavorEntity;
  45 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ImageEntity;
  46 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.NetworkEntity;
  47 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.NicEntity;
  48 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
  49 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspQuestionnaireEntity;
  50 import org.openecomp.sdc.vendorsoftwareproduct.services.schemagenerator.SchemaGenerator;
  51 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Component;
  52 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ComponentData;
  53 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionData;
  54 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityId;
  55 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityType;
  56 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityValidationData;
  57 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ComputeData;
  58 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Image;
  59 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Network;
  60 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.NetworkType;
  61 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Nic;
  62 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.SchemaTemplateContext;
  63 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.SchemaTemplateInput;
  64 import org.openecomp.sdc.versioning.dao.types.Version;
  65
  66 import java.util.ArrayList;
  67 import java.util.Collection;
  68 import java.util.Collections;
  69 import java.util.HashMap;
  70 import java.util.HashSet;
  71 import java.util.List;
  72 import java.util.Map;
  73 import java.util.Objects;
  74 import java.util.Set;
  75
  76 public class CompositionEntityDataManagerImpl implements CompositionEntityDataManager {
  77
  78   private static final String COMPOSITION_ENTITY_DATA_MANAGER_ERR =
  79       "COMPOSITION_ENTITY_DATA_MANAGER_ERR";
  80   private static final String COMPOSITION_ENTITY_DATA_MANAGER_ERR_MSG =
  81       "Invalid input: %s may not be null";
  82   private static final String MISSING_OR_INVALID_QUESTIONNAIRE_MSG =
  83       "Data is missing/invalid for this %s. Please refill and resubmit.";
  84
  85   private static final Logger logger =
  86       LoggerFactory.getLogger(CompositionEntityDataManagerImpl.class);
  87   private Map<CompositionEntityId, CompositionEntityData> entities = new HashMap<>();
  88   private Map<CompositionEntityType, String> nonDynamicSchemas = new HashMap<>();
  89   private List<CompositionEntityValidationData> roots = new ArrayList<>();
  90
  91   private VendorSoftwareProductInfoDao vspInfoDao;
  92   private ComponentDao componentDao;
  93   private NicDao nicDao;
  94   private NetworkDao networkDao;
  95   private ImageDao imageDao;
  96   private ComputeDao computeDao;
  97   private DeploymentFlavorDao deploymentFlavorDao;
  98
  99   public CompositionEntityDataManagerImpl(VendorSoftwareProductInfoDao vspInfoDao,
 100                                           ComponentDao componentDao,
 101                                           NicDao nicDao, NetworkDao networkDao,
 102                                           ImageDao imageDao, ComputeDao computeDao,
 103                                           DeploymentFlavorDao deploymentFlavorDao) {
 104     this.vspInfoDao = vspInfoDao;
 105     this.componentDao = componentDao;
 106     this.nicDao = nicDao;
 107     this.networkDao = networkDao;
 108     this.imageDao = imageDao;
 109     this.computeDao = computeDao;
 110     this.deploymentFlavorDao = deploymentFlavorDao;
 111   }
 112
 113   /**
 114    * Validate entity composition entity validation data.
 115    *
 116    * @param entity                the entity
 117    * @param schemaTemplateContext the schema template context
 118    * @param schemaTemplateInput   the schema template input
 119    * @return the composition entity validation data
 120    */
 121   @Override
 122   public CompositionEntityValidationData validateEntity(CompositionEntity entity,
 123                                                         SchemaTemplateContext schemaTemplateContext,
 124                                                         SchemaTemplateInput schemaTemplateInput) {
 125     if (entity == null) {
 126       throw new CoreException(
 127           new ErrorCode.ErrorCodeBuilder().withCategory(ErrorCategory.APPLICATION)
 128               .withId(COMPOSITION_ENTITY_DATA_MANAGER_ERR).withMessage(
 129               String.format(COMPOSITION_ENTITY_DATA_MANAGER_ERR_MSG, "composition entity"))
 130               .build());
 131     }
 132     if (schemaTemplateContext == null) {
 133       throw new CoreException(
 134           new ErrorCode.ErrorCodeBuilder().withCategory(ErrorCategory.APPLICATION)
 135               .withId(COMPOSITION_ENTITY_DATA_MANAGER_ERR).withMessage(
 136               String.format(COMPOSITION_ENTITY_DATA_MANAGER_ERR_MSG, "schema template context"))
 137               .build());
 138     }
 139
 140     CompositionEntityValidationData validationData =
 141         new CompositionEntityValidationData(entity.getType(), entity.getId());
 142     String json =
 143         schemaTemplateContext == SchemaTemplateContext.composition ? entity.getCompositionData()
 144             : entity.getQuestionnaireData();
 145     validationData.setErrors(JsonUtil.validate(
 146         json == null ? JsonUtil.object2Json(new Object()) : json,
 147         generateSchema(schemaTemplateContext, entity.getType(), schemaTemplateInput)));
 148     return validationData;
 149   }
 150
 151   /**
 152    * Add entity.
 153    *
 154    * @param entity              the entity
 155    * @param schemaTemplateInput the schema template input
 156    */
 157   @Override
 158   public void addEntity(CompositionEntity entity, SchemaTemplateInput schemaTemplateInput) {
 159     if (entity == null) {
 160       throw new CoreException(
 161           new ErrorCode.ErrorCodeBuilder().withCategory(ErrorCategory.APPLICATION)
 162               .withId(COMPOSITION_ENTITY_DATA_MANAGER_ERR).withMessage(
 163               String.format(COMPOSITION_ENTITY_DATA_MANAGER_ERR_MSG, "composition entity"))
 164               .build());
 165     }
 166     entities.put(entity.getCompositionEntityId(),
 167         new CompositionEntityData(entity, schemaTemplateInput));
 168   }
 169
 170   /**
 171    * Validate entities questionnaire map.
 172    *
 173    * @return the map
 174    */
 175   @Override
 176   public Map<CompositionEntityId, Collection<String>> validateEntitiesQuestionnaire() {
 177     Map<CompositionEntityId, Collection<String>> errorsByEntityId = new HashMap<>();
 178     entities.entrySet().forEach(entry -> {
 179       Collection<String> errors = validateQuestionnaire(entry.getValue());
 180       if (errors != null) {
 181         errorsByEntityId.put(entry.getKey(), errors);
 182       }
 183     });
 184     return errorsByEntityId;
 185   }
 186
 187   /**
 188    * Build trees.
 189    */
 190   @Override
 191   public void buildTrees() {
 192     Map<CompositionEntityId, CompositionEntityValidationData> entitiesValidationData =
 193         new HashMap<>();
 194     entities.entrySet().forEach(
 195         entry -> addValidationDataEntity(entitiesValidationData, entry.getKey(),
 196             entry.getValue().entity));
 197   }
 198
 199   public Collection<CompositionEntityValidationData> getTrees() {
 200     return roots;
 201   }
 202
 203   @Override
 204   public void saveCompositionData(String vspId, Version version, CompositionData compositionData) {
 205     if (Objects.isNull(compositionData)) {
 206       return;
 207     }
 208
 209     Map<String, String> networkIdByName = saveNetworks(vspId, version, compositionData);
 210     saveComponents(vspId, version, compositionData, networkIdByName);
 211   }
 212
 213   @Override
 214   public Set<CompositionEntityValidationData> getAllErrorsByVsp(String vspId) {
 215     CompositionEntityValidationData matchVsp = null;
 216     Set<CompositionEntityValidationData> entitiesWithErrors = new HashSet<>();
 217     for (CompositionEntityValidationData root : roots) {
 218       if (root.getEntityId().equals(vspId)) {
 219         matchVsp = root;
 220         break;
 221       }
 222     }
 223
 224     getEntityListWithErrors(matchVsp, entitiesWithErrors);
 225     if (CollectionUtils.isNotEmpty(entitiesWithErrors)) {
 226       updateValidationCompositionEntityName(entitiesWithErrors);
 227       return entitiesWithErrors;
 228     }
 229
 230     return null;
 231   }
 232
 233   private boolean isThereErrorsInSubTree(CompositionEntityValidationData entity) {
 234     if (Objects.isNull(entity)) {
 235       return false;
 236     }
 237
 238     if (CollectionUtils.isNotEmpty(entity.getErrors())) {
 239       return true;
 240     }
 241
 242     Collection<CompositionEntityValidationData> subEntitiesValidationData =
 243         entity.getSubEntitiesValidationData();
 244     return !CollectionUtils.isEmpty(subEntitiesValidationData) &&
 245         checkForErrorsInChildren(subEntitiesValidationData);
 246
 247   }
 248
 249   private boolean checkForErrorsInChildren(
 250       Collection<CompositionEntityValidationData> subEntitiesValidationData) {
 251     boolean result = false;
 252     for (CompositionEntityValidationData subEntity : subEntitiesValidationData) {
 253       if (CollectionUtils.isNotEmpty(subEntity.getErrors())) {
 254         return true;
 255       }
 256
 257       result = isThereErrorsInSubTree(subEntity) || result;
 258       if (result) {
 259         return true;
 260       }
 261     }
 262     return false;
 263   }
 264
 265   private void saveComponents(String vspId, Version version, CompositionData compositionData,
 266                               Map<String, String> networkIdByName) {
 267     if (CollectionUtils.isNotEmpty(compositionData.getComponents())) {
 268       for (Component component : compositionData.getComponents()) {
 269         ComponentEntity componentEntity = new ComponentEntity(vspId, version, null);
 270         componentEntity.setComponentCompositionData(component.getData());
 271
 272         String componentId = createComponent(componentEntity).getId();
 273
 274         saveImagesByComponent(vspId, version, component, componentId);
 275         saveComputesFlavorByComponent(vspId, version, component, componentId);
 276
 277         saveNicsByComponent(vspId, version, networkIdByName, component, componentId);
 278       }
 279     }
 280   }
 281
 282   private void saveNicsByComponent(String vspId, Version version,
 283                                    Map<String, String> networkIdByName, Component component,
 284                                    String componentId) {
 285     if (CollectionUtils.isNotEmpty(component.getNics())) {
 286       for (Nic nic : component.getNics()) {
 287         if (nic.getNetworkName() != null && MapUtils.isNotEmpty(networkIdByName)) {
 288           nic.setNetworkId(networkIdByName.get(nic.getNetworkName()));
 289         }
 290         nic.setNetworkName(null);
 291         //For heat flow set network type to be internal by default for NIC
 292         nic.setNetworkType(NetworkType.Internal);
 293
 294         NicEntity nicEntity = new NicEntity(vspId, version, componentId, null);
 295         nicEntity.setNicCompositionData(nic);
 296         createNic(nicEntity);
 297       }
 298     }
 299   }
 300
 301   private Map<String, String> saveNetworks(String vspId, Version version,
 302                                            CompositionData compositionData) {
 303     Map<String, String> networkIdByName = new HashMap<>();
 304     if (CollectionUtils.isNotEmpty(compositionData.getNetworks())) {
 305       for (Network network : compositionData.getNetworks()) {
 306
 307         NetworkEntity networkEntity = new NetworkEntity(vspId, version, null);
 308         networkEntity.setNetworkCompositionData(network);
 309
 310         if (network.getName() != null) {
 311           networkIdByName.put(network.getName(), createNetwork(networkEntity).getId());
 312         }
 313       }
 314     }
 315     return networkIdByName;
 316   }
 317
 318   private NetworkEntity createNetwork(NetworkEntity network) {
 319     //network.setId(CommonMethods.nextUuId()); will be set by the dao
 320     networkDao.create(network);
 321     return network;
 322   }
 323
 324   @Override
 325   public ComponentEntity createComponent(ComponentEntity component) {
 326     //component.setId(CommonMethods.nextUuId()); will be set by the dao
 327     component.setQuestionnaireData(
 328         new JsonSchemaDataGenerator(
 329             generateSchema(SchemaTemplateContext.questionnaire, CompositionEntityType.component,
 330                 null))
 331             .generateData());
 332
 333     componentDao.create(component);
 334     return component;
 335   }
 336
 337   @Override
 338   public NicEntity createNic(NicEntity nic) {
 339     //nic.setId(CommonMethods.nextUuId()); will be set by the dao
 340     nic.setQuestionnaireData(
 341         new JsonSchemaDataGenerator(
 342             generateSchema(SchemaTemplateContext.questionnaire, CompositionEntityType.nic, null))
 343             .generateData());
 344
 345     nicDao.create(nic);
 346     return nic;
 347   }
 348
 349
 350   public void addErrorsToTrees(Map<CompositionEntityId, Collection<String>> errors) {
 351     roots.forEach(root -> addErrorsToTree(root, null, errors));
 352   }
 353
 354   /* *
 355    * get a flat list of all questionnaire entities that have validation errors
 356    * */
 357   public Set<CompositionEntityValidationData> getEntityListWithErrors() {
 358     Set<CompositionEntityValidationData> treeAsList = new HashSet<>();
 359
 360     for (CompositionEntityValidationData entity : roots) {
 361       if (CollectionUtils.isNotEmpty(entity.getErrors())) {
 362         addNodeWithErrors(entity, treeAsList);
 363       }
 364       getEntityListWithErrors(entity, treeAsList);
 365     }
 366
 367     updateValidationCompositionEntityName(treeAsList);
 368     return treeAsList;
 369   }
 370
 371   private void getEntityListWithErrors(CompositionEntityValidationData entity,
 372                                        Set<CompositionEntityValidationData> compositionSet) {
 373     if (CollectionUtils.isNotEmpty(entity.getErrors())) {
 374       addNodeWithErrors(entity, compositionSet);
 375     }
 376
 377     if (CollectionUtils.isEmpty(entity.getSubEntitiesValidationData())) {
 378       return;
 379     }
 380
 381     for (CompositionEntityValidationData child : entity.getSubEntitiesValidationData()) {
 382       getEntityListWithErrors(child, compositionSet);
 383     }
 384   }
 385
 386
 387   private void addNodeWithErrors(CompositionEntityValidationData node,
 388                                  Set<CompositionEntityValidationData> entitiesWithErrors) {
 389     CompositionEntityValidationData compositionNodeToAdd = new CompositionEntityValidationData(node
 390         .getEntityType(), node.getEntityId());
 391     compositionNodeToAdd.setErrors(node.getErrors());
 392     compositionNodeToAdd.setSubEntitiesValidationData(null);
 393
 394     entitiesWithErrors.add(compositionNodeToAdd);
 395   }
 396
 397   public void removeNodesWithoutErrors() {
 398     roots.forEach(root -> removeNodesWithoutErrors(root, null));
 399   }
 400
 401
 402   private CompositionEntityData getCompositionEntityDataById(CompositionEntityValidationData
 403                                                                  entity) {
 404     for (Map.Entry<CompositionEntityId, CompositionEntityData> entityEntry : entities
 405         .entrySet()) {
 406       if (entityEntry.getKey().getId().equals(entity.getEntityId())) {
 407         return entityEntry.getValue();
 408       }
 409     }
 410     return null;
 411   }
 412
 413
 414   private void updateValidationCompositionEntityName(Set<CompositionEntityValidationData>
 415                                                          compositionSet) {
 416     for (CompositionEntityValidationData entity : compositionSet) {
 417       String compositionData = getCompositionDataAsString(entity);
 418       if (entity.getEntityType().equals(CompositionEntityType.vsp) ||
 419           Objects.nonNull(compositionData)) {
 420         entity.setEntityName(getEntityNameByEntityType(compositionData, entity));
 421       }
 422     }
 423   }
 424
 425   private String getCompositionDataAsString(CompositionEntityValidationData entity) {
 426     CompositionEntityData compositionEntityData = getCompositionEntityDataById(entity);
 427     return compositionEntityData == null ? null : compositionEntityData.entity.getCompositionData();
 428   }
 429
 430
 431   private String getEntityNameByEntityType(String compositionData,
 432                                            CompositionEntityValidationData entity) {
 433     switch (entity.getEntityType()) {
 434       case component:
 435         ComponentData component = JsonUtil.json2Object(compositionData, ComponentData.class);
 436         return component.getDisplayName();
 437
 438       case nic:
 439         Nic nic = JsonUtil.json2Object(compositionData, Nic.class);
 440         return nic.getName();
 441
 442       case network:
 443         Network network = JsonUtil.json2Object(compositionData, Network.class);
 444         return network.getName();
 445
 446       case image:
 447         Image image = JsonUtil.json2Object(compositionData, Image.class);
 448         return image.getFileName();
 449
 450       case vsp:
 451         CompositionEntityData vspEntity = getCompositionEntityDataById(entity);
 452         VspQuestionnaireEntity vspQuestionnaireEntity = (VspQuestionnaireEntity) vspEntity.entity;
 453         VspDetails vspDetails =
 454             vspInfoDao.get(new VspDetails(vspQuestionnaireEntity.getId(),
 455                 vspQuestionnaireEntity.getVersion()));
 456         return vspDetails.getName();
 457     }
 458
 459     return null;
 460   }
 461
 462   private void removeNodesWithoutErrors(CompositionEntityValidationData node,
 463                                         CompositionEntityValidationData parent) {
 464
 465     if (Objects.isNull(node)) {
 466       return;
 467     }
 468
 469     if (hasChildren(node)) {
 470       Collection<CompositionEntityValidationData> subNodes =
 471           new ArrayList<>(node.getSubEntitiesValidationData());
 472       subNodes.forEach(subNode -> removeNodesWithoutErrors(subNode, node));
 473       node.setSubEntitiesValidationData(subNodes);
 474
 475       if (canNodeGetRemovedFromValidationDataTree(node)) {
 476         removeNodeFromChildren(parent, node);
 477       }
 478     } else if (canNodeGetRemovedFromValidationDataTree(node)) {
 479       removeNodeFromChildren(parent, node);
 480     }
 481   }
 482
 483   private void removeNodeFromChildren(CompositionEntityValidationData parent,
 484                                       CompositionEntityValidationData childToRemove) {
 485     if (!Objects.isNull(parent)) {
 486       parent.getSubEntitiesValidationData().remove(childToRemove);
 487     }
 488   }
 489
 490   private boolean hasChildren(CompositionEntityValidationData node) {
 491     return !CollectionUtils.isEmpty(node.getSubEntitiesValidationData());
 492   }
 493
 494   private boolean canNodeGetRemovedFromValidationDataTree(CompositionEntityValidationData node) {
 495     return !hasChildren(node) && CollectionUtils.isEmpty(node.getErrors());
 496   }
 497
 498
 499   private void addValidationDataEntity(
 500       Map<CompositionEntityId, CompositionEntityValidationData> entitiesValidationData,
 501       CompositionEntityId entityId, CompositionEntity entity) {
 502     if (entitiesValidationData.containsKey(entityId)) {
 503       return;
 504     }
 505
 506     CompositionEntityValidationData validationData =
 507         new CompositionEntityValidationData(entity.getType(), entity.getId());
 508     entitiesValidationData.put(entityId, validationData);
 509
 510     CompositionEntityId parentEntityId = entityId.getParentId();
 511     if (parentEntityId == null) {
 512       roots.add(validationData);
 513     } else {
 514       CompositionEntityData parentEntity = entities.get(parentEntityId);
 515       if (parentEntity == null) {
 516         roots.add(validationData);
 517       } else {
 518         addValidationDataEntity(entitiesValidationData, parentEntityId, parentEntity.entity);
 519         entitiesValidationData.get(parentEntityId).addSubEntityValidationData(validationData);
 520       }
 521     }
 522   }
 523
 524   private void addErrorsToTree(CompositionEntityValidationData node,
 525                                CompositionEntityId parentNodeId,
 526                                Map<CompositionEntityId, Collection<String>> errors) {
 527     if (node == null) {
 528       return;
 529     }
 530     CompositionEntityId nodeId = new CompositionEntityId(node.getEntityId(), parentNodeId);
 531     node.setErrors(errors.get(nodeId));
 532
 533     if (node.getSubEntitiesValidationData() != null) {
 534       node.getSubEntitiesValidationData()
 535           .forEach(subNode -> addErrorsToTree(subNode, nodeId, errors));
 536     }
 537   }
 538
 539   private Collection<String> validateQuestionnaire(CompositionEntityData compositionEntityData) {
 540     logger.debug(String.format("validateQuestionnaire start:  " +
 541             "[entity.type]=%s, [entity.id]=%s, [entity.questionnaireString]=%s",
 542         compositionEntityData.entity.getType().name(),
 543         compositionEntityData.entity.getCompositionEntityId().toString(),
 544         compositionEntityData.entity.getQuestionnaireData()));
 545
 546     if (Objects.isNull(compositionEntityData.entity.getQuestionnaireData()) ||
 547         !JsonUtil.isValidJson(compositionEntityData.entity.getQuestionnaireData())) {
 548       return Collections.singletonList(String
 549           .format(MISSING_OR_INVALID_QUESTIONNAIRE_MSG, compositionEntityData.entity.getType()));
 550     }
 551
 552     return JsonUtil.validate(
 553         compositionEntityData.entity.getQuestionnaireData() == null
 554             ? JsonUtil.object2Json(new Object())
 555             : compositionEntityData.entity.getQuestionnaireData(),
 556         getSchema(compositionEntityData.entity.getType(), SchemaTemplateContext.questionnaire,
 557             compositionEntityData.schemaTemplateInput));
 558   }
 559
 560   private String getSchema(CompositionEntityType compositionEntityType,
 561                            SchemaTemplateContext schemaTemplateContext,
 562                            SchemaTemplateInput schemaTemplateInput) {
 563     return schemaTemplateInput == null
 564         ? nonDynamicSchemas.computeIfAbsent(compositionEntityType,
 565         k -> generateSchema(schemaTemplateContext, compositionEntityType, null))
 566         : generateSchema(schemaTemplateContext, compositionEntityType, schemaTemplateInput);
 567   }
 568
 569   private static class CompositionEntityData {
 570     private CompositionEntity entity;
 571     private SchemaTemplateInput schemaTemplateInput;
 572
 573     CompositionEntityData(CompositionEntity entity, SchemaTemplateInput schemaTemplateInput) {
 574       this.entity = entity;
 575       this.schemaTemplateInput = schemaTemplateInput;
 576     }
 577
 578   }
 579
 580   // todo - make SchemaGenerator non static and mock it in UT instead of mocking this method (and
 581   // make the method private
 582   protected String generateSchema(SchemaTemplateContext schemaTemplateContext,
 583                                   CompositionEntityType compositionEntityType,
 584                                   SchemaTemplateInput schemaTemplateInput) {
 585     return SchemaGenerator
 586         .generate(schemaTemplateContext, compositionEntityType, schemaTemplateInput);
 587   }
 588
 589   @Override
 590   public DeploymentFlavorEntity createDeploymentFlavor(DeploymentFlavorEntity deploymentFlavor) {
 591     deploymentFlavor.setId(CommonMethods.nextUuId());
 592     deploymentFlavorDao.create(deploymentFlavor);
 593     return deploymentFlavor;
 594   }
 595
 596   @Override
 597   public ImageEntity createImage(ImageEntity image) {
 598     image.setId(CommonMethods.nextUuId());
 599
 600     image.setQuestionnaireData(
 601         new JsonSchemaDataGenerator(SchemaGenerator
 602             .generate(SchemaTemplateContext.questionnaire, CompositionEntityType.image, null))
 603             .generateData());
 604
 605     imageDao.create(image);
 606     return image;
 607   }
 608
 609   public void saveComputesFlavorByComponent(String vspId, Version version, Component component,
 610                                             String componentId) {
 611     if (CollectionUtils.isNotEmpty(component.getCompute())) {
 612       for (ComputeData flavor : component.getCompute()) {
 613         ComputeEntity computeEntity = new ComputeEntity(vspId, version, componentId, null);
 614         computeEntity.setComputeCompositionData(flavor);
 615         computeEntity.setQuestionnaireData(
 616             new JsonSchemaDataGenerator(SchemaGenerator
 617                 .generate(SchemaTemplateContext.questionnaire, CompositionEntityType.compute,
 618                     null)).generateData());
 619
 620         computeDao.create(computeEntity);
 621       }
 622     }
 623   }
 624
 625   public void saveImagesByComponent(String vspId, Version version, Component component, String
 626       componentId) {
 627     if (CollectionUtils.isNotEmpty(component.getImages())) {
 628       for (Image img : component.getImages()) {
 629         ImageEntity imageEntity = new ImageEntity(vspId, version, componentId, null);
 630         imageEntity.setImageCompositionData(img);
 631         createImage(imageEntity);
 632       }
 633     }
 634   }
 635
 636 }