gerrit.onap Code Review - sdc.git/blob

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