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