gerrit.onap Code Review - sdc.git/blob

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