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