gerrit.onap Code Review - sdc.git/blob

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