openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/VendorSoftwareProductManagerImpl.java

   1 /*
   2  * Copyright © 2016-2018 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.openecomp.sdc.vendorsoftwareproduct.impl;
  18
  19 import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductInvalidErrorBuilder.candidateDataNotProcessedOrAbortedErrorBuilder;
  20 import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductInvalidErrorBuilder.invalidProcessedCandidate;
  21 import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductInvalidErrorBuilder.vspMissingDeploymentFlavorErrorBuilder;
  22
  23 import java.io.BufferedOutputStream;
  24 import java.io.ByteArrayInputStream;
  25 import java.io.ByteArrayOutputStream;
  26 import java.io.File;
  27 import java.io.FileOutputStream;
  28 import java.io.IOException;
  29 import java.io.OutputStream;
  30 import java.nio.ByteBuffer;
  31 import java.nio.file.Path;
  32 import java.util.ArrayList;
  33 import java.util.Collection;
  34 import java.util.Collections;
  35 import java.util.HashMap;
  36 import java.util.HashSet;
  37 import java.util.List;
  38 import java.util.Map;
  39 import java.util.Objects;
  40 import java.util.Optional;
  41 import java.util.Set;
  42 import java.util.zip.ZipInputStream;
  43 import java.util.zip.ZipOutputStream;
  44 import org.apache.commons.collections4.CollectionUtils;
  45 import org.apache.commons.collections4.MapUtils;
  46 import org.apache.commons.lang3.tuple.ImmutablePair;
  47 import org.apache.commons.lang3.tuple.Pair;
  48 import org.openecomp.core.dao.UniqueValueDao;
  49 import org.openecomp.core.enrichment.api.EnrichmentManager;
  50 import org.openecomp.core.enrichment.factory.EnrichmentManagerFactory;
  51 import org.openecomp.core.model.dao.EnrichedServiceModelDao;
  52 import org.openecomp.core.model.dao.ServiceModelDao;
  53 import org.openecomp.core.model.types.ServiceElement;
  54 import org.openecomp.core.util.UniqueValueUtil;
  55 import org.openecomp.core.utilities.file.FileContentHandler;
  56 import org.openecomp.core.utilities.json.JsonSchemaDataGenerator;
  57 import org.openecomp.core.utilities.json.JsonUtil;
  58 import org.openecomp.core.utilities.orchestration.OnboardingTypesEnum;
  59 import org.openecomp.core.validation.api.ValidationManager;
  60 import org.openecomp.core.validation.util.MessageContainerUtil;
  61 import org.openecomp.sdc.common.errors.CoreException;
  62 import org.openecomp.sdc.common.errors.ErrorCode;
  63 import org.openecomp.sdc.common.errors.ValidationErrorBuilder;
  64 import org.openecomp.sdc.common.utils.CommonUtil;
  65 import org.openecomp.sdc.datatypes.error.ErrorLevel;
  66 import org.openecomp.sdc.datatypes.error.ErrorMessage;
  67 import org.openecomp.sdc.tosca.csar.Manifest;
  68 import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel;
  69 import org.openecomp.sdc.tosca.services.impl.ToscaFileOutputServiceCsarImpl;
  70 import org.openecomp.sdc.validation.util.ValidationManagerUtil;
  71 import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacade;
  72 import org.openecomp.sdc.vendorlicense.licenseartifacts.VendorLicenseArtifactsService;
  73 import org.openecomp.sdc.vendorsoftwareproduct.CompositionEntityDataManager;
  74 import org.openecomp.sdc.vendorsoftwareproduct.CompositionEntityDataManagerFactory;
  75 import org.openecomp.sdc.vendorsoftwareproduct.ManualVspToscaManager;
  76 import org.openecomp.sdc.vendorsoftwareproduct.OrchestrationTemplateCandidateManager;
  77 import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductConstants;
  78 import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductManager;
  79 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDao;
  80 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDependencyModelDao;
  81 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComputeDao;
  82 import org.openecomp.sdc.vendorsoftwareproduct.dao.DeploymentFlavorDao;
  83 import org.openecomp.sdc.vendorsoftwareproduct.dao.ImageDao;
  84 import org.openecomp.sdc.vendorsoftwareproduct.dao.NicDao;
  85 import org.openecomp.sdc.vendorsoftwareproduct.dao.OrchestrationTemplateDao;
  86 import org.openecomp.sdc.vendorsoftwareproduct.dao.PackageInfoDao;
  87 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
  88 import org.openecomp.sdc.vendorsoftwareproduct.dao.VspMergeDao;
  89 import org.openecomp.sdc.vendorsoftwareproduct.dao.errors.VendorSoftwareProductNotFoundErrorBuilder;
  90 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentDependencyModelEntity;
  91 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentEntity;
  92 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComputeEntity;
  93 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.DeploymentFlavorEntity;
  94 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ImageEntity;
  95 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.NicEntity;
  96 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.OnboardingMethod;
  97 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.OrchestrationTemplateEntity;
  98 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.PackageInfo;
  99 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
 100 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspQuestionnaireEntity;
 101 import org.openecomp.sdc.vendorsoftwareproduct.errors.ComponentDependencyModelErrorBuilder;
 102 import org.openecomp.sdc.vendorsoftwareproduct.errors.ComponentErrorBuilder;
 103 import org.openecomp.sdc.vendorsoftwareproduct.errors.DeploymentFlavorErrorBuilder;
 104 import org.openecomp.sdc.vendorsoftwareproduct.errors.FileCreationErrorBuilder;
 105 import org.openecomp.sdc.vendorsoftwareproduct.errors.InformationArtifactCreationErrorBuilder;
 106 import org.openecomp.sdc.vendorsoftwareproduct.errors.NicInternalNetworkErrorBuilder;
 107 import org.openecomp.sdc.vendorsoftwareproduct.errors.PackageInvalidErrorBuilder;
 108 import org.openecomp.sdc.vendorsoftwareproduct.errors.PackageNotFoundErrorBuilder;
 109 import org.openecomp.sdc.vendorsoftwareproduct.errors.TranslationFileCreationErrorBuilder;
 110 import org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductInvalidErrorBuilder;
 111 import org.openecomp.sdc.vendorsoftwareproduct.informationArtifact.InformationArtifactGenerator;
 112 import org.openecomp.sdc.vendorsoftwareproduct.services.filedatastructuremodule.CandidateService;
 113 import org.openecomp.sdc.vendorsoftwareproduct.services.impl.etsi.ETSIService;
 114 import org.openecomp.sdc.vendorsoftwareproduct.services.impl.etsi.ETSIServiceImpl;
 115 import org.openecomp.sdc.vendorsoftwareproduct.services.schemagenerator.SchemaGenerator;
 116 import org.openecomp.sdc.vendorsoftwareproduct.types.QuestionnaireResponse;
 117 import org.openecomp.sdc.vendorsoftwareproduct.types.QuestionnaireValidationResult;
 118 import org.openecomp.sdc.vendorsoftwareproduct.types.ValidationResponse;
 119 import org.openecomp.sdc.vendorsoftwareproduct.types.candidateheat.FilesDataStructure;
 120 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ComponentComputeAssociation;
 121 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityId;
 122 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityType;
 123 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityValidationData;
 124 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.DeploymentFlavor;
 125 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.NetworkType;
 126 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Nic;
 127 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.ComponentQuestionnaireSchemaInput;
 128 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.SchemaTemplateContext;
 129 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.SchemaTemplateInput;
 130 import org.openecomp.sdc.vendorsoftwareproduct.utils.ComponentDependencyTracker;
 131 import org.openecomp.sdc.versioning.VersioningManager;
 132 import org.openecomp.sdc.versioning.VersioningManagerFactory;
 133 import org.openecomp.sdc.versioning.VersioningUtil;
 134 import org.openecomp.sdc.versioning.dao.types.Version;
 135
 136 public class VendorSoftwareProductManagerImpl implements VendorSoftwareProductManager {
 137
 138   private VspMergeDao vspMergeDao;
 139   private OrchestrationTemplateDao orchestrationTemplateDao;
 140   private OrchestrationTemplateCandidateManager orchestrationTemplateCandidateManager;
 141   private VendorSoftwareProductInfoDao vspInfoDao;
 142   private VendorLicenseFacade vendorLicenseFacade;
 143   private ServiceModelDao<ToscaServiceModel, ServiceElement> serviceModelDao;
 144   private EnrichedServiceModelDao<ToscaServiceModel, ServiceElement> enrichedServiceModelDao;
 145   private VendorLicenseArtifactsService licenseArtifactsService;
 146   private InformationArtifactGenerator informationArtifactGenerator;
 147   private PackageInfoDao packageInfoDao;
 148   private DeploymentFlavorDao deploymentFlavorDao;
 149   private ComponentDao componentDao;
 150   private ComponentDependencyModelDao componentDependencyModelDao;
 151   private NicDao nicDao;
 152   private ComputeDao computeDao;
 153   private ImageDao imageDao;
 154   private ManualVspToscaManager manualVspToscaManager;
 155   private UniqueValueUtil uniqueValueUtil;
 156   private CandidateService candidateService;
 157
 158   @Override
 159   public ValidationResponse validate(VspDetails vspDetails) throws IOException {
 160     List<ErrorCode> vspErrors = new ArrayList<>(validateVspFields(vspDetails));
 161     ValidationResponse validationResponse = new ValidationResponse();
 162     if (Objects.nonNull(vspDetails.getOnboardingMethod())
 163         && OnboardingMethod.Manual.name().equals(vspDetails.getOnboardingMethod())) {
 164       validateManualOnboardingMethod(vspDetails, validationResponse, vspErrors);
 165     } else {
 166       validateOrchestrationTemplateCandidate(validationResponse, vspErrors, vspDetails.getId(), vspDetails.getVersion());
 167       if (!validationResponse.isValid()) {
 168         return validationResponse;
 169       }
 170       validateLicense(vspDetails, vspErrors);
 171       OrchestrationTemplateEntity orchestrationTemplate =
 172           orchestrationTemplateDao.get(vspDetails.getId(), vspDetails.getVersion());
 173       ToscaServiceModel serviceModel =
 174           serviceModelDao.getServiceModel( vspDetails.getId(), vspDetails.getVersion());
 175       if (isOrchestrationTemplateMissing(orchestrationTemplate)
 176           || isServiceModelMissing(serviceModel)) {
 177         vspErrors.add(VendorSoftwareProductInvalidErrorBuilder
 178             .vendorSoftwareProductMissingServiceModelErrorBuilder(vspDetails.getId(),
 179                 vspDetails.getVersion()));
 180       }
 181       validationResponse.setUploadDataErrors(validateOrchestrationTemplate(orchestrationTemplate));
 182     }
 183
 184     QuestionnaireValidationResult questionnaireValidationResult = validateQuestionnaire
 185         (vspDetails.getId(), vspDetails.getVersion(), vspDetails.getOnboardingMethod());
 186
 187     if (Objects.nonNull(questionnaireValidationResult)) {
 188       if (validationResponse.getQuestionnaireValidationResult() == null || validationResponse
 189           .getQuestionnaireValidationResult().getValidationData() == null) {
 190         validationResponse.setQuestionnaireValidationResult(questionnaireValidationResult);
 191       } else {
 192         validationResponse.getQuestionnaireValidationResult().getValidationData().addAll
 193             (questionnaireValidationResult.getValidationData());
 194       }
 195     }
 196
 197     Collection<ComponentDependencyModelEntity> componentDependencies =
 198         componentDependencyModelDao.list(new ComponentDependencyModelEntity(vspDetails.getId(), vspDetails.getVersion(), null));
 199
 200     if (validateComponentDependencies(componentDependencies)) {
 201       vspErrors
 202           .add(ComponentDependencyModelErrorBuilder.getCyclicDependencyComponentErrorBuilder());
 203     }
 204     validationResponse
 205         .setVspErrors(vspErrors);
 206     validationResponse.setLicensingDataErrors(validateLicensingData(vspDetails));
 207     return validationResponse;
 208   }
 209
 210   private void validateLicense(VspDetails vspDetails, List<ErrorCode> vspErrors) {
 211     if (vspDetails.getVlmVersion() != null || vspDetails.getLicenseAgreement() != null
 212             || vspDetails.getFeatureGroups() != null) {
 213       vspErrors.addAll(validateMandatoryLicenseFields(vspDetails));
 214     }
 215   }
 216
 217   private void validateOrchestrationTemplateCandidate(ValidationResponse validationResponse,
 218                                                       List<ErrorCode> vspErrors, String vspId,
 219                                                       Version version) {
 220     orchestrationTemplateCandidateManager.getInfo(vspId, version)
 221         .ifPresent(candidateInfo -> {
 222           String fileName = candidateInfo.getFileName();
 223           vspErrors.add(candidateInfo.getValidationData().isEmpty()
 224               ? candidateDataNotProcessedOrAbortedErrorBuilder(fileName)
 225               : invalidProcessedCandidate(fileName));
 226           validationResponse.setVspErrors(vspErrors);
 227         });
 228   }
 229
 230   private void validateManualOnboardingMethod(VspDetails vspDetails,
 231                                               ValidationResponse validationResponse,
 232                                               List<ErrorCode> vspErrors) {
 233     vspErrors.addAll(validateMandatoryLicenseFields(vspDetails));
 234
 235     Collection<DeploymentFlavorEntity> deploymentFlavors = deploymentFlavorDao
 236         .list(new DeploymentFlavorEntity(vspDetails.getId(), vspDetails.getVersion(), null));
 237     if (CollectionUtils.isEmpty(deploymentFlavors)) {
 238       vspErrors.add(vspMissingDeploymentFlavorErrorBuilder());
 239     }
 240     vspErrors.addAll(validateDeploymentFlavors(deploymentFlavors));
 241
 242     Set<CompositionEntityValidationData> componentValidationResult =
 243         componentValidation(vspDetails.getId(), vspDetails.getVersion());
 244     if (!CollectionUtils.isEmpty(componentValidationResult)) {
 245       if (validationResponse.getQuestionnaireValidationResult() == null
 246           || validationResponse.getQuestionnaireValidationResult().getValidationData() == null) {
 247         validationResponse.setQuestionnaireValidationResult(
 248             new QuestionnaireValidationResult(componentValidationResult));
 249       } else {
 250         validationResponse.getQuestionnaireValidationResult().getValidationData()
 251             .addAll(componentValidationResult);
 252       }
 253     }
 254   }
 255
 256   @Override
 257   public Map<String, List<ErrorMessage>> compile(String vspId, Version version) {
 258     ToscaServiceModel serviceModel =
 259         OnboardingMethod.Manual.name().equals(getValidatedVsp(vspId, version).getOnboardingMethod())
 260             //Generate Tosca service model for Manual Onboarding flow
 261             ? manualVspToscaManager
 262             .generateToscaModel(manualVspToscaManager.gatherVspInformation(vspId, version))
 263             : serviceModelDao.getServiceModel(vspId, version);
 264
 265     return compile(vspId, version, serviceModel);
 266   }
 267
 268   private boolean validateComponentDependencies(
 269       Collection<ComponentDependencyModelEntity> componentDependencies) {
 270     ComponentDependencyTracker dependencyTracker = new ComponentDependencyTracker();
 271
 272     for (ComponentDependencyModelEntity componentDependency : componentDependencies) {
 273       dependencyTracker.addDependency(componentDependency.getSourceComponentId(),
 274           componentDependency.getTargetComponentId());
 275     }
 276     return dependencyTracker.isCyclicDependencyPresent();
 277   }
 278
 279   private Collection<ErrorCode> validateDeploymentFlavors(
 280       Collection<DeploymentFlavorEntity> deploymentFlavors) {
 281
 282     Collection<ErrorCode> errorCodeList = new ArrayList<>();
 283     if (!CollectionUtils.isEmpty(deploymentFlavors)) {
 284       deploymentFlavors.forEach(deploymentFlavor -> {
 285         DeploymentFlavorEntity deployment = deploymentFlavorDao.get(deploymentFlavor);
 286         DeploymentFlavor deploymentLocalFlavor = deployment.getDeploymentFlavorCompositionData();
 287         if (deploymentLocalFlavor != null) {
 288           if (deploymentLocalFlavor.getFeatureGroupId() == null) {
 289             ErrorCode deploymentFlavorErrorBuilder = DeploymentFlavorErrorBuilder.
 290                 getFeatureGroupMandatoryErrorBuilder(deploymentLocalFlavor.getModel());
 291             errorCodeList.add(deploymentFlavorErrorBuilder);
 292           }
 293           validateComponentComputeAssociations(errorCodeList, deploymentFlavor,
 294               deployment, deploymentLocalFlavor);
 295         }
 296       });
 297     }
 298     return errorCodeList;
 299   }
 300
 301   private void validateComponentComputeAssociations(Collection<ErrorCode> errorCodeList,
 302                                                     DeploymentFlavorEntity deploymentFlavor,
 303                                                     DeploymentFlavorEntity deployment,
 304                                                     DeploymentFlavor deploymentlocalFlavor) {
 305     List<ComponentComputeAssociation> componentComputeAssociations =
 306         deploymentlocalFlavor.getComponentComputeAssociations();
 307     if (CollectionUtils.isEmpty(componentComputeAssociations)) {
 308         validateCompositionEntity(errorCodeList, deploymentFlavor, deployment, deploymentlocalFlavor);
 309     } else {
 310       componentComputeAssociations.forEach(componentComputeAssociation -> {
 311         if (componentComputeAssociation == null
 312             || !(componentComputeAssociation.getComponentId() != null
 313             && componentComputeAssociation.getComputeFlavorId() != null)) {
 314             validateCompositionEntity(errorCodeList, deploymentFlavor, deployment, deploymentlocalFlavor);
 315         }
 316       });
 317     }
 318   }
 319
 320   private void validateCompositionEntity(Collection<ErrorCode> errorCodeList,
 321                                                                              DeploymentFlavorEntity deploymentFlavor,
 322                                                                              DeploymentFlavorEntity deployment,
 323                                                                              DeploymentFlavor deploymentlocalFlavor){
 324     CompositionEntityValidationData compositionEntityValidationData = new
 325             CompositionEntityValidationData(CompositionEntityType.deployment, deploymentFlavor
 326             .getId());
 327     compositionEntityValidationData.setEntityName(deployment
 328             .getDeploymentFlavorCompositionData().getModel());
 329     ErrorCode deploymentFlavorErrorBuilder = DeploymentFlavorErrorBuilder
 330             .getInvalidComponentComputeAssociationErrorBuilder(
 331                     deploymentlocalFlavor.getModel());
 332     errorCodeList.add(deploymentFlavorErrorBuilder);
 333   }
 334
 335   private Set<CompositionEntityValidationData> componentValidation(String vspId, Version version) {
 336     Set<CompositionEntityValidationData> validationData = new HashSet<>();
 337     Collection<ComponentEntity> components =
 338         componentDao.list(new ComponentEntity(vspId, version, null));
 339     if (!CollectionUtils.isEmpty(components)) {
 340       components.forEach(component -> {
 341         validateImage(vspId, version, validationData, component);
 342         validateNic(vspId, version, validationData, component);
 343
 344       });
 345     }
 346
 347     return validationData;
 348   }
 349
 350   private void validateNic(String vspId, Version version,
 351                            Set<CompositionEntityValidationData> validationData,
 352                            ComponentEntity component) {
 353     Collection<NicEntity> nics =
 354         nicDao.list(new NicEntity(vspId, version, component.getId(), null));
 355     if (CollectionUtils.isNotEmpty(nics)) {
 356       nics.forEach(nicEntity -> {
 357         NicEntity nic = nicDao.get(new NicEntity(vspId, version, component.getId(),
 358             nicEntity.getId()));
 359         NetworkType networkType = nic.getNicCompositionData().getNetworkType();
 360         String networkId = nic.getNicCompositionData().getNetworkId();
 361         if (networkType.equals(NetworkType.Internal) && networkId == null) {
 362           CompositionEntityValidationData compositionEntityValidationData = new
 363               CompositionEntityValidationData(CompositionEntityType.nic, nic.getId());
 364           compositionEntityValidationData.setEntityName(nic.getNicCompositionData().getName());
 365           ErrorCode nicInternalNetworkErrorBuilder = NicInternalNetworkErrorBuilder
 366               .getNicNullNetworkIdInternalNetworkIdErrorBuilder();
 367           List<String> errors = new ArrayList<>();
 368           errors.add(nicInternalNetworkErrorBuilder.message());
 369           compositionEntityValidationData.setErrors(errors);
 370           validationData.add(compositionEntityValidationData);
 371         }
 372       });
 373     }
 374   }
 375
 376   private void validateImage(String vspId, Version version,
 377                              Set<CompositionEntityValidationData> validationData,
 378                              ComponentEntity component) {
 379     Collection<ImageEntity> images =
 380         imageDao.list(new ImageEntity(vspId, version, component.getId(), null));
 381     if (CollectionUtils.isEmpty(images)) {
 382       CompositionEntityValidationData compositionEntityValidationData = new
 383           CompositionEntityValidationData(component.getType(), component.getId());
 384       compositionEntityValidationData
 385           .setEntityName(component.getComponentCompositionData().getDisplayName());
 386       ErrorCode vfcMissingImageErrorBuilder =
 387           ComponentErrorBuilder.vfcMissingImageErrorBuilder();
 388       List<String> errors = new ArrayList<>();
 389       errors.add(vfcMissingImageErrorBuilder.message());
 390       compositionEntityValidationData.setErrors(errors);
 391       validationData.add(compositionEntityValidationData);
 392     }
 393   }
 394
 395   private List<ErrorCode> validateVspFields(VspDetails vspDetails) {
 396     List<ErrorCode> errors = new ArrayList<>();
 397
 398     if (vspDetails.getName() == null) {
 399       errors.add(createMissingMandatoryFieldError("name"));
 400     }
 401     if (vspDetails.getDescription() == null) {
 402       errors.add(createMissingMandatoryFieldError("description"));
 403     }
 404     if (vspDetails.getVendorId() == null) {
 405       errors.add(createMissingMandatoryFieldError("vendor Id"));
 406     }
 407     if (vspDetails.getCategory() == null) {
 408       errors.add(createMissingMandatoryFieldError("category"));
 409     }
 410     if (vspDetails.getSubCategory() == null) {
 411       errors.add(createMissingMandatoryFieldError("sub category"));
 412     }
 413     return errors;
 414   }
 415
 416   private List<ErrorCode> validateMandatoryLicenseFields(VspDetails vspDetails) {
 417     List<ErrorCode> errors = new ArrayList<>();
 418     if (vspDetails.getVlmVersion() == null) {
 419       errors.add(createMissingMandatoryFieldError("licensing version"));
 420     }
 421     if (vspDetails.getLicenseAgreement() == null) {
 422       errors.add(createMissingMandatoryFieldError("license agreement"));
 423     }
 424     if (CollectionUtils.isEmpty(vspDetails.getFeatureGroups())) {
 425       errors.add(createMissingMandatoryFieldError("feature groups"));
 426     }
 427     return errors;
 428   }
 429
 430   private static ErrorCode createMissingMandatoryFieldError(String fieldName) {
 431     return new ValidationErrorBuilder("must be supplied", fieldName).build();
 432   }
 433
 434   private Map<String, List<ErrorMessage>> compile(String vendorSoftwareProductId, Version version,
 435                                                   ToscaServiceModel serviceModel) {
 436     if (isServiceModelMissing(serviceModel)) {
 437       return null;
 438     }
 439
 440     enrichedServiceModelDao.deleteAll(vendorSoftwareProductId, version);
 441
 442     EnrichmentManager<ToscaServiceModel> enrichmentManager =
 443         EnrichmentManagerFactory.getInstance().createInterface();
 444     enrichmentManager.init(vendorSoftwareProductId, version);
 445     enrichmentManager.setModel(serviceModel);
 446     Map<String, List<ErrorMessage>> enrichErrors = enrichmentManager.enrich();
 447
 448     enrichedServiceModelDao
 449         .storeServiceModel(vendorSoftwareProductId, version, enrichmentManager.getModel());
 450
 451     return enrichErrors;
 452   }
 453
 454   private Collection<ErrorCode> validateLicensingData(VspDetails vspDetails) {
 455     if (vspDetails.getVendorId() != null) {
 456       Optional<ErrorCode> errorCode = vendorLicenseFacade.validateVendorForUsage(vspDetails.getVendorId(),vspDetails.getVlmVersion());
 457       if (errorCode.isPresent()) {
 458         return Collections.singleton(errorCode.get());
 459       }
 460     }
 461
 462     if (vspDetails.getVendorId() == null || vspDetails.getVlmVersion() == null
 463         || vspDetails.getLicenseAgreement() == null
 464         || CollectionUtils.isEmpty(vspDetails.getFeatureGroups())) {
 465       return Collections.emptyList();
 466     }
 467     return vendorLicenseFacade
 468         .validateLicensingData(vspDetails.getVendorId(), vspDetails.getVlmVersion(),
 469             vspDetails.getLicenseAgreement(), vspDetails.getFeatureGroups());
 470   }
 471
 472   @Override
 473   public VspDetails createVsp(VspDetails vspDetails) {
 474     vspInfoDao.create(vspDetails);
 475     vspInfoDao.updateQuestionnaireData(vspDetails.getId(), vspDetails.getVersion(),
 476         new JsonSchemaDataGenerator(getVspQuestionnaireSchema(null)).generateData());
 477     return vspDetails;
 478   }
 479
 480   @Override
 481   public void updateVsp(VspDetails vspDetails) {
 482     VspDetails retrieved = vspInfoDao.get(vspDetails);
 483     if (retrieved == null) {
 484       throw new CoreException((new ErrorCode.ErrorCodeBuilder()
 485           .withMessage(String.format("Vsp with id %s and version %s does not exist.",
 486               vspDetails.getId(), vspDetails.getVersion().getId()))).build());
 487     }
 488     vspDetails.setOnboardingMethod(retrieved.getOnboardingMethod());
 489
 490     //If any existing feature group is removed from VSP which is also associated in DF then
 491     //update DF to remove feature group associations.
 492     updateDeploymentFlavor(vspDetails);
 493
 494     updateUniqueName(retrieved.getName(), vspDetails.getName());
 495     vspInfoDao.update(vspDetails);
 496   }
 497
 498   private void updateDeploymentFlavor(VspDetails vspDetails) {
 499     final List<String> featureGroups = vspDetails.getFeatureGroups();
 500     if (featureGroups != null) {
 501       final Collection<DeploymentFlavorEntity> deploymentFlavorEntities = deploymentFlavorDao
 502           .list(new DeploymentFlavorEntity(vspDetails.getId(), vspDetails
 503               .getVersion(), null));
 504       if (Objects.nonNull(deploymentFlavorEntities)) {
 505         for (DeploymentFlavorEntity deploymentFlavorEntity : deploymentFlavorEntities) {
 506           updateDeploymentFlavourEntity(featureGroups, deploymentFlavorEntity);
 507         }
 508       }
 509     }
 510   }
 511
 512   private void updateDeploymentFlavourEntity(List<String> featureGroups,
 513                                              DeploymentFlavorEntity deploymentFlavorEntity) {
 514     final String featureGroupId =
 515         deploymentFlavorEntity.getDeploymentFlavorCompositionData().getFeatureGroupId();
 516     if (!featureGroups.contains(featureGroupId)) {
 517       DeploymentFlavor deploymentFlavorCompositionData =
 518           deploymentFlavorEntity.getDeploymentFlavorCompositionData();
 519       deploymentFlavorCompositionData.setFeatureGroupId(null);
 520       deploymentFlavorEntity.setDeploymentFlavorCompositionData
 521           (deploymentFlavorCompositionData);
 522       deploymentFlavorDao.update(deploymentFlavorEntity);
 523     }
 524   }
 525
 526
 527   @Override
 528   public VspDetails getVsp(String vspId, Version version) {
 529     return getValidatedVsp(vspId, version);
 530   }
 531
 532   private VspDetails getValidatedVsp(String vspId, Version version) {
 533     VspDetails vsp = vspInfoDao.get(new VspDetails(vspId, version));
 534     if (vsp == null) {
 535       throw new CoreException(new VendorSoftwareProductNotFoundErrorBuilder(vspId).build());
 536     }
 537     return vsp;
 538   }
 539
 540   @Override
 541   public void deleteVsp(String vspId, Version version) {
 542     vspMergeDao.deleteHint(vspId, version);
 543   }
 544
 545   @Override
 546   public List<PackageInfo> listPackages(String category, String subCategory) {
 547     return packageInfoDao.listByCategory(category, subCategory);
 548   }
 549
 550   @Override
 551   public File getTranslatedFile(String vspId, Version version) {
 552     PackageInfo packageInfo = packageInfoDao.get(new PackageInfo(vspId, version));
 553     if (packageInfo == null) {
 554       throw new CoreException(new PackageNotFoundErrorBuilder(vspId, version).build());
 555     }
 556
 557     ByteBuffer translatedFileBuffer = packageInfo.getTranslatedFile();
 558     if (translatedFileBuffer == null) {
 559       throw new CoreException(new PackageInvalidErrorBuilder(vspId, version).build());
 560     }
 561
 562     File translatedFile = new File(VendorSoftwareProductConstants.VSP_PACKAGE_ZIP);
 563
 564     try (FileOutputStream fos = new FileOutputStream(translatedFile)) {
 565       fos.write(translatedFileBuffer.array());
 566     } catch (IOException exception) {
 567       throw new CoreException(new TranslationFileCreationErrorBuilder(vspId, version).build(),
 568           exception);
 569     }
 570     return translatedFile;
 571   }
 572
 573   @Override
 574   public byte[] getOrchestrationTemplateFile(String vspId, Version version) {
 575     OrchestrationTemplateEntity uploadData = orchestrationTemplateDao.get(vspId, version);
 576     ByteBuffer contentData = uploadData.getContentData();
 577     if (contentData == null) {
 578       return new byte[0];
 579     }
 580
 581     ByteArrayOutputStream baos = new ByteArrayOutputStream();
 582
 583     try (final ZipOutputStream zos = new ZipOutputStream(baos);
 584          ZipInputStream ignored = new ZipInputStream(
 585              new ByteArrayInputStream(contentData.array()))) {
 586       zos.write(contentData.array());
 587     } catch (IOException exception) {
 588       throw new CoreException(new FileCreationErrorBuilder(vspId).build(), exception);
 589     }
 590     return baos.toByteArray();
 591   }
 592
 593   @Override
 594   public OrchestrationTemplateEntity getOrchestrationTemplateInfo(String vspId, Version version) {
 595     return orchestrationTemplateDao.getInfo(vspId, version);
 596   }
 597
 598   @Override
 599   public Optional<FilesDataStructure> getOrchestrationTemplateStructure(String vspId,
 600                                                                         Version version) {
 601     Optional<String> jsonFileDataStructure =
 602         orchestrationTemplateDao.getOrchestrationTemplateStructure(vspId, version);
 603
 604     if (jsonFileDataStructure.isPresent() && JsonUtil.isValidJson(jsonFileDataStructure.get())) {
 605       return Optional
 606           .of(JsonUtil.json2Object(jsonFileDataStructure.get(), FilesDataStructure.class));
 607     } else {
 608       return Optional.empty();
 609     }
 610   }
 611
 612   @Override
 613   public PackageInfo createPackage(final String vspId, final Version version) throws IOException {
 614       final ToscaServiceModel toscaServiceModel = enrichedServiceModelDao.getServiceModel(vspId, version);
 615       final VspDetails vspDetails = vspInfoDao.get(new VspDetails(vspId, version));
 616       final Version vlmVersion = vspDetails.getVlmVersion();
 617     if (vlmVersion != null) {
 618       populateVersionsForVlm(vspDetails.getVendorId(), vlmVersion);
 619     }
 620       final PackageInfo packageInfo = createPackageInfo(vspDetails);
 621
 622       final ToscaFileOutputServiceCsarImpl toscaServiceTemplateServiceCsar =
 623         new ToscaFileOutputServiceCsarImpl();
 624       final FileContentHandler licenseArtifacts = licenseArtifactsService
 625         .createLicenseArtifacts(vspDetails.getId(), vspDetails.getVendorId(), vlmVersion,
 626             vspDetails.getFeatureGroups());
 627       final ETSIService etsiService = new ETSIServiceImpl();
 628     if (etsiService.isSol004WithToscaMetaDirectory(toscaServiceModel.getArtifactFiles())) {
 629         final FileContentHandler handler = toscaServiceModel.getArtifactFiles();
 630       final Manifest manifest = etsiService.getManifest(handler);
 631       final Optional<Map<String, Path>> fromToMovedPaths = etsiService.moveNonManoFileToArtifactFolder(handler);
 632       fromToMovedPaths
 633           .ifPresent(it -> etsiService.updateMainDescriptorPaths(toscaServiceModel, it));
 634       packageInfo.setResourceType(etsiService.getResourceType(manifest).name());
 635     }
 636     packageInfo.setTranslatedFile(ByteBuffer.wrap(
 637         toscaServiceTemplateServiceCsar.createOutputFile(toscaServiceModel, licenseArtifacts)));
 638
 639     packageInfoDao.create(packageInfo);
 640     return packageInfo;
 641   }
 642
 643   void populateVersionsForVlm(String vlmId, Version vlmVersion) {
 644     VersioningManager versioningManager = VersioningManagerFactory.getInstance().createInterface();
 645     versioningManager.list(vlmId).stream()
 646         .filter(version -> version.getId().equalsIgnoreCase(vlmVersion.getId()))
 647         .findAny()
 648         .ifPresent(version -> {
 649           vlmVersion.setMinor(version.getMinor());
 650           vlmVersion.setMajor(version.getMajor());
 651         });
 652   }
 653
 654   private PackageInfo createPackageInfo(VspDetails vspDetails) {
 655     PackageInfo packageInfo = new PackageInfo(vspDetails.getId(), vspDetails.getVersion());
 656     packageInfo.setVspName(vspDetails.getName());
 657     packageInfo.setVspDescription(vspDetails.getDescription());
 658     packageInfo.setCategory(vspDetails.getCategory());
 659     packageInfo.setSubCategory(vspDetails.getSubCategory());
 660     packageInfo.setVendorName(vspDetails.getVendorName());
 661     packageInfo.setPackageType(VendorSoftwareProductConstants.CSAR);
 662     packageInfo.setVendorRelease("1.0"); //todo TBD
 663     return packageInfo;
 664   }
 665
 666   @Override
 667
 668   public QuestionnaireResponse getVspQuestionnaire(String vspId, Version version) {
 669     VspQuestionnaireEntity retrieved = vspInfoDao.getQuestionnaire(vspId, version);
 670     VersioningUtil.validateEntityExistence(retrieved, new VspQuestionnaireEntity(vspId, version),
 671         VspDetails.ENTITY_TYPE);
 672
 673     String questionnaireData = retrieved.getQuestionnaireData();
 674
 675     QuestionnaireResponse questionnaireResponse = new QuestionnaireResponse();
 676     questionnaireResponse.setData(questionnaireData);
 677     questionnaireResponse.setSchema(getVspQuestionnaireSchema(null));
 678     return questionnaireResponse;
 679   }
 680
 681   @Override
 682   public void updateVspQuestionnaire(String vspId, Version version, String questionnaireData) {
 683     vspInfoDao.updateQuestionnaireData(vspId, version, questionnaireData);
 684   }
 685
 686
 687   private Map<String, List<ErrorMessage>> validateOrchestrationTemplate(
 688       OrchestrationTemplateEntity orchestrationTemplate) throws IOException {
 689
 690     if (isOrchestrationTemplateMissing(orchestrationTemplate)) {
 691       return null;
 692     }
 693     Map<String, List<ErrorMessage>> validationErrors = new HashMap<>();
 694
 695     FileContentHandler fileContentMap = CommonUtil.validateAndUploadFileContent(
 696         OnboardingTypesEnum.getOnboardingTypesEnum(orchestrationTemplate.getFileSuffix()),
 697         orchestrationTemplate.getContentData().array());
 698
 699     if (CommonUtil.isFileOriginFromZip(orchestrationTemplate.getFileSuffix())) {
 700       ValidationManager validationManager =
 701           ValidationManagerUtil.initValidationManager(fileContentMap);
 702       validationErrors.putAll(validationManager.validate());
 703     }
 704
 705     return
 706         MapUtils.isEmpty(MessageContainerUtil.getMessageByLevel(ErrorLevel.ERROR, validationErrors))
 707             ? null : validationErrors;
 708   }
 709
 710   private QuestionnaireValidationResult validateQuestionnaire(String vspId, Version version,
 711                                                               String onboardingMethod) {
 712     // The apis of CompositionEntityDataManager used here are stateful!
 713     // so, it must be re-created from scratch when it is used!
 714     CompositionEntityDataManager compositionEntityDataManager =
 715         CompositionEntityDataManagerFactory.getInstance().createInterface();
 716     compositionEntityDataManager
 717         .addEntity(vspInfoDao.getQuestionnaire(vspId, version), null);
 718
 719     Collection<NicEntity> nics = nicDao.listByVsp(vspId, version);
 720
 721     Map<String, List<String>> nicNamesByComponent = new HashMap<>();
 722     for (NicEntity nicEntity : nics) {
 723       compositionEntityDataManager.addEntity(nicEntity, null);
 724
 725       Nic nic = nicEntity.getNicCompositionData();
 726       if (nic != null && nic.getName() != null) {
 727         List<String> nicNames =
 728             nicNamesByComponent.computeIfAbsent(nicEntity.getComponentId(), k -> new ArrayList<>());
 729         nicNames.add(nic.getName());
 730       }
 731     }
 732
 733     Collection<ComponentEntity> components =
 734         componentDao.listCompositionAndQuestionnaire(vspId, version);
 735     components.forEach(component -> compositionEntityDataManager.addEntity(component,
 736         new ComponentQuestionnaireSchemaInput(nicNamesByComponent.get(component.getId()),
 737             JsonUtil.json2Object(component.getQuestionnaireData(), Map.class), null,
 738                                                      OnboardingMethod.Manual.name().equals(onboardingMethod))));
 739
 740     Collection<ComputeEntity> computes = computeDao.listByVsp(vspId, version);
 741     computes.forEach(compute -> compositionEntityDataManager.addEntity(compute, null));
 742
 743     if (OnboardingMethod.Manual.name().equals(onboardingMethod)) {
 744       Collection<ImageEntity> images = imageDao.listByVsp(vspId, version);
 745       images.forEach(image -> compositionEntityDataManager.addEntity(image, null));
 746     }
 747
 748     Map<CompositionEntityId, Collection<String>> errorsByEntityId =
 749         compositionEntityDataManager.validateEntitiesQuestionnaire();
 750     if (MapUtils.isNotEmpty(errorsByEntityId)) {
 751       compositionEntityDataManager.buildTrees();
 752       compositionEntityDataManager.addErrorsToTrees(errorsByEntityId);
 753       return new QuestionnaireValidationResult(
 754           compositionEntityDataManager.getAllErrorsByVsp(vspId));
 755     }
 756     return null;
 757   }
 758
 759   @Override
 760   public File getInformationArtifact(String vspId, Version version) {
 761     VspDetails vspDetails = vspInfoDao.get(new VspDetails(vspId, version));
 762
 763     if (vspDetails == null) {
 764       return null;
 765     }
 766
 767     String vspName = vspDetails.getName();
 768     ByteBuffer infoArtifactAsByteBuffer;
 769     File infoArtifactFile;
 770     try {
 771       infoArtifactAsByteBuffer = ByteBuffer.wrap(informationArtifactGenerator.generate(vspId,
 772           version).getBytes());
 773
 774       infoArtifactFile =
 775           new File(
 776               String.format(VendorSoftwareProductConstants.INFORMATION_ARTIFACT_NAME, vspName));
 777       try (OutputStream out = new BufferedOutputStream(new FileOutputStream(infoArtifactFile))) {
 778         out.write(infoArtifactAsByteBuffer.array());
 779       }
 780
 781     } catch (IOException ex) {
 782       throw new CoreException(new InformationArtifactCreationErrorBuilder(vspId).build(), ex);
 783     }
 784     return infoArtifactFile;
 785   }
 786
 787   String getVspQuestionnaireSchema(SchemaTemplateInput schemaInput) {
 788     return SchemaGenerator
 789         .generate(SchemaTemplateContext.questionnaire, CompositionEntityType.vsp, schemaInput);
 790   }
 791
 792   @Override
 793   public Optional<Pair<String, byte[]>> get(String vspId, Version version) throws IOException {
 794
 795     OrchestrationTemplateEntity orchestrationTemplateEntity =
 796         orchestrationTemplateDao.get(vspId, version);
 797
 798     if (isOrchestrationTemplateMissing(orchestrationTemplateEntity)) {
 799       return Optional.empty();
 800     }
 801
 802     if (CommonUtil.isFileOriginFromZip(orchestrationTemplateEntity.getFileSuffix())) {
 803       return Optional.of(new ImmutablePair<>(OnboardingTypesEnum.ZIP.toString(), candidateService
 804           .getZipData(orchestrationTemplateEntity.getContentData())));
 805     }
 806     return Optional.of(new ImmutablePair<>(orchestrationTemplateEntity.getFileSuffix(),
 807         orchestrationTemplateEntity.getContentData().array()));
 808   }
 809
 810   void updateUniqueName(String oldVspName, String newVspName) {
 811     uniqueValueUtil.updateUniqueValue(
 812         VendorSoftwareProductConstants.UniqueValues.VENDOR_SOFTWARE_PRODUCT_NAME,
 813         oldVspName, newVspName);
 814   }
 815
 816   @Override
 817   public Collection<ComputeEntity> getComputeByVsp(String vspId, Version version) {
 818     return computeDao.listByVsp(vspId, version);
 819   }
 820
 821   private boolean isOrchestrationTemplateMissing(
 822       OrchestrationTemplateEntity orchestrationTemplate) {
 823     return orchestrationTemplate == null
 824         || orchestrationTemplate.getContentData() == null
 825         || orchestrationTemplate.getFileSuffix() == null
 826         || orchestrationTemplate.getFileName() == null;
 827   }
 828
 829   private boolean isServiceModelMissing(ToscaServiceModel serviceModel) {
 830     return serviceModel == null || serviceModel.getEntryDefinitionServiceTemplate() == null;
 831   }
 832
 833   public static class Builder{
 834     private VspMergeDao vspMergeDao;
 835     private OrchestrationTemplateDao orchestrationTemplateDao;
 836     private OrchestrationTemplateCandidateManager orchestrationTemplateCandidateManager;
 837     private VendorSoftwareProductInfoDao vspInfoDao;
 838     private VendorLicenseFacade vendorLicenseFacade;
 839     private ServiceModelDao<ToscaServiceModel, ServiceElement> serviceModelDao;
 840     private EnrichedServiceModelDao<ToscaServiceModel, ServiceElement> enrichedServiceModelDao;
 841     private VendorLicenseArtifactsService licenseArtifactsService;
 842     private InformationArtifactGenerator informationArtifactGenerator;
 843     private PackageInfoDao packageInfoDao;
 844     private DeploymentFlavorDao deploymentFlavorDao;
 845     private ComponentDao componentDao;
 846     private ComponentDependencyModelDao componentDependencyModelDao;
 847     private NicDao nicDao;
 848     private ComputeDao computeDao;
 849     private ImageDao imageDao;
 850     private ManualVspToscaManager manualVspToscaManager;
 851     private UniqueValueDao uniqueValueDao;
 852     private CandidateService candidateService;
 853
 854     public Builder vspMerge(VspMergeDao vspMergeDao){
 855       this.vspMergeDao = vspMergeDao;
 856       return this;
 857     }
 858
 859     public Builder orchestrationTemplate(OrchestrationTemplateDao orchestrationTemplateDao) {
 860       this.orchestrationTemplateDao = orchestrationTemplateDao;
 861       return this;
 862     }
 863
 864     public Builder orchestrationTemplateCandidateManager(OrchestrationTemplateCandidateManager orchestrationTemplateCandidateManager) {
 865       this.orchestrationTemplateCandidateManager = orchestrationTemplateCandidateManager;
 866       return this;
 867     }
 868
 869     public Builder vspInfo(VendorSoftwareProductInfoDao vspInfoDao) {
 870       this.vspInfoDao = vspInfoDao;
 871       return this;
 872     }
 873
 874     public Builder vendorLicenseFacade(VendorLicenseFacade vendorLicenseFacade) {
 875       this.vendorLicenseFacade = vendorLicenseFacade;
 876       return this;
 877     }
 878
 879     public Builder serviceModel(ServiceModelDao<ToscaServiceModel, ServiceElement> serviceModelDao) {
 880       this.serviceModelDao = serviceModelDao;
 881       return this;
 882     }
 883
 884     public Builder enrichedServiceModel(EnrichedServiceModelDao<ToscaServiceModel, ServiceElement> enrichedServiceModelDao) {
 885       this.enrichedServiceModelDao = enrichedServiceModelDao;
 886       return this;
 887     }
 888
 889     public Builder licenseArtifactsService(VendorLicenseArtifactsService licenseArtifactsService) {
 890       this.licenseArtifactsService = licenseArtifactsService;
 891       return this;
 892     }
 893
 894     public Builder informationArtifactGenerator(InformationArtifactGenerator informationArtifactGenerator) {
 895       this.informationArtifactGenerator = informationArtifactGenerator;
 896       return this;
 897     }
 898
 899     public Builder packageInfo(PackageInfoDao packageInfoDao) {
 900       this.packageInfoDao = packageInfoDao;
 901       return this;
 902     }
 903
 904     public Builder deploymentFlavor(DeploymentFlavorDao deploymentFlavorDao) {
 905       this.deploymentFlavorDao = deploymentFlavorDao;
 906       return this;
 907     }
 908
 909     public Builder component(ComponentDao componentDao) {
 910       this.componentDao = componentDao;
 911       return this;
 912     }
 913
 914     public Builder componentDependencyModel(ComponentDependencyModelDao componentDependencyModelDao) {
 915       this.componentDependencyModelDao = componentDependencyModelDao;
 916       return this;
 917     }
 918
 919     public Builder nic(NicDao nicDao) {
 920       this.nicDao = nicDao;
 921       return this;
 922     }
 923
 924     public Builder compute(ComputeDao computeDao) {
 925       this.computeDao = computeDao;
 926       return this;
 927     }
 928
 929     public Builder image(ImageDao imageDao) {
 930       this.imageDao = imageDao;
 931       return this;
 932     }
 933
 934     public Builder manualVspToscaManager(ManualVspToscaManager manualVspToscaManager) {
 935       this.manualVspToscaManager = manualVspToscaManager;
 936       return this;
 937     }
 938
 939     public Builder uniqueValue(UniqueValueDao uniqueValueDao) {
 940       this.uniqueValueDao = uniqueValueDao;
 941       return this;
 942     }
 943
 944     public Builder candidateService(CandidateService candidateService) {
 945       this.candidateService = candidateService;
 946       return this;
 947     }
 948
 949     private void registerToVersioning() {
 950       if(serviceModelDao != null) {
 951         serviceModelDao.registerVersioning(
 952                 VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE);
 953       }
 954       if(enrichedServiceModelDao != null) {
 955         enrichedServiceModelDao.registerVersioning(
 956                 VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE);
 957       }
 958     }
 959
 960     public VendorSoftwareProductManager build(){
 961       VendorSoftwareProductManagerImpl vendorSoftwareProductManager = new VendorSoftwareProductManagerImpl();
 962       vendorSoftwareProductManager.vspMergeDao = this.vspMergeDao;
 963       vendorSoftwareProductManager.orchestrationTemplateDao = this.orchestrationTemplateDao;
 964       vendorSoftwareProductManager.orchestrationTemplateCandidateManager = this.orchestrationTemplateCandidateManager;
 965       vendorSoftwareProductManager.vspInfoDao = this.vspInfoDao;
 966       vendorSoftwareProductManager.vendorLicenseFacade = this.vendorLicenseFacade;
 967       vendorSoftwareProductManager.serviceModelDao = this.serviceModelDao;
 968       vendorSoftwareProductManager.enrichedServiceModelDao = this.enrichedServiceModelDao;
 969       vendorSoftwareProductManager.licenseArtifactsService = this.licenseArtifactsService;
 970       vendorSoftwareProductManager.informationArtifactGenerator = this.informationArtifactGenerator;
 971       vendorSoftwareProductManager.packageInfoDao = this.packageInfoDao;
 972       vendorSoftwareProductManager.deploymentFlavorDao = this.deploymentFlavorDao;
 973       vendorSoftwareProductManager.componentDao = this.componentDao;
 974       vendorSoftwareProductManager.componentDependencyModelDao = this.componentDependencyModelDao;
 975       vendorSoftwareProductManager.nicDao = this.nicDao;
 976       vendorSoftwareProductManager.computeDao = this.computeDao;
 977       vendorSoftwareProductManager.imageDao = this.imageDao;
 978       vendorSoftwareProductManager.manualVspToscaManager = this.manualVspToscaManager;
 979       vendorSoftwareProductManager.uniqueValueUtil = new UniqueValueUtil(this.uniqueValueDao);
 980       vendorSoftwareProductManager.candidateService = candidateService;
 981       this.registerToVersioning();
 982       return vendorSoftwareProductManager;
 983     }
 984   }
 985
 986 }