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/ComponentDaoZusammenImpl.java

   1 package org.openecomp.sdc.vendorsoftwareproduct.dao.impl.zusammen;
   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 org.openecomp.core.zusammen.api.ZusammenAdaptor;
  12 import org.openecomp.sdc.datatypes.model.ElementType;
  13 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDao;
  14 import org.openecomp.sdc.vendorsoftwareproduct.dao.impl.zusammen.convertor.ElementToComponentConvertor;
  15 import org.openecomp.sdc.vendorsoftwareproduct.dao.impl.zusammen.convertor.ElementToComponentQuestionnnaireConvertor;
  16 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentEntity;
  17 import org.openecomp.sdc.versioning.dao.types.Version;
  18 import org.openecomp.types.ElementPropertyName;
  19
  20 import java.io.ByteArrayInputStream;
  21 import java.util.ArrayList;
  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 ComponentDaoZusammenImpl implements ComponentDao {
  32
  33   private ZusammenAdaptor zusammenAdaptor;
  34
  35   public ComponentDaoZusammenImpl(ZusammenAdaptor zusammenAdaptor) {
  36     this.zusammenAdaptor = zusammenAdaptor;
  37   }
  38
  39   @Override
  40   public void registerVersioning(String versionableEntityType) {
  41   }
  42
  43   @Override
  44   public Collection<ComponentEntity> list(ComponentEntity component) {
  45     SessionContext context = createSessionContext();
  46
  47     return listComponents(zusammenAdaptor, context, component.getVspId(), component.getVersion());
  48   }
  49
  50   static Collection<ComponentEntity> listComponents(ZusammenAdaptor zusammenAdaptor,
  51                                                     SessionContext context,
  52                                                     String vspId, Version version) {
  53     ElementContext elementContext = new ElementContext(vspId, version.getId());
  54
  55     Optional<ElementInfo> vspModel = zusammenAdaptor
  56         .getElementInfoByName(context, elementContext, null, ElementType.VspModel.name());
  57     if (!vspModel.isPresent()) {
  58       return new ArrayList<>();
  59     }
  60
  61     ElementToComponentConvertor convertor = new ElementToComponentConvertor();
  62     return zusammenAdaptor.listElementsByName(context, elementContext, vspModel.get().getId(),
  63         ElementType.Components.name()).stream()
  64         .map(elementInfo -> {
  65           ComponentEntity entity = convertor.convert(elementInfo);
  66           entity.setVspId(vspId);
  67           entity.setVersion(version);
  68           return entity;
  69         })
  70         .collect(Collectors.toList());
  71   }
  72
  73
  74   @Override
  75   public void create(ComponentEntity component) {
  76     ZusammenElement componentElement = componentToZusammen(component, Action.CREATE);
  77
  78     ZusammenElement componentsElement =
  79         buildStructuralElement(ElementType.Components, Action.IGNORE);
  80     componentsElement.getSubElements().add(componentElement);
  81
  82     ZusammenElement vspModel = buildStructuralElement(ElementType.VspModel, Action.IGNORE);
  83     vspModel.addSubElement(componentsElement);
  84
  85     SessionContext context = createSessionContext();
  86     Element savedVspModel = zusammenAdaptor.saveElement(context,
  87         new ElementContext(component.getVspId(), component.getVersion().getId()),
  88         vspModel, "Create component");
  89     component.setId(savedVspModel.getSubElements().iterator().next()
  90         .getSubElements().iterator().next().getElementId().getValue());
  91   }
  92
  93   @Override
  94   public void update(ComponentEntity component) {
  95     ZusammenElement componentElement = componentToZusammen(component, Action.UPDATE);
  96
  97     SessionContext context = createSessionContext();
  98     zusammenAdaptor.saveElement(context,
  99         new ElementContext(component.getVspId(), component.getVersion().getId()),
 100         componentElement, String.format("Update component with id %s", component.getId()));
 101   }
 102
 103   @Override
 104   public ComponentEntity get(ComponentEntity component) {
 105     SessionContext context = createSessionContext();
 106
 107     Optional<Element> element =
 108         zusammenAdaptor.getElement(context,
 109             new ElementContext(component.getVspId(), component.getVersion().getId()),
 110             component.getId());
 111
 112     if (element.isPresent()) {
 113       ComponentEntity entity = new ElementToComponentConvertor().convert(element.get());
 114       entity.setVspId(component.getVspId());
 115       entity.setVersion(component.getVersion());
 116       return entity;
 117     }
 118     return null;
 119   }
 120
 121   @Override
 122   public void delete(ComponentEntity component) {
 123     ZusammenElement componentElement = buildElement(new Id(component.getId()), Action.DELETE);
 124
 125     SessionContext context = createSessionContext();
 126     zusammenAdaptor.saveElement(context,
 127         new ElementContext(component.getVspId(), component.getVersion().getId()),
 128         componentElement, String.format("Delete component with id %s", component.getId()));
 129   }
 130
 131   @Override
 132   public ComponentEntity getQuestionnaireData(String vspId, Version version, String componentId) {
 133     SessionContext context = createSessionContext();
 134
 135     return getQuestionnaire(context, new ElementContext(vspId, version.getId()),
 136         new ComponentEntity(vspId, version, componentId));
 137   }
 138
 139   private ComponentEntity getQuestionnaire(SessionContext context, ElementContext elementContext,
 140                                            ComponentEntity component) {
 141     Optional<Element> questionnaireElement = zusammenAdaptor
 142         .getElementByName(context, elementContext, new Id(component.getId()),
 143             ElementType.ComponentQuestionnaire.name());
 144     return questionnaireElement.map(new ElementToComponentQuestionnnaireConvertor()::convert)
 145         .map(entity -> {
 146           entity.setVspId(component.getVspId());
 147           entity.setVersion(component.getVersion());
 148           return entity;
 149         })
 150         .orElse(null);
 151   }
 152
 153   @Override
 154   public void updateQuestionnaireData(String vspId, Version version, String componentId,
 155                                       String questionnaireData) {
 156     ZusammenElement questionnaireElement =
 157         componentQuestionnaireToZusammen(questionnaireData, Action.UPDATE);
 158
 159     ZusammenElement componentElement = buildElement(new Id(componentId), Action.IGNORE);
 160     componentElement.setSubElements(Collections.singletonList(questionnaireElement));
 161
 162     SessionContext context = createSessionContext();
 163     zusammenAdaptor.saveElement(context, new ElementContext(vspId, version.getId()),
 164         componentElement, "Update component questionnaire");
 165   }
 166
 167   @Override
 168   public Collection<ComponentEntity> listQuestionnaires(String vspId, Version version) {
 169     return listCompositionAndQuestionnaire(vspId, version);
 170   }
 171
 172   @Override
 173   public Collection<ComponentEntity> listCompositionAndQuestionnaire(String vspId,
 174                                                                      Version version) {
 175     SessionContext context = createSessionContext();
 176
 177     Collection<ComponentEntity> components =
 178         listComponents(zusammenAdaptor, context, vspId, version);
 179
 180     ElementContext elementContext = new ElementContext(vspId, version.getId());
 181     components.forEach(component -> component.setQuestionnaireData(
 182         getQuestionnaire(context, elementContext, component).getQuestionnaireData()));
 183     return components;
 184   }
 185
 186   @Override
 187   public void deleteAll(String vspId, Version version) {
 188     SessionContext context = createSessionContext();
 189     ElementContext elementContext = new ElementContext(vspId, version.getId());
 190
 191     Collection<ElementInfo> vspModelSubs = zusammenAdaptor
 192         .listElementsByName(context, elementContext, null, ElementType.VspModel.name());
 193
 194     Optional<ElementInfo> componentsElement = vspModelSubs.stream()
 195         .filter(elementInfo -> elementInfo.getInfo() != null
 196             && ElementType.Components.name().equals(elementInfo.getInfo().getName()))
 197         .findFirst();
 198     if (!componentsElement.isPresent()) {
 199       return;
 200     }
 201
 202     ZusammenElement components = buildElement(componentsElement.get().getId(), Action.IGNORE);
 203     components.setSubElements(componentsElement.get().getSubElements().stream()
 204         .map(component -> buildElement(component.getId(), Action.DELETE))
 205         .collect(Collectors.toList()));
 206
 207     zusammenAdaptor.saveElement(context, elementContext, components, "Delete all components");
 208   }
 209
 210   private ZusammenElement componentToZusammen(ComponentEntity component, Action action) {
 211     ZusammenElement componentElement = buildComponentElement(component, action);
 212
 213     if (action == Action.CREATE) {
 214       ZusammenElement mibs = buildStructuralElement(ElementType.Mibs, Action.CREATE);
 215       mibs.addSubElement(buildStructuralElement(ElementType.SNMP_TRAP, Action.CREATE));
 216       mibs.addSubElement(buildStructuralElement(ElementType.VES_EVENTS, Action.CREATE));
 217       mibs.addSubElement(buildStructuralElement(ElementType.SNMP_POLL, Action.CREATE));
 218
 219       componentElement.addSubElement(mibs);
 220       componentElement.addSubElement(
 221           componentQuestionnaireToZusammen(component.getQuestionnaireData(), Action.CREATE));
 222       componentElement.addSubElement(buildStructuralElement(ElementType.Nics, Action.CREATE));
 223       componentElement.addSubElement(buildStructuralElement(ElementType.Processes, Action.CREATE));
 224       componentElement.addSubElement(buildStructuralElement(ElementType.Computes, Action.CREATE));
 225       componentElement.addSubElement(buildStructuralElement(ElementType.Images, Action.CREATE));
 226     }
 227     return componentElement;
 228   }
 229
 230   private ZusammenElement componentQuestionnaireToZusammen(String questionnaireData,
 231                                                            Action action) {
 232     ZusammenElement questionnaireElement =
 233         buildStructuralElement(ElementType.ComponentQuestionnaire, action);
 234     questionnaireElement.setData(new ByteArrayInputStream(questionnaireData.getBytes()));
 235     return questionnaireElement;
 236   }
 237
 238   private ZusammenElement buildComponentElement(ComponentEntity component, Action action) {
 239     ZusammenElement componentElement =
 240         buildElement(component.getId() == null ? null : new Id(component.getId()), action);
 241     Info info = new Info();
 242     info.addProperty(ElementPropertyName.elementType.name(), ElementType.Component);
 243     info.addProperty(ElementPropertyName.compositionData.name(), component.getCompositionData());
 244     componentElement.setInfo(info);
 245     componentElement.setData(new ByteArrayInputStream(component.getCompositionData().getBytes()));
 246     return componentElement;
 247   }
 248
 249
 250 }