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