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

lib/taskana-core/src/main/java/pro/taskana/TaskMonitorService.java

@@ -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

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

@@ -328,8 +328,11 @@ public class TaskMonitorServiceImpl implements TaskMonitorService {
                 selectedItems = convertWorkingDaysToDays(selectedItems, columnHeaders);
             }
 
-            List<String> taskIds = taskMonitorMapper.getTaskIdsOfCategoriesBySelectedItems(workbasketIds, states,
+            // List<String> taskIds = taskMonitorMapper.getTaskIdsOfCategoriesBySelectedItems(workbasketIds, states,
-                categories, domains, customField, customFieldValues, selectedItems);
+            // 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());
     }
+
 }

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

@@ -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("categories") List<String> categories, @Param("domains") List<String> domains,
-        @Param("domains") List<String> domains,
+        @Param("customField") CustomField customField, @Param("customFieldValues") List<String> customFieldValues,
-        @Param("customField") CustomField customField,
+        @Param("groupedBy") String groupedBy, @Param("selectedItems") List<SelectedItem> selectedItems);
-        @Param("customFieldValues") List<String> customFieldValues,
-        @Param("selectedItems") List<SelectedItem> selectedItems);
 
     @Select("<script>"
         + "SELECT DOMAIN, STATE, COUNT(STATE) as COUNT "

lib/taskana-core/src/test/java/acceptance/monitoring/GetTaskIdsOfWorkbasketReportAccTest.java

@@ -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;
+    }
+
+}

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

@@ -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,
+        doReturn(expectedResult).when(taskMonitorMapperMock).getTaskIdsForSelectedItems(workbasketIds,
-            states, categories, domains, customField, customFieldValues, selectedItems);
+            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()));