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