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

   1 package org.onap.sdc.workflow.services.impl;
   2
   3 import static org.onap.sdc.workflow.api.RestConstants.SORT_FIELD_NAME;
   4
   5 import java.util.ArrayList;
   6 import java.util.Collection;
   7 import java.util.Collections;
   8 import java.util.Comparator;
   9 import java.util.List;
  10 import java.util.Set;
  11 import java.util.function.Predicate;
  12 import java.util.stream.Collectors;
  13 import org.onap.sdc.workflow.persistence.types.Workflow;
  14 import org.onap.sdc.workflow.persistence.types.WorkflowVersionState;
  15 import org.onap.sdc.workflow.services.UniqueValueService;
  16 import org.onap.sdc.workflow.services.WorkflowManager;
  17 import org.onap.sdc.workflow.services.WorkflowNameComparator;
  18 import org.onap.sdc.workflow.services.exceptions.EntityNotFoundException;
  19 import org.onap.sdc.workflow.services.impl.mappers.VersionStateMapper;
  20 import org.onap.sdc.workflow.services.impl.mappers.WorkflowMapper;
  21 import org.openecomp.sdc.logging.api.Logger;
  22 import org.openecomp.sdc.logging.api.LoggerFactory;
  23 import org.openecomp.sdc.versioning.ItemManager;
  24 import org.openecomp.sdc.versioning.dao.types.VersionStatus;
  25 import org.openecomp.sdc.versioning.types.Item;
  26 import org.openecomp.sdc.versioning.types.ItemStatus;
  27 import org.springframework.beans.factory.annotation.Autowired;
  28 import org.springframework.beans.factory.annotation.Qualifier;
  29 import org.springframework.data.domain.Pageable;
  30 import org.springframework.data.domain.Sort;
  31 import org.springframework.stereotype.Service;
  32 import org.springframework.util.CollectionUtils;
  33
  34 @Service("workflowManager")
  35 public class WorkflowManagerImpl implements WorkflowManager {
  36
  37     public static final String WORKFLOW_TYPE = "WORKFLOW";
  38     private static final String WORKFLOW_NOT_FOUND_ERROR_MSG = "Workflow with id '%s' does not exist";
  39     private static final String WORKFLOW_NAME_UNIQUE_TYPE = "WORKFLOW_NAME";
  40     static final Predicate<Item> WORKFLOW_ITEM_FILTER = item -> WORKFLOW_TYPE.equals(item.getType());
  41
  42     private static final Logger LOGGER = LoggerFactory.getLogger(WorkflowManagerImpl.class);
  43     private final ItemManager itemManager;
  44     private final UniqueValueService uniqueValueService;
  45     private final WorkflowMapper workflowMapper;
  46     private final VersionStateMapper versionStateMapper;
  47
  48     @Autowired
  49     public WorkflowManagerImpl(ItemManager itemManager,
  50             @Qualifier("uniqueValueService") UniqueValueService uniqueValueService, WorkflowMapper workflowMapper,
  51             VersionStateMapper versionStateMapper) {
  52         this.itemManager = itemManager;
  53         this.uniqueValueService = uniqueValueService;
  54         this.workflowMapper = workflowMapper;
  55         this.versionStateMapper = versionStateMapper;
  56     }
  57
  58     @Override
  59     public Collection<Workflow> list(Set<WorkflowVersionState> versionStatesFilter, Pageable pageRequest) {
  60         Set<VersionStatus> versionStatusesFilter =
  61                 CollectionUtils.isEmpty(versionStatesFilter) ? Collections.emptySet() :
  62                         versionStatesFilter.stream().map(versionStateMapper::workflowVersionStateToVersionStatus)
  63                                            .collect(Collectors.toSet());
  64
  65         List<Workflow> workflows = itemManager.list(getFilter(versionStatusesFilter)).stream()
  66                                               .map(workflowMapper::itemToWorkflow)
  67                                               .collect(Collectors.toList());
  68         sortWorkflows(workflows, pageRequest);
  69         return applyLimitAndOffset(workflows, pageRequest);
  70     }
  71
  72     @Override
  73     public Workflow get(Workflow workflow) {
  74         Item retrievedItem = itemManager.get(workflow.getId());
  75         if (retrievedItem == null) {
  76             LOGGER.error(String.format("Workflow with id %s was not found",workflow.getId()));
  77             throw new EntityNotFoundException(String.format(WORKFLOW_NOT_FOUND_ERROR_MSG, workflow.getId()));
  78         }
  79         return this.workflowMapper.itemToWorkflow(retrievedItem);
  80     }
  81
  82     @Override
  83     public Workflow create(Workflow workflow) {
  84         Item item = workflowMapper.workflowToItem(workflow);
  85         item.setStatus(ItemStatus.ACTIVE);
  86
  87         uniqueValueService.validateUniqueValue(WORKFLOW_NAME_UNIQUE_TYPE, new String[] {workflow.getName()});
  88         Item createdItem = itemManager.create(item);
  89         uniqueValueService.createUniqueValue(WORKFLOW_NAME_UNIQUE_TYPE, new String[] {workflow.getName()});
  90
  91         return workflowMapper.itemToWorkflow(createdItem);
  92     }
  93
  94     @Override
  95     public void update(Workflow workflow) {
  96         Item retrievedItem = itemManager.get(workflow.getId());
  97         if (retrievedItem == null) {
  98             LOGGER.error(String.format("Workflow with id %s was not found",workflow.getId()));
  99             throw new EntityNotFoundException(String.format(WORKFLOW_NOT_FOUND_ERROR_MSG, workflow.getId()));
 100         }
 101
 102         uniqueValueService.updateUniqueValue(WORKFLOW_NAME_UNIQUE_TYPE, retrievedItem.getName(), workflow.getName());
 103
 104         Item item = workflowMapper.workflowToItem(workflow);
 105         item.setId(workflow.getId());
 106         item.setStatus(retrievedItem.getStatus());
 107         item.setVersionStatusCounters(retrievedItem.getVersionStatusCounters());
 108         itemManager.update(item);
 109     }
 110
 111     private List<Workflow> applyLimitAndOffset(List<Workflow> workflowList, Pageable pageRequest) {
 112         int limit = pageRequest.getPageSize();
 113         int offset = pageRequest.getPageNumber();
 114         int totalNumOfWorkflows = workflowList.size();
 115         List<Workflow> selectedWorkflows;
 116         try {
 117             if (limit > totalNumOfWorkflows) {
 118                 limit = totalNumOfWorkflows;
 119             }
 120             int startIndex = offset * limit;
 121             int endIndex = startIndex + limit;
 122             if (endIndex > totalNumOfWorkflows) {
 123                 endIndex = totalNumOfWorkflows;
 124             }
 125             selectedWorkflows = workflowList.subList(startIndex, endIndex);
 126         } catch (IndexOutOfBoundsException | IllegalArgumentException ex) {
 127             selectedWorkflows = new ArrayList<>();
 128         }
 129         return selectedWorkflows;
 130     }
 131
 132     private void sortWorkflows(List<Workflow> workflows, Pageable pageRequest) {
 133         Comparator<Workflow> comparator = getWorkflowsComparator();
 134         if (pageRequest.getSort().getOrderFor(SORT_FIELD_NAME).getDirection() == Sort.Direction.ASC) {
 135             workflows.sort(comparator);
 136         } else {
 137             workflows.sort(Collections.reverseOrder(comparator));
 138         }
 139     }
 140
 141     private Comparator<Workflow> getWorkflowsComparator() {
 142         //More comparators can be added if required based on sort field name
 143         return new WorkflowNameComparator();
 144     }
 145
 146     private static Predicate<Item> getFilter(Set<VersionStatus> versionStatuses) {
 147         return CollectionUtils.isEmpty(versionStatuses)
 148                        ? WORKFLOW_ITEM_FILTER
 149                        : WORKFLOW_ITEM_FILTER.and(item -> item.getVersionStatusCounters().keySet().stream()
 150                                                               .anyMatch(versionStatuses::contains));
 151     }
 152 }