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

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