gerrit.onap Code Review - sdc.git/blob

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