openecomp-be/api/openecomp-sdc-rest-webapp/vendor-software-products-rest/vendor-software-products-rest-services/src/main/java/org/openecomp/sdcrests/vsp/rest/services/VendorSoftwareProductsImpl.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.sdcrests.vsp.rest.services;
  17
  18 import static javax.ws.rs.core.HttpHeaders.CONTENT_DISPOSITION;
  19 import static org.openecomp.sdc.itempermissions.notifications.NotificationConstants.PERMISSION_USER;
  20 import static org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductConstants.UniqueValues.VENDOR_SOFTWARE_PRODUCT_NAME;
  21 import static org.openecomp.sdc.vendorsoftwareproduct.dao.type.OnboardingMethod.NetworkPackage;
  22 import static org.openecomp.sdc.versioning.VersioningNotificationConstansts.ITEM_ID;
  23 import static org.openecomp.sdc.versioning.VersioningNotificationConstansts.ITEM_NAME;
  24 import static org.openecomp.sdc.versioning.VersioningNotificationConstansts.SUBMIT_DESCRIPTION;
  25 import static org.openecomp.sdc.versioning.VersioningNotificationConstansts.VERSION_ID;
  26 import static org.openecomp.sdc.versioning.VersioningNotificationConstansts.VERSION_NAME;
  27
  28 import java.io.File;
  29 import java.io.IOException;
  30 import java.nio.ByteBuffer;
  31 import java.util.Collection;
  32 import java.util.Comparator;
  33 import java.util.Date;
  34 import java.util.HashMap;
  35 import java.util.HashSet;
  36 import java.util.List;
  37 import java.util.ArrayList;
  38 import java.util.Map;
  39 import java.util.Set;
  40 import java.util.Objects;
  41 import java.util.Optional;
  42 import java.util.function.Predicate;
  43 import java.util.stream.Collectors;
  44 import javax.inject.Named;
  45 import javax.servlet.http.HttpServletRequest;
  46 import javax.ws.rs.core.Response;
  47 import org.apache.commons.collections4.MapUtils;
  48 import org.openecomp.core.dao.UniqueValueDaoFactory;
  49 import org.openecomp.core.util.UniqueValueUtil;
  50 import org.openecomp.sdc.activitylog.ActivityLogManager;
  51 import org.openecomp.sdc.activitylog.ActivityLogManagerFactory;
  52 import org.openecomp.sdc.activitylog.dao.type.ActivityLogEntity;
  53 import org.openecomp.sdc.activitylog.dao.type.ActivityType;
  54 import org.openecomp.sdc.be.csar.storage.ArtifactStorageManager;
  55 import org.openecomp.sdc.be.csar.storage.StorageFactory;
  56 import org.openecomp.sdc.common.errors.CoreException;
  57 import org.openecomp.sdc.common.errors.ErrorCode;
  58 import org.openecomp.sdc.common.errors.Messages;
  59 import org.openecomp.sdc.common.util.Multitenancy;
  60 import org.openecomp.sdc.datatypes.error.ErrorMessage;
  61 import org.openecomp.sdc.datatypes.model.ItemType;
  62 import org.openecomp.sdc.healing.factory.HealingManagerFactory;
  63 import org.openecomp.sdc.itempermissions.PermissionsManager;
  64 import org.openecomp.sdc.itempermissions.PermissionsManagerFactory;
  65 import org.openecomp.sdc.itempermissions.impl.types.PermissionTypes;
  66 import org.openecomp.sdc.logging.api.Logger;
  67 import org.openecomp.sdc.logging.api.LoggerFactory;
  68 import org.openecomp.sdc.notification.dtos.Event;
  69 import org.openecomp.sdc.notification.factories.NotificationPropagationManagerFactory;
  70 import org.openecomp.sdc.notification.services.NotificationPropagationManager;
  71 import org.openecomp.sdc.vendorsoftwareproduct.OrchestrationTemplateCandidateManagerFactory;
  72 import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductManager;
  73 import org.openecomp.sdc.vendorsoftwareproduct.VspManagerFactory;
  74 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComputeEntity;
  75 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.OnboardingMethod;
  76 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.OrchestrationTemplateCandidateData;
  77 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.OrchestrationTemplateEntity;
  78 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.PackageInfo;
  79 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
  80 import org.openecomp.sdc.vendorsoftwareproduct.errors.CreatePackageForNonFinalVendorSoftwareProductErrorBuilder;
  81 import org.openecomp.sdc.vendorsoftwareproduct.errors.OnboardingMethodErrorBuilder;
  82 import org.openecomp.sdc.vendorsoftwareproduct.errors.PackageNotFoundErrorBuilder;
  83 import org.openecomp.sdc.vendorsoftwareproduct.types.QuestionnaireResponse;
  84 import org.openecomp.sdc.vendorsoftwareproduct.types.ValidationResponse;
  85 import org.openecomp.sdc.versioning.AsdcItemManager;
  86 import org.openecomp.sdc.versioning.AsdcItemManagerFactory;
  87 import org.openecomp.sdc.versioning.VersioningManager;
  88 import org.openecomp.sdc.versioning.VersioningManagerFactory;
  89 import org.openecomp.sdc.versioning.dao.types.Version;
  90 import org.openecomp.sdc.versioning.dao.types.VersionStatus;
  91 import org.openecomp.sdc.versioning.errors.RequestedVersionInvalidErrorBuilder;
  92 import org.openecomp.sdc.versioning.types.Item;
  93 import org.openecomp.sdc.versioning.types.ItemStatus;
  94 import org.openecomp.sdc.versioning.types.NotificationEventTypes;
  95 import org.openecomp.sdcrests.item.rest.mapping.MapVersionToDto;
  96 import org.openecomp.sdcrests.item.types.ItemCreationDto;
  97 import org.openecomp.sdcrests.item.types.VersionDto;
  98 import org.openecomp.sdcrests.vendorsoftwareproducts.types.PackageInfoDto;
  99 import org.openecomp.sdcrests.vendorsoftwareproducts.types.QuestionnaireResponseDto;
 100 import org.openecomp.sdcrests.vendorsoftwareproducts.types.ValidationResponseDto;
 101 import org.openecomp.sdcrests.vendorsoftwareproducts.types.VendorSoftwareProductAction;
 102 import org.openecomp.sdcrests.vendorsoftwareproducts.types.VersionSoftwareProductActionRequestDto;
 103 import org.openecomp.sdcrests.vendorsoftwareproducts.types.VspComputeDto;
 104 import org.openecomp.sdcrests.vendorsoftwareproducts.types.VspDescriptionDto;
 105 import org.openecomp.sdcrests.vendorsoftwareproducts.types.VspDetailsDto;
 106 import org.openecomp.sdcrests.vendorsoftwareproducts.types.VspRequestDto;
 107 import org.openecomp.sdcrests.vsp.rest.CatalogVspClient;
 108 import org.openecomp.sdcrests.vsp.rest.VendorSoftwareProducts;
 109 import org.openecomp.sdcrests.vsp.rest.exception.VendorSoftwareProductsExceptionSupplier;
 110 import org.openecomp.sdcrests.vsp.rest.mapping.MapComputeEntityToVspComputeDto;
 111 import org.openecomp.sdcrests.vsp.rest.mapping.MapItemToVspDetailsDto;
 112 import org.openecomp.sdcrests.vsp.rest.mapping.MapPackageInfoToPackageInfoDto;
 113 import org.openecomp.sdcrests.vsp.rest.mapping.MapQuestionnaireResponseToQuestionnaireResponseDto;
 114 import org.openecomp.sdcrests.vsp.rest.mapping.MapValidationResponseToDto;
 115 import org.openecomp.sdcrests.vsp.rest.mapping.MapVspDescriptionDtoToItem;
 116 import org.openecomp.sdcrests.vsp.rest.mapping.MapVspDescriptionDtoToVspDetails;
 117 import org.openecomp.sdcrests.vsp.rest.mapping.MapVspDetailsToDto;
 118 import org.openecomp.sdcrests.wrappers.GenericCollectionWrapper;
 119 import org.springframework.context.annotation.Scope;
 120 import org.springframework.stereotype.Service;
 121 import org.keycloak.representations.AccessToken;
 122
 123 @Named
 124 @Service("vendorSoftwareProducts")
 125 @Scope(value = "prototype")
 126 public class VendorSoftwareProductsImpl implements VendorSoftwareProducts {
 127
 128     private static final String VALIDATION_VSP_NAME = "validationOnlyVspName";
 129     private static final String VALIDATION_VSP_USER = "validationOnlyVspUser";
 130     private static final String SUBMIT_ITEM_ACTION = "Submit_Item";
 131     private static final String ATTACHMENT_FILENAME = "attachment; filename=";
 132     private static final String SUBMIT_HEALED_VERSION_ERROR = "VSP Id %s: Error while submitting version %s created based on Certified version %s for healing purpose.";
 133     private static final Logger LOGGER = LoggerFactory.getLogger(VendorSoftwareProductsImpl.class);
 134     private static final Object VALIDATION_VSP_CACHE_LOCK = new Object();
 135     private static ItemCreationDto cachedValidationVsp;
 136     private final AsdcItemManager itemManager;
 137     private final PermissionsManager permissionsManager;
 138     private final VersioningManager versioningManager;
 139     private final VendorSoftwareProductManager vendorSoftwareProductManager;
 140     private final ActivityLogManager activityLogManager;
 141     private final NotificationPropagationManager notifier;
 142     private final UniqueValueUtil uniqueValueUtil;
 143     private final StorageFactory storageFactory;
 144     private final CatalogVspClient catalogVspClient;
 145
 146     public VendorSoftwareProductsImpl() {
 147         this.itemManager = AsdcItemManagerFactory.getInstance().createInterface();
 148         this.permissionsManager = PermissionsManagerFactory.getInstance().createInterface();
 149         this.versioningManager = VersioningManagerFactory.getInstance().createInterface();
 150         this.vendorSoftwareProductManager = VspManagerFactory.getInstance().createInterface();
 151         this.activityLogManager = ActivityLogManagerFactory.getInstance().createInterface();
 152         this.notifier = NotificationPropagationManagerFactory.getInstance().createInterface();
 153         this.uniqueValueUtil = new UniqueValueUtil(UniqueValueDaoFactory.getInstance().createInterface());
 154         this.storageFactory = new StorageFactory();
 155         this.catalogVspClient = new CatalogVspClientImpl();
 156     }
 157
 158     public VendorSoftwareProductsImpl(AsdcItemManager itemManager,
 159                                       PermissionsManager permissionsManager,
 160                                       VersioningManager versioningManager,
 161                                       VendorSoftwareProductManager vendorSoftwareProductManager,
 162                                       ActivityLogManager activityLogManager,
 163                                       NotificationPropagationManager notifier,
 164                                       UniqueValueUtil uniqueValueUtil,
 165                                       final StorageFactory storageFactory,
 166                                       CatalogVspClient catalogVspClient) {
 167         this.itemManager = itemManager;
 168         this.permissionsManager = permissionsManager;
 169         this.versioningManager = versioningManager;
 170         this.vendorSoftwareProductManager = vendorSoftwareProductManager;
 171         this.activityLogManager = activityLogManager;
 172         this.notifier = notifier;
 173         this.uniqueValueUtil = uniqueValueUtil;
 174         this.storageFactory = storageFactory;
 175         this.catalogVspClient = catalogVspClient;
 176     }
 177
 178     @Override
 179     public Response createVsp(VspRequestDto vspRequestDto, String user, HttpServletRequest hreq) {
 180         ItemCreationDto vspCreationDto = createVspItem(vspRequestDto, user, hreq);
 181         if (vspCreationDto != null) {
 182             return Response.ok(vspCreationDto).build();
 183         }
 184         else return Response.status(401, "Unauthorized Tenant").build();
 185         }
 186
 187     private ItemCreationDto createVspItem(VspRequestDto vspRequestDto, String user, HttpServletRequest hreq) {
 188         OnboardingMethod onboardingMethod = null;
 189         try {
 190             onboardingMethod = OnboardingMethod.valueOf(vspRequestDto.getOnboardingMethod());
 191         } catch (IllegalArgumentException e) {
 192             LOGGER.error("Error while creating VSP. Message: " + e.getMessage());
 193             throwUnknownOnboardingMethodException(e);
 194         }
 195         ItemCreationDto itemCreationDto = null;
 196         if (onboardingMethod == NetworkPackage || onboardingMethod == OnboardingMethod.Manual) {
 197             itemCreationDto = createItem(vspRequestDto, user, onboardingMethod, hreq);
 198         } else {
 199             throwUnknownOnboardingMethodException(new IllegalArgumentException("Wrong parameter Onboarding Method"));
 200         }
 201         return itemCreationDto;
 202     }
 203
 204     private ItemCreationDto createItem(VspRequestDto vspRequestDto, String user, OnboardingMethod onboardingMethod , HttpServletRequest hreq) {
 205         Multitenancy keyaccess= new Multitenancy();
 206         if (keyaccess.multiTenancyCheck()) {
 207            AccessToken.Access realmAccess = keyaccess.getAccessToken(hreq).getRealmAccess();
 208             Set<String> realmroles = realmAccess.getRoles();
 209             boolean match = realmroles.contains(vspRequestDto.getTenant());
 210             if (match) {
 211                 Item item = new MapVspDescriptionDtoToItem().applyMapping(vspRequestDto, Item.class);
 212                 item.setType(ItemType.vsp.name());
 213                 item.setOwner(user);
 214                 item.setTenant(item.getTenant());
 215                 item.setStatus(ItemStatus.ACTIVE);
 216                 item.addProperty(VspItemProperty.ONBOARDING_METHOD, onboardingMethod.name());
 217                 uniqueValueUtil.validateUniqueValue(VENDOR_SOFTWARE_PRODUCT_NAME, item.getName());
 218                 item = itemManager.create(item);
 219                 uniqueValueUtil.createUniqueValue(VENDOR_SOFTWARE_PRODUCT_NAME, item.getName());
 220                 Version version = versioningManager.create(item.getId(), new Version(), null);
 221                 VspDetails vspDetails = new MapVspDescriptionDtoToVspDetails().applyMapping(vspRequestDto, VspDetails.class);
 222                 vspDetails.setId(item.getId());
 223                 vspDetails.setVersion(version);
 224                 vspDetails.setOnboardingMethod(vspRequestDto.getOnboardingMethod());
 225                 vendorSoftwareProductManager.createVsp(vspDetails);
 226                 versioningManager.publish(item.getId(), version, "Initial vsp:" + vspDetails.getName());
 227                 ItemCreationDto itemCreationDto = new ItemCreationDto();
 228                 itemCreationDto.setItemId(item.getId());
 229                 itemCreationDto.setVersion(new MapVersionToDto().applyMapping(version, VersionDto.class));
 230                 activityLogManager.logActivity(new ActivityLogEntity(vspDetails.getId(), version, ActivityType.Create, user, true, "", ""));
 231                 return itemCreationDto;
 232             }
 233             else {
 234                 LOGGER.error("Unauthorized tenant");
 235                 return null;
 236             }
 237         }
 238         else {
 239             Item item = new MapVspDescriptionDtoToItem().applyMapping(vspRequestDto, Item.class);
 240             item.setType(ItemType.vsp.name());
 241             item.setOwner(user);
 242             item.setStatus(ItemStatus.ACTIVE);
 243             item.addProperty(VspItemProperty.ONBOARDING_METHOD, onboardingMethod.name());
 244             uniqueValueUtil.validateUniqueValue(VENDOR_SOFTWARE_PRODUCT_NAME, item.getName());
 245             item = itemManager.create(item);
 246             uniqueValueUtil.createUniqueValue(VENDOR_SOFTWARE_PRODUCT_NAME, item.getName());
 247             Version version = versioningManager.create(item.getId(), new Version(), null);
 248             VspDetails vspDetails = new MapVspDescriptionDtoToVspDetails().applyMapping(vspRequestDto, VspDetails.class);
 249             vspDetails.setId(item.getId());
 250             vspDetails.setVersion(version);
 251             vspDetails.setOnboardingMethod(vspRequestDto.getOnboardingMethod());
 252             vendorSoftwareProductManager.createVsp(vspDetails);
 253             versioningManager.publish(item.getId(), version, "Initial vsp:" + vspDetails.getName());
 254             ItemCreationDto itemCreationDto = new ItemCreationDto();
 255             itemCreationDto.setItemId(item.getId());
 256             itemCreationDto.setVersion(new MapVersionToDto().applyMapping(version, VersionDto.class));
 257             activityLogManager.logActivity(new ActivityLogEntity(vspDetails.getId(), version, ActivityType.Create, user, true, "", ""));
 258             return itemCreationDto;
 259         }
 260     }
 261
 262     private void throwUnknownOnboardingMethodException(IllegalArgumentException e) {
 263         ErrorCode onboardingMethodUpdateErrorCode = OnboardingMethodErrorBuilder.getInvalidOnboardingMethodErrorBuilder();
 264         throw new CoreException(onboardingMethodUpdateErrorCode, e);
 265     }
 266
 267     @Override
 268     public Response listVsps(String versionStatus, String itemStatus, String user, HttpServletRequest hreq ) {
 269         Multitenancy keyaccess = new Multitenancy();
 270         if (keyaccess.multiTenancyCheck()) {
 271            AccessToken.Access realmAccess = keyaccess.getAccessToken(hreq).getRealmAccess();
 272             Set<String> realmroles = realmAccess.getRoles();
 273             Predicate<Item> itemPredicate = createItemPredicate(versionStatus, itemStatus, user);
 274             GenericCollectionWrapper<VspDetailsDto> results = new GenericCollectionWrapper<>();
 275             MapItemToVspDetailsDto mapper = new MapItemToVspDetailsDto();
 276             realmroles.stream().forEach(role -> itemManager.list(itemPredicate).stream().sorted((o1, o2) -> o2.getModificationTime().compareTo(o1.getModificationTime()))
 277                     .filter(vspItem -> vspItem.getTenant().contains(role))
 278                     .forEach(vspItem -> results.add(mapper.applyMapping(vspItem, VspDetailsDto.class))));
 279             return Response.ok(results).build();
 280         }
 281         else {
 282             GenericCollectionWrapper<VspDetailsDto> results = new GenericCollectionWrapper<>();
 283             MapItemToVspDetailsDto mapper = new MapItemToVspDetailsDto();
 284             getVspList(versionStatus, itemStatus, user).forEach(vspItem -> results.add(mapper.applyMapping(vspItem, VspDetailsDto.class)));
 285             return Response.ok(results).build();
 286         }
 287     }
 288
 289     @Override
 290     public Response getVsp(String vspId, String versionId, String user) {
 291         Version version = versioningManager.get(vspId, new Version(versionId));
 292         VspDetails vspDetails = vendorSoftwareProductManager.getVsp(vspId, version);
 293         try {
 294             HealingManagerFactory.getInstance().createInterface().healItemVersion(vspId, version, ItemType.vsp, false).ifPresent(healedVersion -> {
 295                 vspDetails.setVersion(healedVersion);
 296                 if (version.getStatus() == VersionStatus.Certified) {
 297                     submitHealedVersion(vspDetails, versionId, user);
 298                 }
 299             });
 300         } catch (Exception e) {
 301             LOGGER.error(String.format("Error while auto healing VSP with Id %s and version %s", vspId, versionId), e);
 302         }
 303         VspDetailsDto vspDetailsDto = new MapVspDetailsToDto().applyMapping(vspDetails, VspDetailsDto.class);
 304         addNetworkPackageInfo(vspId, vspDetails.getVersion(), vspDetailsDto);
 305         return Response.ok(vspDetailsDto).build();
 306     }
 307
 308     @Override
 309     public Response getLatestVsp(final String vspId, final String user) {
 310         final List<Version> versions = versioningManager.list(vspId);
 311         final Version version = versions.stream().filter(ver -> VersionStatus.Certified == ver.getStatus())
 312             .max(Comparator.comparingDouble(o -> Double.parseDouble(o.getName())))
 313             .orElseThrow(() -> new CoreException(new PackageNotFoundErrorBuilder(vspId).build()));
 314         return getVsp(vspId, version.getId(), user);
 315     }
 316
 317     private void submitHealedVersion(VspDetails vspDetails, String baseVersionId, String user) {
 318         try {
 319             if (vspDetails.getVlmVersion() != null) {
 320                 // sync vlm if not exists on user space
 321                 versioningManager.get(vspDetails.getVendorId(), vspDetails.getVlmVersion());
 322             }
 323             submit(vspDetails.getId(), vspDetails.getVersion(), "Submit healed Vsp", user).ifPresent(validationResponse -> {
 324                 throw new IllegalStateException("Certified vsp after healing failed on validation");
 325             });
 326             vendorSoftwareProductManager.createPackage(vspDetails.getId(), vspDetails.getVersion());
 327         } catch (Exception ex) {
 328             LOGGER.error(String.format(SUBMIT_HEALED_VERSION_ERROR, vspDetails.getId(), vspDetails.getVersion().getId(), baseVersionId), ex);
 329         }
 330     }
 331
 332     @Override
 333     public Response updateVsp(String vspId, String versionId, VspDescriptionDto vspDescriptionDto, String user) {
 334         VspDetails vspDetails = new MapVspDescriptionDtoToVspDetails().applyMapping(vspDescriptionDto, VspDetails.class);
 335         vspDetails.setId(vspId);
 336         vspDetails.setVersion(new Version(versionId));
 337         vendorSoftwareProductManager.updateVsp(vspDetails);
 338         updateVspItem(vspId, vspDescriptionDto);
 339         return Response.ok().build();
 340     }
 341
 342     @Override
 343     public Response deleteVsp(final String vspId, final String user) {
 344         final Item vsp = itemManager.get(vspId);
 345         if (!ItemType.vsp.getName().equals(vsp.getType())) {
 346             throw VendorSoftwareProductsExceptionSupplier.vspNotFound(vspId).get();
 347         }
 348
 349         checkIfCanDeleteVsp(vsp, user);
 350
 351         try {
 352             deleteVspFromStorage(vspId, user);
 353         } catch (final Exception e) {
 354             logDeleteFromStorageFailure(vspId, user);
 355             throw VendorSoftwareProductsExceptionSupplier.deleteVspFromStorageFailure(vspId).get();
 356         }
 357
 358         try {
 359             deleteVsp(vspId, user, vsp);
 360         } catch (final Exception e) {
 361             throw VendorSoftwareProductsExceptionSupplier.deleteVspFromDatabaseFailure(vspId).get();
 362         }
 363
 364         return Response.ok().build();
 365     }
 366
 367     private void checkIfCanDeleteVsp(final Item vsp, final String user) {
 368         final String vspId = vsp.getId();
 369
 370         checkIfVspInUse(user, vspId);
 371
 372         if (isVspItemNeverCertified(vsp)) {
 373             return;
 374         }
 375         if (!isVspItemArchived(vspId, user)) {
 376             throw VendorSoftwareProductsExceptionSupplier.deleteNotArchivedVsp(vspId).get();
 377         }
 378     }
 379
 380     private void checkIfVspInUse(final String user, final String vspId) {
 381         final Optional<String> vfNameThatUsesVspOpt;
 382         try {
 383             vfNameThatUsesVspOpt = catalogVspClient.findNameOfVfUsingVsp(vspId, user);
 384         } catch (final Exception e) {
 385             throw VendorSoftwareProductsExceptionSupplier.deleteGenericError(vspId).get();
 386         }
 387         if (vfNameThatUsesVspOpt.isPresent()) {
 388             final String vfName = vfNameThatUsesVspOpt.get();
 389             throw VendorSoftwareProductsExceptionSupplier.vspInUseByVf(vfName).get();
 390         }
 391     }
 392
 393     private boolean isVspItemArchived(final String vspId, final String user) {
 394         return getVspList(null, ItemStatus.ARCHIVED.name(), user).stream().anyMatch(item -> vspId.equals(item.getId()));
 395     }
 396
 397     private boolean isVspItemNeverCertified(final Item vsp) {
 398         final Integer certifiedVersionsCounter = vsp.getVersionStatusCounters().get(VersionStatus.Certified);
 399         return certifiedVersionsCounter == null || certifiedVersionsCounter == 0;
 400     }
 401
 402     private void deleteVspFromStorage(final String vspId, final String user) {
 403         final ArtifactStorageManager artifactStorageManager = storageFactory.createArtifactStorageManager();
 404         if (artifactStorageManager.isEnabled()) {
 405             artifactStorageManager.delete(vspId);
 406             logDeleteFromStorageAllSuccess(vspId, user);
 407         }
 408     }
 409
 410     private void logDeleteFromStorageFailure(final String vspId, final String user) {
 411         final String message = Messages.DELETE_VSP_FROM_STORAGE_ERROR.formatMessage(vspId);
 412         try {
 413             versioningManager.list(vspId).forEach(version -> activityLogManager.logActivity(
 414                 new ActivityLogEntity(vspId, version, ActivityType.Delete_From_Storage, user, false, message, message)
 415             ));
 416         } catch (final Exception e) {
 417             LOGGER.error("Could not log activity '{}'", message, e);
 418         }
 419     }
 420     private void logDeleteFromStorageAllSuccess(final String vspId, final String user) {
 421         final String message = String.format("VSP '%s' fully deleted from the storage", vspId);
 422         try {
 423             versioningManager.list(vspId).forEach(version -> activityLogManager.logActivity(
 424                 new ActivityLogEntity(vspId, version, ActivityType.Delete_From_Storage, user, true, message, message)
 425             ));
 426         } catch (final Exception e) {
 427             LOGGER.error("Could not log activity '{}'", message, e);
 428         }
 429     }
 430
 431     private void deleteVsp(final String vspId, final String user, final Item vsp) {
 432         updatePackageDetails(vspId);
 433         versioningManager.list(vspId).forEach(version -> vendorSoftwareProductManager.deleteVsp(vspId, version));
 434         itemManager.delete(vsp);
 435         deleteUserPermissions(vspId);
 436         permissionsManager.deleteItemPermissions(vspId);
 437         uniqueValueUtil.deleteUniqueValue(VENDOR_SOFTWARE_PRODUCT_NAME, vsp.getName());
 438         notifyUsers(vspId, vsp.getName(), null, null, user, NotificationEventTypes.DELETE);
 439     }
 440
 441     private void updatePackageDetails(final String vspId) {
 442         final List<VspDetails> listVsp = new ArrayList<>();
 443         versioningManager.list(vspId).forEach(version -> listVsp.add(vendorSoftwareProductManager.getVsp(vspId, version)));
 444         listVsp.forEach(vspDetail ->
 445                 vendorSoftwareProductManager.listPackages(vspDetail.getCategory(), vspDetail.getSubCategory())
 446                         .stream().filter(packageInfo -> packageInfo.getVspId().equals(vspId)).collect(Collectors.toList())
 447                         .forEach(packInfo -> {
 448                             packInfo.setTranslatedFile(ByteBuffer.wrap(new byte[0]));
 449                             vendorSoftwareProductManager.updatePackage(packInfo);
 450                         })
 451         );
 452     }
 453
 454     private void deleteUserPermissions(String vspId) {
 455         permissionsManager.listItemPermissions(vspId).forEach(itemPermissionsEntity -> {
 456             Set<String> usersToDelete = new HashSet<>();
 457             usersToDelete.add(itemPermissionsEntity.getUserId());
 458             permissionsManager.updateItemPermissions(vspId, itemPermissionsEntity.getPermission(), new HashSet<>(), usersToDelete);
 459         });
 460     }
 461
 462     @Override
 463     public Response actOnVendorSoftwareProduct(VersionSoftwareProductActionRequestDto request, String vspId, String versionId, String user)
 464         throws IOException {
 465         Version version = new Version(versionId);
 466         if (request.getAction() == VendorSoftwareProductAction.Submit) {
 467             if (!permissionsManager.isAllowed(vspId, user, SUBMIT_ITEM_ACTION)) {
 468                 return Response.status(Response.Status.FORBIDDEN).entity(new Exception(Messages.PERMISSIONS_ERROR.getErrorMessage())).build();
 469             }
 470             String message = request.getSubmitRequest() == null ? "Submit" : request.getSubmitRequest().getMessage();
 471             Optional<ValidationResponse> validationResponse = submit(vspId, version, message, user);
 472             if (validationResponse.isPresent()) {
 473                 ValidationResponseDto validationResponseDto = new MapValidationResponseToDto()
 474                     .applyMapping(validationResponse.get(), ValidationResponseDto.class);
 475                 return Response.status(Response.Status.EXPECTATION_FAILED).entity(validationResponseDto).build();
 476             }
 477             notifyUsers(vspId, null, version, message, user, NotificationEventTypes.SUBMIT);
 478         } else if (request.getAction() == VendorSoftwareProductAction.Create_Package) {
 479             return createPackage(vspId, version);
 480         }
 481         return Response.ok().build();
 482     }
 483
 484     @Override
 485     public Response getValidationVsp(String user, HttpServletRequest hreq) {
 486         ItemCreationDto validationVsp = retrieveValidationVsp(hreq);
 487         return Response.ok(validationVsp).build();
 488     }
 489
 490     private ItemCreationDto retrieveValidationVsp(HttpServletRequest req) {
 491         synchronized (VALIDATION_VSP_CACHE_LOCK) {
 492             if (cachedValidationVsp != null) {
 493                 return cachedValidationVsp;
 494             }
 495             VspRequestDto validationVspRequest = new VspRequestDto();
 496             validationVspRequest.setOnboardingMethod(NetworkPackage.toString());
 497             validationVspRequest.setName(VALIDATION_VSP_NAME);
 498             try {
 499                 cachedValidationVsp = createVspItem(validationVspRequest, VALIDATION_VSP_USER, req);
 500                 return cachedValidationVsp;
 501             } catch (CoreException vspCreateException) {
 502                 LOGGER.debug("Failed to create validation VSP", vspCreateException);
 503                 Predicate<Item> validationVspFilter = item -> ItemType.vsp.name().equals(item.getType()) && VALIDATION_VSP_NAME
 504                     .equals(item.getName());
 505                 String validationVspId = itemManager.list(validationVspFilter).stream().findFirst().orElseThrow(() -> new IllegalStateException(
 506                         "Vsp with name " + VALIDATION_VSP_NAME + " does not exist even though the name exists according to " + "unique value util"))
 507                     .getId();
 508                 Version validationVspVersion = versioningManager.list(validationVspId).iterator().next();
 509                 cachedValidationVsp = new ItemCreationDto();
 510                 cachedValidationVsp.setItemId(validationVspId);
 511                 cachedValidationVsp.setVersion(new MapVersionToDto().applyMapping(validationVspVersion, VersionDto.class));
 512                 return cachedValidationVsp;
 513             }
 514         }
 515     }
 516
 517     @Override
 518     public Response getOrchestrationTemplate(String vspId, String versionId, String user) {
 519         byte[] orchestrationTemplateFile = vendorSoftwareProductManager.getOrchestrationTemplateFile(vspId, new Version(versionId));
 520         if (orchestrationTemplateFile == null || orchestrationTemplateFile.length == 0) {
 521             return Response.status(Response.Status.NOT_FOUND).build();
 522         }
 523         Response.ResponseBuilder response = Response.ok(orchestrationTemplateFile);
 524         response.header(CONTENT_DISPOSITION, ATTACHMENT_FILENAME + "LatestHeatPackage.zip");
 525         return response.build();
 526     }
 527
 528     @Override
 529     public Response listPackages(String status, String category, String subCategory, String user) {
 530         List<String> vspsIds = getVspList(null, status != null ? ItemStatus.valueOf(status).name() : null, user).stream().map(Item::getId)
 531             .collect(Collectors.toList());
 532         List<PackageInfo> packageInfoList = vendorSoftwareProductManager.listPackages(category, subCategory);
 533         packageInfoList = packageInfoList.stream().filter(packageInfo -> vspsIds.contains(packageInfo.getVspId())).collect(Collectors.toList());
 534         GenericCollectionWrapper<PackageInfoDto> results = new GenericCollectionWrapper<>();
 535         MapPackageInfoToPackageInfoDto mapper = new MapPackageInfoToPackageInfoDto();
 536         if (packageInfoList != null) {
 537             for (PackageInfo packageInfo : packageInfoList) {
 538                 results.add(mapper.applyMapping(packageInfo, PackageInfoDto.class));
 539             }
 540         }
 541         return Response.ok(results).build();
 542     }
 543
 544     @Override
 545     public Response getTranslatedFile(String vspId, String versionId, String user) {
 546         final List<Version> versions = versioningManager.list(vspId);
 547         final Version version;
 548         if (versionId == null) {
 549             version = versions.stream().filter(ver -> VersionStatus.Certified == ver.getStatus())
 550                 .max(Comparator.comparingDouble(o -> Double.parseDouble(o.getName())))
 551                 .orElseThrow(() -> new CoreException(new PackageNotFoundErrorBuilder(vspId).build()));
 552         } else {
 553             version = versions.stream()
 554                 .filter(ver -> versionId.equals(ver.getName()) || versionId.equals(ver.getId()))
 555                 .findFirst()
 556                 .orElseThrow(() -> new CoreException(new PackageNotFoundErrorBuilder(vspId, versionId).build()));
 557             if (version.getStatus() != VersionStatus.Certified) {
 558                 throw new CoreException(new RequestedVersionInvalidErrorBuilder().build());
 559             }
 560         }
 561         File zipFile = vendorSoftwareProductManager.getTranslatedFile(vspId, version);
 562         Response.ResponseBuilder response = Response.ok(zipFile);
 563         if (zipFile == null) {
 564             return Response.status(Response.Status.NOT_FOUND).build();
 565         }
 566         response.header(CONTENT_DISPOSITION, ATTACHMENT_FILENAME + zipFile.getName());
 567         return response.build();
 568     }
 569
 570     @Override
 571     public Response getQuestionnaire(String vspId, String versionId, String user) {
 572         QuestionnaireResponse questionnaireResponse = vendorSoftwareProductManager.getVspQuestionnaire(vspId, new Version(versionId));
 573         if (questionnaireResponse.getErrorMessage() != null) {
 574             return Response.status(Response.Status.EXPECTATION_FAILED)
 575                 .entity(new MapQuestionnaireResponseToQuestionnaireResponseDto().applyMapping(questionnaireResponse, QuestionnaireResponseDto.class))
 576                 .build();
 577         }
 578         QuestionnaireResponseDto result = new MapQuestionnaireResponseToQuestionnaireResponseDto()
 579             .applyMapping(questionnaireResponse, QuestionnaireResponseDto.class);
 580         return Response.ok(result).build();
 581     }
 582
 583     @Override
 584     public Response updateQuestionnaire(String questionnaireData, String vspId, String versionId, String user) {
 585         vendorSoftwareProductManager.updateVspQuestionnaire(vspId, new Version(versionId), questionnaireData);
 586         return Response.ok().build();
 587     }
 588
 589     @Override
 590     public Response heal(String vspId, String versionId, String user) {
 591         HealingManagerFactory.getInstance().createInterface().healItemVersion(vspId, new Version(versionId), ItemType.vsp, true);
 592         return Response.ok().build();
 593     }
 594
 595     @Override
 596     public Response getVspInformationArtifact(String vspId, String versionId, String user) {
 597         File textInformationArtifact = vendorSoftwareProductManager.getInformationArtifact(vspId, new Version(versionId));
 598         Response.ResponseBuilder response = Response.ok(textInformationArtifact);
 599         if (textInformationArtifact == null) {
 600             return Response.status(Response.Status.NOT_FOUND).build();
 601         }
 602         response.header(CONTENT_DISPOSITION, ATTACHMENT_FILENAME + textInformationArtifact.getName());
 603         return response.build();
 604     }
 605
 606     @Override
 607     public Response listComputes(String vspId, String version, String user) {
 608         Collection<ComputeEntity> computes = vendorSoftwareProductManager.getComputeByVsp(vspId, new Version(version));
 609         MapComputeEntityToVspComputeDto mapper = new MapComputeEntityToVspComputeDto();
 610         GenericCollectionWrapper<VspComputeDto> results = new GenericCollectionWrapper<>();
 611         for (ComputeEntity compute : computes) {
 612             results.add(mapper.applyMapping(compute, VspComputeDto.class));
 613         }
 614         return Response.ok(results).build();
 615     }
 616
 617     private void updateVspItem(String vspId, VspDescriptionDto vspDescriptionDto) {
 618         Item retrievedItem = itemManager.get(vspId);
 619         Item item = new MapVspDescriptionDtoToItem().applyMapping(vspDescriptionDto, Item.class);
 620         item.setId(vspId);
 621         item.setType(retrievedItem.getType());
 622         item.setOwner(retrievedItem.getOwner());
 623         item.setStatus(retrievedItem.getStatus());
 624         item.setVersionStatusCounters(retrievedItem.getVersionStatusCounters());
 625         item.setCreationTime(retrievedItem.getCreationTime());
 626         item.setModificationTime(new Date());
 627         item.addProperty(VspItemProperty.ONBOARDING_METHOD, retrievedItem.getProperties().get(VspItemProperty.ONBOARDING_METHOD));
 628         itemManager.update(item);
 629     }
 630
 631     private Optional<ValidationResponse> submit(String vspId, Version version, String message, String user) throws IOException {
 632         VspDetails vspDetails = vendorSoftwareProductManager.getVsp(vspId, version);
 633         if (vspDetails.getVlmVersion() != null) {
 634             vspDetails.setVlmVersion(versioningManager.get(vspDetails.getVendorId(), vspDetails.getVlmVersion()));
 635         }
 636         ValidationResponse validationResponse = vendorSoftwareProductManager.validate(vspDetails);
 637         Map<String, List<ErrorMessage>> compilationErrors = vendorSoftwareProductManager.compile(vspId, version);
 638         if (!validationResponse.isValid() || MapUtils.isNotEmpty(compilationErrors)) {
 639             activityLogManager
 640                 .logActivity(new ActivityLogEntity(vspId, version, ActivityType.Submit, user, false, "Failed on validation before submit", ""));
 641             return Optional.of(validationResponse);
 642         }
 643         versioningManager.submit(vspId, version, message);
 644         activityLogManager.logActivity(new ActivityLogEntity(vspId, version, ActivityType.Submit, user, true, "", message));
 645         return Optional.empty();
 646     }
 647
 648     private void notifyUsers(String itemId, String itemName, Version version, String message, String userName, NotificationEventTypes eventType) {
 649         Map<String, Object> eventProperties = new HashMap<>();
 650         eventProperties.put(ITEM_NAME, itemName == null ? itemManager.get(itemId).getName() : itemName);
 651         eventProperties.put(ITEM_ID, itemId);
 652         if (version != null) {
 653             eventProperties.put(VERSION_NAME, version.getName() == null ? versioningManager.get(itemId, version).getName() : version.getName());
 654             eventProperties.put(VERSION_ID, version.getId());
 655         }
 656         eventProperties.put(SUBMIT_DESCRIPTION, message);
 657         eventProperties.put(PERMISSION_USER, userName);
 658         Event syncEvent = new SyncEvent(eventType.getEventName(), itemId, eventProperties, itemId);
 659         try {
 660             notifier.notifySubscribers(syncEvent, userName);
 661         } catch (Exception e) {
 662             LOGGER.error("Failed to send sync notification to users subscribed o item '" + itemId, e);
 663         }
 664     }
 665
 666     private Response createPackage(String vspId, Version version) throws IOException {
 667         Version retrievedVersion = versioningManager.get(vspId, version);
 668         if (retrievedVersion.getStatus() != VersionStatus.Certified) {
 669             throw new CoreException(new CreatePackageForNonFinalVendorSoftwareProductErrorBuilder(vspId, version).build());
 670         }
 671         PackageInfo packageInfo = vendorSoftwareProductManager.createPackage(vspId, retrievedVersion);
 672         return Response.ok(packageInfo == null ? null : new MapPackageInfoToPackageInfoDto().applyMapping(packageInfo, PackageInfoDto.class)).build();
 673     }
 674
 675     private void addNetworkPackageInfo(String vspId, Version version, VspDetailsDto vspDetailsDto) {
 676         Optional<OrchestrationTemplateCandidateData> candidateInfo = OrchestrationTemplateCandidateManagerFactory.getInstance().createInterface()
 677             .getInfo(vspId, version);
 678         if (candidateInfo.isPresent()) {
 679             if (candidateInfo.get().getValidationDataStructure() != null) {
 680                 vspDetailsDto.setValidationData(candidateInfo.get().getValidationDataStructure());
 681             }
 682             vspDetailsDto.setNetworkPackageName(candidateInfo.get().getFileName());
 683             vspDetailsDto.setCandidateOnboardingOrigin(candidateInfo.get().getFileSuffix());
 684         } else {
 685             OrchestrationTemplateEntity orchestrationTemplateInfo = vendorSoftwareProductManager.getOrchestrationTemplateInfo(vspId, version);
 686             if (Objects.nonNull(orchestrationTemplateInfo) && Objects.nonNull(orchestrationTemplateInfo.getFileSuffix())) {
 687                 if (orchestrationTemplateInfo.getValidationDataStructure() != null) {
 688                     vspDetailsDto.setValidationData(orchestrationTemplateInfo.getValidationDataStructure());
 689                 }
 690                 vspDetailsDto.setNetworkPackageName(orchestrationTemplateInfo.getFileName());
 691                 vspDetailsDto.setOnboardingOrigin(orchestrationTemplateInfo.getFileSuffix());
 692             }
 693         }
 694     }
 695
 696     private boolean userHasPermission(String itemId, String userId) {
 697         return permissionsManager.getUserItemPermission(itemId, userId)
 698             .map(permission -> permission.matches(PermissionTypes.Contributor.name() + "|" + PermissionTypes.Owner.name())).orElse(false);
 699     }
 700
 701     private Predicate<Item> createItemPredicate(String versionStatus, String itemStatus, String user) {
 702         Predicate<Item> itemPredicate = item -> ItemType.vsp.name().equals(item.getType());
 703         if (ItemStatus.ARCHIVED.name().equals(itemStatus)) {
 704             itemPredicate = itemPredicate.and(item -> ItemStatus.ARCHIVED.equals(item.getStatus()));
 705         } else {
 706             itemPredicate = itemPredicate.and(item -> ItemStatus.ACTIVE.equals(item.getStatus()));
 707             if (VersionStatus.Certified.name().equals(versionStatus)) {
 708                 itemPredicate = itemPredicate.and(item -> item.getVersionStatusCounters().containsKey(VersionStatus.Certified));
 709             } else if (VersionStatus.Draft.name().equals(versionStatus)) {
 710                 itemPredicate = itemPredicate
 711                     .and(item -> item.getVersionStatusCounters().containsKey(VersionStatus.Draft) && userHasPermission(item.getId(), user));
 712             }
 713         }
 714         return itemPredicate;
 715     }
 716
 717     private List<Item> getVspList(String versionStatus, String itemStatus, String user) {
 718         Predicate<Item> itemPredicate = createItemPredicate(versionStatus, itemStatus, user);
 719         return itemManager.list(itemPredicate).stream().sorted((o1, o2) -> o2.getModificationTime().compareTo(o1.getModificationTime()))
 720             .collect(Collectors.toList());
 721     }
 722
 723     private class SyncEvent implements Event {
 724
 725         private final String eventType;
 726         private final String originatorId;
 727         private final Map<String, Object> attributes;
 728         private final String entityId;
 729
 730         SyncEvent(String eventType, String originatorId, Map<String, Object> attributes, String entityId) {
 731             this.eventType = eventType;
 732             this.originatorId = originatorId;
 733             this.attributes = attributes;
 734             this.entityId = entityId;
 735         }
 736
 737         @Override
 738         public String getEventType() {
 739             return eventType;
 740         }
 741
 742         @Override
 743         public String getOriginatorId() {
 744             return originatorId;
 745         }
 746
 747         @Override
 748         public Map<String, Object> getAttributes() {
 749             return attributes;
 750         }
 751
 752         @Override
 753         public String getEntityId() {
 754             return entityId;
 755         }
 756     }
 757 }