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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.vendorsoftwareproduct.dao.impl.zusammen;
  22
  23 import com.amdocs.zusammen.adaptor.inbound.api.types.item.Element;
  24 import com.amdocs.zusammen.adaptor.inbound.api.types.item.ElementInfo;
  25 import com.amdocs.zusammen.adaptor.inbound.api.types.item.ZusammenElement;
  26 import com.amdocs.zusammen.datatypes.Id;
  27 import com.amdocs.zusammen.datatypes.SessionContext;
  28 import com.amdocs.zusammen.datatypes.item.Action;
  29 import com.amdocs.zusammen.datatypes.item.ElementContext;
  30 import com.amdocs.zusammen.datatypes.item.Info;
  31 import org.openecomp.core.zusammen.api.ZusammenAdaptor;
  32 import org.openecomp.sdc.datatypes.model.ElementType;
  33 import org.openecomp.sdc.vendorsoftwareproduct.dao.ProcessDao;
  34 import org.openecomp.sdc.vendorsoftwareproduct.dao.impl.zusammen.convertor.ElementToProcessConvertor;
  35 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ProcessEntity;
  36 import org.openecomp.sdc.versioning.dao.types.Version;
  37 import org.openecomp.types.ElementPropertyName;
  38
  39 import java.io.ByteArrayInputStream;
  40 import java.util.ArrayList;
  41 import java.util.Collection;
  42 import java.util.Objects;
  43 import java.util.Optional;
  44 import java.util.stream.Collectors;
  45
  46 import static org.openecomp.core.zusammen.api.ZusammenUtil.*;
  47 import static org.openecomp.sdc.vendorsoftwareproduct.dao.impl.zusammen.convertor.ElementToProcessConvertor.*;
  48
  49 /**
  50  * @author Avrahamg.
  51  * @since March 23, 2017
  52  */
  53 public class ProcessDaoZusammenImpl implements ProcessDao {
  54
  55   private ZusammenAdaptor zusammenAdaptor;
  56
  57   public ProcessDaoZusammenImpl(ZusammenAdaptor zusammenAdaptor) {
  58     this.zusammenAdaptor = zusammenAdaptor;
  59   }
  60
  61   @Override
  62   public void registerVersioning(String versionableEntityType) {
  63     // registerVersioning not implemented for ProcessDaoZusammenImpl
  64   }
  65
  66   @Override
  67   public void create(ProcessEntity processEntity) {
  68     ZusammenElement processElement = buildProcessElement(processEntity, Action.CREATE);
  69
  70     ZusammenElement processesElement =
  71         buildStructuralElement(ElementType.Processes, Action.IGNORE);
  72     ZusammenElement aggregatedElement = VspZusammenUtil.aggregateElements(processesElement,
  73         processElement);
  74     ZusammenElement componentElement;
  75     if (processEntity.getComponentId() != null) {
  76       componentElement = buildElement(new Id(processEntity.getComponentId()), Action.IGNORE);
  77       aggregatedElement =
  78           VspZusammenUtil.aggregateElements(componentElement, aggregatedElement);
  79     }
  80
  81     SessionContext context = createSessionContext();
  82     ElementContext elementContext =
  83         new ElementContext(processEntity.getVspId(), processEntity.getVersion().getId());
  84
  85     Element savedElement =
  86         zusammenAdaptor.saveElement(context, elementContext, aggregatedElement, "Create process");
  87     processEntity
  88         .setId(processEntity.getComponentId() == null
  89             ? savedElement.getSubElements().iterator().next().getElementId().getValue()
  90             : savedElement.getSubElements().iterator().next().getSubElements()
  91                 .iterator().next().getElementId().getValue());
  92   }
  93
  94   @Override
  95   public ProcessEntity get(ProcessEntity processEntity) {
  96     SessionContext context = createSessionContext();
  97     ElementContext elementContext =
  98         new ElementContext(processEntity.getVspId(), processEntity.getVersion().getId());
  99
 100     return zusammenAdaptor.getElementInfo(context, elementContext, new Id(processEntity.getId()))
 101         .map(elementInfo -> convertToProcessEntity(elementInfo, new ElementToProcessConvertor(),
 102             processEntity))
 103         .orElse(null);
 104   }
 105
 106   @Override
 107   public void update(ProcessEntity processEntity) {
 108     ProcessEntity retrieved = getArtifact(processEntity);
 109     if (retrieved != null && retrieved.getArtifact() != null) {
 110       processEntity.setArtifactName(retrieved.getArtifactName());
 111       processEntity.setArtifact(retrieved.getArtifact());
 112     }
 113
 114     update(processEntity, "Update process");
 115   }
 116
 117   @Override
 118   public void delete(ProcessEntity processEntity) {
 119     ZusammenElement processElement = buildElement(new Id(processEntity.getId()), Action.DELETE);
 120
 121     SessionContext context = createSessionContext();
 122     ElementContext elementContext =
 123         new ElementContext(processEntity.getVspId(), processEntity.getVersion().getId());
 124
 125     zusammenAdaptor.saveElement(context, elementContext, processElement,
 126         String.format("Delete process with id %s", processEntity.getId()));
 127   }
 128
 129   @Override
 130   public void deleteAll(ProcessEntity processEntity) {
 131     SessionContext context = createSessionContext();
 132     ElementContext elementContext =
 133         new ElementContext(processEntity.getVspId(), processEntity.getVersion().getId());
 134
 135     Optional<Element> optionalElement = zusammenAdaptor.getElementByName(context,
 136         elementContext, new Id(processEntity.getComponentId()), ElementType.Processes.name());
 137
 138     if (optionalElement.isPresent()) {
 139       Element processesElement = optionalElement.get();
 140       Collection<Element> processes = processesElement.getSubElements();
 141
 142       processes.forEach(process -> {
 143         ZusammenElement processZusammenElement =
 144             buildElement(process.getElementId(), Action.DELETE);
 145         zusammenAdaptor.saveElement(context, elementContext, processZusammenElement,
 146             "Delete Process with id " + process.getElementId());
 147       });
 148     }
 149   }
 150
 151   @Override
 152   public void deleteVspAll(String vspId, Version version) {
 153     SessionContext context = createSessionContext();
 154     ElementContext elementContext =
 155         new ElementContext(vspId, version.getId());
 156
 157     Optional<Element> optionalElement = zusammenAdaptor.getElementByName(context,
 158         elementContext, null, ElementType.Processes.name());
 159
 160     if (optionalElement.isPresent()) {
 161       Element processesElement = optionalElement.get();
 162       Collection<Element> processes = processesElement.getSubElements();
 163
 164       processes.forEach(process -> {
 165         ZusammenElement processZusammenElement =
 166             buildElement(process.getElementId(), Action.DELETE);
 167         zusammenAdaptor.saveElement(context, elementContext, processZusammenElement,
 168             "Delete Process with id " + process.getElementId());
 169       });
 170     }
 171   }
 172
 173   @Override
 174   public ProcessEntity getArtifact(ProcessEntity processEntity) {
 175     SessionContext context = createSessionContext();
 176     ElementContext elementContext =
 177         new ElementContext(processEntity.getVspId(), processEntity.getVersion().getId());
 178
 179     return zusammenAdaptor.getElement(context, elementContext, processEntity.getId())
 180         .map(element -> {
 181           ProcessEntity process = new ElementToProcessConvertor().convert(element);
 182           process.setVspId(processEntity.getVspId());
 183           process.setVersion(processEntity.getVersion());
 184           process.setComponentId(processEntity.getComponentId());
 185           return process;
 186         })
 187         .orElse(null);
 188   }
 189
 190   @Override
 191   public void uploadArtifact(ProcessEntity processEntity) {
 192     ProcessEntity retrieved = get(processEntity);
 193     if (retrieved != null) {
 194       retrieved.setArtifactName(processEntity.getArtifactName());
 195       retrieved.setArtifact(processEntity.getArtifact());
 196
 197       update(retrieved, "Upload process artifact");
 198     }
 199   }
 200
 201   @Override
 202   public void deleteArtifact(ProcessEntity processEntity) {
 203     ProcessEntity retrieved = get(processEntity);
 204     if (retrieved != null) {
 205       retrieved.setArtifactName(null);
 206       retrieved.setArtifact(null);
 207
 208       update(retrieved, "Delete process artifact");
 209     }
 210   }
 211
 212   @Override
 213   public Collection<ProcessEntity> list(ProcessEntity processEntity) {
 214     SessionContext context = createSessionContext();
 215     ElementContext elementContext =
 216         new ElementContext(processEntity.getVspId(), processEntity.getVersion().getId());
 217
 218     Optional<ElementInfo> processesOptional =
 219         zusammenAdaptor.getElementInfoByName(context, elementContext,
 220             extractParentElementId(processEntity), ElementType.Processes.name());
 221     if (!processesOptional.isPresent()) {
 222       return new ArrayList<>();
 223     }
 224     ElementToProcessConvertor convertor = new ElementToProcessConvertor();
 225     return zusammenAdaptor.listElements(context, elementContext, processesOptional.get().getId())
 226         .stream()
 227         .map(elementInfo -> convertToProcessEntity(elementInfo, convertor, processEntity))
 228         .collect(Collectors.toList());
 229   }
 230
 231   private ProcessEntity convertToProcessEntity(ElementInfo elementInfo,
 232                                                ElementToProcessConvertor convertor,
 233                                                ProcessEntity inputProcess) {
 234     ProcessEntity process = convertor.convert(elementInfo);
 235     process.setVspId(inputProcess.getVspId());
 236     process.setVersion(inputProcess.getVersion());
 237     process.setComponentId(inputProcess.getComponentId());
 238     return process;
 239   }
 240
 241   private void update(ProcessEntity processEntity, String message) {
 242     ZusammenElement processElement = buildProcessElement(processEntity, Action.UPDATE);
 243
 244     SessionContext context = createSessionContext();
 245     ElementContext elementContext =
 246         new ElementContext(processEntity.getVspId(), processEntity.getVersion().getId());
 247
 248     zusammenAdaptor.saveElement(context, elementContext, processElement, message);
 249   }
 250
 251   private Id extractParentElementId(ProcessEntity processEntity) {
 252     return processEntity.getComponentId() == null ? null : new Id(processEntity.getComponentId());
 253   }
 254
 255   private ZusammenElement buildProcessElement(ProcessEntity process, Action action) {
 256
 257     Info info = new Info();
 258     info.setName(process.getName());
 259     info.addProperty(NAME, process.getName());
 260     info.addProperty(ElementPropertyName.elementType.name(), ElementType.Process);
 261     info.addProperty(ARTIFACT_NAME, process.getArtifactName());
 262     info.addProperty(DESCRIPTION, process.getDescription());
 263     info.addProperty(PROCESS_TYPE, process.getType() != null ? process.getType().name() : null);
 264
 265     ZusammenElement processElement = buildElement(new Id(process.getId()), action);
 266     processElement.setInfo(info);
 267     if (Objects.nonNull(process.getArtifact())) {
 268       processElement.setData(new ByteArrayInputStream(process.getArtifact().array()));
 269     }
 270     return processElement;
 271   }
 272
 273 }