openecomp-be/lib/openecomp-sdc-vendor-software-product-lib/openecomp-sdc-vendor-software-product-core/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/dao/impl/zusammen/ComputeDaoZusammenImpl.java

   1 package org.openecomp.sdc.vendorsoftwareproduct.dao.impl.zusammen;
   2
   3
   4 import com.amdocs.zusammen.adaptor.inbound.api.types.item.Element;
   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 org.openecomp.core.utilities.file.FileUtils;
  12 import org.openecomp.core.zusammen.api.ZusammenAdaptor;
  13 import org.openecomp.sdc.datatypes.model.ElementType;
  14 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComputeDao;
  15 import org.openecomp.sdc.vendorsoftwareproduct.dao.impl.zusammen.convertor.ElementToComputeConvertor;
  16 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentEntity;
  17 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComputeEntity;
  18 import org.openecomp.sdc.versioning.dao.types.Version;
  19 import org.openecomp.types.ElementPropertyName;
  20
  21 import java.io.ByteArrayInputStream;
  22 import java.util.Collection;
  23 import java.util.Collections;
  24 import java.util.Optional;
  25 import java.util.stream.Collectors;
  26
  27 import static org.openecomp.core.zusammen.api.ZusammenUtil.*;
  28
  29 public class ComputeDaoZusammenImpl implements ComputeDao {
  30
  31   private ZusammenAdaptor zusammenAdaptor;
  32
  33   public ComputeDaoZusammenImpl(ZusammenAdaptor zusammenAdaptor) {
  34     this.zusammenAdaptor = zusammenAdaptor;
  35   }
  36
  37   @Override
  38   public void registerVersioning(String versionableEntityType) {
  39     // registerVersioning not implemented for ComputeDaoZusammenImpl
  40   }
  41
  42   @Override
  43   public Collection<ComputeEntity> list(ComputeEntity compute) {
  44     SessionContext context = createSessionContext();
  45     ElementContext elementContext =
  46         new ElementContext(compute.getVspId(), compute.getVersion().getId());
  47
  48     return listComputes(context, elementContext, compute);
  49   }
  50
  51   private Collection<ComputeEntity> listComputes(SessionContext context,
  52                                                  ElementContext elementContext,
  53                                                  ComputeEntity compute) {
  54     return zusammenAdaptor
  55         .listElementsByName(context, elementContext, new Id(compute.getComponentId()),
  56             ElementType.Computes.name())
  57         .stream()
  58         .map(new ElementToComputeConvertor()::convert)
  59         .map(computeEntity -> {
  60           computeEntity.setComponentId(compute.getComponentId());
  61           computeEntity.setVspId(compute.getVspId());
  62           computeEntity.setVersion(compute.getVersion());
  63           return computeEntity;
  64         })
  65         .collect(Collectors.toList());
  66   }
  67
  68   @Override
  69   public void create(ComputeEntity compute) {
  70     ZusammenElement computeElement = computeToZusammen(compute, Action.CREATE);
  71
  72     ZusammenElement computesElement = buildStructuralElement(ElementType.Computes, Action.IGNORE);
  73     computesElement.setSubElements(Collections.singletonList(computeElement));
  74
  75     ZusammenElement componentElement =
  76         buildElement(new Id(compute.getComponentId()), Action.IGNORE);
  77     componentElement.setSubElements(Collections.singletonList(computesElement));
  78
  79     SessionContext context = createSessionContext();
  80     ElementContext elementContext =
  81         new ElementContext(compute.getVspId(), compute.getVersion().getId());
  82
  83     Element savedElement =
  84         zusammenAdaptor.saveElement(context, elementContext, componentElement, "Create compute");
  85     compute.setId(savedElement.getSubElements().iterator().next()
  86         .getSubElements().iterator().next().getElementId().getValue());
  87   }
  88
  89   @Override
  90   public void update(ComputeEntity compute) {
  91     ZusammenElement computeElement = computeToZusammen(compute, Action.UPDATE);
  92
  93     SessionContext context = createSessionContext();
  94     ElementContext elementContext =
  95         new ElementContext(compute.getVspId(), compute.getVersion().getId());
  96     zusammenAdaptor.saveElement(context, elementContext, computeElement,
  97         String.format("Update compute with id %s", compute.getId()));
  98   }
  99
 100   @Override
 101   public ComputeEntity get(ComputeEntity compute) {
 102     SessionContext context = createSessionContext();
 103     ElementContext elementContext =
 104         new ElementContext(compute.getVspId(), compute.getVersion().getId());
 105     Optional<Element> element =
 106         zusammenAdaptor.getElement(context, elementContext, compute.getId());
 107
 108     if (element.isPresent()) {
 109
 110       ElementToComputeConvertor convertor = new ElementToComputeConvertor();
 111       ComputeEntity entity = convertor.convert(element.get());
 112       entity.setVspId(compute.getVspId());
 113       entity.setVersion(compute.getVersion());
 114       entity.setComponentId(compute.getComponentId());
 115       return entity;
 116     } else {
 117       return null;
 118     }
 119   }
 120
 121   @Override
 122   public void delete(ComputeEntity compute) {
 123     ZusammenElement computeElement = buildElement(new Id(compute.getId()), Action.DELETE);
 124
 125     SessionContext context = createSessionContext();
 126     ElementContext elementContext =
 127         new ElementContext(compute.getVspId(), compute.getVersion().getId());
 128     zusammenAdaptor.saveElement(context, elementContext, computeElement,
 129         String.format("Delete compute with id %s", compute.getId()));
 130   }
 131
 132   @Override
 133   public ComputeEntity getQuestionnaireData(String vspId, Version version, String componentId,
 134                                             String computeId) {
 135     SessionContext context = createSessionContext();
 136     ElementContext elementContext = new ElementContext(vspId, version.getId());
 137
 138     return getQuestionnaire(context, elementContext,
 139         new ComputeEntity(vspId, version, componentId, computeId));
 140   }
 141
 142   private ComputeEntity getQuestionnaire(SessionContext context, ElementContext elementContext,
 143                                          ComputeEntity compute) {
 144     Optional<Element> questionnaireElement = zusammenAdaptor
 145         .getElementByName(context, elementContext, new Id(compute.getId()),
 146             ElementType.ComputeQuestionnaire.name());
 147     return questionnaireElement.map(
 148         element -> element.getData() == null
 149             ? null
 150             : new String(FileUtils.toByteArray(element.getData())))
 151         .map(questionnaireData -> {
 152           compute.setQuestionnaireData(questionnaireData);
 153           return compute;
 154         })
 155         .orElse(null);
 156   }
 157
 158   @Override
 159   public void updateQuestionnaireData(String vspId, Version version, String componentId,
 160                                       String computeId, String questionnaireData) {
 161     ZusammenElement questionnaireElement =
 162         computeQuestionnaireToZusammen(questionnaireData, Action.UPDATE);
 163
 164     ZusammenElement computeElement = buildElement(new Id(computeId), Action.IGNORE);
 165     computeElement.setSubElements(Collections.singletonList(questionnaireElement));
 166
 167     SessionContext context = createSessionContext();
 168     ElementContext elementContext = new ElementContext(vspId, version.getId());
 169     zusammenAdaptor.saveElement(context, elementContext, computeElement, "Update compute "
 170         + "questionnaire");
 171   }
 172
 173   @Override
 174   public Collection<ComputeEntity> listByVsp(String vspId, Version version) {
 175     SessionContext context = createSessionContext();
 176     ElementContext elementContext = new ElementContext(vspId, version.getId());
 177
 178     Collection<ComponentEntity> components = ComponentDaoZusammenImpl
 179         .listComponents(zusammenAdaptor, context, vspId, version);
 180
 181     return components.stream()
 182         .map(component ->
 183             listComputes(context, elementContext,
 184                 new ComputeEntity(vspId, version, component.getId(), null)).stream()
 185                 .map(compute -> getQuestionnaire(context, elementContext, compute))
 186                 .collect(Collectors.toList()))
 187         .flatMap(Collection::stream)
 188         .collect(Collectors.toList());
 189   }
 190
 191   @Override
 192   public void deleteAll(String vspId, Version version) {
 193
 194     SessionContext context = createSessionContext();
 195     ElementContext elementContext = new ElementContext(vspId, version.getId());
 196
 197     Optional<Element> optionalElement = zusammenAdaptor.getElementByName(context,
 198         elementContext, null, ElementType.Computes.name());
 199
 200     if (optionalElement.isPresent()) {
 201       Element computesElement = optionalElement.get();
 202       Collection<Element> computes = computesElement.getSubElements();
 203
 204       computes.forEach(compute -> {
 205         ZusammenElement computeElement = buildElement(compute.getElementId(), Action.DELETE);
 206         zusammenAdaptor.saveElement(context, elementContext, computeElement,
 207             "Delete compute with id " + compute.getElementId());
 208       });
 209     }
 210   }
 211
 212   private ZusammenElement computeToZusammen(ComputeEntity compute, Action action) {
 213     ZusammenElement computeElement = buildComputeElement(compute, action);
 214     if (action == Action.CREATE) {
 215       computeElement.setSubElements(Collections.singletonList(
 216           computeQuestionnaireToZusammen(compute.getQuestionnaireData(), Action.CREATE)));
 217     }
 218     return computeElement;
 219   }
 220
 221   private ZusammenElement computeQuestionnaireToZusammen(String questionnaireData,
 222                                                          Action action) {
 223     ZusammenElement questionnaireElement =
 224         buildStructuralElement(ElementType.ComputeQuestionnaire, action);
 225     questionnaireElement.setData(new ByteArrayInputStream(questionnaireData.getBytes()));
 226     return questionnaireElement;
 227   }
 228
 229   private ZusammenElement buildComputeElement(ComputeEntity compute, Action action) {
 230     ZusammenElement computeElement =
 231         buildElement(compute.getId() == null ? null : new Id(compute.getId()), action);
 232     Info info = new Info();
 233     info.addProperty(ElementPropertyName.elementType.name(), ElementType.Compute);
 234     info.addProperty(ElementPropertyName.compositionData.name(), compute.getCompositionData());
 235     computeElement.setInfo(info);
 236     computeElement.setData(new ByteArrayInputStream(compute.getCompositionData().getBytes()));
 237     return computeElement;
 238   }
 239 }