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