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