gerrit.onap Code Review - sdc.git/blob

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