openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-core/src/main/java/org/openecomp/core/zusammen/impl/ZusammenAdaptorImpl.java

   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 import org.openecomp.sdc.versioning.dao.types.Revision;
  24
  25 import java.util.ArrayList;
  26 import java.util.Collection;
  27 import java.util.Comparator;
  28 import java.util.List;
  29 import java.util.Optional;
  30 import java.util.function.Predicate;
  31 import java.util.stream.Collectors;
  32
  33 public class ZusammenAdaptorImpl implements ZusammenAdaptor {
  34
  35   private ZusammenConnector connector;
  36
  37   public ZusammenAdaptorImpl(ZusammenConnector connector) {
  38     this.connector = connector;
  39   }
  40
  41   @Override
  42   public Optional<ElementInfo> getElementInfo(SessionContext context, ElementContext elementContext,
  43                                               Id elementId) {
  44     return Optional.ofNullable(connector.getElementInfo(context, elementContext, elementId));
  45   }
  46
  47   @Override
  48   public Optional<Element> getElement(SessionContext context, ElementContext elementContext,
  49                                       String elementId) {
  50     return Optional.ofNullable(connector.getElement(context, elementContext, new Id(elementId)));
  51   }
  52
  53   @Override
  54   public Optional<Element> getElementByName(
  55       SessionContext context, ElementContext elementContext, Id parentElementId,
  56       String elementName) {
  57     Collection<ElementInfo> elementInfos =
  58         connector.listElements(context, elementContext, parentElementId);
  59     Predicate<ElementInfo> elementInfoPredicate = elementInfo -> elementInfo.getInfo() != null
  60         && elementName.equals(elementInfo.getInfo().getName());
  61     return getFirstElementInfo(elementInfos, elementInfoPredicate)
  62         .map(elementInfo -> getElement(context, elementContext, elementInfo.getId().getValue()))
  63         .orElse(Optional.empty());
  64   }
  65
  66   @Override
  67   public Collection<ElementInfo> listElements(SessionContext context, ElementContext elementContext,
  68                                               Id parentElementId) {
  69     return connector.listElements(context, elementContext, parentElementId);
  70   }
  71
  72   @Override
  73   public Collection<Element> listElementData(SessionContext context,
  74                                              ElementContext elementContext,
  75                                              Id parentElementId) {
  76     Collection<ElementInfo> elementInfoList = connector.listElements(context, elementContext,
  77         parentElementId);
  78
  79     return elementInfoList == null
  80         ? new ArrayList<>()
  81         : elementInfoList.stream()
  82             .map(elementInfo -> connector.getElement(context, elementContext, elementInfo.getId()))
  83             .collect(Collectors.toList());
  84   }
  85
  86
  87   @Override
  88   public Collection<ElementInfo> listElementsByName(
  89       SessionContext context, ElementContext elementContext, Id parentElementId,
  90       String elementName) {
  91     Optional<ElementInfo> elementInfoByName =
  92         getElementInfoByName(context, elementContext, parentElementId, elementName);
  93
  94     return elementInfoByName.isPresent()
  95         ? connector.listElements(context, elementContext, elementInfoByName.get().getId())
  96         : new ArrayList<>();
  97   }
  98
  99   @Override
 100   public Optional<ElementInfo> getElementInfoByName(
 101       SessionContext context, ElementContext elementContext, Id parentElementId,
 102       String elementName) {
 103     Collection<ElementInfo> elementInfos =
 104         connector.listElements(context, elementContext, parentElementId);
 105     return getFirstElementInfo(elementInfos,
 106         elementInfo -> elementInfo.getInfo() != null &&
 107             elementName.equals(elementInfo.getInfo().getName()));
 108   }
 109
 110   @Override
 111   public Optional<ElementConflict> getElementConflict(SessionContext context, ElementContext elementContext,
 112                                                       Id elementId) {
 113     return Optional.ofNullable(connector.getElementConflict(context, elementContext, elementId));
 114   }
 115
 116   @Override
 117   public Element saveElement(SessionContext context, ElementContext elementContext,
 118                              ZusammenElement element, String message) {
 119     enrichElementHierarchyRec(context, elementContext, null, element);
 120     return connector.saveElement(context, elementContext, element, message);
 121   }
 122
 123   @Override
 124   public void resolveElementConflict(SessionContext context, ElementContext elementContext,
 125                                      ZusammenElement element, Resolution resolution) {
 126     connector.resolveElementConflict(context, elementContext, element, resolution);
 127   }
 128
 129   private void enrichElementHierarchyRec(SessionContext context, ElementContext
 130       elementContext, Id parentElementId, ZusammenElement element) {
 131     if (element.getAction() == Action.CREATE) {
 132       return;
 133     }
 134     locateElementAndUpdateAction(context, elementContext, parentElementId, element);
 135     element.getSubElements().forEach(subElement -> enrichElementHierarchyRec(
 136         context, elementContext, element.getElementId(), (ZusammenElement) subElement));
 137   }
 138
 139   // should be applied only for structural elements
 140   private void locateElementAndUpdateAction(SessionContext context, ElementContext elementContext,
 141                                             Id parentElementId, ZusammenElement element) {
 142     if (element.getElementId() != null) {
 143       return;
 144     }
 145     Optional<ElementInfo> elementInfo =
 146         getElementInfoByName(context, elementContext, parentElementId, element.getInfo().getName());
 147     if (elementInfo.isPresent()) {
 148       element.setElementId(elementInfo.get().getId());
 149       if (element.getAction() == null) {
 150         element.setAction(Action.IGNORE);
 151       }
 152     } else {
 153       element.setAction(Action.CREATE);
 154     }
 155   }
 156
 157   private Optional<ElementInfo> getFirstElementInfo(Collection<ElementInfo> elementInfos,
 158                                                     Predicate<ElementInfo> elementInfoPredicate) {
 159     return elementInfos.stream()
 160         .filter(elementInfoPredicate)
 161         .findFirst();
 162   }
 163
 164   @Override
 165   public Collection<Item> listItems(SessionContext context) {
 166     return connector.listItems(context);
 167   }
 168
 169   @Override
 170   public Item getItem(SessionContext context, Id itemId) {
 171     return connector.getItem(context, itemId);
 172   }
 173
 174   @Override
 175   public Id createItem(SessionContext context, Info info) {
 176     return connector.createItem(context, info);
 177   }
 178
 179   @Override
 180   public void updateItem(SessionContext context, Id itemId, Info info) {
 181     connector.updateItem(context, itemId, info);
 182   }
 183
 184   @Override
 185   public Optional<ItemVersion> getFirstVersion(SessionContext context, Id itemId) {
 186     Collection<ItemVersion> versions = connector.listPublicVersions(context, itemId);
 187     if (versions == null || versions.size() == 0) {
 188       return Optional.empty();
 189     }
 190     List<ItemVersion> itemVersions = new ArrayList<>(versions);
 191     sortItemVersionListByModificationTimeDescOrder(itemVersions);
 192     ItemVersion itemVersion = itemVersions.iterator().next();
 193
 194     return Optional.ofNullable(itemVersion);
 195   }
 196
 197   @Override
 198   public Collection<ItemVersion> listPublicVersions(SessionContext context, Id itemId) {
 199     return connector.listPublicVersions(context, itemId);
 200   }
 201
 202   @Override
 203   public ItemVersion getPublicVersion(SessionContext context, Id itemId, Id versionId) {
 204     return connector.getPublicVersion(context, itemId, versionId);
 205   }
 206
 207   @Override
 208   public ItemVersion getVersion(SessionContext context, Id itemId, Id versionId) {
 209     return connector.getVersion(context, itemId, versionId);
 210   }
 211
 212   @Override
 213   public ItemVersionStatus getVersionStatus(SessionContext context, Id itemId, Id versionId) {
 214     return connector.getVersionStatus(context, itemId, versionId);
 215   }
 216
 217   @Override
 218   public ItemVersionConflict getVersionConflict(SessionContext context, Id itemId, Id versionId) {
 219     return connector.getVersionConflict(context, itemId, versionId);
 220   }
 221
 222   @Override
 223   public Id createVersion(SessionContext context, Id itemId, Id baseVersionId, ItemVersionData
 224       itemVersionData) {
 225     return connector.createVersion(context, itemId, baseVersionId, itemVersionData);
 226   }
 227
 228   @Override
 229   public void updateVersion(SessionContext context, Id itemId, Id versionId,
 230                             ItemVersionData itemVersionData) {
 231     connector.updateVersion(context, itemId, versionId, itemVersionData);
 232   }
 233
 234   @Override
 235   public void tagVersion(SessionContext context, Id itemId, Id versionId, Tag tag) {
 236     connector.tagVersion(context, itemId, versionId, tag);
 237   }
 238
 239   @Override
 240   public void resetVersionHistory(SessionContext context, Id itemId, Id versionId,
 241                                   String changeRef) {
 242     connector.resetVersionHistory(context, itemId, versionId, changeRef);
 243   }
 244
 245   /*@Override
 246   public void revertVersionToRevision(SessionContext context, Id itemId, Id versionId,
 247                                       Id revisionId) {
 248     connector.resetVersionRevision(context, itemId, versionId, revisionId);
 249   }*/
 250
 251   /*@Override
 252   public ItemVersionRevisions listVersionRevisions(SessionContext context, Id itemId, Id
 253       versionId) {
 254     return connector.listVersionRevisions(context, itemId, versionId);
 255   }*/
 256
 257   @Override
 258   public void publishVersion(SessionContext context, Id itemId, Id versionId, String message) {
 259     connector.publishVersion(context, itemId, versionId, message);
 260   }
 261
 262   @Override
 263   public void syncVersion(SessionContext context, Id itemId, Id versionId) {
 264     connector.syncVersion(context, itemId, versionId);
 265   }
 266
 267   @Override
 268   public void forceSyncVersion(SessionContext context, Id itemId, Id versionId) {
 269     connector.forceSyncVersion(context, itemId, versionId);
 270   }
 271
 272   @Override
 273   public Collection<HealthInfo> checkHealth(SessionContext context) {
 274     return connector.checkHealth(context);
 275   }
 276
 277   @Override
 278   public String getVersion(SessionContext sessionContext) {
 279     return connector.getVersion(sessionContext);
 280   }
 281
 282   @Override
 283   public void revert(SessionContext sessionContext, String itemId, String versionId,
 284                      String revisionId) {
 285     connector.revertVersionRevision(sessionContext, new Id(itemId), new Id(versionId),
 286         new Id(revisionId));
 287   }
 288
 289   @Override
 290   public List<Revision> listRevisions(SessionContext sessionContext, String itemId,
 291                                       String versionId) {
 292     List<Revision> revisions = new ArrayList<>();
 293     ItemVersionRevisions itemVersionRevisions =
 294         connector.listVersionRevisions(sessionContext, new Id(itemId), new Id
 295             (versionId));
 296     if(itemVersionRevisions == null || itemVersionRevisions.getItemVersionRevisions()==null ||
 297         itemVersionRevisions.getItemVersionRevisions().size()==0) {
 298       return revisions;
 299     }
 300     else{
 301       revisions =  itemVersionRevisions.getItemVersionRevisions().stream().map
 302           (revision -> {
 303         Revision rev = new Revision();
 304         rev.setId(revision.getRevisionId().getValue());
 305         rev.setTime(revision.getTime());
 306         rev.setUser(revision.getUser());
 307         rev.setMessage(revision.getMessage());
 308         return rev;
 309       }).collect(Collectors.toList());
 310       revisions.sort(new Comparator<Revision>() {
 311         @Override
 312         public int compare(Revision o1, Revision o2) {
 313           if(o1.getTime().before(o2.getTime())) return 1;
 314           else return -1;
 315         }
 316       });
 317       // when creating a new item an initial version is created with
 318       // invalid data. this revision is not an applicable revision.
 319       //the logic of identifying this revision is:
 320       //1- only the first version of item has this issue
 321       //2- only in the first item version there are 2 revisions created
 322       //3- the second revision is in format "Initial {vlm/vsp}: {name of the vlm/vsp}
 323       //4- only if a revision in this format exists we remove the first revision.
 324       if(revisions.size()>1 && revisions.get(revisions.size()-2).getMessage().matches("Initial " +
 325           ".*:.*")){
 326         revisions.remove(revisions.size()-1);
 327       }
 328       return revisions;
 329     }
 330   }
 331
 332   private static void sortItemVersionListByModificationTimeDescOrder(
 333       List<ItemVersion> itemVersions) {
 334     itemVersions.sort((o1, o2) -> ((Integer) o2.getId().getValue().length())
 335         .compareTo((o1.getId().getValue().length())));
 336   }
 337 }