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