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