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

TSK-286: Replace workbaskets bei workbasketIds in TaskMonitorService 

- Create method for generating workbasket ids
- Remove unnecessary exceptions in throws clauses
- Remove unused WithAccessId annotations
This commit is contained in:
Konstantin Kläger 2018-02-22 12:01:32 +01:00 committed by Marcel Lengl
parent 351d9654a2
commit fa0a41e419
10 changed files with 481 additions and 581 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -19,8 +19,8 @@ public interface TaskMonitorService {
* workbasket as well as the total number of all tasks. The tasks of the report are filtered by workbaskets, states,
* categories and domains. Task with Timestamp DUE = null are not considered.
*
* @param workbaskets
* a list of workbaskets to filter by workbaskets
* @param workbasketIds
* a list of workbasket ids to filter by workbaskets
* @param states
* a list of states to filter by states
* @param categories
@ -29,7 +29,7 @@ public interface TaskMonitorService {
* a list of domains to filter by domains
* @return the report
*/
Report getWorkbasketLevelReport(List<Workbasket> workbaskets, List<TaskState> states, List<String> categories,
Report getWorkbasketLevelReport(List<String> workbasketIds, List<TaskState> states, List<String> categories,
List<String> domains);
/**
@ -40,8 +40,8 @@ public interface TaskMonitorService {
* tasks in this report. The tasks of the report are filtered by workbaskets, states, categories and domains. Task
* with Timestamp DUE = null are not considered.
*
* @param workbaskets
* a list of workbaskets objects to filter by workbaskets
* @param workbasketIds
* a list of workbasket ids objects to filter by workbaskets
* @param states
* a list of states objects to filter by states
* @param categories
@ -56,7 +56,7 @@ public interface TaskMonitorService {
* should represent a single day, lowerLimit and upperLimit have to be equal.
* @return the report
*/
Report getWorkbasketLevelReport(List<Workbasket> workbaskets, List<TaskState> states,
Report getWorkbasketLevelReport(List<String> workbasketIds, List<TaskState> states,
List<String> categories, List<String> domains, List<ReportLineItemDefinition> reportLineItemDefinitions);
/**
@ -67,8 +67,8 @@ public interface TaskMonitorService {
* clusters and the total number of all tasks. The tasks of the report are filtered by workbaskets, states,
* categories and domains. Task with Timestamp DUE = null are not considered.
*
* @param workbaskets
* a list of workbaskets objects to filter by workbaskets
* @param workbasketIds
* a list of workbasket ids objects to filter by workbaskets
* @param states
* a list of states objects to filter by states
* @param categories
@ -86,7 +86,7 @@ public interface TaskMonitorService {
* working days
* @return the report
*/
Report getWorkbasketLevelReport(List<Workbasket> workbaskets, List<TaskState> states,
Report getWorkbasketLevelReport(List<String> workbasketIds, List<TaskState> states,
List<String> categories, List<String> domains, List<ReportLineItemDefinition> reportLineItemDefinitions,
boolean inWorkingDays);
@ -95,8 +95,8 @@ public interface TaskMonitorService {
* category as well as the total number of all tasks. The tasks of the report are filtered by workbaskets, states,
* categories and domains. Task with Timestamp DUE = null are not considered.
*
* @param workbaskets
* a list of workbaskets to filter by workbaskets
* @param workbasketIds
* a list of workbasket ids to filter by workbaskets
* @param states
* a list of states to filter by states
* @param categories
@ -105,7 +105,7 @@ public interface TaskMonitorService {
* a list of domains to filter by domains
* @return the report
*/
Report getCategoryReport(List<Workbasket> workbaskets, List<TaskState> states, List<String> categories,
Report getCategoryReport(List<String> workbasketIds, List<TaskState> states, List<String> categories,
List<String> domains);
/**
@ -116,8 +116,8 @@ public interface TaskMonitorService {
* report are filtered by workbaskets, states, categories and domains. Task with Timestamp DUE = null are not
* considered.
*
* @param workbaskets
* a list of workbaskets objects to filter by workbaskets
* @param workbasketIds
* a list of workbasket ids objects to filter by workbaskets
* @param states
* a list of states objects to filter by states
* @param categories
@ -132,7 +132,7 @@ public interface TaskMonitorService {
* should represent a single day, lowerLimit and upperLimit have to be equal.
* @return the report
*/
Report getCategoryReport(List<Workbasket> workbaskets, List<TaskState> states, List<String> categories,
Report getCategoryReport(List<String> workbasketIds, List<TaskState> states, List<String> categories,
List<String> domains, List<ReportLineItemDefinition> reportLineItemDefinitions);
/**
@ -143,8 +143,8 @@ public interface TaskMonitorService {
* The tasks of the report are filtered by workbaskets, states, categories and domains. Task with Timestamp DUE =
* null are not considered.
*
* @param workbaskets
* a list of workbaskets objects to filter by workbaskets
* @param workbasketIds
* a list of workbasket ids objects to filter by workbaskets
* @param states
* a list of states objects to filter by states
* @param categories
@ -162,7 +162,7 @@ public interface TaskMonitorService {
* working days
* @return the report
*/
Report getCategoryReport(List<Workbasket> workbaskets, List<TaskState> states, List<String> categories,
Report getCategoryReport(List<String> workbasketIds, List<TaskState> states, List<String> categories,
List<String> domains, List<ReportLineItemDefinition> reportLineItemDefinitions, boolean inWorkingDays);
/**
@ -170,8 +170,8 @@ public interface TaskMonitorService {
* the respective classification as well as the total number of all tasks. The tasks of the report are filtered by
* workbaskets, states, categories and domains. Task with Timestamp DUE = null are not considered.
*
* @param workbaskets
* a list of workbaskets to filter by workbaskets
* @param workbasketIds
* a list of workbasket ids to filter by workbaskets
* @param states
* a list of states to filter by states
* @param categories
@ -180,7 +180,7 @@ public interface TaskMonitorService {
* a list of domains to filter by domains
* @return the ClassificationReport
*/
ClassificationReport getClassificationReport(List<Workbasket> workbaskets, List<TaskState> states,
ClassificationReport getClassificationReport(List<String> workbasketIds, List<TaskState> states,
List<String> categories, List<String> domains);
/**
@ -191,8 +191,8 @@ public interface TaskMonitorService {
* tasks in this report. The tasks of the report are filtered by workbaskets, states, categories and domains. Task
* with Timestamp DUE = null are not considered.
*
* @param workbaskets
* a list of workbaskets objects to filter by workbaskets
* @param workbasketIds
* a list of workbasket ids objects to filter by workbaskets
* @param states
* a list of states objects to filter by states
* @param categories
@ -207,7 +207,7 @@ public interface TaskMonitorService {
* should represent a single day, lowerLimit and upperLimit have to be equal.
* @return the ClassificationReport
*/
ClassificationReport getClassificationReport(List<Workbasket> workbaskets, List<TaskState> states,
ClassificationReport getClassificationReport(List<String> workbasketIds, List<TaskState> states,
List<String> categories, List<String> domains, List<ReportLineItemDefinition> reportLineItemDefinitions);
/**
@ -218,8 +218,8 @@ public interface TaskMonitorService {
* clusters and the total number of all tasks. The tasks of the report are filtered by workbaskets, states,
* categories and domains. Task with Timestamp DUE = null are not considered.
*
* @param workbaskets
* a list of workbaskets objects to filter by workbaskets
* @param workbasketIds
* a list of workbasket ids objects to filter by workbaskets
* @param states
* a list of states objects to filter by states
* @param categories
@ -237,7 +237,7 @@ public interface TaskMonitorService {
* working days
* @return the ClassificationReport
*/
ClassificationReport getClassificationReport(List<Workbasket> workbaskets, List<TaskState> states,
ClassificationReport getClassificationReport(List<String> workbasketIds, List<TaskState> states,
List<String> categories, List<String> domains, List<ReportLineItemDefinition> reportLineItemDefinitions,
boolean inWorkingDays);
@ -247,8 +247,8 @@ public interface TaskMonitorService {
* ReportLines for the classifications of the attachments of the tasks. The tasks of the report are filtered by
* workbaskets, states, categories and domains. Task with Timestamp DUE = null are not considered.
*
* @param workbaskets
* a list of workbaskets to filter by workbaskets
* @param workbasketIds
* a list of workbasket ids to filter by workbaskets
* @param states
* a list of states to filter by states
* @param categories
@ -257,7 +257,7 @@ public interface TaskMonitorService {
* a list of domains to filter by domains
* @return the DetailedClassificationReport
*/
DetailedClassificationReport getDetailedClassificationReport(List<Workbasket> workbaskets, List<TaskState> states,
DetailedClassificationReport getDetailedClassificationReport(List<String> workbasketIds, List<TaskState> states,
List<String> categories, List<String> domains);
/**
@ -269,8 +269,8 @@ public interface TaskMonitorService {
* all tasks in this report. The tasks of the report are filtered by workbaskets, states, categories and domains.
* Task with Timestamp DUE = null are not considered.
*
* @param workbaskets
* a list of workbaskets objects to filter by workbaskets
* @param workbasketIds
* a list of workbasket ids objects to filter by workbaskets
* @param states
* a list of states objects to filter by states
* @param categories
@ -285,7 +285,7 @@ public interface TaskMonitorService {
* should represent a single day, lowerLimit and upperLimit have to be equal.
* @return the DetailedClassificationReport
*/
DetailedClassificationReport getDetailedClassificationReport(List<Workbasket> workbaskets, List<TaskState> states,
DetailedClassificationReport getDetailedClassificationReport(List<String> workbasketIds, List<TaskState> states,
List<String> categories, List<String> domains, List<ReportLineItemDefinition> reportLineItemDefinitions);
/**
@ -297,8 +297,8 @@ public interface TaskMonitorService {
* different clusters and the total number of all tasks. The tasks of the report are filtered by workbaskets,
* states, categories and domains. Task with Timestamp DUE = null are not considered.
*
* @param workbaskets
* a list of workbaskets objects to filter by workbaskets
* @param workbasketIds
* a list of workbasket ids objects to filter by workbaskets
* @param states
* a list of states objects to filter by states
* @param categories
@ -316,7 +316,7 @@ public interface TaskMonitorService {
* working days
* @return the DetailedClassificationReport
*/
DetailedClassificationReport getDetailedClassificationReport(List<Workbasket> workbaskets, List<TaskState> states,
DetailedClassificationReport getDetailedClassificationReport(List<String> workbasketIds, List<TaskState> states,
List<String> categories, List<String> domains, List<ReportLineItemDefinition> reportLineItemDefinitions,
boolean inWorkingDays);
@ -325,8 +325,8 @@ public interface TaskMonitorService {
* numbers of tasks of the respective custom field as well as the total number of all tasks. The tasks of the report
* are filtered by workbaskets, states, categories and domains. Task with Timestamp DUE = null are not considered.
*
* @param workbaskets
* a list of workbaskets to filter by workbaskets
* @param workbasketIds
* a list of workbasket ids to filter by workbaskets
* @param states
* a list of states to filter by states
* @param categories
@ -337,7 +337,7 @@ public interface TaskMonitorService {
* a custom field whose values should be listed in the report
* @return the report
*/
Report getCustomFieldValueReport(List<Workbasket> workbaskets, List<TaskState> states, List<String> categories,
Report getCustomFieldValueReport(List<String> workbasketIds, List<TaskState> states, List<String> categories,
List<String> domains, CustomField customField);
/**
@ -348,8 +348,8 @@ public interface TaskMonitorService {
* total number of all tasks in this report. The tasks of the report are filtered by workbaskets, states, categories
* and domains. Task with Timestamp DUE = null are not considered.
*
* @param workbaskets
* a list of workbaskets objects to filter by workbaskets
* @param workbasketIds
* a list of workbasket ids objects to filter by workbaskets
* @param states
* a list of states objects to filter by states
* @param categories
@ -366,7 +366,7 @@ public interface TaskMonitorService {
* should represent a single day, lowerLimit and upperLimit have to be equal.
* @return the report
*/
Report getCustomFieldValueReport(List<Workbasket> workbaskets, List<TaskState> states, List<String> categories,
Report getCustomFieldValueReport(List<String> workbasketIds, List<TaskState> states, List<String> categories,
List<String> domains, CustomField customField, List<ReportLineItemDefinition> reportLineItemDefinitions);
/**
@ -377,8 +377,8 @@ public interface TaskMonitorService {
* different clusters and the total number of all tasks. The tasks of the report are filtered by workbaskets,
* states, categories and domains. Task with Timestamp DUE = null are not considered.
*
* @param workbaskets
* a list of workbaskets objects to filter by workbaskets
* @param workbasketIds
* a list of workbasket ids objects to filter by workbaskets
* @param states
* a list of states objects to filter by states
* @param categories
@ -398,7 +398,7 @@ public interface TaskMonitorService {
* working days
* @return the report
*/
Report getCustomFieldValueReport(List<Workbasket> workbaskets, List<TaskState> states, List<String> categories,
Report getCustomFieldValueReport(List<String> workbasketIds, List<TaskState> states, List<String> categories,
List<String> domains, CustomField customField, List<ReportLineItemDefinition> reportLineItemDefinitions,
boolean inWorkingDays);
}

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

@ -7,7 +7,6 @@ import org.slf4j.LoggerFactory;
import pro.taskana.TaskMonitorService;
import pro.taskana.TaskanaEngine;
import pro.taskana.Workbasket;
import pro.taskana.impl.util.LoggerUtils;
import pro.taskana.mappings.TaskMonitorMapper;
@ -27,26 +26,27 @@ public class TaskMonitorServiceImpl implements TaskMonitorService {
}
@Override
public Report getWorkbasketLevelReport(List<Workbasket> workbaskets, List<TaskState> states,
public Report getWorkbasketLevelReport(List<String> workbasketIds, List<TaskState> states,
List<String> categories, List<String> domains) {
return getWorkbasketLevelReport(workbaskets, states, categories, domains, null, false);
return getWorkbasketLevelReport(workbasketIds, states, categories, domains, null, false);
}
@Override
public Report getWorkbasketLevelReport(List<Workbasket> workbaskets, List<TaskState> states,
public Report getWorkbasketLevelReport(List<String> workbasketIds, List<TaskState> states,
List<String> categories, List<String> domains, List<ReportLineItemDefinition> reportLineItemDefinitions) {
return getWorkbasketLevelReport(workbaskets, states, categories, domains, reportLineItemDefinitions, true);
return getWorkbasketLevelReport(workbasketIds, states, categories, domains, reportLineItemDefinitions, true);
}
@Override
public Report getWorkbasketLevelReport(List<Workbasket> workbaskets, List<TaskState> states,
public Report getWorkbasketLevelReport(List<String> workbasketIds, List<TaskState> states,
List<String> categories, List<String> domains, List<ReportLineItemDefinition> reportLineItemDefinitions,
boolean inWorkingDays) {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(
"entry to getWorkbasketLevelReport(workbaskets = {}, states = {}, reportLineItemDefinitions = {},"
+ " inWorkingDays = {})",
LoggerUtils.listToString(workbaskets), LoggerUtils.listToString(states),
"entry to getWorkbasketLevelReport(workbasketIds = {}, states = {}, categories = {}, domains = {}, "
+ "reportLineItemDefinitions = {}, inWorkingDays = {})",
LoggerUtils.listToString(workbasketIds), LoggerUtils.listToString(states),
LoggerUtils.listToString(categories), LoggerUtils.listToString(domains),
LoggerUtils.listToString(reportLineItemDefinitions), inWorkingDays);
}
try {
@ -54,7 +54,7 @@ public class TaskMonitorServiceImpl implements TaskMonitorService {
Report report = new Report();
List<MonitorQueryItem> monitorQueryItems = taskMonitorMapper
.getTaskCountOfWorkbasketsByWorkbasketsAndStates(workbaskets, states, categories, domains);
.getTaskCountOfWorkbasketsByWorkbasketsAndStates(workbasketIds, states, categories, domains);
report.addMonitoringQueryItems(monitorQueryItems, reportLineItemDefinitions, inWorkingDays);
return report;
@ -66,25 +66,26 @@ public class TaskMonitorServiceImpl implements TaskMonitorService {
}
@Override
public Report getCategoryReport(List<Workbasket> workbaskets, List<TaskState> states, List<String> categories,
public Report getCategoryReport(List<String> workbasketIds, List<TaskState> states, List<String> categories,
List<String> domains) {
return getCategoryReport(workbaskets, states, categories, domains, null, false);
return getCategoryReport(workbasketIds, states, categories, domains, null, false);
}
@Override
public Report getCategoryReport(List<Workbasket> workbaskets, List<TaskState> states, List<String> categories,
public Report getCategoryReport(List<String> workbasketIds, List<TaskState> states, List<String> categories,
List<String> domains, List<ReportLineItemDefinition> reportLineItemDefinitions) {
return getCategoryReport(workbaskets, states, categories, domains, reportLineItemDefinitions, true);
return getCategoryReport(workbasketIds, states, categories, domains, reportLineItemDefinitions, true);
}
@Override
public Report getCategoryReport(List<Workbasket> workbaskets, List<TaskState> states, List<String> categories,
public Report getCategoryReport(List<String> workbasketIds, List<TaskState> states, List<String> categories,
List<String> domains, List<ReportLineItemDefinition> reportLineItemDefinitions, boolean inWorkingDays) {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(
"entry to getCategoryReport(workbaskets = {}, states = {}, reportLineItemDefinitions = {},"
+ " inWorkingDays = {})",
LoggerUtils.listToString(workbaskets), LoggerUtils.listToString(states),
"entry to getCategoryReport(workbasketIds = {}, states = {}, categories = {}, domains = {}, "
+ "reportLineItemDefinitions = {}, inWorkingDays = {})",
LoggerUtils.listToString(workbasketIds), LoggerUtils.listToString(states),
LoggerUtils.listToString(categories), LoggerUtils.listToString(domains),
LoggerUtils.listToString(reportLineItemDefinitions), inWorkingDays);
}
try {
@ -92,7 +93,7 @@ public class TaskMonitorServiceImpl implements TaskMonitorService {
Report report = new Report();
List<MonitorQueryItem> monitorQueryItems = taskMonitorMapper
.getTaskCountOfCategoriesByWorkbasketsAndStates(workbaskets, states, categories, domains);
.getTaskCountOfCategoriesByWorkbasketsAndStates(workbasketIds, states, categories, domains);
report.addMonitoringQueryItems(monitorQueryItems, reportLineItemDefinitions, inWorkingDays);
return report;
@ -103,26 +104,27 @@ public class TaskMonitorServiceImpl implements TaskMonitorService {
}
@Override
public ClassificationReport getClassificationReport(List<Workbasket> workbaskets, List<TaskState> states,
public ClassificationReport getClassificationReport(List<String> workbasketIds, List<TaskState> states,
List<String> categories, List<String> domains) {
return getClassificationReport(workbaskets, states, categories, domains, null, false);
return getClassificationReport(workbasketIds, states, categories, domains, null, false);
}
@Override
public ClassificationReport getClassificationReport(List<Workbasket> workbaskets, List<TaskState> states,
public ClassificationReport getClassificationReport(List<String> workbasketIds, List<TaskState> states,
List<String> categories, List<String> domains, List<ReportLineItemDefinition> reportLineItemDefinitions) {
return getClassificationReport(workbaskets, states, categories, domains, reportLineItemDefinitions, true);
return getClassificationReport(workbasketIds, states, categories, domains, reportLineItemDefinitions, true);
}
@Override
public ClassificationReport getClassificationReport(List<Workbasket> workbaskets, List<TaskState> states,
public ClassificationReport getClassificationReport(List<String> workbasketIds, List<TaskState> states,
List<String> categories, List<String> domains, List<ReportLineItemDefinition> reportLineItemDefinitions,
boolean inWorkingDays) {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(
"entry to getClassificationReport(workbaskets = {}, states = {}, reportLineItemDefinitions = {},"
+ " inWorkingDays = {})",
LoggerUtils.listToString(workbaskets), LoggerUtils.listToString(states),
"entry to getClassificationReport(workbasketIds = {}, states = {}, categories = {}, domains = {}, "
+ "reportLineItemDefinitions = {}, inWorkingDays = {})",
LoggerUtils.listToString(workbasketIds), LoggerUtils.listToString(states),
LoggerUtils.listToString(categories), LoggerUtils.listToString(domains),
LoggerUtils.listToString(reportLineItemDefinitions), inWorkingDays);
}
try {
@ -130,7 +132,7 @@ public class TaskMonitorServiceImpl implements TaskMonitorService {
ClassificationReport report = new ClassificationReport();
List<MonitorQueryItem> monitorQueryItems = taskMonitorMapper
.getTaskCountOfClassificationsByWorkbasketsAndStates(workbaskets, states, categories, domains);
.getTaskCountOfClassificationsByWorkbasketsAndStates(workbasketIds, states, categories, domains);
report.addMonitoringQueryItems(monitorQueryItems, reportLineItemDefinitions, inWorkingDays);
return report;
@ -141,30 +143,31 @@ public class TaskMonitorServiceImpl implements TaskMonitorService {
}
@Override
public DetailedClassificationReport getDetailedClassificationReport(List<Workbasket> workbaskets,
public DetailedClassificationReport getDetailedClassificationReport(List<String> workbasketIds,
List<TaskState> states, List<String> categories, List<String> domains) {
return getDetailedClassificationReport(workbaskets, states, categories, domains, null, false);
return getDetailedClassificationReport(workbasketIds, states, categories, domains, null, false);
}
@Override
public DetailedClassificationReport getDetailedClassificationReport(List<Workbasket> workbaskets,
public DetailedClassificationReport getDetailedClassificationReport(List<String> workbasketIds,
List<TaskState> states, List<String> categories, List<String> domains,
List<ReportLineItemDefinition> reportLineItemDefinitions) {
return getDetailedClassificationReport(workbaskets, states, categories, domains, reportLineItemDefinitions,
return getDetailedClassificationReport(workbasketIds, states, categories, domains, reportLineItemDefinitions,
true);
}
@Override
public DetailedClassificationReport getDetailedClassificationReport(List<Workbasket> workbaskets,
public DetailedClassificationReport getDetailedClassificationReport(List<String> workbasketIds,
List<TaskState> states, List<String> categories, List<String> domains,
List<ReportLineItemDefinition> reportLineItemDefinitions,
boolean inWorkingDays) {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(
"entry to getDetailedClassificationReport(workbaskets = {}, states = {}, customField = {}, "
+ "reportLineItemDefinitions = {}, inWorkingDays = {})",
LoggerUtils.listToString(workbaskets), LoggerUtils.listToString(states),
"entry to getDetailedClassificationReport(workbasketIds = {}, states = {}, categories = {},"
+ " domains = {}, reportLineItemDefinitions = {}, inWorkingDays = {})",
LoggerUtils.listToString(workbasketIds), LoggerUtils.listToString(states),
LoggerUtils.listToString(categories), LoggerUtils.listToString(domains),
LoggerUtils.listToString(reportLineItemDefinitions), inWorkingDays);
}
try {
@ -172,7 +175,8 @@ public class TaskMonitorServiceImpl implements TaskMonitorService {
DetailedClassificationReport report = new DetailedClassificationReport();
List<DetailedMonitorQueryItem> detailedMonitorQueryItems = taskMonitorMapper
.getTaskCountOfDetailedClassificationsByWorkbasketsAndStates(workbaskets, states, categories, domains);
.getTaskCountOfDetailedClassificationsByWorkbasketsAndStates(workbasketIds, states, categories,
domains);
report.addDetailedMonitoringQueryItems(detailedMonitorQueryItems, reportLineItemDefinitions,
inWorkingDays);
return report;
@ -184,29 +188,30 @@ public class TaskMonitorServiceImpl implements TaskMonitorService {
}
@Override
public Report getCustomFieldValueReport(List<Workbasket> workbaskets, List<TaskState> states,
public Report getCustomFieldValueReport(List<String> workbasketIds, List<TaskState> states,
List<String> categories, List<String> domains, CustomField customField) {
return getCustomFieldValueReport(workbaskets, states, categories, domains, customField, null, false);
return getCustomFieldValueReport(workbasketIds, states, categories, domains, customField, null, false);
}
@Override
public Report getCustomFieldValueReport(List<Workbasket> workbaskets, List<TaskState> states,
public Report getCustomFieldValueReport(List<String> workbasketIds, List<TaskState> states,
List<String> categories, List<String> domains, CustomField customField,
List<ReportLineItemDefinition> reportLineItemDefinitions) {
return getCustomFieldValueReport(workbaskets, states, categories, domains, customField,
return getCustomFieldValueReport(workbasketIds, states, categories, domains, customField,
reportLineItemDefinitions, true);
}
@Override
public Report getCustomFieldValueReport(List<Workbasket> workbaskets, List<TaskState> states,
public Report getCustomFieldValueReport(List<String> workbasketIds, List<TaskState> states,
List<String> categories, List<String> domains, CustomField customField,
List<ReportLineItemDefinition> reportLineItemDefinitions,
boolean inWorkingDays) {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(
"entry to getCustomFieldValueReport(workbaskets = {}, states = {}, customField = {}, "
+ "reportLineItemDefinitions = {}, inWorkingDays = {})",
LoggerUtils.listToString(workbaskets), LoggerUtils.listToString(states), customField,
"entry to getCustomFieldValueReport(workbasketIds = {}, states = {}, categories = {}, domains = {},"
+ " customField = {}, reportLineItemDefinitions = {}, inWorkingDays = {})",
LoggerUtils.listToString(workbasketIds), LoggerUtils.listToString(states),
LoggerUtils.listToString(categories), LoggerUtils.listToString(domains), customField,
LoggerUtils.listToString(reportLineItemDefinitions), inWorkingDays);
}
try {
@ -214,7 +219,7 @@ public class TaskMonitorServiceImpl implements TaskMonitorService {
Report report = new Report();
List<MonitorQueryItem> monitorQueryItems = taskMonitorMapper
.getTaskCountOfCustomFieldValuesByWorkbasketsAndStatesAndCustomField(workbaskets, states, categories,
.getTaskCountOfCustomFieldValuesByWorkbasketsAndStatesAndCustomField(workbasketIds, states, categories,
domains, customField);
report.addMonitoringQueryItems(monitorQueryItems, reportLineItemDefinitions, inWorkingDays);
return report;

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

@ -7,7 +7,6 @@ import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;
import pro.taskana.Workbasket;
import pro.taskana.impl.CustomField;
import pro.taskana.impl.DetailedMonitorQueryItem;
import pro.taskana.impl.MonitorQueryItem;
@ -19,23 +18,23 @@ import pro.taskana.impl.TaskState;
public interface TaskMonitorMapper {
@Select("<script>"
+ "<if test=\"_databaseId == 'db2'\">SELECT WORKBASKET_KEY, (DAYS(DUE) - DAYS(CURRENT_TIMESTAMP)) as AGE_IN_DAYS, COUNT(*) as NUMBER_OF_TASKS</if> "
+ "<if test=\"_databaseId == 'h2'\">SELECT WORKBASKET_KEY, DATEDIFF('DAY', CURRENT_TIMESTAMP, DUE) as AGE_IN_DAYS, COUNT(*) as NUMBER_OF_TASKS</if> "
+ "<if test=\"_databaseId == 'db2'\">SELECT WORKBASKET_ID, (DAYS(DUE) - DAYS(CURRENT_TIMESTAMP)) as AGE_IN_DAYS, COUNT(*) as NUMBER_OF_TASKS</if> "
+ "<if test=\"_databaseId == 'h2'\">SELECT WORKBASKET_ID, DATEDIFF('DAY', CURRENT_TIMESTAMP, DUE) as AGE_IN_DAYS, COUNT(*) as NUMBER_OF_TASKS</if> "
+ "FROM TASK "
+ "WHERE WORKBASKET_KEY IN (<foreach collection='workbaskets' item='workbasket' separator=','>#{workbasket.key}</foreach>) "
+ "WHERE WORKBASKET_ID IN (<foreach collection='workbasketIds' item='workbasketId' separator=','>#{workbasketId}</foreach>) "
+ "AND STATE IN (<foreach collection='states' item='state' separator=','>#{state}</foreach>) "
+ "AND CLASSIFICATION_CATEGORY IN (<foreach collection='categories' item='category' separator=','>#{category}</foreach>) "
+ "AND DOMAIN IN (<foreach collection='domains' item='domain' separator=','>#{domain}</foreach>) "
+ "AND DUE IS NOT NULL "
+ "<if test=\"_databaseId == 'db2'\">GROUP BY WORKBASKET_KEY, (DAYS(DUE) - DAYS(CURRENT_TIMESTAMP))</if> "
+ "<if test=\"_databaseId == 'h2'\">GROUP BY WORKBASKET_KEY, DATEDIFF('DAY', CURRENT_TIMESTAMP, DUE)</if> "
+ "<if test=\"_databaseId == 'db2'\">GROUP BY WORKBASKET_ID, (DAYS(DUE) - DAYS(CURRENT_TIMESTAMP))</if> "
+ "<if test=\"_databaseId == 'h2'\">GROUP BY WORKBASKET_ID, DATEDIFF('DAY', CURRENT_TIMESTAMP, DUE)</if> "
+ "</script>")
@Results({
@Result(column = "WORKBASKET_KEY", property = "key"),
@Result(column = "WORKBASKET_ID", property = "key"),
@Result(column = "AGE_IN_DAYS", property = "ageInDays"),
@Result(column = "NUMBER_OF_TASKS", property = "numberOfTasks") })
List<MonitorQueryItem> getTaskCountOfWorkbasketsByWorkbasketsAndStates(
@Param("workbaskets") List<Workbasket> workbaskets,
@Param("workbasketIds") List<String> workbasketIds,
@Param("states") List<TaskState> states,
@Param("categories") List<String> categories,
@Param("domains") List<String> domains);
@ -44,7 +43,7 @@ public interface TaskMonitorMapper {
+ "<if test=\"_databaseId == 'db2'\">SELECT CLASSIFICATION_CATEGORY, (DAYS(DUE) - DAYS(CURRENT_TIMESTAMP)) as AGE_IN_DAYS, COUNT(*) as NUMBER_OF_TASKS</if> "
+ "<if test=\"_databaseId == 'h2'\">SELECT CLASSIFICATION_CATEGORY, DATEDIFF('DAY', CURRENT_TIMESTAMP, DUE) as AGE_IN_DAYS, COUNT(*) as NUMBER_OF_TASKS</if> "
+ "FROM TASK "
+ "WHERE WORKBASKET_KEY IN (<foreach collection='workbaskets' item='workbasket' separator=','>#{workbasket.key}</foreach>) "
+ "WHERE WORKBASKET_ID IN (<foreach collection='workbasketIds' item='workbasketId' separator=','>#{workbasketId}</foreach>) "
+ "AND STATE IN (<foreach collection='states' item='state' separator=','>#{state}</foreach>) "
+ "AND CLASSIFICATION_CATEGORY IN (<foreach collection='categories' item='category' separator=','>#{category}</foreach>) "
+ "AND DOMAIN IN (<foreach collection='domains' item='domain' separator=','>#{domain}</foreach>) "
@ -57,52 +56,52 @@ public interface TaskMonitorMapper {
@Result(column = "AGE_IN_DAYS", property = "ageInDays"),
@Result(column = "NUMBER_OF_TASKS", property = "numberOfTasks") })
List<MonitorQueryItem> getTaskCountOfCategoriesByWorkbasketsAndStates(
@Param("workbaskets") List<Workbasket> workbaskets,
@Param("workbasketIds") List<String> workbasketIds,
@Param("states") List<TaskState> states,
@Param("categories") List<String> categories,
@Param("domains") List<String> domains);
@Select("<script>"
+ "<if test=\"_databaseId == 'db2'\">SELECT CLASSIFICATION_KEY, (DAYS(DUE) - DAYS(CURRENT_TIMESTAMP)) as AGE_IN_DAYS, COUNT(*) as NUMBER_OF_TASKS</if> "
+ "<if test=\"_databaseId == 'h2'\">SELECT CLASSIFICATION_KEY, DATEDIFF('DAY', CURRENT_TIMESTAMP, DUE) as AGE_IN_DAYS, COUNT(*) as NUMBER_OF_TASKS</if> "
+ "<if test=\"_databaseId == 'db2'\">SELECT CLASSIFICATION_ID, (DAYS(DUE) - DAYS(CURRENT_TIMESTAMP)) as AGE_IN_DAYS, COUNT(*) as NUMBER_OF_TASKS</if> "
+ "<if test=\"_databaseId == 'h2'\">SELECT CLASSIFICATION_ID, DATEDIFF('DAY', CURRENT_TIMESTAMP, DUE) as AGE_IN_DAYS, COUNT(*) as NUMBER_OF_TASKS</if> "
+ "FROM TASK "
+ "WHERE WORKBASKET_KEY IN (<foreach collection='workbaskets' item='workbasket' separator=','>#{workbasket.key}</foreach>) "
+ "WHERE WORKBASKET_ID IN (<foreach collection='workbasketIds' item='workbasketId' separator=','>#{workbasketId}</foreach>) "
+ "AND STATE IN (<foreach collection='states' item='state' separator=','>#{state}</foreach>) "
+ "AND CLASSIFICATION_CATEGORY IN (<foreach collection='categories' item='category' separator=','>#{category}</foreach>) "
+ "AND DOMAIN IN (<foreach collection='domains' item='domain' separator=','>#{domain}</foreach>) "
+ "AND DUE IS NOT NULL "
+ "<if test=\"_databaseId == 'db2'\">GROUP BY CLASSIFICATION_KEY, (DAYS(DUE) - DAYS(CURRENT_TIMESTAMP))</if> "
+ "<if test=\"_databaseId == 'h2'\">GROUP BY CLASSIFICATION_KEY, DATEDIFF('DAY', CURRENT_TIMESTAMP, DUE)</if> "
+ "<if test=\"_databaseId == 'db2'\">GROUP BY CLASSIFICATION_ID, (DAYS(DUE) - DAYS(CURRENT_TIMESTAMP))</if> "
+ "<if test=\"_databaseId == 'h2'\">GROUP BY CLASSIFICATION_ID, DATEDIFF('DAY', CURRENT_TIMESTAMP, DUE)</if> "
+ "</script>")
@Results({
@Result(column = "CLASSIFICATION_KEY", property = "key"),
@Result(column = "CLASSIFICATION_ID", property = "key"),
@Result(column = "AGE_IN_DAYS", property = "ageInDays"),
@Result(column = "NUMBER_OF_TASKS", property = "numberOfTasks") })
List<MonitorQueryItem> getTaskCountOfClassificationsByWorkbasketsAndStates(
@Param("workbaskets") List<Workbasket> workbaskets,
@Param("workbasketIds") List<String> workbasketIds,
@Param("states") List<TaskState> states,
@Param("categories") List<String> categories,
@Param("domains") List<String> domains);
@Select("<script>"
+ "<if test=\"_databaseId == 'db2'\">SELECT T.CLASSIFICATION_KEY as TASK_CLASSIFICATION_KEY, A.CLASSIFICATION_KEY as ATTACHMENT_CLASSIFICATION_KEY, (DAYS(DUE) - DAYS(CURRENT_TIMESTAMP)) as AGE_IN_DAYS, COUNT(*) as NUMBER_OF_TASKS</if> "
+ "<if test=\"_databaseId == 'h2'\">SELECT T.CLASSIFICATION_KEY as TASK_CLASSIFICATION_KEY, A.CLASSIFICATION_KEY as ATTACHMENT_CLASSIFICATION_KEY, DATEDIFF('DAY', CURRENT_TIMESTAMP, DUE) as AGE_IN_DAYS, COUNT(*) as NUMBER_OF_TASKS</if> "
+ "<if test=\"_databaseId == 'db2'\">SELECT T.CLASSIFICATION_ID as TASK_CLASSIFICATION_ID, A.CLASSIFICATION_ID as ATTACHMENT_CLASSIFICATION_ID, (DAYS(DUE) - DAYS(CURRENT_TIMESTAMP)) as AGE_IN_DAYS, COUNT(*) as NUMBER_OF_TASKS</if> "
+ "<if test=\"_databaseId == 'h2'\">SELECT T.CLASSIFICATION_ID as TASK_CLASSIFICATION_ID, A.CLASSIFICATION_ID as ATTACHMENT_CLASSIFICATION_ID, DATEDIFF('DAY', CURRENT_TIMESTAMP, DUE) as AGE_IN_DAYS, COUNT(*) as NUMBER_OF_TASKS</if> "
+ "FROM TASK AS T LEFT JOIN ATTACHMENT AS A ON T.ID = A.TASK_ID "
+ "WHERE T.WORKBASKET_KEY IN (<foreach collection='workbaskets' item='workbasket' separator=','>#{workbasket.key}</foreach>) "
+ "WHERE T.WORKBASKET_ID IN (<foreach collection='workbasketIds' item='workbasketId' separator=','>#{workbasketId}</foreach>) "
+ "AND STATE IN (<foreach collection='states' item='state' separator=','>#{state}</foreach>) "
+ "AND CLASSIFICATION_CATEGORY IN (<foreach collection='categories' item='category' separator=','>#{category}</foreach>) "
+ "AND DOMAIN IN (<foreach collection='domains' item='domain' separator=','>#{domain}</foreach>) "
+ "AND DUE IS NOT NULL "
+ "<if test=\"_databaseId == 'db2'\">GROUP BY T.CLASSIFICATION_KEY, A.CLASSIFICATION_KEY, (DAYS(DUE) - DAYS(CURRENT_TIMESTAMP))</if> "
+ "<if test=\"_databaseId == 'h2'\">GROUP BY T.CLASSIFICATION_KEY, A.CLASSIFICATION_KEY, DATEDIFF('DAY', CURRENT_TIMESTAMP, DUE)</if> "
+ "<if test=\"_databaseId == 'db2'\">GROUP BY T.CLASSIFICATION_ID, A.CLASSIFICATION_ID, (DAYS(DUE) - DAYS(CURRENT_TIMESTAMP))</if> "
+ "<if test=\"_databaseId == 'h2'\">GROUP BY T.CLASSIFICATION_ID, A.CLASSIFICATION_ID, DATEDIFF('DAY', CURRENT_TIMESTAMP, DUE)</if> "
+ "</script>")
@Results({
@Result(column = "TASK_CLASSIFICATION_KEY", property = "key"),
@Result(column = "ATTACHMENT_CLASSIFICATION_KEY", property = "attachmentKey"),
@Result(column = "TASK_CLASSIFICATION_ID", property = "key"),
@Result(column = "ATTACHMENT_CLASSIFICATION_ID", property = "attachmentKey"),
@Result(column = "AGE_IN_DAYS", property = "ageInDays"),
@Result(column = "NUMBER_OF_TASKS", property = "numberOfTasks") })
List<DetailedMonitorQueryItem> getTaskCountOfDetailedClassificationsByWorkbasketsAndStates(
@Param("workbaskets") List<Workbasket> workbaskets,
@Param("workbasketIds") List<String> workbasketIds,
@Param("states") List<TaskState> states,
@Param("categories") List<String> categories,
@Param("domains") List<String> domains);
@ -111,7 +110,7 @@ public interface TaskMonitorMapper {
+ "<if test=\"_databaseId == 'db2'\">SELECT ${customField} as CUSTOM_FIELD, (DAYS(DUE) - DAYS(CURRENT_TIMESTAMP)) as AGE_IN_DAYS, COUNT(*) as NUMBER_OF_TASKS</if> "
+ "<if test=\"_databaseId == 'h2'\">SELECT ${customField} as CUSTOM_FIELD, DATEDIFF('DAY', CURRENT_TIMESTAMP, DUE) as AGE_IN_DAYS, COUNT(*) as NUMBER_OF_TASKS</if> "
+ "FROM TASK "
+ "WHERE WORKBASKET_KEY IN (<foreach collection='workbaskets' item='workbasket' separator=','>#{workbasket.key}</foreach>) "
+ "WHERE WORKBASKET_ID IN (<foreach collection='workbasketIds' item='workbasketId' separator=','>#{workbasketId}</foreach>) "
+ "AND STATE IN (<foreach collection='states' item='state' separator=','>#{state}</foreach>) "
+ "AND CLASSIFICATION_CATEGORY IN (<foreach collection='categories' item='category' separator=','>#{category}</foreach>) "
+ "AND DOMAIN IN (<foreach collection='domains' item='domain' separator=','>#{domain}</foreach>) "
@ -125,7 +124,7 @@ public interface TaskMonitorMapper {
@Result(column = "AGE_IN_DAYS", property = "ageInDays"),
@Result(column = "NUMBER_OF_TASKS", property = "numberOfTasks") })
List<MonitorQueryItem> getTaskCountOfCustomFieldValuesByWorkbasketsAndStatesAndCustomField(
@Param("workbaskets") List<Workbasket> workbaskets,
@Param("workbasketIds") List<String> workbasketIds,
@Param("states") List<TaskState> states,
@Param("categories") List<String> categories,
@Param("domains") List<String> domains,

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

@ -15,33 +15,23 @@ import org.h2.store.fs.FileUtils;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import pro.taskana.TaskMonitorService;
import pro.taskana.TaskanaEngine;
import pro.taskana.TaskanaEngine.ConnectionManagementMode;
import pro.taskana.Workbasket;
import pro.taskana.WorkbasketService;
import pro.taskana.configuration.TaskanaEngineConfiguration;
import pro.taskana.database.TestDataGenerator;
import pro.taskana.exceptions.ClassificationNotFoundException;
import pro.taskana.exceptions.NotAuthorizedException;
import pro.taskana.exceptions.WorkbasketNotFoundException;
import pro.taskana.impl.Report;
import pro.taskana.impl.ReportLineItem;
import pro.taskana.impl.ReportLineItemDefinition;
import pro.taskana.impl.TaskState;
import pro.taskana.impl.TaskanaEngineImpl;
import pro.taskana.impl.WorkbasketImpl;
import pro.taskana.impl.configuration.DBCleaner;
import pro.taskana.impl.configuration.TaskanaEngineConfigurationTest;
import pro.taskana.security.JAASRunner;
import pro.taskana.security.WithAccessId;
/**
* Acceptance test for all "category report" scenarios.
*/
@RunWith(JAASRunner.class)
public class ProvideCategoryReportAccTest {
protected static TaskanaEngineConfiguration taskanaEngineConfiguration;
@ -65,18 +55,16 @@ public class ProvideCategoryReportAccTest {
testDataGenerator.generateMonitoringTestData(dataSource);
}
@WithAccessId(userName = "monitor_user_1")
@Test
public void testGetTotalNumbersOfTasksOfCategoryReport()
throws WorkbasketNotFoundException, NotAuthorizedException {
public void testGetTotalNumbersOfTasksOfCategoryReport() {
TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService();
List<Workbasket> workbaskets = getListOfWorkbaskets();
List<String> workbasketIds = generateWorkbasketIds(3, 1);
List<TaskState> states = Arrays.asList(TaskState.READY, TaskState.CLAIMED);
List<String> categories = Arrays.asList("EXTERN", "AUTOMATIC", "MANUAL");
List<String> domains = Arrays.asList("DOMAIN_A", "DOMAIN_B", "DOMAIN_C");
Report report = taskMonitorService.getCategoryReport(workbaskets, states, categories, domains);
Report report = taskMonitorService.getCategoryReport(workbasketIds, states, categories, domains);
assertNotNull(report);
assertEquals(33, report.getReportLines().get(categories.get(0)).getTotalNumberOfTasks());
@ -86,23 +74,20 @@ public class ProvideCategoryReportAccTest {
assertEquals(0, report.getReportLines().get(categories.get(1)).getLineItems().size());
assertEquals(0, report.getReportLines().get(categories.get(2)).getLineItems().size());
assertEquals(50, report.getSumLine().getTotalNumberOfTasks());
}
@WithAccessId(userName = "monitor_user_1")
@Test
public void testGetCategoryReportWithReportLineItemDefinitions()
throws WorkbasketNotFoundException, NotAuthorizedException {
public void testGetCategoryReportWithReportLineItemDefinitions() {
TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService();
List<Workbasket> workbaskets = getListOfWorkbaskets();
List<String> workbasketIds = generateWorkbasketIds(3, 1);
List<TaskState> states = Arrays.asList(TaskState.READY, TaskState.CLAIMED);
List<String> categories = Arrays.asList("EXTERN", "AUTOMATIC", "MANUAL");
List<String> domains = Arrays.asList("DOMAIN_A", "DOMAIN_B", "DOMAIN_C");
List<ReportLineItemDefinition> reportLineItemDefinitions = getListOfReportLineItemDefinitions();
Report report = taskMonitorService.getCategoryReport(workbaskets, states, categories, domains,
Report report = taskMonitorService.getCategoryReport(workbasketIds, states, categories, domains,
reportLineItemDefinitions);
int sumLineCount = report.getSumLine().getLineItems().get(0).getNumberOfTasks()
@ -132,23 +117,20 @@ public class ProvideCategoryReportAccTest {
assertEquals(5, report.getSumLine().getLineItems().get(8).getNumberOfTasks());
assertEquals(50, report.getSumLine().getTotalNumberOfTasks());
assertEquals(50, sumLineCount);
}
@WithAccessId(userName = "monitor_user_1")
@Test
public void testEachItemOfCategoryReportWithCategoryFilter()
throws WorkbasketNotFoundException, NotAuthorizedException, ClassificationNotFoundException {
public void testEachItemOfCategoryReportWithCategoryFilter() {
TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService();
List<Workbasket> workbaskets = getListOfWorkbaskets();
List<String> workbasketIds = generateWorkbasketIds(3, 1);
List<TaskState> states = Arrays.asList(TaskState.READY, TaskState.CLAIMED);
List<String> categories = Arrays.asList("AUTOMATIC", "MANUAL");
List<String> domains = Arrays.asList("DOMAIN_A", "DOMAIN_B", "DOMAIN_C");
List<ReportLineItemDefinition> reportLineItemDefinitions = getShortListOfReportLineItemDefinitions();
Report report = taskMonitorService.getCategoryReport(workbaskets, states, categories, domains,
Report report = taskMonitorService.getCategoryReport(workbasketIds, states, categories, domains,
reportLineItemDefinitions);
List<ReportLineItem> line1 = report.getReportLines().get("AUTOMATIC").getLineItems();
@ -168,20 +150,18 @@ public class ProvideCategoryReportAccTest {
assertEquals(2, report.getReportLines().size());
}
@WithAccessId(userName = "monitor_user_1")
@Test
public void testEachItemOfCategoryReportWithDomainFilter()
throws WorkbasketNotFoundException, NotAuthorizedException, ClassificationNotFoundException {
public void testEachItemOfCategoryReportWithDomainFilter() {
TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService();
List<Workbasket> workbaskets = getListOfWorkbaskets();
List<String> workbasketIds = generateWorkbasketIds(3, 1);
List<TaskState> states = Arrays.asList(TaskState.READY, TaskState.CLAIMED);
List<String> categories = Arrays.asList("EXTERN", "AUTOMATIC", "MANUAL");
List<String> domains = Arrays.asList("DOMAIN_A");
List<ReportLineItemDefinition> reportLineItemDefinitions = getShortListOfReportLineItemDefinitions();
Report report = taskMonitorService.getCategoryReport(workbaskets, states, categories, domains,
Report report = taskMonitorService.getCategoryReport(workbasketIds, states, categories, domains,
reportLineItemDefinitions);
List<ReportLineItem> line1 = report.getReportLines().get("EXTERN").getLineItems();
@ -206,19 +186,12 @@ public class ProvideCategoryReportAccTest {
assertEquals(3, line3.get(4).getNumberOfTasks());
}
private List<Workbasket> getListOfWorkbaskets() throws WorkbasketNotFoundException, NotAuthorizedException {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
WorkbasketImpl workbasket1 = (WorkbasketImpl) workbasketService
.getWorkbasket("WBI:000000000000000000000000000000000001");
WorkbasketImpl workbasket2 = (WorkbasketImpl) workbasketService
.getWorkbasket("WBI:000000000000000000000000000000000002");
WorkbasketImpl workbasket3 = (WorkbasketImpl) workbasketService
.getWorkbasket("WBI:000000000000000000000000000000000003");
WorkbasketImpl workbasket4 = (WorkbasketImpl) workbasketService
.getWorkbasket("WBI:000000000000000000000000000000000004");
return Arrays.asList(workbasket1, workbasket2, workbasket3, workbasket4);
private List<String> generateWorkbasketIds(int amount, int startAt) {
List<String> workbasketIds = new ArrayList<>();
for (int i = 0; i < amount; i++) {
workbasketIds.add(String.format("WBI:%036d", startAt + i));
}
return workbasketIds;
}
private List<ReportLineItemDefinition> getListOfReportLineItemDefinitions() {

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

@ -15,33 +15,23 @@ import org.h2.store.fs.FileUtils;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import pro.taskana.TaskMonitorService;
import pro.taskana.TaskanaEngine;
import pro.taskana.TaskanaEngine.ConnectionManagementMode;
import pro.taskana.Workbasket;
import pro.taskana.WorkbasketService;
import pro.taskana.configuration.TaskanaEngineConfiguration;
import pro.taskana.database.TestDataGenerator;
import pro.taskana.exceptions.ClassificationNotFoundException;
import pro.taskana.exceptions.NotAuthorizedException;
import pro.taskana.exceptions.WorkbasketNotFoundException;
import pro.taskana.impl.Report;
import pro.taskana.impl.ReportLineItem;
import pro.taskana.impl.ReportLineItemDefinition;
import pro.taskana.impl.TaskState;
import pro.taskana.impl.TaskanaEngineImpl;
import pro.taskana.impl.WorkbasketImpl;
import pro.taskana.impl.configuration.DBCleaner;
import pro.taskana.impl.configuration.TaskanaEngineConfigurationTest;
import pro.taskana.security.JAASRunner;
import pro.taskana.security.WithAccessId;
/**
* Acceptance test for all "classification report" scenarios.
*/
@RunWith(JAASRunner.class)
public class ProvideClassificationReportAccTest {
protected static TaskanaEngineConfiguration taskanaEngineConfiguration;
@ -65,48 +55,49 @@ public class ProvideClassificationReportAccTest {
testDataGenerator.generateMonitoringTestData(dataSource);
}
@WithAccessId(userName = "monitor_user_1")
@Test
public void testGetTotalNumbersOfTasksOfClassificationReport()
throws WorkbasketNotFoundException, NotAuthorizedException, ClassificationNotFoundException {
public void testGetTotalNumbersOfTasksOfClassificationReport() {
TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService();
List<Workbasket> workbaskets = getListOfWorkbaskets();
List<String> workbasketIds = generateWorkbasketIds(3, 1);
List<TaskState> states = Arrays.asList(TaskState.READY, TaskState.CLAIMED);
List<String> categories = Arrays.asList("EXTERN", "AUTOMATIC", "MANUAL");
List<String> domains = Arrays.asList("DOMAIN_A", "DOMAIN_B", "DOMAIN_C");
Report report = taskMonitorService.getClassificationReport(workbaskets, states, categories, domains);
Report report = taskMonitorService.getClassificationReport(workbasketIds, states, categories, domains);
assertNotNull(report);
assertEquals(10, report.getReportLines().get("L10000").getTotalNumberOfTasks());
assertEquals(10, report.getReportLines().get("L20000").getTotalNumberOfTasks());
assertEquals(7, report.getReportLines().get("L30000").getTotalNumberOfTasks());
assertEquals(10, report.getReportLines().get("L40000").getTotalNumberOfTasks());
assertEquals(13, report.getReportLines().get("L50000").getTotalNumberOfTasks());
assertEquals(0, report.getReportLines().get("L10000").getLineItems().size());
assertEquals(0, report.getReportLines().get("L20000").getLineItems().size());
assertEquals(0, report.getReportLines().get("L30000").getLineItems().size());
assertEquals(0, report.getReportLines().get("L40000").getLineItems().size());
assertEquals(0, report.getReportLines().get("L50000").getLineItems().size());
assertEquals(10,
report.getReportLines().get("CLI:000000000000000000000000000000000001").getTotalNumberOfTasks());
assertEquals(10,
report.getReportLines().get("CLI:000000000000000000000000000000000002").getTotalNumberOfTasks());
assertEquals(7,
report.getReportLines().get("CLI:000000000000000000000000000000000003").getTotalNumberOfTasks());
assertEquals(10,
report.getReportLines().get("CLI:000000000000000000000000000000000004").getTotalNumberOfTasks());
assertEquals(13,
report.getReportLines().get("CLI:000000000000000000000000000000000005").getTotalNumberOfTasks());
assertEquals(0, report.getReportLines().get("CLI:000000000000000000000000000000000001").getLineItems().size());
assertEquals(0, report.getReportLines().get("CLI:000000000000000000000000000000000002").getLineItems().size());
assertEquals(0, report.getReportLines().get("CLI:000000000000000000000000000000000003").getLineItems().size());
assertEquals(0, report.getReportLines().get("CLI:000000000000000000000000000000000004").getLineItems().size());
assertEquals(0, report.getReportLines().get("CLI:000000000000000000000000000000000005").getLineItems().size());
assertEquals(50, report.getSumLine().getTotalNumberOfTasks());
}
@WithAccessId(userName = "monitor_user_1")
@Test
public void testGetClassificationReportWithReportLineItemDefinitions()
throws WorkbasketNotFoundException, NotAuthorizedException, ClassificationNotFoundException {
public void testGetClassificationReportWithReportLineItemDefinitions() {
TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService();
List<Workbasket> workbaskets = getListOfWorkbaskets();
List<String> workbasketIds = generateWorkbasketIds(3, 1);
List<TaskState> states = Arrays.asList(TaskState.READY, TaskState.CLAIMED);
List<String> categories = Arrays.asList("EXTERN", "AUTOMATIC", "MANUAL");
List<String> domains = Arrays.asList("DOMAIN_A", "DOMAIN_B", "DOMAIN_C");
List<ReportLineItemDefinition> reportLineItemDefinitions = getListOfReportLineItemDefinitions();
Report report = taskMonitorService.getClassificationReport(workbaskets, states, categories, domains,
Report report = taskMonitorService.getClassificationReport(workbasketIds, states, categories, domains,
reportLineItemDefinitions);
int sumLineCount = report.getSumLine().getLineItems().get(0).getNumberOfTasks()
@ -121,11 +112,16 @@ public class ProvideClassificationReportAccTest {
assertNotNull(report);
assertEquals(10, report.getReportLines().get("L10000").getTotalNumberOfTasks());
assertEquals(10, report.getReportLines().get("L20000").getTotalNumberOfTasks());
assertEquals(7, report.getReportLines().get("L30000").getTotalNumberOfTasks());
assertEquals(10, report.getReportLines().get("L40000").getTotalNumberOfTasks());
assertEquals(13, report.getReportLines().get("L50000").getTotalNumberOfTasks());
assertEquals(10,
report.getReportLines().get("CLI:000000000000000000000000000000000001").getTotalNumberOfTasks());
assertEquals(10,
report.getReportLines().get("CLI:000000000000000000000000000000000002").getTotalNumberOfTasks());
assertEquals(7,
report.getReportLines().get("CLI:000000000000000000000000000000000003").getTotalNumberOfTasks());
assertEquals(10,
report.getReportLines().get("CLI:000000000000000000000000000000000004").getTotalNumberOfTasks());
assertEquals(13,
report.getReportLines().get("CLI:000000000000000000000000000000000005").getTotalNumberOfTasks());
assertEquals(10, report.getSumLine().getLineItems().get(0).getNumberOfTasks());
assertEquals(9, report.getSumLine().getLineItems().get(1).getNumberOfTasks());
@ -140,51 +136,59 @@ public class ProvideClassificationReportAccTest {
assertEquals(50, sumLineCount);
}
@WithAccessId(userName = "monitor_user_1")
@Test
public void testEachItemOfClassificationReport()
throws WorkbasketNotFoundException, NotAuthorizedException, ClassificationNotFoundException {
public void testEachItemOfClassificationReport() {
TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService();
List<Workbasket> workbaskets = getListOfWorkbaskets();
List<String> workbasketIds = generateWorkbasketIds(3, 1);
List<TaskState> states = Arrays.asList(TaskState.READY, TaskState.CLAIMED);
List<String> categories = Arrays.asList("EXTERN", "AUTOMATIC", "MANUAL");
List<String> domains = Arrays.asList("DOMAIN_A", "DOMAIN_B", "DOMAIN_C");
List<ReportLineItemDefinition> reportLineItemDefinitions = getShortListOfReportLineItemDefinitions();
Report report = taskMonitorService.getClassificationReport(workbaskets, states, categories, domains,
Report report = taskMonitorService.getClassificationReport(workbasketIds, states, categories, domains,
reportLineItemDefinitions);
List<ReportLineItem> line1 = report.getReportLines().get("L10000").getLineItems();
List<ReportLineItem> line1 = report.getReportLines()
.get("CLI:000000000000000000000000000000000001")
.getLineItems();
assertEquals(7, line1.get(0).getNumberOfTasks());
assertEquals(2, line1.get(1).getNumberOfTasks());
assertEquals(1, line1.get(2).getNumberOfTasks());
assertEquals(0, line1.get(3).getNumberOfTasks());
assertEquals(0, line1.get(4).getNumberOfTasks());
List<ReportLineItem> line2 = report.getReportLines().get("L20000").getLineItems();
List<ReportLineItem> line2 = report.getReportLines()
.get("CLI:000000000000000000000000000000000002")
.getLineItems();
assertEquals(5, line2.get(0).getNumberOfTasks());
assertEquals(3, line2.get(1).getNumberOfTasks());
assertEquals(1, line2.get(2).getNumberOfTasks());
assertEquals(1, line2.get(3).getNumberOfTasks());
assertEquals(0, line2.get(4).getNumberOfTasks());
List<ReportLineItem> line3 = report.getReportLines().get("L30000").getLineItems();
List<ReportLineItem> line3 = report.getReportLines()
.get("CLI:000000000000000000000000000000000003")
.getLineItems();
assertEquals(2, line3.get(0).getNumberOfTasks());
assertEquals(1, line3.get(1).getNumberOfTasks());
assertEquals(0, line3.get(2).getNumberOfTasks());
assertEquals(1, line3.get(3).getNumberOfTasks());
assertEquals(3, line3.get(4).getNumberOfTasks());
List<ReportLineItem> line4 = report.getReportLines().get("L40000").getLineItems();
List<ReportLineItem> line4 = report.getReportLines()
.get("CLI:000000000000000000000000000000000004")
.getLineItems();
assertEquals(2, line4.get(0).getNumberOfTasks());
assertEquals(2, line4.get(1).getNumberOfTasks());
assertEquals(2, line4.get(2).getNumberOfTasks());
assertEquals(0, line4.get(3).getNumberOfTasks());
assertEquals(4, line4.get(4).getNumberOfTasks());
List<ReportLineItem> line5 = report.getReportLines().get("L50000").getLineItems();
List<ReportLineItem> line5 = report.getReportLines()
.get("CLI:000000000000000000000000000000000005")
.getLineItems();
assertEquals(3, line5.get(0).getNumberOfTasks());
assertEquals(3, line5.get(1).getNumberOfTasks());
assertEquals(0, line5.get(2).getNumberOfTasks());
@ -192,30 +196,32 @@ public class ProvideClassificationReportAccTest {
assertEquals(2, line5.get(4).getNumberOfTasks());
}
@WithAccessId(userName = "monitor_user_1")
@Test
public void testEachItemOfClassificationReportWithCategoryFilter()
throws WorkbasketNotFoundException, NotAuthorizedException, ClassificationNotFoundException {
public void testEachItemOfClassificationReportWithCategoryFilter() {
TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService();
List<Workbasket> workbaskets = getListOfWorkbaskets();
List<String> workbasketIds = generateWorkbasketIds(3, 1);
List<TaskState> states = Arrays.asList(TaskState.READY, TaskState.CLAIMED);
List<String> categories = Arrays.asList("AUTOMATIC", "MANUAL");
List<String> domains = Arrays.asList("DOMAIN_A", "DOMAIN_B", "DOMAIN_C");
List<ReportLineItemDefinition> reportLineItemDefinitions = getShortListOfReportLineItemDefinitions();
Report report = taskMonitorService.getClassificationReport(workbaskets, states, categories, domains,
Report report = taskMonitorService.getClassificationReport(workbasketIds, states, categories, domains,
reportLineItemDefinitions);
List<ReportLineItem> line1 = report.getReportLines().get("L30000").getLineItems();
List<ReportLineItem> line1 = report.getReportLines()
.get("CLI:000000000000000000000000000000000003")
.getLineItems();
assertEquals(2, line1.get(0).getNumberOfTasks());
assertEquals(1, line1.get(1).getNumberOfTasks());
assertEquals(0, line1.get(2).getNumberOfTasks());
assertEquals(1, line1.get(3).getNumberOfTasks());
assertEquals(3, line1.get(4).getNumberOfTasks());
List<ReportLineItem> line2 = report.getReportLines().get("L40000").getLineItems();
List<ReportLineItem> line2 = report.getReportLines()
.get("CLI:000000000000000000000000000000000004")
.getLineItems();
assertEquals(2, line2.get(0).getNumberOfTasks());
assertEquals(2, line2.get(1).getNumberOfTasks());
assertEquals(2, line2.get(2).getNumberOfTasks());
@ -225,51 +231,59 @@ public class ProvideClassificationReportAccTest {
assertEquals(2, report.getReportLines().size());
}
@WithAccessId(userName = "monitor_user_1")
@Test
public void testEachItemOfClassificationReportWithDomainFilter()
throws WorkbasketNotFoundException, NotAuthorizedException, ClassificationNotFoundException {
public void testEachItemOfClassificationReportWithDomainFilter() {
TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService();
List<Workbasket> workbaskets = getListOfWorkbaskets();
List<String> workbasketIds = generateWorkbasketIds(3, 1);
List<TaskState> states = Arrays.asList(TaskState.READY, TaskState.CLAIMED);
List<String> categories = Arrays.asList("EXTERN", "AUTOMATIC", "MANUAL");
List<String> domains = Arrays.asList("DOMAIN_A");
List<ReportLineItemDefinition> reportLineItemDefinitions = getShortListOfReportLineItemDefinitions();
Report report = taskMonitorService.getClassificationReport(workbaskets, states, categories, domains,
Report report = taskMonitorService.getClassificationReport(workbasketIds, states, categories, domains,
reportLineItemDefinitions);
List<ReportLineItem> line1 = report.getReportLines().get("L10000").getLineItems();
List<ReportLineItem> line1 = report.getReportLines()
.get("CLI:000000000000000000000000000000000001")
.getLineItems();
assertEquals(5, line1.get(0).getNumberOfTasks());
assertEquals(2, line1.get(1).getNumberOfTasks());
assertEquals(1, line1.get(2).getNumberOfTasks());
assertEquals(0, line1.get(3).getNumberOfTasks());
assertEquals(0, line1.get(4).getNumberOfTasks());
List<ReportLineItem> line2 = report.getReportLines().get("L20000").getLineItems();
List<ReportLineItem> line2 = report.getReportLines()
.get("CLI:000000000000000000000000000000000002")
.getLineItems();
assertEquals(3, line2.get(0).getNumberOfTasks());
assertEquals(1, line2.get(1).getNumberOfTasks());
assertEquals(1, line2.get(2).getNumberOfTasks());
assertEquals(1, line2.get(3).getNumberOfTasks());
assertEquals(0, line2.get(4).getNumberOfTasks());
List<ReportLineItem> line3 = report.getReportLines().get("L30000").getLineItems();
List<ReportLineItem> line3 = report.getReportLines()
.get("CLI:000000000000000000000000000000000003")
.getLineItems();
assertEquals(1, line3.get(0).getNumberOfTasks());
assertEquals(0, line3.get(1).getNumberOfTasks());
assertEquals(0, line3.get(2).getNumberOfTasks());
assertEquals(1, line3.get(3).getNumberOfTasks());
assertEquals(1, line3.get(4).getNumberOfTasks());
List<ReportLineItem> line4 = report.getReportLines().get("L40000").getLineItems();
List<ReportLineItem> line4 = report.getReportLines()
.get("CLI:000000000000000000000000000000000004")
.getLineItems();
assertEquals(2, line4.get(0).getNumberOfTasks());
assertEquals(0, line4.get(1).getNumberOfTasks());
assertEquals(0, line4.get(2).getNumberOfTasks());
assertEquals(0, line4.get(3).getNumberOfTasks());
assertEquals(3, line4.get(4).getNumberOfTasks());
List<ReportLineItem> line5 = report.getReportLines().get("L50000").getLineItems();
List<ReportLineItem> line5 = report.getReportLines()
.get("CLI:000000000000000000000000000000000005")
.getLineItems();
assertEquals(0, line5.get(0).getNumberOfTasks());
assertEquals(1, line5.get(1).getNumberOfTasks());
assertEquals(0, line5.get(2).getNumberOfTasks());
@ -277,19 +291,12 @@ public class ProvideClassificationReportAccTest {
assertEquals(0, line5.get(4).getNumberOfTasks());
}
private List<Workbasket> getListOfWorkbaskets() throws WorkbasketNotFoundException, NotAuthorizedException {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
WorkbasketImpl workbasket1 = (WorkbasketImpl) workbasketService
.getWorkbasket("WBI:000000000000000000000000000000000001");
WorkbasketImpl workbasket2 = (WorkbasketImpl) workbasketService
.getWorkbasket("WBI:000000000000000000000000000000000002");
WorkbasketImpl workbasket3 = (WorkbasketImpl) workbasketService
.getWorkbasket("WBI:000000000000000000000000000000000003");
WorkbasketImpl workbasket4 = (WorkbasketImpl) workbasketService
.getWorkbasket("WBI:000000000000000000000000000000000004");
return Arrays.asList(workbasket1, workbasket2, workbasket3, workbasket4);
private List<String> generateWorkbasketIds(int amount, int startAt) {
List<String> workbasketIds = new ArrayList<>();
for (int i = 0; i < amount; i++) {
workbasketIds.add(String.format("WBI:%036d", startAt + i));
}
return workbasketIds;
}
private List<ReportLineItemDefinition> getListOfReportLineItemDefinitions() {

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

@ -15,34 +15,24 @@ import org.h2.store.fs.FileUtils;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import pro.taskana.TaskMonitorService;
import pro.taskana.TaskanaEngine;
import pro.taskana.TaskanaEngine.ConnectionManagementMode;
import pro.taskana.Workbasket;
import pro.taskana.WorkbasketService;
import pro.taskana.configuration.TaskanaEngineConfiguration;
import pro.taskana.database.TestDataGenerator;
import pro.taskana.exceptions.ClassificationNotFoundException;
import pro.taskana.exceptions.NotAuthorizedException;
import pro.taskana.exceptions.WorkbasketNotFoundException;
import pro.taskana.impl.CustomField;
import pro.taskana.impl.Report;
import pro.taskana.impl.ReportLineItem;
import pro.taskana.impl.ReportLineItemDefinition;
import pro.taskana.impl.TaskState;
import pro.taskana.impl.TaskanaEngineImpl;
import pro.taskana.impl.WorkbasketImpl;
import pro.taskana.impl.configuration.DBCleaner;
import pro.taskana.impl.configuration.TaskanaEngineConfigurationTest;
import pro.taskana.security.JAASRunner;
import pro.taskana.security.WithAccessId;
/**
* Acceptance test for all "classification report" scenarios.
*/
@RunWith(JAASRunner.class)
public class ProvideCustomFieldValueReportAccTest {
protected static TaskanaEngineConfiguration taskanaEngineConfiguration;
@ -66,14 +56,12 @@ public class ProvideCustomFieldValueReportAccTest {
testDataGenerator.generateMonitoringTestData(dataSource);
}
@WithAccessId(userName = "monitor_user_1")
@Test
public void testGetTotalNumbersOfTasksOfCustomFieldValueReportForCustom1()
throws WorkbasketNotFoundException, NotAuthorizedException, ClassificationNotFoundException {
public void testGetTotalNumbersOfTasksOfCustomFieldValueReportForCustom1() {
TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService();
List<Workbasket> workbaskets = getListOfWorkbaskets();
List<String> workbasketIds = generateWorkbasketIds(3, 1);
List<TaskState> states = Arrays.asList(TaskState.READY, TaskState.CLAIMED);
List<String> categories = Arrays.asList("EXTERN", "AUTOMATIC", "MANUAL");
List<String> domains = Arrays.asList("DOMAIN_A", "DOMAIN_B", "DOMAIN_C");
@ -83,7 +71,7 @@ public class ProvideCustomFieldValueReportAccTest {
String customFieldValue2 = "Geschaeftsstelle B";
String customFieldValue3 = "Geschaeftsstelle C";
Report report = taskMonitorService.getCustomFieldValueReport(workbaskets, states, categories, domains,
Report report = taskMonitorService.getCustomFieldValueReport(workbasketIds, states, categories, domains,
customField);
assertNotNull(report);
@ -97,14 +85,12 @@ public class ProvideCustomFieldValueReportAccTest {
assertEquals(50, report.getSumLine().getTotalNumberOfTasks());
}
@WithAccessId(userName = "monitor_user_1")
@Test
public void testGetTotalNumbersOfTasksOfCustomFieldValueReportForCustom2()
throws WorkbasketNotFoundException, NotAuthorizedException, ClassificationNotFoundException {
public void testGetTotalNumbersOfTasksOfCustomFieldValueReportForCustom2() {
TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService();
List<Workbasket> workbaskets = getListOfWorkbaskets();
List<String> workbasketIds = generateWorkbasketIds(3, 1);
List<TaskState> states = Arrays.asList(TaskState.READY, TaskState.CLAIMED);
List<String> categories = Arrays.asList("EXTERN", "AUTOMATIC", "MANUAL");
List<String> domains = Arrays.asList("DOMAIN_A", "DOMAIN_B", "DOMAIN_C");
@ -113,7 +99,7 @@ public class ProvideCustomFieldValueReportAccTest {
String customFieldValue1 = "Vollkasko";
String customFieldValue2 = "Teilkasko";
Report report = taskMonitorService.getCustomFieldValueReport(workbaskets, states, categories, domains,
Report report = taskMonitorService.getCustomFieldValueReport(workbasketIds, states, categories, domains,
customField);
assertNotNull(report);
assertEquals(21, report.getReportLines().get(customFieldValue1).getTotalNumberOfTasks());
@ -126,14 +112,12 @@ public class ProvideCustomFieldValueReportAccTest {
assertEquals(50, report.getSumLine().getTotalNumberOfTasks());
}
@WithAccessId(userName = "monitor_user_1")
@Test
public void testGetCustomFieldValueReportWithReportLineItemDefinitions()
throws WorkbasketNotFoundException, NotAuthorizedException, ClassificationNotFoundException {
public void testGetCustomFieldValueReportWithReportLineItemDefinitions() {
TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService();
List<Workbasket> workbaskets = getListOfWorkbaskets();
List<String> workbasketIds = generateWorkbasketIds(3, 1);
List<TaskState> states = Arrays.asList(TaskState.READY, TaskState.CLAIMED);
List<String> categories = Arrays.asList("EXTERN", "AUTOMATIC", "MANUAL");
List<String> domains = Arrays.asList("DOMAIN_A", "DOMAIN_B", "DOMAIN_C");
@ -144,7 +128,7 @@ public class ProvideCustomFieldValueReportAccTest {
String customFieldValue2 = "Geschaeftsstelle B";
String customFieldValue3 = "Geschaeftsstelle C";
Report report = taskMonitorService.getCustomFieldValueReport(workbaskets, states, categories, domains,
Report report = taskMonitorService.getCustomFieldValueReport(workbasketIds, states, categories, domains,
customField, reportLineItemDefinitions);
assertNotNull(report);
@ -167,14 +151,12 @@ public class ProvideCustomFieldValueReportAccTest {
assertEquals(50, report.getSumLine().getTotalNumberOfTasks());
}
@WithAccessId(userName = "monitor_user_1")
@Test
public void testGetCustomFieldValueReportWithReportLineItemDefinitionsNotInWorkingDays()
throws WorkbasketNotFoundException, NotAuthorizedException, ClassificationNotFoundException {
public void testGetCustomFieldValueReportWithReportLineItemDefinitionsNotInWorkingDays() {
TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService();
List<Workbasket> workbaskets = getListOfWorkbaskets();
List<String> workbasketIds = generateWorkbasketIds(3, 1);
List<TaskState> states = Arrays.asList(TaskState.READY, TaskState.CLAIMED);
List<String> categories = Arrays.asList("EXTERN", "AUTOMATIC", "MANUAL");
List<String> domains = Arrays.asList("DOMAIN_A", "DOMAIN_B", "DOMAIN_C");
@ -185,7 +167,7 @@ public class ProvideCustomFieldValueReportAccTest {
String customFieldValue2 = "Geschaeftsstelle B";
String customFieldValue3 = "Geschaeftsstelle C";
Report report = taskMonitorService.getCustomFieldValueReport(workbaskets, states, categories, domains,
Report report = taskMonitorService.getCustomFieldValueReport(workbasketIds, states, categories, domains,
customField, reportLineItemDefinitions, false);
assertNotNull(report);
@ -208,14 +190,12 @@ public class ProvideCustomFieldValueReportAccTest {
assertEquals(50, report.getSumLine().getTotalNumberOfTasks());
}
@WithAccessId(userName = "monitor_user_1")
@Test
public void testEachItemOfCustomFieldValueReport()
throws WorkbasketNotFoundException, NotAuthorizedException, ClassificationNotFoundException {
public void testEachItemOfCustomFieldValueReport() {
TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService();
List<Workbasket> workbaskets = getListOfWorkbaskets();
List<String> workbasketIds = generateWorkbasketIds(3, 1);
List<TaskState> states = Arrays.asList(TaskState.READY, TaskState.CLAIMED);
List<String> categories = Arrays.asList("EXTERN", "AUTOMATIC", "MANUAL");
List<String> domains = Arrays.asList("DOMAIN_A", "DOMAIN_B", "DOMAIN_C");
@ -226,7 +206,7 @@ public class ProvideCustomFieldValueReportAccTest {
String customFieldValue2 = "Geschaeftsstelle B";
String customFieldValue3 = "Geschaeftsstelle C";
Report report = taskMonitorService.getCustomFieldValueReport(workbaskets, states, categories, domains,
Report report = taskMonitorService.getCustomFieldValueReport(workbasketIds, states, categories, domains,
customField, reportLineItemDefinitions);
List<ReportLineItem> line1 = report.getReportLines().get(customFieldValue1).getLineItems();
@ -251,14 +231,12 @@ public class ProvideCustomFieldValueReportAccTest {
assertEquals(6, line3.get(4).getNumberOfTasks());
}
@WithAccessId(userName = "monitor_user_1")
@Test
public void testEachItemOfCustomFieldValueReportWithCategoryFilter()
throws WorkbasketNotFoundException, NotAuthorizedException, ClassificationNotFoundException {
public void testEachItemOfCustomFieldValueReportWithCategoryFilter() {
TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService();
List<Workbasket> workbaskets = getListOfWorkbaskets();
List<String> workbasketIds = generateWorkbasketIds(3, 1);
List<TaskState> states = Arrays.asList(TaskState.READY, TaskState.CLAIMED);
List<String> categories = Arrays.asList("AUTOMATIC", "MANUAL");
List<String> domains = Arrays.asList("DOMAIN_A", "DOMAIN_B", "DOMAIN_C");
@ -269,7 +247,7 @@ public class ProvideCustomFieldValueReportAccTest {
String customFieldValue2 = "Geschaeftsstelle B";
String customFieldValue3 = "Geschaeftsstelle C";
Report report = taskMonitorService.getCustomFieldValueReport(workbaskets, states, categories, domains,
Report report = taskMonitorService.getCustomFieldValueReport(workbasketIds, states, categories, domains,
customField, reportLineItemDefinitions);
List<ReportLineItem> line1 = report.getReportLines().get(customFieldValue1).getLineItems();
@ -294,14 +272,12 @@ public class ProvideCustomFieldValueReportAccTest {
assertEquals(4, line3.get(4).getNumberOfTasks());
}
@WithAccessId(userName = "monitor_user_1")
@Test
public void testEachItemOfCustomFieldValueReportWithDomainFilter()
throws WorkbasketNotFoundException, NotAuthorizedException, ClassificationNotFoundException {
public void testEachItemOfCustomFieldValueReportWithDomainFilter() {
TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService();
List<Workbasket> workbaskets = getListOfWorkbaskets();
List<String> workbasketIds = generateWorkbasketIds(3, 1);
List<TaskState> states = Arrays.asList(TaskState.READY, TaskState.CLAIMED);
List<String> categories = Arrays.asList("EXTERN", "AUTOMATIC", "MANUAL");
List<String> domains = Arrays.asList("DOMAIN_A");
@ -312,7 +288,7 @@ public class ProvideCustomFieldValueReportAccTest {
String customFieldValue2 = "Geschaeftsstelle B";
String customFieldValue3 = "Geschaeftsstelle C";
Report report = taskMonitorService.getCustomFieldValueReport(workbaskets, states, categories, domains,
Report report = taskMonitorService.getCustomFieldValueReport(workbasketIds, states, categories, domains,
customField, reportLineItemDefinitions);
List<ReportLineItem> line1 = report.getReportLines().get(customFieldValue1).getLineItems();
@ -337,19 +313,12 @@ public class ProvideCustomFieldValueReportAccTest {
assertEquals(3, line3.get(4).getNumberOfTasks());
}
private List<Workbasket> getListOfWorkbaskets() throws WorkbasketNotFoundException, NotAuthorizedException {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
WorkbasketImpl workbasket1 = (WorkbasketImpl) workbasketService
.getWorkbasket("WBI:000000000000000000000000000000000001");
WorkbasketImpl workbasket2 = (WorkbasketImpl) workbasketService
.getWorkbasket("WBI:000000000000000000000000000000000002");
WorkbasketImpl workbasket3 = (WorkbasketImpl) workbasketService
.getWorkbasket("WBI:000000000000000000000000000000000003");
WorkbasketImpl workbasket4 = (WorkbasketImpl) workbasketService
.getWorkbasket("WBI:000000000000000000000000000000000004");
return Arrays.asList(workbasket1, workbasket2, workbasket3, workbasket4);
private List<String> generateWorkbasketIds(int amount, int startAt) {
List<String> workbasketIds = new ArrayList<>();
for (int i = 0; i < amount; i++) {
workbasketIds.add(String.format("WBI:%036d", startAt + i));
}
return workbasketIds;
}
private List<ReportLineItemDefinition> getListOfReportLineItemDefinitions() {

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

@ -15,34 +15,24 @@ import org.h2.store.fs.FileUtils;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import pro.taskana.TaskMonitorService;
import pro.taskana.TaskanaEngine;
import pro.taskana.TaskanaEngine.ConnectionManagementMode;
import pro.taskana.Workbasket;
import pro.taskana.WorkbasketService;
import pro.taskana.configuration.TaskanaEngineConfiguration;
import pro.taskana.database.TestDataGenerator;
import pro.taskana.exceptions.ClassificationNotFoundException;
import pro.taskana.exceptions.NotAuthorizedException;
import pro.taskana.exceptions.WorkbasketNotFoundException;
import pro.taskana.impl.DetailedClassificationReport;
import pro.taskana.impl.DetailedReportLine;
import pro.taskana.impl.ReportLine;
import pro.taskana.impl.ReportLineItemDefinition;
import pro.taskana.impl.TaskState;
import pro.taskana.impl.TaskanaEngineImpl;
import pro.taskana.impl.WorkbasketImpl;
import pro.taskana.impl.configuration.DBCleaner;
import pro.taskana.impl.configuration.TaskanaEngineConfigurationTest;
import pro.taskana.security.JAASRunner;
import pro.taskana.security.WithAccessId;
/**
* Acceptance test for all "classification report" scenarios.
* Acceptance test for all "detailed classification report" scenarios.
*/
@RunWith(JAASRunner.class)
public class ProvideDetailedClassificationReportAccTest {
protected static TaskanaEngineConfiguration taskanaEngineConfiguration;
@ -66,52 +56,55 @@ public class ProvideDetailedClassificationReportAccTest {
testDataGenerator.generateMonitoringTestData(dataSource);
}
@WithAccessId(userName = "monitor_user_1")
@Test
public void testGetTotalNumbersOfTasksOfClassificationReport()
throws WorkbasketNotFoundException, NotAuthorizedException, ClassificationNotFoundException {
public void testGetTotalNumbersOfTasksOfDetailedClassificationReport() {
TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService();
List<Workbasket> workbaskets = getListOfWorkbaskets();
List<String> workbasketIds = generateWorkbasketIds(3, 1);
List<TaskState> states = Arrays.asList(TaskState.READY, TaskState.CLAIMED);
List<String> categories = Arrays.asList("EXTERN", "AUTOMATIC", "MANUAL");
List<String> domains = Arrays.asList("DOMAIN_A", "DOMAIN_B", "DOMAIN_C");
DetailedClassificationReport report = taskMonitorService.getDetailedClassificationReport(workbaskets, states,
DetailedClassificationReport report = taskMonitorService.getDetailedClassificationReport(workbasketIds, states,
categories, domains);
assertNotNull(report);
DetailedReportLine line1 = (DetailedReportLine) report.getReportLines().get("L10000");
DetailedReportLine line1 = (DetailedReportLine) report.getReportLines()
.get("CLI:000000000000000000000000000000000001");
assertEquals(10, line1.getTotalNumberOfTasks());
assertEquals(3, line1.getDetailLines().get("L11000").getTotalNumberOfTasks());
assertEquals(3, line1.getDetailLines().get("CLI:000000000000000000000000000000000006").getTotalNumberOfTasks());
assertEquals(7, line1.getDetailLines().get("N/A").getTotalNumberOfTasks());
assertEquals(0, line1.getLineItems().size());
assertEquals(2, line1.getDetailLines().size());
DetailedReportLine line2 = (DetailedReportLine) report.getReportLines().get("L20000");
DetailedReportLine line2 = (DetailedReportLine) report.getReportLines()
.get("CLI:000000000000000000000000000000000002");
assertEquals(10, line2.getTotalNumberOfTasks());
assertEquals(4, line2.getDetailLines().get("L22000").getTotalNumberOfTasks());
assertEquals(4, line2.getDetailLines().get("CLI:000000000000000000000000000000000007").getTotalNumberOfTasks());
assertEquals(6, line2.getDetailLines().get("N/A").getTotalNumberOfTasks());
assertEquals(0, line2.getLineItems().size());
assertEquals(2, line2.getDetailLines().size());
DetailedReportLine line3 = (DetailedReportLine) report.getReportLines().get("L30000");
DetailedReportLine line3 = (DetailedReportLine) report.getReportLines()
.get("CLI:000000000000000000000000000000000003");
assertEquals(7, line3.getTotalNumberOfTasks());
assertEquals(3, line3.getDetailLines().get("L33000").getTotalNumberOfTasks());
assertEquals(1, line3.getDetailLines().get("L99000").getTotalNumberOfTasks());
assertEquals(3, line3.getDetailLines().get("CLI:000000000000000000000000000000000008").getTotalNumberOfTasks());
assertEquals(1, line3.getDetailLines().get("CLI:000000000000000000000000000000000009").getTotalNumberOfTasks());
assertEquals(3, line3.getDetailLines().get("N/A").getTotalNumberOfTasks());
assertEquals(0, line3.getLineItems().size());
assertEquals(3, line3.getDetailLines().size());
DetailedReportLine line4 = (DetailedReportLine) report.getReportLines().get("L40000");
DetailedReportLine line4 = (DetailedReportLine) report.getReportLines()
.get("CLI:000000000000000000000000000000000004");
assertEquals(10, line4.getTotalNumberOfTasks());
assertEquals(10, line4.getDetailLines().get("N/A").getTotalNumberOfTasks());
assertEquals(0, line4.getLineItems().size());
assertEquals(1, line4.getDetailLines().size());
DetailedReportLine line5 = (DetailedReportLine) report.getReportLines().get("L50000");
DetailedReportLine line5 = (DetailedReportLine) report.getReportLines()
.get("CLI:000000000000000000000000000000000005");
assertEquals(13, line5.getTotalNumberOfTasks());
assertEquals(13, line5.getDetailLines().get("N/A").getTotalNumberOfTasks());
assertEquals(0, line5.getLineItems().size());
@ -120,29 +113,32 @@ public class ProvideDetailedClassificationReportAccTest {
assertEquals(50, report.getSumLine().getTotalNumberOfTasks());
}
@WithAccessId(userName = "monitor_user_1")
@Test
public void testGetClassificationReportWithReportLineItemDefinitions()
throws WorkbasketNotFoundException, NotAuthorizedException, ClassificationNotFoundException {
public void testGetDetailedClassificationReportWithReportLineItemDefinitions() {
TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService();
List<Workbasket> workbaskets = getListOfWorkbaskets();
List<String> workbasketIds = generateWorkbasketIds(3, 1);
List<TaskState> states = Arrays.asList(TaskState.READY, TaskState.CLAIMED);
List<String> categories = Arrays.asList("EXTERN", "AUTOMATIC", "MANUAL");
List<String> domains = Arrays.asList("DOMAIN_A", "DOMAIN_B", "DOMAIN_C");
List<ReportLineItemDefinition> reportLineItemDefinitions = getListOfReportLineItemDefinitions();
DetailedClassificationReport report = taskMonitorService.getDetailedClassificationReport(workbaskets, states,
DetailedClassificationReport report = taskMonitorService.getDetailedClassificationReport(workbasketIds, states,
categories, domains, reportLineItemDefinitions);
assertNotNull(report);
assertEquals(10, report.getReportLines().get("L10000").getTotalNumberOfTasks());
assertEquals(10, report.getReportLines().get("L20000").getTotalNumberOfTasks());
assertEquals(7, report.getReportLines().get("L30000").getTotalNumberOfTasks());
assertEquals(10, report.getReportLines().get("L40000").getTotalNumberOfTasks());
assertEquals(13, report.getReportLines().get("L50000").getTotalNumberOfTasks());
assertEquals(10,
report.getReportLines().get("CLI:000000000000000000000000000000000001").getTotalNumberOfTasks());
assertEquals(10,
report.getReportLines().get("CLI:000000000000000000000000000000000002").getTotalNumberOfTasks());
assertEquals(7,
report.getReportLines().get("CLI:000000000000000000000000000000000003").getTotalNumberOfTasks());
assertEquals(10,
report.getReportLines().get("CLI:000000000000000000000000000000000004").getTotalNumberOfTasks());
assertEquals(13,
report.getReportLines().get("CLI:000000000000000000000000000000000005").getTotalNumberOfTasks());
assertEquals(10, report.getSumLine().getLineItems().get(0).getNumberOfTasks());
assertEquals(9, report.getSumLine().getLineItems().get(1).getNumberOfTasks());
@ -156,30 +152,29 @@ public class ProvideDetailedClassificationReportAccTest {
assertEquals(50, report.getSumLine().getTotalNumberOfTasks());
}
@WithAccessId(userName = "monitor_user_1")
@Test
public void testEachItemOfClassificationReport()
throws WorkbasketNotFoundException, NotAuthorizedException, ClassificationNotFoundException {
public void testEachItemOfDetailedClassificationReport() {
TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService();
List<Workbasket> workbaskets = getListOfWorkbaskets();
List<String> workbasketIds = generateWorkbasketIds(3, 1);
List<TaskState> states = Arrays.asList(TaskState.READY, TaskState.CLAIMED);
List<String> categories = Arrays.asList("EXTERN", "AUTOMATIC", "MANUAL");
List<String> domains = Arrays.asList("DOMAIN_A", "DOMAIN_B", "DOMAIN_C");
List<ReportLineItemDefinition> reportLineItemDefinitions = getShortListOfReportLineItemDefinitions();
DetailedClassificationReport report = taskMonitorService.getDetailedClassificationReport(workbaskets, states,
DetailedClassificationReport report = taskMonitorService.getDetailedClassificationReport(workbasketIds, states,
categories, domains, reportLineItemDefinitions);
DetailedReportLine line1 = (DetailedReportLine) report.getReportLines().get("L10000");
DetailedReportLine line1 = (DetailedReportLine) report.getReportLines()
.get("CLI:000000000000000000000000000000000001");
assertEquals(7, line1.getLineItems().get(0).getNumberOfTasks());
assertEquals(2, line1.getLineItems().get(1).getNumberOfTasks());
assertEquals(1, line1.getLineItems().get(2).getNumberOfTasks());
assertEquals(0, line1.getLineItems().get(3).getNumberOfTasks());
assertEquals(0, line1.getLineItems().get(4).getNumberOfTasks());
ReportLine detailedLine1 = line1.getDetailLines().get("L11000");
ReportLine detailedLine1 = line1.getDetailLines().get("CLI:000000000000000000000000000000000006");
assertEquals(2, detailedLine1.getLineItems().get(0).getNumberOfTasks());
assertEquals(0, detailedLine1.getLineItems().get(1).getNumberOfTasks());
assertEquals(1, detailedLine1.getLineItems().get(2).getNumberOfTasks());
@ -193,14 +188,15 @@ public class ProvideDetailedClassificationReportAccTest {
assertEquals(0, detailedLineNoAttachment1.getLineItems().get(3).getNumberOfTasks());
assertEquals(0, detailedLineNoAttachment1.getLineItems().get(4).getNumberOfTasks());
DetailedReportLine line2 = (DetailedReportLine) report.getReportLines().get("L20000");
DetailedReportLine line2 = (DetailedReportLine) report.getReportLines()
.get("CLI:000000000000000000000000000000000002");
assertEquals(5, line2.getLineItems().get(0).getNumberOfTasks());
assertEquals(3, line2.getLineItems().get(1).getNumberOfTasks());
assertEquals(1, line2.getLineItems().get(2).getNumberOfTasks());
assertEquals(1, line2.getLineItems().get(3).getNumberOfTasks());
assertEquals(0, line2.getLineItems().get(4).getNumberOfTasks());
ReportLine detailedLine2 = line2.getDetailLines().get("L22000");
ReportLine detailedLine2 = line2.getDetailLines().get("CLI:000000000000000000000000000000000007");
assertEquals(1, detailedLine2.getLineItems().get(0).getNumberOfTasks());
assertEquals(1, detailedLine2.getLineItems().get(1).getNumberOfTasks());
assertEquals(1, detailedLine2.getLineItems().get(2).getNumberOfTasks());
@ -214,21 +210,22 @@ public class ProvideDetailedClassificationReportAccTest {
assertEquals(0, detailedLineNoAttachment2.getLineItems().get(3).getNumberOfTasks());
assertEquals(0, detailedLineNoAttachment2.getLineItems().get(4).getNumberOfTasks());
DetailedReportLine line3 = (DetailedReportLine) report.getReportLines().get("L30000");
DetailedReportLine line3 = (DetailedReportLine) report.getReportLines()
.get("CLI:000000000000000000000000000000000003");
assertEquals(2, line3.getLineItems().get(0).getNumberOfTasks());
assertEquals(1, line3.getLineItems().get(1).getNumberOfTasks());
assertEquals(0, line3.getLineItems().get(2).getNumberOfTasks());
assertEquals(1, line3.getLineItems().get(3).getNumberOfTasks());
assertEquals(3, line3.getLineItems().get(4).getNumberOfTasks());
ReportLine detailedLine3a = line3.getDetailLines().get("L33000");
ReportLine detailedLine3a = line3.getDetailLines().get("CLI:000000000000000000000000000000000008");
assertEquals(0, detailedLine3a.getLineItems().get(0).getNumberOfTasks());
assertEquals(1, detailedLine3a.getLineItems().get(1).getNumberOfTasks());
assertEquals(0, detailedLine3a.getLineItems().get(2).getNumberOfTasks());
assertEquals(1, detailedLine3a.getLineItems().get(3).getNumberOfTasks());
assertEquals(1, detailedLine3a.getLineItems().get(4).getNumberOfTasks());
ReportLine detailedLine3b = line3.getDetailLines().get("L99000");
ReportLine detailedLine3b = line3.getDetailLines().get("CLI:000000000000000000000000000000000009");
assertEquals(0, detailedLine3b.getLineItems().get(0).getNumberOfTasks());
assertEquals(0, detailedLine3b.getLineItems().get(1).getNumberOfTasks());
assertEquals(0, detailedLine3b.getLineItems().get(2).getNumberOfTasks());
@ -242,7 +239,8 @@ public class ProvideDetailedClassificationReportAccTest {
assertEquals(0, detailedLineNoAttachment3.getLineItems().get(3).getNumberOfTasks());
assertEquals(1, detailedLineNoAttachment3.getLineItems().get(4).getNumberOfTasks());
DetailedReportLine line4 = (DetailedReportLine) report.getReportLines().get("L40000");
DetailedReportLine line4 = (DetailedReportLine) report.getReportLines()
.get("CLI:000000000000000000000000000000000004");
assertEquals(2, line4.getLineItems().get(0).getNumberOfTasks());
assertEquals(2, line4.getLineItems().get(1).getNumberOfTasks());
assertEquals(2, line4.getLineItems().get(2).getNumberOfTasks());
@ -256,7 +254,8 @@ public class ProvideDetailedClassificationReportAccTest {
assertEquals(0, detailedLineNoAttachment4.getLineItems().get(3).getNumberOfTasks());
assertEquals(4, detailedLineNoAttachment4.getLineItems().get(4).getNumberOfTasks());
DetailedReportLine line5 = (DetailedReportLine) report.getReportLines().get("L50000");
DetailedReportLine line5 = (DetailedReportLine) report.getReportLines()
.get("CLI:000000000000000000000000000000000005");
assertEquals(3, line5.getLineItems().get(0).getNumberOfTasks());
assertEquals(3, line5.getLineItems().get(1).getNumberOfTasks());
assertEquals(0, line5.getLineItems().get(2).getNumberOfTasks());
@ -271,37 +270,36 @@ public class ProvideDetailedClassificationReportAccTest {
assertEquals(2, detailedLineNoAttachment5.getLineItems().get(4).getNumberOfTasks());
}
@WithAccessId(userName = "monitor_user_1")
@Test
public void testEachItemOfClassificationReportWithCategoryFilter()
throws WorkbasketNotFoundException, NotAuthorizedException, ClassificationNotFoundException {
public void testEachItemOfDetailedClassificationReportWithCategoryFilter() {
TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService();
List<Workbasket> workbaskets = getListOfWorkbaskets();
List<String> workbasketIds = generateWorkbasketIds(3, 1);
List<TaskState> states = Arrays.asList(TaskState.READY, TaskState.CLAIMED);
List<String> categories = Arrays.asList("AUTOMATIC", "MANUAL");
List<String> domains = Arrays.asList("DOMAIN_A", "DOMAIN_B", "DOMAIN_C");
List<ReportLineItemDefinition> reportLineItemDefinitions = getShortListOfReportLineItemDefinitions();
DetailedClassificationReport report = taskMonitorService.getDetailedClassificationReport(workbaskets, states,
DetailedClassificationReport report = taskMonitorService.getDetailedClassificationReport(workbasketIds, states,
categories, domains, reportLineItemDefinitions);
DetailedReportLine line1 = (DetailedReportLine) report.getReportLines().get("L30000");
DetailedReportLine line1 = (DetailedReportLine) report.getReportLines()
.get("CLI:000000000000000000000000000000000003");
assertEquals(2, line1.getLineItems().get(0).getNumberOfTasks());
assertEquals(1, line1.getLineItems().get(1).getNumberOfTasks());
assertEquals(0, line1.getLineItems().get(2).getNumberOfTasks());
assertEquals(1, line1.getLineItems().get(3).getNumberOfTasks());
assertEquals(3, line1.getLineItems().get(4).getNumberOfTasks());
ReportLine detailedLine1a = line1.getDetailLines().get("L33000");
ReportLine detailedLine1a = line1.getDetailLines().get("CLI:000000000000000000000000000000000008");
assertEquals(0, detailedLine1a.getLineItems().get(0).getNumberOfTasks());
assertEquals(1, detailedLine1a.getLineItems().get(1).getNumberOfTasks());
assertEquals(0, detailedLine1a.getLineItems().get(2).getNumberOfTasks());
assertEquals(1, detailedLine1a.getLineItems().get(3).getNumberOfTasks());
assertEquals(1, detailedLine1a.getLineItems().get(4).getNumberOfTasks());
ReportLine detailedLine1b = line1.getDetailLines().get("L99000");
ReportLine detailedLine1b = line1.getDetailLines().get("CLI:000000000000000000000000000000000009");
assertEquals(0, detailedLine1b.getLineItems().get(0).getNumberOfTasks());
assertEquals(0, detailedLine1b.getLineItems().get(1).getNumberOfTasks());
assertEquals(0, detailedLine1b.getLineItems().get(2).getNumberOfTasks());
@ -315,7 +313,8 @@ public class ProvideDetailedClassificationReportAccTest {
assertEquals(0, detailedLine1WithoutAttachment.getLineItems().get(3).getNumberOfTasks());
assertEquals(1, detailedLine1WithoutAttachment.getLineItems().get(4).getNumberOfTasks());
DetailedReportLine line2 = (DetailedReportLine) report.getReportLines().get("L40000");
DetailedReportLine line2 = (DetailedReportLine) report.getReportLines()
.get("CLI:000000000000000000000000000000000004");
assertEquals(2, line2.getLineItems().get(0).getNumberOfTasks());
assertEquals(2, line2.getLineItems().get(1).getNumberOfTasks());
assertEquals(2, line2.getLineItems().get(2).getNumberOfTasks());
@ -332,30 +331,29 @@ public class ProvideDetailedClassificationReportAccTest {
assertEquals(2, report.getReportLines().size());
}
@WithAccessId(userName = "monitor_user_1")
@Test
public void testEachItemOfClassificationReportWithDomainFilter()
throws WorkbasketNotFoundException, NotAuthorizedException, ClassificationNotFoundException {
public void testEachItemOfDetailedClassificationReportWithDomainFilter() {
TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService();
List<Workbasket> workbaskets = getListOfWorkbaskets();
List<String> workbasketIds = generateWorkbasketIds(3, 1);
List<TaskState> states = Arrays.asList(TaskState.READY, TaskState.CLAIMED);
List<String> categories = Arrays.asList("EXTERN", "AUTOMATIC", "MANUAL");
List<String> domains = Arrays.asList("DOMAIN_A");
List<ReportLineItemDefinition> reportLineItemDefinitions = getShortListOfReportLineItemDefinitions();
DetailedClassificationReport report = taskMonitorService.getDetailedClassificationReport(workbaskets, states,
DetailedClassificationReport report = taskMonitorService.getDetailedClassificationReport(workbasketIds, states,
categories, domains, reportLineItemDefinitions);
DetailedReportLine line1 = (DetailedReportLine) report.getReportLines().get("L10000");
DetailedReportLine line1 = (DetailedReportLine) report.getReportLines()
.get("CLI:000000000000000000000000000000000001");
assertEquals(5, line1.getLineItems().get(0).getNumberOfTasks());
assertEquals(2, line1.getLineItems().get(1).getNumberOfTasks());
assertEquals(1, line1.getLineItems().get(2).getNumberOfTasks());
assertEquals(0, line1.getLineItems().get(3).getNumberOfTasks());
assertEquals(0, line1.getLineItems().get(4).getNumberOfTasks());
ReportLine detailedLine1 = line1.getDetailLines().get("L11000");
ReportLine detailedLine1 = line1.getDetailLines().get("CLI:000000000000000000000000000000000006");
assertEquals(1, detailedLine1.getLineItems().get(0).getNumberOfTasks());
assertEquals(0, detailedLine1.getLineItems().get(1).getNumberOfTasks());
assertEquals(1, detailedLine1.getLineItems().get(2).getNumberOfTasks());
@ -369,14 +367,15 @@ public class ProvideDetailedClassificationReportAccTest {
assertEquals(0, detailedLineNoAttachment1.getLineItems().get(3).getNumberOfTasks());
assertEquals(0, detailedLineNoAttachment1.getLineItems().get(4).getNumberOfTasks());
DetailedReportLine line2 = (DetailedReportLine) report.getReportLines().get("L20000");
DetailedReportLine line2 = (DetailedReportLine) report.getReportLines()
.get("CLI:000000000000000000000000000000000002");
assertEquals(3, line2.getLineItems().get(0).getNumberOfTasks());
assertEquals(1, line2.getLineItems().get(1).getNumberOfTasks());
assertEquals(1, line2.getLineItems().get(2).getNumberOfTasks());
assertEquals(1, line2.getLineItems().get(3).getNumberOfTasks());
assertEquals(0, line2.getLineItems().get(4).getNumberOfTasks());
ReportLine detailedLine2 = line2.getDetailLines().get("L22000");
ReportLine detailedLine2 = line2.getDetailLines().get("CLI:000000000000000000000000000000000007");
assertEquals(1, detailedLine2.getLineItems().get(0).getNumberOfTasks());
assertEquals(0, detailedLine2.getLineItems().get(1).getNumberOfTasks());
assertEquals(1, detailedLine2.getLineItems().get(2).getNumberOfTasks());
@ -390,14 +389,15 @@ public class ProvideDetailedClassificationReportAccTest {
assertEquals(0, detailedLineNoAttachment2.getLineItems().get(3).getNumberOfTasks());
assertEquals(0, detailedLineNoAttachment2.getLineItems().get(4).getNumberOfTasks());
DetailedReportLine line3 = (DetailedReportLine) report.getReportLines().get("L30000");
DetailedReportLine line3 = (DetailedReportLine) report.getReportLines()
.get("CLI:000000000000000000000000000000000003");
assertEquals(1, line3.getLineItems().get(0).getNumberOfTasks());
assertEquals(0, line3.getLineItems().get(1).getNumberOfTasks());
assertEquals(0, line3.getLineItems().get(2).getNumberOfTasks());
assertEquals(1, line3.getLineItems().get(3).getNumberOfTasks());
assertEquals(1, line3.getLineItems().get(4).getNumberOfTasks());
ReportLine detailedLine3 = line3.getDetailLines().get("L33000");
ReportLine detailedLine3 = line3.getDetailLines().get("CLI:000000000000000000000000000000000008");
assertEquals(0, detailedLine3.getLineItems().get(0).getNumberOfTasks());
assertEquals(0, detailedLine3.getLineItems().get(1).getNumberOfTasks());
assertEquals(0, detailedLine3.getLineItems().get(2).getNumberOfTasks());
@ -411,7 +411,8 @@ public class ProvideDetailedClassificationReportAccTest {
assertEquals(0, detailedLineNoAttachment3.getLineItems().get(3).getNumberOfTasks());
assertEquals(0, detailedLineNoAttachment3.getLineItems().get(4).getNumberOfTasks());
DetailedReportLine line4 = (DetailedReportLine) report.getReportLines().get("L40000");
DetailedReportLine line4 = (DetailedReportLine) report.getReportLines()
.get("CLI:000000000000000000000000000000000004");
assertEquals(2, line4.getLineItems().get(0).getNumberOfTasks());
assertEquals(0, line4.getLineItems().get(1).getNumberOfTasks());
assertEquals(0, line4.getLineItems().get(2).getNumberOfTasks());
@ -425,7 +426,8 @@ public class ProvideDetailedClassificationReportAccTest {
assertEquals(0, detailedLineNoAttachment4.getLineItems().get(3).getNumberOfTasks());
assertEquals(3, detailedLineNoAttachment4.getLineItems().get(4).getNumberOfTasks());
DetailedReportLine line5 = (DetailedReportLine) report.getReportLines().get("L50000");
DetailedReportLine line5 = (DetailedReportLine) report.getReportLines()
.get("CLI:000000000000000000000000000000000005");
assertEquals(0, line5.getLineItems().get(0).getNumberOfTasks());
assertEquals(1, line5.getLineItems().get(1).getNumberOfTasks());
assertEquals(0, line5.getLineItems().get(2).getNumberOfTasks());
@ -440,19 +442,12 @@ public class ProvideDetailedClassificationReportAccTest {
assertEquals(0, detailedLineNoAttachment5.getLineItems().get(4).getNumberOfTasks());
}
private List<Workbasket> getListOfWorkbaskets() throws WorkbasketNotFoundException, NotAuthorizedException {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
WorkbasketImpl workbasket1 = (WorkbasketImpl) workbasketService
.getWorkbasket("WBI:000000000000000000000000000000000001");
WorkbasketImpl workbasket2 = (WorkbasketImpl) workbasketService
.getWorkbasket("WBI:000000000000000000000000000000000002");
WorkbasketImpl workbasket3 = (WorkbasketImpl) workbasketService
.getWorkbasket("WBI:000000000000000000000000000000000003");
WorkbasketImpl workbasket4 = (WorkbasketImpl) workbasketService
.getWorkbasket("WBI:000000000000000000000000000000000004");
return Arrays.asList(workbasket1, workbasket2, workbasket3, workbasket4);
private List<String> generateWorkbasketIds(int amount, int startAt) {
List<String> workbasketIds = new ArrayList<>();
for (int i = 0; i < amount; i++) {
workbasketIds.add(String.format("WBI:%036d", startAt + i));
}
return workbasketIds;
}
private List<ReportLineItemDefinition> getListOfReportLineItemDefinitions() {

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

@ -15,13 +15,10 @@ import org.h2.store.fs.FileUtils;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import pro.taskana.TaskMonitorService;
import pro.taskana.TaskanaEngine;
import pro.taskana.TaskanaEngine.ConnectionManagementMode;
import pro.taskana.Workbasket;
import pro.taskana.WorkbasketService;
import pro.taskana.configuration.TaskanaEngineConfiguration;
import pro.taskana.database.TestDataGenerator;
import pro.taskana.exceptions.ClassificationNotFoundException;
@ -32,16 +29,12 @@ import pro.taskana.impl.ReportLineItem;
import pro.taskana.impl.ReportLineItemDefinition;
import pro.taskana.impl.TaskState;
import pro.taskana.impl.TaskanaEngineImpl;
import pro.taskana.impl.WorkbasketImpl;
import pro.taskana.impl.configuration.DBCleaner;
import pro.taskana.impl.configuration.TaskanaEngineConfigurationTest;
import pro.taskana.security.JAASRunner;
import pro.taskana.security.WithAccessId;
/**
* Acceptance test for all "workbasket level report" scenarios.
*/
@RunWith(JAASRunner.class)
public class ProvideWorkbasketLevelReportAccTest {
protected static TaskanaEngineConfiguration taskanaEngineConfiguration;
@ -65,42 +58,40 @@ public class ProvideWorkbasketLevelReportAccTest {
testDataGenerator.generateMonitoringTestData(dataSource);
}
@WithAccessId(userName = "monitor_user_1")
@Test
public void testGetTotalNumbersOfTasksOfWorkbasketLevelReport()
throws WorkbasketNotFoundException, NotAuthorizedException {
public void testGetTotalNumbersOfTasksOfWorkbasketLevelReport() {
TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService();
List<Workbasket> workbaskets = getListOfWorkbaskets();
List<String> workbasketIds = generateWorkbasketIds(3, 1);
List<TaskState> states = Arrays.asList(TaskState.READY, TaskState.CLAIMED);
List<String> categories = Arrays.asList("EXTERN", "AUTOMATIC", "MANUAL");
List<String> domains = Arrays.asList("DOMAIN_A", "DOMAIN_B", "DOMAIN_C");
Report report = taskMonitorService.getWorkbasketLevelReport(workbaskets, states, categories, domains);
Report report = taskMonitorService.getWorkbasketLevelReport(workbasketIds, states, categories, domains);
assertNotNull(report);
assertEquals(20, report.getReportLines().get(workbaskets.get(0).getKey()).getTotalNumberOfTasks());
assertEquals(20, report.getReportLines().get(workbaskets.get(1).getKey()).getTotalNumberOfTasks());
assertEquals(10, report.getReportLines().get(workbaskets.get(2).getKey()).getTotalNumberOfTasks());
assertEquals(20,
report.getReportLines().get("WBI:000000000000000000000000000000000001").getTotalNumberOfTasks());
assertEquals(20,
report.getReportLines().get("WBI:000000000000000000000000000000000002").getTotalNumberOfTasks());
assertEquals(10,
report.getReportLines().get("WBI:000000000000000000000000000000000003").getTotalNumberOfTasks());
assertEquals(50, report.getSumLine().getTotalNumberOfTasks());
}
@WithAccessId(userName = "monitor_user_1")
@Test
public void testGetWorkbasketLevelReportWithReportLineItemDefinitions()
throws WorkbasketNotFoundException, NotAuthorizedException {
public void testGetWorkbasketLevelReportWithReportLineItemDefinitions() {
TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService();
List<Workbasket> workbaskets = getListOfWorkbaskets();
List<String> workbasketIds = generateWorkbasketIds(3, 1);
List<TaskState> states = Arrays.asList(TaskState.READY, TaskState.CLAIMED);
List<String> categories = Arrays.asList("EXTERN", "AUTOMATIC", "MANUAL");
List<String> domains = Arrays.asList("DOMAIN_A", "DOMAIN_B", "DOMAIN_C");
List<ReportLineItemDefinition> reportLineItemDefinitions = getListOfReportLineItemDefinitions();
Report report = taskMonitorService.getWorkbasketLevelReport(workbaskets, states, categories, domains,
Report report = taskMonitorService.getWorkbasketLevelReport(workbasketIds, states, categories, domains,
reportLineItemDefinitions);
int sumLineCount = report.getSumLine().getLineItems().get(0).getNumberOfTasks()
@ -115,9 +106,12 @@ public class ProvideWorkbasketLevelReportAccTest {
assertNotNull(report);
assertEquals(20, report.getReportLines().get(workbaskets.get(0).getKey()).getTotalNumberOfTasks());
assertEquals(20, report.getReportLines().get(workbaskets.get(1).getKey()).getTotalNumberOfTasks());
assertEquals(10, report.getReportLines().get(workbaskets.get(2).getKey()).getTotalNumberOfTasks());
assertEquals(20,
report.getReportLines().get("WBI:000000000000000000000000000000000001").getTotalNumberOfTasks());
assertEquals(20,
report.getReportLines().get("WBI:000000000000000000000000000000000002").getTotalNumberOfTasks());
assertEquals(10,
report.getReportLines().get("WBI:000000000000000000000000000000000003").getTotalNumberOfTasks());
assertEquals(10, report.getSumLine().getLineItems().get(0).getNumberOfTasks());
assertEquals(9, report.getSumLine().getLineItems().get(1).getNumberOfTasks());
@ -130,60 +124,58 @@ public class ProvideWorkbasketLevelReportAccTest {
assertEquals(5, report.getSumLine().getLineItems().get(8).getNumberOfTasks());
assertEquals(50, report.getSumLine().getTotalNumberOfTasks());
assertEquals(50, sumLineCount);
}
@WithAccessId(userName = "monitor_user_1")
@Test
public void testGetWorkbasketLevelReportIfWorkbasketContainsNoTask()
throws WorkbasketNotFoundException, NotAuthorizedException {
public void testGetWorkbasketLevelReportIfWorkbasketContainsNoTask() {
TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService();
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<Workbasket> workbaskets = new ArrayList<>();
WorkbasketImpl workbasket = (WorkbasketImpl) workbasketService
.getWorkbasket("WBI:000000000000000000000000000000000004");
workbaskets.add(workbasket);
List<String> workbasketIds = generateWorkbasketIds(1, 4);
List<TaskState> states = Arrays.asList(TaskState.READY, TaskState.CLAIMED);
List<String> categories = Arrays.asList("EXTERN", "AUTOMATIC", "MANUAL");
List<String> domains = Arrays.asList("DOMAIN_A", "DOMAIN_B", "DOMAIN_C");
Report report = taskMonitorService.getWorkbasketLevelReport(workbaskets, states, categories, domains);
Report report = taskMonitorService.getWorkbasketLevelReport(workbasketIds, states, categories, domains);
assertNotNull(report);
assertEquals(0, report.getSumLine().getTotalNumberOfTasks());
}
@WithAccessId(userName = "monitor_user_1")
@Test
public void testEachItemOfWorkbasketLevelReportWithCategoryFilter()
throws WorkbasketNotFoundException, NotAuthorizedException, ClassificationNotFoundException {
TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService();
List<Workbasket> workbaskets = getListOfWorkbaskets();
List<String> workbasketIds = generateWorkbasketIds(3, 1);
List<TaskState> states = Arrays.asList(TaskState.READY, TaskState.CLAIMED);
List<String> categories = Arrays.asList("AUTOMATIC", "MANUAL");
List<String> domains = Arrays.asList("DOMAIN_A", "DOMAIN_B", "DOMAIN_C");
List<ReportLineItemDefinition> reportLineItemDefinitions = getShortListOfReportLineItemDefinitions();
Report report = taskMonitorService.getWorkbasketLevelReport(workbaskets, states, categories, domains,
Report report = taskMonitorService.getWorkbasketLevelReport(workbasketIds, states, categories, domains,
reportLineItemDefinitions);
List<ReportLineItem> line1 = report.getReportLines().get(workbaskets.get(0).getKey()).getLineItems();
List<ReportLineItem> line1 = report.getReportLines()
.get("WBI:000000000000000000000000000000000001")
.getLineItems();
assertEquals(3, line1.get(0).getNumberOfTasks());
assertEquals(1, line1.get(1).getNumberOfTasks());
assertEquals(1, line1.get(2).getNumberOfTasks());
assertEquals(1, line1.get(3).getNumberOfTasks());
assertEquals(2, line1.get(4).getNumberOfTasks());
List<ReportLineItem> line2 = report.getReportLines().get(workbaskets.get(1).getKey()).getLineItems();
List<ReportLineItem> line2 = report.getReportLines()
.get("WBI:000000000000000000000000000000000002")
.getLineItems();
assertEquals(1, line2.get(0).getNumberOfTasks());
assertEquals(1, line2.get(1).getNumberOfTasks());
assertEquals(1, line2.get(2).getNumberOfTasks());
assertEquals(0, line2.get(3).getNumberOfTasks());
assertEquals(1, line2.get(4).getNumberOfTasks());
List<ReportLineItem> line3 = report.getReportLines().get(workbaskets.get(2).getKey()).getLineItems();
List<ReportLineItem> line3 = report.getReportLines()
.get("WBI:000000000000000000000000000000000003")
.getLineItems();
assertEquals(0, line3.get(0).getNumberOfTasks());
assertEquals(1, line3.get(1).getNumberOfTasks());
assertEquals(0, line3.get(2).getNumberOfTasks());
@ -193,37 +185,41 @@ public class ProvideWorkbasketLevelReportAccTest {
assertEquals(3, report.getReportLines().size());
}
@WithAccessId(userName = "monitor_user_1")
@Test
public void testEachItemOfWorkbasketLevelReportWithDomainFilter()
throws WorkbasketNotFoundException, NotAuthorizedException, ClassificationNotFoundException {
public void testEachItemOfWorkbasketLevelReportWithDomainFilter() {
TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService();
List<Workbasket> workbaskets = getListOfWorkbaskets();
List<String> workbasketIds = generateWorkbasketIds(3, 1);
List<TaskState> states = Arrays.asList(TaskState.READY, TaskState.CLAIMED);
List<String> categories = Arrays.asList("EXTERN", "AUTOMATIC", "MANUAL");
List<String> domains = Arrays.asList("DOMAIN_A");
List<ReportLineItemDefinition> reportLineItemDefinitions = getShortListOfReportLineItemDefinitions();
Report report = taskMonitorService.getWorkbasketLevelReport(workbaskets, states, categories, domains,
Report report = taskMonitorService.getWorkbasketLevelReport(workbasketIds, states, categories, domains,
reportLineItemDefinitions);
List<ReportLineItem> line1 = report.getReportLines().get(workbaskets.get(0).getKey()).getLineItems();
List<ReportLineItem> line1 = report.getReportLines()
.get("WBI:000000000000000000000000000000000001")
.getLineItems();
assertEquals(8, line1.get(0).getNumberOfTasks());
assertEquals(1, line1.get(1).getNumberOfTasks());
assertEquals(0, line1.get(2).getNumberOfTasks());
assertEquals(1, line1.get(3).getNumberOfTasks());
assertEquals(2, line1.get(4).getNumberOfTasks());
List<ReportLineItem> line2 = report.getReportLines().get(workbaskets.get(1).getKey()).getLineItems();
List<ReportLineItem> line2 = report.getReportLines()
.get("WBI:000000000000000000000000000000000002")
.getLineItems();
assertEquals(2, line2.get(0).getNumberOfTasks());
assertEquals(2, line2.get(1).getNumberOfTasks());
assertEquals(2, line2.get(2).getNumberOfTasks());
assertEquals(4, line2.get(3).getNumberOfTasks());
assertEquals(0, line2.get(4).getNumberOfTasks());
List<ReportLineItem> line3 = report.getReportLines().get(workbaskets.get(2).getKey()).getLineItems();
List<ReportLineItem> line3 = report.getReportLines()
.get("WBI:000000000000000000000000000000000003")
.getLineItems();
assertEquals(1, line3.get(0).getNumberOfTasks());
assertEquals(1, line3.get(1).getNumberOfTasks());
assertEquals(0, line3.get(2).getNumberOfTasks());
@ -231,19 +227,12 @@ public class ProvideWorkbasketLevelReportAccTest {
assertEquals(2, line3.get(4).getNumberOfTasks());
}
private List<Workbasket> getListOfWorkbaskets() throws WorkbasketNotFoundException, NotAuthorizedException {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
WorkbasketImpl workbasket1 = (WorkbasketImpl) workbasketService
.getWorkbasket("WBI:000000000000000000000000000000000001");
WorkbasketImpl workbasket2 = (WorkbasketImpl) workbasketService
.getWorkbasket("WBI:000000000000000000000000000000000002");
WorkbasketImpl workbasket3 = (WorkbasketImpl) workbasketService
.getWorkbasket("WBI:000000000000000000000000000000000003");
WorkbasketImpl workbasket4 = (WorkbasketImpl) workbasketService
.getWorkbasket("WBI:000000000000000000000000000000000004");
return Arrays.asList(workbasket1, workbasket2, workbasket3, workbasket4);
private List<String> generateWorkbasketIds(int amount, int startAt) {
List<String> workbasketIds = new ArrayList<>();
for (int i = 0; i < amount; i++) {
workbasketIds.add(String.format("WBI:%036d", startAt + i));
}
return workbasketIds;
}
private List<ReportLineItemDefinition> getListOfReportLineItemDefinitions() {

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

@ -21,10 +21,6 @@ import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.junit.MockitoJUnitRunner;
import pro.taskana.Workbasket;
import pro.taskana.WorkbasketService;
import pro.taskana.configuration.TaskanaEngineConfiguration;
import pro.taskana.mappings.ObjectReferenceMapper;
import pro.taskana.mappings.TaskMonitorMapper;
/**
@ -37,68 +33,50 @@ public class TaskMonitorServiceImplTest {
private TaskMonitorServiceImpl cut;
@Mock
private TaskanaEngineConfiguration taskanaEngineConfigurationMock;
@Mock
private TaskanaEngineImpl taskanaEngineMock;
@Mock
private TaskanaEngineImpl taskanaEngineImpl;
private TaskanaEngineImpl taskanaEngineImplMock;
@Mock
private TaskMonitorMapper taskMonitorMapperMock;
@Mock
private ObjectReferenceMapper objectReferenceMapperMock;
@Mock
private WorkbasketService workbasketServiceMock;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
Mockito.doNothing().when(taskanaEngineImpl).openConnection();
Mockito.doNothing().when(taskanaEngineImpl).returnConnection();
Mockito.doNothing().when(taskanaEngineImplMock).openConnection();
Mockito.doNothing().when(taskanaEngineImplMock).returnConnection();
}
@Test
public void testGetTotalNumbersOfWorkbasketLevelReport() {
WorkbasketImpl workbasket = new WorkbasketImpl();
workbasket.setName("workbasket");
workbasket.setKey("wb1");
List<Workbasket> workbaskets = Arrays.asList(workbasket);
List<String> workbasketIds = Arrays.asList("WBI:000000000000000000000000000000000001");
List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
List<String> categories = Arrays.asList("EXTERN");
List<String> domains = Arrays.asList("DOMAIN_A");
List<MonitorQueryItem> expectedResult = new ArrayList<>();
MonitorQueryItem monitorQueryItem = new MonitorQueryItem();
monitorQueryItem.setKey("wb1");
monitorQueryItem.setKey("WBI:000000000000000000000000000000000001");
monitorQueryItem.setNumberOfTasks(1);
expectedResult.add(monitorQueryItem);
doReturn(expectedResult).when(taskMonitorMapperMock).getTaskCountOfWorkbasketsByWorkbasketsAndStates(
workbaskets, states, categories, domains);
workbasketIds, states, categories, domains);
Report actualResult = cut.getWorkbasketLevelReport(workbaskets, states, categories, domains);
Report actualResult = cut.getWorkbasketLevelReport(workbasketIds, states, categories, domains);
verify(taskanaEngineImpl, times(1)).openConnection();
verify(taskanaEngineImplMock, times(1)).openConnection();
verify(taskMonitorMapperMock, times(1)).getTaskCountOfWorkbasketsByWorkbasketsAndStates(any(), any(), any(),
any());
verify(taskanaEngineImpl, times(1)).returnConnection();
verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl,
taskMonitorMapperMock, objectReferenceMapperMock, workbasketServiceMock);
verify(taskanaEngineImplMock, times(1)).returnConnection();
verifyNoMoreInteractions(taskanaEngineImplMock, taskMonitorMapperMock);
assertNotNull(actualResult);
assertEquals(actualResult.getReportLines().get(workbasket.getKey()).getTotalNumberOfTasks(), 1);
assertEquals(
actualResult.getReportLines().get("WBI:000000000000000000000000000000000001").getTotalNumberOfTasks(), 1);
assertEquals(actualResult.getSumLine().getTotalNumberOfTasks(), 1);
}
@Test
public void testGetWorkbasketLevelReportWithReportLineItemDefinitions() {
WorkbasketImpl workbasket = new WorkbasketImpl();
workbasket.setName("workbasket");
workbasket.setKey("wb1");
List<Workbasket> workbaskets = Arrays.asList(workbasket);
List<String> workbasketIds = Arrays.asList("WBI:000000000000000000000000000000000001");
List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
List<String> categories = Arrays.asList("EXTERN");
List<String> domains = Arrays.asList("DOMAIN_A");
@ -107,36 +85,38 @@ public class TaskMonitorServiceImplTest {
List<MonitorQueryItem> expectedResult = new ArrayList<>();
MonitorQueryItem monitorQueryItem = new MonitorQueryItem();
monitorQueryItem.setKey("wb1");
monitorQueryItem.setKey("WBI:000000000000000000000000000000000001");
monitorQueryItem.setAgeInDays(0);
monitorQueryItem.setNumberOfTasks(1);
expectedResult.add(monitorQueryItem);
doReturn(expectedResult).when(taskMonitorMapperMock).getTaskCountOfWorkbasketsByWorkbasketsAndStates(
workbaskets, states, categories, domains);
workbasketIds, states, categories, domains);
Report actualResult = cut.getWorkbasketLevelReport(workbaskets, states, categories, domains,
Report actualResult = cut.getWorkbasketLevelReport(workbasketIds, states, categories, domains,
reportLineItemDefinitions);
verify(taskanaEngineImpl, times(1)).openConnection();
verify(taskanaEngineImplMock, times(1)).openConnection();
verify(taskMonitorMapperMock, times(1)).getTaskCountOfWorkbasketsByWorkbasketsAndStates(any(), any(), any(),
any());
verify(taskanaEngineImpl, times(1)).returnConnection();
verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl,
taskMonitorMapperMock, objectReferenceMapperMock, workbasketServiceMock);
verify(taskanaEngineImplMock, times(1)).returnConnection();
verifyNoMoreInteractions(taskanaEngineImplMock, taskMonitorMapperMock);
assertNotNull(actualResult);
assertEquals(actualResult.getReportLines().get(workbasket.getKey()).getTotalNumberOfTasks(), 1);
assertEquals(actualResult.getReportLines().get(workbasket.getKey()).getLineItems().get(0).getNumberOfTasks(),
assertEquals(
actualResult.getReportLines().get("WBI:000000000000000000000000000000000001").getTotalNumberOfTasks(), 1);
assertEquals(
actualResult.getReportLines()
.get("WBI:000000000000000000000000000000000001")
.getLineItems()
.get(0)
.getNumberOfTasks(),
1);
assertEquals(actualResult.getSumLine().getTotalNumberOfTasks(), 1);
}
@Test
public void testGetTotalNumbersOfCatgoryReport() {
WorkbasketImpl workbasket = new WorkbasketImpl();
workbasket.setName("workbasket");
workbasket.setKey("wb1");
List<Workbasket> workbaskets = Arrays.asList(workbasket);
List<String> workbasketIds = Arrays.asList("WBI:000000000000000000000000000000000001");
List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
List<String> categories = Arrays.asList("EXTERN");
List<String> domains = Arrays.asList("DOMAIN_A");
@ -147,16 +127,15 @@ public class TaskMonitorServiceImplTest {
monitorQueryItem.setNumberOfTasks(1);
expectedResult.add(monitorQueryItem);
doReturn(expectedResult).when(taskMonitorMapperMock).getTaskCountOfCategoriesByWorkbasketsAndStates(
workbaskets, states, categories, domains);
workbasketIds, states, categories, domains);
Report actualResult = cut.getCategoryReport(workbaskets, states, categories, domains);
Report actualResult = cut.getCategoryReport(workbasketIds, states, categories, domains);
verify(taskanaEngineImpl, times(1)).openConnection();
verify(taskanaEngineImplMock, times(1)).openConnection();
verify(taskMonitorMapperMock, times(1)).getTaskCountOfCategoriesByWorkbasketsAndStates(any(), any(), any(),
any());
verify(taskanaEngineImpl, times(1)).returnConnection();
verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl,
taskMonitorMapperMock, objectReferenceMapperMock, workbasketServiceMock);
verify(taskanaEngineImplMock, times(1)).returnConnection();
verifyNoMoreInteractions(taskanaEngineImplMock, taskMonitorMapperMock);
assertNotNull(actualResult);
assertEquals(actualResult.getReportLines().get("EXTERN").getTotalNumberOfTasks(), 1);
@ -165,10 +144,7 @@ public class TaskMonitorServiceImplTest {
@Test
public void testGetCategoryReportWithReportLineItemDefinitions() {
WorkbasketImpl workbasket = new WorkbasketImpl();
workbasket.setName("workbasket");
workbasket.setKey("wb1");
List<Workbasket> workbaskets = Arrays.asList(workbasket);
List<String> workbasketIds = Arrays.asList("WBI:000000000000000000000000000000000001");
List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
List<String> categories = Arrays.asList("EXTERN");
List<String> domains = Arrays.asList("DOMAIN_A");
@ -182,17 +158,16 @@ public class TaskMonitorServiceImplTest {
monitorQueryItem.setNumberOfTasks(1);
expectedResult.add(monitorQueryItem);
doReturn(expectedResult).when(taskMonitorMapperMock).getTaskCountOfCategoriesByWorkbasketsAndStates(
workbaskets, states, categories, domains);
workbasketIds, states, categories, domains);
Report actualResult = cut.getCategoryReport(workbaskets, states, categories, domains,
Report actualResult = cut.getCategoryReport(workbasketIds, states, categories, domains,
reportLineItemDefinitions);
verify(taskanaEngineImpl, times(1)).openConnection();
verify(taskanaEngineImplMock, times(1)).openConnection();
verify(taskMonitorMapperMock, times(1)).getTaskCountOfCategoriesByWorkbasketsAndStates(any(), any(), any(),
any());
verify(taskanaEngineImpl, times(1)).returnConnection();
verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl,
taskMonitorMapperMock, objectReferenceMapperMock, workbasketServiceMock);
verify(taskanaEngineImplMock, times(1)).returnConnection();
verifyNoMoreInteractions(taskanaEngineImplMock, taskMonitorMapperMock);
assertNotNull(actualResult);
assertEquals(actualResult.getReportLines().get("EXTERN").getTotalNumberOfTasks(), 1);
@ -202,42 +177,36 @@ public class TaskMonitorServiceImplTest {
@Test
public void testGetTotalNumbersOfClassificationReport() {
WorkbasketImpl workbasket = new WorkbasketImpl();
workbasket.setName("workbasket");
workbasket.setKey("wb1");
List<Workbasket> workbaskets = Arrays.asList(workbasket);
List<String> workbasketIds = Arrays.asList("WBI:000000000000000000000000000000000001");
List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
List<String> categories = Arrays.asList("EXTERN");
List<String> domains = Arrays.asList("DOMAIN_A");
List<MonitorQueryItem> expectedResult = new ArrayList<>();
MonitorQueryItem monitorQueryItem = new MonitorQueryItem();
monitorQueryItem.setKey("L10000");
monitorQueryItem.setKey("CLI:000000000000000000000000000000000001");
monitorQueryItem.setNumberOfTasks(1);
expectedResult.add(monitorQueryItem);
doReturn(expectedResult).when(taskMonitorMapperMock).getTaskCountOfClassificationsByWorkbasketsAndStates(
workbaskets, states, categories, domains);
workbasketIds, states, categories, domains);
ClassificationReport actualResult = cut.getClassificationReport(workbaskets, states, categories, domains);
ClassificationReport actualResult = cut.getClassificationReport(workbasketIds, states, categories, domains);
verify(taskanaEngineImpl, times(1)).openConnection();
verify(taskanaEngineImplMock, times(1)).openConnection();
verify(taskMonitorMapperMock, times(1)).getTaskCountOfClassificationsByWorkbasketsAndStates(any(), any(), any(),
any());
verify(taskanaEngineImpl, times(1)).returnConnection();
verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl,
taskMonitorMapperMock, objectReferenceMapperMock, workbasketServiceMock);
verify(taskanaEngineImplMock, times(1)).returnConnection();
verifyNoMoreInteractions(taskanaEngineImplMock, taskMonitorMapperMock);
assertNotNull(actualResult);
assertEquals(actualResult.getReportLines().get("L10000").getTotalNumberOfTasks(), 1);
assertEquals(
actualResult.getReportLines().get("CLI:000000000000000000000000000000000001").getTotalNumberOfTasks(), 1);
assertEquals(actualResult.getSumLine().getTotalNumberOfTasks(), 1);
}
@Test
public void testGetClassificationReportWithReportLineItemDefinitions() {
WorkbasketImpl workbasket = new WorkbasketImpl();
workbasket.setName("workbasket");
workbasket.setKey("wb1");
List<Workbasket> workbaskets = Arrays.asList(workbasket);
List<String> workbasketIds = Arrays.asList("WBI:000000000000000000000000000000000001");
List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
List<String> categories = Arrays.asList("EXTERN");
List<String> domains = Arrays.asList("DOMAIN_A");
@ -246,71 +215,69 @@ public class TaskMonitorServiceImplTest {
List<MonitorQueryItem> expectedResult = new ArrayList<>();
MonitorQueryItem monitorQueryItem = new MonitorQueryItem();
monitorQueryItem.setKey("L10000");
monitorQueryItem.setKey("CLI:000000000000000000000000000000000001");
monitorQueryItem.setAgeInDays(0);
monitorQueryItem.setNumberOfTasks(1);
expectedResult.add(monitorQueryItem);
doReturn(expectedResult).when(taskMonitorMapperMock).getTaskCountOfClassificationsByWorkbasketsAndStates(
workbaskets, states, categories, domains);
workbasketIds, states, categories, domains);
ClassificationReport actualResult = cut.getClassificationReport(workbaskets, states, categories, domains,
ClassificationReport actualResult = cut.getClassificationReport(workbasketIds, states, categories, domains,
reportLineItemDefinitions);
verify(taskanaEngineImpl, times(1)).openConnection();
verify(taskanaEngineImplMock, times(1)).openConnection();
verify(taskMonitorMapperMock, times(1)).getTaskCountOfClassificationsByWorkbasketsAndStates(any(), any(), any(),
any());
verify(taskanaEngineImpl, times(1)).returnConnection();
verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl,
taskMonitorMapperMock, objectReferenceMapperMock, workbasketServiceMock);
verify(taskanaEngineImplMock, times(1)).returnConnection();
verifyNoMoreInteractions(taskanaEngineImplMock, taskMonitorMapperMock);
assertNotNull(actualResult);
assertEquals(actualResult.getReportLines().get("L10000").getTotalNumberOfTasks(), 1);
assertEquals(actualResult.getReportLines().get("L10000").getLineItems().get(0).getNumberOfTasks(), 1);
assertEquals(
actualResult.getReportLines().get("CLI:000000000000000000000000000000000001").getTotalNumberOfTasks(), 1);
assertEquals(actualResult.getReportLines()
.get("CLI:000000000000000000000000000000000001")
.getLineItems()
.get(0)
.getNumberOfTasks(), 1);
assertEquals(actualResult.getSumLine().getTotalNumberOfTasks(), 1);
}
@Test
public void testGetTotalNumbersOfDetailedClassificationReport() {
WorkbasketImpl workbasket = new WorkbasketImpl();
workbasket.setName("workbasket");
workbasket.setKey("wb1");
List<Workbasket> workbaskets = Arrays.asList(workbasket);
List<String> workbasketIds = Arrays.asList("WBI:000000000000000000000000000000000001");
List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
List<String> categories = Arrays.asList("EXTERN");
List<String> domains = Arrays.asList("DOMAIN_A");
List<DetailedMonitorQueryItem> expectedResult = new ArrayList<>();
DetailedMonitorQueryItem detailedMonitorQueryItem = new DetailedMonitorQueryItem();
detailedMonitorQueryItem.setKey("L10000");
detailedMonitorQueryItem.setAttachmentKey("L11000");
detailedMonitorQueryItem.setKey("CLI:000000000000000000000000000000000001");
detailedMonitorQueryItem.setAttachmentKey("CLI:000000000000000000000000000000000006");
detailedMonitorQueryItem.setNumberOfTasks(1);
expectedResult.add(detailedMonitorQueryItem);
doReturn(expectedResult).when(taskMonitorMapperMock)
.getTaskCountOfDetailedClassificationsByWorkbasketsAndStates(workbaskets, states, categories, domains);
.getTaskCountOfDetailedClassificationsByWorkbasketsAndStates(workbasketIds, states, categories, domains);
DetailedClassificationReport actualResult = cut.getDetailedClassificationReport(workbaskets, states,
DetailedClassificationReport actualResult = cut.getDetailedClassificationReport(workbasketIds, states,
categories, domains);
verify(taskanaEngineImpl, times(1)).openConnection();
verify(taskanaEngineImplMock, times(1)).openConnection();
verify(taskMonitorMapperMock, times(1)).getTaskCountOfDetailedClassificationsByWorkbasketsAndStates(any(),
any(), any(), any());
verify(taskanaEngineImpl, times(1)).returnConnection();
verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl,
taskMonitorMapperMock, objectReferenceMapperMock, workbasketServiceMock);
verify(taskanaEngineImplMock, times(1)).returnConnection();
verifyNoMoreInteractions(taskanaEngineImplMock, taskMonitorMapperMock);
DetailedReportLine line = (DetailedReportLine) actualResult.getReportLines().get("L10000");
DetailedReportLine line = (DetailedReportLine) actualResult.getReportLines()
.get("CLI:000000000000000000000000000000000001");
assertNotNull(actualResult);
assertEquals(line.getTotalNumberOfTasks(), 1);
assertEquals(line.getDetailLines().get("L11000").getTotalNumberOfTasks(), 1);
assertEquals(line.getDetailLines().get("CLI:000000000000000000000000000000000006").getTotalNumberOfTasks(), 1);
assertEquals(actualResult.getSumLine().getTotalNumberOfTasks(), 1);
}
@Test
public void testGetDetailedClassificationReportWithReportLineItemDefinitions() {
WorkbasketImpl workbasket = new WorkbasketImpl();
workbasket.setName("workbasket");
workbasket.setKey("wb1");
List<Workbasket> workbaskets = Arrays.asList(workbasket);
List<String> workbasketIds = Arrays.asList("WBI:000000000000000000000000000000000001");
List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
List<String> categories = Arrays.asList("EXTERN");
List<String> domains = Arrays.asList("DOMAIN_A");
@ -319,40 +286,42 @@ public class TaskMonitorServiceImplTest {
List<DetailedMonitorQueryItem> expectedResult = new ArrayList<>();
DetailedMonitorQueryItem detailedMonitorQueryItem = new DetailedMonitorQueryItem();
detailedMonitorQueryItem.setKey("L10000");
detailedMonitorQueryItem.setAttachmentKey("L11000");
detailedMonitorQueryItem.setKey("CLI:000000000000000000000000000000000001");
detailedMonitorQueryItem.setAttachmentKey("CLI:000000000000000000000000000000000006");
detailedMonitorQueryItem.setAgeInDays(0);
detailedMonitorQueryItem.setNumberOfTasks(1);
expectedResult.add(detailedMonitorQueryItem);
doReturn(expectedResult).when(taskMonitorMapperMock)
.getTaskCountOfDetailedClassificationsByWorkbasketsAndStates(workbaskets, states, categories, domains);
.getTaskCountOfDetailedClassificationsByWorkbasketsAndStates(workbasketIds, states, categories, domains);
DetailedClassificationReport actualResult = cut.getDetailedClassificationReport(workbaskets, states, categories,
DetailedClassificationReport actualResult = cut.getDetailedClassificationReport(workbasketIds, states,
categories,
domains, reportLineItemDefinitions);
verify(taskanaEngineImpl, times(1)).openConnection();
verify(taskanaEngineImplMock, times(1)).openConnection();
verify(taskMonitorMapperMock, times(1)).getTaskCountOfDetailedClassificationsByWorkbasketsAndStates(any(),
any(), any(), any());
verify(taskanaEngineImpl, times(1)).returnConnection();
verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl,
taskMonitorMapperMock, objectReferenceMapperMock, workbasketServiceMock);
verify(taskanaEngineImplMock, times(1)).returnConnection();
verifyNoMoreInteractions(taskanaEngineImplMock, taskMonitorMapperMock);
DetailedReportLine line = (DetailedReportLine) actualResult.getReportLines().get("L10000");
DetailedReportLine line = (DetailedReportLine) actualResult.getReportLines()
.get("CLI:000000000000000000000000000000000001");
assertNotNull(actualResult);
assertEquals(line.getTotalNumberOfTasks(), 1);
assertEquals(line.getDetailLines().get("L11000").getTotalNumberOfTasks(), 1);
assertEquals(line.getDetailLines().get("CLI:000000000000000000000000000000000006").getTotalNumberOfTasks(), 1);
assertEquals(line.getLineItems().get(0).getNumberOfTasks(), 1);
assertEquals(line.getDetailLines().get("L11000").getLineItems().get(0).getNumberOfTasks(), 1);
assertEquals(line.getDetailLines()
.get("CLI:000000000000000000000000000000000006")
.getLineItems()
.get(0)
.getNumberOfTasks(), 1);
assertEquals(actualResult.getSumLine().getTotalNumberOfTasks(), 1);
assertEquals(actualResult.getSumLine().getLineItems().get(0).getNumberOfTasks(), 1);
}
@Test
public void testGetTotalNumbersOfCustomFieldValueReport() {
WorkbasketImpl workbasket = new WorkbasketImpl();
workbasket.setName("workbasket");
workbasket.setKey("wb1");
List<Workbasket> workbaskets = Arrays.asList(workbasket);
List<String> workbasketIds = Arrays.asList("WBI:000000000000000000000000000000000001");
List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
List<String> categories = Arrays.asList("EXTERN");
List<String> domains = Arrays.asList("DOMAIN_A");
@ -364,17 +333,16 @@ public class TaskMonitorServiceImplTest {
expectedResult.add(monitorQueryItem);
doReturn(expectedResult).when(taskMonitorMapperMock)
.getTaskCountOfCustomFieldValuesByWorkbasketsAndStatesAndCustomField(
workbaskets, states, categories, domains, CustomField.CUSTOM_1);
workbasketIds, states, categories, domains, CustomField.CUSTOM_1);
Report actualResult = cut.getCustomFieldValueReport(workbaskets, states, categories, domains,
Report actualResult = cut.getCustomFieldValueReport(workbasketIds, states, categories, domains,
CustomField.CUSTOM_1);
verify(taskanaEngineImpl, times(1)).openConnection();
verify(taskanaEngineImplMock, times(1)).openConnection();
verify(taskMonitorMapperMock, times(1))
.getTaskCountOfCustomFieldValuesByWorkbasketsAndStatesAndCustomField(any(), any(), any(), any(), any());
verify(taskanaEngineImpl, times(1)).returnConnection();
verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl,
taskMonitorMapperMock, objectReferenceMapperMock, workbasketServiceMock);
verify(taskanaEngineImplMock, times(1)).returnConnection();
verifyNoMoreInteractions(taskanaEngineImplMock, taskMonitorMapperMock);
assertNotNull(actualResult);
assertEquals(actualResult.getReportLines().get("Geschaeftsstelle A").getTotalNumberOfTasks(), 1);
@ -383,10 +351,7 @@ public class TaskMonitorServiceImplTest {
@Test
public void testGetCustomFieldValueReportWithReportLineItemDefinitions() {
WorkbasketImpl workbasket = new WorkbasketImpl();
workbasket.setName("workbasket");
workbasket.setKey("wb1");
List<Workbasket> workbaskets = Arrays.asList(workbasket);
List<String> workbasketIds = Arrays.asList("WBI:000000000000000000000000000000000001");
List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
List<String> categories = Arrays.asList("EXTERN");
List<String> domains = Arrays.asList("DOMAIN_A");
@ -401,17 +366,16 @@ public class TaskMonitorServiceImplTest {
expectedResult.add(monitorQueryItem);
doReturn(expectedResult).when(taskMonitorMapperMock)
.getTaskCountOfCustomFieldValuesByWorkbasketsAndStatesAndCustomField(
workbaskets, states, categories, domains, CustomField.CUSTOM_1);
workbasketIds, states, categories, domains, CustomField.CUSTOM_1);
Report actualResult = cut.getCustomFieldValueReport(workbaskets, states, categories, domains,
Report actualResult = cut.getCustomFieldValueReport(workbasketIds, states, categories, domains,
CustomField.CUSTOM_1, reportLineItemDefinitions);
verify(taskanaEngineImpl, times(1)).openConnection();
verify(taskanaEngineImplMock, times(1)).openConnection();
verify(taskMonitorMapperMock, times(1))
.getTaskCountOfCustomFieldValuesByWorkbasketsAndStatesAndCustomField(any(), any(), any(), any(), any());
verify(taskanaEngineImpl, times(1)).returnConnection();
verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl,
taskMonitorMapperMock, objectReferenceMapperMock, workbasketServiceMock);
verify(taskanaEngineImplMock, times(1)).returnConnection();
verifyNoMoreInteractions(taskanaEngineImplMock, taskMonitorMapperMock);
assertNotNull(actualResult);
assertEquals(actualResult.getReportLines().get("Geschaeftsstelle A").getTotalNumberOfTasks(), 1);

3
lib/taskana-core/src/test/resources/sql/monitor-sample-data.sql
View File

@ -1,4 +1,3 @@
-- WORKBASKET TABLE (ID , KEY , CREATED , MODIFIED , NAME , DOMAIN , TYPE , DESCRIPTION , OWNER , CUSTOM_1 , CUSTOM_2 , CUSTOM_3 , CUSTOM_4 , ORG_LEVEL_1 , ORG_LEVEL_2 , ORG_LEVEL_3 , ORG_LEVEL_4 );
INSERT INTO WORKBASKET VALUES ('WBI:000000000000000000000000000000000001', 'USER_1_1', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'PPK User 1 KSC 1', 'MONITOR_TEST_DOMAIN', 'PERSONAL', 'Monitor Test Postkorb 1', 'John' , '' , '' , '' , '' , '' , '' , '' , '' );
INSERT INTO WORKBASKET VALUES ('WBI:000000000000000000000000000000000002', 'USER_1_2', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'PPK User 1 KSC 2', 'MONITOR_TEST_DOMAIN', 'PERSONAL', 'Monitor Test Postkorb 2', 'John' , '' , '' , '' , '' , '' , '' , '' , '' );
@ -35,7 +34,7 @@ INSERT INTO ATTACHMENT VALUES('ATT:000000000000000000000000000000000009', 'TKI:0
INSERT INTO ATTACHMENT VALUES('ATT:000000000000000000000000000000000010', 'TKI:000000000000000000000000000000000044', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'L33000' ,'CLI:000000000000000000000000000000000008', '' , '' , '' , '' , '' , '' , CURRENT_TIMESTAMP, null );
INSERT INTO ATTACHMENT VALUES('ATT:000000000000000000000000000000000011', 'TKI:000000000000000000000000000000000045', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'L99000' ,'CLI:000000000000000000000000000000000009', '' , '' , '' , '' , '' , '' , CURRENT_TIMESTAMP, null );
-- TASK TABLE (ID , CREATED , CLAIMED , COMPLETED , MODIFIED , PLANNED , DUE , NAME , DESCRIPTION , NOTE , PRIORITY, STATE , CLASSIFICATION_CATEGORY , CLASSIFICATION_KEY, Classification_id , workbasket_id , WORKBASKET_KEY, DOMAIN , BUSINESS_PROCESS_ID, PARENT_BUSINESS_PROCESS_ID, OWNER , POR_COMPANY , POR_SYSTEM , POR_INSTANCE , POR_TYPE , POR_VALUE , IS_READ, IS_TRANSFERRED, CUSTOM_ATTRIBUTES, CUSTOM_1 , CUSTOM_2 , CUSTOM_3, CUSTOM_4, CUSTOM_5, CUSTOM_6, CUSTOM_7, CUSTOM_8, CUSTOM_9, CUSTOM_10 );
-- TASK TABLE (ID , CREATED , CLAIMED , COMPLETED , MODIFIED , PLANNED , DUE , NAME , DESCRIPTION , NOTE , PRIORITY, STATE , CLASSIFICATION_CATEGORY , CLASSIFICATION_KEY, CLASSIFICATION_ID , WORKBASKET_ID , WORKBASKET_KEY, DOMAIN , BUSINESS_PROCESS_ID, PARENT_BUSINESS_PROCESS_ID, OWNER , POR_COMPANY , POR_SYSTEM , POR_INSTANCE , POR_TYPE , POR_VALUE , IS_READ, IS_TRANSFERRED, CUSTOM_ATTRIBUTES, CUSTOM_1 , CUSTOM_2 , CUSTOM_3, CUSTOM_4, CUSTOM_5, CUSTOM_6, CUSTOM_7, CUSTOM_8, CUSTOM_9, CUSTOM_10 );
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000001', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, dueDate, 'Task01', 'Some description.', 'Some custom Note', 1 , 'READY' , 'EXTERN' , 'L10000' , 'CLI:000000000000000000000000000000000001', 'WBI:000000000000000000000000000000000001', 'USER_1_1' , 'DOMAIN_C', 'BPI21' , 'PBPI21' , 'John', 'MyCompany1', 'MySystem1', 'MyInstance1', 'MyType1', 'MyValue1', true , false , null , 'Geschaeftsstelle A' , 'Vollkasko' , null , null , null , null , null , null , null , null );
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000002', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, dueDate, 'Task02', 'Some description.', 'Some custom Note', 1 , 'READY' , 'EXTERN' , 'L20000' , 'CLI:000000000000000000000000000000000002', 'WBI:000000000000000000000000000000000002', 'USER_1_2' , 'DOMAIN_C', 'BPI21' , 'PBPI21' , 'John', 'MyCompany1', 'MySystem1', 'MyInstance1', 'MyType1', 'MyValue1', true , false , null , 'Geschaeftsstelle B' , 'Teilkasko' , null , null , null , null , null , null , null , null );
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000003', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, null , CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, dueDate, 'Task03', 'Some description.', 'Some custom Note', 1 , 'READY' , 'EXTERN' , 'L20000' , 'CLI:000000000000000000000000000000000002', 'WBI:000000000000000000000000000000000002', 'USER_1_2' , 'DOMAIN_B', 'BPI21' , 'PBPI21' , 'John', 'MyCompany1', 'MySystem1', 'MyInstance1', 'MyType1', 'MyValue1', true , false , null , 'Geschaeftsstelle A' , 'Teilkasko' , null , null , null , null , null , null , null , null );