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.commons.health.data.HealthInfo;
   7 import com.amdocs.zusammen.datatypes.Id;
   8 import com.amdocs.zusammen.datatypes.SessionContext;
   9 import com.amdocs.zusammen.datatypes.item.*;
  10 import com.amdocs.zusammen.datatypes.itemversion.Tag;
  11 import com.amdocs.zusammen.datatypes.response.Response;
  12 import com.amdocs.zusammen.datatypes.response.ReturnCode;
  13 import org.openecomp.core.zusammen.api.ZusammenAdaptor;
  14 import org.openecomp.core.zusammen.db.ZusammenConnector;
  15 import org.openecomp.sdc.datatypes.error.ErrorLevel;
  16 import org.openecomp.sdc.logging.context.impl.MdcDataErrorMessage;
  17 import org.openecomp.sdc.logging.types.LoggerConstants;
  18 import org.openecomp.sdc.logging.types.LoggerErrorCode;
  19
  20 import java.util.ArrayList;
  21 import java.util.Collection;
  22 import java.util.List;
  23 import java.util.Optional;
  24 import java.util.function.Predicate;
  25 import java.util.stream.Collectors;
  26
  27 public class ZusammenAdaptorImpl implements ZusammenAdaptor {
  28
  29   private ZusammenConnector connector;
  30
  31   public ZusammenAdaptorImpl(ZusammenConnector connector) {
  32     this.connector = connector;
  33   }
  34
  35   @Override
  36   public Optional<ItemVersion> getFirstVersion(SessionContext context, Id itemId) {
  37     Collection<ItemVersion> versions = connector.listVersions(context, itemId);
  38     if(versions == null || versions.size()==0) {
  39       return Optional.empty();
  40     }
  41     List<ItemVersion> itemVersions = new ArrayList<>(versions);
  42     sortItemVersionListByModificationTimeDescOrder(itemVersions);
  43     ItemVersion itemVersion = itemVersions.iterator().next();
  44
  45     return Optional.ofNullable(itemVersion);
  46   }
  47
  48   @Override
  49   public Optional<ElementInfo> getElementInfo(SessionContext context, ElementContext elementContext,
  50                                               Id elementId) {
  51     Response<ElementInfo> response = connector.getElementInfo(context, elementContext, elementId);
  52     return response.isSuccessful() ? Optional.ofNullable(response.getValue()) : Optional.empty();
  53   }
  54
  55   @Override
  56   public Optional<Element> getElement(SessionContext context, ElementContext elementContext,
  57                                       String elementId) {
  58     Response<Element> response = connector.getElement(context, elementContext, new Id(elementId));
  59     return response.isSuccessful() ? Optional.ofNullable(response.getValue()) : Optional.empty();
  60   }
  61
  62   @Override
  63   public Optional<Element> getElementByName(
  64       SessionContext context, ElementContext elementContext, Id parentElementId,
  65       String elementName) {
  66     Collection<ElementInfo> elementInfos =
  67         connector.listElements(context, elementContext, parentElementId);
  68     Predicate<ElementInfo> elementInfoPredicate = elementInfo -> elementInfo.getInfo() != null
  69         && elementName.equals(elementInfo.getInfo().getName());
  70     return getFirstElementInfo(elementInfos, elementInfoPredicate)
  71         .map(elementInfo -> getElement(context, elementContext, elementInfo.getId().getValue()))
  72         .orElse(Optional.empty());
  73   }
  74
  75   @Override
  76   public Collection<ElementInfo> listElements(SessionContext context, ElementContext elementContext,
  77                                               Id parentElementId) {
  78     return connector.listElements(context, elementContext, parentElementId);
  79   }
  80
  81   @Override
  82   public Collection<Element> listElementData(SessionContext context,
  83                                              ElementContext elementContext,
  84                                              Id parentElementId) {
  85
  86     Collection<ElementInfo> elementInfoList = connector.listElements(context, elementContext,
  87         parentElementId);
  88     if (elementInfoList != null) {
  89       return elementInfoList.stream().map(elementInfo -> connector.getElement(context,
  90           elementContext, elementInfo.getId()).getValue()).collect(Collectors.toList());
  91     }
  92
  93     return new ArrayList<>();
  94
  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<Element> saveElement(SessionContext context, ElementContext elementContext,
 123                                        ZusammenElement element, String message) {
 124     enrichElementHierarchyRec(context, elementContext, null, element);
 125     return connector.saveElement(context, elementContext, element, message);
 126   }
 127
 128   private void enrichElementHierarchyRec(SessionContext context, ElementContext
 129       elementContext, Id parentElementId, ZusammenElement element) {
 130     if (element.getAction() == Action.CREATE) {
 131       return;
 132     }
 133     locateElementAndUpdateAction(context, elementContext, parentElementId, element);
 134     element.getSubElements().forEach(subElement -> enrichElementHierarchyRec(
 135         context, elementContext, element.getElementId(), (ZusammenElement) subElement));
 136   }
 137
 138   // should be applied only for structural elements
 139   private void locateElementAndUpdateAction(SessionContext context, ElementContext elementContext,
 140                                             Id parentElementId, ZusammenElement element) {
 141     if (element.getElementId() != null) {
 142       return;
 143     }
 144     Optional<ElementInfo> elementInfo =
 145         getElementInfoByName(context, elementContext, parentElementId, element.getInfo().getName());
 146     if (elementInfo.isPresent()) {
 147       element.setElementId(elementInfo.get().getId());
 148       if (element.getAction() == null) {
 149         element.setAction(Action.IGNORE);
 150       }
 151     } else {
 152       element.setAction(Action.CREATE);
 153     }
 154   }
 155
 156   private Optional<ElementInfo> getFirstElementInfo(Collection<ElementInfo> elementInfos,
 157                                                     Predicate<ElementInfo> elementInfoPredicate) {
 158     return elementInfos.stream()
 159         .filter(elementInfoPredicate)
 160         .findFirst();
 161   }
 162
 163   private void logErrorMessageToMdc(ItemElementLoggerTargetServiceName
 164                                         itemElementLoggerTargetServiceName,
 165                                     ReturnCode returnCode) {
 166     logErrorMessageToMdc(itemElementLoggerTargetServiceName, returnCode.toString());
 167   }
 168
 169   private void logErrorMessageToMdc(ItemElementLoggerTargetServiceName
 170                                         itemElementLoggerTargetServiceName,
 171                                     String message) {
 172     MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 173         itemElementLoggerTargetServiceName.getDescription(),
 174         ErrorLevel.ERROR.name(),
 175         LoggerErrorCode.BUSINESS_PROCESS_ERROR.getErrorCode(),
 176         message);
 177   }
 178
 179   @Override
 180   public Id createItem(SessionContext context, Info info) {
 181     return connector.createItem(context, info);
 182   }
 183
 184   @Override
 185   public Id createVersion(SessionContext context, Id itemId, Id baseVersionId, ItemVersionData
 186       itemVersionData) {
 187     return connector.createVersion(context, itemId, baseVersionId, itemVersionData);
 188
 189   }
 190
 191   @Override
 192   public Collection<Item> listItems(SessionContext context) {
 193     return connector.listItems(context);
 194   }
 195
 196   @Override
 197   public void updateVersion(SessionContext context, Id itemId, Id versionId,
 198                             ItemVersionData itemVersionData) {
 199     connector.updateVersion(context, itemId, versionId, itemVersionData);
 200   }
 201
 202   @Override
 203   public void tagVersion(SessionContext context, Id itemId, Id versionId, Tag tag) {
 204     connector.tagVersion(context, itemId, versionId, tag);
 205   }
 206
 207   @Override
 208   public void resetVersionHistory(SessionContext context, Id itemId, Id versionId,
 209                                   String changeRef) {
 210     connector.resetVersionHistory(context, itemId, versionId, changeRef);
 211   }
 212
 213   @Override
 214   public void updateItem(SessionContext context, Id itemId, Info info) {
 215     connector.updateItem(context, itemId, info);
 216   }
 217
 218
 219   @Override
 220   public Collection<HealthInfo> checkHealth(SessionContext context) {
 221     return connector.checkHealth(context);
 222   }
 223
 224   private static void sortItemVersionListByModificationTimeDescOrder(
 225       List<ItemVersion> itemVersions) {
 226     itemVersions.sort((o1, o2) -> ((Integer)o2.getId().getValue().length())
 227         .compareTo( (o1.getId().getValue().length())));
 228   }
 229
 230   @Override
 231   public String getVersion(SessionContext sessionContext) {
 232     return connector.getVersion(sessionContext);
 233   }
 234 }