gerrit.onap Code Review - sdc.git/blob

   1 /*
   2  * Copyright © 2016-2017 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.openecomp.sdc.vendorsoftwareproduct.impl;
  18
  19
  20 import org.apache.commons.collections4.CollectionUtils;
  21 import org.openecomp.core.utilities.json.JsonUtil;
  22 import org.openecomp.sdc.common.errors.CoreException;
  23 import org.openecomp.sdc.common.errors.ErrorCode;
  24 import org.openecomp.sdc.vendorsoftwareproduct.CompositionEntityDataManager;
  25 import org.openecomp.sdc.vendorsoftwareproduct.ImageManager;
  26 import org.openecomp.sdc.vendorsoftwareproduct.dao.ImageDao;
  27 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
  28 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentEntity;
  29 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ImageEntity;
  30 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
  31 import org.openecomp.sdc.vendorsoftwareproduct.errors.ImageErrorBuilder;
  32 import org.openecomp.sdc.vendorsoftwareproduct.errors.NotSupportedHeatOnboardMethodErrorBuilder;
  33 import org.openecomp.sdc.vendorsoftwareproduct.services.schemagenerator.SchemaGenerator;
  34 import org.openecomp.sdc.vendorsoftwareproduct.types.CompositionEntityResponse;
  35 import org.openecomp.sdc.vendorsoftwareproduct.types.QuestionnaireResponse;
  36 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityType;
  37 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityValidationData;
  38 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Image;
  39 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ImageFormat;
  40 import org.openecomp.sdc.vendorsoftwareproduct.types.questionnaire.component.image.ImageDetails;
  41 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.ImageCompositionSchemaInput;
  42 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.SchemaTemplateContext;
  43 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.SchemaTemplateInput;
  44 import org.openecomp.sdc.versioning.VersioningUtil;
  45 import org.openecomp.sdc.versioning.dao.types.Version;
  46
  47 import java.util.Collection;
  48 import java.util.stream.Collectors;
  49
  50 public class ImageManagerImpl implements ImageManager {
  51   private final VendorSoftwareProductInfoDao vspInfoDao;
  52   private final ImageDao imageDao;
  53   private final CompositionEntityDataManager compositionEntityDataManager;
  54
  55   public ImageManagerImpl(VendorSoftwareProductInfoDao vspInfoDao,
  56                           ImageDao imageDao,
  57                           CompositionEntityDataManager compositionEntityDataManager) {
  58     this.vspInfoDao = vspInfoDao;
  59     this.imageDao = imageDao;
  60     this.compositionEntityDataManager = compositionEntityDataManager;
  61   }
  62
  63   @Override
  64   public ImageEntity createImage(ImageEntity imageEntity) {
  65     boolean isManual = vspInfoDao.isManual(imageEntity.getVspId(), imageEntity.getVersion());
  66     if (!isManual) {
  67       ErrorCode errorCode = NotSupportedHeatOnboardMethodErrorBuilder
  68           .getAddImageNotSupportedHeatOnboardMethodErrorBuilder();
  69       throw new CoreException(errorCode);
  70     }
  71     compositionEntityDataManager.createImage(imageEntity);
  72     return imageEntity;
  73   }
  74
  75   @Override
  76   public Collection<ImageEntity> listImages(String vspId, Version version, String componentId) {
  77     return imageDao.list(new ImageEntity(vspId, version, componentId, null));
  78   }
  79
  80   @Override
  81   public CompositionEntityResponse<Image> getImageSchema(String vspId) {
  82     CompositionEntityResponse<Image> response = new CompositionEntityResponse<>();
  83     ImageCompositionSchemaInput inputSchema = new ImageCompositionSchemaInput();
  84     Image image = new Image();
  85     inputSchema.setImage(image);
  86     response.setSchema(getImageCompositionSchema(inputSchema));
  87     return response;
  88   }
  89
  90   @Override
  91   public CompositionEntityResponse<Image> getImage(String vspId, Version version, String
  92       componentId, String imageId) {
  93     ImageEntity imageEntity = getImageEntity(vspId, version, componentId, imageId);
  94
  95     Image image = imageEntity.getImageCompositionData();
  96
  97     ImageCompositionSchemaInput schemaInput = new ImageCompositionSchemaInput();
  98     schemaInput.setImage(image);
  99
 100     CompositionEntityResponse<Image> response = new CompositionEntityResponse<>();
 101     response.setId(imageId);
 102     response.setData(image);
 103     response.setSchema(getImageCompositionSchema(schemaInput));
 104     return response;
 105   }
 106
 107   @Override
 108   public QuestionnaireResponse getImageQuestionnaire(String vspId, Version version, String
 109       componentId, String imageId) {
 110     QuestionnaireResponse questionnaireResponse = new QuestionnaireResponse();
 111
 112     ImageEntity retrieved = imageDao.getQuestionnaireData(vspId, version, componentId, imageId);
 113     VersioningUtil.validateEntityExistence(retrieved, new ImageEntity(vspId, version, componentId,
 114         imageId), ComponentEntity.ENTITY_TYPE);
 115     questionnaireResponse.setData(retrieved.getQuestionnaireData());
 116     questionnaireResponse.setSchema(getImageQuestionnaireSchema(null));
 117     return questionnaireResponse;
 118   }
 119
 120   @Override
 121   public void deleteImage(String vspId, Version version, String componentId, String imageId) {
 122     ImageEntity imageEntity = getImageEntity(vspId, version, componentId, imageId);
 123     if (!vspInfoDao.isManual(vspId, version)) {
 124       final ErrorCode deleteImageErrorBuilder =
 125           NotSupportedHeatOnboardMethodErrorBuilder
 126               .getDelImageNotSupportedHeatOnboardMethodErrorBuilder();
 127       throw new CoreException(deleteImageErrorBuilder);
 128     }
 129     if (imageEntity != null) {
 130       imageDao.delete(new ImageEntity(vspId, version, componentId, imageId));
 131     }
 132   }
 133
 134   private void validateHeatVspImageUpdate(String name, String value, String retrivedValue) {
 135     if (value != null && !value.equals(retrivedValue)) {
 136       final ErrorCode updateHeatImageErrorBuilder =
 137           ImageErrorBuilder.getImageHeatReadOnlyErrorBuilder(name);
 138       throw new CoreException(updateHeatImageErrorBuilder);
 139     }
 140   }
 141
 142   @Override
 143   public CompositionEntityValidationData updateImage(ImageEntity image) {
 144     boolean isManual = vspInfoDao.isManual(image.getVspId(), image.getVersion());
 145     ImageEntity retrieved =
 146         getImageEntity(image.getVspId(), image.getVersion(), image.getComponentId(),
 147             image.getId());
 148
 149     if (!isManual) {
 150       final Image imageCompositionData = image.getImageCompositionData();
 151       final String fileName = imageCompositionData.getFileName();
 152       validateHeatVspImageUpdate("fileName", fileName, retrieved.getImageCompositionData()
 153           .getFileName());
 154     }
 155
 156     Collection<ImageEntity> vfcImageList = listImages(image.getVspId(),
 157         image.getVersion(), image.getComponentId());
 158
 159     //Set to null so that retrieved object is equal to one in list and gets removed.
 160     retrieved.setQuestionnaireData(null);
 161     vfcImageList.remove(retrieved);
 162
 163
 164     ImageCompositionSchemaInput schemaInput = new ImageCompositionSchemaInput();
 165     schemaInput.setImage(image.getImageCompositionData());
 166
 167     CompositionEntityValidationData validationData = compositionEntityDataManager
 168         .validateEntity(image, SchemaTemplateContext.composition, schemaInput);
 169     if (CollectionUtils.isEmpty(validationData.getErrors())) {
 170       imageDao.update(image);
 171     }
 172     return validationData;
 173   }
 174
 175   @Override
 176   public void updateImageQuestionnaire(String vspId, Version version, String componentId, String
 177       imageId, String questionnaireData) {
 178     getImageEntity(vspId, version, componentId, imageId);
 179
 180
 181     final ImageDetails image = JsonUtil.json2Object(questionnaireData, ImageDetails.class);
 182     final String format = image.getFormat();
 183     try {
 184       if (format != null) {
 185         ImageFormat.valueOf(format);
 186       }
 187     } catch (IllegalArgumentException exception) {
 188       ErrorCode errorCode = ImageErrorBuilder.getInvalidImageFormatErrorBuilder();
 189       throw new CoreException(errorCode, exception);
 190     }
 191
 192     //Validate Format is read only for HEAT Onboarding
 193     if (!vspInfoDao.isManual(vspId, version)) {
 194       final QuestionnaireResponse imageQuestionnaire = getImageQuestionnaire(vspId, version,
 195           componentId, imageId);
 196       final String data = imageQuestionnaire.getData();
 197       if (data != null) {
 198         String retrivedFormat = JsonUtil.json2Object(data, ImageDetails.class).getFormat();
 199         validateHeatVspImageUpdate("format", format, retrivedFormat);
 200       }
 201     }
 202
 203     if (!isImageVersionUnique(vspId, version, componentId, imageId, image)) {
 204       ErrorCode errorCode = ImageErrorBuilder.getDuplicateImageVersionErrorBuilder(image
 205           .getVersion(), componentId);
 206       throw new CoreException(errorCode);
 207     }
 208
 209     imageDao.updateQuestionnaireData(vspId, version, componentId, imageId, questionnaireData);
 210   }
 211
 212   private boolean isImageVersionUnique(String vspId, Version version, String componentId,
 213                                        String imageId,
 214                                        ImageDetails image) {
 215     boolean isPresent = true;
 216     if (image != null && image.getVersion() != null) {
 217       Collection<ImageEntity> imageEntities =
 218           imageDao.list(new ImageEntity(vspId, version, componentId, null));
 219       if (CollectionUtils.isNotEmpty(imageEntities)) {
 220         imageEntities =
 221             imageEntities.stream().filter(imageEntity -> image.getVersion().trim().equalsIgnoreCase(
 222                 getImageVersion(vspId, version, componentId, imageEntity))
 223                 && !imageEntity.getId().equals(imageId)).collect(Collectors.toList());
 224
 225         isPresent = CollectionUtils.isEmpty(imageEntities);
 226       }
 227     }
 228
 229     return isPresent;
 230   }
 231
 232   private String getImageVersion(String vspId, Version version, String componentId,
 233                                  ImageEntity imageEntity) {
 234     QuestionnaireResponse imageQuestionnaire = getImageQuestionnaire(vspId, version,
 235         componentId, imageEntity.getId());
 236     ImageDetails imageDetails =
 237         JsonUtil.json2Object(imageQuestionnaire.getData(), ImageDetails.class);
 238
 239     return imageDetails == null ? null
 240         : imageDetails.getVersion() != null ? imageDetails.getVersion().trim() : null;
 241   }
 242
 243   private ImageEntity getImageEntity(String vspId, Version version, String componentId,
 244                                      String imageId) {
 245
 246     ImageEntity imageEntity = imageDao.get(new ImageEntity(vspId, version, componentId, imageId));
 247
 248     VersioningUtil.validateEntityExistence(imageEntity, new ImageEntity(vspId, version, componentId,
 249         imageId), VspDetails.ENTITY_TYPE);
 250     return imageEntity;
 251   }
 252
 253   protected String getImageCompositionSchema(SchemaTemplateInput schemaInput) {
 254     return SchemaGenerator
 255         .generate(SchemaTemplateContext.composition, CompositionEntityType.image,
 256             schemaInput);
 257   }
 258
 259   protected String getImageQuestionnaireSchema(SchemaTemplateInput schemaInput) {
 260     return SchemaGenerator
 261         .generate(SchemaTemplateContext.questionnaire, CompositionEntityType.image,
 262             schemaInput);
 263   }
 264 }