openecomp-be/api/openecomp-sdc-rest-webapp/vendor-license-rest/vendor-license-rest-services/src/main/java/org/openecomp/sdcrests/vendorlicense/rest/services/VendorLicenseModelsImpl.java

   1 /*
   2  * Copyright © 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
  18 package org.openecomp.sdcrests.vendorlicense.rest.services;
  19
  20 import org.openecomp.core.dao.UniqueValueDaoFactory;
  21 import org.openecomp.core.util.UniqueValueUtil;
  22 import org.openecomp.sdc.activitylog.ActivityLogManager;
  23 import org.openecomp.sdc.activitylog.ActivityLogManagerFactory;
  24 import org.openecomp.sdc.activitylog.dao.type.ActivityLogEntity;
  25 import org.openecomp.sdc.activitylog.dao.type.ActivityType;
  26 import org.openecomp.sdc.common.errors.CoreException;
  27 import org.openecomp.sdc.common.errors.ErrorCode;
  28 import org.openecomp.sdc.common.errors.Messages;
  29 import org.openecomp.sdc.datatypes.model.ItemType;
  30 import org.openecomp.sdc.healing.factory.HealingManagerFactory;
  31 import org.openecomp.sdc.itempermissions.ItemPermissionsManager;
  32 import org.openecomp.sdc.itempermissions.ItemPermissionsManagerFactory;
  33 import org.openecomp.sdc.itempermissions.impl.types.PermissionTypes;
  34 import org.openecomp.sdc.logging.api.Logger;
  35 import org.openecomp.sdc.logging.api.LoggerFactory;
  36 import org.openecomp.sdc.notification.dtos.Event;
  37 import org.openecomp.sdc.notification.factories.NotificationPropagationManagerFactory;
  38 import org.openecomp.sdc.notification.services.NotificationPropagationManager;
  39 import org.openecomp.sdc.vendorlicense.VendorLicenseConstants;
  40 import org.openecomp.sdc.vendorlicense.VendorLicenseManager;
  41 import org.openecomp.sdc.vendorlicense.VendorLicenseManagerFactory;
  42 import org.openecomp.sdc.vendorlicense.dao.types.VendorLicenseModelEntity;
  43 import org.openecomp.sdc.versioning.AsdcItemManager;
  44 import org.openecomp.sdc.versioning.AsdcItemManagerFactory;
  45 import org.openecomp.sdc.versioning.VersioningManager;
  46 import org.openecomp.sdc.versioning.VersioningManagerFactory;
  47 import org.openecomp.sdc.versioning.dao.types.Version;
  48 import org.openecomp.sdc.versioning.dao.types.VersionStatus;
  49 import org.openecomp.sdc.versioning.types.Item;
  50 import org.openecomp.sdc.versioning.types.NotificationEventTypes;
  51 import org.openecomp.sdcrests.item.rest.mapping.MapItemToDto;
  52 import org.openecomp.sdcrests.item.rest.mapping.MapVersionToDto;
  53 import org.openecomp.sdcrests.item.types.ItemCreationDto;
  54 import org.openecomp.sdcrests.item.types.ItemDto;
  55 import org.openecomp.sdc.versioning.types.ItemStatus;
  56 import org.openecomp.sdcrests.item.types.VersionDto;
  57 import org.openecomp.sdcrests.vendorlicense.rest.VendorLicenseModels;
  58 import org.openecomp.sdcrests.vendorlicense.rest.mapping.MapVendorLicenseModelEntityToDto;
  59 import org.openecomp.sdcrests.vendorlicense.rest.mapping.MapVendorLicenseModelRequestDtoToVendorLicenseModelEntity;
  60 import org.openecomp.sdcrests.vendorlicense.types.VendorLicenseModelActionRequestDto;
  61 import org.openecomp.sdcrests.vendorlicense.types.VendorLicenseModelEntityDto;
  62 import org.openecomp.sdcrests.vendorlicense.types.VendorLicenseModelRequestDto;
  63 import org.openecomp.sdcrests.wrappers.GenericCollectionWrapper;
  64 import org.springframework.context.annotation.Scope;
  65 import org.springframework.stereotype.Service;
  66 import org.springframework.validation.annotation.Validated;
  67
  68 import javax.inject.Named;
  69 import javax.ws.rs.core.Response;
  70 import java.util.HashMap;
  71 import java.util.Map;
  72 import java.util.Objects;
  73 import java.util.Optional;
  74 import java.util.function.Predicate;
  75
  76 import static org.openecomp.sdc.itempermissions.notifications.NotificationConstants.PERMISSION_USER;
  77 import static org.openecomp.sdc.versioning.VersioningNotificationConstansts.ITEM_ID;
  78 import static org.openecomp.sdc.versioning.VersioningNotificationConstansts.ITEM_NAME;
  79 import static org.openecomp.sdc.versioning.VersioningNotificationConstansts.SUBMIT_DESCRIPTION;
  80 import static org.openecomp.sdc.versioning.VersioningNotificationConstansts.VERSION_ID;
  81 import static org.openecomp.sdc.versioning.VersioningNotificationConstansts.VERSION_NAME;
  82 import static org.openecomp.sdcrests.vendorlicense.types.VendorLicenseModelActionRequestDto.VendorLicenseModelAction.Submit;
  83
  84 @Named
  85 @Service("vendorLicenseModels")
  86 @Scope(value = "prototype")
  87 @Validated
  88 public class VendorLicenseModelsImpl implements VendorLicenseModels {
  89
  90   private static final String SUBMIT_ITEM_ACTION = "Submit_Item";
  91   private static final String SUBMIT_HEALED_VERSION_ERROR =
  92       "VLM Id %s: Error while submitting version %s created based on Certified version %s for healing purpose.";
  93   private static final Logger LOGGER = LoggerFactory.getLogger(VendorLicenseModelsImpl.class);
  94   private ItemPermissionsManager permissionsManager = ItemPermissionsManagerFactory.getInstance()
  95       .createInterface();
  96   private NotificationPropagationManager notifier =
  97       NotificationPropagationManagerFactory.getInstance().createInterface();
  98
  99   private AsdcItemManager asdcItemManager = AsdcItemManagerFactory.getInstance().createInterface();
 100   private VersioningManager versioningManager =
 101       VersioningManagerFactory.getInstance().createInterface();
 102   private VendorLicenseManager vendorLicenseManager =
 103       VendorLicenseManagerFactory.getInstance().createInterface();
 104   private ActivityLogManager activityLogManager =
 105       ActivityLogManagerFactory.getInstance().createInterface();
 106   private UniqueValueUtil uniqueValueUtil = new UniqueValueUtil(UniqueValueDaoFactory.getInstance()
 107       .createInterface());
 108
 109   @Override
 110   public Response listLicenseModels(String versionStatus,String itemStatus, String user) {
 111     Predicate<Item> itemPredicate = createItemPredicate(versionStatus, itemStatus, user);
 112
 113     GenericCollectionWrapper<ItemDto> results = new GenericCollectionWrapper<>();
 114     MapItemToDto mapper = new MapItemToDto();
 115     asdcItemManager.list(itemPredicate).stream()
 116         .sorted((o1, o2) -> o2.getModificationTime().compareTo(o1.getModificationTime()))
 117         .forEach(vspItem -> results.add(mapper.applyMapping(vspItem, ItemDto.class)));
 118     return Response.ok(results).build();
 119   }
 120
 121   @Override
 122   public Response createLicenseModel(VendorLicenseModelRequestDto request, String user) {
 123
 124     Item item = new Item();
 125     item.setType(ItemType.vlm.name());
 126     item.setOwner(user);
 127     item.setStatus(ItemStatus.ACTIVE);
 128     item.setName(request.getVendorName());
 129     item.setDescription(request.getDescription());
 130
 131     uniqueValueUtil
 132         .validateUniqueValue(VendorLicenseConstants.UniqueValues.VENDOR_NAME, item.getName());
 133     item = asdcItemManager.create(item);
 134     uniqueValueUtil
 135         .createUniqueValue(VendorLicenseConstants.UniqueValues.VENDOR_NAME, item.getName());
 136
 137     Version version = versioningManager.create(item.getId(), new Version(), null);
 138
 139     VendorLicenseModelEntity vlm = new MapVendorLicenseModelRequestDtoToVendorLicenseModelEntity()
 140         .applyMapping(request, VendorLicenseModelEntity.class);
 141     vlm.setId(item.getId());
 142     vlm.setVersion(version);
 143
 144     vendorLicenseManager.createVendorLicenseModel(vlm);
 145     versioningManager.publish(item.getId(), version, "Initial vlm:" + vlm.getVendorName());
 146
 147     ItemCreationDto itemCreationDto = new ItemCreationDto();
 148     itemCreationDto.setItemId(item.getId());
 149     itemCreationDto.setVersion(new MapVersionToDto().applyMapping(version, VersionDto.class));
 150
 151     activityLogManager.logActivity(new ActivityLogEntity(vlm.getId(), version,
 152         ActivityType.Create, user, true, "", ""));
 153     return Response.ok(itemCreationDto).build();
 154   }
 155
 156   @Override
 157   public Response updateLicenseModel(VendorLicenseModelRequestDto request, String vlmId,
 158                                      String versionId, String user) {
 159     VendorLicenseModelEntity vlm =
 160         new MapVendorLicenseModelRequestDtoToVendorLicenseModelEntity()
 161             .applyMapping(request, VendorLicenseModelEntity.class);
 162     vlm.setId(vlmId);
 163     vlm.setVersion(new Version(versionId));
 164
 165     vendorLicenseManager.updateVendorLicenseModel(vlm);
 166     return Response.ok().build();
 167   }
 168
 169   @Override
 170   public Response getLicenseModel(String vlmId, String versionId, String user) {
 171     Version version = versioningManager.get(vlmId, new Version(versionId));
 172     VendorLicenseModelEntity vlm = vendorLicenseManager.getVendorLicenseModel(vlmId, version);
 173     vlm.setWritetimeMicroSeconds(version.getModificationTime().getTime());
 174
 175     try {
 176       Optional<Version> healedVersion = HealingManagerFactory.getInstance().createInterface()
 177           .healItemVersion(vlmId, version, ItemType.vlm, false);
 178
 179       if (healedVersion.isPresent()) {
 180         vlm.setVersion(healedVersion.get());
 181         if (version.getStatus() == VersionStatus.Certified) {
 182           submitHealedVersion(vlmId, healedVersion.get(), versionId, user);
 183         }
 184       }
 185     } catch (Exception e) {
 186       LOGGER.error(
 187           String.format("Error while auto healing VLM with Id %s and version %s", vlmId, versionId),
 188           e);
 189     }
 190
 191     VendorLicenseModelEntityDto vlmDto =
 192         new MapVendorLicenseModelEntityToDto().applyMapping(vlm, VendorLicenseModelEntityDto.class);
 193     return Response.ok(vlmDto).build();
 194   }
 195
 196   @Override
 197   public Response deleteLicenseModel(String vlmId, String user) {
 198     Item vlm = asdcItemManager.get(vlmId);
 199
 200     if (!vlm.getType().equals(ItemType.vlm.name())){
 201       throw new CoreException((new ErrorCode.ErrorCodeBuilder()
 202               .withMessage(String.format("Vlm with id %s does not exist.",
 203                       vlmId)).build()));
 204     }
 205
 206     Integer certifiedVersionsCounter = vlm.getVersionStatusCounters().get(VersionStatus.Certified);
 207     if (Objects.isNull(certifiedVersionsCounter) || certifiedVersionsCounter == 0) {
 208       asdcItemManager.delete(vlm);
 209       permissionsManager.deleteItemPermissions(vlmId);
 210       uniqueValueUtil
 211           .deleteUniqueValue(VendorLicenseConstants.UniqueValues.VENDOR_NAME, vlm.getName());
 212       notifyUsers(vlmId, vlm.getName(), null, null, user,
 213           NotificationEventTypes.DELETE);
 214
 215       return Response.ok().build();
 216     } else {
 217       return Response.status(Response.Status.FORBIDDEN)
 218           .entity(new Exception(Messages.DELETE_VLM_ERROR.getErrorMessage())).build();
 219     }
 220   }
 221
 222   @Override
 223   public Response actOnLicenseModel(VendorLicenseModelActionRequestDto request, String vlmId,
 224                                     String versionId, String user) {
 225     Version version = new Version(versionId);
 226
 227     if (request.getAction() == Submit) {
 228       if (!permissionsManager.isAllowed(vlmId, user, SUBMIT_ITEM_ACTION)) {
 229         return Response.status(Response.Status.FORBIDDEN)
 230             .entity(new Exception(Messages.PERMISSIONS_ERROR.getErrorMessage())).build();
 231       }
 232       String message =
 233           request.getSubmitRequest() == null ? "Submit" : request.getSubmitRequest().getMessage();
 234       submit(vlmId, version, message, user);
 235
 236       notifyUsers(vlmId, null, version, message, user, NotificationEventTypes.SUBMIT);
 237
 238     }
 239     return Response.ok().build();
 240   }
 241
 242   private void submit(String vlmId, Version version, String message, String user) {
 243
 244     vendorLicenseManager.validate(vlmId, version);
 245     versioningManager.submit(vlmId, version, message);
 246
 247     activityLogManager.logActivity(
 248         new ActivityLogEntity(vlmId, version, ActivityType.Submit, user, true, "", message));
 249   }
 250
 251   private void submitHealedVersion(String vlmId, Version healedVersion, String baseVersionId,
 252                                    String user) {
 253     try {
 254       submit(vlmId, healedVersion, "Submit after heal", user);
 255     } catch (Exception ex) {
 256       LOGGER.error(
 257           String.format(SUBMIT_HEALED_VERSION_ERROR, vlmId, healedVersion.getId(), baseVersionId),
 258           ex);
 259     }
 260   }
 261
 262   private void notifyUsers(String itemId, String itemName, Version version, String message,
 263                            String userName, NotificationEventTypes eventType) {
 264     Map<String, Object> eventProperties = new HashMap<>();
 265     eventProperties.put(ITEM_NAME, itemName == null ? asdcItemManager.get(itemId).getName() : itemName);
 266     eventProperties.put(ITEM_ID, itemId);
 267
 268     if (version != null) {
 269       eventProperties.put(VERSION_NAME, version.getName() == null
 270           ? versioningManager.get(itemId, version).getName()
 271           : version.getName());
 272       eventProperties.put(VERSION_ID, version.getId());
 273     }
 274
 275     eventProperties.put(SUBMIT_DESCRIPTION, message);
 276     eventProperties.put(PERMISSION_USER, userName);
 277
 278     Event syncEvent = new SyncEvent(eventType.getEventName(), itemId, eventProperties, itemId);
 279     try {
 280       notifier.notifySubscribers(syncEvent, userName);
 281     } catch (Exception e) {
 282       LOGGER.error("Failed to send sync notification to users subscribed o item '" + itemId);
 283     }
 284   }
 285
 286   private class SyncEvent implements Event {
 287
 288     private String eventType;
 289     private String originatorId;
 290     private Map<String, Object> attributes;
 291     private String entityId;
 292
 293     SyncEvent(String eventType, String originatorId,
 294               Map<String, Object> attributes, String entityId) {
 295       this.eventType = eventType;
 296       this.originatorId = originatorId;
 297       this.attributes = attributes;
 298       this.entityId = entityId;
 299     }
 300
 301     @Override
 302     public String getEventType() {
 303       return eventType;
 304     }
 305
 306     @Override
 307     public String getOriginatorId() {
 308       return originatorId;
 309     }
 310
 311     @Override
 312     public Map<String, Object> getAttributes() {
 313       return attributes;
 314     }
 315
 316     @Override
 317     public String getEntityId() {
 318       return entityId;
 319     }
 320   }
 321
 322   private boolean userHasPermission(String itemId, String userId) {
 323     String permission = permissionsManager.getUserItemPermiission(itemId, userId);
 324     return (permission != null && permission
 325         .matches(PermissionTypes.Contributor.name() + "|" + PermissionTypes.Owner.name()));
 326   }
 327
 328   private Predicate<Item> createItemPredicate(String versionStatus,
 329                                               String itemStatus,
 330                                               String user) {
 331     Predicate<Item> itemPredicate = item -> ItemType.vlm.name().equals(item.getType());
 332
 333     if (ItemStatus.ARCHIVED.name().equals(itemStatus)) {
 334       itemPredicate = itemPredicate.and(item -> ItemStatus.ARCHIVED.equals(item.getStatus()));
 335     } else {
 336       itemPredicate = itemPredicate.and(item -> ItemStatus.ACTIVE.equals(item.getStatus()));
 337
 338       if (VersionStatus.Certified.name().equals(versionStatus)) {
 339         itemPredicate = itemPredicate
 340                 .and(item -> item.getVersionStatusCounters().containsKey(VersionStatus.Certified));
 341
 342       } else if (VersionStatus.Draft.name().equals(versionStatus)) {
 343         itemPredicate = itemPredicate.and(
 344                 item -> item.getVersionStatusCounters().containsKey(VersionStatus.Draft)
 345                         &&  userHasPermission(item.getId(), user));
 346       }
 347     }
 348     return itemPredicate;
 349   }
 350
 351 }