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