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

TSK-395 created TaskStatusReport 

TSK-395 created rest endpoint
This commit is contained in:
Mustapha Zorgati 2018-03-19 18:12:11 +01:00
parent 95146d764f
commit bb4d5adf35
16 changed files with 488 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -8,6 +8,7 @@ import pro.taskana.impl.report.impl.CategoryReport;
import pro.taskana.impl.report.impl.ClassificationReport;
import pro.taskana.impl.report.impl.CustomFieldValueReport;
import pro.taskana.impl.report.impl.DetailedClassificationReport;
import pro.taskana.impl.report.impl.TaskStatusReport;
import pro.taskana.impl.report.impl.TimeIntervalColumnHeader;
import pro.taskana.impl.report.impl.WorkbasketLevelReport;
@ -658,4 +659,35 @@ public interface TaskMonitorService {
List<TimeIntervalColumnHeader> columnHeaders, boolean inWorkingDays,
List<SelectedItem> selectedItems) throws InvalidArgumentException;
/**
* Overloaded method for {@link #getTaskStatusReport(List, List)}.
* This method omits all filters.
*
* @return the {@link TaskStatusReport}
*/
TaskStatusReport getTaskStatusReport();
/**
* Overloaded method for {@link #getTaskStatusReport(List, List)}.
* This method applies a domain filter and omits the state filter.
*
* @param domains
* a list of domains to filter by domains. To omit this filter, use null for this parameter
* @return the {@link TaskStatusReport}
*/
TaskStatusReport getTaskStatusReport(List<String> domains);
/**
* Returns a {@link TaskStatusReport}. For each domain the report contains the total number of tasks, clustered in
* their task status. Furthermore the report contains a sum line that contains the total numbers of the different
* clusters and the total number of all tasks.
*
* @param states
* a list of states objects to filter by states. 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
* @return the {@link TaskStatusReport}
*/
TaskStatusReport getTaskStatusReport(List<String> domains, List<TaskState> states);
}

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

@ -18,6 +18,8 @@ import pro.taskana.impl.report.impl.DaysToWorkingDaysPreProcessor;
import pro.taskana.impl.report.impl.DetailedClassificationReport;
import pro.taskana.impl.report.impl.DetailedMonitorQueryItem;
import pro.taskana.impl.report.impl.MonitorQueryItem;
import pro.taskana.impl.report.impl.TaskQueryItem;
import pro.taskana.impl.report.impl.TaskStatusReport;
import pro.taskana.impl.report.impl.TimeIntervalColumnHeader;
import pro.taskana.impl.report.impl.WorkbasketLevelReport;
import pro.taskana.impl.util.LoggerUtils;
@ -336,6 +338,31 @@ public class TaskMonitorServiceImpl implements TaskMonitorService {
}
}
@Override
public TaskStatusReport getTaskStatusReport() {
return getTaskStatusReport(null, null);
}
@Override
public TaskStatusReport getTaskStatusReport(List<String> domains) {
return getTaskStatusReport(domains, null);
}
@Override
public TaskStatusReport getTaskStatusReport(List<String> domains, List<TaskState> states) {
try {
taskanaEngineImpl.openConnection();
List<TaskQueryItem> tasks = taskMonitorMapper.getTasksCountByState(domains, states);
TaskStatusReport report = new TaskStatusReport(states);
report.addItems(tasks);
return report;
} finally {
taskanaEngineImpl.returnConnection();
}
}
private List<SelectedItem> convertWorkingDaysToDays(List<SelectedItem> selectedItems,
List<TimeIntervalColumnHeader> columnHeaders) throws InvalidArgumentException {
@ -354,5 +381,4 @@ public class TaskMonitorServiceImpl implements TaskMonitorService {
DaysToWorkingDaysConverter.setGermanPublicHolidaysEnabled(
this.taskanaEngineImpl.getConfiguration().isGermanPublicHolidaysEnabled());
}
}

6
lib/taskana-core/src/main/java/pro/taskana/impl/report/Report.java
View File

@ -59,7 +59,7 @@ public abstract class Report<Item extends QueryItem, ColumnHeader extends Report
return sumRow;
}
public Set<String> getRowTitles() {
public Set<String> rowTitles() {
return reportRows.keySet();
}
@ -70,4 +70,8 @@ public abstract class Report<Item extends QueryItem, ColumnHeader extends Report
protected ReportRow<Item> createReportRow(int columnSize) {
return new ReportRow<>(columnSize);
}
public List<ColumnHeader> getColumnHeaders() {
return columnHeaders;
}
}

40
lib/taskana-core/src/main/java/pro/taskana/impl/report/impl/TaskQueryItem.java Normal file
View File

@ -0,0 +1,40 @@
package pro.taskana.impl.report.impl;
import pro.taskana.TaskState;
import pro.taskana.impl.report.QueryItem;
/**
* The TaskQueryItem entity contains the number of tasks for a domain which have a specific state.
*/
public class TaskQueryItem implements QueryItem {
private String domain;
private TaskState state;
private int count;
public void setDomain(String domain) {
this.domain = domain;
}
public void setCount(int count) {
this.count = count;
}
public TaskState getState() {
return state;
}
public void setState(TaskState state) {
this.state = state;
}
@Override
public String getKey() {
return domain;
}
@Override
public int getValue() {
return count;
}
}

31
lib/taskana-core/src/main/java/pro/taskana/impl/report/impl/TaskStatusColumnHeader.java Normal file
View File

@ -0,0 +1,31 @@
package pro.taskana.impl.report.impl;
import pro.taskana.TaskState;
import pro.taskana.impl.report.ReportColumnHeader;
/**
* TODO.
*/
public class TaskStatusColumnHeader implements ReportColumnHeader<TaskQueryItem> {
private TaskState state;
public TaskStatusColumnHeader(TaskState state) {
this.state = state;
}
@Override
public String displayName() {
return state.name();
}
@Override
public boolean fits(TaskQueryItem item) {
return item.getState() == state;
}
@Override
public String toString() {
return displayName();
}
}

25
lib/taskana-core/src/main/java/pro/taskana/impl/report/impl/TaskStatusReport.java Normal file
View File

@ -0,0 +1,25 @@
package pro.taskana.impl.report.impl;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import pro.taskana.TaskState;
import pro.taskana.impl.report.Report;
/**
* TODO.
*/
public class TaskStatusReport extends Report<TaskQueryItem, TaskStatusColumnHeader> {
public TaskStatusReport() {
this(null);
}
public TaskStatusReport(List<TaskState> filter) {
super((filter != null ? filter.stream() : Arrays.stream(TaskState.values()))
.map(TaskStatusColumnHeader::new)
.collect(Collectors.toList()));
}
}

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

@ -12,6 +12,7 @@ import pro.taskana.TaskState;
import pro.taskana.impl.SelectedItem;
import pro.taskana.impl.report.impl.DetailedMonitorQueryItem;
import pro.taskana.impl.report.impl.MonitorQueryItem;
import pro.taskana.impl.report.impl.TaskQueryItem;
/**
* This class is the mybatis mapping of task monitoring.
@ -246,4 +247,25 @@ public interface TaskMonitorMapper {
@Param("customFieldValues") List<String> customFieldValues,
@Param("selectedItems") List<SelectedItem> selectedItems);
@Select("<script>"
+ "SELECT DOMAIN, STATE, COUNT(STATE) as COUNT "
+ "FROM TASK "
+ "<where>"
+ "<if test='domains != null'>"
+ "DOMAIN IN (<foreach collection='domains' item='domain' separator=','>#{domain}</foreach>) "
+ "</if>"
+ "<if test='states != null'>"
+ "AND STATE IN (<foreach collection='states' item='state' separator=','>#{state}</foreach>) "
+ "</if>"
+ "</where>"
+ "GROUP BY DOMAIN, STATE"
+ "</script>")
@Results({
@Result(column = "DOMAIN", property = "domain"),
@Result(column = "STATE", property = "state"),
@Result(column = "COUNT", property = "count"),
})
List<TaskQueryItem> getTasksCountByState(@Param("domains") List<String> domains,
@Param("states") List<TaskState> states);
}

2
lib/taskana-core/src/test/java/acceptance/monitoring/ProvideCategoryReportAccTest.java
View File

@ -365,7 +365,7 @@ public class ProvideCategoryReportAccTest {
}
builder.append("\n");
for (String rl : report.getRowTitles()) {
for (String rl : report.rowTitles()) {
builder
.append(String.format(formatFirstColumn, rl, report.getRow(rl).getTotalValue()));
if (columnHeaders != null) {

2
lib/taskana-core/src/test/java/acceptance/monitoring/ProvideClassificationReportAccTest.java
View File

@ -414,7 +414,7 @@ public class ProvideClassificationReportAccTest {
}
builder.append("\n");
for (String rl : report.getRowTitles()) {
for (String rl : report.rowTitles()) {
builder
.append(String.format(formatFirstColumn, rl, report.getRow(rl).getTotalValue()));
if (columnHeaders != null) {

2
lib/taskana-core/src/test/java/acceptance/monitoring/ProvideCustomFieldValueReportAccTest.java
View File

@ -400,7 +400,7 @@ public class ProvideCustomFieldValueReportAccTest {
}
builder.append("\n");
for (String rl : report.getRowTitles()) {
for (String rl : report.rowTitles()) {
builder
.append(String.format(formatFirstColumn, rl, report.getRow(rl).getTotalValue()));
if (columnHeaders != null) {

2
lib/taskana-core/src/test/java/acceptance/monitoring/ProvideDetailedClassificationReportAccTest.java
View File

@ -592,7 +592,7 @@ public class ProvideDetailedClassificationReportAccTest {
}
builder.append("\n");
for (String rl : report.getRowTitles()) {
for (String rl : report.rowTitles()) {
builder
.append(String.format(formatFirstColumn, rl, report.getRow(rl).getTotalValue()));
if (columnHeaders != null) {

195
lib/taskana-core/src/test/java/acceptance/monitoring/ProvideTaskStatusReportAccTest.java Normal file
View File

@ -0,0 +1,195 @@
package acceptance.monitoring;
import static java.util.Arrays.asList;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import java.io.IOException;
import java.sql.SQLException;
import java.util.Collections;
import java.util.List;
import javax.sql.DataSource;
import org.junit.BeforeClass;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import pro.taskana.TaskMonitorService;
import pro.taskana.TaskState;
import pro.taskana.TaskanaEngine;
import pro.taskana.configuration.TaskanaEngineConfiguration;
import pro.taskana.database.TestDataGenerator;
import pro.taskana.impl.configuration.DBCleaner;
import pro.taskana.impl.configuration.TaskanaEngineConfigurationTest;
import pro.taskana.impl.report.ReportRow;
import pro.taskana.impl.report.impl.TaskQueryItem;
import pro.taskana.impl.report.impl.TaskStatusColumnHeader;
import pro.taskana.impl.report.impl.TaskStatusReport;
/**
* Acceptance test for all "task status report" scenarios.
*/
public class ProvideTaskStatusReportAccTest {
private static final Logger LOGGER = LoggerFactory.getLogger(ProvideWorkbasketLevelReportAccTest.class);
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();
taskanaEngine.setConnectionManagementMode(TaskanaEngine.ConnectionManagementMode.AUTOCOMMIT);
cleaner.clearDb(dataSource, false);
TestDataGenerator testDataGenerator = new TestDataGenerator();
testDataGenerator.generateMonitoringTestData(dataSource);
}
@Test
public void testCompleteTaskStatusReport() {
//given
TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService();
//when
TaskStatusReport report = taskMonitorService.getTaskStatusReport();
//then
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report));
}
assertNotNull(report);
assertEquals(3, report.rowSize());
ReportRow<TaskQueryItem> row1 = report.getRow("DOMAIN_A");
assertArrayEquals(new int[] {22, 4, 0}, row1.getCells());
assertEquals(26, row1.getTotalValue());
ReportRow<TaskQueryItem> row2 = report.getRow("DOMAIN_B");
assertArrayEquals(new int[] {9, 3, 0}, row2.getCells());
assertEquals(12, row2.getTotalValue());
ReportRow<TaskQueryItem> row3 = report.getRow("DOMAIN_C");
assertArrayEquals(new int[] {10, 2, 0}, row3.getCells());
assertEquals(12, row3.getTotalValue());
ReportRow<TaskQueryItem> sumRow = report.getSumRow();
assertArrayEquals(new int[] {41, 9, 0}, sumRow.getCells());
assertEquals(50, sumRow.getTotalValue());
}
@Test
public void testCompleteTaskStatusReportWithDomainFilter() {
//given
TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService();
//when
TaskStatusReport report = taskMonitorService.getTaskStatusReport(asList("DOMAIN_C", "DOMAIN_A"));
//then
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report));
}
assertNotNull(report);
assertEquals(2, report.rowSize());
ReportRow<TaskQueryItem> row1 = report.getRow("DOMAIN_A");
assertArrayEquals(new int[] {22, 4, 0}, row1.getCells());
assertEquals(26, row1.getTotalValue());
ReportRow<TaskQueryItem> row2 = report.getRow("DOMAIN_C");
assertArrayEquals(new int[] {10, 2, 0}, row2.getCells());
assertEquals(12, row2.getTotalValue());
ReportRow<TaskQueryItem> sumRow = report.getSumRow();
assertArrayEquals(new int[] {32, 6, 0}, sumRow.getCells());
assertEquals(38, sumRow.getTotalValue());
}
@Test
public void testCompleteTaskStatusReportWithStateFilter() {
//given
TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService();
//when
TaskStatusReport report = taskMonitorService.getTaskStatusReport(null,
Collections.singletonList(TaskState.READY));
//then
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report));
}
assertNotNull(report);
assertEquals(3, report.rowSize());
ReportRow<TaskQueryItem> row1 = report.getRow("DOMAIN_A");
assertArrayEquals(new int[] {22}, row1.getCells());
assertEquals(22, row1.getTotalValue());
ReportRow<TaskQueryItem> row2 = report.getRow("DOMAIN_B");
assertArrayEquals(new int[] {9}, row2.getCells());
assertEquals(9, row2.getTotalValue());
ReportRow<TaskQueryItem> row3 = report.getRow("DOMAIN_C");
assertArrayEquals(new int[] {10}, row3.getCells());
assertEquals(10, row3.getTotalValue());
ReportRow<TaskQueryItem> sumRow = report.getSumRow();
assertArrayEquals(new int[] {41}, sumRow.getCells());
assertEquals(41, sumRow.getTotalValue());
}
private String reportToString(TaskStatusReport report) {
List<TaskStatusColumnHeader> columnHeaders = report.getColumnHeaders();
String formatColumnWidth = "| %-7s ";
String formatFirstColumn = "| %-36s %-4s ";
String formatFirstColumnFirstLine = "| %-29s %12s ";
String formatFirstColumnSumLine = "| %-36s %-5s";
int reportWidth = columnHeaders.size() * 10 + 46;
StringBuilder builder = new StringBuilder();
builder.append("\n");
for (int i = 0; i < reportWidth; i++) {
builder.append("-");
}
builder.append("\n");
builder.append(String.format(formatFirstColumnFirstLine, "Domain", "Total"));
for (TaskStatusColumnHeader def : columnHeaders) {
builder.append(String.format(formatColumnWidth, def.displayName()));
}
builder.append("|\n");
for (int i = 0; i < reportWidth; i++) {
builder.append("-");
}
builder.append("\n");
for (String rl : report.rowTitles()) {
builder.append(String.format(formatFirstColumn, rl, report.getRow(rl).getTotalValue()));
for (int cell : report.getRow(rl).getCells()) {
builder.append(String.format(formatColumnWidth, cell));
}
builder.append("|\n");
for (int i = 0; i < reportWidth; i++) {
builder.append("-");
}
builder.append("\n");
}
builder.append(String.format(formatFirstColumnSumLine, "Total", report.getSumRow().getTotalValue()));
for (int cell : report.getSumRow().getCells()) {
builder.append(String.format(formatColumnWidth, cell));
}
builder.append("|\n");
for (int i = 0; i < reportWidth; i++) {
builder.append("-");
}
builder.append("\n");
return builder.toString();
}
}

2
lib/taskana-core/src/test/java/acceptance/monitoring/ProvideWorkbasketLevelReportAccTest.java
View File

@ -364,7 +364,7 @@ public class ProvideWorkbasketLevelReportAccTest {
}
builder.append("\n");
for (String rl : report.getRowTitles()) {
for (String rl : report.rowTitles()) {
builder
.append(String.format(formatFirstColumn, rl, report.getRow(rl).getTotalValue()));
if (reportLineItemDefinitions != null) {

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

@ -1,12 +1,16 @@
package pro.taskana.impl;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.powermock.api.mockito.PowerMockito.when;
import java.util.ArrayList;
import java.util.Arrays;
@ -16,6 +20,7 @@ import java.util.List;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InOrder;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
@ -32,6 +37,9 @@ import pro.taskana.impl.report.impl.CustomFieldValueReport;
import pro.taskana.impl.report.impl.DetailedClassificationReport;
import pro.taskana.impl.report.impl.DetailedMonitorQueryItem;
import pro.taskana.impl.report.impl.DetailedReportRow;
import pro.taskana.impl.report.impl.MonitorQueryItem;
import pro.taskana.impl.report.impl.TaskQueryItem;
import pro.taskana.impl.report.impl.TaskStatusReport;
import pro.taskana.impl.report.impl.TimeIntervalColumnHeader;
import pro.taskana.impl.report.impl.WorkbasketLevelReport;
import pro.taskana.mappings.TaskMonitorMapper;
@ -73,8 +81,8 @@ public class TaskMonitorServiceImplTest {
CustomField customField = CustomField.CUSTOM_1;
List<String> customFieldValues = Collections.singletonList("Geschaeftsstelle A");
List<pro.taskana.impl.report.impl.MonitorQueryItem> expectedResult = new ArrayList<>();
pro.taskana.impl.report.impl.MonitorQueryItem monitorQueryItem = new pro.taskana.impl.report.impl.MonitorQueryItem();
List<MonitorQueryItem> expectedResult = new ArrayList<>();
MonitorQueryItem monitorQueryItem = new MonitorQueryItem();
monitorQueryItem.setKey("WBI:000000000000000000000000000000000001");
monitorQueryItem.setNumberOfTasks(1);
expectedResult.add(monitorQueryItem);
@ -110,8 +118,8 @@ public class TaskMonitorServiceImplTest {
List<TimeIntervalColumnHeader> reportLineItemDefinitions = Collections.singletonList(
new TimeIntervalColumnHeader(0, 0));
List<pro.taskana.impl.report.impl.MonitorQueryItem> expectedResult = new ArrayList<>();
pro.taskana.impl.report.impl.MonitorQueryItem monitorQueryItem = new pro.taskana.impl.report.impl.MonitorQueryItem();
List<MonitorQueryItem> expectedResult = new ArrayList<>();
MonitorQueryItem monitorQueryItem = new MonitorQueryItem();
monitorQueryItem.setKey("WBI:000000000000000000000000000000000001");
monitorQueryItem.setAgeInDays(0);
monitorQueryItem.setNumberOfTasks(1);
@ -146,8 +154,8 @@ public class TaskMonitorServiceImplTest {
CustomField customField = CustomField.CUSTOM_1;
List<String> customFieldValues = Collections.singletonList("Geschaeftsstelle A");
List<pro.taskana.impl.report.impl.MonitorQueryItem> expectedResult = new ArrayList<>();
pro.taskana.impl.report.impl.MonitorQueryItem monitorQueryItem = new pro.taskana.impl.report.impl.MonitorQueryItem();
List<MonitorQueryItem> expectedResult = new ArrayList<>();
MonitorQueryItem monitorQueryItem = new MonitorQueryItem();
monitorQueryItem.setKey("EXTERN");
monitorQueryItem.setNumberOfTasks(1);
expectedResult.add(monitorQueryItem);
@ -181,8 +189,8 @@ public class TaskMonitorServiceImplTest {
List<TimeIntervalColumnHeader> reportLineItemDefinitions = Collections.singletonList(
new TimeIntervalColumnHeader(0, 0));
List<pro.taskana.impl.report.impl.MonitorQueryItem> expectedResult = new ArrayList<>();
pro.taskana.impl.report.impl.MonitorQueryItem monitorQueryItem = new pro.taskana.impl.report.impl.MonitorQueryItem();
List<MonitorQueryItem> expectedResult = new ArrayList<>();
MonitorQueryItem monitorQueryItem = new MonitorQueryItem();
monitorQueryItem.setKey("EXTERN");
monitorQueryItem.setAgeInDays(0);
monitorQueryItem.setNumberOfTasks(1);
@ -216,8 +224,8 @@ public class TaskMonitorServiceImplTest {
CustomField customField = CustomField.CUSTOM_1;
List<String> customFieldValues = Collections.singletonList("Geschaeftsstelle A");
List<pro.taskana.impl.report.impl.MonitorQueryItem> expectedResult = new ArrayList<>();
pro.taskana.impl.report.impl.MonitorQueryItem monitorQueryItem = new pro.taskana.impl.report.impl.MonitorQueryItem();
List<MonitorQueryItem> expectedResult = new ArrayList<>();
MonitorQueryItem monitorQueryItem = new MonitorQueryItem();
monitorQueryItem.setKey("CLI:000000000000000000000000000000000001");
monitorQueryItem.setNumberOfTasks(1);
expectedResult.add(monitorQueryItem);
@ -253,8 +261,8 @@ public class TaskMonitorServiceImplTest {
List<TimeIntervalColumnHeader> reportLineItemDefinitions = Collections.singletonList(
new TimeIntervalColumnHeader(0, 0));
List<pro.taskana.impl.report.impl.MonitorQueryItem> expectedResult = new ArrayList<>();
pro.taskana.impl.report.impl.MonitorQueryItem monitorQueryItem = new pro.taskana.impl.report.impl.MonitorQueryItem();
List<MonitorQueryItem> expectedResult = new ArrayList<>();
MonitorQueryItem monitorQueryItem = new MonitorQueryItem();
monitorQueryItem.setKey("CLI:000000000000000000000000000000000001");
monitorQueryItem.setAgeInDays(0);
monitorQueryItem.setNumberOfTasks(1);
@ -369,8 +377,8 @@ public class TaskMonitorServiceImplTest {
CustomField customField = CustomField.CUSTOM_1;
List<String> customFieldValues = Collections.singletonList("Geschaeftsstelle A");
List<pro.taskana.impl.report.impl.MonitorQueryItem> expectedResult = new ArrayList<>();
pro.taskana.impl.report.impl.MonitorQueryItem monitorQueryItem = new pro.taskana.impl.report.impl.MonitorQueryItem();
List<MonitorQueryItem> expectedResult = new ArrayList<>();
MonitorQueryItem monitorQueryItem = new MonitorQueryItem();
monitorQueryItem.setKey("Geschaeftsstelle A");
monitorQueryItem.setNumberOfTasks(1);
expectedResult.add(monitorQueryItem);
@ -406,8 +414,8 @@ public class TaskMonitorServiceImplTest {
List<TimeIntervalColumnHeader> reportLineItemDefinitions = Collections.singletonList(
new TimeIntervalColumnHeader(0, 0));
List<pro.taskana.impl.report.impl.MonitorQueryItem> expectedResult = new ArrayList<>();
pro.taskana.impl.report.impl.MonitorQueryItem monitorQueryItem = new pro.taskana.impl.report.impl.MonitorQueryItem();
List<MonitorQueryItem> expectedResult = new ArrayList<>();
MonitorQueryItem monitorQueryItem = new MonitorQueryItem();
monitorQueryItem.setKey("Geschaeftsstelle A");
monitorQueryItem.setAgeInDays(0);
monitorQueryItem.setNumberOfTasks(1);
@ -470,4 +478,66 @@ public class TaskMonitorServiceImplTest {
assertNotNull(actualResult);
assertEquals(expectedResult, actualResult);
}
@Test
public void testGetTaskStateReportWithoutFilters() {
//given
TaskQueryItem queryItem1 = new TaskQueryItem();
queryItem1.setCount(50);
queryItem1.setState(TaskState.READY);
queryItem1.setDomain("DOMAIN_X");
TaskQueryItem queryItem2 = new TaskQueryItem();
queryItem2.setCount(30);
queryItem2.setState(TaskState.COMPLETED);
queryItem2.setDomain("DOMAIN_X");
List<TaskQueryItem> queryItems = Arrays.asList(queryItem1, queryItem2);
when(taskMonitorMapperMock.getTasksCountByState(null, null)).thenReturn(queryItems);
//when
TaskStatusReport report = cut.getTaskStatusReport();
//then
InOrder inOrder = inOrder(taskanaEngineImplMock, taskMonitorMapperMock, taskanaEngineImplMock);
inOrder.verify(taskanaEngineImplMock).openConnection();
inOrder.verify(taskMonitorMapperMock).getTasksCountByState(eq(null), eq(null));
inOrder.verify(taskanaEngineImplMock).returnConnection();
assertNotNull(report);
assertEquals(1, report.rowSize());
assertArrayEquals(new int[] {50, 0, 30}, report.getRow("DOMAIN_X").getCells());
assertArrayEquals(new int[] {50, 0, 30}, report.getSumRow().getCells());
assertEquals(80, report.getRow("DOMAIN_X").getTotalValue());
assertEquals(80, report.getSumRow().getTotalValue());
}
@Test
public void testGetTotalNumberOfTaskStateReport() {
//given
TaskQueryItem queryItem1 = new TaskQueryItem();
queryItem1.setCount(50);
queryItem1.setState(TaskState.READY);
queryItem1.setDomain("DOMAIN_X");
TaskQueryItem queryItem2 = new TaskQueryItem();
queryItem2.setCount(30);
queryItem2.setState(TaskState.COMPLETED);
queryItem2.setDomain("DOMAIN_X");
List<TaskQueryItem> queryItems = Arrays.asList(queryItem1, queryItem2);
when(taskMonitorMapperMock.getTasksCountByState(eq(null), eq(Collections.emptyList()))).thenReturn(queryItems);
//when
TaskStatusReport report = cut.getTaskStatusReport(null, Collections.emptyList());
//then
InOrder inOrder = inOrder(taskanaEngineImplMock, taskMonitorMapperMock, taskanaEngineImplMock);
inOrder.verify(taskanaEngineImplMock).openConnection();
inOrder.verify(taskMonitorMapperMock).getTasksCountByState(eq(null), eq(Collections.emptyList()));
inOrder.verify(taskanaEngineImplMock).returnConnection();
assertNotNull(report);
assertEquals(1, report.rowSize());
assertArrayEquals(new int[0], report.getRow("DOMAIN_X").getCells());
assertArrayEquals(new int[0], report.getSumRow().getCells());
assertEquals(80, report.getRow("DOMAIN_X").getTotalValue());
assertEquals(80, report.getSumRow().getTotalValue());
}
}

12
rest/taskana-rest-spring/src/main/java/pro/taskana/rest/MonitorController.java
View File

@ -2,6 +2,7 @@ package pro.taskana.rest;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
@ -11,6 +12,7 @@ import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import pro.taskana.TaskMonitorService;
import pro.taskana.TaskState;
/**
@ -20,6 +22,9 @@ import pro.taskana.TaskState;
@RequestMapping(path = "/v1/monitor", produces = {MediaType.APPLICATION_JSON_VALUE})
public class MonitorController {
@Autowired
private TaskMonitorService taskMonitorService;
@GetMapping(path = "/countByState")
@Transactional(readOnly = true, rollbackFor = Exception.class)
public ResponseEntity<?> getTaskcountForState(
@ -57,4 +62,11 @@ public class MonitorController {
builder.append("]}");
return ResponseEntity.status(HttpStatus.OK).body(builder.toString());
}
@GetMapping(path = "/taskStatusReport")
@Transactional(readOnly = true, rollbackFor = Exception.class)
public ResponseEntity<?> getTaskStatusReport(@RequestParam(required = false) List<String> domains,
@RequestParam(required = false) List<TaskState> states) {
return ResponseEntity.status(HttpStatus.OK).body(taskMonitorService.getTaskStatusReport(domains, states));
}
}

8
rest/taskana-rest-spring/src/main/java/pro/taskana/rest/RestConfiguration.java
View File

@ -19,6 +19,9 @@ import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.cfg.HandlerInstantiator;
import pro.taskana.ClassificationService;
@ -91,6 +94,11 @@ public class RestConfiguration {
return b;
}
@Bean
public ObjectMapper objectMapper(Jackson2ObjectMapperBuilder jacksonBuilder) {
return jacksonBuilder.build().setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY);
}
//Needed for injection into jackson deserilizer.
@Bean
public HandlerInstantiator handlerInstantiator(ApplicationContext context) {