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