nosu
/
taskana
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

TSK-266: added generic getTaskIds... to monitor.

This commit is contained in:
Holger Hagen 2018-04-25 22:25:48 +02:00
parent 74b61ccaa9
commit 2a6fe0ef77
5 changed files with 214 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
lib/taskana-core/src/main/java/pro/taskana/TaskMonitorService.java
View File

@ -128,6 +128,46 @@ public interface TaskMonitorService {
List<TimeIntervalColumnHeader> columnHeaders, boolean inWorkingDays)
throws InvalidArgumentException;
/**
* Returns a list of all task ids in the selected items of a {@link pro.taskana.impl.report.Report}. By default the
* age of the tasks is counted in working days. The tasks of the report are filtered by workbaskets, states,
* categories, domains and values of a custom field. If no filter is required, the respective parameter should be
* null. Tasks with Timestamp DUE = null are not considered.
*
* @param workbasketIds
* a list of workbasket ids objects to filter by workbaskets. To omit this filter, use null for this
* parameter
* @param states
* a list of states objects to filter by states. To omit this filter, use null for this parameter
* @param categories
* a list of categories to filter by categories. To omit this filter, use null for this parameter
* @param domains
* a list of domains to filter by domains. To omit this filter, use null for this parameter
* @param customField
* a custom field to filter by the values of the custom field. To omit this filter, use null for this
* parameter
* @param customFieldValues
* a list of custom field values to filter by the values of the custom field. To omit this filter, use
* null for this parameter
* @param columnHeaders
* a list of columnHeaders that specify the subdivision into different cluster of due dates. Days in past
* are represented as negative values and days in the future are represented as positive values. To avoid
* tasks are counted multiple times or not be listed in the report, these columnHeaders should not
* overlap and should not have gaps. If the ReportLineDefinition should represent a single day,
* lowerLimit and upperLimit have to be equal. The outer cluster of a report should have open ends. These
* open ends are represented with Integer.MIN_VALUE and Integer.MAX_VALUE.
* @param inWorkingDays
* a boolean parameter that specifies whether the age of the tasks should be counted in days or in
* working days
* @return the report
* @throws InvalidArgumentException
* thrown if DaysToWorkingDaysConverter is initialized with null
*/
List<String> getTaskIdsOfWorkbasketLevelReportLineItems(List<String> workbasketIds, List<TaskState> states,
List<String> categories, List<String> domains, CustomField customField, List<String> customFieldValues,
List<TimeIntervalColumnHeader> columnHeaders, boolean inWorkingDays, List<SelectedItem> selectedItems)
throws InvalidArgumentException;
/**
* Returns a {@link CategoryReport} grouped by categories. The report contains the total numbers of tasks of the
* respective category as well as the total number of all tasks. The tasks of the report are filtered by

53
lib/taskana-core/src/main/java/pro/taskana/impl/TaskMonitorServiceImpl.java
View File

@ -328,8 +328,11 @@ public class TaskMonitorServiceImpl implements TaskMonitorService {
selectedItems = convertWorkingDaysToDays(selectedItems, columnHeaders);
}
List<String> taskIds = taskMonitorMapper.getTaskIdsOfCategoriesBySelectedItems(workbasketIds, states,
categories, domains, customField, customFieldValues, selectedItems);
// List<String> taskIds = taskMonitorMapper.getTaskIdsOfCategoriesBySelectedItems(workbasketIds, states,
// categories, domains, customField, customFieldValues, selectedItems);
List<String> taskIds = taskMonitorMapper.getTaskIdsForSelectedItems(workbasketIds, states,
categories, domains, customField, customFieldValues, "CLASSIFICATION_CATEGORY", selectedItems);
return taskIds;
@ -372,6 +375,51 @@ public class TaskMonitorServiceImpl implements TaskMonitorService {
}
}
@Override
public List<String> getTaskIdsOfWorkbasketLevelReportLineItems(List<String> workbasketIds, List<TaskState> states,
List<String> categories, List<String> domains, CustomField customField, List<String> customFieldValues,
List<TimeIntervalColumnHeader> columnHeaders, boolean inWorkingDays, List<SelectedItem> selectedItems)
throws InvalidArgumentException {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("entry to getTaskIdsOfWorkbasketLevelReportLineItems(workbasketIds = {}, states = {}, "
+ "categories = {}, domains = {}, customField = {}, customFieldValues = {}, "
+ "columnHeaders = {}, inWorkingDays = {}, selectedItems = {})",
LoggerUtils.listToString(workbasketIds), LoggerUtils.listToString(states),
LoggerUtils.listToString(categories), LoggerUtils.listToString(domains), customField,
LoggerUtils.listToString(customFieldValues), LoggerUtils.listToString(columnHeaders),
inWorkingDays, LoggerUtils.listToString(selectedItems));
}
try {
taskanaEngineImpl.openConnection();
if (columnHeaders == null) {
throw new InvalidArgumentException("ReportLineItemDefinitions can´t be used as NULL-Parameter");
}
if (selectedItems == null || selectedItems.size() == 0) {
throw new InvalidArgumentException(
"SelectedItems can´t be used as NULL-Parameter and should not be empty");
}
configureDaysToWorkingDaysConverter();
if (inWorkingDays) {
selectedItems = convertWorkingDaysToDays(selectedItems, columnHeaders);
}
// List<String> taskIds = taskMonitorMapper.getTaskIdsOfWorkbasketLevelBySelectedItems(workbasketIds,
// states,
// categories, domains, customField, customFieldValues, selectedItems);
List<String> taskIds = taskMonitorMapper.getTaskIdsForSelectedItems(workbasketIds, states,
categories, domains, customField, customFieldValues, "WORKBASKET_KEY", selectedItems);
return taskIds;
} finally {
taskanaEngineImpl.returnConnection();
LOGGER.debug("exit from getTaskIdsOfWorkbasketLevelReportLineItems().");
}
}
@Override
public TaskStatusReport getTaskStatusReport() {
return getTaskStatusReport(null, null);
@ -415,4 +463,5 @@ public class TaskMonitorServiceImpl implements TaskMonitorService {
DaysToWorkingDaysConverter.setGermanPublicHolidaysEnabled(
this.taskanaEngineImpl.getConfiguration().isGermanPublicHolidaysEnabled());
}
}

12
lib/taskana-core/src/main/java/pro/taskana/mappings/TaskMonitorMapper.java
View File

@ -227,7 +227,7 @@ public interface TaskMonitorMapper {
+ "</if>"
+ "AND DUE IS NOT NULL AND ( "
+ "<foreach collection='selectedItems' item='selectedItem' separator=' OR '>"
+ "#{selectedItem.key} = CLASSIFICATION_CATEGORY AND "
+ "#{selectedItem.key} = ${groupedBy} AND "
+ "<if test=\"_databaseId == 'db2'\">"
+ "#{selectedItem.upperAgeLimit} >= (DAYS(DUE) - DAYS(CURRENT_TIMESTAMP)) AND "
+ "#{selectedItem.lowerAgeLimit} &lt;= (DAYS(DUE) - DAYS(CURRENT_TIMESTAMP)) "
@ -240,13 +240,11 @@ public interface TaskMonitorMapper {
+ "</where>"
+ "<if test=\"_databaseId == 'db2'\">with UR </if> "
+ "</script>")
List<String> getTaskIdsOfCategoriesBySelectedItems(@Param("workbasketIds") List<String> workbasketIds,
List<String> getTaskIdsForSelectedItems(@Param("workbasketIds") List<String> workbasketIds,
@Param("states") List<TaskState> states,
@Param("categories") List<String> categories,
@Param("domains") List<String> domains,
@Param("customField") CustomField customField,
@Param("customFieldValues") List<String> customFieldValues,
@Param("selectedItems") List<SelectedItem> selectedItems);
@Param("categories") List<String> categories, @Param("domains") List<String> domains,
@Param("customField") CustomField customField, @Param("customFieldValues") List<String> customFieldValues,
@Param("groupedBy") String groupedBy, @Param("selectedItems") List<SelectedItem> selectedItems);
@Select("<script>"
+ "SELECT DOMAIN, STATE, COUNT(STATE) as COUNT "

109
lib/taskana-core/src/test/java/acceptance/monitoring/GetTaskIdsOfWorkbasketReportAccTest.java Normal file
View File

@ -0,0 +1,109 @@
package acceptance.monitoring;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import java.io.IOException;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import javax.sql.DataSource;
import org.junit.BeforeClass;
import org.junit.Test;
import pro.taskana.TaskMonitorService;
import pro.taskana.TaskanaEngine;
import pro.taskana.TaskanaEngine.ConnectionManagementMode;
import pro.taskana.configuration.TaskanaEngineConfiguration;
import pro.taskana.database.TestDataGenerator;
import pro.taskana.exceptions.InvalidArgumentException;
import pro.taskana.impl.SelectedItem;
import pro.taskana.impl.TaskanaEngineImpl;
import pro.taskana.impl.configuration.DBCleaner;
import pro.taskana.impl.configuration.TaskanaEngineConfigurationTest;
import pro.taskana.impl.report.impl.TimeIntervalColumnHeader;
/**
* Acceptance test for all "get task ids of workbasket report" scenarios.
*/
public class GetTaskIdsOfWorkbasketReportAccTest {
protected static TaskanaEngineConfiguration taskanaEngineConfiguration;
protected static TaskanaEngine taskanaEngine;
@BeforeClass
public static void setupTest() throws Exception {
resetDb();
}
public static void resetDb() throws SQLException, IOException {
DataSource dataSource = TaskanaEngineConfigurationTest.getDataSource();
DBCleaner cleaner = new DBCleaner();
cleaner.clearDb(dataSource, true);
dataSource = TaskanaEngineConfigurationTest.getDataSource();
taskanaEngineConfiguration = new TaskanaEngineConfiguration(dataSource, false);
taskanaEngineConfiguration.setGermanPublicHolidaysEnabled(false);
taskanaEngine = taskanaEngineConfiguration.buildTaskanaEngine();
((TaskanaEngineImpl) taskanaEngine).setConnectionManagementMode(ConnectionManagementMode.AUTOCOMMIT);
cleaner.clearDb(dataSource, false);
TestDataGenerator testDataGenerator = new TestDataGenerator();
testDataGenerator.generateMonitoringTestData(dataSource);
}
@Test
public void testGetTaskIdsOfWorkbasketReport() throws InvalidArgumentException {
TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService();
List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
List<SelectedItem> selectedItems = new ArrayList<>();
SelectedItem s1 = new SelectedItem();
s1.setKey("USER_1_1");
s1.setLowerAgeLimit(0);
s1.setUpperAgeLimit(0);
selectedItems.add(s1);
SelectedItem s2 = new SelectedItem();
s2.setKey("USER_1_1");
s2.setLowerAgeLimit(Integer.MIN_VALUE);
s2.setUpperAgeLimit(-11);
selectedItems.add(s2);
SelectedItem s3 = new SelectedItem();
s3.setKey("USER_1_2");
s3.setLowerAgeLimit(1000);
s3.setUpperAgeLimit(Integer.MAX_VALUE);
selectedItems.add(s3);
List<String> ids = taskMonitorService.getTaskIdsOfWorkbasketLevelReportLineItems(null, null, null, null, null,
null,
columnHeaders, true, selectedItems);
assertEquals(7, ids.size());
assertTrue(ids.contains("TKI:000000000000000000000000000000000001"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000004"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000006"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000009"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000010"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000031"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000050"));
}
private List<TimeIntervalColumnHeader> getListOfColumnHeaders() {
List<TimeIntervalColumnHeader> columnHeaders = new ArrayList<>();
columnHeaders.add(new TimeIntervalColumnHeader(Integer.MIN_VALUE, -11));
columnHeaders.add(new TimeIntervalColumnHeader(-10, -6));
columnHeaders.add(new TimeIntervalColumnHeader(-5, -2));
columnHeaders.add(new TimeIntervalColumnHeader(-1));
columnHeaders.add(new TimeIntervalColumnHeader(0));
columnHeaders.add(new TimeIntervalColumnHeader(1));
columnHeaders.add(new TimeIntervalColumnHeader(2, 5));
columnHeaders.add(new TimeIntervalColumnHeader(6, 10));
columnHeaders.add(new TimeIntervalColumnHeader(11, Integer.MAX_VALUE));
return columnHeaders;
}
}

18
lib/taskana-core/src/test/java/pro/taskana/impl/TaskMonitorServiceImplTest.java
View File

@ -460,8 +460,8 @@ public class TaskMonitorServiceImplTest {
List<SelectedItem> selectedItems = Collections.singletonList(selectedItem);
List<String> expectedResult = Collections.singletonList("TKI:000000000000000000000000000000000001");
doReturn(expectedResult).when(taskMonitorMapperMock).getTaskIdsOfCategoriesBySelectedItems(workbasketIds,
states, categories, domains, customField, customFieldValues, selectedItems);
doReturn(expectedResult).when(taskMonitorMapperMock).getTaskIdsForSelectedItems(workbasketIds,
states, categories, domains, customField, customFieldValues, "CLASSIFICATION_CATEGORY", selectedItems);
List<String> actualResult = cut.getTaskIdsOfCategoryReportLineItems(workbasketIds, states, categories, domains,
customField, customFieldValues, reportLineItemDefinitions, selectedItems);
@ -471,7 +471,7 @@ public class TaskMonitorServiceImplTest {
verify(taskanaEngineConfiguration, times(1)).isGermanPublicHolidaysEnabled();
verify(taskanaEngineConfiguration, times(1)).getCustomHolidays();
verify(taskMonitorMapperMock, times(1))
.getTaskIdsOfCategoriesBySelectedItems(any(), any(), any(), any(), any(), any(), any());
.getTaskIdsForSelectedItems(any(), any(), any(), any(), any(), any(), any(), any());
verify(taskanaEngineImplMock, times(1)).returnConnection();
verifyNoMoreInteractions(taskanaEngineImplMock, taskMonitorMapperMock, taskanaEngineConfiguration);
@ -481,7 +481,7 @@ public class TaskMonitorServiceImplTest {
@Test
public void testGetTaskStateReportWithoutFilters() {
//given
// given
TaskQueryItem queryItem1 = new TaskQueryItem();
queryItem1.setCount(50);
queryItem1.setState(TaskState.READY);
@ -493,10 +493,10 @@ public class TaskMonitorServiceImplTest {
List<TaskQueryItem> queryItems = Arrays.asList(queryItem1, queryItem2);
when(taskMonitorMapperMock.getTasksCountByState(null, null)).thenReturn(queryItems);
//when
// when
TaskStatusReport report = cut.getTaskStatusReport();
//then
// then
InOrder inOrder = inOrder(taskanaEngineImplMock, taskMonitorMapperMock, taskanaEngineImplMock);
inOrder.verify(taskanaEngineImplMock).openConnection();
inOrder.verify(taskMonitorMapperMock).getTasksCountByState(eq(null), eq(null));
@ -512,7 +512,7 @@ public class TaskMonitorServiceImplTest {
@Test
public void testGetTotalNumberOfTaskStateReport() {
//given
// given
TaskQueryItem queryItem1 = new TaskQueryItem();
queryItem1.setCount(50);
queryItem1.setState(TaskState.READY);
@ -524,10 +524,10 @@ public class TaskMonitorServiceImplTest {
List<TaskQueryItem> queryItems = Arrays.asList(queryItem1, queryItem2);
when(taskMonitorMapperMock.getTasksCountByState(eq(null), eq(Collections.emptyList()))).thenReturn(queryItems);
//when
// when
TaskStatusReport report = cut.getTaskStatusReport(null, Collections.emptyList());
//then
// then
InOrder inOrder = inOrder(taskanaEngineImplMock, taskMonitorMapperMock, taskanaEngineImplMock);
inOrder.verify(taskanaEngineImplMock).openConnection();
inOrder.verify(taskMonitorMapperMock).getTasksCountByState(eq(null), eq(Collections.emptyList()));