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