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

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