openecomp-be/api/openecomp-sdc-rest-webapp/item-rest/item-rest-services/src/main/java/org/openecomp/sdcrests/item/rest/services/ItemsImpl.java

   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 package org.openecomp.sdcrests.item.rest.services;
  18
  19 import static org.openecomp.sdc.itempermissions.notifications.NotificationConstants.PERMISSION_USER;
  20 import static org.openecomp.sdc.versioning.VersioningNotificationConstansts.ITEM_ID;
  21 import static org.openecomp.sdc.versioning.VersioningNotificationConstansts.ITEM_NAME;
  22
  23 import java.util.Arrays;
  24 import java.util.Collections;
  25 import java.util.EnumMap;
  26 import java.util.HashMap;
  27 import java.util.HashSet;
  28 import java.util.List;
  29 import java.util.Map;
  30 import java.util.Optional;
  31 import java.util.Set;
  32 import java.util.function.Predicate;
  33 import java.util.stream.Collectors;
  34 import javax.annotation.PostConstruct;
  35 import javax.inject.Named;
  36 import javax.ws.rs.core.Response;
  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.datatypes.model.ItemType;
  42 import org.openecomp.sdc.itempermissions.PermissionsManager;
  43 import org.openecomp.sdc.itempermissions.PermissionsManagerFactory;
  44 import org.openecomp.sdc.itempermissions.impl.types.PermissionTypes;
  45 import org.openecomp.sdc.logging.api.Logger;
  46 import org.openecomp.sdc.logging.api.LoggerFactory;
  47 import org.openecomp.sdc.notification.dtos.Event;
  48 import org.openecomp.sdc.notification.factories.NotificationPropagationManagerFactory;
  49 import org.openecomp.sdc.notification.services.NotificationPropagationManager;
  50 import org.openecomp.sdc.versioning.ItemManager;
  51 import org.openecomp.sdc.versioning.ItemManagerFactory;
  52 import org.openecomp.sdc.versioning.VersioningManager;
  53 import org.openecomp.sdc.versioning.VersioningManagerFactory;
  54 import org.openecomp.sdc.versioning.dao.types.Version;
  55 import org.openecomp.sdc.versioning.dao.types.VersionStatus;
  56 import org.openecomp.sdc.versioning.types.Item;
  57 import org.openecomp.sdc.versioning.types.ItemStatus;
  58 import org.openecomp.sdc.versioning.types.NotificationEventTypes;
  59 import org.openecomp.sdcrests.item.rest.Items;
  60 import org.openecomp.sdcrests.item.rest.mapping.MapItemToDto;
  61 import org.openecomp.sdcrests.item.types.ItemAction;
  62 import org.openecomp.sdcrests.item.types.ItemActionRequestDto;
  63 import org.openecomp.sdcrests.item.types.ItemDto;
  64 import org.openecomp.sdcrests.wrappers.GenericCollectionWrapper;
  65 import org.springframework.context.annotation.Scope;
  66 import org.springframework.stereotype.Service;
  67 import org.springframework.validation.annotation.Validated;
  68
  69
  70 @Named
  71 @Service("items")
  72 @Scope(value = "prototype")
  73 @Validated
  74 public class ItemsImpl implements Items {
  75
  76     private ItemManager itemManager = ItemManagerFactory.getInstance().createInterface();
  77
  78     private static ActivityLogManager activityLogManager = ActivityLogManagerFactory.getInstance().createInterface();
  79
  80     private VersioningManager versioningManager = VersioningManagerFactory.getInstance().createInterface();
  81
  82     private final PermissionsManager permissionsManager = PermissionsManagerFactory.getInstance().createInterface();
  83
  84     private static final Logger LOGGER = LoggerFactory.getLogger(ItemsImpl.class);
  85
  86     private NotificationPropagationManager notifier =
  87             NotificationPropagationManagerFactory.getInstance().createInterface();
  88
  89     private CatalogNotifier catalogNotifier = new CatalogNotifier();
  90
  91     private Map<ItemAction, ActionSideAffects> actionSideAffectsMap = new EnumMap<>(ItemAction.class);
  92
  93     @PostConstruct
  94     public void initActionSideAffectsMap() {
  95         actionSideAffectsMap
  96                 .put(ItemAction.ARCHIVE, new ActionSideAffects(ActivityType.Archive, NotificationEventTypes.ARCHIVE));
  97         actionSideAffectsMap
  98                 .put(ItemAction.RESTORE, new ActionSideAffects(ActivityType.Restore, NotificationEventTypes.RESTORE));
  99     }
 100
 101     private static final String ONBOARDING_METHOD = "onboardingMethod";
 102
 103
 104     @Override
 105     public Response actOn(ItemActionRequestDto request, String itemId, String user) {
 106
 107         Item item = itemManager.get(itemId);
 108         if (item == null) {
 109             return Response.status(Response.Status.NOT_FOUND).entity(new Exception("Item does not exist.")).build();
 110         }
 111
 112         switch (request.getAction()) {
 113             case ARCHIVE:
 114                 itemManager.archive(item);
 115                 break;
 116             case RESTORE:
 117                 itemManager.restore(item);
 118                 break;
 119             default:
 120         }
 121
 122         actionSideAffectsMap.get(request.getAction()).execute(item, user);
 123         catalogNotifier.execute(Collections.singleton(itemId),request.getAction(),2);
 124
 125         return Response.ok().build();
 126     }
 127
 128     @Override
 129     public Response list(String itemStatusFilter, String versionStatusFilter, String itemTypeFilter,
 130             String permissionFilter, String onboardingMethodFilter, String user) {
 131
 132         Predicate<Item> itemPredicate =
 133                 createItemPredicate(itemStatusFilter, versionStatusFilter, itemTypeFilter, onboardingMethodFilter,
 134                         permissionFilter, user);
 135
 136         GenericCollectionWrapper<ItemDto> results = new GenericCollectionWrapper<>();
 137         MapItemToDto mapper = new MapItemToDto();
 138         itemManager.list(itemPredicate).stream()
 139                    .sorted((o1, o2) -> o2.getModificationTime().compareTo(o1.getModificationTime()))
 140                    .forEach(item -> results.add(mapper.applyMapping(item, ItemDto.class)));
 141
 142         return Response.ok(results).build();
 143
 144     }
 145
 146     @Override
 147     public Response getItem(String itemId, String user) {
 148         Item item = itemManager.get(itemId);
 149         ItemDto itemDto = new MapItemToDto().applyMapping(item, ItemDto.class);
 150
 151         return Response.ok(itemDto).build();
 152     }
 153
 154     private class SyncEvent implements Event {
 155
 156         private String eventType;
 157         private String originatorId;
 158         private Map<String, Object> attributes;
 159         private String entityId;
 160
 161         SyncEvent(String eventType, String originatorId, Map<String, Object> attributes, String entityId) {
 162             this.eventType = eventType;
 163             this.originatorId = originatorId;
 164             this.attributes = attributes;
 165             this.entityId = entityId;
 166         }
 167
 168         @Override
 169         public String getEventType() {
 170             return eventType;
 171         }
 172
 173         @Override
 174         public String getOriginatorId() {
 175             return originatorId;
 176         }
 177
 178         @Override
 179         public Map<String, Object> getAttributes() {
 180             return attributes;
 181         }
 182
 183         @Override
 184         public String getEntityId() {
 185             return entityId;
 186         }
 187
 188     }
 189
 190     private class ActionSideAffects {
 191
 192         private ActivityType activityType;
 193         private NotificationEventTypes notificationType;
 194
 195         private ActionSideAffects(ActivityType activityType, NotificationEventTypes notificationType) {
 196             this.activityType = activityType;
 197             this.notificationType = notificationType;
 198
 199         }
 200
 201         private Version getLatestVersion(String itemId) {
 202             List<Version> list = versioningManager.list(itemId);
 203             Optional<Version> max = list.stream().max(Version::compareTo);
 204
 205             return max.orElse(null);
 206         }
 207
 208         private void execute(Item item, String user) {
 209             notifyUsers(item.getId(), item.getName(), user, this.notificationType);
 210             activityLogManager.logActivity(
 211                     new ActivityLogEntity(item.getId(), getLatestVersion(item.getId()), this.activityType, user, true,
 212                             "", ""));
 213         }
 214
 215         private void notifyUsers(String itemId, String itemName, String userName, NotificationEventTypes eventType) {
 216             Map<String, Object> eventProperties = new HashMap<>();
 217             eventProperties.put(ITEM_NAME, itemName == null ? itemManager.get(itemId).getName() : itemName);
 218             eventProperties.put(ITEM_ID, itemId);
 219
 220             eventProperties.put(PERMISSION_USER, userName);
 221
 222             Event syncEvent = new SyncEvent(eventType.getEventName(), itemId, eventProperties, itemId);
 223             try {
 224                 notifier.notifySubscribers(syncEvent, userName);
 225             } catch (Exception e) {
 226                 LOGGER.error("Failed to send sync notification to users subscribed to item '" + itemId);
 227             }
 228         }
 229     }
 230
 231     private Predicate<Item> createItemPredicate(String itemStatusFilter, String versionStatusFilter,
 232             String itemTypeFilter, String onboardingMethodFilter, String permissionsFilter, String user) {
 233         Predicate<Item> itemPredicate = item -> true;
 234
 235         if (itemStatusFilter != null) {
 236             validateItemStatusValue(itemStatusFilter);
 237             itemPredicate = itemPredicate.and(createItemStatusPredicate(itemStatusFilter));
 238         }
 239         if (versionStatusFilter != null) {
 240             validateVersionStatusValue(versionStatusFilter);
 241             itemPredicate = itemPredicate.and(createVersionStatusPredicate(versionStatusFilter));
 242         }
 243         if (itemTypeFilter != null) {
 244             validateItemTypeValue(itemTypeFilter);
 245             itemPredicate = itemPredicate.and(createItemTypePredicate(itemTypeFilter));
 246         }
 247         if (onboardingMethodFilter != null) {
 248             validateOnboardingMethodValue(onboardingMethodFilter);
 249             itemPredicate = itemPredicate.and(createOnboardingMethodPredicate(onboardingMethodFilter));
 250         }
 251         if (permissionsFilter != null) {
 252             validatePermissionValue(permissionsFilter);
 253             itemPredicate = itemPredicate.and(createPermissionsPredicate(user, permissionsFilter));
 254         }
 255         return itemPredicate;
 256     }
 257
 258     private String formatFilter(String filterValue) {
 259         return filterValue.replace(",", "|");
 260     }
 261
 262     private Predicate<Item> createItemStatusPredicate(String filterValue) {
 263         return item -> item.getStatus().name().matches(formatFilter(filterValue));
 264     }
 265
 266     private Predicate<Item> createVersionStatusPredicate(String filterValue) {
 267         Set<VersionStatus> versionStatuses =
 268                 Arrays.stream(filterValue.split(",")).map(VersionStatus::valueOf).collect(Collectors.toSet());
 269         return item -> item.getVersionStatusCounters().keySet().stream().anyMatch(versionStatuses::contains);
 270     }
 271
 272     private Predicate<Item> createItemTypePredicate(String filterValue) {
 273         return item -> item.getType().matches(formatFilter(filterValue));
 274     }
 275
 276     private Predicate<Item> createOnboardingMethodPredicate(String filterValue) {
 277         return item -> !ItemType.vsp.name().equals(item.getType()) || ((String) item.getProperties()
 278                                                                                     .get(ONBOARDING_METHOD))
 279                                                                               .matches(formatFilter(filterValue));
 280     }
 281
 282     private Predicate<Item> createPermissionsPredicate(String user, String filterValue) {
 283         String[] permissions = filterValue.split(",");
 284         Set<String> itemIds = new HashSet<>();
 285         for (String permission : permissions) {
 286             itemIds.addAll(permissionsManager.listUserPermittedItems(user, permission));
 287         }
 288         return item -> itemIds.contains(item.getId());
 289     }
 290
 291     private void validateItemStatusValue(String itemStatusFilter) {
 292         String[] values = itemStatusFilter.split(",");
 293         for (String value : values) {
 294             ItemStatus.valueOf(value);
 295         }
 296     }
 297
 298     private void validateVersionStatusValue(String versionStatusFilter) {
 299         String[] values = versionStatusFilter.split(",");
 300         for (String value : values) {
 301             VersionStatus.valueOf(value);
 302         }
 303
 304     }
 305
 306     private void validateItemTypeValue(String itemTypeFilter) {
 307         String[] values = itemTypeFilter.split(",");
 308         for (String value : values) {
 309             ItemType.valueOf(value);
 310         }
 311     }
 312
 313     private void validateOnboardingMethodValue(String onboardingMethodFilter) {
 314         String[] values = onboardingMethodFilter.split(",");
 315         for (String value : values) {
 316             OnboardingMethod.valueOf(value);
 317         }
 318     }
 319
 320     private void validatePermissionValue(String permissionsFilter) {
 321         String[] values = permissionsFilter.split(",");
 322         for (String value : values) {
 323             PermissionTypes.valueOf(value);
 324         }
 325     }
 326
 327     //Do not delete - is in use, duplicates code to prevent dependency on openecomp-sdc-vendor-software-product-api
 328     private enum OnboardingMethod {
 329         NetworkPackage, Manual;
 330     }
 331 }