gerrit.onap Code Review - sdc/sdc-workflow-designer.git/blob

   1 package org.onap.sdc.workflow.services.impl;
   2
   3 import static org.openecomp.sdc.versioning.dao.types.VersionStatus.Certified;
   4
   5 import java.io.IOException;
   6 import java.io.InputStream;
   7 import java.util.Collection;
   8 import java.util.List;
   9 import java.util.Optional;
  10 import java.util.stream.Collectors;
  11 import org.onap.sdc.workflow.api.types.VersionRequestDto;
  12 import org.onap.sdc.workflow.persistence.ArtifactRepository;
  13 import org.onap.sdc.workflow.persistence.ParameterRepository;
  14 import org.onap.sdc.workflow.persistence.types.ArtifactEntity;
  15 import org.onap.sdc.workflow.persistence.types.ParameterEntity;
  16 import org.onap.sdc.workflow.persistence.types.ParameterRole;
  17 import org.onap.sdc.workflow.persistence.types.WorkflowVersion;
  18 import org.onap.sdc.workflow.persistence.types.WorkflowVersionState;
  19 import org.onap.sdc.workflow.services.WorkflowVersionManager;
  20 import org.onap.sdc.workflow.services.exceptions.EntityNotFoundException;
  21 import org.onap.sdc.workflow.services.exceptions.InvalidArtifactException;
  22 import org.onap.sdc.workflow.services.exceptions.VersionCreationException;
  23 import org.onap.sdc.workflow.services.exceptions.VersionModificationException;
  24 import org.onap.sdc.workflow.services.exceptions.VersionStateModificationException;
  25 import org.onap.sdc.workflow.services.impl.mappers.VersionMapper;
  26 import org.onap.sdc.workflow.services.impl.mappers.VersionStateMapper;
  27 import org.openecomp.sdc.versioning.VersioningManager;
  28 import org.openecomp.sdc.versioning.dao.types.Version;
  29 import org.openecomp.sdc.versioning.types.VersionCreationMethod;
  30 import org.springframework.beans.factory.annotation.Autowired;
  31 import org.springframework.stereotype.Service;
  32 import org.springframework.util.StringUtils;
  33 import org.springframework.web.multipart.MultipartFile;
  34 import org.openecomp.sdc.logging.api.Logger;
  35 import org.openecomp.sdc.logging.api.LoggerFactory;
  36
  37 @Service("workflowVersionManager")
  38 public class WorkflowVersionManagerImpl implements WorkflowVersionManager {
  39
  40     private static final String VERSION_NOT_EXIST_MSG = "version with id '%s' does not exist for workflow with id '%s'";
  41     private final VersioningManager versioningManager;
  42     private final ArtifactRepository artifactRepository;
  43     private final ParameterRepository parameterRepository;
  44     private final VersionMapper versionMapper;
  45     private final VersionStateMapper versionStateMapper;
  46     private static final Logger LOGGER = LoggerFactory.getLogger(WorkflowVersionManagerImpl.class);
  47
  48     @Autowired
  49     public WorkflowVersionManagerImpl(VersioningManager versioningManager, ArtifactRepository artifactRepository,
  50             VersionMapper versionMapper, VersionStateMapper versionStateMapper,
  51             ParameterRepository parameterRepository) {
  52         this.versioningManager = versioningManager;
  53         this.artifactRepository = artifactRepository;
  54         this.parameterRepository = parameterRepository;
  55         this.versionMapper = versionMapper;
  56         this.versionStateMapper = versionStateMapper;
  57     }
  58
  59     @Override
  60     public Collection<WorkflowVersion> list(String workflowId) {
  61         Collection<WorkflowVersion> versions =
  62                 versioningManager.list(workflowId).stream().map(versionMapper::versionToWorkflowVersion)
  63                                  .collect(Collectors.toList());
  64         versions.forEach(workflowVersion -> addVersionParameters(workflowId,workflowVersion));
  65
  66         return  versions;
  67     }
  68
  69     @Override
  70     public WorkflowVersion get(String workflowId, String versionId) {
  71         WorkflowVersion workflowVersion = versionMapper.versionToWorkflowVersion(getVersion(workflowId, versionId));
  72         addVersionParameters(workflowId,workflowVersion);
  73         return workflowVersion;
  74
  75     }
  76
  77
  78     @Override
  79     public WorkflowVersion create(String workflowId, VersionRequestDto versionRequest) {
  80         List<Version> versions = versioningManager.list(workflowId);
  81
  82         if (versionRequest.getBaseVersionId() != null) {
  83             validateVersionExistAndCertified(workflowId, versions, versionRequest.getBaseVersionId());
  84         } else if (!versions.isEmpty()) {
  85             throw new VersionCreationException(workflowId);
  86         }
  87
  88         Version version = new Version();
  89         version.setDescription(versionRequest.getDescription());
  90         version.setBaseId(versionRequest.getBaseVersionId());
  91         Version createdVersion = versioningManager.create(workflowId, version, VersionCreationMethod.major);
  92
  93         if (versions.isEmpty()) { // only for first version
  94             artifactRepository.createStructure(workflowId, createdVersion.getId());
  95             parameterRepository.createStructure(workflowId, createdVersion.getId());
  96             versioningManager.publish(workflowId, createdVersion, "Add workflow structure");
  97         }
  98
  99         updateVersionParameters(workflowId,  createdVersion.getId(), ParameterRole.INPUT, versionRequest.getInputs());
 100         updateVersionParameters(workflowId,  createdVersion.getId(), ParameterRole.OUTPUT, versionRequest.getOutputs());
 101
 102         return get(workflowId, createdVersion.getId());
 103     }
 104
 105     @Override
 106     public void update(String workflowId, WorkflowVersion workflowVersion) {
 107         Version retrievedVersion = getVersion(workflowId, workflowVersion.getId());
 108         if (WorkflowVersionState.CERTIFIED
 109             .equals(versionStateMapper.versionStatusToWorkflowVersionState(retrievedVersion.getStatus()))) {
 110             throw new VersionModificationException(workflowId, workflowVersion.getId());
 111         }
 112
 113         Version version = versionMapper.workflowVersionToVersion(workflowVersion);
 114         version.setName(retrievedVersion.getName());
 115         version.setStatus(retrievedVersion.getStatus());
 116
 117         updateVersionParameters(workflowId, version.getId(), ParameterRole.INPUT, workflowVersion.getInputs());
 118         updateVersionParameters(workflowId, version.getId(), ParameterRole.OUTPUT, workflowVersion.getOutputs());
 119
 120         versioningManager.updateVersion(workflowId, version);
 121         versioningManager.publish(workflowId, version, "Update version");
 122     }
 123
 124     @Override
 125     public WorkflowVersionState getState(String workflowId, String versionId) {
 126         return versionStateMapper.versionStatusToWorkflowVersionState(getVersion(workflowId, versionId).getStatus());
 127     }
 128
 129     @Override
 130     public void updateState(String workflowId, String versionId, WorkflowVersionState state) {
 131         Version retrievedVersion = getVersion(workflowId, versionId);
 132         WorkflowVersionState retrievedState =
 133             versionStateMapper.versionStatusToWorkflowVersionState(retrievedVersion.getStatus());
 134         if (WorkflowVersionState.CERTIFIED.equals(retrievedState) || retrievedState.equals(state)) {
 135             LOGGER.error(String.format(
 136                     "Workflow Version is certified and can not be edited.Workflow id %s and version id %s", workflowId,
 137                     versionId));
 138             throw new VersionStateModificationException(workflowId, versionId, retrievedState, state);
 139         }
 140
 141         retrievedVersion.setStatus(versionStateMapper.workflowVersionStateToVersionStatus(state));
 142         versioningManager.updateVersion(workflowId, retrievedVersion);
 143         versioningManager.publish(workflowId, retrievedVersion,
 144             String.format("Update version state from %s to %s", retrievedState.name(), state.name()));
 145     }
 146
 147     @Override
 148     public void uploadArtifact(String workflowId, String versionId, MultipartFile artifact) {
 149         Version retrievedVersion = getVersion(workflowId, versionId);
 150         if (WorkflowVersionState.CERTIFIED
 151             .equals(versionStateMapper.versionStatusToWorkflowVersionState(retrievedVersion.getStatus()))) {
 152             LOGGER.error(String.format("Workflow Version Artifact was not found for workflow id %s and version id %s",
 153                     workflowId, versionId));
 154             throw new VersionModificationException(workflowId, versionId);
 155         }
 156
 157         try (InputStream artifactData = artifact.getInputStream()) {
 158             ArtifactEntity artifactEntity =
 159                 new ArtifactEntity(StringUtils.cleanPath(artifact.getOriginalFilename()), artifactData);
 160             artifactRepository.update(workflowId, versionId, artifactEntity);
 161             versioningManager.publish(workflowId, new Version(versionId), "Update Artifact");
 162
 163         } catch (IOException e) {
 164             LOGGER.error(String.format("Upload Artifact failed for workflow id %s and version id %s",
 165                     workflowId, versionId),e);
 166             throw new InvalidArtifactException(e.getMessage());
 167         }
 168     }
 169
 170     @Override
 171     public ArtifactEntity getArtifact(String workflowId, String versionId) {
 172         getVersion(workflowId, versionId);
 173         Optional<ArtifactEntity> artifactOptional = artifactRepository.get(workflowId, versionId);
 174         if (!artifactOptional.isPresent()) {
 175             LOGGER.error(String.format("Workflow Version Artifact was not found for workflow id %s and version id %s",
 176                     workflowId, versionId));
 177             throw new EntityNotFoundException(
 178                     String.format("Artifact for workflow id %S version id %S was not found", workflowId, versionId));
 179         }
 180         return artifactOptional.get();
 181     }
 182
 183     @Override
 184     public void deleteArtifact(String workflowId, String versionId) {
 185         WorkflowVersion retrievedVersion = get(workflowId, versionId);
 186         if (WorkflowVersionState.CERTIFIED.equals(retrievedVersion.getState())) {
 187             LOGGER.error(String.format(
 188                     "Workflow Version is certified and can not be edited.Workflow id %s and version id %s", workflowId,
 189                     versionId));
 190             throw new VersionModificationException(workflowId, versionId);
 191         }
 192
 193         artifactRepository.delete(workflowId, versionId);
 194         versioningManager.publish(workflowId, new Version(versionId), "Delete Artifact");
 195     }
 196
 197     private void validateVersionExistAndCertified(String workflowId, List<Version> versions, String versionId) {
 198         Version baseVersion = findVersion(versions, versionId).orElseThrow(
 199             () -> new EntityNotFoundException(String.format(VERSION_NOT_EXIST_MSG, versionId, workflowId)));
 200
 201         if (!Certified.equals(baseVersion.getStatus())) {
 202             throw new VersionCreationException(workflowId, versionId);
 203         }
 204     }
 205
 206
 207     private Version getVersion(String workflowId, String versionId) {
 208         try {
 209             Version version = versioningManager.get(workflowId, new Version(versionId));
 210             if (version == null) {
 211                 throw new EntityNotFoundException(String.format(VERSION_NOT_EXIST_MSG, versionId, workflowId));
 212             }
 213             return version;
 214         } catch (Exception e) {
 215             LOGGER.error(String.format(
 216                     "Workflow Version was not found.Workflow id %s and version id %s", workflowId,
 217                     versionId),e);
 218             throw new EntityNotFoundException(String.format(VERSION_NOT_EXIST_MSG, versionId, workflowId));
 219         }
 220     }
 221
 222     private void updateVersionParameters(String workflowId, String versionId, ParameterRole role,
 223             Collection<ParameterEntity> parameters) {
 224
 225         Collection<ParameterEntity> retrievedParameters = parameterRepository.list(workflowId, versionId, role);
 226
 227         parameters.forEach(parameterEntity -> {
 228             if (retrievedParameters.stream().anyMatch(
 229                     parameterEntity1 -> parameterEntity.getName().equals(parameterEntity1.getName()))) {
 230                 parameterRepository.update(workflowId, versionId, role, parameterEntity);
 231             } else {
 232                 parameterRepository.create(workflowId, versionId, role, parameterEntity);
 233             }
 234         });
 235
 236         retrievedParameters.forEach(parameterEntity -> {
 237             if (parameters.stream().noneMatch(
 238                     parameterEntity1 -> parameterEntity.getName().equals(parameterEntity1.getName()))) {
 239                 parameterRepository.delete(workflowId, versionId, parameterEntity.getId());
 240             }
 241         });
 242     }
 243
 244     private static Optional<Version> findVersion(List<Version> versions, String versionId) {
 245         return versions.stream().filter(version -> versionId.equals(version.getId())).findFirst();
 246     }
 247
 248     private void addVersionParameters(String workflowId, WorkflowVersion workflowVersion) {
 249         workflowVersion.setInputs(parameterRepository.list(workflowId, workflowVersion.getId(), ParameterRole.INPUT));
 250         workflowVersion.setOutputs(parameterRepository.list(workflowId, workflowVersion.getId(), ParameterRole.OUTPUT));
 251     }
 252 }