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