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