gerrit.onap Code Review - sdc.git/blob

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