gerrit.onap Code Review - sdc.git/blob

   1 package org.openecomp.core.zusammen.impl;
   2
   3 import com.amdocs.zusammen.adaptor.inbound.api.types.item.Element;
   4 import com.amdocs.zusammen.adaptor.inbound.api.types.item.ElementConflict;
   5 import com.amdocs.zusammen.adaptor.inbound.api.types.item.ElementInfo;
   6 import com.amdocs.zusammen.adaptor.inbound.api.types.item.ItemVersionConflict;
   7 import com.amdocs.zusammen.adaptor.inbound.api.types.item.ZusammenElement;
   8 import com.amdocs.zusammen.commons.health.data.HealthInfo;
   9 import com.amdocs.zusammen.datatypes.Id;
  10 import com.amdocs.zusammen.datatypes.SessionContext;
  11 import com.amdocs.zusammen.datatypes.item.Action;
  12 import com.amdocs.zusammen.datatypes.item.ElementContext;
  13 import com.amdocs.zusammen.datatypes.item.Info;
  14 import com.amdocs.zusammen.datatypes.item.Item;
  15 import com.amdocs.zusammen.datatypes.item.ItemVersion;
  16 import com.amdocs.zusammen.datatypes.item.ItemVersionData;
  17 import com.amdocs.zusammen.datatypes.item.ItemVersionStatus;
  18 import com.amdocs.zusammen.datatypes.item.Resolution;
  19 import com.amdocs.zusammen.datatypes.itemversion.ItemVersionRevisions;
  20 import com.amdocs.zusammen.datatypes.itemversion.Tag;
  21 import org.openecomp.core.zusammen.api.ZusammenAdaptor;
  22 import org.openecomp.core.zusammen.db.ZusammenConnector;
  23
  24 import java.util.ArrayList;
  25 import java.util.Collection;
  26 import java.util.List;
  27 import java.util.Optional;
  28 import java.util.function.Predicate;
  29 import java.util.stream.Collectors;
  30
  31 public class ZusammenAdaptorImpl implements ZusammenAdaptor {
  32
  33   private ZusammenConnector connector;
  34
  35   public ZusammenAdaptorImpl(ZusammenConnector connector) {
  36     this.connector = connector;
  37   }
  38
  39   @Override
  40   public Optional<ElementInfo> getElementInfo(SessionContext context, ElementContext elementContext,
  41                                               Id elementId) {
  42     return Optional.ofNullable(connector.getElementInfo(context, elementContext, elementId));
  43   }
  44
  45   @Override
  46   public Optional<Element> getElement(SessionContext context, ElementContext elementContext,
  47                                       String elementId) {
  48     return Optional.ofNullable(connector.getElement(context, elementContext, new Id(elementId)));
  49   }
  50
  51   @Override
  52   public Optional<Element> getElementByName(
  53       SessionContext context, ElementContext elementContext, Id parentElementId,
  54       String elementName) {
  55     Collection<ElementInfo> elementInfos =
  56         connector.listElements(context, elementContext, parentElementId);
  57     Predicate<ElementInfo> elementInfoPredicate = elementInfo -> elementInfo.getInfo() != null
  58         && elementName.equals(elementInfo.getInfo().getName());
  59     return getFirstElementInfo(elementInfos, elementInfoPredicate)
  60         .map(elementInfo -> getElement(context, elementContext, elementInfo.getId().getValue()))
  61         .orElse(Optional.empty());
  62   }
  63
  64   @Override
  65   public Collection<ElementInfo> listElements(SessionContext context, ElementContext elementContext,
  66                                               Id parentElementId) {
  67     return connector.listElements(context, elementContext, parentElementId);
  68   }
  69
  70   @Override
  71   public Collection<Element> listElementData(SessionContext context,
  72                                              ElementContext elementContext,
  73                                              Id parentElementId) {
  74     Collection<ElementInfo> elementInfoList = connector.listElements(context, elementContext,
  75         parentElementId);
  76
  77     return elementInfoList == null
  78         ? new ArrayList<>()
  79         : elementInfoList.stream()
  80             .map(elementInfo -> connector.getElement(context, elementContext, elementInfo.getId()))
  81             .collect(Collectors.toList());
  82   }
  83
  84
  85   @Override
  86   public Collection<ElementInfo> listElementsByName(
  87       SessionContext context, ElementContext elementContext, Id parentElementId,
  88       String elementName) {
  89     Optional<ElementInfo> elementInfoByName =
  90         getElementInfoByName(context, elementContext, parentElementId, elementName);
  91
  92     return elementInfoByName.isPresent()
  93         ? connector.listElements(context, elementContext, elementInfoByName.get().getId())
  94         : new ArrayList<>();
  95   }
  96
  97   @Override
  98   public Optional<ElementInfo> getElementInfoByName(
  99       SessionContext context, ElementContext elementContext, Id parentElementId,
 100       String elementName) {
 101     Collection<ElementInfo> elementInfos =
 102         connector.listElements(context, elementContext, parentElementId);
 103     return getFirstElementInfo(elementInfos,
 104         elementInfo -> elementInfo.getInfo() != null &&
 105             elementName.equals(elementInfo.getInfo().getName()));
 106   }
 107
 108   @Override
 109   public Optional<ElementConflict> getElementConflict(SessionContext context,
 110                                                       ElementContext elementContext,
 111                                                       Id elementId) {
 112     return Optional.ofNullable(connector.getElementConflict(context, elementContext, elementId));
 113   }
 114
 115   @Override
 116   public Element saveElement(SessionContext context, ElementContext elementContext,
 117                              ZusammenElement element, String message) {
 118     enrichElementHierarchyRec(context, elementContext, null, element);
 119     return connector.saveElement(context, elementContext, element, message);
 120   }
 121
 122   @Override
 123   public void resolveElementConflict(SessionContext context, ElementContext elementContext,
 124                                      ZusammenElement element, Resolution resolution) {
 125     connector.resolveElementConflict(context, elementContext, element, resolution);
 126   }
 127
 128   private void enrichElementHierarchyRec(SessionContext context, ElementContext
 129       elementContext, Id parentElementId, ZusammenElement element) {
 130     if (element.getAction() == Action.CREATE) {
 131       return;
 132     }
 133     locateElementAndUpdateAction(context, elementContext, parentElementId, element);
 134     element.getSubElements().forEach(subElement -> enrichElementHierarchyRec(
 135         context, elementContext, element.getElementId(), (ZusammenElement) subElement));
 136   }
 137
 138   // should be applied only for structural elements
 139   private void locateElementAndUpdateAction(SessionContext context, ElementContext elementContext,
 140                                             Id parentElementId, ZusammenElement element) {
 141     if (element.getElementId() != null) {
 142       return;
 143     }
 144     Optional<ElementInfo> elementInfo =
 145         getElementInfoByName(context, elementContext, parentElementId, element.getInfo().getName());
 146     if (elementInfo.isPresent()) {
 147       element.setElementId(elementInfo.get().getId());
 148       if (element.getAction() == null) {
 149         element.setAction(Action.IGNORE);
 150       }
 151     } else {
 152       element.setAction(Action.CREATE);
 153     }
 154   }
 155
 156   private Optional<ElementInfo> getFirstElementInfo(Collection<ElementInfo> elementInfos,
 157                                                     Predicate<ElementInfo> elementInfoPredicate) {
 158     return elementInfos.stream()
 159         .filter(elementInfoPredicate)
 160         .findFirst();
 161   }
 162
 163   @Override
 164   public Collection<Item> listItems(SessionContext context) {
 165     return connector.listItems(context);
 166   }
 167
 168   @Override
 169   public Item getItem(SessionContext context, Id itemId) {
 170     return connector.getItem(context, itemId);
 171   }
 172
 173   @Override
 174   public Id createItem(SessionContext context, Info info) {
 175     return connector.createItem(context, info);
 176   }
 177
 178   @Override
 179   public void updateItem(SessionContext context, Id itemId, Info info) {
 180     connector.updateItem(context, itemId, info);
 181   }
 182
 183   @Override
 184   public Optional<ItemVersion> getFirstVersion(SessionContext context, Id itemId) {
 185     Collection<ItemVersion> versions = connector.listPublicVersions(context, itemId);
 186     if (versions == null || versions.isEmpty()) {
 187       return Optional.empty();
 188     }
 189     List<ItemVersion> itemVersions = new ArrayList<>(versions);
 190     sortItemVersionListByModificationTimeDescOrder(itemVersions);
 191     ItemVersion itemVersion = itemVersions.iterator().next();
 192
 193     return Optional.ofNullable(itemVersion);
 194   }
 195
 196   @Override
 197   public Collection<ItemVersion> listPublicVersions(SessionContext context, Id itemId) {
 198     return connector.listPublicVersions(context, itemId);
 199   }
 200
 201   @Override
 202   public ItemVersion getPublicVersion(SessionContext context, Id itemId, Id versionId) {
 203     return connector.getPublicVersion(context, itemId, versionId);
 204   }
 205
 206   @Override
 207   public ItemVersion getVersion(SessionContext context, Id itemId, Id versionId) {
 208     return connector.getVersion(context, itemId, versionId);
 209   }
 210
 211   @Override
 212   public ItemVersionStatus getVersionStatus(SessionContext context, Id itemId, Id versionId) {
 213     return connector.getVersionStatus(context, itemId, versionId);
 214   }
 215
 216   @Override
 217   public ItemVersionConflict getVersionConflict(SessionContext context, Id itemId, Id versionId) {
 218     return connector.getVersionConflict(context, itemId, versionId);
 219   }
 220
 221   @Override
 222   public Id createVersion(SessionContext context, Id itemId, Id baseVersionId, ItemVersionData
 223       itemVersionData) {
 224     return connector.createVersion(context, itemId, baseVersionId, itemVersionData);
 225   }
 226
 227   @Override
 228   public void updateVersion(SessionContext context, Id itemId, Id versionId,
 229                             ItemVersionData itemVersionData) {
 230     connector.updateVersion(context, itemId, versionId, itemVersionData);
 231   }
 232
 233   @Override
 234   public void tagVersion(SessionContext context, Id itemId, Id versionId, Tag tag) {
 235     connector.tagVersion(context, itemId, versionId, tag);
 236   }
 237
 238   @Override
 239   public void resetVersionHistory(SessionContext context, Id itemId, Id versionId,
 240                                   String changeRef) {
 241     connector.resetVersionHistory(context, itemId, versionId, changeRef);
 242   }
 243
 244   @Override
 245   public void publishVersion(SessionContext context, Id itemId, Id versionId, String message) {
 246     connector.publishVersion(context, itemId, versionId, message);
 247   }
 248
 249   @Override
 250   public void syncVersion(SessionContext context, Id itemId, Id versionId) {
 251     connector.syncVersion(context, itemId, versionId);
 252   }
 253
 254   @Override
 255   public void forceSyncVersion(SessionContext context, Id itemId, Id versionId) {
 256     connector.forceSyncVersion(context, itemId, versionId);
 257   }
 258
 259   @Override
 260   public void revert(SessionContext context, Id itemId, Id versionId, Id revisionId) {
 261     connector.revertVersionRevision(context, itemId, versionId, revisionId);
 262   }
 263
 264   @Override
 265   public ItemVersionRevisions listRevisions(SessionContext context, Id itemId, Id versionId) {
 266     return connector.listVersionRevisions(context, itemId, versionId);
 267   }
 268
 269   @Override
 270   public Collection<HealthInfo> checkHealth(SessionContext context) {
 271     return connector.checkHealth(context);
 272   }
 273
 274   @Override
 275   public String getVersion(SessionContext context) {
 276     return connector.getVersion(context);
 277   }
 278
 279   private static void sortItemVersionListByModificationTimeDescOrder(
 280       List<ItemVersion> itemVersions) {
 281     itemVersions.sort((o1, o2) -> ((Integer) o2.getId().getValue().length())
 282         .compareTo((o1.getId().getValue().length())));
 283   }
 284 }