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.ElementInfo;
   5 import com.amdocs.zusammen.adaptor.inbound.api.types.item.ZusammenElement;
   6 import com.amdocs.zusammen.datatypes.Id;
   7 import com.amdocs.zusammen.datatypes.SessionContext;
   8 import com.amdocs.zusammen.datatypes.item.Action;
   9 import com.amdocs.zusammen.datatypes.item.ElementContext;
  10 import com.amdocs.zusammen.datatypes.item.Info;
  11 import com.amdocs.zusammen.datatypes.item.Item;
  12 import com.amdocs.zusammen.datatypes.item.ItemVersion;
  13 import com.amdocs.zusammen.datatypes.item.ItemVersionData;
  14 import com.amdocs.zusammen.datatypes.itemversion.Tag;
  15 import com.amdocs.zusammen.datatypes.response.Response;
  16 import com.amdocs.zusammen.datatypes.response.ReturnCode;
  17 import org.openecomp.core.zusammen.api.ZusammenAdaptor;
  18 import org.openecomp.core.zusammen.db.ZusammenConnector;
  19 import org.openecomp.sdc.datatypes.error.ErrorLevel;
  20 import org.openecomp.sdc.logging.context.impl.MdcDataErrorMessage;
  21 import org.openecomp.sdc.logging.types.LoggerConstants;
  22 import org.openecomp.sdc.logging.types.LoggerErrorCode;
  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<ItemVersion> getFirstVersion(SessionContext context, Id itemId) {
  41     Collection<ItemVersion> versions = connector.listVersions(context, itemId);
  42     if(versions == null || versions.size()==0) {
  43       return Optional.empty();
  44     }
  45     List<ItemVersion> itemVersions = new ArrayList<>(versions);
  46     sortItemVersionListByModificationTimeDescOrder(itemVersions);
  47     ItemVersion itemVersion = itemVersions.iterator().next();
  48
  49     return Optional.ofNullable(itemVersion);
  50   }
  51
  52   @Override
  53   public Optional<ElementInfo> getElementInfo(SessionContext context, ElementContext elementContext,
  54                                               Id elementId) {
  55     Response<ElementInfo> response = connector.getElementInfo(context, elementContext, elementId);
  56     return response.isSuccessful() ? Optional.ofNullable(response.getValue()) : Optional.empty();
  57   }
  58
  59   @Override
  60   public Optional<Element> getElement(SessionContext context, ElementContext elementContext,
  61                                       String elementId) {
  62     Response<Element> response = connector.getElement(context, elementContext, new Id(elementId));
  63     return response.isSuccessful() ? Optional.ofNullable(response.getValue()) : Optional.empty();
  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         .map(elementInfo -> getElement(context, elementContext, elementInfo.getId().getValue()))
  76         .orElse(Optional.empty());
  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
  90     Collection<ElementInfo> elementInfoList = connector.listElements(context, elementContext,
  91         parentElementId);
  92     if (elementInfoList != null) {
  93       return elementInfoList.stream().map(elementInfo -> connector.getElement(context,
  94           elementContext, elementInfo.getId()).getValue()).collect(Collectors.toList());
  95     }
  96
  97     return new ArrayList<>();
  98
  99   }
 100
 101
 102   @Override
 103   public Collection<ElementInfo> listElementsByName(
 104       SessionContext context, ElementContext elementContext, Id parentElementId,
 105       String elementName) {
 106     Optional<ElementInfo> elementInfoByName =
 107         getElementInfoByName(context, elementContext, parentElementId, elementName);
 108
 109     return elementInfoByName.isPresent()
 110         ? connector.listElements(context, elementContext, elementInfoByName.get().getId())
 111         : new ArrayList<>();
 112   }
 113
 114   @Override
 115   public Optional<ElementInfo> getElementInfoByName(
 116       SessionContext context, ElementContext elementContext, Id parentElementId,
 117       String elementName) {
 118     Collection<ElementInfo> elementInfos =
 119         connector.listElements(context, elementContext, parentElementId);
 120     return getFirstElementInfo(elementInfos,
 121         elementInfo -> elementInfo.getInfo() != null &&
 122             elementName.equals(elementInfo.getInfo().getName()));
 123   }
 124
 125   @Override
 126   public Optional<Element> saveElement(SessionContext context, ElementContext elementContext,
 127                                        ZusammenElement element, String message) {
 128     enrichElementHierarchyRec(context, elementContext, null, element);
 129     return connector.saveElement(context, elementContext, element, message);
 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   private void logErrorMessageToMdc(ItemElementLoggerTargetServiceName
 168                                         itemElementLoggerTargetServiceName,
 169                                     ReturnCode returnCode) {
 170     logErrorMessageToMdc(itemElementLoggerTargetServiceName, returnCode.toString());
 171   }
 172
 173   private void logErrorMessageToMdc(ItemElementLoggerTargetServiceName
 174                                         itemElementLoggerTargetServiceName,
 175                                     String message) {
 176     MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 177         itemElementLoggerTargetServiceName.getDescription(),
 178         ErrorLevel.ERROR.name(),
 179         LoggerErrorCode.BUSINESS_PROCESS_ERROR.getErrorCode(),
 180         message);
 181   }
 182
 183   @Override
 184   public Id createItem(SessionContext context, Info info) {
 185     return connector.createItem(context, info);
 186   }
 187
 188   @Override
 189   public Id createVersion(SessionContext context, Id itemId, Id baseVersionId, ItemVersionData
 190       itemVersionData) {
 191     return connector.createVersion(context, itemId, baseVersionId, itemVersionData);
 192
 193   }
 194
 195   @Override
 196   public Collection<Item> listItems(SessionContext context) {
 197     return connector.listItems(context);
 198   }
 199
 200   @Override
 201   public void updateVersion(SessionContext context, Id itemId, Id versionId,
 202                             ItemVersionData itemVersionData) {
 203     connector.updateVersion(context, itemId, versionId, itemVersionData);
 204   }
 205
 206   @Override
 207   public void tagVersion(SessionContext context, Id itemId, Id versionId, Tag tag) {
 208     connector.tagVersion(context, itemId, versionId, tag);
 209   }
 210
 211   @Override
 212   public void resetVersionHistory(SessionContext context, Id itemId, Id versionId,
 213                                   String changeRef) {
 214     connector.resetVersionHistory(context, itemId, versionId, changeRef);
 215   }
 216
 217   @Override
 218   public void updateItem(SessionContext context, Id itemId, Info info) {
 219     connector.updateItem(context, itemId, info);
 220   }
 221
 222   private static void sortItemVersionListByModificationTimeDescOrder(
 223       List<ItemVersion> itemVersions) {
 224     itemVersions.sort((o1, o2) -> ((Integer)o2.getId().getValue().length())
 225         .compareTo( (o1.getId().getValue().length())));
 226   }
 227
 228 }