gerrit.onap Code Review - sdc.git/blob

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