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.types.ArtifactEntity;
  14 import org.onap.sdc.workflow.persistence.types.WorkflowVersion;
  15 import org.onap.sdc.workflow.persistence.types.WorkflowVersionState;
  16 import org.onap.sdc.workflow.services.WorkflowVersionManager;
  17 import org.onap.sdc.workflow.services.exceptions.EntityNotFoundException;
  18 import org.onap.sdc.workflow.services.exceptions.InvalidArtifactException;
  19 import org.onap.sdc.workflow.services.exceptions.VersionCreationException;
  20 import org.onap.sdc.workflow.services.exceptions.VersionModificationException;
  21 import org.onap.sdc.workflow.services.exceptions.VersionStateModificationException;
  22 import org.onap.sdc.workflow.services.impl.mappers.VersionMapper;
  23 import org.onap.sdc.workflow.services.impl.mappers.VersionStateMapper;
  24 import org.openecomp.sdc.versioning.VersioningManager;
  25 import org.openecomp.sdc.versioning.dao.types.Version;
  26 import org.openecomp.sdc.versioning.types.VersionCreationMethod;
  27 import org.springframework.beans.factory.annotation.Autowired;
  28 import org.springframework.stereotype.Service;
  29 import org.springframework.util.StringUtils;
  30 import org.springframework.web.multipart.MultipartFile;
  31
  32 @Service("workflowVersionManager")
  33 public class WorkflowVersionManagerImpl implements WorkflowVersionManager {
  34
  35     private static final String VERSION_NOT_EXIST_MSG = "version with id '%s' does not exist for workflow with id '%s'";
  36     private final VersioningManager versioningManager;
  37     private final ArtifactRepository artifactRepository;
  38     private final VersionMapper versionMapper;
  39     private final VersionStateMapper versionStateMapper;
  40
  41
  42     @Autowired
  43     public WorkflowVersionManagerImpl(VersioningManager versioningManager, ArtifactRepository artifactRepository,
  44         VersionMapper versionMapper, VersionStateMapper versionStateMapper) {
  45         this.versioningManager = versioningManager;
  46         this.artifactRepository = artifactRepository;
  47         this.versionMapper = versionMapper;
  48         this.versionStateMapper = versionStateMapper;
  49     }
  50
  51     @Override
  52     public Collection<WorkflowVersion> list(String workflowId) {
  53         return versioningManager.list(workflowId).stream().map(versionMapper::versionToWorkflowVersion)
  54             .collect(Collectors.toList());
  55     }
  56
  57     @Override
  58     public WorkflowVersion get(String workflowId, String versionId) {
  59         return versionMapper.versionToWorkflowVersion(getVersion(workflowId, versionId));
  60     }
  61
  62     @Override
  63     public WorkflowVersion create(String workflowId, VersionRequestDto versionRequest) {
  64         List<Version> versions = versioningManager.list(workflowId);
  65
  66         if (versionRequest.getBaseVersionId() != null) {
  67             validateVersionExistAndCertified(workflowId, versions, versionRequest.getBaseVersionId());
  68         } else if (!versions.isEmpty()) {
  69             throw new VersionCreationException(workflowId);
  70         }
  71
  72         Version version = new Version();
  73         version.setDescription(versionRequest.getDescription());
  74         version.setBaseId(versionRequest.getBaseVersionId());
  75         Version createdVersion = versioningManager.create(workflowId, version, VersionCreationMethod.major);
  76
  77         if (versions.isEmpty()) { // only for first version
  78             artifactRepository.createStructure(workflowId, createdVersion.getId());
  79             versioningManager.publish(workflowId, createdVersion, "Add workflow structure");
  80         }
  81
  82         return versionMapper.versionToWorkflowVersion(createdVersion);
  83     }
  84
  85     @Override
  86     public void update(String workflowId, WorkflowVersion workflowVersion) {
  87         Version retrievedVersion = getVersion(workflowId, workflowVersion.getId());
  88         if (WorkflowVersionState.CERTIFIED
  89             .equals(versionStateMapper.versionStatusToWorkflowVersionState(retrievedVersion.getStatus()))) {
  90             throw new VersionModificationException(workflowId, workflowVersion.getId());
  91         }
  92
  93         Version version = versionMapper.workflowVersionToVersion(workflowVersion);
  94         version.setName(retrievedVersion.getName());
  95         version.setStatus(retrievedVersion.getStatus());
  96
  97         versioningManager.updateVersion(workflowId, version);
  98         versioningManager.publish(workflowId, version, "Update version");
  99     }
 100
 101     @Override
 102     public WorkflowVersionState getState(String workflowId, String versionId) {
 103         return versionStateMapper.versionStatusToWorkflowVersionState(getVersion(workflowId, versionId).getStatus());
 104     }
 105
 106     @Override
 107     public void updateState(String workflowId, String versionId, WorkflowVersionState state) {
 108         Version retrievedVersion = getVersion(workflowId, versionId);
 109         WorkflowVersionState retrievedState =
 110             versionStateMapper.versionStatusToWorkflowVersionState(retrievedVersion.getStatus());
 111         if (WorkflowVersionState.CERTIFIED.equals(retrievedState) || retrievedState.equals(state)) {
 112             throw new VersionStateModificationException(workflowId, versionId, retrievedState, state);
 113         }
 114
 115         retrievedVersion.setStatus(versionStateMapper.workflowVersionStateToVersionStatus(state));
 116         versioningManager.updateVersion(workflowId, retrievedVersion);
 117         versioningManager.publish(workflowId, retrievedVersion,
 118             String.format("Update version state from %s to %s", retrievedState.name(), state.name()));
 119     }
 120
 121     @Override
 122     public void uploadArtifact(String workflowId, String versionId, MultipartFile artifact) {
 123         Version retrievedVersion = getVersion(workflowId, versionId);
 124         if (WorkflowVersionState.CERTIFIED
 125             .equals(versionStateMapper.versionStatusToWorkflowVersionState(retrievedVersion.getStatus()))) {
 126             throw new VersionModificationException(workflowId, versionId);
 127         }
 128
 129         try (InputStream artifactData = artifact.getInputStream()) {
 130             ArtifactEntity artifactEntity =
 131                 new ArtifactEntity(StringUtils.cleanPath(artifact.getOriginalFilename()), artifactData);
 132             artifactRepository.update(workflowId, versionId, artifactEntity);
 133             versioningManager.publish(workflowId, new Version(versionId), "Update Artifact");
 134
 135         } catch (IOException e) {
 136             throw new InvalidArtifactException(e.getMessage());
 137         }
 138     }
 139
 140     @Override
 141     public ArtifactEntity getArtifact(String workflowId, String versionId) {
 142         getVersion(workflowId, versionId);
 143         Optional<ArtifactEntity> artifactOptional = artifactRepository.get(workflowId, versionId);
 144         if (!artifactOptional.isPresent()) {
 145             throw new EntityNotFoundException(
 146                 String.format("Artifact for workflow id %S version id %S was not found", workflowId, versionId));
 147         }
 148         return artifactOptional.get();
 149     }
 150
 151     @Override
 152     public void deleteArtifact(String workflowId, String versionId) {
 153         WorkflowVersion retrievedVersion = get(workflowId, versionId);
 154         if (WorkflowVersionState.CERTIFIED.equals(retrievedVersion.getState())) {
 155             throw new VersionModificationException(workflowId, versionId);
 156         }
 157
 158         artifactRepository.delete(workflowId, versionId);
 159         versioningManager.publish(workflowId, new Version(versionId), "Delete Artifact");
 160     }
 161
 162     private void validateVersionExistAndCertified(String workflowId, List<Version> versions, String versionId) {
 163         Version baseVersion = findVersion(versions, versionId).orElseThrow(
 164             () -> new EntityNotFoundException(String.format(VERSION_NOT_EXIST_MSG, versionId, workflowId)));
 165
 166         if (!Certified.equals(baseVersion.getStatus())) {
 167             throw new VersionCreationException(workflowId, versionId);
 168         }
 169     }
 170
 171     private Version getVersion(String workflowId, String versionId) {
 172         try {
 173             Version version = versioningManager.get(workflowId, new Version(versionId));
 174             if (version == null) {
 175                 throw new EntityNotFoundException(String.format(VERSION_NOT_EXIST_MSG, versionId, workflowId));
 176             }
 177             return version;
 178         } catch (Exception e) {
 179             throw new EntityNotFoundException(String.format(VERSION_NOT_EXIST_MSG, versionId, workflowId));
 180         }
 181     }
 182
 183     private static Optional<Version> findVersion(List<Version> versions, String versionId) {
 184         return versions.stream().filter(version -> versionId.equals(version.getId())).findFirst();
 185     }
 186 }