diff --git a/lib/taskana-core/src/main/java/pro/taskana/TaskMonitorService.java b/lib/taskana-core/src/main/java/pro/taskana/TaskMonitorService.java index 17a730d83..08c8a1f1f 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/TaskMonitorService.java +++ b/lib/taskana-core/src/main/java/pro/taskana/TaskMonitorService.java @@ -3,11 +3,13 @@ package pro.taskana; import java.util.List; import pro.taskana.exceptions.InvalidArgumentException; -import pro.taskana.impl.ClassificationReport; -import pro.taskana.impl.DetailedClassificationReport; -import pro.taskana.impl.Report; -import pro.taskana.impl.ReportLineItemDefinition; import pro.taskana.impl.SelectedItem; +import pro.taskana.impl.report.impl.CategoryReport; +import pro.taskana.impl.report.impl.ClassificationReport; +import pro.taskana.impl.report.impl.CustomFieldValueReport; +import pro.taskana.impl.report.impl.DetailedClassificationReport; +import pro.taskana.impl.report.impl.TimeIntervalColumnHeader; +import pro.taskana.impl.report.impl.WorkbasketLevelReport; /** * The Task Monitor Service manages operations on tasks regarding the monitoring. @@ -15,7 +17,7 @@ import pro.taskana.impl.SelectedItem; public interface TaskMonitorService { /** - * Returns a {@link Report} grouped by workbaskets. The report contains the total numbers of tasks of the respective + * Returns a {@link WorkbasketLevelReport} grouped by workbaskets. The report contains the total numbers of tasks of the respective * workbasket as well as the total number of all tasks. If no filter is required, the respective parameter should be * null. The tasks of the report are filtered by workbaskets, states, categories, domains and values of a custom * field. Tasks with Timestamp DUE = null are not considered. @@ -38,13 +40,14 @@ public interface TaskMonitorService { * @throws InvalidArgumentException * thrown if DaysToWorkingDaysConverter is initialized with null */ - Report getWorkbasketLevelReport(List workbasketIds, List states, List categories, - List domains, CustomField customField, List customFieldValues) throws InvalidArgumentException; + WorkbasketLevelReport getWorkbasketLevelReport(List workbasketIds, List states, + List categories, List domains, CustomField customField, List customFieldValues) + throws InvalidArgumentException; /** - * Returns a {@link Report} grouped by workbaskets. For each workbasket the report contains the total number of + * Returns a {@link WorkbasketLevelReport} grouped by workbaskets. For each workbasket the report contains the total number of * tasks and the number of tasks of the respective cluster that are specified by the - * {@link ReportLineItemDefinition}s. By default the age of the tasks is counted in working days. Furthermore the + * {@link TimeIntervalColumnHeader}s. By default the age of the tasks is counted in working days. Furthermore the * Report contains a sum line that contains the total numbers of the different clusters and the total number of all * tasks in this report. The tasks of the report are filtered by workbaskets, states, categories, domains and values * of a custom field. If no filter is required, the respective parameter should be null. Tasks with Timestamp DUE = @@ -65,11 +68,11 @@ public interface TaskMonitorService { * @param customFieldValues * a list of custom field values to filter by the values of the custom field. To omit this filter, use * null for this parameter - * @param reportLineItemDefinitions - * a list of reportLineItemDefinitions that specify the subdivision into different cluster of due dates. + * @param columnHeaders + * a list of columnHeaders that specify the subdivision into different cluster of due dates. * Days in past are represented as negative values and days in the future are represented as positive * values. To avoid tasks are counted multiple times or not be listed in the report, these - * reportLineItemDefinitions should not overlap and should not have gaps. If the ReportLineDefinition + * columnHeaders should not overlap and should not have gaps. If the ReportLineDefinition * should represent a single day, lowerLimit and upperLimit have to be equal. The outer cluster of a * report should have open ends. These open ends are represented with Integer.MIN_VALUE and * Integer.MAX_VALUE. @@ -77,14 +80,14 @@ public interface TaskMonitorService { * @throws InvalidArgumentException * thrown if DaysToWorkingDaysConverter is initialized with null */ - Report getWorkbasketLevelReport(List workbasketIds, List states, + WorkbasketLevelReport getWorkbasketLevelReport(List workbasketIds, List states, List categories, List domains, CustomField customField, List customFieldValues, - List reportLineItemDefinitions) throws InvalidArgumentException; + List columnHeaders) throws InvalidArgumentException; /** - * Returns a {@link Report} grouped by workbaskets. For each workbasket the report contains the total number of + * Returns a {@link WorkbasketLevelReport} grouped by workbaskets. For each workbasket the report contains the total number of * tasks and the number of tasks of the respective cluster that are specified by the - * {@link ReportLineItemDefinition}s. It can be specified whether the age of the tasks is counted in days or in + * {@link TimeIntervalColumnHeader}s. It can be specified whether the age of the tasks is counted in days or in * working days. Furthermore the report contains a sum line that contains the total numbers of the different * clusters and the total number of all tasks. The tasks of the report are filtered by workbaskets, states, * categories, domains and values of a custom field. If no filter is required, the respective parameter should be @@ -105,11 +108,11 @@ public interface TaskMonitorService { * @param customFieldValues * a list of custom field values to filter by the values of the custom field. To omit this filter, use * null for this parameter - * @param reportLineItemDefinitions - * a list of reportLineItemDefinitions that specify the subdivision into different cluster of due dates. + * @param columnHeaders + * a list of columnHeaders that specify the subdivision into different cluster of due dates. * Days in past are represented as negative values and days in the future are represented as positive * values. To avoid tasks are counted multiple times or not be listed in the report, these - * reportLineItemDefinitions should not overlap and should not have gaps. If the ReportLineDefinition + * columnHeaders should not overlap and should not have gaps. If the ReportLineDefinition * should represent a single day, lowerLimit and upperLimit have to be equal. The outer cluster of a * report should have open ends. These open ends are represented with Integer.MIN_VALUE and * Integer.MAX_VALUE. @@ -120,13 +123,13 @@ public interface TaskMonitorService { * @throws InvalidArgumentException * thrown if DaysToWorkingDaysConverter is initialized with null */ - Report getWorkbasketLevelReport(List workbasketIds, List states, + WorkbasketLevelReport getWorkbasketLevelReport(List workbasketIds, List states, List categories, List domains, CustomField customField, List customFieldValues, - List reportLineItemDefinitions, boolean inWorkingDays) + List columnHeaders, boolean inWorkingDays) throws InvalidArgumentException; /** - * Returns a {@link Report} grouped by categories. The report contains the total numbers of tasks of the respective + * Returns a {@link CategoryReport} grouped by categories. The report contains the total numbers of tasks of the respective * category as well as the total number of all tasks. The tasks of the report are filtered by workbaskets, states, * categories, domains and values of a custom field and values of a custom field. If no filter is required, the * respective parameter should be null. Tasks with Timestamp DUE = null are not considered. @@ -149,12 +152,12 @@ public interface TaskMonitorService { * @throws InvalidArgumentException * thrown if DaysToWorkingDaysConverter is initialized with null */ - Report getCategoryReport(List workbasketIds, List states, List categories, + CategoryReport getCategoryReport(List workbasketIds, List states, List categories, List domains, CustomField customField, List customFieldValues) throws InvalidArgumentException; /** - * Returns a {@link Report} grouped by categories. For each category the report contains the total number of tasks - * and the number of tasks of the respective cluster that are specified by the {@link ReportLineItemDefinition}s. By + * Returns a {@link CategoryReport} grouped by categories. For each category the report contains the total number of tasks + * and the number of tasks of the respective cluster that are specified by the {@link TimeIntervalColumnHeader}s. By * default the age of the tasks is counted in working days. Furthermore the Report contains a sum line that contains * the total numbers of the different clusters and the total number of all tasks in this report. The tasks of the * report are filtered by workbaskets, states, categories, domains and values of a custom field. If no filter is @@ -175,11 +178,11 @@ public interface TaskMonitorService { * @param customFieldValues * a list of custom field values to filter by the values of the custom field. To omit this filter, use * null for this parameter - * @param reportLineItemDefinitions - * a list of reportLineItemDefinitions that specify the subdivision into different cluster of due dates. + * @param columnHeaders + * a list of columnHeaders that specify the subdivision into different cluster of due dates. * Days in past are represented as negative values and days in the future are represented as positive * values. To avoid tasks are counted multiple times or not be listed in the report, these - * reportLineItemDefinitions should not overlap and should not have gaps. If the ReportLineDefinition + * columnHeaders should not overlap and should not have gaps. If the ReportLineDefinition * should represent a single day, lowerLimit and upperLimit have to be equal. The outer cluster of a * report should have open ends. These open ends are represented with Integer.MIN_VALUE and * Integer.MAX_VALUE. @@ -187,13 +190,13 @@ public interface TaskMonitorService { * @throws InvalidArgumentException * thrown if DaysToWorkingDaysConverter is initialized with null */ - Report getCategoryReport(List workbasketIds, List states, List categories, + CategoryReport getCategoryReport(List workbasketIds, List states, List categories, List domains, CustomField customField, List customFieldValues, - List reportLineItemDefinitions) throws InvalidArgumentException; + List columnHeaders) throws InvalidArgumentException; /** - * Returns a {@link Report} grouped by categories. For each category the report contains the total number of tasks - * and the number of tasks of the respective cluster that are specified by the {@link ReportLineItemDefinition}s. It + * Returns a {@link CategoryReport} grouped by categories. For each category the report contains the total number of tasks + * and the number of tasks of the respective cluster that are specified by the {@link TimeIntervalColumnHeader}s. It * can be specified whether the age of the tasks is counted in days or in working days. Furthermore the report * contains a sum line that contains the total numbers of the different clusters and the total number of all tasks. * The tasks of the report are filtered by workbaskets, states, categories, domains and values of a custom field. If @@ -215,11 +218,11 @@ public interface TaskMonitorService { * @param customFieldValues * a list of custom field values to filter by the values of the custom field. To omit this filter, use * null for this parameter - * @param reportLineItemDefinitions - * a list of reportLineItemDefinitions that specify the subdivision into different cluster of due dates. + * @param columnHeaders + * a list of columnHeaders that specify the subdivision into different cluster of due dates. * Days in past are represented as negative values and days in the future are represented as positive * values. To avoid tasks are counted multiple times or not be listed in the report, these - * reportLineItemDefinitions should not overlap and should not have gaps. If the ReportLineDefinition + * columnHeaders should not overlap and should not have gaps. If the ReportLineDefinition * should represent a single day, lowerLimit and upperLimit have to be equal. The outer cluster of a * report should have open ends. These open ends are represented with Integer.MIN_VALUE and * Integer.MAX_VALUE. @@ -230,13 +233,13 @@ public interface TaskMonitorService { * @throws InvalidArgumentException * thrown if DaysToWorkingDaysConverter is initialized with null */ - Report getCategoryReport(List workbasketIds, List states, List categories, + CategoryReport getCategoryReport(List workbasketIds, List states, List categories, List domains, CustomField customField, List customFieldValues, - List reportLineItemDefinitions, boolean inWorkingDays) + List columnHeaders, boolean inWorkingDays) throws InvalidArgumentException; /** - * Returns a {@link Classification} grouped by classifications. The report contains the total numbers of tasks of + * Returns a {@link ClassificationReport} grouped by classifications. The report contains the total numbers of tasks of * the respective classification as well as the total number of all tasks. The tasks of the report are filtered by * workbaskets, states, categories, domains and values of a custom field. If no filter is required, the respective * parameter should be null. Tasks with Timestamp DUE = null are not considered. @@ -264,9 +267,9 @@ public interface TaskMonitorService { throws InvalidArgumentException; /** - * Returns a {@link Classification} grouped by classifications. For each classification the report contains the + * Returns a {@link ClassificationReport} grouped by classifications. For each classification the report contains the * total number of tasks and the number of tasks of the respective cluster that are specified by the - * {@link ReportLineItemDefinition}s. By default the age of the tasks is counted in working days. Furthermore the + * {@link TimeIntervalColumnHeader}s. By default the age of the tasks is counted in working days. Furthermore the * Report contains a sum line that contains the total numbers of the different clusters and the total number of all * tasks in this report. The tasks of the report are filtered by workbaskets, states, categories, domains and values * of a custom field. If no filter is required, the respective parameter should be null. Tasks with Timestamp DUE = @@ -287,11 +290,11 @@ public interface TaskMonitorService { * @param customFieldValues * a list of custom field values to filter by the values of the custom field. To omit this filter, use * null for this parameter - * @param reportLineItemDefinitions - * a list of reportLineItemDefinitions that specify the subdivision into different cluster of due dates. + * @param columnHeaders + * a list of columnHeaders that specify the subdivision into different cluster of due dates. * Days in past are represented as negative values and days in the future are represented as positive * values. To avoid tasks are counted multiple times or not be listed in the report, these - * reportLineItemDefinitions should not overlap and should not have gaps. If the ReportLineDefinition + * columnHeaders should not overlap and should not have gaps. If the ReportLineDefinition * should represent a single day, lowerLimit and upperLimit have to be equal. The outer cluster of a * report should have open ends. These open ends are represented with Integer.MIN_VALUE and * Integer.MAX_VALUE. @@ -301,12 +304,12 @@ public interface TaskMonitorService { */ ClassificationReport getClassificationReport(List workbasketIds, List states, List categories, List domains, CustomField customField, List customFieldValues, - List reportLineItemDefinitions) throws InvalidArgumentException; + List columnHeaders) throws InvalidArgumentException; /** * Returns a {@link ClassificationReport} grouped by classification. For each classification the report contains the * total number of tasks and the number of tasks of the respective cluster that are specified by the - * {@link ReportLineItemDefinition}s. It can be specified whether the age of the tasks is counted in days or in + * {@link TimeIntervalColumnHeader}s. It can be specified whether the age of the tasks is counted in days or in * working days. Furthermore the report contains a sum line that contains the total numbers of the different * clusters and the total number of all tasks. The tasks of the report are filtered by workbaskets, states, * categories, domains and values of a custom field. If no filter is required, the respective parameter should be @@ -327,11 +330,11 @@ public interface TaskMonitorService { * @param customFieldValues * a list of custom field values to filter by the values of the custom field. To omit this filter, use * null for this parameter - * @param reportLineItemDefinitions - * a list of reportLineItemDefinitions that specify the subdivision into different cluster of due dates. + * @param columnHeaders + * a list of columnHeaders that specify the subdivision into different cluster of due dates. * Days in past are represented as negative values and days in the future are represented as positive * values. To avoid tasks are counted multiple times or not be listed in the report, these - * reportLineItemDefinitions should not overlap and should not have gaps. If the ReportLineDefinition + * columnHeaders should not overlap and should not have gaps. If the ReportLineDefinition * should represent a single day, lowerLimit and upperLimit have to be equal. The outer cluster of a * report should have open ends. These open ends are represented with Integer.MIN_VALUE and * Integer.MAX_VALUE. @@ -344,7 +347,7 @@ public interface TaskMonitorService { */ ClassificationReport getClassificationReport(List workbasketIds, List states, List categories, List domains, CustomField customField, List customFieldValues, - List reportLineItemDefinitions, boolean inWorkingDays) + List columnHeaders, boolean inWorkingDays) throws InvalidArgumentException; /** @@ -379,7 +382,7 @@ public interface TaskMonitorService { /** * Returns a {@link DetailedClassificationReport}. For each classification the report contains the total number of * tasks and the number of tasks of the respective cluster that are specified by the - * {@link ReportLineItemDefinition}s. By default the age of the tasks is counted in working days. Each ReportLine + * {@link TimeIntervalColumnHeader}s. By default the age of the tasks is counted in working days. Each ReportLine * contains an additional list of ReportLines for the classifications of the attachments of the tasks. Furthermore * the Report contains a sum line that contains the total numbers of the different clusters and the total number of * all tasks in this report. The tasks of the report are filtered by workbaskets, states, categories, domains and @@ -401,11 +404,11 @@ public interface TaskMonitorService { * @param customFieldValues * a list of custom field values to filter by the values of the custom field. To omit this filter, use * null for this parameter - * @param reportLineItemDefinitions - * a list of reportLineItemDefinitions that specify the subdivision into different cluster of due dates. + * @param columnHeaders + * a list of columnHeaders that specify the subdivision into different cluster of due dates. * Days in past are represented as negative values and days in the future are represented as positive * values. To avoid tasks are counted multiple times or not be listed in the report, these - * reportLineItemDefinitions should not overlap and should not have gaps. If the ReportLineDefinition + * columnHeaders should not overlap and should not have gaps. If the ReportLineDefinition * should represent a single day, lowerLimit and upperLimit have to be equal. The outer cluster of a * report should have open ends. These open ends are represented with Integer.MIN_VALUE and * Integer.MAX_VALUE. @@ -415,12 +418,12 @@ public interface TaskMonitorService { */ DetailedClassificationReport getDetailedClassificationReport(List workbasketIds, List states, List categories, List domains, CustomField customField, List customFieldValues, - List reportLineItemDefinitions) throws InvalidArgumentException; + List columnHeaders) throws InvalidArgumentException; /** * Returns a {@link DetailedClassificationReport}. For each classification the report contains the total number of * tasks and the number of tasks of the respective cluster that are specified by the - * {@link ReportLineItemDefinition}s. It can be specified whether the age of the tasks is counted in days or in + * {@link TimeIntervalColumnHeader}s. It can be specified whether the age of the tasks is counted in days or in * working days. Each ReportLine contains an additional list of ReportLines for the classifications of the * attachments of the tasks. Furthermore the report contains a sum line that contains the total numbers of the * different clusters and the total number of all tasks. The tasks of the report are filtered by workbaskets, @@ -442,11 +445,11 @@ public interface TaskMonitorService { * @param customFieldValues * a list of custom field values to filter by the values of the custom field. To omit this filter, use * null for this parameter - * @param reportLineItemDefinitions - * a list of reportLineItemDefinitions that specify the subdivision into different cluster of due dates. + * @param columnHeaders + * a list of columnHeaders that specify the subdivision into different cluster of due dates. * Days in past are represented as negative values and days in the future are represented as positive * values. To avoid tasks are counted multiple times or not be listed in the report, these - * reportLineItemDefinitions should not overlap and should not have gaps. If the ReportLineDefinition + * columnHeaders should not overlap and should not have gaps. If the ReportLineDefinition * should represent a single day, lowerLimit and upperLimit have to be equal. The outer cluster of a * report should have open ends. These open ends are represented with Integer.MIN_VALUE and * Integer.MAX_VALUE. @@ -459,11 +462,11 @@ public interface TaskMonitorService { */ DetailedClassificationReport getDetailedClassificationReport(List workbasketIds, List states, List categories, List domains, CustomField customField, List customFieldValues, - List reportLineItemDefinitions, boolean inWorkingDays) + List columnHeaders, boolean inWorkingDays) throws InvalidArgumentException; /** - * Returns a {@link Report} grouped by the value of a certain {@link CustomField}. The report contains the total + * Returns a {@link CustomFieldValueReport} grouped by the value of a certain {@link CustomField}. The report contains the total * 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, domains and values of a custom field. If no filter is required, * the respective parameter should be null. Tasks with Timestamp DUE = null are not considered. @@ -485,13 +488,14 @@ public interface TaskMonitorService { * @throws InvalidArgumentException * thrown if customField is null */ - Report getCustomFieldValueReport(List workbasketIds, List states, List categories, - List domains, CustomField customField, List customFieldValues) throws InvalidArgumentException; + CustomFieldValueReport getCustomFieldValueReport(List workbasketIds, List states, + List categories, List domains, CustomField customField, List customFieldValues) + throws InvalidArgumentException; /** - * Returns a {@link Report} grouped by the value of a certain {@link CustomField}. For each value of the custom + * Returns a {@link CustomFieldValueReport} grouped by the value of a certain {@link CustomField}. For each value of the custom * field the report contains the total number of tasks and the number of tasks of the respective cluster that are - * specified by the {@link ReportLineItemDefinition}s. By default the age of the tasks is counted in working days. + * specified by the {@link TimeIntervalColumnHeader}s. By default the age of the tasks is counted in working days. * Furthermore the Report contains a sum line that contains the total numbers of the different clusters and the * total number of all tasks in this report. The tasks of the report are filtered by workbaskets, states, * categories, domains and values of a custom field. If no filter is required, the respective parameter should be @@ -511,11 +515,11 @@ public interface TaskMonitorService { * @param customFieldValues * a list of custom field values to filter by the values of the custom field. To omit this filter, use * null for this parameter - * @param reportLineItemDefinitions - * a list of reportLineItemDefinitions that specify the subdivision into different cluster of due dates. + * @param columnHeaders + * a list of columnHeaders that specify the subdivision into different cluster of due dates. * Days in past are represented as negative values and days in the future are represented as positive * values. To avoid tasks are counted multiple times or not be listed in the report, these - * reportLineItemDefinitions should not overlap and should not have gaps. If the ReportLineDefinition + * columnHeaders should not overlap and should not have gaps. If the ReportLineDefinition * should represent a single day, lowerLimit and upperLimit have to be equal. The outer cluster of a * report should have open ends. These open ends are represented with Integer.MIN_VALUE and * Integer.MAX_VALUE. @@ -523,14 +527,14 @@ public interface TaskMonitorService { * @throws InvalidArgumentException * thrown if customField is null */ - Report getCustomFieldValueReport(List workbasketIds, List states, List categories, - List domains, CustomField customField, List customFieldValues, - List reportLineItemDefinitions) throws InvalidArgumentException; + CustomFieldValueReport getCustomFieldValueReport(List workbasketIds, List states, + List categories, List domains, CustomField customField, List customFieldValues, + List columnHeaders) throws InvalidArgumentException; /** - * Returns a {@link Report} grouped by the value of a certain {@link CustomField}. For each value of the custom + * Returns a {@link CustomFieldValueReport} grouped by the value of a certain {@link CustomField}. For each value of the custom * field the report contains the total number of tasks and the number of tasks of the respective cluster that are - * specified by the {@link ReportLineItemDefinition}s. It can be specified whether the age of the tasks is counted + * specified by the {@link TimeIntervalColumnHeader}s. It can be specified whether the age of the tasks is counted * in days or in working days. Furthermore the report contains a sum line that contains the total numbers of the * different clusters and the total number of all tasks. The tasks of the report are filtered by workbaskets, * states, categories, domains and values of a custom field. If no filter is required, the respective parameter @@ -550,11 +554,11 @@ public interface TaskMonitorService { * @param customFieldValues * a list of custom field values to filter by the values of the custom field. To omit this filter, use * null for this parameter - * @param reportLineItemDefinitions - * a list of reportLineItemDefinitions that specify the subdivision into different cluster of due dates. + * @param columnHeaders + * a list of columnHeaders that specify the subdivision into different cluster of due dates. * Days in past are represented as negative values and days in the future are represented as positive * values. To avoid tasks are counted multiple times or not be listed in the report, these - * reportLineItemDefinitions should not overlap and should not have gaps. If the ReportLineDefinition + * columnHeaders should not overlap and should not have gaps. If the ReportLineDefinition * should represent a single day, lowerLimit and upperLimit have to be equal. The outer cluster of a * report should have open ends. These open ends are represented with Integer.MIN_VALUE and * Integer.MAX_VALUE. @@ -565,16 +569,17 @@ public interface TaskMonitorService { * @throws InvalidArgumentException * thrown if customField is null */ - Report getCustomFieldValueReport(List workbasketIds, List states, List categories, + CustomFieldValueReport getCustomFieldValueReport(List workbasketIds, List states, + List categories, List domains, CustomField customField, List customFieldValues, - List reportLineItemDefinitions, boolean inWorkingDays) + List columnHeaders, boolean inWorkingDays) throws InvalidArgumentException; /** - * Returns a list of all task ids in the selected items of a {@link Report}. By default the age of the tasks is - * counted in working days. The tasks of the report are filtered by workbaskets, states, categories, domains and - * values of a custom field. If no filter is required, the respective parameter should be null. Tasks with Timestamp - * DUE = null are not considered. + * Returns a list of all task ids in the selected items of a {@link pro.taskana.impl.report.Report}. + * By default the age of the tasks is counted in working days. The tasks of the report are filtered by workbaskets, + * states, categories, domains and values of a custom field. If no filter is required, the respective parameter + * should be null. Tasks with Timestamp DUE = null are not considered. * * @param workbasketIds * a list of workbasket ids objects to filter by workbaskets. To omit this filter, use null for this @@ -591,11 +596,11 @@ public interface TaskMonitorService { * @param customFieldValues * a list of custom field values to filter by the values of the custom field. To omit this filter, use * null for this parameter - * @param reportLineItemDefinitions - * a list of reportLineItemDefinitions that specify the subdivision into different cluster of due dates. + * @param columnHeaders + * a list of columnHeaders that specify the subdivision into different cluster of due dates. * Days in past are represented as negative values and days in the future are represented as positive * values. To avoid tasks are counted multiple times or not be listed in the report, these - * reportLineItemDefinitions should not overlap and should not have gaps. If the ReportLineDefinition + * columnHeaders should not overlap and should not have gaps. If the ReportLineDefinition * should represent a single day, lowerLimit and upperLimit have to be equal. The outer cluster of a * report should have open ends. These open ends are represented with Integer.MIN_VALUE and * Integer.MAX_VALUE. @@ -603,18 +608,18 @@ public interface TaskMonitorService { * a list of {@link SelectedItem}s that are selected from the report whose task ids should be determined. * @return the list of task ids * @throws InvalidArgumentException - * thrown if reportLineItemDefinitions is null or if selectedItems is empty or null + * thrown if columnHeaders is null or if selectedItems is empty or null */ List getTaskIdsOfCategoryReportLineItems(List workbasketIds, List states, List categories, List domains, CustomField customField, List customFieldValues, - List reportLineItemDefinitions, List selectedItems) + List columnHeaders, List selectedItems) throws InvalidArgumentException; /** - * Returns a list of all task ids in the selected items of a {@link Report}. By default the age of the tasks is - * counted in working days. The tasks of the report are filtered by workbaskets, states, categories, domains and - * values of a custom field. If no filter is required, the respective parameter should be null. Tasks with Timestamp - * DUE = null are not considered. + * Returns a list of all task ids in the selected items of a {@link pro.taskana.impl.report.Report}. + * By default the age of the tasks is counted in working days. The tasks of the report are filtered by workbaskets, + * states, categories, domains and values of a custom field. If no filter is required, the respective parameter + * should be null. Tasks with Timestamp DUE = null are not considered. * * @param workbasketIds * a list of workbasket ids objects to filter by workbaskets. To omit this filter, use null for this @@ -631,11 +636,11 @@ public interface TaskMonitorService { * @param customFieldValues * a list of custom field values to filter by the values of the custom field. To omit this filter, use * null for this parameter - * @param reportLineItemDefinitions - * a list of reportLineItemDefinitions that specify the subdivision into different cluster of due dates. + * @param columnHeaders + * a list of columnHeaders that specify the subdivision into different cluster of due dates. * Days in past are represented as negative values and days in the future are represented as positive * values. To avoid tasks are counted multiple times or not be listed in the report, these - * reportLineItemDefinitions should not overlap and should not have gaps. If the ReportLineDefinition + * columnHeaders should not overlap and should not have gaps. If the ReportLineDefinition * should represent a single day, lowerLimit and upperLimit have to be equal. The outer cluster of a * report should have open ends. These open ends are represented with Integer.MIN_VALUE and * Integer.MAX_VALUE. @@ -646,11 +651,11 @@ public interface TaskMonitorService { * a list of {@link SelectedItem}s that are selected from the report whose task ids should be determined. * @return the list of task ids * @throws InvalidArgumentException - * thrown if reportLineItemDefinitions is null or if selectedItems is empty or null + * thrown if columnHeaders is null or if selectedItems is empty or null */ List getTaskIdsOfCategoryReportLineItems(List workbasketIds, List states, List categories, List domains, CustomField customField, List customFieldValues, - List reportLineItemDefinitions, boolean inWorkingDays, + List columnHeaders, boolean inWorkingDays, List selectedItems) throws InvalidArgumentException; } diff --git a/lib/taskana-core/src/main/java/pro/taskana/impl/ClassificationReport.java b/lib/taskana-core/src/main/java/pro/taskana/impl/ClassificationReport.java deleted file mode 100644 index c1e51d4c8..000000000 --- a/lib/taskana-core/src/main/java/pro/taskana/impl/ClassificationReport.java +++ /dev/null @@ -1,13 +0,0 @@ -package pro.taskana.impl; - -/** - * The ClassificationReport extends the Report. The {@link ReportLine}s of the ClassificationReport are grouped by - * classifications. - */ -public class ClassificationReport extends Report { - - public ClassificationReport() { - super(); - } - -} diff --git a/lib/taskana-core/src/main/java/pro/taskana/impl/DaysToWorkingDaysConverter.java b/lib/taskana-core/src/main/java/pro/taskana/impl/DaysToWorkingDaysConverter.java index 8fb7f44ef..54b8d3c92 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/impl/DaysToWorkingDaysConverter.java +++ b/lib/taskana-core/src/main/java/pro/taskana/impl/DaysToWorkingDaysConverter.java @@ -12,14 +12,15 @@ import java.util.List; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import pro.taskana.impl.report.impl.TimeIntervalColumnHeader; import pro.taskana.exceptions.InvalidArgumentException; import pro.taskana.impl.util.LoggerUtils; /** * The DaysToWorkingDaysConverter provides a method to convert an age in days into an age in working days. Before the * method convertDaysToWorkingDays() can be used, the DaysToWorkingDaysConverter has to be initialized. For a list of - * {@link ReportLineItemDefinition}s the converter creates a "table" with integer that represents the age in days from - * the largest lower limit until the smallest upper limit of the reportLineItemDefinitions. This table is valid for a + * {@link TimeIntervalColumnHeader}s the converter creates a "table" with integer that represents the age in days from + * the largest lower limit until the smallest upper limit of the timeIntervalColumnHeaders. This table is valid for a * whole day until the converter is initialized with bigger limits. */ public final class DaysToWorkingDaysConverter { @@ -33,61 +34,61 @@ public final class DaysToWorkingDaysConverter { private static boolean germanHolidaysEnabled; private static List customHolidays; - private DaysToWorkingDaysConverter(List reportLineItemDefinitions, + private DaysToWorkingDaysConverter(List columnHeaders, Instant referenceDate) { easterSunday = getEasterSunday(LocalDateTime.ofInstant(referenceDate, ZoneId.systemDefault()).getYear()); dateCreated = referenceDate; - positiveDaysToWorkingDays = generatePositiveDaysToWorkingDays(reportLineItemDefinitions, referenceDate); - negativeDaysToWorkingDays = generateNegativeDaysToWorkingDays(reportLineItemDefinitions, referenceDate); + positiveDaysToWorkingDays = generatePositiveDaysToWorkingDays(columnHeaders, referenceDate); + negativeDaysToWorkingDays = generateNegativeDaysToWorkingDays(columnHeaders, referenceDate); } /** - * Initializes the DaysToWorkingDaysConverter for a list of {@link ReportLineItemDefinition}s and the current day. A + * Initializes the DaysToWorkingDaysConverter for a list of {@link TimeIntervalColumnHeader}s and the current day. A * new table is only created if there are bigger limits or the date has changed. * - * @param reportLineItemDefinitions - * a list of {@link ReportLineItemDefinition}s that determines the size of the table + * @param columnHeaders + * a list of {@link TimeIntervalColumnHeader}s that determines the size of the table * @return an instance of the DaysToWorkingDaysConverter * @throws InvalidArgumentException - * thrown if reportLineItemDefinitions is null + * thrown if columnHeaders is null */ - public static DaysToWorkingDaysConverter initialize(List reportLineItemDefinitions) + public static DaysToWorkingDaysConverter initialize(List columnHeaders) throws InvalidArgumentException { - return initialize(reportLineItemDefinitions, Instant.now()); + return initialize(columnHeaders, Instant.now()); } /** - * Initializes the DaysToWorkingDaysConverter for a list of {@link ReportLineItemDefinition}s and a referenceDate. A + * Initializes the DaysToWorkingDaysConverter for a list of {@link TimeIntervalColumnHeader}s and a referenceDate. A * new table is only created if there are bigger limits or the date has changed. * - * @param reportLineItemDefinitions - * a list of {@link ReportLineItemDefinition}s that determines the size of the table + * @param columnHeaders + * a list of {@link TimeIntervalColumnHeader}s that determines the size of the table * @param referenceDate * a {@link Instant} that represents the current day of the table * @return an instance of the DaysToWorkingDaysConverter * @throws InvalidArgumentException - * thrown if reportLineItemDefinitions or referenceDate is null + * thrown if columnHeaders or referenceDate is null */ - public static DaysToWorkingDaysConverter initialize(List reportLineItemDefinitions, + public static DaysToWorkingDaysConverter initialize(List columnHeaders, Instant referenceDate) throws InvalidArgumentException { if (LOGGER.isDebugEnabled()) { - LOGGER.debug("Initialize DaysToWorkingDaysConverter with reportLineItemDefinitions: {}", - LoggerUtils.listToString(reportLineItemDefinitions)); + LOGGER.debug("Initialize DaysToWorkingDaysConverter with columnHeaders: {}", + LoggerUtils.listToString(columnHeaders)); } - if (reportLineItemDefinitions == null) { - throw new InvalidArgumentException("ReportLineItemDefinitions can´t be used as NULL-Parameter"); + if (columnHeaders == null) { + throw new InvalidArgumentException("TimeIntervalColumnHeaders can´t be used as NULL-Parameter"); } if (referenceDate == null) { throw new InvalidArgumentException("ReferenceDate can´t be used as NULL-Parameter"); } - int largesLowerLimit = getLargestLowerLimit(reportLineItemDefinitions); - int smallestUpperLimit = getSmallestUpperLimit(reportLineItemDefinitions); + int largesLowerLimit = getLargestLowerLimit(columnHeaders); + int smallestUpperLimit = getSmallestUpperLimit(columnHeaders); if (instance == null || !positiveDaysToWorkingDays.contains(largesLowerLimit) || !negativeDaysToWorkingDays.contains(smallestUpperLimit) || !dateCreated.truncatedTo(ChronoUnit.DAYS).equals(referenceDate.truncatedTo(ChronoUnit.DAYS))) { - instance = new DaysToWorkingDaysConverter(reportLineItemDefinitions, referenceDate); + instance = new DaysToWorkingDaysConverter(columnHeaders, referenceDate); LOGGER.debug("Create new converter for the values from {} until {} for the date: {}.", largesLowerLimit, smallestUpperLimit, dateCreated); } @@ -188,8 +189,8 @@ public final class DaysToWorkingDaysConverter { } private ArrayList generateNegativeDaysToWorkingDays( - List reportLineItemDefinitions, Instant referenceDate) { - int minUpperLimit = getSmallestUpperLimit(reportLineItemDefinitions); + List columnHeaders, Instant referenceDate) { + int minUpperLimit = getSmallestUpperLimit(columnHeaders); ArrayList daysToWorkingDays = new ArrayList<>(); daysToWorkingDays.add(0); int day = -1; @@ -205,8 +206,8 @@ public final class DaysToWorkingDaysConverter { } private ArrayList generatePositiveDaysToWorkingDays( - List reportLineItemDefinitions, Instant referenceDate) { - int maxLowerLimit = getLargestLowerLimit(reportLineItemDefinitions); + List columnHeaders, Instant referenceDate) { + int maxLowerLimit = getLargestLowerLimit(columnHeaders); ArrayList daysToWorkingDays = new ArrayList<>(); daysToWorkingDays.add(0); @@ -222,21 +223,21 @@ public final class DaysToWorkingDaysConverter { return daysToWorkingDays; } - private static int getSmallestUpperLimit(List reportLineItemDefinitions) { + private static int getSmallestUpperLimit(List columnHeaders) { int smallestUpperLimit = 0; - for (ReportLineItemDefinition reportLineItemDefinition : reportLineItemDefinitions) { - if (reportLineItemDefinition.getUpperAgeLimit() < smallestUpperLimit) { - smallestUpperLimit = reportLineItemDefinition.getUpperAgeLimit(); + for (TimeIntervalColumnHeader columnHeader : columnHeaders) { + if (columnHeader.getUpperAgeLimit() < smallestUpperLimit) { + smallestUpperLimit = columnHeader.getUpperAgeLimit(); } } return smallestUpperLimit; } - private static int getLargestLowerLimit(List reportLineItemDefinitions) { + private static int getLargestLowerLimit(List columnHeaders) { int greatestLowerLimit = 0; - for (ReportLineItemDefinition reportLineItemDefinition : reportLineItemDefinitions) { - if (reportLineItemDefinition.getUpperAgeLimit() > greatestLowerLimit) { - greatestLowerLimit = reportLineItemDefinition.getLowerAgeLimit(); + for (TimeIntervalColumnHeader columnHeader : columnHeaders) { + if (columnHeader.getUpperAgeLimit() > greatestLowerLimit) { + greatestLowerLimit = columnHeader.getLowerAgeLimit(); } } return greatestLowerLimit; diff --git a/lib/taskana-core/src/main/java/pro/taskana/impl/DetailedClassificationReport.java b/lib/taskana-core/src/main/java/pro/taskana/impl/DetailedClassificationReport.java deleted file mode 100644 index eccdaeb94..000000000 --- a/lib/taskana-core/src/main/java/pro/taskana/impl/DetailedClassificationReport.java +++ /dev/null @@ -1,56 +0,0 @@ -package pro.taskana.impl; - -import java.util.List; - -import pro.taskana.exceptions.InvalidArgumentException; - -/** - * The DetailedClassificationReport extends the {@link ClassificationReport}. In contrast to the ClassificationReport - * there are DetailedReportLines instead of ReportLines. That means each ReportLine contains an additional list of - * ReportLines for the classifications of the attachments of the tasks. The additional addDetailedMonitoringQueryItems - * method allows to add {@link DetailedMonitorQueryItem}s to the DetailedClassificationReport. - */ -public class DetailedClassificationReport extends ClassificationReport { - - public DetailedClassificationReport() { - super(); - } - - /** - * Adds the information of the {@link DetailedMonitorQueryItem}s to the DetailedClassificationReport. - * - * @param detailedMonitorQueryItems - * a list of {@link DetailedMonitorQueryItem} with the information of the database - * @param reportLineItemDefinitions - * a list of {@link ReportLineItemDefinition}s that is needed to create the {@link ReportLine}s. - * @param inWorkingDays - * a boolean parameter that specifies whether the age of the tasks should be counted in days or in - * working days. - * @throws InvalidArgumentException - * thrown if reportLineItemDefinitions is null and inWorkingDays is true - */ - public void addDetailedMonitoringQueryItems(List detailedMonitorQueryItems, - List reportLineItemDefinitions, boolean inWorkingDays) - throws InvalidArgumentException { - - DaysToWorkingDaysConverter instance = null; - if (inWorkingDays) { - instance = DaysToWorkingDaysConverter.initialize(reportLineItemDefinitions); - } - - for (DetailedMonitorQueryItem item : detailedMonitorQueryItems) { - if (instance != null) { - item.setAgeInDays(instance.convertDaysToWorkingDays(item.getAgeInDays())); - } - if (!this.reportLines.containsKey(item.getKey())) { - DetailedReportLine detailedReportLine = new DetailedReportLine(); - detailedReportLine.create(reportLineItemDefinitions); - this.reportLines.put(item.getKey(), detailedReportLine); - } - DetailedReportLine detailedReportLine = (DetailedReportLine) this.reportLines.get(item.getKey()); - detailedReportLine.addNumberOfTasks(item, reportLineItemDefinitions); - } - this.sumLine = createSumLine(reportLineItemDefinitions); - } - -} diff --git a/lib/taskana-core/src/main/java/pro/taskana/impl/DetailedReportLine.java b/lib/taskana-core/src/main/java/pro/taskana/impl/DetailedReportLine.java deleted file mode 100644 index 55f046ddf..000000000 --- a/lib/taskana-core/src/main/java/pro/taskana/impl/DetailedReportLine.java +++ /dev/null @@ -1,59 +0,0 @@ -package pro.taskana.impl; - -import java.util.LinkedHashMap; -import java.util.List; -import java.util.Map; - -/** - * The DetailedReportLine extends the {@link ReportLine}. In contrast to the ReportLine there is an additional list of - * ReportLines for the classifications of the attachments of the tasks. - */ -public class DetailedReportLine extends ReportLine { - - private Map detailLines; - - public DetailedReportLine() { - super(); - this.detailLines = new LinkedHashMap<>(); - } - - public Map getDetailLines() { - return detailLines; - } - - public void setDetailLines(Map reportLines) { - this.detailLines = reportLines; - } - - /** - * Adds the number of tasks of the {@link DetailedMonitorQueryItem} to the respective {@link ReportLineItem} of this - * {@link DetailedReportLine} and and of the suitable sub line. - * - * @param item - * a {@link DetailedMonitorQueryItem} that contains the number of tasks, the age in days of these tasks - * and the Classification key of the corresponding attachment. - * @param reportLineItemDefinitions - * a list of {@link ReportLineItemDefinition}s that is needed to create a sub line if necessary. - */ - public void addNumberOfTasks(DetailedMonitorQueryItem item, - List reportLineItemDefinitions) { - super.addNumberOfTasks(item); - - if (item.getAttachmentKey() != null) { - if (!this.detailLines.containsKey(item.getAttachmentKey())) { - ReportLine reportLine = new ReportLine(); - reportLine.create(reportLineItemDefinitions); - this.detailLines.put(item.getAttachmentKey(), reportLine); - } - this.detailLines.get(item.getAttachmentKey()).addNumberOfTasks(item); - } else { - if (!this.detailLines.containsKey("N/A")) { - ReportLine reportLine = new ReportLine(); - reportLine.create(reportLineItemDefinitions); - this.detailLines.put("N/A", reportLine); - } - this.detailLines.get("N/A").addNumberOfTasks(item); - } - } - -} diff --git a/lib/taskana-core/src/main/java/pro/taskana/impl/Report.java b/lib/taskana-core/src/main/java/pro/taskana/impl/Report.java deleted file mode 100644 index af0e66366..000000000 --- a/lib/taskana-core/src/main/java/pro/taskana/impl/Report.java +++ /dev/null @@ -1,102 +0,0 @@ -package pro.taskana.impl; - -import java.util.Iterator; -import java.util.LinkedHashMap; -import java.util.List; -import java.util.Map; - -import pro.taskana.exceptions.InvalidArgumentException; - -/** - * A Report represents a table that consists of {@link ReportLine} objects. The detailLines are the rows of the table - * that contains the total number of all tasks and could be optionally subdivided into different sections. The sumLine - * contains the sums of all tasks and if the detailLines are subdivided into different sections the sumLine also - * contains the number of tasks of the respective section. - */ -public class Report { - - protected Map reportLines; - protected ReportLine sumLine; - - public Report() { - this.reportLines = new LinkedHashMap(); - } - - public Map getReportLines() { - return reportLines; - } - - public void setReportLines(Map reportLines) { - this.reportLines = reportLines; - } - - public ReportLine getSumLine() { - return sumLine; - } - - public void setSumLine(ReportLine sumLine) { - this.sumLine = sumLine; - } - - /** - * Adds the information of the {@link MonitorQueryItem}s to the Report. - * - * @param monitorQueryItems - * a list of {@link MonitorQueryItem} with the information of the database - * @param reportLineItemDefinitions - * a list of {@link ReportLineItemDefinition}s that is needed to create the {@link ReportLine}s. - * @param inWorkingDays - * a boolean parameter that specifies whether the age of the tasks should be counted in days or in - * working days. - * @throws InvalidArgumentException - * thrown if reportLineItemDefinitions is null and inWorkingDays is true - */ - public void addMonitoringQueryItems(List monitorQueryItems, - List reportLineItemDefinitions, boolean inWorkingDays) - throws InvalidArgumentException { - DaysToWorkingDaysConverter instance = null; - if (inWorkingDays) { - instance = DaysToWorkingDaysConverter.initialize(reportLineItemDefinitions); - } - - for (MonitorQueryItem item : monitorQueryItems) { - if (instance != null) { - item.setAgeInDays(instance.convertDaysToWorkingDays(item.getAgeInDays())); - } - if (!this.reportLines.containsKey(item.getKey())) { - ReportLine reportLine = new ReportLine(); - reportLine.create(reportLineItemDefinitions); - this.reportLines.put(item.getKey(), reportLine); - } - this.reportLines.get(item.getKey()).addNumberOfTasks(item); - } - - this.sumLine = createSumLine(reportLineItemDefinitions); - } - - /** - * Creates the sum line of this {@link Report}. - * - * @param reportLineItemDefinitions - * a list of {@link ReportLineItemDefinition}s that specify the subdivision into different cluster of - * ages. - * @return a {@link ReportLine} that contains the sums of the different cluster of this {@link Report}. - */ - protected ReportLine createSumLine(List reportLineItemDefinitions) { - ReportLine sumLine = new ReportLine(); - sumLine.create(reportLineItemDefinitions); - int totalNumberOfTasks = 0; - for (ReportLine reportLine : this.reportLines.values()) { - Iterator reportLineItemIterator = reportLine.getLineItems().iterator(); - Iterator sumLineItemIterator = sumLine.getLineItems().iterator(); - while (reportLineItemIterator.hasNext() && sumLineItemIterator.hasNext()) { - int numberOfTasks = reportLineItemIterator.next().getNumberOfTasks(); - sumLineItemIterator.next().addNumberOfTasks(numberOfTasks); - } - totalNumberOfTasks += reportLine.getTotalNumberOfTasks(); - } - sumLine.setTotalNumberOfTasks(totalNumberOfTasks); - return sumLine; - } - -} diff --git a/lib/taskana-core/src/main/java/pro/taskana/impl/ReportLine.java b/lib/taskana-core/src/main/java/pro/taskana/impl/ReportLine.java deleted file mode 100644 index 0c6e0fa58..000000000 --- a/lib/taskana-core/src/main/java/pro/taskana/impl/ReportLine.java +++ /dev/null @@ -1,71 +0,0 @@ -package pro.taskana.impl; - -import java.util.ArrayList; -import java.util.List; - -/** - * Each ReportLine consists of a list of {@link ReportLineItem} objects and the number of all tasks of this ReportLine. - */ -public class ReportLine { - - protected List lineItems; - protected int totalNumberOfTasks; - - public ReportLine() { - this.lineItems = new ArrayList<>(); - this.totalNumberOfTasks = 0; - } - - public List getLineItems() { - return lineItems; - } - - public void setLineItems(List lineItems) { - this.lineItems = lineItems; - } - - public int getTotalNumberOfTasks() { - return totalNumberOfTasks; - } - - public void setTotalNumberOfTasks(int totalNumberOfTasks) { - this.totalNumberOfTasks = totalNumberOfTasks; - } - - /** - * Creates a list of {@link ReportLineItem}s for this {@link ReportLine} by using the list of - * {@link ReportLineItemDefinition}s. - * - * @param reportLineItemDefinitions - * a list of {@link ReportLineItemDefinition}s that specify the subdivision into different cluster of - * ages. - */ - public void create(List reportLineItemDefinitions) { - if (reportLineItemDefinitions != null) { - for (ReportLineItemDefinition reportLineItemDefinition : reportLineItemDefinitions) { - ReportLineItem reportLineItem = new ReportLineItem(); - reportLineItem.setReportLineItemDefinition(reportLineItemDefinition); - this.getLineItems().add(reportLineItem); - } - } - } - - /** - * Adds the number of tasks of the {@link MonitorQueryItem} to the respective {@link ReportLineItem}. - * - * @param item - * a {@link MonitorQueryItem} that contains the number of tasks and the age in days of these tasks. - */ - public void addNumberOfTasks(MonitorQueryItem item) { - this.totalNumberOfTasks += item.getNumberOfTasks(); - for (ReportLineItem reportLineItem : lineItems) { - int lowerAgeLimit = reportLineItem.getReportLineItemDefinition().getLowerAgeLimit(); - int upperAgeLimit = reportLineItem.getReportLineItemDefinition().getUpperAgeLimit(); - if (lowerAgeLimit <= item.getAgeInDays() && upperAgeLimit >= item.getAgeInDays()) { - reportLineItem.addNumberOfTasks(item.getNumberOfTasks()); - break; - } - } - } - -} diff --git a/lib/taskana-core/src/main/java/pro/taskana/impl/ReportLineItem.java b/lib/taskana-core/src/main/java/pro/taskana/impl/ReportLineItem.java deleted file mode 100644 index 12ee6fc57..000000000 --- a/lib/taskana-core/src/main/java/pro/taskana/impl/ReportLineItem.java +++ /dev/null @@ -1,36 +0,0 @@ -package pro.taskana.impl; - -/** - * Each ReportLineItem consists of a {@link ReportLineItemDefinition} that defines the upper and lower age limits of - * this item and a number of tasks of this item. - */ -public class ReportLineItem { - - private ReportLineItemDefinition reportLineItemDefinition; - private int numberOfTasks; - - public ReportLineItem() { - this.numberOfTasks = 0; - } - - public ReportLineItemDefinition getReportLineItemDefinition() { - return reportLineItemDefinition; - } - - public void setReportLineItemDefinition(ReportLineItemDefinition reportLineItemDefinition) { - this.reportLineItemDefinition = reportLineItemDefinition; - } - - public int getNumberOfTasks() { - return numberOfTasks; - } - - public void setNumberOfTasks(int numberOfTasks) { - this.numberOfTasks = numberOfTasks; - } - - public void addNumberOfTasks(int numberOfTasks) { - this.numberOfTasks += numberOfTasks; - } - -} diff --git a/lib/taskana-core/src/main/java/pro/taskana/impl/TaskMonitorServiceImpl.java b/lib/taskana-core/src/main/java/pro/taskana/impl/TaskMonitorServiceImpl.java index e2a10a19e..64738f365 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/impl/TaskMonitorServiceImpl.java +++ b/lib/taskana-core/src/main/java/pro/taskana/impl/TaskMonitorServiceImpl.java @@ -11,6 +11,15 @@ import pro.taskana.TaskMonitorService; import pro.taskana.TaskState; import pro.taskana.TaskanaEngine; import pro.taskana.exceptions.InvalidArgumentException; +import pro.taskana.impl.report.impl.CategoryReport; +import pro.taskana.impl.report.impl.ClassificationReport; +import pro.taskana.impl.report.impl.CustomFieldValueReport; +import pro.taskana.impl.report.impl.DaysToWorkingDaysPreProcessor; +import pro.taskana.impl.report.impl.DetailedClassificationReport; +import pro.taskana.impl.report.impl.DetailedMonitorQueryItem; +import pro.taskana.impl.report.impl.MonitorQueryItem; +import pro.taskana.impl.report.impl.TimeIntervalColumnHeader; +import pro.taskana.impl.report.impl.WorkbasketLevelReport; import pro.taskana.impl.util.LoggerUtils; import pro.taskana.mappings.TaskMonitorMapper; @@ -30,32 +39,32 @@ public class TaskMonitorServiceImpl implements TaskMonitorService { } @Override - public Report getWorkbasketLevelReport(List workbasketIds, List states, + public WorkbasketLevelReport getWorkbasketLevelReport(List workbasketIds, List states, List categories, List domains, CustomField customField, List customFieldValues) throws InvalidArgumentException { return getWorkbasketLevelReport(workbasketIds, states, categories, domains, customField, customFieldValues, - null, false); + Collections.emptyList(), false); } @Override - public Report getWorkbasketLevelReport(List workbasketIds, List states, + public WorkbasketLevelReport getWorkbasketLevelReport(List workbasketIds, List states, List categories, List domains, CustomField customField, List customFieldValues, - List reportLineItemDefinitions) throws InvalidArgumentException { + List columnHeaders) throws InvalidArgumentException { return getWorkbasketLevelReport(workbasketIds, states, categories, domains, customField, customFieldValues, - reportLineItemDefinitions, true); + columnHeaders, true); } @Override - public Report getWorkbasketLevelReport(List workbasketIds, List states, + public WorkbasketLevelReport getWorkbasketLevelReport(List workbasketIds, List states, List categories, List domains, CustomField customField, List customFieldValues, - List reportLineItemDefinitions, boolean inWorkingDays) + List columnHeaders, boolean inWorkingDays) throws InvalidArgumentException { if (LOGGER.isDebugEnabled()) { LOGGER.debug("entry to getWorkbasketLevelReport(workbasketIds = {}, states = {}, categories = {}, " - + "domains = {}, customField = {}, customFieldValues = {}, reportLineItemDefinitions = {}, " - + "inWorkingDays = {})", LoggerUtils.listToString(workbasketIds), LoggerUtils.listToString(states), + + "domains = {}, customField = {}, customFieldValues = {}, columnHeaders = {}, " + + "inWorkingDays = {})", LoggerUtils.listToString(workbasketIds), LoggerUtils.listToString(states), LoggerUtils.listToString(categories), LoggerUtils.listToString(domains), customField, - LoggerUtils.listToString(customFieldValues), LoggerUtils.listToString(reportLineItemDefinitions), + LoggerUtils.listToString(customFieldValues), LoggerUtils.listToString(columnHeaders), inWorkingDays); } try { @@ -63,10 +72,16 @@ public class TaskMonitorServiceImpl implements TaskMonitorService { configureDaysToWorkingDaysConverter(); - Report report = new Report(); - List monitorQueryItems = taskMonitorMapper.getTaskCountOfWorkbaskets(workbasketIds, - states, categories, domains, customField, customFieldValues); - report.addMonitoringQueryItems(monitorQueryItems, reportLineItemDefinitions, inWorkingDays); + WorkbasketLevelReport report = new WorkbasketLevelReport(columnHeaders); + List monitorQueryItems = taskMonitorMapper.getTaskCountOfWorkbaskets( + workbasketIds, states, categories, domains, customField, customFieldValues); + + if (inWorkingDays) { + report.addItems(monitorQueryItems, new DaysToWorkingDaysPreProcessor<>(columnHeaders)); + } else { + report.addItems(monitorQueryItems); + } + return report; } finally { @@ -76,32 +91,31 @@ public class TaskMonitorServiceImpl implements TaskMonitorService { } @Override - public Report getCategoryReport(List workbasketIds, List states, List categories, + public CategoryReport getCategoryReport(List workbasketIds, List states, List categories, List domains, CustomField customField, List customFieldValues) throws InvalidArgumentException { - return getCategoryReport(workbasketIds, states, categories, domains, customField, customFieldValues, null, + return getCategoryReport(workbasketIds, states, categories, domains, customField, customFieldValues, + Collections.emptyList(), false); } @Override - public Report getCategoryReport(List workbasketIds, List states, List categories, + public CategoryReport getCategoryReport(List workbasketIds, List states, List categories, List domains, CustomField customField, List customFieldValues, - List reportLineItemDefinitions) - throws InvalidArgumentException { + List columnHeaders) throws InvalidArgumentException { return getCategoryReport(workbasketIds, states, categories, domains, customField, customFieldValues, - reportLineItemDefinitions, true); + columnHeaders, true); } @Override - public Report getCategoryReport(List workbasketIds, List states, List categories, + public CategoryReport getCategoryReport(List workbasketIds, List states, List categories, List domains, CustomField customField, List customFieldValues, - List reportLineItemDefinitions, boolean inWorkingDays) - throws InvalidArgumentException { + List columnHeaders, boolean inWorkingDays) throws InvalidArgumentException { if (LOGGER.isDebugEnabled()) { LOGGER.debug("entry to getCategoryReport(workbasketIds = {}, states = {}, categories = {}, " - + "domains = {}, customField = {}, customFieldValues = {}, reportLineItemDefinitions = {}, " - + "inWorkingDays = {})", LoggerUtils.listToString(workbasketIds), LoggerUtils.listToString(states), + + "domains = {}, customField = {}, customFieldValues = {}, reportLineItemDefinitions = {}, " + + "inWorkingDays = {})", LoggerUtils.listToString(workbasketIds), LoggerUtils.listToString(states), LoggerUtils.listToString(categories), LoggerUtils.listToString(domains), customField, - LoggerUtils.listToString(customFieldValues), LoggerUtils.listToString(reportLineItemDefinitions), + LoggerUtils.listToString(customFieldValues), LoggerUtils.listToString(columnHeaders), inWorkingDays); } try { @@ -109,10 +123,16 @@ public class TaskMonitorServiceImpl implements TaskMonitorService { configureDaysToWorkingDaysConverter(); - Report report = new Report(); - List monitorQueryItems = taskMonitorMapper.getTaskCountOfCategories(workbasketIds, states, - categories, domains, customField, customFieldValues); - report.addMonitoringQueryItems(monitorQueryItems, reportLineItemDefinitions, inWorkingDays); + CategoryReport report = new CategoryReport(columnHeaders); + List monitorQueryItems = taskMonitorMapper.getTaskCountOfCategories( + workbasketIds, states, categories, domains, customField, customFieldValues); + + if (inWorkingDays) { + report.addItems(monitorQueryItems, new DaysToWorkingDaysPreProcessor<>(columnHeaders)); + } else { + report.addItems(monitorQueryItems); + } + return report; } finally { @@ -125,29 +145,29 @@ public class TaskMonitorServiceImpl implements TaskMonitorService { public ClassificationReport getClassificationReport(List workbasketIds, List states, List categories, List domains, CustomField customField, List customFieldValues) throws InvalidArgumentException { - return getClassificationReport(workbasketIds, states, categories, domains, customField, customFieldValues, null, - false); - } - - @Override - public ClassificationReport getClassificationReport(List workbasketIds, List states, - List categories, List domains, CustomField customField, List customFieldValues, - List reportLineItemDefinitions) throws InvalidArgumentException { return getClassificationReport(workbasketIds, states, categories, domains, customField, customFieldValues, - reportLineItemDefinitions, true); + Collections.emptyList(), false); } @Override public ClassificationReport getClassificationReport(List workbasketIds, List states, List categories, List domains, CustomField customField, List customFieldValues, - List reportLineItemDefinitions, boolean inWorkingDays) + List columnHeaders) throws InvalidArgumentException { + return getClassificationReport(workbasketIds, states, categories, domains, customField, customFieldValues, + columnHeaders, true); + } + + @Override + public ClassificationReport getClassificationReport(List workbasketIds, List states, + List categories, List domains, CustomField customField, List customFieldValues, + List columnHeaders, boolean inWorkingDays) throws InvalidArgumentException { if (LOGGER.isDebugEnabled()) { LOGGER.debug("entry to getClassificationReport(workbasketIds = {}, states = {}, categories = {}, " - + "domains = {}, customField = {}, customFieldValues = {}, reportLineItemDefinitions = {}, " - + "inWorkingDays = {})", LoggerUtils.listToString(workbasketIds), LoggerUtils.listToString(states), + + "domains = {}, customField = {}, customFieldValues = {}, columnHeaders = {}, " + + "inWorkingDays = {})", LoggerUtils.listToString(workbasketIds), LoggerUtils.listToString(states), LoggerUtils.listToString(categories), LoggerUtils.listToString(domains), customField, - LoggerUtils.listToString(customFieldValues), LoggerUtils.listToString(reportLineItemDefinitions), + LoggerUtils.listToString(customFieldValues), LoggerUtils.listToString(columnHeaders), inWorkingDays); } try { @@ -155,10 +175,16 @@ public class TaskMonitorServiceImpl implements TaskMonitorService { configureDaysToWorkingDaysConverter(); - ClassificationReport report = new ClassificationReport(); - List monitorQueryItems = taskMonitorMapper.getTaskCountOfClassifications(workbasketIds, - states, categories, domains, customField, customFieldValues); - report.addMonitoringQueryItems(monitorQueryItems, reportLineItemDefinitions, inWorkingDays); + ClassificationReport report = new ClassificationReport(columnHeaders); + List monitorQueryItems = taskMonitorMapper.getTaskCountOfClassifications( + workbasketIds, states, categories, domains, customField, customFieldValues); + + if (inWorkingDays) { + report.addItems(monitorQueryItems, new DaysToWorkingDaysPreProcessor<>(columnHeaders)); + } else { + report.addItems(monitorQueryItems); + } + return report; } finally { @@ -172,43 +198,48 @@ public class TaskMonitorServiceImpl implements TaskMonitorService { List states, List categories, List domains, CustomField customField, List customFieldValues) throws InvalidArgumentException { return getDetailedClassificationReport(workbasketIds, states, categories, domains, customField, - customFieldValues, null, false); + customFieldValues, Collections.emptyList(), false); } @Override public DetailedClassificationReport getDetailedClassificationReport(List workbasketIds, List states, List categories, List domains, CustomField customField, - List customFieldValues, List reportLineItemDefinitions) + List customFieldValues, List columnHeaders) throws InvalidArgumentException { return getDetailedClassificationReport(workbasketIds, states, categories, domains, customField, - customFieldValues, reportLineItemDefinitions, true); + customFieldValues, columnHeaders, true); } @Override public DetailedClassificationReport getDetailedClassificationReport(List workbasketIds, List states, List categories, List domains, CustomField customField, - List customFieldValues, List reportLineItemDefinitions, boolean inWorkingDays) + List customFieldValues, List columnHeaders, boolean inWorkingDays) throws InvalidArgumentException { if (LOGGER.isDebugEnabled()) { LOGGER.debug("entry to getDetailedClassificationReport(workbasketIds = {}, states = {}, " - + "categories = {}, domains = {}, customField = {}, customFieldValues = {}, " - + "reportLineItemDefinitions = {}, inWorkingDays = {})", LoggerUtils.listToString(workbasketIds), + + "categories = {}, domains = {}, customField = {}, customFieldValues = {}, " + + "columnHeaders = {}, inWorkingDays = {})", LoggerUtils.listToString(workbasketIds), LoggerUtils.listToString(states), LoggerUtils.listToString(categories), LoggerUtils.listToString(domains), customField, LoggerUtils.listToString(customFieldValues), - LoggerUtils.listToString(reportLineItemDefinitions), inWorkingDays); + LoggerUtils.listToString(columnHeaders), inWorkingDays); } try { taskanaEngineImpl.openConnection(); configureDaysToWorkingDaysConverter(); - DetailedClassificationReport report = new DetailedClassificationReport(); + DetailedClassificationReport report = new DetailedClassificationReport(columnHeaders); List detailedMonitorQueryItems = taskMonitorMapper .getTaskCountOfDetailedClassifications(workbasketIds, states, categories, domains, customField, customFieldValues); - report.addDetailedMonitoringQueryItems(detailedMonitorQueryItems, reportLineItemDefinitions, - inWorkingDays); + + if (inWorkingDays) { + report.addItems(detailedMonitorQueryItems, new DaysToWorkingDaysPreProcessor<>(columnHeaders)); + } else { + report.addItems(detailedMonitorQueryItems); + } + return report; } finally { @@ -218,32 +249,32 @@ public class TaskMonitorServiceImpl implements TaskMonitorService { } @Override - public Report getCustomFieldValueReport(List workbasketIds, List states, + public CustomFieldValueReport getCustomFieldValueReport(List workbasketIds, List states, List categories, List domains, CustomField customField, List customFieldValues) throws InvalidArgumentException { return getCustomFieldValueReport(workbasketIds, states, categories, domains, customField, customFieldValues, - null, false); + Collections.emptyList(), false); } @Override - public Report getCustomFieldValueReport(List workbasketIds, List states, + public CustomFieldValueReport getCustomFieldValueReport(List workbasketIds, List states, List categories, List domains, CustomField customField, List customFieldValues, - List reportLineItemDefinitions) throws InvalidArgumentException { + List columnHeaders) throws InvalidArgumentException { return getCustomFieldValueReport(workbasketIds, states, categories, domains, customField, customFieldValues, - reportLineItemDefinitions, true); + columnHeaders, true); } @Override - public Report getCustomFieldValueReport(List workbasketIds, List states, + public CustomFieldValueReport getCustomFieldValueReport(List workbasketIds, List states, List categories, List domains, CustomField customField, List customFieldValues, - List reportLineItemDefinitions, boolean inWorkingDays) + List columnHeaders, boolean inWorkingDays) throws InvalidArgumentException { if (LOGGER.isDebugEnabled()) { LOGGER.debug("entry to getCustomFieldValueReport(workbasketIds = {}, states = {}, categories = {}, " - + "domains = {}, customField = {}, customFieldValues = {}, reportLineItemDefinitions = {}, " - + "inWorkingDays = {})", LoggerUtils.listToString(workbasketIds), LoggerUtils.listToString(states), + + "domains = {}, customField = {}, customFieldValues = {}, columnHeaders = {}, " + + "inWorkingDays = {})", LoggerUtils.listToString(workbasketIds), LoggerUtils.listToString(states), LoggerUtils.listToString(categories), LoggerUtils.listToString(domains), customField, - LoggerUtils.listToString(customFieldValues), LoggerUtils.listToString(reportLineItemDefinitions), + LoggerUtils.listToString(customFieldValues), LoggerUtils.listToString(columnHeaders), inWorkingDays); } try { @@ -255,10 +286,16 @@ public class TaskMonitorServiceImpl implements TaskMonitorService { configureDaysToWorkingDaysConverter(); - Report report = new Report(); - List monitorQueryItems = taskMonitorMapper.getTaskCountOfCustomFieldValues(workbasketIds, - states, categories, domains, customField, customFieldValues); - report.addMonitoringQueryItems(monitorQueryItems, reportLineItemDefinitions, inWorkingDays); + CustomFieldValueReport report = new CustomFieldValueReport(columnHeaders); + List monitorQueryItems = taskMonitorMapper.getTaskCountOfCustomFieldValues( + workbasketIds, states, categories, domains, customField, customFieldValues); + + if (inWorkingDays) { + report.addItems(monitorQueryItems, new DaysToWorkingDaysPreProcessor<>(columnHeaders)); + } else { + report.addItems(monitorQueryItems); + } + return report; } finally { @@ -270,30 +307,30 @@ public class TaskMonitorServiceImpl implements TaskMonitorService { @Override public List getTaskIdsOfCategoryReportLineItems(List workbasketIds, List states, List categories, List domains, CustomField customField, List customFieldValues, - List reportLineItemDefinitions, List selectedItems) + List columnHeaders, List selectedItems) throws InvalidArgumentException { return getTaskIdsOfCategoryReportLineItems(workbasketIds, states, categories, domains, customField, - customFieldValues, reportLineItemDefinitions, true, selectedItems); + customFieldValues, columnHeaders, true, selectedItems); } @Override public List getTaskIdsOfCategoryReportLineItems(List workbasketIds, List states, List categories, List domains, CustomField customField, List customFieldValues, - List reportLineItemDefinitions, boolean inWorkingDays, + List columnHeaders, boolean inWorkingDays, List selectedItems) throws InvalidArgumentException { if (LOGGER.isDebugEnabled()) { LOGGER.debug("entry to getTaskIdsOfCategoryReportLineItems(workbasketIds = {}, states = {}, " - + "categories = {}, domains = {}, customField = {}, customFieldValues = {}, " - + "reportLineItemDefinitions = {}, inWorkingDays = {}, selectedItems = {})", + + "categories = {}, domains = {}, customField = {}, customFieldValues = {}, " + + "columnHeaders = {}, inWorkingDays = {}, selectedItems = {})", LoggerUtils.listToString(workbasketIds), LoggerUtils.listToString(states), LoggerUtils.listToString(categories), LoggerUtils.listToString(domains), customField, - LoggerUtils.listToString(customFieldValues), LoggerUtils.listToString(reportLineItemDefinitions), + LoggerUtils.listToString(customFieldValues), LoggerUtils.listToString(columnHeaders), inWorkingDays, LoggerUtils.listToString(selectedItems)); } try { taskanaEngineImpl.openConnection(); - if (reportLineItemDefinitions == null) { + if (columnHeaders == null) { throw new InvalidArgumentException("ReportLineItemDefinitions can´t be used as NULL-Parameter"); } if (selectedItems == null || selectedItems.size() == 0) { @@ -304,7 +341,7 @@ public class TaskMonitorServiceImpl implements TaskMonitorService { configureDaysToWorkingDaysConverter(); if (inWorkingDays) { - selectedItems = convertWorkingDaysToDays(selectedItems, reportLineItemDefinitions); + selectedItems = convertWorkingDaysToDays(selectedItems, columnHeaders); } List taskIds = taskMonitorMapper.getTaskIdsOfCategoriesBySelectedItems(workbasketIds, states, @@ -319,9 +356,9 @@ public class TaskMonitorServiceImpl implements TaskMonitorService { } private List convertWorkingDaysToDays(List selectedItems, - List reportLineItemDefinitions) throws InvalidArgumentException { + List columnHeaders) throws InvalidArgumentException { - DaysToWorkingDaysConverter instance = DaysToWorkingDaysConverter.initialize(reportLineItemDefinitions); + DaysToWorkingDaysConverter instance = DaysToWorkingDaysConverter.initialize(columnHeaders); for (SelectedItem selectedItem : selectedItems) { selectedItem .setLowerAgeLimit(Collections.min(instance.convertWorkingDaysToDays(selectedItem.getLowerAgeLimit()))); diff --git a/lib/taskana-core/src/main/java/pro/taskana/impl/TaskServiceImpl.java b/lib/taskana-core/src/main/java/pro/taskana/impl/TaskServiceImpl.java index 7cf33e0dc..47bc0ef93 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/impl/TaskServiceImpl.java +++ b/lib/taskana-core/src/main/java/pro/taskana/impl/TaskServiceImpl.java @@ -4,6 +4,7 @@ import java.time.Duration; import java.time.Instant; import java.util.ArrayList; import java.util.Arrays; +import java.util.Collections; import java.util.HashSet; import java.util.Iterator; import java.util.List; @@ -42,6 +43,7 @@ import pro.taskana.exceptions.TaskAlreadyExistException; import pro.taskana.exceptions.TaskNotFoundException; import pro.taskana.exceptions.TaskanaException; import pro.taskana.exceptions.WorkbasketNotFoundException; +import pro.taskana.impl.report.impl.TimeIntervalColumnHeader; import pro.taskana.impl.util.IdGenerator; import pro.taskana.impl.util.LoggerUtils; import pro.taskana.mappings.AttachmentMapper; @@ -72,7 +74,7 @@ public class TaskServiceImpl implements TaskService { super(); try { this.converter = DaysToWorkingDaysConverter - .initialize(new ArrayList<>(Arrays.asList(new ReportLineItemDefinition(0))), Instant.now()); + .initialize(Collections.singletonList(new TimeIntervalColumnHeader(0)), Instant.now()); } catch (InvalidArgumentException e) { LOGGER.error("could not initialize DaysToWorkingDaysConverter. Caught exception " + e); throw new SystemException("Internal error. Cannot initialize DaysToWorkingDaysConverter"); diff --git a/lib/taskana-core/src/main/java/pro/taskana/impl/report/QueryItem.java b/lib/taskana-core/src/main/java/pro/taskana/impl/report/QueryItem.java index 739282a3d..8082908c3 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/impl/report/QueryItem.java +++ b/lib/taskana-core/src/main/java/pro/taskana/impl/report/QueryItem.java @@ -1,9 +1,14 @@ package pro.taskana.impl.report; +/** + * A QueryItem is en entity on which a {@link Report} is based on. + * Its value will be added to the existing cell value during the insertion into a report. + * Its key will determine in which {@link ReportRow} the item will be inserted. + */ public interface QueryItem { String getKey(); int getValue(); -} \ No newline at end of file +} diff --git a/lib/taskana-core/src/main/java/pro/taskana/impl/report/QueryItemPreprocessor.java b/lib/taskana-core/src/main/java/pro/taskana/impl/report/QueryItemPreprocessor.java new file mode 100644 index 000000000..b4bfbc42d --- /dev/null +++ b/lib/taskana-core/src/main/java/pro/taskana/impl/report/QueryItemPreprocessor.java @@ -0,0 +1,13 @@ +package pro.taskana.impl.report; + +/** + * The QueryItemPreprocessor is used when adding {@link QueryItem}s into a {@link Report}. It defines a processing + * step which is executed on each {@link QueryItem} before inserting it into the {@link Report}. + * @param Item class which is being pre processed. + */ +@FunctionalInterface +public interface QueryItemPreprocessor { + + Item apply(Item item); + +} diff --git a/lib/taskana-core/src/main/java/pro/taskana/impl/report/Report.java b/lib/taskana-core/src/main/java/pro/taskana/impl/report/Report.java index 8928123d8..77f90dc20 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/impl/report/Report.java +++ b/lib/taskana-core/src/main/java/pro/taskana/impl/report/Report.java @@ -4,45 +4,70 @@ import java.util.ArrayList; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; +import java.util.Set; -public abstract class Report> { +/** + * A Report represents a an abstract table that consists of {@link ReportRow}s and a list of <ColumnHeader>s. + * Since a report does not specify <Item> and <ColumnHeader> it does not contain functional logic. + * Due to readability implicit definition of functional logic is prevented and thus prevent + * initialization of an abstract Report. In order to create a specific Report a subclass has to be created. + * + * @param {@link QueryItem} whose value is relevant for this report. + * @param {@link ReportColumnHeader} which can determine if an <Item> belongs into that column or not. + */ +public abstract class Report> { - protected List columns = new ArrayList<>(); //this can be done as an array - private Map> reportLines = new LinkedHashMap<>(); - private ReportRow sumLine; + protected List columnHeaders = new ArrayList<>(); + private Map> reportRows = new LinkedHashMap<>(); + private ReportRow sumRow; - public Report(List columns) { - sumLine = new ReportRow<>(columns.size()); - this.columns.addAll(columns); + public Report(List columnHeaders) { + sumRow = new ReportRow<>(columnHeaders.size()); + this.columnHeaders.addAll(columnHeaders); } - protected final void addItem(Item item) { - ReportRow row = reportLines.computeIfAbsent(item.getKey(), (s) -> createReportRow(columns.size())); - for (int i = 0; i < columns.size(); i++) { - if (columns.get(i).fits(item)) { - row.addItem(item, i); - sumLine.addItem(item, i); + public final void addItem(Item item) { + ReportRow row = reportRows.computeIfAbsent(item.getKey(), (s) -> createReportRow(columnHeaders.size())); + if (columnHeaders.isEmpty()) { + row.updateTotalValue(item); + sumRow.updateTotalValue(item); + } else { + for (int i = 0; i < columnHeaders.size(); i++) { + if (columnHeaders.get(i).fits(item)) { + row.addItem(item, i); + sumRow.addItem(item, i); + } } } } - public ReportRow getRow(String key) { - return reportLines.get(key); + public final void addItems(List items, QueryItemPreprocessor preprocessor) { + items.stream() + .map(preprocessor::apply) + .forEach(this::addItem); } - public void addItems(List items) { + public final void addItems(List items) { items.forEach(this::addItem); } - public final ReportRow getSumLine() { - return sumLine; + public ReportRow getRow(String key) { + return reportRows.get(key); } - public Map> getReportLines() { - return reportLines; + public final ReportRow getSumRow() { + return sumRow; + } + + public Set getRowTitles() { + return reportRows.keySet(); + } + + public final int rowSize() { + return reportRows.size(); } protected ReportRow createReportRow(int columnSize) { return new ReportRow<>(columnSize); } -} \ No newline at end of file +} diff --git a/lib/taskana-core/src/main/java/pro/taskana/impl/report/ReportColumnHeader.java b/lib/taskana-core/src/main/java/pro/taskana/impl/report/ReportColumnHeader.java index 0d0739364..188b83b77 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/impl/report/ReportColumnHeader.java +++ b/lib/taskana-core/src/main/java/pro/taskana/impl/report/ReportColumnHeader.java @@ -1,9 +1,15 @@ package pro.taskana.impl.report; +/** + * A ReportColumnHeader is an element of a {@link Report}. + * It determines weather a given <Item> belongs into the representing column. + * + * @param {@link QueryItem} on which the {@link Report} is based on. + */ public interface ReportColumnHeader { String displayName(); boolean fits(Item item); -} \ No newline at end of file +} diff --git a/lib/taskana-core/src/main/java/pro/taskana/impl/report/ReportRow.java b/lib/taskana-core/src/main/java/pro/taskana/impl/report/ReportRow.java index 3853847bd..a499238d1 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/impl/report/ReportRow.java +++ b/lib/taskana-core/src/main/java/pro/taskana/impl/report/ReportRow.java @@ -1,25 +1,34 @@ package pro.taskana.impl.report; +/** + * A ReportRow represents a row in a {@link Report}. + * It contains an array of cells whose index corresponds to the {@link ReportColumnHeader} index in the {@link Report}. + * + * @param {@link QueryItem} on which the {@link Report} is based on. + */ public class ReportRow { - private final int[] lineItems; + private final int[] cells; private int totalValue = 0; public ReportRow(int columnCount) { - //TODO: do you use an assert / throw an exception? - lineItems = new int[columnCount]; + cells = new int[columnCount]; } - public int[] getLineItems() { - return lineItems; + public int[] getCells() { + return cells; } public int getTotalValue() { return totalValue; } + public void updateTotalValue(Item item) { + totalValue += item.getValue(); + } + public void addItem(Item item, int index) throws IndexOutOfBoundsException { totalValue += item.getValue(); - lineItems[index] += item.getValue(); + cells[index] += item.getValue(); } -} \ No newline at end of file +} diff --git a/lib/taskana-core/src/main/java/pro/taskana/impl/report/impl/CategoryReport.java b/lib/taskana-core/src/main/java/pro/taskana/impl/report/impl/CategoryReport.java new file mode 100644 index 000000000..468a2bfdb --- /dev/null +++ b/lib/taskana-core/src/main/java/pro/taskana/impl/report/impl/CategoryReport.java @@ -0,0 +1,16 @@ +package pro.taskana.impl.report.impl; + +import java.util.List; + +import pro.taskana.impl.report.Report; + +/** + * TODO. + */ +public class CategoryReport extends Report { + + public CategoryReport(List timeIntervalColumnHeaders) { + super(timeIntervalColumnHeaders); + } + +} diff --git a/lib/taskana-core/src/main/java/pro/taskana/impl/report/impl/ClassificationReport.java b/lib/taskana-core/src/main/java/pro/taskana/impl/report/impl/ClassificationReport.java new file mode 100644 index 000000000..c49357317 --- /dev/null +++ b/lib/taskana-core/src/main/java/pro/taskana/impl/report/impl/ClassificationReport.java @@ -0,0 +1,17 @@ +package pro.taskana.impl.report.impl; + +import java.util.List; + +import pro.taskana.impl.report.Report; + +/** + * The ClassificationReport extends the Report. The {@link pro.taskana.impl.report.ReportRow}s of the ClassificationReport are grouped by + * classifications. + */ +public class ClassificationReport extends Report { + + public ClassificationReport(List timeIntervalColumnHeaders) { + super(timeIntervalColumnHeaders); + } + +} diff --git a/lib/taskana-core/src/main/java/pro/taskana/impl/report/impl/CustomFieldValueReport.java b/lib/taskana-core/src/main/java/pro/taskana/impl/report/impl/CustomFieldValueReport.java new file mode 100644 index 000000000..38c8a1235 --- /dev/null +++ b/lib/taskana-core/src/main/java/pro/taskana/impl/report/impl/CustomFieldValueReport.java @@ -0,0 +1,15 @@ +package pro.taskana.impl.report.impl; + +import java.util.List; + +import pro.taskana.impl.report.Report; + +/** + * TODO. + */ +public class CustomFieldValueReport extends Report { + + public CustomFieldValueReport(List timeIntervalColumnHeaders) { + super(timeIntervalColumnHeaders); + } +} diff --git a/lib/taskana-core/src/main/java/pro/taskana/impl/report/impl/DaysToWorkingDaysPreProcessor.java b/lib/taskana-core/src/main/java/pro/taskana/impl/report/impl/DaysToWorkingDaysPreProcessor.java new file mode 100644 index 000000000..238b0c85b --- /dev/null +++ b/lib/taskana-core/src/main/java/pro/taskana/impl/report/impl/DaysToWorkingDaysPreProcessor.java @@ -0,0 +1,27 @@ +package pro.taskana.impl.report.impl; + +import java.util.List; + +import pro.taskana.exceptions.InvalidArgumentException; +import pro.taskana.impl.DaysToWorkingDaysConverter; +import pro.taskana.impl.report.QueryItemPreprocessor; + +/** + * Uses {@link DaysToWorkingDaysConverter} to convert an <Item>s age to working days. + * @param QueryItem which is being processed + */ +public class DaysToWorkingDaysPreProcessor implements QueryItemPreprocessor { + + private DaysToWorkingDaysConverter instance; + + public DaysToWorkingDaysPreProcessor(List columnHeaders) + throws InvalidArgumentException { + instance = DaysToWorkingDaysConverter.initialize(columnHeaders); + } + + @Override + public Item apply(Item item) { + item.setAgeInDays(instance.convertDaysToWorkingDays(item.getAgeInDays())); + return item; + } +} diff --git a/lib/taskana-core/src/main/java/pro/taskana/impl/report/impl/DetailedClassificationReport.java b/lib/taskana-core/src/main/java/pro/taskana/impl/report/impl/DetailedClassificationReport.java new file mode 100644 index 000000000..efba8d417 --- /dev/null +++ b/lib/taskana-core/src/main/java/pro/taskana/impl/report/impl/DetailedClassificationReport.java @@ -0,0 +1,28 @@ +package pro.taskana.impl.report.impl; + +import java.util.List; + +import pro.taskana.impl.report.Report; + +/** + * The DetailedClassificationReport is a functional extension of the {@link ClassificationReport}. + * Its {@link DetailedReportRow}s contain an additional list of {@link pro.taskana.impl.report.ReportRow}s + * for the classifications of the attachments of the tasks. + */ +public class DetailedClassificationReport extends Report { + + public DetailedClassificationReport(List workbasketLevelReportColumnHeaders) { + super(workbasketLevelReportColumnHeaders); + } + + @Override + protected DetailedReportRow createReportRow(int columnSize) { + return new DetailedReportRow(columnSize); + } + + @Override + public DetailedReportRow getRow(String key) { + return (DetailedReportRow) super.getRow(key); + } + +} diff --git a/lib/taskana-core/src/main/java/pro/taskana/impl/DetailedMonitorQueryItem.java b/lib/taskana-core/src/main/java/pro/taskana/impl/report/impl/DetailedMonitorQueryItem.java similarity index 53% rename from lib/taskana-core/src/main/java/pro/taskana/impl/DetailedMonitorQueryItem.java rename to lib/taskana-core/src/main/java/pro/taskana/impl/report/impl/DetailedMonitorQueryItem.java index 4c2d1e34b..570dfc970 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/impl/DetailedMonitorQueryItem.java +++ b/lib/taskana-core/src/main/java/pro/taskana/impl/report/impl/DetailedMonitorQueryItem.java @@ -1,23 +1,19 @@ -package pro.taskana.impl; - -/** - * The DetailedMonitorQueryItem extends the MonitorQueryItem. The additional attachment key is used for the detailed - * classification report. - */ -public class DetailedMonitorQueryItem extends MonitorQueryItem { - - private String attachmentKey; - - public DetailedMonitorQueryItem() { - super(); - } - - public String getAttachmentKey() { - return attachmentKey; - } - - public void setAttachmentKey(String attachmentKey) { - this.attachmentKey = attachmentKey; - } - -} +package pro.taskana.impl.report.impl; + +/** + * The DetailedMonitorQueryItem extends the {@link MonitorQueryItem}. + * The additional attachment key is used for the detailed classification report. + */ +public class DetailedMonitorQueryItem extends MonitorQueryItem { + + private String attachmentKey; + + public String getAttachmentKey() { + return attachmentKey; + } + + public void setAttachmentKey(String attachmentKey) { + this.attachmentKey = attachmentKey; + } + +} diff --git a/lib/taskana-core/src/main/java/pro/taskana/impl/report/impl/DetailedReportRow.java b/lib/taskana-core/src/main/java/pro/taskana/impl/report/impl/DetailedReportRow.java new file mode 100644 index 000000000..872a1388b --- /dev/null +++ b/lib/taskana-core/src/main/java/pro/taskana/impl/report/impl/DetailedReportRow.java @@ -0,0 +1,53 @@ +package pro.taskana.impl.report.impl; + +import java.util.LinkedHashMap; +import java.util.Map; + +import pro.taskana.impl.report.ReportRow; + +/** + * The DetailedReportRow extends the {@link ReportRow}. + * In contrast to the ReportRow there is an additional list of ReportRows for the classifications of the + * attachments of the tasks. + */ +public class DetailedReportRow extends ReportRow { + + private Map> detailRows = new LinkedHashMap<>(); + private int columnCount; + + public DetailedReportRow(int columnCount) { + super(columnCount); + this.columnCount = columnCount; + } + + public Map> getDetailRows() { + return detailRows; + } + + @Override + public void updateTotalValue(DetailedMonitorQueryItem item) { + super.updateTotalValue(item); + + if (item.getAttachmentKey() != null) { + detailRows.computeIfAbsent(item.getAttachmentKey(), (s) -> new ReportRow<>(columnCount)) + .updateTotalValue(item); + } else { + detailRows.computeIfAbsent("N/A", (s) -> new ReportRow<>(columnCount)) + .updateTotalValue(item); + } + } + + @Override + public void addItem(DetailedMonitorQueryItem item, int index) { + super.addItem(item, index); + + if (item.getAttachmentKey() != null) { + detailRows.computeIfAbsent(item.getAttachmentKey(), (s) -> new ReportRow<>(columnCount)) + .addItem(item, index); + } else { + detailRows.computeIfAbsent("N/A", (s) -> new ReportRow<>(columnCount)) + .addItem(item, index); + } + } + +} diff --git a/lib/taskana-core/src/main/java/pro/taskana/impl/MonitorQueryItem.java b/lib/taskana-core/src/main/java/pro/taskana/impl/report/impl/MonitorQueryItem.java similarity index 79% rename from lib/taskana-core/src/main/java/pro/taskana/impl/MonitorQueryItem.java rename to lib/taskana-core/src/main/java/pro/taskana/impl/report/impl/MonitorQueryItem.java index cdc968b4c..0ec54303b 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/impl/MonitorQueryItem.java +++ b/lib/taskana-core/src/main/java/pro/taskana/impl/report/impl/MonitorQueryItem.java @@ -1,36 +1,38 @@ -package pro.taskana.impl; - -/** - * The MonitorQueryItem entity contains the number of tasks for a key (e.g. workbasketKey) and age in days. - */ -public class MonitorQueryItem { - - private String key; - private int ageInDays; - private int numberOfTasks; - - public String getKey() { - return key; - } - - public void setKey(String key) { - this.key = key; - } - - public int getAgeInDays() { - return ageInDays; - } - - public void setAgeInDays(int ageInDays) { - this.ageInDays = ageInDays; - } - - public int getNumberOfTasks() { - return numberOfTasks; - } - - public void setNumberOfTasks(int numberOfTasks) { - this.numberOfTasks = numberOfTasks; - } - -} +package pro.taskana.impl.report.impl; + +import pro.taskana.impl.report.QueryItem; + +/** + * The MonitorQueryItem entity contains the number of tasks for a key (e.g. workbasketKey) and age in days. + */ +public class MonitorQueryItem implements QueryItem { + + private String key; + private int ageInDays; + private int numberOfTasks; + + public String getKey() { + return key; + } + + public void setKey(String key) { + this.key = key; + } + + public int getAgeInDays() { + return ageInDays; + } + + public void setAgeInDays(int ageInDays) { + this.ageInDays = ageInDays; + } + + public int getValue() { + return numberOfTasks; + } + + public void setNumberOfTasks(int numberOfTasks) { + this.numberOfTasks = numberOfTasks; + } + +} diff --git a/lib/taskana-core/src/main/java/pro/taskana/impl/ReportLineItemDefinition.java b/lib/taskana-core/src/main/java/pro/taskana/impl/report/impl/TimeIntervalColumnHeader.java similarity index 51% rename from lib/taskana-core/src/main/java/pro/taskana/impl/ReportLineItemDefinition.java rename to lib/taskana-core/src/main/java/pro/taskana/impl/report/impl/TimeIntervalColumnHeader.java index 6783cfb36..28932a2a8 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/impl/ReportLineItemDefinition.java +++ b/lib/taskana-core/src/main/java/pro/taskana/impl/report/impl/TimeIntervalColumnHeader.java @@ -1,49 +1,50 @@ -package pro.taskana.impl; - -/** - * A ReportLineItemDefinition has a lower and an upper age limit which subdivide the count of tasks into different - * sections. Days in past are represented as negative values and days in the future are represented as positive values. - * To avoid tasks are counted multiple times or not be listed in the report, these reportLineItemDefinitions should not - * overlap and should not have gaps. If the ReportLineDefinition should represent a single day, lowerAgeLimit and - * upperAgeLimit have to be equal. The outer cluster of a report should have open ends. These open ends are represented - * with Integer.MIN_VALUE and Integer.MAX_VALUE. - */ -public class ReportLineItemDefinition { - - private int lowerAgeLimit; - private int upperAgeLimit; - - public ReportLineItemDefinition() { - } - - public ReportLineItemDefinition(int ageInDays) { - this.lowerAgeLimit = ageInDays; - this.upperAgeLimit = ageInDays; - } - - public ReportLineItemDefinition(int lowerAgeLimit, int upperAgeLimit) { - this.lowerAgeLimit = lowerAgeLimit; - this.upperAgeLimit = upperAgeLimit; - } - - public int getLowerAgeLimit() { - return lowerAgeLimit; - } - - public void setLowerAgeLimit(int lowerAgeLimit) { - this.lowerAgeLimit = lowerAgeLimit; - } - - public int getUpperAgeLimit() { - return upperAgeLimit; - } - - public void setUpperAgeLimit(int upperAgeLimit) { - this.upperAgeLimit = upperAgeLimit; - } - - @Override - public String toString() { - return "(" + this.lowerAgeLimit + "," + this.upperAgeLimit + ")"; - } -} +package pro.taskana.impl.report.impl; + +import pro.taskana.impl.report.ReportColumnHeader; + +/** + * A TimeIntervalColumnHeader has a lower and an upper age limit which subdivide the count of tasks into different + * sections. Days in past are represented as negative values and days in the future are represented as positive values. + * To avoid tasks are counted multiple times or not be listed in the report, these TimeIntervalColumnHeaders should not + * overlap and should not have gaps. If the TimeIntervalColumnHeader should represent a single day, lowerAgeLimit and + * upperAgeLimit have to be equal. The outer cluster of a report should have open ends. These open ends are represented + * with Integer.MIN_VALUE and Integer.MAX_VALUE. + */ +public class TimeIntervalColumnHeader implements ReportColumnHeader { + + private final int lowerAgeLimit; + private final int upperAgeLimit; + + public TimeIntervalColumnHeader(int ageInDays) { + this.lowerAgeLimit = ageInDays; + this.upperAgeLimit = ageInDays; + } + + public TimeIntervalColumnHeader(int lowerAgeLimit, int upperAgeLimit) { + this.lowerAgeLimit = lowerAgeLimit; + this.upperAgeLimit = upperAgeLimit; + } + + public int getLowerAgeLimit() { + return lowerAgeLimit; + } + + public int getUpperAgeLimit() { + return upperAgeLimit; + } + + @Override + public String toString() { + return displayName(); + } + + @Override + public String displayName() { + return "(" + this.lowerAgeLimit + "," + this.upperAgeLimit + ")"; + } + + @Override + public boolean fits(MonitorQueryItem item) { + return lowerAgeLimit <= item.getAgeInDays() && upperAgeLimit >= item.getAgeInDays(); + } +} diff --git a/lib/taskana-core/src/main/java/pro/taskana/impl/report/impl/WorkbasketLevelReport.java b/lib/taskana-core/src/main/java/pro/taskana/impl/report/impl/WorkbasketLevelReport.java new file mode 100644 index 000000000..4dfb6a7db --- /dev/null +++ b/lib/taskana-core/src/main/java/pro/taskana/impl/report/impl/WorkbasketLevelReport.java @@ -0,0 +1,16 @@ +package pro.taskana.impl.report.impl; + +import java.util.List; + +import pro.taskana.impl.report.Report; + +/** + * TODO. + */ +public class WorkbasketLevelReport extends Report { + + public WorkbasketLevelReport(List timeIntervalColumnHeaders) { + super(timeIntervalColumnHeaders); + } + +} diff --git a/lib/taskana-core/src/main/java/pro/taskana/mappings/TaskMonitorMapper.java b/lib/taskana-core/src/main/java/pro/taskana/mappings/TaskMonitorMapper.java index 79c553c6e..af5a514c7 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/mappings/TaskMonitorMapper.java +++ b/lib/taskana-core/src/main/java/pro/taskana/mappings/TaskMonitorMapper.java @@ -9,9 +9,9 @@ import org.apache.ibatis.annotations.Select; import pro.taskana.CustomField; import pro.taskana.TaskState; -import pro.taskana.impl.DetailedMonitorQueryItem; -import pro.taskana.impl.MonitorQueryItem; import pro.taskana.impl.SelectedItem; +import pro.taskana.impl.report.impl.DetailedMonitorQueryItem; +import pro.taskana.impl.report.impl.MonitorQueryItem; /** * This class is the mybatis mapping of task monitoring. diff --git a/lib/taskana-core/src/test/java/acceptance/monitoring/GetTaskIdsOfCategoryReportAccTest.java b/lib/taskana-core/src/test/java/acceptance/monitoring/GetTaskIdsOfCategoryReportAccTest.java index 41c8544e3..2088a8bdd 100644 --- a/lib/taskana-core/src/test/java/acceptance/monitoring/GetTaskIdsOfCategoryReportAccTest.java +++ b/lib/taskana-core/src/test/java/acceptance/monitoring/GetTaskIdsOfCategoryReportAccTest.java @@ -7,6 +7,7 @@ import java.io.IOException; import java.sql.SQLException; import java.util.ArrayList; import java.util.Arrays; +import java.util.Collections; import java.util.List; import javax.sql.DataSource; @@ -22,11 +23,11 @@ import pro.taskana.TaskanaEngine.ConnectionManagementMode; import pro.taskana.configuration.TaskanaEngineConfiguration; import pro.taskana.database.TestDataGenerator; import pro.taskana.exceptions.InvalidArgumentException; -import pro.taskana.impl.ReportLineItemDefinition; import pro.taskana.impl.SelectedItem; import pro.taskana.impl.TaskanaEngineImpl; import pro.taskana.impl.configuration.DBCleaner; import pro.taskana.impl.configuration.TaskanaEngineConfigurationTest; +import pro.taskana.impl.report.impl.TimeIntervalColumnHeader; /** * Acceptance test for all "get task ids of category report" scenarios. @@ -59,7 +60,7 @@ public class GetTaskIdsOfCategoryReportAccTest { public void testGetTaskIdsOfCategoryReport() throws InvalidArgumentException { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); - List reportLineItemDefinitions = getListOfReportLineItemDefinitions(); + List columnHeaders = getListOfColumnHeaders(); List selectedItems = new ArrayList<>(); @@ -82,7 +83,7 @@ public class GetTaskIdsOfCategoryReportAccTest { selectedItems.add(s3); List ids = taskMonitorService.getTaskIdsOfCategoryReportLineItems(null, null, null, null, null, null, - reportLineItemDefinitions, selectedItems); + columnHeaders, selectedItems); assertEquals(11, ids.size()); assertTrue(ids.contains("TKI:000000000000000000000000000000000006")); @@ -102,8 +103,8 @@ public class GetTaskIdsOfCategoryReportAccTest { public void testGetTaskIdsOfCategoryReportWithWorkbasketFilter() throws InvalidArgumentException { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); - List workbasketIds = Arrays.asList("WBI:000000000000000000000000000000000001"); - List reportLineItemDefinitions = getListOfReportLineItemDefinitions(); + List workbasketIds = Collections.singletonList("WBI:000000000000000000000000000000000001"); + List columnHeaders = getListOfColumnHeaders(); List selectedItems = new ArrayList<>(); @@ -126,7 +127,7 @@ public class GetTaskIdsOfCategoryReportAccTest { selectedItems.add(s3); List ids = taskMonitorService.getTaskIdsOfCategoryReportLineItems(workbasketIds, null, null, null, null, - null, reportLineItemDefinitions, selectedItems); + null, columnHeaders, selectedItems); assertEquals(4, ids.size()); assertTrue(ids.contains("TKI:000000000000000000000000000000000006")); @@ -139,8 +140,8 @@ public class GetTaskIdsOfCategoryReportAccTest { public void testGetTaskIdsOfCategoryReportWithStateFilter() throws InvalidArgumentException { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); - List states = Arrays.asList(TaskState.READY); - List reportLineItemDefinitions = getListOfReportLineItemDefinitions(); + List states = Collections.singletonList(TaskState.READY); + List columnHeaders = getListOfColumnHeaders(); List selectedItems = new ArrayList<>(); @@ -163,7 +164,7 @@ public class GetTaskIdsOfCategoryReportAccTest { selectedItems.add(s3); List ids = taskMonitorService.getTaskIdsOfCategoryReportLineItems(null, states, null, null, null, null, - reportLineItemDefinitions, selectedItems); + columnHeaders, selectedItems); assertEquals(11, ids.size()); assertTrue(ids.contains("TKI:000000000000000000000000000000000006")); @@ -184,7 +185,7 @@ public class GetTaskIdsOfCategoryReportAccTest { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); List categories = Arrays.asList("AUTOMATIC", "MANUAL"); - List reportLineItemDefinitions = getListOfReportLineItemDefinitions(); + List columnHeaders = getListOfColumnHeaders(); List selectedItems = new ArrayList<>(); @@ -201,7 +202,7 @@ public class GetTaskIdsOfCategoryReportAccTest { selectedItems.add(s2); List ids = taskMonitorService.getTaskIdsOfCategoryReportLineItems(null, null, categories, null, null, - null, reportLineItemDefinitions, selectedItems); + null, columnHeaders, selectedItems); assertEquals(3, ids.size()); assertTrue(ids.contains("TKI:000000000000000000000000000000000006")); @@ -213,8 +214,8 @@ public class GetTaskIdsOfCategoryReportAccTest { public void testGetTaskIdsOfCategoryReportWithDomainFilter() throws InvalidArgumentException { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); - List domains = Arrays.asList("DOMAIN_A"); - List reportLineItemDefinitions = getListOfReportLineItemDefinitions(); + List domains = Collections.singletonList("DOMAIN_A"); + List columnHeaders = getListOfColumnHeaders(); List selectedItems = new ArrayList<>(); @@ -237,7 +238,7 @@ public class GetTaskIdsOfCategoryReportAccTest { selectedItems.add(s3); List ids = taskMonitorService.getTaskIdsOfCategoryReportLineItems(null, null, null, domains, null, null, - reportLineItemDefinitions, selectedItems); + columnHeaders, selectedItems); assertEquals(4, ids.size()); assertTrue(ids.contains("TKI:000000000000000000000000000000000020")); @@ -251,8 +252,8 @@ public class GetTaskIdsOfCategoryReportAccTest { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); CustomField customField = CustomField.CUSTOM_1; - List customFieldValues = Arrays.asList("Geschaeftsstelle A"); - List reportLineItemDefinitions = getListOfReportLineItemDefinitions(); + List customFieldValues = Collections.singletonList("Geschaeftsstelle A"); + List columnHeaders = getListOfColumnHeaders(); List selectedItems = new ArrayList<>(); @@ -275,7 +276,7 @@ public class GetTaskIdsOfCategoryReportAccTest { selectedItems.add(s3); List ids = taskMonitorService.getTaskIdsOfCategoryReportLineItems(null, null, null, null, customField, - customFieldValues, reportLineItemDefinitions, selectedItems); + customFieldValues, columnHeaders, selectedItems); assertEquals(5, ids.size()); assertTrue(ids.contains("TKI:000000000000000000000000000000000020")); @@ -285,18 +286,18 @@ public class GetTaskIdsOfCategoryReportAccTest { assertTrue(ids.contains("TKI:000000000000000000000000000000000032")); } - private List getListOfReportLineItemDefinitions() { - List reportLineItemDefinitions = new ArrayList<>(); - reportLineItemDefinitions.add(new ReportLineItemDefinition(Integer.MIN_VALUE, -11)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(-10, -6)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(-5, -2)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(-1)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(0)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(1)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(2, 5)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(6, 10)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(11, Integer.MAX_VALUE)); - return reportLineItemDefinitions; + private List getListOfColumnHeaders() { + List columnHeaders = new ArrayList<>(); + columnHeaders.add(new TimeIntervalColumnHeader(Integer.MIN_VALUE, -11)); + columnHeaders.add(new TimeIntervalColumnHeader(-10, -6)); + columnHeaders.add(new TimeIntervalColumnHeader(-5, -2)); + columnHeaders.add(new TimeIntervalColumnHeader(-1)); + columnHeaders.add(new TimeIntervalColumnHeader(0)); + columnHeaders.add(new TimeIntervalColumnHeader(1)); + columnHeaders.add(new TimeIntervalColumnHeader(2, 5)); + columnHeaders.add(new TimeIntervalColumnHeader(6, 10)); + columnHeaders.add(new TimeIntervalColumnHeader(11, Integer.MAX_VALUE)); + return columnHeaders; } } diff --git a/lib/taskana-core/src/test/java/acceptance/monitoring/ProvideCategoryReportAccTest.java b/lib/taskana-core/src/test/java/acceptance/monitoring/ProvideCategoryReportAccTest.java index 9bec96721..5c84f6b42 100644 --- a/lib/taskana-core/src/test/java/acceptance/monitoring/ProvideCategoryReportAccTest.java +++ b/lib/taskana-core/src/test/java/acceptance/monitoring/ProvideCategoryReportAccTest.java @@ -1,5 +1,6 @@ package acceptance.monitoring; +import static org.junit.Assert.assertArrayEquals; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; @@ -7,7 +8,9 @@ import java.io.IOException; import java.sql.SQLException; import java.util.ArrayList; import java.util.Arrays; +import java.util.Collections; import java.util.List; +import java.util.stream.IntStream; import javax.sql.DataSource; @@ -24,21 +27,20 @@ import pro.taskana.TaskanaEngine.ConnectionManagementMode; import pro.taskana.configuration.TaskanaEngineConfiguration; import pro.taskana.database.TestDataGenerator; import pro.taskana.exceptions.InvalidArgumentException; -import pro.taskana.impl.Report; -import pro.taskana.impl.ReportLineItem; -import pro.taskana.impl.ReportLineItemDefinition; import pro.taskana.impl.TaskanaEngineImpl; import pro.taskana.impl.configuration.DBCleaner; import pro.taskana.impl.configuration.TaskanaEngineConfigurationTest; +import pro.taskana.impl.report.impl.CategoryReport; +import pro.taskana.impl.report.impl.TimeIntervalColumnHeader; /** * Acceptance test for all "category report" scenarios. */ public class ProvideCategoryReportAccTest { + private static final Logger LOGGER = LoggerFactory.getLogger(ProvideCategoryReportAccTest.class); protected static TaskanaEngineConfiguration taskanaEngineConfiguration; protected static TaskanaEngine taskanaEngine; - private static final Logger LOGGER = LoggerFactory.getLogger(ProvideCategoryReportAccTest.class); @BeforeClass public static void setupTest() throws Exception { @@ -63,61 +65,49 @@ public class ProvideCategoryReportAccTest { public void testGetTotalNumbersOfTasksOfCategoryReport() throws InvalidArgumentException { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); - Report report = taskMonitorService.getCategoryReport(null, null, null, null, null, null); + CategoryReport report = taskMonitorService.getCategoryReport(null, null, null, null, null, null); if (LOGGER.isDebugEnabled()) { LOGGER.debug(reportToString(report)); } assertNotNull(report); - assertEquals(33, report.getReportLines().get("EXTERN").getTotalNumberOfTasks()); - assertEquals(7, report.getReportLines().get("AUTOMATIC").getTotalNumberOfTasks()); - assertEquals(10, report.getReportLines().get("MANUAL").getTotalNumberOfTasks()); - assertEquals(0, report.getReportLines().get("EXTERN").getLineItems().size()); - assertEquals(0, report.getReportLines().get("AUTOMATIC").getLineItems().size()); - assertEquals(0, report.getReportLines().get("MANUAL").getLineItems().size()); - assertEquals(50, report.getSumLine().getTotalNumberOfTasks()); + assertEquals(3, report.rowSize()); + + assertEquals(33, report.getRow("EXTERN").getTotalValue()); + assertEquals(7, report.getRow("AUTOMATIC").getTotalValue()); + assertEquals(10, report.getRow("MANUAL").getTotalValue()); + assertEquals(0, report.getRow("EXTERN").getCells().length); + assertEquals(0, report.getRow("AUTOMATIC").getCells().length); + assertEquals(0, report.getRow("MANUAL").getCells().length); + assertEquals(50, report.getSumRow().getTotalValue()); } @Test public void testGetCategoryReportWithReportLineItemDefinitions() throws InvalidArgumentException { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); - List reportLineItemDefinitions = getListOfReportLineItemDefinitions(); + List columnHeaders = getListOfColumnHeaders(); - Report report = taskMonitorService.getCategoryReport(null, null, null, null, null, null, - reportLineItemDefinitions); + CategoryReport report = taskMonitorService.getCategoryReport(null, null, null, null, null, null, + columnHeaders); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } - int sumLineCount = report.getSumLine().getLineItems().get(0).getNumberOfTasks() - + report.getSumLine().getLineItems().get(1).getNumberOfTasks() - + report.getSumLine().getLineItems().get(2).getNumberOfTasks() - + report.getSumLine().getLineItems().get(3).getNumberOfTasks() - + report.getSumLine().getLineItems().get(4).getNumberOfTasks() - + report.getSumLine().getLineItems().get(5).getNumberOfTasks() - + report.getSumLine().getLineItems().get(6).getNumberOfTasks() - + report.getSumLine().getLineItems().get(7).getNumberOfTasks() - + report.getSumLine().getLineItems().get(8).getNumberOfTasks(); + int sumLineCount = IntStream.of(report.getSumRow().getCells()).sum(); assertNotNull(report); + assertEquals(3, report.rowSize()); - assertEquals(33, report.getReportLines().get("EXTERN").getTotalNumberOfTasks()); - assertEquals(7, report.getReportLines().get("AUTOMATIC").getTotalNumberOfTasks()); - assertEquals(10, report.getReportLines().get("MANUAL").getTotalNumberOfTasks()); + assertEquals(33, report.getRow("EXTERN").getTotalValue()); + assertEquals(7, report.getRow("AUTOMATIC").getTotalValue()); + assertEquals(10, report.getRow("MANUAL").getTotalValue()); - assertEquals(10, report.getSumLine().getLineItems().get(0).getNumberOfTasks()); - assertEquals(9, report.getSumLine().getLineItems().get(1).getNumberOfTasks()); - assertEquals(11, report.getSumLine().getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, report.getSumLine().getLineItems().get(3).getNumberOfTasks()); - assertEquals(4, report.getSumLine().getLineItems().get(4).getNumberOfTasks()); - assertEquals(0, report.getSumLine().getLineItems().get(5).getNumberOfTasks()); - assertEquals(7, report.getSumLine().getLineItems().get(6).getNumberOfTasks()); - assertEquals(4, report.getSumLine().getLineItems().get(7).getNumberOfTasks()); - assertEquals(5, report.getSumLine().getLineItems().get(8).getNumberOfTasks()); - assertEquals(50, report.getSumLine().getTotalNumberOfTasks()); + int[] sumRow = report.getSumRow().getCells(); + assertArrayEquals(new int[] {10, 9, 11, 0, 4, 0, 7, 4, 5}, sumRow); + assertEquals(50, report.getSumRow().getTotalValue()); assertEquals(50, sumLineCount); } @@ -125,142 +115,106 @@ public class ProvideCategoryReportAccTest { public void testEachItemOfCategoryReport() throws InvalidArgumentException { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + List columnHeaders = getShortListOfColumnHeaders(); - Report report = taskMonitorService.getCategoryReport(null, null, null, null, null, null, - reportLineItemDefinitions); + CategoryReport report = taskMonitorService.getCategoryReport(null, null, null, null, null, null, + columnHeaders); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } - List line1 = report.getReportLines().get("EXTERN").getLineItems(); - assertEquals(15, line1.get(0).getNumberOfTasks()); - assertEquals(8, line1.get(1).getNumberOfTasks()); - assertEquals(2, line1.get(2).getNumberOfTasks()); - assertEquals(6, line1.get(3).getNumberOfTasks()); - assertEquals(2, line1.get(4).getNumberOfTasks()); + assertNotNull(report); + assertEquals(3, report.rowSize()); - List line2 = report.getReportLines().get("AUTOMATIC").getLineItems(); - assertEquals(2, line2.get(0).getNumberOfTasks()); - assertEquals(1, line2.get(1).getNumberOfTasks()); - assertEquals(0, line2.get(2).getNumberOfTasks()); - assertEquals(1, line2.get(3).getNumberOfTasks()); - assertEquals(3, line2.get(4).getNumberOfTasks()); + int[] row1 = report.getRow("EXTERN").getCells(); + assertArrayEquals(new int[] {15, 8, 2, 6, 2}, row1); - List line3 = report.getReportLines().get("MANUAL").getLineItems(); - assertEquals(2, line3.get(0).getNumberOfTasks()); - assertEquals(2, line3.get(1).getNumberOfTasks()); - assertEquals(2, line3.get(2).getNumberOfTasks()); - assertEquals(0, line3.get(3).getNumberOfTasks()); - assertEquals(4, line3.get(4).getNumberOfTasks()); + int[] row2 = report.getRow("AUTOMATIC").getCells(); + assertArrayEquals(new int[] {2, 1, 0, 1, 3}, row2); + + int[] row3 = report.getRow("MANUAL").getCells(); + assertArrayEquals(new int[] {2, 2, 2, 0, 4}, row3); } @Test public void testEachItemOfCategoryReportNotInWorkingDays() throws InvalidArgumentException { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + List columnHeaders = getShortListOfColumnHeaders(); - Report report = taskMonitorService.getCategoryReport(null, null, null, null, null, null, - reportLineItemDefinitions, false); + CategoryReport report = taskMonitorService.getCategoryReport(null, null, null, null, null, null, + columnHeaders, false); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } - List line1 = report.getReportLines().get("EXTERN").getLineItems(); - assertEquals(23, line1.get(0).getNumberOfTasks()); - assertEquals(0, line1.get(1).getNumberOfTasks()); - assertEquals(2, line1.get(2).getNumberOfTasks()); - assertEquals(0, line1.get(3).getNumberOfTasks()); - assertEquals(8, line1.get(4).getNumberOfTasks()); + assertNotNull(report); + assertEquals(3, report.rowSize()); - List line2 = report.getReportLines().get("AUTOMATIC").getLineItems(); - assertEquals(3, line2.get(0).getNumberOfTasks()); - assertEquals(0, line2.get(1).getNumberOfTasks()); - assertEquals(0, line2.get(2).getNumberOfTasks()); - assertEquals(0, line2.get(3).getNumberOfTasks()); - assertEquals(4, line2.get(4).getNumberOfTasks()); + int[] row1 = report.getRow("EXTERN").getCells(); + assertArrayEquals(new int[] {23, 0, 2, 0, 8}, row1); - List line3 = report.getReportLines().get("MANUAL").getLineItems(); - assertEquals(4, line3.get(0).getNumberOfTasks()); - assertEquals(0, line3.get(1).getNumberOfTasks()); - assertEquals(2, line3.get(2).getNumberOfTasks()); - assertEquals(0, line3.get(3).getNumberOfTasks()); - assertEquals(4, line3.get(4).getNumberOfTasks()); + int[] row2 = report.getRow("AUTOMATIC").getCells(); + assertArrayEquals(new int[] {3, 0, 0, 0, 4}, row2); + + int[] row3 = report.getRow("MANUAL").getCells(); + assertArrayEquals(new int[] {4, 0, 2, 0, 4}, row3); } @Test public void testEachItemOfCategoryReportWithWorkbasketFilter() throws InvalidArgumentException { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); - List workbasketIds = Arrays.asList("WBI:000000000000000000000000000000000001"); - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + List workbasketIds = Collections.singletonList("WBI:000000000000000000000000000000000001"); + List columnHeaders = getShortListOfColumnHeaders(); - Report report = taskMonitorService.getCategoryReport(workbasketIds, null, null, null, null, null, - reportLineItemDefinitions); + CategoryReport report = taskMonitorService.getCategoryReport(workbasketIds, null, null, null, null, null, + columnHeaders); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } - List line1 = report.getReportLines().get("EXTERN").getLineItems(); - assertEquals(10, line1.get(0).getNumberOfTasks()); - assertEquals(2, line1.get(1).getNumberOfTasks()); - assertEquals(0, line1.get(2).getNumberOfTasks()); - assertEquals(0, line1.get(3).getNumberOfTasks()); - assertEquals(0, line1.get(4).getNumberOfTasks()); + assertNotNull(report); + assertEquals(3, report.rowSize()); - List line2 = report.getReportLines().get("AUTOMATIC").getLineItems(); - assertEquals(2, line2.get(0).getNumberOfTasks()); - assertEquals(1, line2.get(1).getNumberOfTasks()); - assertEquals(0, line2.get(2).getNumberOfTasks()); - assertEquals(1, line2.get(3).getNumberOfTasks()); - assertEquals(1, line2.get(4).getNumberOfTasks()); + int[] row1 = report.getRow("EXTERN").getCells(); + assertArrayEquals(new int[] {10, 2, 0, 0, 0}, row1); - List line3 = report.getReportLines().get("MANUAL").getLineItems(); - assertEquals(1, line3.get(0).getNumberOfTasks()); - assertEquals(0, line3.get(1).getNumberOfTasks()); - assertEquals(1, line3.get(2).getNumberOfTasks()); - assertEquals(0, line3.get(3).getNumberOfTasks()); - assertEquals(1, line3.get(4).getNumberOfTasks()); + int[] row2 = report.getRow("AUTOMATIC").getCells(); + assertArrayEquals(new int[] {2, 1, 0, 1, 1}, row2); + + int[] row3 = report.getRow("MANUAL").getCells(); + assertArrayEquals(new int[] {1, 0, 1, 0, 1}, row3); } @Test public void testEachItemOfCategoryReportWithStateFilter() throws InvalidArgumentException { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); - List states = Arrays.asList(TaskState.READY); - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + List states = Collections.singletonList(TaskState.READY); + List columnHeaders = getShortListOfColumnHeaders(); - Report report = taskMonitorService.getCategoryReport(null, states, null, null, null, null, - reportLineItemDefinitions); + CategoryReport report = taskMonitorService.getCategoryReport(null, states, null, null, null, null, + columnHeaders); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } - List line1 = report.getReportLines().get("EXTERN").getLineItems(); - assertEquals(15, line1.get(0).getNumberOfTasks()); - assertEquals(8, line1.get(1).getNumberOfTasks()); - assertEquals(2, line1.get(2).getNumberOfTasks()); - assertEquals(6, line1.get(3).getNumberOfTasks()); - assertEquals(0, line1.get(4).getNumberOfTasks()); + assertNotNull(report); + assertEquals(3, report.rowSize()); - List line2 = report.getReportLines().get("AUTOMATIC").getLineItems(); - assertEquals(2, line2.get(0).getNumberOfTasks()); - assertEquals(1, line2.get(1).getNumberOfTasks()); - assertEquals(0, line2.get(2).getNumberOfTasks()); - assertEquals(1, line2.get(3).getNumberOfTasks()); - assertEquals(0, line2.get(4).getNumberOfTasks()); + int[] row1 = report.getRow("EXTERN").getCells(); + assertArrayEquals(new int[] {15, 8, 2, 6, 0}, row1); - List line3 = report.getReportLines().get("MANUAL").getLineItems(); - assertEquals(2, line3.get(0).getNumberOfTasks()); - assertEquals(2, line3.get(1).getNumberOfTasks()); - assertEquals(2, line3.get(2).getNumberOfTasks()); - assertEquals(0, line3.get(3).getNumberOfTasks()); - assertEquals(0, line3.get(4).getNumberOfTasks()); + int[] row2 = report.getRow("AUTOMATIC").getCells(); + assertArrayEquals(new int[] {2, 1, 0, 1, 0}, row2); + + int[] row3 = report.getRow("MANUAL").getCells(); + assertArrayEquals(new int[] {2, 2, 2, 0, 0}, row3); } @Test @@ -268,66 +222,51 @@ public class ProvideCategoryReportAccTest { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); List categories = Arrays.asList("AUTOMATIC", "MANUAL"); - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + List columnHeaders = getShortListOfColumnHeaders(); - Report report = taskMonitorService.getCategoryReport(null, null, categories, null, null, null, - reportLineItemDefinitions); + CategoryReport report = taskMonitorService.getCategoryReport(null, null, categories, null, null, null, + columnHeaders); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } - List line1 = report.getReportLines().get("AUTOMATIC").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()); + assertNotNull(report); + assertEquals(2, report.rowSize()); - List line2 = report.getReportLines().get("MANUAL").getLineItems(); - assertEquals(2, line2.get(0).getNumberOfTasks()); - assertEquals(2, line2.get(1).getNumberOfTasks()); - assertEquals(2, line2.get(2).getNumberOfTasks()); - assertEquals(0, line2.get(3).getNumberOfTasks()); - assertEquals(4, line2.get(4).getNumberOfTasks()); + int[] row1 = report.getRow("AUTOMATIC").getCells(); + assertArrayEquals(new int[] {2, 1, 0, 1, 3}, row1); + + int[] row2 = report.getRow("MANUAL").getCells(); + assertArrayEquals(new int[] {2, 2, 2, 0, 4}, row2); - assertEquals(2, report.getReportLines().size()); } @Test public void testEachItemOfCategoryReportWithDomainFilter() throws InvalidArgumentException { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); - List domains = Arrays.asList("DOMAIN_A"); - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + List domains = Collections.singletonList("DOMAIN_A"); + List columnHeaders = getShortListOfColumnHeaders(); - Report report = taskMonitorService.getCategoryReport(null, null, null, domains, null, null, - reportLineItemDefinitions); + CategoryReport report = taskMonitorService.getCategoryReport(null, null, null, domains, null, null, + columnHeaders); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } - List line1 = report.getReportLines().get("EXTERN").getLineItems(); - assertEquals(8, line1.get(0).getNumberOfTasks()); - assertEquals(4, line1.get(1).getNumberOfTasks()); - assertEquals(2, line1.get(2).getNumberOfTasks()); - assertEquals(4, line1.get(3).getNumberOfTasks()); - assertEquals(0, line1.get(4).getNumberOfTasks()); + assertNotNull(report); + assertEquals(3, report.rowSize()); - List line2 = report.getReportLines().get("AUTOMATIC").getLineItems(); - assertEquals(1, line2.get(0).getNumberOfTasks()); - assertEquals(0, line2.get(1).getNumberOfTasks()); - assertEquals(0, line2.get(2).getNumberOfTasks()); - assertEquals(1, line2.get(3).getNumberOfTasks()); - assertEquals(1, line2.get(4).getNumberOfTasks()); + int[] row1 = report.getRow("EXTERN").getCells(); + assertArrayEquals(new int[] {8, 4, 2, 4, 0}, row1); - List line3 = report.getReportLines().get("MANUAL").getLineItems(); - assertEquals(2, line3.get(0).getNumberOfTasks()); - assertEquals(0, line3.get(1).getNumberOfTasks()); - assertEquals(0, line3.get(2).getNumberOfTasks()); - assertEquals(0, line3.get(3).getNumberOfTasks()); - assertEquals(3, line3.get(4).getNumberOfTasks()); + int[] row2 = report.getRow("AUTOMATIC").getCells(); + assertArrayEquals(new int[] {1, 0, 0, 1, 1}, row2); + + int[] row3 = report.getRow("MANUAL").getCells(); + assertArrayEquals(new int[] {2, 0, 0, 0, 3}, row3); } @Test @@ -335,72 +274,64 @@ public class ProvideCategoryReportAccTest { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); CustomField customField = CustomField.CUSTOM_1; - List customFieldValues = Arrays.asList("Geschaeftsstelle A"); - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + List customFieldValues = Collections.singletonList("Geschaeftsstelle A"); + List columnHeaders = getShortListOfColumnHeaders(); - Report report = taskMonitorService.getCategoryReport(null, null, null, null, customField, customFieldValues, - reportLineItemDefinitions); + CategoryReport report = taskMonitorService.getCategoryReport(null, null, null, null, customField, + customFieldValues, columnHeaders); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } - List line1 = report.getReportLines().get("EXTERN").getLineItems(); - assertEquals(9, line1.get(0).getNumberOfTasks()); - assertEquals(3, line1.get(1).getNumberOfTasks()); - assertEquals(1, line1.get(2).getNumberOfTasks()); - assertEquals(3, line1.get(3).getNumberOfTasks()); - assertEquals(0, line1.get(4).getNumberOfTasks()); + assertNotNull(report); + assertEquals(3, report.rowSize()); - List line2 = report.getReportLines().get("AUTOMATIC").getLineItems(); - assertEquals(1, line2.get(0).getNumberOfTasks()); - assertEquals(0, line2.get(1).getNumberOfTasks()); - assertEquals(0, line2.get(2).getNumberOfTasks()); - assertEquals(1, line2.get(3).getNumberOfTasks()); - assertEquals(1, line2.get(4).getNumberOfTasks()); + int[] row1 = report.getRow("EXTERN").getCells(); + assertArrayEquals(new int[] {9, 3, 1, 3, 0}, row1); - List line3 = report.getReportLines().get("MANUAL").getLineItems(); - assertEquals(1, line3.get(0).getNumberOfTasks()); - assertEquals(1, line3.get(1).getNumberOfTasks()); - assertEquals(2, line3.get(2).getNumberOfTasks()); - assertEquals(0, line3.get(3).getNumberOfTasks()); - assertEquals(2, line3.get(4).getNumberOfTasks()); + int[] row2 = report.getRow("AUTOMATIC").getCells(); + assertArrayEquals(new int[] {1, 0, 0, 1, 1}, row2); + + int[] row3 = report.getRow("MANUAL").getCells(); + assertArrayEquals(new int[] {1, 1, 2, 0, 2}, row3); } - private List getListOfReportLineItemDefinitions() { - List reportLineItemDefinitions = new ArrayList<>(); - reportLineItemDefinitions.add(new ReportLineItemDefinition(Integer.MIN_VALUE, -11)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(-10, -6)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(-5, -2)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(-1)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(0)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(1)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(2, 5)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(6, 10)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(11, Integer.MAX_VALUE)); - return reportLineItemDefinitions; + private List getListOfColumnHeaders() { + List columnHeaders = new ArrayList<>(); + columnHeaders.add(new TimeIntervalColumnHeader(Integer.MIN_VALUE, -11)); + columnHeaders.add(new TimeIntervalColumnHeader(-10, -6)); + columnHeaders.add(new TimeIntervalColumnHeader(-5, -2)); + columnHeaders.add(new TimeIntervalColumnHeader(-1)); + columnHeaders.add(new TimeIntervalColumnHeader(0)); + columnHeaders.add(new TimeIntervalColumnHeader(1)); + columnHeaders.add(new TimeIntervalColumnHeader(2, 5)); + columnHeaders.add(new TimeIntervalColumnHeader(6, 10)); + columnHeaders.add(new TimeIntervalColumnHeader(11, Integer.MAX_VALUE)); + return columnHeaders; } - private List getShortListOfReportLineItemDefinitions() { - List reportLineItemDefinitions = new ArrayList<>(); - reportLineItemDefinitions.add(new ReportLineItemDefinition(Integer.MIN_VALUE, -6)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(-5, -1)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(0)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(1, 5)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(6, Integer.MAX_VALUE)); - return reportLineItemDefinitions; + private List getShortListOfColumnHeaders() { + List columnHeaders = new ArrayList<>(); + columnHeaders.add(new TimeIntervalColumnHeader(Integer.MIN_VALUE, -6)); + columnHeaders.add(new TimeIntervalColumnHeader(-5, -1)); + columnHeaders.add(new TimeIntervalColumnHeader(0)); + columnHeaders.add(new TimeIntervalColumnHeader(1, 5)); + columnHeaders.add(new TimeIntervalColumnHeader(6, Integer.MAX_VALUE)); + return columnHeaders; } - private String reportToString(Report report) { + private String reportToString(CategoryReport report) { return reportToString(report, null); } - private String reportToString(Report report, List reportLineItemDefinitions) { + private String reportToString(CategoryReport report, + List columnHeaders) { String formatColumWidth = "| %-7s "; String formatFirstColumn = "| %-36s %-4s "; String formatFirstColumnFirstLine = "| %-29s %12s "; String formatFirstColumnSumLine = "| %-36s %-5s"; - int reportWidth = reportLineItemDefinitions == null ? 46 : reportLineItemDefinitions.size() * 10 + 46; + int reportWidth = columnHeaders == null ? 46 : columnHeaders.size() * 10 + 46; StringBuilder builder = new StringBuilder(); builder.append("\n"); @@ -409,8 +340,8 @@ public class ProvideCategoryReportAccTest { } builder.append("\n"); builder.append(String.format(formatFirstColumnFirstLine, "Categories", "Total")); - if (reportLineItemDefinitions != null) { - for (ReportLineItemDefinition def : reportLineItemDefinitions) { + if (columnHeaders != null) { + for (TimeIntervalColumnHeader def : columnHeaders) { if (def.getLowerAgeLimit() == Integer.MIN_VALUE) { builder.append(String.format(formatColumWidth, "< " + def.getUpperAgeLimit())); } else if (def.getUpperAgeLimit() == Integer.MAX_VALUE) { @@ -434,12 +365,12 @@ public class ProvideCategoryReportAccTest { } builder.append("\n"); - for (String rl : report.getReportLines().keySet()) { + for (String rl : report.getRowTitles()) { builder - .append(String.format(formatFirstColumn, rl, report.getReportLines().get(rl).getTotalNumberOfTasks())); - if (reportLineItemDefinitions != null) { - for (ReportLineItem reportLineItem : report.getReportLines().get(rl).getLineItems()) { - builder.append(String.format(formatColumWidth, reportLineItem.getNumberOfTasks())); + .append(String.format(formatFirstColumn, rl, report.getRow(rl).getTotalValue())); + if (columnHeaders != null) { + for (int cell : report.getRow(rl).getCells()) { + builder.append(String.format(formatColumWidth, cell)); } } builder.append("|\n"); @@ -448,9 +379,9 @@ public class ProvideCategoryReportAccTest { } builder.append("\n"); } - builder.append(String.format(formatFirstColumnSumLine, "Total", report.getSumLine().getTotalNumberOfTasks())); - for (ReportLineItem sumLine : report.getSumLine().getLineItems()) { - builder.append(String.format(formatColumWidth, sumLine.getNumberOfTasks())); + builder.append(String.format(formatFirstColumnSumLine, "Total", report.getSumRow().getTotalValue())); + for (int cell : report.getSumRow().getCells()) { + builder.append(String.format(formatColumWidth, cell)); } builder.append("|\n"); for (int i = 0; i < reportWidth; i++) { diff --git a/lib/taskana-core/src/test/java/acceptance/monitoring/ProvideClassificationReportAccTest.java b/lib/taskana-core/src/test/java/acceptance/monitoring/ProvideClassificationReportAccTest.java index efe0952f0..7ba673ecc 100644 --- a/lib/taskana-core/src/test/java/acceptance/monitoring/ProvideClassificationReportAccTest.java +++ b/lib/taskana-core/src/test/java/acceptance/monitoring/ProvideClassificationReportAccTest.java @@ -1,5 +1,6 @@ package acceptance.monitoring; +import static org.junit.Assert.assertArrayEquals; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; @@ -7,7 +8,9 @@ import java.io.IOException; import java.sql.SQLException; import java.util.ArrayList; import java.util.Arrays; +import java.util.Collections; import java.util.List; +import java.util.stream.IntStream; import javax.sql.DataSource; @@ -24,21 +27,20 @@ import pro.taskana.TaskanaEngine.ConnectionManagementMode; import pro.taskana.configuration.TaskanaEngineConfiguration; import pro.taskana.database.TestDataGenerator; import pro.taskana.exceptions.InvalidArgumentException; -import pro.taskana.impl.Report; -import pro.taskana.impl.ReportLineItem; -import pro.taskana.impl.ReportLineItemDefinition; import pro.taskana.impl.TaskanaEngineImpl; import pro.taskana.impl.configuration.DBCleaner; import pro.taskana.impl.configuration.TaskanaEngineConfigurationTest; +import pro.taskana.impl.report.impl.ClassificationReport; +import pro.taskana.impl.report.impl.TimeIntervalColumnHeader; /** * Acceptance test for all "classification report" scenarios. */ public class ProvideClassificationReportAccTest { + private static final Logger LOGGER = LoggerFactory.getLogger(ProvideClassificationReportAccTest.class); protected static TaskanaEngineConfiguration taskanaEngineConfiguration; protected static TaskanaEngine taskanaEngine; - private static final Logger LOGGER = LoggerFactory.getLogger(ProvideClassificationReportAccTest.class); @BeforeClass public static void setupTest() throws Exception { @@ -59,71 +61,66 @@ public class ProvideClassificationReportAccTest { testDataGenerator.generateMonitoringTestData(dataSource); } - @Test + @Test public void testGetTotalNumbersOfTasksOfClassificationReport() throws InvalidArgumentException { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); - Report report = taskMonitorService.getClassificationReport(null, null, null, null, null, null); + ClassificationReport report = taskMonitorService.getClassificationReport(null, null, null, null, null, null); if (LOGGER.isDebugEnabled()) { LOGGER.debug(reportToString(report)); } 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(50, report.getSumLine().getTotalNumberOfTasks()); + assertEquals(5, report.rowSize()); + + assertEquals(10, report.getRow("L10000").getTotalValue()); + assertEquals(10, report.getRow("L20000").getTotalValue()); + assertEquals(7, report.getRow("L30000").getTotalValue()); + assertEquals(10, report.getRow("L40000").getTotalValue()); + assertEquals(13, report.getRow("L50000").getTotalValue()); + assertEquals(0, report.getRow("L10000").getCells().length); + assertEquals(0, report.getRow("L20000").getCells().length); + assertEquals(0, report.getRow("L30000").getCells().length); + assertEquals(0, report.getRow("L40000").getCells().length); + assertEquals(0, report.getRow("L50000").getCells().length); + assertEquals(50, report.getSumRow().getTotalValue()); } @Test public void testGetClassificationReportWithReportLineItemDefinitions() throws InvalidArgumentException { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); - List reportLineItemDefinitions = getListOfReportLineItemDefinitions(); + List reportLineItemDefinitions = getListOfColumnsHeaders(); - Report report = taskMonitorService.getClassificationReport(null, null, null, null, null, null, + ClassificationReport report = taskMonitorService.getClassificationReport(null, null, null, null, null, null, reportLineItemDefinitions); if (LOGGER.isDebugEnabled()) { LOGGER.debug(reportToString(report, reportLineItemDefinitions)); } - int sumLineCount = report.getSumLine().getLineItems().get(0).getNumberOfTasks() - + report.getSumLine().getLineItems().get(1).getNumberOfTasks() - + report.getSumLine().getLineItems().get(2).getNumberOfTasks() - + report.getSumLine().getLineItems().get(3).getNumberOfTasks() - + report.getSumLine().getLineItems().get(4).getNumberOfTasks() - + report.getSumLine().getLineItems().get(5).getNumberOfTasks() - + report.getSumLine().getLineItems().get(6).getNumberOfTasks() - + report.getSumLine().getLineItems().get(7).getNumberOfTasks() - + report.getSumLine().getLineItems().get(8).getNumberOfTasks(); + int sumLineCount = IntStream.of(report.getSumRow().getCells()).sum(); assertNotNull(report); + assertEquals(5, report.rowSize()); - 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.getRow("L10000").getTotalValue()); + assertEquals(10, report.getRow("L20000").getTotalValue()); + assertEquals(7, report.getRow("L30000").getTotalValue()); + assertEquals(10, report.getRow("L40000").getTotalValue()); + assertEquals(13, report.getRow("L50000").getTotalValue()); - assertEquals(10, report.getSumLine().getLineItems().get(0).getNumberOfTasks()); - assertEquals(9, report.getSumLine().getLineItems().get(1).getNumberOfTasks()); - assertEquals(11, report.getSumLine().getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, report.getSumLine().getLineItems().get(3).getNumberOfTasks()); - assertEquals(4, report.getSumLine().getLineItems().get(4).getNumberOfTasks()); - assertEquals(0, report.getSumLine().getLineItems().get(5).getNumberOfTasks()); - assertEquals(7, report.getSumLine().getLineItems().get(6).getNumberOfTasks()); - assertEquals(4, report.getSumLine().getLineItems().get(7).getNumberOfTasks()); - assertEquals(5, report.getSumLine().getLineItems().get(8).getNumberOfTasks()); - assertEquals(50, report.getSumLine().getTotalNumberOfTasks()); + assertEquals(10, report.getSumRow().getCells()[0]); + assertEquals(9, report.getSumRow().getCells()[1]); + assertEquals(11, report.getSumRow().getCells()[2]); + assertEquals(0, report.getSumRow().getCells()[3]); + assertEquals(4, report.getSumRow().getCells()[4]); + assertEquals(0, report.getSumRow().getCells()[5]); + assertEquals(7, report.getSumRow().getCells()[6]); + assertEquals(4, report.getSumRow().getCells()[7]); + assertEquals(5, report.getSumRow().getCells()[8]); + assertEquals(50, report.getSumRow().getTotalValue()); assertEquals(50, sumLineCount); } @@ -131,198 +128,131 @@ public class ProvideClassificationReportAccTest { public void testEachItemOfClassificationReport() throws InvalidArgumentException { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + List columnHeaders = getShortListOfColumnHeaders(); - Report report = taskMonitorService.getClassificationReport(null, null, null, null, null, null, - reportLineItemDefinitions); + ClassificationReport report = taskMonitorService.getClassificationReport(null, null, null, null, null, null, + columnHeaders); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } - List line1 = report.getReportLines().get("L10000").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()); + assertNotNull(report); + assertEquals(5, report.rowSize()); - List line2 = report.getReportLines().get("L20000").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()); + int[] row1 = report.getRow("L10000").getCells(); + assertArrayEquals(new int[] {7, 2, 1, 0, 0}, row1); - List line3 = report.getReportLines().get("L30000").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()); + int[] row2 = report.getRow("L20000").getCells(); + assertArrayEquals(new int[] {5, 3, 1, 1, 0}, row2); - List line4 = report.getReportLines().get("L40000").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()); + int[] row3 = report.getRow("L30000").getCells(); + assertArrayEquals(new int[] {2, 1, 0, 1, 3}, row3); - List line5 = report.getReportLines().get("L50000").getLineItems(); - assertEquals(3, line5.get(0).getNumberOfTasks()); - assertEquals(3, line5.get(1).getNumberOfTasks()); - assertEquals(0, line5.get(2).getNumberOfTasks()); - assertEquals(5, line5.get(3).getNumberOfTasks()); - assertEquals(2, line5.get(4).getNumberOfTasks()); + int[] row4 = report.getRow("L40000").getCells(); + assertArrayEquals(new int[] {2, 2, 2, 0, 4}, row4); + + int[] row5 = report.getRow("L50000").getCells(); + assertArrayEquals(new int[] {3, 3, 0, 5, 2}, row5); } @Test public void testEachItemOfClassificationReportNotInWorkingDays() throws InvalidArgumentException { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + List reportLineItemDefinitions = getShortListOfColumnHeaders(); - Report report = taskMonitorService.getClassificationReport(null, null, null, null, null, null, + ClassificationReport report = taskMonitorService.getClassificationReport(null, null, null, null, null, null, reportLineItemDefinitions, false); if (LOGGER.isDebugEnabled()) { LOGGER.debug(reportToString(report, reportLineItemDefinitions)); } - List line1 = report.getReportLines().get("L10000").getLineItems(); - assertEquals(9, line1.get(0).getNumberOfTasks()); - assertEquals(0, line1.get(1).getNumberOfTasks()); - assertEquals(1, line1.get(2).getNumberOfTasks()); - assertEquals(0, line1.get(3).getNumberOfTasks()); - assertEquals(0, line1.get(4).getNumberOfTasks()); + assertNotNull(report); + assertEquals(5, report.rowSize()); - List line2 = report.getReportLines().get("L20000").getLineItems(); - assertEquals(8, line2.get(0).getNumberOfTasks()); - assertEquals(0, line2.get(1).getNumberOfTasks()); - assertEquals(1, line2.get(2).getNumberOfTasks()); - assertEquals(0, line2.get(3).getNumberOfTasks()); - assertEquals(1, line2.get(4).getNumberOfTasks()); + int[] row1 = report.getRow("L10000").getCells(); + assertArrayEquals(new int[] {9, 0, 1, 0, 0}, row1); - List line3 = report.getReportLines().get("L30000").getLineItems(); - assertEquals(3, line3.get(0).getNumberOfTasks()); - assertEquals(0, line3.get(1).getNumberOfTasks()); - assertEquals(0, line3.get(2).getNumberOfTasks()); - assertEquals(0, line3.get(3).getNumberOfTasks()); - assertEquals(4, line3.get(4).getNumberOfTasks()); + int[] row2 = report.getRow("L20000").getCells(); + assertArrayEquals(new int[] {8, 0, 1, 0, 1}, row2); - List line4 = report.getReportLines().get("L40000").getLineItems(); - assertEquals(4, line4.get(0).getNumberOfTasks()); - assertEquals(0, line4.get(1).getNumberOfTasks()); - assertEquals(2, line4.get(2).getNumberOfTasks()); - assertEquals(0, line4.get(3).getNumberOfTasks()); - assertEquals(4, line4.get(4).getNumberOfTasks()); + int[] row3 = report.getRow("L30000").getCells(); + assertArrayEquals(new int[] {3, 0, 0, 0, 4}, row3); - List line5 = report.getReportLines().get("L50000").getLineItems(); - assertEquals(6, line5.get(0).getNumberOfTasks()); - assertEquals(0, line5.get(1).getNumberOfTasks()); - assertEquals(0, line5.get(2).getNumberOfTasks()); - assertEquals(0, line5.get(3).getNumberOfTasks()); - assertEquals(7, line5.get(4).getNumberOfTasks()); + int[] row4 = report.getRow("L40000").getCells(); + assertArrayEquals(new int[] {4, 0, 2, 0, 4}, row4); + + int[] row5 = report.getRow("L50000").getCells(); + assertArrayEquals(new int[] {6, 0, 0, 0, 7}, row5); } @Test public void testEachItemOfClassificationReportWithWorkbasketFilter() throws InvalidArgumentException { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); - List workbasketIds = Arrays.asList("WBI:000000000000000000000000000000000001"); - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + List workbasketIds = Collections.singletonList("WBI:000000000000000000000000000000000001"); + List columnHeaders = getShortListOfColumnHeaders(); - Report report = taskMonitorService.getClassificationReport(workbasketIds, null, null, null, null, null, - reportLineItemDefinitions); + ClassificationReport report = taskMonitorService.getClassificationReport(workbasketIds, null, null, null, null, + null, + columnHeaders); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } - List line1 = report.getReportLines().get("L10000").getLineItems(); - assertEquals(6, line1.get(0).getNumberOfTasks()); - assertEquals(0, line1.get(1).getNumberOfTasks()); - assertEquals(0, line1.get(2).getNumberOfTasks()); - assertEquals(0, line1.get(3).getNumberOfTasks()); - assertEquals(0, line1.get(4).getNumberOfTasks()); + assertNotNull(report); + assertEquals(5, report.rowSize()); - List line2 = report.getReportLines().get("L20000").getLineItems(); - assertEquals(2, line2.get(0).getNumberOfTasks()); - assertEquals(0, line2.get(1).getNumberOfTasks()); - assertEquals(0, line2.get(2).getNumberOfTasks()); - assertEquals(0, line2.get(3).getNumberOfTasks()); - assertEquals(0, line2.get(4).getNumberOfTasks()); + int[] row1 = report.getRow("L10000").getCells(); + assertArrayEquals(new int[] {6, 0, 0, 0, 0}, row1); - List line3 = report.getReportLines().get("L30000").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(1, line3.get(4).getNumberOfTasks()); + int[] row2 = report.getRow("L20000").getCells(); + assertArrayEquals(new int[] {2, 0, 0, 0, 0}, row2); - List line4 = report.getReportLines().get("L40000").getLineItems(); - assertEquals(1, line4.get(0).getNumberOfTasks()); - assertEquals(0, line4.get(1).getNumberOfTasks()); - assertEquals(1, line4.get(2).getNumberOfTasks()); - assertEquals(0, line4.get(3).getNumberOfTasks()); - assertEquals(1, line4.get(4).getNumberOfTasks()); + int[] row3 = report.getRow("L30000").getCells(); + assertArrayEquals(new int[] {2, 1, 0, 1, 1}, row3); - List line5 = report.getReportLines().get("L50000").getLineItems(); - assertEquals(2, line5.get(0).getNumberOfTasks()); - assertEquals(2, line5.get(1).getNumberOfTasks()); - assertEquals(0, line5.get(2).getNumberOfTasks()); - assertEquals(0, line5.get(3).getNumberOfTasks()); - assertEquals(0, line5.get(4).getNumberOfTasks()); + int[] row4 = report.getRow("L40000").getCells(); + assertArrayEquals(new int[] {1, 0, 1, 0, 1}, row4); + + int[] row5 = report.getRow("L50000").getCells(); + assertArrayEquals(new int[] {2, 2, 0, 0, 0}, row5); } @Test public void testEachItemOfClassificationReportWithStateFilter() throws InvalidArgumentException { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); - List states = Arrays.asList(TaskState.READY); - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + List states = Collections.singletonList(TaskState.READY); + List columnHeaders = getShortListOfColumnHeaders(); - Report report = taskMonitorService.getClassificationReport(null, states, null, null, null, null, - reportLineItemDefinitions); + ClassificationReport report = taskMonitorService.getClassificationReport(null, states, null, null, null, null, + columnHeaders); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } - List line1 = report.getReportLines().get("L10000").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()); + assertNotNull(report); + assertEquals(5, report.rowSize()); - List line2 = report.getReportLines().get("L20000").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()); + int[] row1 = report.getRow("L10000").getCells(); + assertArrayEquals(new int[] {7, 2, 1, 0, 0}, row1); - List line3 = report.getReportLines().get("L30000").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(0, line3.get(4).getNumberOfTasks()); + int[] row2 = report.getRow("L20000").getCells(); + assertArrayEquals(new int[] {5, 3, 1, 1, 0}, row2); - List line4 = report.getReportLines().get("L40000").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(0, line4.get(4).getNumberOfTasks()); + int[] row3 = report.getRow("L30000").getCells(); + assertArrayEquals(new int[] {2, 1, 0, 1, 0}, row3); - List line5 = report.getReportLines().get("L50000").getLineItems(); - assertEquals(3, line5.get(0).getNumberOfTasks()); - assertEquals(3, line5.get(1).getNumberOfTasks()); - assertEquals(0, line5.get(2).getNumberOfTasks()); - assertEquals(5, line5.get(3).getNumberOfTasks()); - assertEquals(0, line5.get(4).getNumberOfTasks()); + int[] row4 = report.getRow("L40000").getCells(); + assertArrayEquals(new int[] {2, 2, 2, 0, 0}, row4); + + int[] row5 = report.getRow("L50000").getCells(); + assertArrayEquals(new int[] {3, 3, 0, 5, 0}, row5); } @Test @@ -330,80 +260,57 @@ public class ProvideClassificationReportAccTest { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); List categories = Arrays.asList("AUTOMATIC", "MANUAL"); - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + List columnHeaders = getShortListOfColumnHeaders(); - Report report = taskMonitorService.getClassificationReport(null, null, categories, null, null, null, - reportLineItemDefinitions); + ClassificationReport report = taskMonitorService.getClassificationReport(null, null, categories, null, null, + null, columnHeaders); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } - List line1 = report.getReportLines().get("L30000").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()); + assertNotNull(report); + assertEquals(2, report.rowSize()); - List line2 = report.getReportLines().get("L40000").getLineItems(); - assertEquals(2, line2.get(0).getNumberOfTasks()); - assertEquals(2, line2.get(1).getNumberOfTasks()); - assertEquals(2, line2.get(2).getNumberOfTasks()); - assertEquals(0, line2.get(3).getNumberOfTasks()); - assertEquals(4, line2.get(4).getNumberOfTasks()); + int[] row1 = report.getRow("L30000").getCells(); + assertArrayEquals(new int[] {2, 1, 0, 1, 3}, row1); + + int[] row2 = report.getRow("L40000").getCells(); + assertArrayEquals(new int[] {2, 2, 2, 0, 4}, row2); - assertEquals(2, report.getReportLines().size()); } @Test public void testEachItemOfClassificationReportWithDomainFilter() throws InvalidArgumentException { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); - List domains = Arrays.asList("DOMAIN_A"); - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + List domains = Collections.singletonList("DOMAIN_A"); + List columnHeaders = getShortListOfColumnHeaders(); - Report report = taskMonitorService.getClassificationReport(null, null, null, domains, null, null, - reportLineItemDefinitions); + ClassificationReport report = taskMonitorService.getClassificationReport(null, null, null, domains, null, null, + columnHeaders); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } - List line1 = report.getReportLines().get("L10000").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()); + assertNotNull(report); + assertEquals(5, report.rowSize()); - List line2 = report.getReportLines().get("L20000").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()); + int[] row1 = report.getRow("L10000").getCells(); + assertArrayEquals(new int[] {5, 2, 1, 0, 0}, row1); - List line3 = report.getReportLines().get("L30000").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()); + int[] row2 = report.getRow("L20000").getCells(); + assertArrayEquals(new int[] {3, 1, 1, 1, 0}, row2); - List line4 = report.getReportLines().get("L40000").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()); + int[] row3 = report.getRow("L30000").getCells(); + assertArrayEquals(new int[] {1, 0, 0, 1, 1}, row3); - List line5 = report.getReportLines().get("L50000").getLineItems(); - assertEquals(0, line5.get(0).getNumberOfTasks()); - assertEquals(1, line5.get(1).getNumberOfTasks()); - assertEquals(0, line5.get(2).getNumberOfTasks()); - assertEquals(3, line5.get(3).getNumberOfTasks()); - assertEquals(0, line5.get(4).getNumberOfTasks()); + int[] row4 = report.getRow("L40000").getCells(); + assertArrayEquals(new int[] {2, 0, 0, 0, 3}, row4); + + int[] row5 = report.getRow("L50000").getCells(); + assertArrayEquals(new int[] {0, 1, 0, 3, 0}, row5); } @Test @@ -411,86 +318,69 @@ public class ProvideClassificationReportAccTest { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); CustomField customField = CustomField.CUSTOM_1; - List customFieldValues = Arrays.asList("Geschaeftsstelle A"); - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + List customFieldValues = Collections.singletonList("Geschaeftsstelle A"); + List columnHeaders = getShortListOfColumnHeaders(); - Report report = taskMonitorService.getClassificationReport(null, null, null, null, customField, - customFieldValues, reportLineItemDefinitions); + ClassificationReport report = taskMonitorService.getClassificationReport(null, null, null, null, customField, + customFieldValues, columnHeaders); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } - List line1 = report.getReportLines().get("L10000").getLineItems(); - assertEquals(4, line1.get(0).getNumberOfTasks()); - assertEquals(0, line1.get(1).getNumberOfTasks()); - assertEquals(0, line1.get(2).getNumberOfTasks()); - assertEquals(0, line1.get(3).getNumberOfTasks()); - assertEquals(0, line1.get(4).getNumberOfTasks()); + assertNotNull(report); + assertEquals(5, report.rowSize()); - List line2 = report.getReportLines().get("L20000").getLineItems(); - assertEquals(4, 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()); + int[] row1 = report.getRow("L10000").getCells(); + assertArrayEquals(new int[] {4, 0, 0, 0, 0}, row1); - List line3 = report.getReportLines().get("L30000").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()); + int[] row2 = report.getRow("L20000").getCells(); + assertArrayEquals(new int[] {4, 1, 1, 1, 0}, row2); - List line4 = report.getReportLines().get("L40000").getLineItems(); - assertEquals(1, line4.get(0).getNumberOfTasks()); - assertEquals(1, line4.get(1).getNumberOfTasks()); - assertEquals(2, line4.get(2).getNumberOfTasks()); - assertEquals(0, line4.get(3).getNumberOfTasks()); - assertEquals(2, line4.get(4).getNumberOfTasks()); + int[] row3 = report.getRow("L30000").getCells(); + assertArrayEquals(new int[] {1, 0, 0, 1, 1}, row3); - List line5 = report.getReportLines().get("L50000").getLineItems(); - assertEquals(1, line5.get(0).getNumberOfTasks()); - assertEquals(2, line5.get(1).getNumberOfTasks()); - assertEquals(0, line5.get(2).getNumberOfTasks()); - assertEquals(2, line5.get(3).getNumberOfTasks()); - assertEquals(0, line5.get(4).getNumberOfTasks()); + int[] row4 = report.getRow("L40000").getCells(); + assertArrayEquals(new int[] {1, 1, 2, 0, 2}, row4); + + int[] row5 = report.getRow("L50000").getCells(); + assertArrayEquals(new int[] {1, 2, 0, 2, 0}, row5); } - private List getListOfReportLineItemDefinitions() { - List reportLineItemDefinitions = new ArrayList<>(); - reportLineItemDefinitions.add(new ReportLineItemDefinition(Integer.MIN_VALUE, -11)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(-10, -6)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(-5, -2)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(-1)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(0)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(1)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(2, 5)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(6, 10)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(11, Integer.MAX_VALUE)); + private List getListOfColumnsHeaders() { + List columnHeaders = new ArrayList<>(); + columnHeaders.add(new TimeIntervalColumnHeader(Integer.MIN_VALUE, -11)); + columnHeaders.add(new TimeIntervalColumnHeader(-10, -6)); + columnHeaders.add(new TimeIntervalColumnHeader(-5, -2)); + columnHeaders.add(new TimeIntervalColumnHeader(-1)); + columnHeaders.add(new TimeIntervalColumnHeader(0)); + columnHeaders.add(new TimeIntervalColumnHeader(1)); + columnHeaders.add(new TimeIntervalColumnHeader(2, 5)); + columnHeaders.add(new TimeIntervalColumnHeader(6, 10)); + columnHeaders.add(new TimeIntervalColumnHeader(11, Integer.MAX_VALUE)); + return columnHeaders; + } + + private List getShortListOfColumnHeaders() { + List reportLineItemDefinitions = new ArrayList<>(); + reportLineItemDefinitions.add(new TimeIntervalColumnHeader(Integer.MIN_VALUE, -6)); + reportLineItemDefinitions.add(new TimeIntervalColumnHeader(-5, -1)); + reportLineItemDefinitions.add(new TimeIntervalColumnHeader(0)); + reportLineItemDefinitions.add(new TimeIntervalColumnHeader(1, 5)); + reportLineItemDefinitions.add(new TimeIntervalColumnHeader(6, Integer.MAX_VALUE)); return reportLineItemDefinitions; } - private List getShortListOfReportLineItemDefinitions() { - List reportLineItemDefinitions = new ArrayList<>(); - reportLineItemDefinitions.add(new ReportLineItemDefinition(Integer.MIN_VALUE, -6)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(-5, -1)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(0)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(1, 5)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(6, Integer.MAX_VALUE)); - return reportLineItemDefinitions; - } - - private String reportToString(Report report) { + private String reportToString(ClassificationReport report) { return reportToString(report, null); } - private String reportToString(Report report, List reportLineItemDefinitions) { + private String reportToString(ClassificationReport report, List columnHeaders) { String formatColumWidth = "| %-7s "; String formatFirstColumn = "| %-36s %-4s "; String formatFirstColumnFirstLine = "| %-29s %12s "; String formatFirstColumnSumLine = "| %-36s %-5s"; - int reportWidth = reportLineItemDefinitions == null ? 46 : reportLineItemDefinitions.size() * 10 + 46; + int reportWidth = columnHeaders == null ? 46 : columnHeaders.size() * 10 + 46; StringBuilder builder = new StringBuilder(); builder.append("\n"); @@ -499,8 +389,8 @@ public class ProvideClassificationReportAccTest { } builder.append("\n"); builder.append(String.format(formatFirstColumnFirstLine, "Classifications", "Total")); - if (reportLineItemDefinitions != null) { - for (ReportLineItemDefinition def : reportLineItemDefinitions) { + if (columnHeaders != null) { + for (TimeIntervalColumnHeader def : columnHeaders) { if (def.getLowerAgeLimit() == Integer.MIN_VALUE) { builder.append(String.format(formatColumWidth, "< " + def.getUpperAgeLimit())); } else if (def.getUpperAgeLimit() == Integer.MAX_VALUE) { @@ -524,12 +414,12 @@ public class ProvideClassificationReportAccTest { } builder.append("\n"); - for (String rl : report.getReportLines().keySet()) { + for (String rl : report.getRowTitles()) { builder - .append(String.format(formatFirstColumn, rl, report.getReportLines().get(rl).getTotalNumberOfTasks())); - if (reportLineItemDefinitions != null) { - for (ReportLineItem reportLineItem : report.getReportLines().get(rl).getLineItems()) { - builder.append(String.format(formatColumWidth, reportLineItem.getNumberOfTasks())); + .append(String.format(formatFirstColumn, rl, report.getRow(rl).getTotalValue())); + if (columnHeaders != null) { + for (int cell : report.getRow(rl).getCells()) { + builder.append(String.format(formatColumWidth, cell)); } } builder.append("|\n"); @@ -538,9 +428,9 @@ public class ProvideClassificationReportAccTest { } builder.append("\n"); } - builder.append(String.format(formatFirstColumnSumLine, "Total", report.getSumLine().getTotalNumberOfTasks())); - for (ReportLineItem sumLine : report.getSumLine().getLineItems()) { - builder.append(String.format(formatColumWidth, sumLine.getNumberOfTasks())); + builder.append(String.format(formatFirstColumnSumLine, "Total", report.getSumRow().getTotalValue())); + for (int cell : report.getSumRow().getCells()) { + builder.append(String.format(formatColumWidth, cell)); } builder.append("|\n"); for (int i = 0; i < reportWidth; i++) { diff --git a/lib/taskana-core/src/test/java/acceptance/monitoring/ProvideCustomFieldValueReportAccTest.java b/lib/taskana-core/src/test/java/acceptance/monitoring/ProvideCustomFieldValueReportAccTest.java index 5745a7322..668750371 100644 --- a/lib/taskana-core/src/test/java/acceptance/monitoring/ProvideCustomFieldValueReportAccTest.java +++ b/lib/taskana-core/src/test/java/acceptance/monitoring/ProvideCustomFieldValueReportAccTest.java @@ -1,5 +1,6 @@ package acceptance.monitoring; +import static org.junit.Assert.assertArrayEquals; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; @@ -7,6 +8,7 @@ import java.io.IOException; import java.sql.SQLException; import java.util.ArrayList; import java.util.Arrays; +import java.util.Collections; import java.util.List; import javax.sql.DataSource; @@ -24,21 +26,19 @@ import pro.taskana.TaskanaEngine.ConnectionManagementMode; import pro.taskana.configuration.TaskanaEngineConfiguration; import pro.taskana.database.TestDataGenerator; import pro.taskana.exceptions.InvalidArgumentException; -import pro.taskana.impl.Report; -import pro.taskana.impl.ReportLineItem; -import pro.taskana.impl.ReportLineItemDefinition; -import pro.taskana.impl.TaskanaEngineImpl; import pro.taskana.impl.configuration.DBCleaner; import pro.taskana.impl.configuration.TaskanaEngineConfigurationTest; +import pro.taskana.impl.report.impl.CustomFieldValueReport; +import pro.taskana.impl.report.impl.TimeIntervalColumnHeader; /** * Acceptance test for all "classification report" scenarios. */ public class ProvideCustomFieldValueReportAccTest { + private static final Logger LOGGER = LoggerFactory.getLogger(ProvideCustomFieldValueReportAccTest.class); protected static TaskanaEngineConfiguration taskanaEngineConfiguration; protected static TaskanaEngine taskanaEngine; - private static final Logger LOGGER = LoggerFactory.getLogger(ProvideCustomFieldValueReportAccTest.class); @BeforeClass public static void setupTest() throws Exception { @@ -53,7 +53,7 @@ public class ProvideCustomFieldValueReportAccTest { taskanaEngineConfiguration = new TaskanaEngineConfiguration(dataSource, false); taskanaEngineConfiguration.setGermanPublicHolidaysEnabled(false); taskanaEngine = taskanaEngineConfiguration.buildTaskanaEngine(); - ((TaskanaEngineImpl) taskanaEngine).setConnectionManagementMode(ConnectionManagementMode.AUTOCOMMIT); + taskanaEngine.setConnectionManagementMode(ConnectionManagementMode.AUTOCOMMIT); cleaner.clearDb(dataSource, false); TestDataGenerator testDataGenerator = new TestDataGenerator(); testDataGenerator.generateMonitoringTestData(dataSource); @@ -65,21 +65,24 @@ public class ProvideCustomFieldValueReportAccTest { CustomField customField = CustomField.CUSTOM_1; - Report report = taskMonitorService.getCustomFieldValueReport(null, null, null, null, customField, null); + CustomFieldValueReport report = taskMonitorService.getCustomFieldValueReport(null, null, null, null, + customField, null); if (LOGGER.isDebugEnabled()) { LOGGER.debug(reportToString(report)); } assertNotNull(report); - assertEquals(25, report.getReportLines().get("Geschaeftsstelle A").getTotalNumberOfTasks()); - assertEquals(10, report.getReportLines().get("Geschaeftsstelle B").getTotalNumberOfTasks()); - assertEquals(15, report.getReportLines().get("Geschaeftsstelle C").getTotalNumberOfTasks()); - assertEquals(0, report.getReportLines().get("Geschaeftsstelle A").getLineItems().size()); - assertEquals(0, report.getReportLines().get("Geschaeftsstelle B").getLineItems().size()); - assertEquals(0, report.getReportLines().get("Geschaeftsstelle C").getLineItems().size()); - assertEquals(3, report.getReportLines().size()); - assertEquals(50, report.getSumLine().getTotalNumberOfTasks()); + assertEquals(3, report.rowSize()); + + assertEquals(25, report.getRow("Geschaeftsstelle A").getTotalValue()); + assertEquals(10, report.getRow("Geschaeftsstelle B").getTotalValue()); + assertEquals(15, report.getRow("Geschaeftsstelle C").getTotalValue()); + assertEquals(0, report.getRow("Geschaeftsstelle A").getCells().length); + assertEquals(0, report.getRow("Geschaeftsstelle B").getCells().length); + assertEquals(0, report.getRow("Geschaeftsstelle C").getCells().length); + + assertEquals(50, report.getSumRow().getTotalValue()); } @Test @@ -88,21 +91,23 @@ public class ProvideCustomFieldValueReportAccTest { CustomField customField = CustomField.CUSTOM_2; - Report report = taskMonitorService.getCustomFieldValueReport(null, null, null, null, customField, null); + CustomFieldValueReport report = taskMonitorService.getCustomFieldValueReport(null, null, null, null, + customField, null); if (LOGGER.isDebugEnabled()) { LOGGER.debug(reportToString(report)); } assertNotNull(report); - assertEquals(21, report.getReportLines().get("Vollkasko").getTotalNumberOfTasks()); - assertEquals(29, report.getReportLines().get("Teilkasko").getTotalNumberOfTasks()); + assertEquals(2, report.rowSize()); - assertEquals(0, report.getReportLines().get("Vollkasko").getLineItems().size()); - assertEquals(0, report.getReportLines().get("Teilkasko").getLineItems().size()); + assertEquals(21, report.getRow("Vollkasko").getTotalValue()); + assertEquals(29, report.getRow("Teilkasko").getTotalValue()); - assertEquals(2, report.getReportLines().size()); - assertEquals(50, report.getSumLine().getTotalNumberOfTasks()); + assertEquals(0, report.getRow("Vollkasko").getCells().length); + assertEquals(0, report.getRow("Teilkasko").getCells().length); + + assertEquals(50, report.getSumRow().getTotalValue()); } @Test @@ -110,33 +115,26 @@ public class ProvideCustomFieldValueReportAccTest { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); CustomField customField = CustomField.CUSTOM_1; - List reportLineItemDefinitions = getListOfReportLineItemDefinitions(); + List columnHeaders = getListOfColumnHeaders(); - Report report = taskMonitorService.getCustomFieldValueReport(null, null, null, null, customField, null, - reportLineItemDefinitions); + CustomFieldValueReport report = taskMonitorService.getCustomFieldValueReport(null, null, null, null, + customField, null, + columnHeaders); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } assertNotNull(report); + assertEquals(3, report.rowSize()); - assertEquals(25, report.getReportLines().get("Geschaeftsstelle A").getTotalNumberOfTasks()); - assertEquals(10, report.getReportLines().get("Geschaeftsstelle B").getTotalNumberOfTasks()); - assertEquals(15, report.getReportLines().get("Geschaeftsstelle C").getTotalNumberOfTasks()); + assertEquals(25, report.getRow("Geschaeftsstelle A").getTotalValue()); + assertEquals(10, report.getRow("Geschaeftsstelle B").getTotalValue()); + assertEquals(15, report.getRow("Geschaeftsstelle C").getTotalValue()); - assertEquals(10, report.getSumLine().getLineItems().get(0).getNumberOfTasks()); - assertEquals(9, report.getSumLine().getLineItems().get(1).getNumberOfTasks()); - assertEquals(11, report.getSumLine().getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, report.getSumLine().getLineItems().get(3).getNumberOfTasks()); - assertEquals(4, report.getSumLine().getLineItems().get(4).getNumberOfTasks()); - assertEquals(0, report.getSumLine().getLineItems().get(5).getNumberOfTasks()); - assertEquals(7, report.getSumLine().getLineItems().get(6).getNumberOfTasks()); - assertEquals(4, report.getSumLine().getLineItems().get(7).getNumberOfTasks()); - assertEquals(5, report.getSumLine().getLineItems().get(8).getNumberOfTasks()); + assertArrayEquals(new int[] {10, 9, 11, 0, 4, 0, 7, 4, 5}, report.getSumRow().getCells()); - assertEquals(3, report.getReportLines().size()); - assertEquals(50, report.getSumLine().getTotalNumberOfTasks()); + assertEquals(50, report.getSumRow().getTotalValue()); } @Test @@ -144,35 +142,27 @@ public class ProvideCustomFieldValueReportAccTest { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); CustomField customField = CustomField.CUSTOM_1; - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + List columnHeaders = getShortListOfColumnHeaders(); - Report report = taskMonitorService.getCustomFieldValueReport(null, null, null, null, customField, null, - reportLineItemDefinitions); + CustomFieldValueReport report = taskMonitorService.getCustomFieldValueReport(null, null, null, null, + customField, null, + columnHeaders); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } - List line1 = report.getReportLines().get("Geschaeftsstelle A").getLineItems(); - assertEquals(11, line1.get(0).getNumberOfTasks()); - assertEquals(4, line1.get(1).getNumberOfTasks()); - assertEquals(3, line1.get(2).getNumberOfTasks()); - assertEquals(4, line1.get(3).getNumberOfTasks()); - assertEquals(3, line1.get(4).getNumberOfTasks()); + assertNotNull(report); + assertEquals(3, report.rowSize()); - List line2 = report.getReportLines().get("Geschaeftsstelle B").getLineItems(); - assertEquals(5, line2.get(0).getNumberOfTasks()); - assertEquals(3, line2.get(1).getNumberOfTasks()); - assertEquals(0, line2.get(2).getNumberOfTasks()); - assertEquals(2, line2.get(3).getNumberOfTasks()); - assertEquals(0, line2.get(4).getNumberOfTasks()); + int[] row1 = report.getRow("Geschaeftsstelle A").getCells(); + assertArrayEquals(new int[] {11, 4, 3, 4, 3}, row1); - List line3 = report.getReportLines().get("Geschaeftsstelle C").getLineItems(); - assertEquals(3, line3.get(0).getNumberOfTasks()); - assertEquals(4, line3.get(1).getNumberOfTasks()); - assertEquals(1, line3.get(2).getNumberOfTasks()); - assertEquals(1, line3.get(3).getNumberOfTasks()); - assertEquals(6, line3.get(4).getNumberOfTasks()); + int[] row2 = report.getRow("Geschaeftsstelle B").getCells(); + assertArrayEquals(new int[] {5, 3, 0, 2, 0}, row2); + + int[] row3 = report.getRow("Geschaeftsstelle C").getCells(); + assertArrayEquals(new int[] {3, 4, 1, 1, 6}, row3); } @Test @@ -180,109 +170,85 @@ public class ProvideCustomFieldValueReportAccTest { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); CustomField customField = CustomField.CUSTOM_1; - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + List columnHeaders = getShortListOfColumnHeaders(); - Report report = taskMonitorService.getCustomFieldValueReport(null, null, null, null, customField, null, - reportLineItemDefinitions, false); + CustomFieldValueReport report = taskMonitorService.getCustomFieldValueReport(null, null, null, null, + customField, null, + columnHeaders, false); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } - List line1 = report.getReportLines().get("Geschaeftsstelle A").getLineItems(); - assertEquals(15, line1.get(0).getNumberOfTasks()); - assertEquals(0, line1.get(1).getNumberOfTasks()); - assertEquals(3, line1.get(2).getNumberOfTasks()); - assertEquals(0, line1.get(3).getNumberOfTasks()); - assertEquals(7, line1.get(4).getNumberOfTasks()); + assertNotNull(report); + assertEquals(3, report.rowSize()); - List line2 = report.getReportLines().get("Geschaeftsstelle B").getLineItems(); - assertEquals(8, line2.get(0).getNumberOfTasks()); - assertEquals(0, line2.get(1).getNumberOfTasks()); - assertEquals(0, line2.get(2).getNumberOfTasks()); - assertEquals(0, line2.get(3).getNumberOfTasks()); - assertEquals(2, line2.get(4).getNumberOfTasks()); + int[] row1 = report.getRow("Geschaeftsstelle A").getCells(); + assertArrayEquals(new int[] {15, 0, 3, 0, 7}, row1); - List line3 = report.getReportLines().get("Geschaeftsstelle C").getLineItems(); - assertEquals(7, line3.get(0).getNumberOfTasks()); - assertEquals(0, line3.get(1).getNumberOfTasks()); - assertEquals(1, line3.get(2).getNumberOfTasks()); - assertEquals(0, line3.get(3).getNumberOfTasks()); - assertEquals(7, line3.get(4).getNumberOfTasks()); + int[] row2 = report.getRow("Geschaeftsstelle B").getCells(); + assertArrayEquals(new int[] {8, 0, 0, 0, 2}, row2); + + int[] row3 = report.getRow("Geschaeftsstelle C").getCells(); + assertArrayEquals(new int[] {7, 0, 1, 0, 7}, row3); } @Test public void testEachItemOfCustomFieldValueReportWithWorkbasketFilter() throws InvalidArgumentException { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); - List workbasketIds = Arrays.asList("WBI:000000000000000000000000000000000001"); + List workbasketIds = Collections.singletonList("WBI:000000000000000000000000000000000001"); CustomField customField = CustomField.CUSTOM_1; - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + List columnHeaders = getShortListOfColumnHeaders(); - Report report = taskMonitorService.getCustomFieldValueReport(workbasketIds, null, null, null, customField, null, - reportLineItemDefinitions); + CustomFieldValueReport report = taskMonitorService.getCustomFieldValueReport(workbasketIds, null, null, null, + customField, null, + columnHeaders); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } - List line1 = report.getReportLines().get("Geschaeftsstelle A").getLineItems(); - assertEquals(6, line1.get(0).getNumberOfTasks()); - assertEquals(1, line1.get(1).getNumberOfTasks()); - assertEquals(1, line1.get(2).getNumberOfTasks()); - assertEquals(1, line1.get(3).getNumberOfTasks()); - assertEquals(1, line1.get(4).getNumberOfTasks()); + assertNotNull(report); + assertEquals(3, report.rowSize()); - List line2 = report.getReportLines().get("Geschaeftsstelle B").getLineItems(); - assertEquals(4, line2.get(0).getNumberOfTasks()); - assertEquals(1, line2.get(1).getNumberOfTasks()); - assertEquals(0, line2.get(2).getNumberOfTasks()); - assertEquals(0, line2.get(3).getNumberOfTasks()); - assertEquals(0, line2.get(4).getNumberOfTasks()); + int[] row1 = report.getRow("Geschaeftsstelle A").getCells(); + assertArrayEquals(new int[] {6, 1, 1, 1, 1}, row1); - List line3 = report.getReportLines().get("Geschaeftsstelle C").getLineItems(); - assertEquals(3, line3.get(0).getNumberOfTasks()); - assertEquals(1, line3.get(1).getNumberOfTasks()); - assertEquals(0, line3.get(2).getNumberOfTasks()); - assertEquals(0, line3.get(3).getNumberOfTasks()); - assertEquals(1, line3.get(4).getNumberOfTasks()); + int[] row2 = report.getRow("Geschaeftsstelle B").getCells(); + assertArrayEquals(new int[] {4, 1, 0, 0, 0}, row2); + + int[] row3 = report.getRow("Geschaeftsstelle C").getCells(); + assertArrayEquals(new int[] {3, 1, 0, 0, 1}, row3); } @Test public void testEachItemOfCustomFieldValueReportWithStateFilter() throws InvalidArgumentException { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); - List states = Arrays.asList(TaskState.READY); + List states = Collections.singletonList(TaskState.READY); CustomField customField = CustomField.CUSTOM_1; - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + List columnHeaders = getShortListOfColumnHeaders(); - Report report = taskMonitorService.getCustomFieldValueReport(null, states, null, null, customField, null, - reportLineItemDefinitions); + CustomFieldValueReport report = taskMonitorService.getCustomFieldValueReport(null, states, null, null, + customField, null, + columnHeaders); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } - List line1 = report.getReportLines().get("Geschaeftsstelle A").getLineItems(); - assertEquals(11, line1.get(0).getNumberOfTasks()); - assertEquals(4, line1.get(1).getNumberOfTasks()); - assertEquals(3, line1.get(2).getNumberOfTasks()); - assertEquals(4, line1.get(3).getNumberOfTasks()); - assertEquals(0, line1.get(4).getNumberOfTasks()); + assertNotNull(report); + assertEquals(3, report.rowSize()); - List line2 = report.getReportLines().get("Geschaeftsstelle B").getLineItems(); - assertEquals(5, line2.get(0).getNumberOfTasks()); - assertEquals(3, line2.get(1).getNumberOfTasks()); - assertEquals(0, line2.get(2).getNumberOfTasks()); - assertEquals(2, line2.get(3).getNumberOfTasks()); - assertEquals(0, line2.get(4).getNumberOfTasks()); + int[] row1 = report.getRow("Geschaeftsstelle A").getCells(); + assertArrayEquals(new int[] {11, 4, 3, 4, 0}, row1); - List line3 = report.getReportLines().get("Geschaeftsstelle C").getLineItems(); - assertEquals(3, line3.get(0).getNumberOfTasks()); - assertEquals(4, line3.get(1).getNumberOfTasks()); - assertEquals(1, line3.get(2).getNumberOfTasks()); - assertEquals(1, line3.get(3).getNumberOfTasks()); - assertEquals(0, line3.get(4).getNumberOfTasks()); + int[] row2 = report.getRow("Geschaeftsstelle B").getCells(); + assertArrayEquals(new int[] {5, 3, 0, 2, 0}, row2); + + int[] row3 = report.getRow("Geschaeftsstelle C").getCells(); + assertArrayEquals(new int[] {3, 4, 1, 1, 0}, row3); } @Test @@ -292,72 +258,56 @@ public class ProvideCustomFieldValueReportAccTest { List categories = Arrays.asList("AUTOMATIC", "MANUAL"); CustomField customField = CustomField.CUSTOM_1; - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + List columnHeaders = getShortListOfColumnHeaders(); - Report report = taskMonitorService.getCustomFieldValueReport(null, null, categories, null, customField, null, - reportLineItemDefinitions); + CustomFieldValueReport report = taskMonitorService.getCustomFieldValueReport(null, null, categories, null, + customField, null, + columnHeaders); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } - List line1 = report.getReportLines().get("Geschaeftsstelle A").getLineItems(); - assertEquals(2, line1.get(0).getNumberOfTasks()); - assertEquals(1, line1.get(1).getNumberOfTasks()); - assertEquals(2, line1.get(2).getNumberOfTasks()); - assertEquals(1, line1.get(3).getNumberOfTasks()); - assertEquals(3, line1.get(4).getNumberOfTasks()); + assertNotNull(report); + assertEquals(3, report.rowSize()); - List line2 = report.getReportLines().get("Geschaeftsstelle B").getLineItems(); - assertEquals(2, line2.get(0).getNumberOfTasks()); - assertEquals(0, line2.get(1).getNumberOfTasks()); - assertEquals(0, line2.get(2).getNumberOfTasks()); - assertEquals(0, line2.get(3).getNumberOfTasks()); - assertEquals(0, line2.get(4).getNumberOfTasks()); + int[] row1 = report.getRow("Geschaeftsstelle A").getCells(); + assertArrayEquals(new int[] {2, 1, 2, 1, 3}, row1); - List line3 = report.getReportLines().get("Geschaeftsstelle C").getLineItems(); - assertEquals(0, line3.get(0).getNumberOfTasks()); - assertEquals(2, line3.get(1).getNumberOfTasks()); - assertEquals(0, line3.get(2).getNumberOfTasks()); - assertEquals(0, line3.get(3).getNumberOfTasks()); - assertEquals(4, line3.get(4).getNumberOfTasks()); + int[] row2 = report.getRow("Geschaeftsstelle B").getCells(); + assertArrayEquals(new int[] {2, 0, 0, 0, 0}, row2); + + int[] row3 = report.getRow("Geschaeftsstelle C").getCells(); + assertArrayEquals(new int[] {0, 2, 0, 0, 4}, row3); } @Test public void testEachItemOfCustomFieldValueReportWithDomainFilter() throws InvalidArgumentException { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); - List domains = Arrays.asList("DOMAIN_A"); + List domains = Collections.singletonList("DOMAIN_A"); CustomField customField = CustomField.CUSTOM_1; - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + List columnHeaders = getShortListOfColumnHeaders(); - Report report = taskMonitorService.getCustomFieldValueReport(null, null, null, domains, customField, null, - reportLineItemDefinitions); + CustomFieldValueReport report = taskMonitorService.getCustomFieldValueReport(null, null, null, domains, + customField, null, + columnHeaders); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } - List line1 = report.getReportLines().get("Geschaeftsstelle A").getLineItems(); - assertEquals(8, line1.get(0).getNumberOfTasks()); - assertEquals(1, line1.get(1).getNumberOfTasks()); - assertEquals(1, line1.get(2).getNumberOfTasks()); - assertEquals(4, line1.get(3).getNumberOfTasks()); - assertEquals(1, line1.get(4).getNumberOfTasks()); + assertNotNull(report); + assertEquals(3, report.rowSize()); - List line2 = report.getReportLines().get("Geschaeftsstelle B").getLineItems(); - assertEquals(2, line2.get(0).getNumberOfTasks()); - assertEquals(2, line2.get(1).getNumberOfTasks()); - assertEquals(0, line2.get(2).getNumberOfTasks()); - assertEquals(1, line2.get(3).getNumberOfTasks()); - assertEquals(0, line2.get(4).getNumberOfTasks()); + int[] row1 = report.getRow("Geschaeftsstelle A").getCells(); + assertArrayEquals(new int[] {8, 1, 1, 4, 1}, row1); - List line3 = report.getReportLines().get("Geschaeftsstelle C").getLineItems(); - assertEquals(1, line3.get(0).getNumberOfTasks()); - assertEquals(1, line3.get(1).getNumberOfTasks()); - assertEquals(1, line3.get(2).getNumberOfTasks()); - assertEquals(0, line3.get(3).getNumberOfTasks()); - assertEquals(3, line3.get(4).getNumberOfTasks()); + int[] row2 = report.getRow("Geschaeftsstelle B").getCells(); + assertArrayEquals(new int[] {2, 2, 0, 1, 0}, row2); + + int[] row3 = report.getRow("Geschaeftsstelle C").getCells(); + assertArrayEquals(new int[] {1, 1, 1, 0, 3}, row3); } @Test @@ -365,60 +315,58 @@ public class ProvideCustomFieldValueReportAccTest { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); CustomField customField = CustomField.CUSTOM_1; - List customFieldValues = Arrays.asList("Geschaeftsstelle A"); - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + List customFieldValues = Collections.singletonList("Geschaeftsstelle A"); + List columnHeaders = getShortListOfColumnHeaders(); - Report report = taskMonitorService.getCustomFieldValueReport(null, null, null, null, customField, - customFieldValues, reportLineItemDefinitions); + CustomFieldValueReport report = taskMonitorService.getCustomFieldValueReport(null, null, null, null, + customField, + customFieldValues, columnHeaders); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } - List line1 = report.getReportLines().get("Geschaeftsstelle A").getLineItems(); - assertEquals(11, line1.get(0).getNumberOfTasks()); - assertEquals(4, line1.get(1).getNumberOfTasks()); - assertEquals(3, line1.get(2).getNumberOfTasks()); - assertEquals(4, line1.get(3).getNumberOfTasks()); - assertEquals(3, line1.get(4).getNumberOfTasks()); + assertNotNull(report); + assertEquals(1, report.rowSize()); - assertEquals(1, report.getReportLines().size()); + int[] row1 = report.getRow("Geschaeftsstelle A").getCells(); + assertArrayEquals(new int[] {11, 4, 3, 4, 3}, row1); } - private List getListOfReportLineItemDefinitions() { - List reportLineItemDefinitions = new ArrayList<>(); - reportLineItemDefinitions.add(new ReportLineItemDefinition(Integer.MIN_VALUE, -11)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(-10, -6)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(-5, -2)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(-1)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(0)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(1)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(2, 5)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(6, 10)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(11, Integer.MAX_VALUE)); - return reportLineItemDefinitions; + private List getListOfColumnHeaders() { + List columnHeaders = new ArrayList<>(); + columnHeaders.add(new TimeIntervalColumnHeader(Integer.MIN_VALUE, -11)); + columnHeaders.add(new TimeIntervalColumnHeader(-10, -6)); + columnHeaders.add(new TimeIntervalColumnHeader(-5, -2)); + columnHeaders.add(new TimeIntervalColumnHeader(-1)); + columnHeaders.add(new TimeIntervalColumnHeader(0)); + columnHeaders.add(new TimeIntervalColumnHeader(1)); + columnHeaders.add(new TimeIntervalColumnHeader(2, 5)); + columnHeaders.add(new TimeIntervalColumnHeader(6, 10)); + columnHeaders.add(new TimeIntervalColumnHeader(11, Integer.MAX_VALUE)); + return columnHeaders; } - private List getShortListOfReportLineItemDefinitions() { - List reportLineItemDefinitions = new ArrayList<>(); - reportLineItemDefinitions.add(new ReportLineItemDefinition(Integer.MIN_VALUE, -6)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(-5, -1)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(0)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(1, 5)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(6, Integer.MAX_VALUE)); - return reportLineItemDefinitions; + private List getShortListOfColumnHeaders() { + List columnHeaders = new ArrayList<>(); + columnHeaders.add(new TimeIntervalColumnHeader(Integer.MIN_VALUE, -6)); + columnHeaders.add(new TimeIntervalColumnHeader(-5, -1)); + columnHeaders.add(new TimeIntervalColumnHeader(0)); + columnHeaders.add(new TimeIntervalColumnHeader(1, 5)); + columnHeaders.add(new TimeIntervalColumnHeader(6, Integer.MAX_VALUE)); + return columnHeaders; } - private String reportToString(Report report) { + private String reportToString(CustomFieldValueReport report) { return reportToString(report, null); } - private String reportToString(Report report, List reportLineItemDefinitions) { + private String reportToString(CustomFieldValueReport report, List columnHeaders) { String formatColumWidth = "| %-7s "; String formatFirstColumn = "| %-36s %-4s "; String formatFirstColumnFirstLine = "| %-29s %12s "; String formatFirstColumnSumLine = "| %-36s %-5s"; - int reportWidth = reportLineItemDefinitions == null ? 46 : reportLineItemDefinitions.size() * 10 + 46; + int reportWidth = columnHeaders == null ? 46 : columnHeaders.size() * 10 + 46; StringBuilder builder = new StringBuilder(); builder.append("\n"); @@ -427,8 +375,8 @@ public class ProvideCustomFieldValueReportAccTest { } builder.append("\n"); builder.append(String.format(formatFirstColumnFirstLine, "Custom field values", "Total")); - if (reportLineItemDefinitions != null) { - for (ReportLineItemDefinition def : reportLineItemDefinitions) { + if (columnHeaders != null) { + for (TimeIntervalColumnHeader def : columnHeaders) { if (def.getLowerAgeLimit() == Integer.MIN_VALUE) { builder.append(String.format(formatColumWidth, "< " + def.getUpperAgeLimit())); } else if (def.getUpperAgeLimit() == Integer.MAX_VALUE) { @@ -452,12 +400,12 @@ public class ProvideCustomFieldValueReportAccTest { } builder.append("\n"); - for (String rl : report.getReportLines().keySet()) { + for (String rl : report.getRowTitles()) { builder - .append(String.format(formatFirstColumn, rl, report.getReportLines().get(rl).getTotalNumberOfTasks())); - if (reportLineItemDefinitions != null) { - for (ReportLineItem reportLineItem : report.getReportLines().get(rl).getLineItems()) { - builder.append(String.format(formatColumWidth, reportLineItem.getNumberOfTasks())); + .append(String.format(formatFirstColumn, rl, report.getRow(rl).getTotalValue())); + if (columnHeaders != null) { + for (int cell : report.getRow(rl).getCells()) { + builder.append(String.format(formatColumWidth, cell)); } } builder.append("|\n"); @@ -466,9 +414,9 @@ public class ProvideCustomFieldValueReportAccTest { } builder.append("\n"); } - builder.append(String.format(formatFirstColumnSumLine, "Total", report.getSumLine().getTotalNumberOfTasks())); - for (ReportLineItem sumLine : report.getSumLine().getLineItems()) { - builder.append(String.format(formatColumWidth, sumLine.getNumberOfTasks())); + builder.append(String.format(formatFirstColumnSumLine, "Total", report.getSumRow().getTotalValue())); + for (int cell : report.getSumRow().getCells()) { + builder.append(String.format(formatColumWidth, cell)); } builder.append("|\n"); for (int i = 0; i < reportWidth; i++) { diff --git a/lib/taskana-core/src/test/java/acceptance/monitoring/ProvideDetailedClassificationReportAccTest.java b/lib/taskana-core/src/test/java/acceptance/monitoring/ProvideDetailedClassificationReportAccTest.java index fc8fa5b2d..03f7c7f66 100644 --- a/lib/taskana-core/src/test/java/acceptance/monitoring/ProvideDetailedClassificationReportAccTest.java +++ b/lib/taskana-core/src/test/java/acceptance/monitoring/ProvideDetailedClassificationReportAccTest.java @@ -1,5 +1,6 @@ package acceptance.monitoring; +import static org.junit.Assert.assertArrayEquals; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; @@ -7,6 +8,7 @@ import java.io.IOException; import java.sql.SQLException; import java.util.ArrayList; import java.util.Arrays; +import java.util.Collections; import java.util.List; import javax.sql.DataSource; @@ -24,24 +26,23 @@ import pro.taskana.TaskanaEngine.ConnectionManagementMode; import pro.taskana.configuration.TaskanaEngineConfiguration; import pro.taskana.database.TestDataGenerator; import pro.taskana.exceptions.InvalidArgumentException; -import pro.taskana.impl.DetailedClassificationReport; -import pro.taskana.impl.DetailedReportLine; -import pro.taskana.impl.Report; -import pro.taskana.impl.ReportLine; -import pro.taskana.impl.ReportLineItem; -import pro.taskana.impl.ReportLineItemDefinition; import pro.taskana.impl.TaskanaEngineImpl; import pro.taskana.impl.configuration.DBCleaner; import pro.taskana.impl.configuration.TaskanaEngineConfigurationTest; +import pro.taskana.impl.report.ReportRow; +import pro.taskana.impl.report.impl.DetailedClassificationReport; +import pro.taskana.impl.report.impl.DetailedMonitorQueryItem; +import pro.taskana.impl.report.impl.DetailedReportRow; +import pro.taskana.impl.report.impl.TimeIntervalColumnHeader; /** * Acceptance test for all "detailed classification report" scenarios. */ public class ProvideDetailedClassificationReportAccTest { + private static final Logger LOGGER = LoggerFactory.getLogger(ProvideDetailedClassificationReportAccTest.class); protected static TaskanaEngineConfiguration taskanaEngineConfiguration; protected static TaskanaEngine taskanaEngine; - private static final Logger LOGGER = LoggerFactory.getLogger(ProvideDetailedClassificationReportAccTest.class); @BeforeClass public static void setupTest() throws Exception { @@ -74,49 +75,77 @@ public class ProvideDetailedClassificationReportAccTest { } assertNotNull(report); + assertEquals(5, report.rowSize()); - DetailedReportLine line1 = (DetailedReportLine) report.getReportLines().get("L10000"); - assertEquals(10, line1.getTotalNumberOfTasks()); - assertEquals(3, line1.getDetailLines().get("L11000").getTotalNumberOfTasks()); - assertEquals(7, line1.getDetailLines().get("N/A").getTotalNumberOfTasks()); - assertEquals(0, line1.getLineItems().size()); - assertEquals(2, line1.getDetailLines().size()); + DetailedReportRow row1 = report.getRow("L10000"); + assertEquals(10, row1.getTotalValue()); + assertEquals(3, row1.getDetailRows().get("L11000").getTotalValue()); + assertEquals(7, row1.getDetailRows().get("N/A").getTotalValue()); + assertEquals(0, row1.getCells().length); + assertEquals(2, row1.getDetailRows().size()); - DetailedReportLine line2 = (DetailedReportLine) report.getReportLines().get("L20000"); - assertEquals(10, line2.getTotalNumberOfTasks()); - assertEquals(4, line2.getDetailLines().get("L22000").getTotalNumberOfTasks()); - assertEquals(6, line2.getDetailLines().get("N/A").getTotalNumberOfTasks()); - assertEquals(0, line2.getLineItems().size()); - assertEquals(2, line2.getDetailLines().size()); + DetailedReportRow row2 = report.getRow("L20000"); + assertEquals(10, row2.getTotalValue()); + assertEquals(4, row2.getDetailRows().get("L22000").getTotalValue()); + assertEquals(6, row2.getDetailRows().get("N/A").getTotalValue()); + assertEquals(0, row2.getCells().length); + assertEquals(2, row2.getDetailRows().size()); - DetailedReportLine line3 = (DetailedReportLine) report.getReportLines().get("L30000"); - assertEquals(7, line3.getTotalNumberOfTasks()); - assertEquals(3, line3.getDetailLines().get("L33000").getTotalNumberOfTasks()); - assertEquals(1, line3.getDetailLines().get("L99000").getTotalNumberOfTasks()); - assertEquals(3, line3.getDetailLines().get("N/A").getTotalNumberOfTasks()); - assertEquals(0, line3.getLineItems().size()); - assertEquals(3, line3.getDetailLines().size()); + DetailedReportRow row3 = report.getRow("L30000"); + assertEquals(7, row3.getTotalValue()); + assertEquals(3, row3.getDetailRows().get("L33000").getTotalValue()); + assertEquals(1, row3.getDetailRows().get("L99000").getTotalValue()); + assertEquals(3, row3.getDetailRows().get("N/A").getTotalValue()); + assertEquals(0, row3.getCells().length); + assertEquals(3, row3.getDetailRows().size()); - DetailedReportLine line4 = (DetailedReportLine) report.getReportLines().get("L40000"); - assertEquals(10, line4.getTotalNumberOfTasks()); - assertEquals(10, line4.getDetailLines().get("N/A").getTotalNumberOfTasks()); - assertEquals(0, line4.getLineItems().size()); - assertEquals(1, line4.getDetailLines().size()); + DetailedReportRow row4 = report.getRow("L40000"); + assertEquals(10, row4.getTotalValue()); + assertEquals(10, row4.getDetailRows().get("N/A").getTotalValue()); + assertEquals(0, row4.getCells().length); + assertEquals(1, row4.getDetailRows().size()); - DetailedReportLine line5 = (DetailedReportLine) report.getReportLines().get("L50000"); - assertEquals(13, line5.getTotalNumberOfTasks()); - assertEquals(13, line5.getDetailLines().get("N/A").getTotalNumberOfTasks()); - assertEquals(0, line5.getLineItems().size()); - assertEquals(1, line5.getDetailLines().size()); + DetailedReportRow row5 = report.getRow("L50000"); + assertEquals(13, row5.getTotalValue()); + assertEquals(13, row5.getDetailRows().get("N/A").getTotalValue()); + assertEquals(0, row5.getCells().length); + assertEquals(1, row5.getDetailRows().size()); - assertEquals(50, report.getSumLine().getTotalNumberOfTasks()); + assertEquals(50, report.getSumRow().getTotalValue()); } @Test public void testGetDetailedClassificationReportWithReportLineItemDefinitions() throws InvalidArgumentException { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); - List reportLineItemDefinitions = getListOfReportLineItemDefinitions(); + List columnHeaders = getListOfColumnHeaders(); + + DetailedClassificationReport report = taskMonitorService.getDetailedClassificationReport(null, null, null, null, + null, null, columnHeaders); + + if (LOGGER.isDebugEnabled()) { + LOGGER.debug(reportToString(report, columnHeaders)); + } + + assertNotNull(report); + assertEquals(5, report.rowSize()); + + assertEquals(10, report.getRow("L10000").getTotalValue()); + assertEquals(10, report.getRow("L20000").getTotalValue()); + assertEquals(7, report.getRow("L30000").getTotalValue()); + assertEquals(10, report.getRow("L40000").getTotalValue()); + assertEquals(13, report.getRow("L50000").getTotalValue()); + + int[] sumRow = report.getSumRow().getCells(); + assertArrayEquals(new int[] {10, 9, 11, 0, 4, 0, 7, 4, 5}, sumRow); + assertEquals(50, report.getSumRow().getTotalValue()); + } + + @Test + public void testEachItemOfDetailedClassificationReport() throws InvalidArgumentException { + TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); + + List reportLineItemDefinitions = getShortListOfColumnHeaders(); DetailedClassificationReport report = taskMonitorService.getDetailedClassificationReport(null, null, null, null, null, null, reportLineItemDefinitions); @@ -126,143 +155,57 @@ public class ProvideDetailedClassificationReportAccTest { } assertNotNull(report); + assertEquals(5, report.rowSize()); - 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()); + DetailedReportRow line1 = report.getRow("L10000"); + assertArrayEquals(new int[] {7, 2, 1, 0, 0}, line1.getCells()); - assertEquals(10, report.getSumLine().getLineItems().get(0).getNumberOfTasks()); - assertEquals(9, report.getSumLine().getLineItems().get(1).getNumberOfTasks()); - assertEquals(11, report.getSumLine().getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, report.getSumLine().getLineItems().get(3).getNumberOfTasks()); - assertEquals(4, report.getSumLine().getLineItems().get(4).getNumberOfTasks()); - assertEquals(0, report.getSumLine().getLineItems().get(5).getNumberOfTasks()); - assertEquals(7, report.getSumLine().getLineItems().get(6).getNumberOfTasks()); - assertEquals(4, report.getSumLine().getLineItems().get(7).getNumberOfTasks()); - assertEquals(5, report.getSumLine().getLineItems().get(8).getNumberOfTasks()); - assertEquals(50, report.getSumLine().getTotalNumberOfTasks()); - } + ReportRow detailedLine1 = line1.getDetailRows().get("L11000"); + assertArrayEquals(new int[] {2, 0, 1, 0, 0}, detailedLine1.getCells()); - @Test - public void testEachItemOfDetailedClassificationReport() throws InvalidArgumentException { - TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); + ReportRow detailedLineNoAttachment1 = line1.getDetailRows().get("N/A"); + assertArrayEquals(new int[] {5, 2, 0, 0, 0}, detailedLineNoAttachment1.getCells()); - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + DetailedReportRow line2 = report.getRow("L20000"); + assertArrayEquals(new int[] {5, 3, 1, 1, 0}, line2.getCells()); - DetailedClassificationReport report = taskMonitorService.getDetailedClassificationReport(null, null, null, null, - null, null, reportLineItemDefinitions); + ReportRow detailedLine2 = line2.getDetailRows().get("L22000"); + assertArrayEquals(new int[] {1, 1, 1, 1, 0}, detailedLine2.getCells()); - if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); - } + ReportRow detailedLineNoAttachment2 = line2.getDetailRows().get("N/A"); + assertArrayEquals(new int[] {4, 2, 0, 0, 0}, detailedLineNoAttachment2.getCells()); - DetailedReportLine line1 = (DetailedReportLine) report.getReportLines().get("L10000"); - 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()); + DetailedReportRow line3 = report.getRow("L30000"); + assertArrayEquals(new int[] {2, 1, 0, 1, 3}, line3.getCells()); - ReportLine detailedLine1 = line1.getDetailLines().get("L11000"); - assertEquals(2, detailedLine1.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, detailedLine1.getLineItems().get(1).getNumberOfTasks()); - assertEquals(1, detailedLine1.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLine1.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, detailedLine1.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLine3a = line3.getDetailRows().get("L33000"); + assertArrayEquals(new int[] {0, 1, 0, 1, 1}, detailedLine3a.getCells()); - ReportLine detailedLineNoAttachment1 = line1.getDetailLines().get("N/A"); - assertEquals(5, detailedLineNoAttachment1.getLineItems().get(0).getNumberOfTasks()); - assertEquals(2, detailedLineNoAttachment1.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment1.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment1.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment1.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLine3b = line3.getDetailRows().get("L99000"); + assertArrayEquals(new int[] {0, 0, 0, 0, 1}, detailedLine3b.getCells()); - DetailedReportLine line2 = (DetailedReportLine) report.getReportLines().get("L20000"); - 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()); + ReportRow detailedLineNoAttachment3 = line3.getDetailRows().get("N/A"); + assertArrayEquals(new int[] {2, 0, 0, 0, 1}, detailedLineNoAttachment3.getCells()); - ReportLine detailedLine2 = line2.getDetailLines().get("L22000"); - assertEquals(1, detailedLine2.getLineItems().get(0).getNumberOfTasks()); - assertEquals(1, detailedLine2.getLineItems().get(1).getNumberOfTasks()); - assertEquals(1, detailedLine2.getLineItems().get(2).getNumberOfTasks()); - assertEquals(1, detailedLine2.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, detailedLine2.getLineItems().get(4).getNumberOfTasks()); + DetailedReportRow line4 = report.getRow("L40000"); + assertArrayEquals(new int[] {2, 2, 2, 0, 4}, line4.getCells()); - ReportLine detailedLineNoAttachment2 = line2.getDetailLines().get("N/A"); - assertEquals(4, detailedLineNoAttachment2.getLineItems().get(0).getNumberOfTasks()); - assertEquals(2, detailedLineNoAttachment2.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment2.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment2.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment2.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLineNoAttachment4 = line4.getDetailRows().get("N/A"); + assertArrayEquals(new int[] {2, 2, 2, 0, 4}, detailedLineNoAttachment4.getCells()); - DetailedReportLine line3 = (DetailedReportLine) report.getReportLines().get("L30000"); - 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()); + DetailedReportRow line5 = report.getRow("L50000"); + assertArrayEquals(new int[] {3, 3, 0, 5, 2}, line5.getCells()); - ReportLine detailedLine3a = line3.getDetailLines().get("L33000"); - 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"); - assertEquals(0, detailedLine3b.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, detailedLine3b.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLine3b.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLine3b.getLineItems().get(3).getNumberOfTasks()); - assertEquals(1, detailedLine3b.getLineItems().get(4).getNumberOfTasks()); - - ReportLine detailedLineNoAttachment3 = line3.getDetailLines().get("N/A"); - assertEquals(2, detailedLineNoAttachment3.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment3.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment3.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment3.getLineItems().get(3).getNumberOfTasks()); - assertEquals(1, detailedLineNoAttachment3.getLineItems().get(4).getNumberOfTasks()); - - DetailedReportLine line4 = (DetailedReportLine) report.getReportLines().get("L40000"); - assertEquals(2, line4.getLineItems().get(0).getNumberOfTasks()); - assertEquals(2, line4.getLineItems().get(1).getNumberOfTasks()); - assertEquals(2, line4.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, line4.getLineItems().get(3).getNumberOfTasks()); - assertEquals(4, line4.getLineItems().get(4).getNumberOfTasks()); - - ReportLine detailedLineNoAttachment4 = line4.getDetailLines().get("N/A"); - assertEquals(2, detailedLineNoAttachment4.getLineItems().get(0).getNumberOfTasks()); - assertEquals(2, detailedLineNoAttachment4.getLineItems().get(1).getNumberOfTasks()); - assertEquals(2, detailedLineNoAttachment4.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment4.getLineItems().get(3).getNumberOfTasks()); - assertEquals(4, detailedLineNoAttachment4.getLineItems().get(4).getNumberOfTasks()); - - DetailedReportLine line5 = (DetailedReportLine) report.getReportLines().get("L50000"); - assertEquals(3, line5.getLineItems().get(0).getNumberOfTasks()); - assertEquals(3, line5.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, line5.getLineItems().get(2).getNumberOfTasks()); - assertEquals(5, line5.getLineItems().get(3).getNumberOfTasks()); - assertEquals(2, line5.getLineItems().get(4).getNumberOfTasks()); - - ReportLine detailedLineNoAttachment5 = line5.getDetailLines().get("N/A"); - assertEquals(3, detailedLineNoAttachment5.getLineItems().get(0).getNumberOfTasks()); - assertEquals(3, detailedLineNoAttachment5.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment5.getLineItems().get(2).getNumberOfTasks()); - assertEquals(5, detailedLineNoAttachment5.getLineItems().get(3).getNumberOfTasks()); - assertEquals(2, detailedLineNoAttachment5.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLineNoAttachment5 = line5.getDetailRows().get("N/A"); + assertArrayEquals(new int[] {3, 3, 0, 5, 2}, detailedLineNoAttachment5.getCells()); } @Test public void testEachItemOfDetailedClassificationReportWithWorkbasketFilter() throws InvalidArgumentException { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); - List workbasketIds = Arrays.asList("WBI:000000000000000000000000000000000001"); - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + List workbasketIds = Collections.singletonList("WBI:000000000000000000000000000000000001"); + List reportLineItemDefinitions = getShortListOfColumnHeaders(); DetailedClassificationReport report = taskMonitorService.getDetailedClassificationReport(workbasketIds, null, null, null, null, null, reportLineItemDefinitions); @@ -271,315 +214,163 @@ public class ProvideDetailedClassificationReportAccTest { LOGGER.debug(reportToString(report, reportLineItemDefinitions)); } - DetailedReportLine line1 = (DetailedReportLine) report.getReportLines().get("L10000"); - assertEquals(6, line1.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, line1.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, line1.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, line1.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, line1.getLineItems().get(4).getNumberOfTasks()); + assertNotNull(report); + assertEquals(5, report.rowSize()); - ReportLine detailedLine1 = line1.getDetailLines().get("L11000"); - assertEquals(2, detailedLine1.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, detailedLine1.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLine1.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLine1.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, detailedLine1.getLineItems().get(4).getNumberOfTasks()); + DetailedReportRow line1 = report.getRow("L10000"); + assertArrayEquals(new int[] {6, 0, 0, 0, 0}, line1.getCells()); - ReportLine detailedLineNoAttachment1 = line1.getDetailLines().get("N/A"); - assertEquals(4, detailedLineNoAttachment1.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment1.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment1.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment1.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment1.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLine1 = line1.getDetailRows().get("L11000"); + assertArrayEquals(new int[] {2, 0, 0, 0, 0}, detailedLine1.getCells()); - DetailedReportLine line2 = (DetailedReportLine) report.getReportLines().get("L20000"); - assertEquals(2, line2.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, line2.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, line2.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, line2.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, line2.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLineNoAttachment1 = line1.getDetailRows().get("N/A"); + assertArrayEquals(new int[] {4, 0, 0, 0, 0}, detailedLineNoAttachment1.getCells()); - ReportLine detailedLine2 = line2.getDetailLines().get("L22000"); - assertEquals(1, detailedLine2.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, detailedLine2.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLine2.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLine2.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, detailedLine2.getLineItems().get(4).getNumberOfTasks()); + DetailedReportRow line2 = report.getRow("L20000"); + assertArrayEquals(new int[] {2, 0, 0, 0, 0}, line2.getCells()); - ReportLine detailedLineNoAttachment2 = line2.getDetailLines().get("N/A"); - assertEquals(1, detailedLineNoAttachment2.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment2.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment2.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment2.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment2.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLine2 = line2.getDetailRows().get("L22000"); + assertArrayEquals(new int[] {1, 0, 0, 0, 0}, detailedLine2.getCells()); - DetailedReportLine line3 = (DetailedReportLine) report.getReportLines().get("L30000"); - 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(1, line3.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLineNoAttachment2 = line2.getDetailRows().get("N/A"); + assertArrayEquals(new int[] {1, 0, 0, 0, 0}, detailedLineNoAttachment2.getCells()); - ReportLine detailedLine3a = line3.getDetailLines().get("L33000"); - 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()); + DetailedReportRow line3 = report.getRow("L30000"); + assertArrayEquals(new int[] {2, 1, 0, 1, 1}, line3.getCells()); - ReportLine detailedLineNoAttachment3 = line3.getDetailLines().get("N/A"); - assertEquals(2, detailedLineNoAttachment3.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment3.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment3.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment3.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment3.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLine3a = line3.getDetailRows().get("L33000"); + assertArrayEquals(new int[] {0, 1, 0, 1, 1}, detailedLine3a.getCells()); - DetailedReportLine line4 = (DetailedReportLine) report.getReportLines().get("L40000"); - assertEquals(1, line4.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, line4.getLineItems().get(1).getNumberOfTasks()); - assertEquals(1, line4.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, line4.getLineItems().get(3).getNumberOfTasks()); - assertEquals(1, line4.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLineNoAttachment3 = line3.getDetailRows().get("N/A"); + assertArrayEquals(new int[] {2, 0, 0, 0, 0}, detailedLineNoAttachment3.getCells()); - ReportLine detailedLineNoAttachment4 = line4.getDetailLines().get("N/A"); - assertEquals(1, detailedLineNoAttachment4.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment4.getLineItems().get(1).getNumberOfTasks()); - assertEquals(1, detailedLineNoAttachment4.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment4.getLineItems().get(3).getNumberOfTasks()); - assertEquals(1, detailedLineNoAttachment4.getLineItems().get(4).getNumberOfTasks()); + DetailedReportRow line4 = report.getRow("L40000"); + assertArrayEquals(new int[] {1, 0, 1, 0, 1}, line4.getCells()); - DetailedReportLine line5 = (DetailedReportLine) report.getReportLines().get("L50000"); - assertEquals(2, line5.getLineItems().get(0).getNumberOfTasks()); - assertEquals(2, line5.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, line5.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, line5.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, line5.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLineNoAttachment4 = line4.getDetailRows().get("N/A"); + assertArrayEquals(new int[] {1, 0, 1, 0, 1}, detailedLineNoAttachment4.getCells()); - ReportLine detailedLineNoAttachment5 = line5.getDetailLines().get("N/A"); - assertEquals(2, detailedLineNoAttachment5.getLineItems().get(0).getNumberOfTasks()); - assertEquals(2, detailedLineNoAttachment5.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment5.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment5.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment5.getLineItems().get(4).getNumberOfTasks()); + DetailedReportRow line5 = report.getRow("L50000"); + assertArrayEquals(new int[] {2, 2, 0, 0, 0}, line5.getCells()); + + ReportRow detailedLineNoAttachment5 = line5.getDetailRows().get("N/A"); + assertArrayEquals(new int[] {2, 2, 0, 0, 0}, detailedLineNoAttachment5.getCells()); } @Test public void testEachItemOfDetailedClassificationReportWithStateFilter() throws InvalidArgumentException { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); - List states = Arrays.asList(TaskState.READY); - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + List states = Collections.singletonList(TaskState.READY); + List columnHeaders = getShortListOfColumnHeaders(); DetailedClassificationReport report = taskMonitorService.getDetailedClassificationReport(null, states, null, - null, - null, null, reportLineItemDefinitions); + null, null, null, columnHeaders); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } - DetailedReportLine line1 = (DetailedReportLine) report.getReportLines().get("L10000"); - 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()); + assertNotNull(report); + assertEquals(5, report.rowSize()); - ReportLine detailedLine1 = line1.getDetailLines().get("L11000"); - assertEquals(2, detailedLine1.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, detailedLine1.getLineItems().get(1).getNumberOfTasks()); - assertEquals(1, detailedLine1.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLine1.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, detailedLine1.getLineItems().get(4).getNumberOfTasks()); + DetailedReportRow line1 = report.getRow("L10000"); + assertArrayEquals(new int[] {7, 2, 1, 0, 0}, line1.getCells()); - ReportLine detailedLineNoAttachment1 = line1.getDetailLines().get("N/A"); - assertEquals(5, detailedLineNoAttachment1.getLineItems().get(0).getNumberOfTasks()); - assertEquals(2, detailedLineNoAttachment1.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment1.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment1.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment1.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLine1 = line1.getDetailRows().get("L11000"); + assertArrayEquals(new int[] {2, 0, 1, 0, 0}, detailedLine1.getCells()); - DetailedReportLine line2 = (DetailedReportLine) report.getReportLines().get("L20000"); - 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()); + ReportRow detailedLineNoAttachment1 = line1.getDetailRows().get("N/A"); + assertArrayEquals(new int[] {5, 2, 0, 0, 0}, detailedLineNoAttachment1.getCells()); - ReportLine detailedLine2 = line2.getDetailLines().get("L22000"); - assertEquals(1, detailedLine2.getLineItems().get(0).getNumberOfTasks()); - assertEquals(1, detailedLine2.getLineItems().get(1).getNumberOfTasks()); - assertEquals(1, detailedLine2.getLineItems().get(2).getNumberOfTasks()); - assertEquals(1, detailedLine2.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, detailedLine2.getLineItems().get(4).getNumberOfTasks()); + DetailedReportRow line2 = report.getRow("L20000"); + assertArrayEquals(new int[] {5, 3, 1, 1, 0}, line2.getCells()); - ReportLine detailedLineNoAttachment2 = line2.getDetailLines().get("N/A"); - assertEquals(4, detailedLineNoAttachment2.getLineItems().get(0).getNumberOfTasks()); - assertEquals(2, detailedLineNoAttachment2.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment2.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment2.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment2.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLine2 = line2.getDetailRows().get("L22000"); + assertArrayEquals(new int[] {1, 1, 1, 1, 0}, detailedLine2.getCells()); - DetailedReportLine line3 = (DetailedReportLine) report.getReportLines().get("L30000"); - 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(0, line3.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLineNoAttachment2 = line2.getDetailRows().get("N/A"); + assertArrayEquals(new int[] {4, 2, 0, 0, 0}, detailedLineNoAttachment2.getCells()); - ReportLine detailedLine3a = line3.getDetailLines().get("L33000"); - 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(0, detailedLine3a.getLineItems().get(4).getNumberOfTasks()); + DetailedReportRow line3 = report.getRow("L30000"); + assertArrayEquals(new int[] {2, 1, 0, 1, 0}, line3.getCells()); - ReportLine detailedLineNoAttachment3 = line3.getDetailLines().get("N/A"); - assertEquals(2, detailedLineNoAttachment3.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment3.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment3.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment3.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment3.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLine3a = line3.getDetailRows().get("L33000"); + assertArrayEquals(new int[] {0, 1, 0, 1, 0}, detailedLine3a.getCells()); - DetailedReportLine line4 = (DetailedReportLine) report.getReportLines().get("L40000"); - assertEquals(2, line4.getLineItems().get(0).getNumberOfTasks()); - assertEquals(2, line4.getLineItems().get(1).getNumberOfTasks()); - assertEquals(2, line4.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, line4.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, line4.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLineNoAttachment3 = line3.getDetailRows().get("N/A"); + assertArrayEquals(new int[] {2, 0, 0, 0, 0}, detailedLineNoAttachment3.getCells()); - ReportLine detailedLineNoAttachment4 = line4.getDetailLines().get("N/A"); - assertEquals(2, detailedLineNoAttachment4.getLineItems().get(0).getNumberOfTasks()); - assertEquals(2, detailedLineNoAttachment4.getLineItems().get(1).getNumberOfTasks()); - assertEquals(2, detailedLineNoAttachment4.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment4.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment4.getLineItems().get(4).getNumberOfTasks()); + DetailedReportRow line4 = report.getRow("L40000"); + assertArrayEquals(new int[] {2, 2, 2, 0, 0}, line4.getCells()); - DetailedReportLine line5 = (DetailedReportLine) report.getReportLines().get("L50000"); - assertEquals(3, line5.getLineItems().get(0).getNumberOfTasks()); - assertEquals(3, line5.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, line5.getLineItems().get(2).getNumberOfTasks()); - assertEquals(5, line5.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, line5.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLineNoAttachment4 = line4.getDetailRows().get("N/A"); + assertArrayEquals(new int[] {2, 2, 2, 0, 0}, detailedLineNoAttachment4.getCells()); - ReportLine detailedLineNoAttachment5 = line5.getDetailLines().get("N/A"); - assertEquals(3, detailedLineNoAttachment5.getLineItems().get(0).getNumberOfTasks()); - assertEquals(3, detailedLineNoAttachment5.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment5.getLineItems().get(2).getNumberOfTasks()); - assertEquals(5, detailedLineNoAttachment5.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment5.getLineItems().get(4).getNumberOfTasks()); + DetailedReportRow line5 = report.getRow("L50000"); + assertArrayEquals(new int[] {3, 3, 0, 5, 0}, line5.getCells()); + + ReportRow detailedLineNoAttachment5 = line5.getDetailRows().get("N/A"); + assertArrayEquals(new int[] {3, 3, 0, 5, 0}, detailedLineNoAttachment5.getCells()); } @Test public void testEachItemOfDetailedClassificationReportNotInWorkingDays() throws InvalidArgumentException { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + List columnHeaders = getShortListOfColumnHeaders(); DetailedClassificationReport report = taskMonitorService.getDetailedClassificationReport(null, null, null, null, - null, null, reportLineItemDefinitions, false); + null, null, columnHeaders, false); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } - DetailedReportLine line1 = (DetailedReportLine) report.getReportLines().get("L10000"); - assertEquals(9, line1.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, 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()); + assertNotNull(report); + assertEquals(5, report.rowSize()); - ReportLine detailedLine1 = line1.getDetailLines().get("L11000"); - assertEquals(2, detailedLine1.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, detailedLine1.getLineItems().get(1).getNumberOfTasks()); - assertEquals(1, detailedLine1.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLine1.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, detailedLine1.getLineItems().get(4).getNumberOfTasks()); + DetailedReportRow line1 = report.getRow("L10000"); + assertArrayEquals(new int[] {9, 0, 1, 0, 0}, line1.getCells()); - ReportLine detailedLineNoAttachment1 = line1.getDetailLines().get("N/A"); - assertEquals(7, detailedLineNoAttachment1.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment1.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment1.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment1.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment1.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLine1 = line1.getDetailRows().get("L11000"); + assertArrayEquals(new int[] {2, 0, 1, 0, 0}, detailedLine1.getCells()); - DetailedReportLine line2 = (DetailedReportLine) report.getReportLines().get("L20000"); - assertEquals(8, line2.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, line2.getLineItems().get(1).getNumberOfTasks()); - assertEquals(1, line2.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, line2.getLineItems().get(3).getNumberOfTasks()); - assertEquals(1, line2.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLineNoAttachment1 = line1.getDetailRows().get("N/A"); + assertArrayEquals(new int[] {7, 0, 0, 0, 0}, detailedLineNoAttachment1.getCells()); - ReportLine detailedLine2 = line2.getDetailLines().get("L22000"); - assertEquals(2, detailedLine2.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, detailedLine2.getLineItems().get(1).getNumberOfTasks()); - assertEquals(1, detailedLine2.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLine2.getLineItems().get(3).getNumberOfTasks()); - assertEquals(1, detailedLine2.getLineItems().get(4).getNumberOfTasks()); + DetailedReportRow line2 = report.getRow("L20000"); + assertArrayEquals(new int[] {8, 0, 1, 0, 1}, line2.getCells()); - ReportLine detailedLineNoAttachment2 = line2.getDetailLines().get("N/A"); - assertEquals(6, detailedLineNoAttachment2.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment2.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment2.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment2.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment2.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLine2 = line2.getDetailRows().get("L22000"); + assertArrayEquals(new int[] {2, 0, 1, 0, 1}, detailedLine2.getCells()); - DetailedReportLine line3 = (DetailedReportLine) report.getReportLines().get("L30000"); - assertEquals(3, line3.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, line3.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, line3.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, line3.getLineItems().get(3).getNumberOfTasks()); - assertEquals(4, line3.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLineNoAttachment2 = line2.getDetailRows().get("N/A"); + assertArrayEquals(new int[] {6, 0, 0, 0, 0}, detailedLineNoAttachment2.getCells()); - ReportLine detailedLine3a = line3.getDetailLines().get("L33000"); - assertEquals(1, detailedLine3a.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, detailedLine3a.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLine3a.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLine3a.getLineItems().get(3).getNumberOfTasks()); - assertEquals(2, detailedLine3a.getLineItems().get(4).getNumberOfTasks()); + DetailedReportRow line3 = report.getRow("L30000"); + assertArrayEquals(new int[] {3, 0, 0, 0, 4}, line3.getCells()); - ReportLine detailedLine3b = line3.getDetailLines().get("L99000"); - assertEquals(0, detailedLine3b.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, detailedLine3b.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLine3b.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLine3b.getLineItems().get(3).getNumberOfTasks()); - assertEquals(1, detailedLine3b.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLine3a = line3.getDetailRows().get("L33000"); + assertArrayEquals(new int[] {1, 0, 0, 0, 2}, detailedLine3a.getCells()); - ReportLine detailedLineNoAttachment3 = line3.getDetailLines().get("N/A"); - assertEquals(2, detailedLineNoAttachment3.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment3.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment3.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment3.getLineItems().get(3).getNumberOfTasks()); - assertEquals(1, detailedLineNoAttachment3.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLine3b = line3.getDetailRows().get("L99000"); + assertArrayEquals(new int[] {0, 0, 0, 0, 1}, detailedLine3b.getCells()); - DetailedReportLine line4 = (DetailedReportLine) report.getReportLines().get("L40000"); - assertEquals(4, line4.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, line4.getLineItems().get(1).getNumberOfTasks()); - assertEquals(2, line4.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, line4.getLineItems().get(3).getNumberOfTasks()); - assertEquals(4, line4.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLineNoAttachment3 = line3.getDetailRows().get("N/A"); + assertArrayEquals(new int[] {2, 0, 0, 0, 1}, detailedLineNoAttachment3.getCells()); - ReportLine detailedLineNoAttachment4 = line4.getDetailLines().get("N/A"); - assertEquals(4, detailedLineNoAttachment4.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment4.getLineItems().get(1).getNumberOfTasks()); - assertEquals(2, detailedLineNoAttachment4.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment4.getLineItems().get(3).getNumberOfTasks()); - assertEquals(4, detailedLineNoAttachment4.getLineItems().get(4).getNumberOfTasks()); + DetailedReportRow line4 = report.getRow("L40000"); + assertArrayEquals(new int[] {4, 0, 2, 0, 4}, line4.getCells()); - DetailedReportLine line5 = (DetailedReportLine) report.getReportLines().get("L50000"); - assertEquals(6, line5.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, line5.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, line5.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, line5.getLineItems().get(3).getNumberOfTasks()); - assertEquals(7, line5.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLineNoAttachment4 = line4.getDetailRows().get("N/A"); + assertArrayEquals(new int[] {4, 0, 2, 0, 4}, detailedLineNoAttachment4.getCells()); - ReportLine detailedLineNoAttachment5 = line5.getDetailLines().get("N/A"); - assertEquals(6, detailedLineNoAttachment5.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment5.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment5.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment5.getLineItems().get(3).getNumberOfTasks()); - assertEquals(7, detailedLineNoAttachment5.getLineItems().get(4).getNumberOfTasks()); + DetailedReportRow line5 = report.getRow("L50000"); + assertArrayEquals(new int[] {6, 0, 0, 0, 7}, line5.getCells()); + + ReportRow detailedLineNoAttachment5 = line5.getDetailRows().get("N/A"); + assertArrayEquals(new int[] {6, 0, 0, 0, 7}, detailedLineNoAttachment5.getCells()); } @Test @@ -587,164 +378,93 @@ public class ProvideDetailedClassificationReportAccTest { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); List categories = Arrays.asList("AUTOMATIC", "MANUAL"); - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + List columnHeaders = getShortListOfColumnHeaders(); DetailedClassificationReport report = taskMonitorService.getDetailedClassificationReport(null, null, categories, - null, null, null, reportLineItemDefinitions); + null, null, null, columnHeaders); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } - DetailedReportLine line1 = (DetailedReportLine) report.getReportLines().get("L30000"); - 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()); + assertNotNull(report); + assertEquals(2, report.rowSize()); - ReportLine detailedLine1a = line1.getDetailLines().get("L33000"); - 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()); + DetailedReportRow line1 = report.getRow("L30000"); + assertArrayEquals(new int[] {2, 1, 0, 1, 3}, line1.getCells()); - ReportLine detailedLine1b = line1.getDetailLines().get("L99000"); - assertEquals(0, detailedLine1b.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, detailedLine1b.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLine1b.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLine1b.getLineItems().get(3).getNumberOfTasks()); - assertEquals(1, detailedLine1b.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLine1a = line1.getDetailRows().get("L33000"); + assertArrayEquals(new int[] {0, 1, 0, 1, 1}, detailedLine1a.getCells()); - ReportLine detailedLine1WithoutAttachment = line1.getDetailLines().get("N/A"); - assertEquals(2, detailedLine1WithoutAttachment.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, detailedLine1WithoutAttachment.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLine1WithoutAttachment.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLine1WithoutAttachment.getLineItems().get(3).getNumberOfTasks()); - assertEquals(1, detailedLine1WithoutAttachment.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLine1b = line1.getDetailRows().get("L99000"); + assertArrayEquals(new int[] {0, 0, 0, 0, 1}, detailedLine1b.getCells()); - DetailedReportLine line2 = (DetailedReportLine) report.getReportLines().get("L40000"); - assertEquals(2, line2.getLineItems().get(0).getNumberOfTasks()); - assertEquals(2, line2.getLineItems().get(1).getNumberOfTasks()); - assertEquals(2, line2.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, line2.getLineItems().get(3).getNumberOfTasks()); - assertEquals(4, line2.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLine1WithoutAttachment = line1.getDetailRows().get("N/A"); + assertArrayEquals(new int[] {2, 0, 0, 0, 1}, detailedLine1WithoutAttachment.getCells()); - ReportLine detailedLine2WithoutAttachment = line2.getDetailLines().get("N/A"); - assertEquals(2, detailedLine2WithoutAttachment.getLineItems().get(0).getNumberOfTasks()); - assertEquals(2, detailedLine2WithoutAttachment.getLineItems().get(1).getNumberOfTasks()); - assertEquals(2, detailedLine2WithoutAttachment.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLine2WithoutAttachment.getLineItems().get(3).getNumberOfTasks()); - assertEquals(4, detailedLine2WithoutAttachment.getLineItems().get(4).getNumberOfTasks()); + DetailedReportRow line2 = report.getRow("L40000"); + assertArrayEquals(new int[] {2, 2, 2, 0, 4}, line2.getCells()); + + ReportRow detailedLine2WithoutAttachment = line2.getDetailRows().get("N/A"); + assertArrayEquals(new int[] {2, 2, 2, 0, 4}, detailedLine2WithoutAttachment.getCells()); - assertEquals(2, report.getReportLines().size()); } @Test public void testEachItemOfDetailedClassificationReportWithDomainFilter() throws InvalidArgumentException { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); - List domains = Arrays.asList("DOMAIN_A"); - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + List domains = Collections.singletonList("DOMAIN_A"); + List columnHeaders = getShortListOfColumnHeaders(); DetailedClassificationReport report = taskMonitorService.getDetailedClassificationReport(null, null, null, - domains, null, null, reportLineItemDefinitions); + domains, null, null, columnHeaders); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } - DetailedReportLine line1 = (DetailedReportLine) report.getReportLines().get("L10000"); - 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()); + assertNotNull(report); + assertEquals(5, report.rowSize()); - ReportLine detailedLine1 = line1.getDetailLines().get("L11000"); - assertEquals(1, detailedLine1.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, detailedLine1.getLineItems().get(1).getNumberOfTasks()); - assertEquals(1, detailedLine1.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLine1.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, detailedLine1.getLineItems().get(4).getNumberOfTasks()); + DetailedReportRow line1 = report.getRow("L10000"); + assertArrayEquals(new int[] {5, 2, 1, 0, 0}, line1.getCells()); - ReportLine detailedLineNoAttachment1 = line1.getDetailLines().get("N/A"); - assertEquals(4, detailedLineNoAttachment1.getLineItems().get(0).getNumberOfTasks()); - assertEquals(2, detailedLineNoAttachment1.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment1.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment1.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment1.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLine1 = line1.getDetailRows().get("L11000"); + assertArrayEquals(new int[] {1, 0, 1, 0, 0}, detailedLine1.getCells()); - DetailedReportLine line2 = (DetailedReportLine) report.getReportLines().get("L20000"); - 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()); + ReportRow detailedLineNoAttachment1 = line1.getDetailRows().get("N/A"); + assertArrayEquals(new int[] {4, 2, 0, 0, 0}, detailedLineNoAttachment1.getCells()); - ReportLine detailedLine2 = line2.getDetailLines().get("L22000"); - assertEquals(1, detailedLine2.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, detailedLine2.getLineItems().get(1).getNumberOfTasks()); - assertEquals(1, detailedLine2.getLineItems().get(2).getNumberOfTasks()); - assertEquals(1, detailedLine2.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, detailedLine2.getLineItems().get(4).getNumberOfTasks()); + DetailedReportRow line2 = report.getRow("L20000"); + assertArrayEquals(new int[] {3, 1, 1, 1, 0}, line2.getCells()); - ReportLine detailedLineNoAttachment2 = line2.getDetailLines().get("N/A"); - assertEquals(2, detailedLineNoAttachment2.getLineItems().get(0).getNumberOfTasks()); - assertEquals(1, detailedLineNoAttachment2.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment2.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment2.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment2.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLine2 = line2.getDetailRows().get("L22000"); + assertArrayEquals(new int[] {1, 0, 1, 1, 0}, detailedLine2.getCells()); - DetailedReportLine line3 = (DetailedReportLine) report.getReportLines().get("L30000"); - 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()); + ReportRow detailedLineNoAttachment2 = line2.getDetailRows().get("N/A"); + assertArrayEquals(new int[] {2, 1, 0, 0, 0}, detailedLineNoAttachment2.getCells()); - ReportLine detailedLine3 = line3.getDetailLines().get("L33000"); - assertEquals(0, detailedLine3.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, detailedLine3.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLine3.getLineItems().get(2).getNumberOfTasks()); - assertEquals(1, detailedLine3.getLineItems().get(3).getNumberOfTasks()); - assertEquals(1, detailedLine3.getLineItems().get(4).getNumberOfTasks()); + DetailedReportRow line3 = report.getRow("L30000"); + assertArrayEquals(new int[] {1, 0, 0, 1, 1}, line3.getCells()); - ReportLine detailedLineNoAttachment3 = line3.getDetailLines().get("N/A"); - assertEquals(1, detailedLineNoAttachment3.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment3.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment3.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment3.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment3.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLine3 = line3.getDetailRows().get("L33000"); + assertArrayEquals(new int[] {0, 0, 0, 1, 1}, detailedLine3.getCells()); - DetailedReportLine line4 = (DetailedReportLine) report.getReportLines().get("L40000"); - assertEquals(2, line4.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, line4.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, line4.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, line4.getLineItems().get(3).getNumberOfTasks()); - assertEquals(3, line4.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLineNoAttachment3 = line3.getDetailRows().get("N/A"); + assertArrayEquals(new int[] {1, 0, 0, 0, 0}, detailedLineNoAttachment3.getCells()); - ReportLine detailedLineNoAttachment4 = line4.getDetailLines().get("N/A"); - assertEquals(2, detailedLineNoAttachment4.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment4.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment4.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment4.getLineItems().get(3).getNumberOfTasks()); - assertEquals(3, detailedLineNoAttachment4.getLineItems().get(4).getNumberOfTasks()); + DetailedReportRow line4 = report.getRow("L40000"); + assertArrayEquals(new int[] {2, 0, 0, 0, 3}, line4.getCells()); - DetailedReportLine line5 = (DetailedReportLine) report.getReportLines().get("L50000"); - assertEquals(0, line5.getLineItems().get(0).getNumberOfTasks()); - assertEquals(1, line5.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, line5.getLineItems().get(2).getNumberOfTasks()); - assertEquals(3, line5.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, line5.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLineNoAttachment4 = line4.getDetailRows().get("N/A"); + assertArrayEquals(new int[] {2, 0, 0, 0, 3}, detailedLineNoAttachment4.getCells()); - ReportLine detailedLineNoAttachment5 = line5.getDetailLines().get("N/A"); - assertEquals(0, detailedLineNoAttachment5.getLineItems().get(0).getNumberOfTasks()); - assertEquals(1, detailedLineNoAttachment5.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment5.getLineItems().get(2).getNumberOfTasks()); - assertEquals(3, detailedLineNoAttachment5.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment5.getLineItems().get(4).getNumberOfTasks()); + DetailedReportRow line5 = report.getRow("L50000"); + assertArrayEquals(new int[] {0, 1, 0, 3, 0}, line5.getCells()); + + ReportRow detailedLineNoAttachment5 = line5.getDetailRows().get("N/A"); + assertArrayEquals(new int[] {0, 1, 0, 3, 0}, detailedLineNoAttachment5.getCells()); } @Test @@ -752,143 +472,94 @@ public class ProvideDetailedClassificationReportAccTest { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); CustomField customField = CustomField.CUSTOM_1; - List customFieldValues = Arrays.asList("Geschaeftsstelle A"); - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + List customFieldValues = Collections.singletonList("Geschaeftsstelle A"); + List columnHeaders = getShortListOfColumnHeaders(); DetailedClassificationReport report = taskMonitorService.getDetailedClassificationReport(null, null, - null, null, customField, customFieldValues, reportLineItemDefinitions); + null, null, customField, customFieldValues, columnHeaders); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } - DetailedReportLine line1 = (DetailedReportLine) report.getReportLines().get("L10000"); - assertEquals(4, line1.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, line1.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, line1.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, line1.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, line1.getLineItems().get(4).getNumberOfTasks()); + assertNotNull(report); + assertEquals(5, report.rowSize()); - ReportLine detailedLine1 = line1.getDetailLines().get("L11000"); - assertEquals(1, detailedLine1.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, detailedLine1.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLine1.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLine1.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, detailedLine1.getLineItems().get(4).getNumberOfTasks()); + DetailedReportRow line1 = report.getRow("L10000"); + assertArrayEquals(new int[] {4, 0, 0, 0, 0}, line1.getCells()); - ReportLine detailedLineNoAttachment1 = line1.getDetailLines().get("N/A"); - assertEquals(3, detailedLineNoAttachment1.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment1.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment1.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment1.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment1.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLine1 = line1.getDetailRows().get("L11000"); + assertArrayEquals(new int[] {1, 0, 0, 0, 0}, detailedLine1.getCells()); - DetailedReportLine line2 = (DetailedReportLine) report.getReportLines().get("L20000"); - assertEquals(4, 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()); + ReportRow detailedLineNoAttachment1 = line1.getDetailRows().get("N/A"); + assertArrayEquals(new int[] {3, 0, 0, 0, 0}, detailedLineNoAttachment1.getCells()); - ReportLine detailedLine2 = line2.getDetailLines().get("L22000"); - assertEquals(1, detailedLine2.getLineItems().get(0).getNumberOfTasks()); - assertEquals(1, detailedLine2.getLineItems().get(1).getNumberOfTasks()); - assertEquals(1, detailedLine2.getLineItems().get(2).getNumberOfTasks()); - assertEquals(1, detailedLine2.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, detailedLine2.getLineItems().get(4).getNumberOfTasks()); + DetailedReportRow line2 = report.getRow("L20000"); + assertArrayEquals(new int[] {4, 1, 1, 1, 0}, line2.getCells()); - ReportLine detailedLineNoAttachment2 = line2.getDetailLines().get("N/A"); - assertEquals(3, detailedLineNoAttachment2.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment2.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment2.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment2.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment2.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLine2 = line2.getDetailRows().get("L22000"); + assertArrayEquals(new int[] {1, 1, 1, 1, 0}, detailedLine2.getCells()); - DetailedReportLine line3 = (DetailedReportLine) report.getReportLines().get("L30000"); - 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()); + ReportRow detailedLineNoAttachment2 = line2.getDetailRows().get("N/A"); + assertArrayEquals(new int[] {3, 0, 0, 0, 0}, detailedLineNoAttachment2.getCells()); - ReportLine detailedLine3a = line3.getDetailLines().get("L33000"); - assertEquals(0, detailedLine3a.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, detailedLine3a.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLine3a.getLineItems().get(2).getNumberOfTasks()); - assertEquals(1, detailedLine3a.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, detailedLine3a.getLineItems().get(4).getNumberOfTasks()); + DetailedReportRow line3 = report.getRow("L30000"); + assertArrayEquals(new int[] {1, 0, 0, 1, 1}, line3.getCells()); - ReportLine detailedLineNoAttachment3 = line3.getDetailLines().get("N/A"); - assertEquals(1, detailedLineNoAttachment3.getLineItems().get(0).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment3.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment3.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment3.getLineItems().get(3).getNumberOfTasks()); - assertEquals(1, detailedLineNoAttachment3.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLine3a = line3.getDetailRows().get("L33000"); + assertArrayEquals(new int[] {0, 0, 0, 1, 0}, detailedLine3a.getCells()); - DetailedReportLine line4 = (DetailedReportLine) report.getReportLines().get("L40000"); - assertEquals(1, line4.getLineItems().get(0).getNumberOfTasks()); - assertEquals(1, line4.getLineItems().get(1).getNumberOfTasks()); - assertEquals(2, line4.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, line4.getLineItems().get(3).getNumberOfTasks()); - assertEquals(2, line4.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLineNoAttachment3 = line3.getDetailRows().get("N/A"); + assertArrayEquals(new int[] {1, 0, 0, 0, 1}, detailedLineNoAttachment3.getCells()); - ReportLine detailedLineNoAttachment4 = line4.getDetailLines().get("N/A"); - assertEquals(1, detailedLineNoAttachment4.getLineItems().get(0).getNumberOfTasks()); - assertEquals(1, detailedLineNoAttachment4.getLineItems().get(1).getNumberOfTasks()); - assertEquals(2, detailedLineNoAttachment4.getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment4.getLineItems().get(3).getNumberOfTasks()); - assertEquals(2, detailedLineNoAttachment4.getLineItems().get(4).getNumberOfTasks()); + DetailedReportRow line4 = report.getRow("L40000"); + assertArrayEquals(new int[] {1, 1, 2, 0, 2}, line4.getCells()); - DetailedReportLine line5 = (DetailedReportLine) report.getReportLines().get("L50000"); - assertEquals(1, line5.getLineItems().get(0).getNumberOfTasks()); - assertEquals(2, line5.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, line5.getLineItems().get(2).getNumberOfTasks()); - assertEquals(2, line5.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, line5.getLineItems().get(4).getNumberOfTasks()); + ReportRow detailedLineNoAttachment4 = line4.getDetailRows().get("N/A"); + assertArrayEquals(new int[] {1, 1, 2, 0, 2}, detailedLineNoAttachment4.getCells()); - ReportLine detailedLineNoAttachment5 = line5.getDetailLines().get("N/A"); - assertEquals(1, detailedLineNoAttachment5.getLineItems().get(0).getNumberOfTasks()); - assertEquals(2, detailedLineNoAttachment5.getLineItems().get(1).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment5.getLineItems().get(2).getNumberOfTasks()); - assertEquals(2, detailedLineNoAttachment5.getLineItems().get(3).getNumberOfTasks()); - assertEquals(0, detailedLineNoAttachment5.getLineItems().get(4).getNumberOfTasks()); + DetailedReportRow line5 = report.getRow("L50000"); + assertArrayEquals(new int[] {1, 2, 0, 2, 0}, line5.getCells()); + + ReportRow detailedLineNoAttachment5 = line5.getDetailRows().get("N/A"); + assertArrayEquals(new int[] {1, 2, 0, 2, 0}, detailedLineNoAttachment5.getCells()); } - private List getListOfReportLineItemDefinitions() { - List reportLineItemDefinitions = new ArrayList<>(); - reportLineItemDefinitions.add(new ReportLineItemDefinition(Integer.MIN_VALUE, -11)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(-10, -6)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(-5, -2)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(-1)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(0)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(1)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(2, 5)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(6, 10)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(11, Integer.MAX_VALUE)); - return reportLineItemDefinitions; + private List getListOfColumnHeaders() { + List columnHeaders = new ArrayList<>(); + columnHeaders.add(new TimeIntervalColumnHeader(Integer.MIN_VALUE, -11)); + columnHeaders.add(new TimeIntervalColumnHeader(-10, -6)); + columnHeaders.add(new TimeIntervalColumnHeader(-5, -2)); + columnHeaders.add(new TimeIntervalColumnHeader(-1)); + columnHeaders.add(new TimeIntervalColumnHeader(0)); + columnHeaders.add(new TimeIntervalColumnHeader(1)); + columnHeaders.add(new TimeIntervalColumnHeader(2, 5)); + columnHeaders.add(new TimeIntervalColumnHeader(6, 10)); + columnHeaders.add(new TimeIntervalColumnHeader(11, Integer.MAX_VALUE)); + return columnHeaders; } - private List getShortListOfReportLineItemDefinitions() { - List reportLineItemDefinitions = new ArrayList<>(); - reportLineItemDefinitions.add(new ReportLineItemDefinition(Integer.MIN_VALUE, -6)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(-5, -1)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(0)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(1, 5)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(6, Integer.MAX_VALUE)); - return reportLineItemDefinitions; + private List getShortListOfColumnHeaders() { + List columnHeaders = new ArrayList<>(); + columnHeaders.add(new TimeIntervalColumnHeader(Integer.MIN_VALUE, -6)); + columnHeaders.add(new TimeIntervalColumnHeader(-5, -1)); + columnHeaders.add(new TimeIntervalColumnHeader(0)); + columnHeaders.add(new TimeIntervalColumnHeader(1, 5)); + columnHeaders.add(new TimeIntervalColumnHeader(6, Integer.MAX_VALUE)); + return columnHeaders; } - private String reportToString(Report report) { + private String reportToString(DetailedClassificationReport report) { return reportToString(report, null); } - private String reportToString(Report report, List reportLineItemDefinitions) { + private String reportToString(DetailedClassificationReport report, List columnHeaders) { String formatColumWidth = "| %-7s "; String formatFirstColumn = "| %-36s %-4s "; String formatFirstColumnFirstLine = "| %-29s %12s "; String formatFirstColumnDetailLines = "| + %-34s %-4s "; String formatFirstColumnSumLine = "| %-36s %-5s"; - int reportWidth = reportLineItemDefinitions == null ? 46 : reportLineItemDefinitions.size() * 10 + 46; + int reportWidth = columnHeaders == null ? 46 : columnHeaders.size() * 10 + 46; StringBuilder builder = new StringBuilder(); builder.append("\n"); @@ -897,8 +568,8 @@ public class ProvideDetailedClassificationReportAccTest { } builder.append("\n"); builder.append(String.format(formatFirstColumnFirstLine, "Classifications + Attachments", "Total")); - if (reportLineItemDefinitions != null) { - for (ReportLineItemDefinition def : reportLineItemDefinitions) { + if (columnHeaders != null) { + for (TimeIntervalColumnHeader def : columnHeaders) { if (def.getLowerAgeLimit() == Integer.MIN_VALUE) { builder.append(String.format(formatColumWidth, "< " + def.getUpperAgeLimit())); } else if (def.getUpperAgeLimit() == Integer.MAX_VALUE) { @@ -921,28 +592,23 @@ public class ProvideDetailedClassificationReportAccTest { } builder.append("\n"); - for (String rl : report.getReportLines().keySet()) { + for (String rl : report.getRowTitles()) { builder - .append(String.format(formatFirstColumn, rl, report.getReportLines().get(rl).getTotalNumberOfTasks())); - if (reportLineItemDefinitions != null) { - for (ReportLineItem reportLineItem : report.getReportLines().get(rl).getLineItems()) { - builder.append(String.format(formatColumWidth, reportLineItem.getNumberOfTasks())); + .append(String.format(formatFirstColumn, rl, report.getRow(rl).getTotalValue())); + if (columnHeaders != null) { + for (int cell : report.getRow(rl).getCells()) { + builder.append(String.format(formatColumWidth, cell)); } } builder.append("|\n"); - if (report instanceof DetailedClassificationReport) { - for (String detaileLine : ((DetailedReportLine) report.getReportLines().get(rl)).getDetailLines() - .keySet()) { - ReportLine reportLine = ((DetailedReportLine) report.getReportLines().get(rl)).getDetailLines() - .get(detaileLine); - builder.append( - String.format(formatFirstColumnDetailLines, detaileLine, - reportLine.getTotalNumberOfTasks())); - for (ReportLineItem reportLineItem : reportLine.getLineItems()) { - builder.append(String.format(formatColumWidth, reportLineItem.getNumberOfTasks())); - } - builder.append("|\n"); + for (String detaileLine : report.getRow(rl).getDetailRows().keySet()) { + ReportRow reportLine = report.getRow(rl).getDetailRows().get(detaileLine); + builder.append( + String.format(formatFirstColumnDetailLines, detaileLine, reportLine.getTotalValue())); + for (int cell : reportLine.getCells()) { + builder.append(String.format(formatColumWidth, cell)); } + builder.append("|\n"); } for (int i = 0; i < reportWidth; i++) { @@ -950,9 +616,9 @@ public class ProvideDetailedClassificationReportAccTest { } builder.append("\n"); } - builder.append(String.format(formatFirstColumnSumLine, "Total", report.getSumLine().getTotalNumberOfTasks())); - for (ReportLineItem sumLine : report.getSumLine().getLineItems()) { - builder.append(String.format(formatColumWidth, sumLine.getNumberOfTasks())); + builder.append(String.format(formatFirstColumnSumLine, "Total", report.getSumRow().getTotalValue())); + for (int cell : report.getSumRow().getCells()) { + builder.append(String.format(formatColumWidth, cell)); } builder.append("|\n"); for (int i = 0; i < reportWidth; i++) { diff --git a/lib/taskana-core/src/test/java/acceptance/monitoring/ProvideWorkbasketLevelReportAccTest.java b/lib/taskana-core/src/test/java/acceptance/monitoring/ProvideWorkbasketLevelReportAccTest.java index 71ea8a0f6..b1049d0a3 100644 --- a/lib/taskana-core/src/test/java/acceptance/monitoring/ProvideWorkbasketLevelReportAccTest.java +++ b/lib/taskana-core/src/test/java/acceptance/monitoring/ProvideWorkbasketLevelReportAccTest.java @@ -1,5 +1,6 @@ package acceptance.monitoring; +import static org.junit.Assert.assertArrayEquals; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; @@ -7,7 +8,9 @@ import java.io.IOException; import java.sql.SQLException; import java.util.ArrayList; import java.util.Arrays; +import java.util.Collections; import java.util.List; +import java.util.stream.IntStream; import javax.sql.DataSource; @@ -24,21 +27,19 @@ import pro.taskana.TaskanaEngine.ConnectionManagementMode; import pro.taskana.configuration.TaskanaEngineConfiguration; import pro.taskana.database.TestDataGenerator; import pro.taskana.exceptions.InvalidArgumentException; -import pro.taskana.impl.Report; -import pro.taskana.impl.ReportLineItem; -import pro.taskana.impl.ReportLineItemDefinition; -import pro.taskana.impl.TaskanaEngineImpl; import pro.taskana.impl.configuration.DBCleaner; import pro.taskana.impl.configuration.TaskanaEngineConfigurationTest; +import pro.taskana.impl.report.impl.TimeIntervalColumnHeader; +import pro.taskana.impl.report.impl.WorkbasketLevelReport; /** * Acceptance test for all "workbasket level report" scenarios. */ public class ProvideWorkbasketLevelReportAccTest { + private static final Logger LOGGER = LoggerFactory.getLogger(ProvideWorkbasketLevelReportAccTest.class); protected static TaskanaEngineConfiguration taskanaEngineConfiguration; protected static TaskanaEngine taskanaEngine; - private static final Logger LOGGER = LoggerFactory.getLogger(ProvideWorkbasketLevelReportAccTest.class); @BeforeClass public static void setupTest() throws Exception { @@ -53,7 +54,7 @@ public class ProvideWorkbasketLevelReportAccTest { taskanaEngineConfiguration = new TaskanaEngineConfiguration(dataSource, false); taskanaEngineConfiguration.setGermanPublicHolidaysEnabled(false); taskanaEngine = taskanaEngineConfiguration.buildTaskanaEngine(); - ((TaskanaEngineImpl) taskanaEngine).setConnectionManagementMode(ConnectionManagementMode.AUTOCOMMIT); + taskanaEngine.setConnectionManagementMode(ConnectionManagementMode.AUTOCOMMIT); cleaner.clearDb(dataSource, false); TestDataGenerator testDataGenerator = new TestDataGenerator(); testDataGenerator.generateMonitoringTestData(dataSource); @@ -63,58 +64,48 @@ public class ProvideWorkbasketLevelReportAccTest { public void testGetTotalNumbersOfTasksOfWorkbasketLevelReport() throws InvalidArgumentException { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); - Report report = taskMonitorService.getWorkbasketLevelReport(null, null, null, null, null, null); + WorkbasketLevelReport report = taskMonitorService.getWorkbasketLevelReport(null, null, null, null, null, null); if (LOGGER.isDebugEnabled()) { LOGGER.debug(reportToString(report)); } assertNotNull(report); - assertEquals(20, report.getReportLines().get("USER_1_1").getTotalNumberOfTasks()); - assertEquals(20, report.getReportLines().get("USER_1_2").getTotalNumberOfTasks()); - assertEquals(10, report.getReportLines().get("USER_1_3").getTotalNumberOfTasks()); - assertEquals(50, report.getSumLine().getTotalNumberOfTasks()); + assertEquals(3, report.rowSize()); + + assertEquals(20, report.getRow("USER_1_1").getTotalValue()); + assertEquals(20, report.getRow("USER_1_2").getTotalValue()); + assertEquals(10, report.getRow("USER_1_3").getTotalValue()); + + assertEquals(50, report.getSumRow().getTotalValue()); } @Test public void testGetWorkbasketLevelReportWithReportLineItemDefinitions() throws InvalidArgumentException { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); - List reportLineItemDefinitions = getListOfReportLineItemDefinitions(); + List columnHeaders = getListOfColumnHeaders(); - Report report = taskMonitorService.getWorkbasketLevelReport(null, null, null, null, null, null, - reportLineItemDefinitions); + WorkbasketLevelReport report = taskMonitorService.getWorkbasketLevelReport(null, null, null, null, null, null, + columnHeaders); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } - int sumLineCount = report.getSumLine().getLineItems().get(0).getNumberOfTasks() - + report.getSumLine().getLineItems().get(1).getNumberOfTasks() - + report.getSumLine().getLineItems().get(2).getNumberOfTasks() - + report.getSumLine().getLineItems().get(3).getNumberOfTasks() - + report.getSumLine().getLineItems().get(4).getNumberOfTasks() - + report.getSumLine().getLineItems().get(5).getNumberOfTasks() - + report.getSumLine().getLineItems().get(6).getNumberOfTasks() - + report.getSumLine().getLineItems().get(7).getNumberOfTasks() - + report.getSumLine().getLineItems().get(8).getNumberOfTasks(); + int sumLineCount = IntStream.of(report.getSumRow().getCells()).sum(); assertNotNull(report); + assertEquals(3, report.rowSize()); - assertEquals(20, report.getReportLines().get("USER_1_1").getTotalNumberOfTasks()); - assertEquals(20, report.getReportLines().get("USER_1_2").getTotalNumberOfTasks()); - assertEquals(10, report.getReportLines().get("USER_1_3").getTotalNumberOfTasks()); + assertEquals(20, report.getRow("USER_1_1").getTotalValue()); + assertEquals(20, report.getRow("USER_1_2").getTotalValue()); + assertEquals(10, report.getRow("USER_1_3").getTotalValue()); - assertEquals(10, report.getSumLine().getLineItems().get(0).getNumberOfTasks()); - assertEquals(9, report.getSumLine().getLineItems().get(1).getNumberOfTasks()); - assertEquals(11, report.getSumLine().getLineItems().get(2).getNumberOfTasks()); - assertEquals(0, report.getSumLine().getLineItems().get(3).getNumberOfTasks()); - assertEquals(4, report.getSumLine().getLineItems().get(4).getNumberOfTasks()); - assertEquals(0, report.getSumLine().getLineItems().get(5).getNumberOfTasks()); - assertEquals(7, report.getSumLine().getLineItems().get(6).getNumberOfTasks()); - assertEquals(4, report.getSumLine().getLineItems().get(7).getNumberOfTasks()); - assertEquals(5, report.getSumLine().getLineItems().get(8).getNumberOfTasks()); - assertEquals(50, report.getSumLine().getTotalNumberOfTasks()); + int[] sumRow = report.getSumRow().getCells(); + assertArrayEquals(new int[] {10, 9, 11, 0, 4, 0, 7, 4, 5}, sumRow); + + assertEquals(50, report.getSumRow().getTotalValue()); assertEquals(50, sumLineCount); } @@ -122,130 +113,102 @@ public class ProvideWorkbasketLevelReportAccTest { public void testEachItemOfWorkbasketLevelReport() throws InvalidArgumentException { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + List columnHeaders = getShortListOfColumnHeaders(); - Report report = taskMonitorService.getWorkbasketLevelReport(null, null, null, null, null, null, - reportLineItemDefinitions); + WorkbasketLevelReport report = taskMonitorService.getWorkbasketLevelReport(null, null, null, null, null, null, + columnHeaders); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } - List line1 = report.getReportLines().get("USER_1_1").getLineItems(); - assertEquals(13, line1.get(0).getNumberOfTasks()); - assertEquals(3, line1.get(1).getNumberOfTasks()); - assertEquals(1, line1.get(2).getNumberOfTasks()); - assertEquals(1, line1.get(3).getNumberOfTasks()); - assertEquals(2, line1.get(4).getNumberOfTasks()); + assertNotNull(report); + assertEquals(3, report.rowSize()); - List line2 = report.getReportLines().get("USER_1_2").getLineItems(); - assertEquals(4, line2.get(0).getNumberOfTasks()); - assertEquals(6, line2.get(1).getNumberOfTasks()); - assertEquals(3, line2.get(2).getNumberOfTasks()); - assertEquals(6, line2.get(3).getNumberOfTasks()); - assertEquals(1, line2.get(4).getNumberOfTasks()); + int[] row1 = report.getRow("USER_1_1").getCells(); + assertArrayEquals(new int[] {13, 3, 1, 1, 2}, row1); - List line3 = report.getReportLines().get("USER_1_3").getLineItems(); - assertEquals(2, line3.get(0).getNumberOfTasks()); - assertEquals(2, line3.get(1).getNumberOfTasks()); - assertEquals(0, line3.get(2).getNumberOfTasks()); - assertEquals(0, line3.get(3).getNumberOfTasks()); - assertEquals(6, line3.get(4).getNumberOfTasks()); + int[] row2 = report.getRow("USER_1_2").getCells(); + assertArrayEquals(new int[] {4, 6, 3, 6, 1}, row2); + + int[] row3 = report.getRow("USER_1_3").getCells(); + assertArrayEquals(new int[] {2, 2, 0, 0, 6}, row3); } @Test public void testEachItemOfWorkbasketLevelReportNotInWorkingDays() throws InvalidArgumentException { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + List columnHeaders = getShortListOfColumnHeaders(); - Report report = taskMonitorService.getWorkbasketLevelReport(null, null, null, null, null, null, - reportLineItemDefinitions, false); + WorkbasketLevelReport report = taskMonitorService.getWorkbasketLevelReport(null, null, null, null, null, null, + columnHeaders, false); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } - List line1 = report.getReportLines().get("USER_1_1").getLineItems(); - assertEquals(16, line1.get(0).getNumberOfTasks()); - assertEquals(0, line1.get(1).getNumberOfTasks()); - assertEquals(1, line1.get(2).getNumberOfTasks()); - assertEquals(0, line1.get(3).getNumberOfTasks()); - assertEquals(3, line1.get(4).getNumberOfTasks()); + assertNotNull(report); + assertEquals(3, report.rowSize()); - List line2 = report.getReportLines().get("USER_1_2").getLineItems(); - assertEquals(10, line2.get(0).getNumberOfTasks()); - assertEquals(0, line2.get(1).getNumberOfTasks()); - assertEquals(3, line2.get(2).getNumberOfTasks()); - assertEquals(0, line2.get(3).getNumberOfTasks()); - assertEquals(7, line2.get(4).getNumberOfTasks()); + int[] row1 = report.getRow("USER_1_1").getCells(); + assertArrayEquals(new int[] {16, 0, 1, 0, 3}, row1); - List line3 = report.getReportLines().get("USER_1_3").getLineItems(); - assertEquals(4, line3.get(0).getNumberOfTasks()); - assertEquals(0, line3.get(1).getNumberOfTasks()); - assertEquals(0, line3.get(2).getNumberOfTasks()); - assertEquals(0, line3.get(3).getNumberOfTasks()); - assertEquals(6, line3.get(4).getNumberOfTasks()); + int[] row2 = report.getRow("USER_1_2").getCells(); + assertArrayEquals(new int[] {10, 0, 3, 0, 7}, row2); + + int[] row3 = report.getRow("USER_1_3").getCells(); + assertArrayEquals(new int[] {4, 0, 0, 0, 6}, row3); } @Test public void testEachItemOfWorkbasketLevelReportWithWorkbasketFilter() throws InvalidArgumentException { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); - List workbasketIds = Arrays.asList("WBI:000000000000000000000000000000000001"); - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + List workbasketIds = Collections.singletonList("WBI:000000000000000000000000000000000001"); + List columnHeaders = getShortListOfColumnHeaders(); - Report report = taskMonitorService.getWorkbasketLevelReport(workbasketIds, null, null, null, null, null, - reportLineItemDefinitions); + WorkbasketLevelReport report = taskMonitorService.getWorkbasketLevelReport(workbasketIds, null, null, null, + null, null, + columnHeaders); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } - List line1 = report.getReportLines().get("USER_1_1").getLineItems(); - assertEquals(13, line1.get(0).getNumberOfTasks()); - assertEquals(3, line1.get(1).getNumberOfTasks()); - assertEquals(1, line1.get(2).getNumberOfTasks()); - assertEquals(1, line1.get(3).getNumberOfTasks()); - assertEquals(2, line1.get(4).getNumberOfTasks()); + assertNotNull(report); + assertEquals(1, report.rowSize()); + + int[] row1 = report.getRow("USER_1_1").getCells(); + assertArrayEquals(new int[] {13, 3, 1, 1, 2}, row1); - assertEquals(1, report.getReportLines().size()); } @Test public void testEachItemOfWorkbasketLevelReportWithStateFilter() throws InvalidArgumentException { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); - List states = Arrays.asList(TaskState.READY); - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + List states = Collections.singletonList(TaskState.READY); + List columnHeaders = getShortListOfColumnHeaders(); - Report report = taskMonitorService.getWorkbasketLevelReport(null, states, null, null, null, null, - reportLineItemDefinitions); + WorkbasketLevelReport report = taskMonitorService.getWorkbasketLevelReport(null, states, null, null, null, null, + columnHeaders); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } - List line1 = report.getReportLines().get("USER_1_1").getLineItems(); - assertEquals(13, line1.get(0).getNumberOfTasks()); - assertEquals(3, line1.get(1).getNumberOfTasks()); - assertEquals(1, line1.get(2).getNumberOfTasks()); - assertEquals(1, line1.get(3).getNumberOfTasks()); - assertEquals(0, line1.get(4).getNumberOfTasks()); + assertNotNull(report); + assertEquals(3, report.rowSize()); - List line2 = report.getReportLines().get("USER_1_2").getLineItems(); - assertEquals(4, line2.get(0).getNumberOfTasks()); - assertEquals(6, line2.get(1).getNumberOfTasks()); - assertEquals(3, line2.get(2).getNumberOfTasks()); - assertEquals(6, line2.get(3).getNumberOfTasks()); - assertEquals(0, line2.get(4).getNumberOfTasks()); + int[] row1 = report.getRow("USER_1_1").getCells(); + assertArrayEquals(new int[] {13, 3, 1, 1, 0}, row1); - List line3 = report.getReportLines().get("USER_1_3").getLineItems(); - assertEquals(2, line3.get(0).getNumberOfTasks()); - assertEquals(2, line3.get(1).getNumberOfTasks()); - assertEquals(0, line3.get(2).getNumberOfTasks()); - assertEquals(0, line3.get(3).getNumberOfTasks()); - assertEquals(0, line3.get(4).getNumberOfTasks()); + int[] row2 = report.getRow("USER_1_2").getCells(); + assertArrayEquals(new int[] {4, 6, 3, 6, 0}, row2); + + int[] row3 = report.getRow("USER_1_3").getCells(); + assertArrayEquals(new int[] {2, 2, 0, 0, 0}, row3); } @Test @@ -253,73 +216,56 @@ public class ProvideWorkbasketLevelReportAccTest { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); List categories = Arrays.asList("AUTOMATIC", "MANUAL"); - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + List columnHeaders = getShortListOfColumnHeaders(); - Report report = taskMonitorService.getWorkbasketLevelReport(null, null, categories, null, null, null, - reportLineItemDefinitions); + WorkbasketLevelReport report = taskMonitorService.getWorkbasketLevelReport(null, null, categories, null, null, + null, + columnHeaders); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } - List line1 = report.getReportLines().get("USER_1_1").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()); + assertNotNull(report); + assertEquals(3, report.rowSize()); - List line2 = report.getReportLines().get("USER_1_2").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()); + int[] row1 = report.getRow("USER_1_1").getCells(); + assertArrayEquals(new int[] {3, 1, 1, 1, 2}, row1); - List line3 = report.getReportLines().get("USER_1_3").getLineItems(); - assertEquals(0, line3.get(0).getNumberOfTasks()); - assertEquals(1, line3.get(1).getNumberOfTasks()); - assertEquals(0, line3.get(2).getNumberOfTasks()); - assertEquals(0, line3.get(3).getNumberOfTasks()); - assertEquals(4, line3.get(4).getNumberOfTasks()); + int[] row2 = report.getRow("USER_1_2").getCells(); + assertArrayEquals(new int[] {1, 1, 1, 0, 1}, row2); + + int[] row3 = report.getRow("USER_1_3").getCells(); + assertArrayEquals(new int[] {0, 1, 0, 0, 4}, row3); - assertEquals(3, report.getReportLines().size()); } @Test public void testEachItemOfWorkbasketLevelReportWithDomainFilter() throws InvalidArgumentException { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); - List domains = Arrays.asList("DOMAIN_A"); - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + List domains = Collections.singletonList("DOMAIN_A"); + List columnHeaders = getShortListOfColumnHeaders(); - Report report = taskMonitorService.getWorkbasketLevelReport(null, null, null, domains, null, null, - reportLineItemDefinitions); + WorkbasketLevelReport report = taskMonitorService.getWorkbasketLevelReport(null, null, null, domains, null, + null, + columnHeaders); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } - List line1 = report.getReportLines().get("USER_1_1").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()); + assertNotNull(report); + assertEquals(3, report.rowSize()); - List line2 = report.getReportLines().get("USER_1_2").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()); + int[] row1 = report.getRow("USER_1_1").getCells(); + assertArrayEquals(new int[] {8, 1, 0, 1, 2}, row1); - List line3 = report.getReportLines().get("USER_1_3").getLineItems(); - assertEquals(1, line3.get(0).getNumberOfTasks()); - assertEquals(1, line3.get(1).getNumberOfTasks()); - assertEquals(0, line3.get(2).getNumberOfTasks()); - assertEquals(0, line3.get(3).getNumberOfTasks()); - assertEquals(2, line3.get(4).getNumberOfTasks()); + int[] row2 = report.getRow("USER_1_2").getCells(); + assertArrayEquals(new int[] {2, 2, 2, 4, 0}, row2); + + int[] row3 = report.getRow("USER_1_3").getCells(); + assertArrayEquals(new int[] {1, 1, 0, 0, 2}, row3); } @Test @@ -327,67 +273,59 @@ public class ProvideWorkbasketLevelReportAccTest { TaskMonitorService taskMonitorService = taskanaEngine.getTaskMonitorService(); CustomField customField = CustomField.CUSTOM_1; - List customFieldValues = Arrays.asList("Geschaeftsstelle A"); - List reportLineItemDefinitions = getShortListOfReportLineItemDefinitions(); + List customFieldValues = Collections.singletonList("Geschaeftsstelle A"); + List columnHeaders = getShortListOfColumnHeaders(); - Report report = taskMonitorService.getWorkbasketLevelReport(null, null, null, null, - customField, customFieldValues, reportLineItemDefinitions); + WorkbasketLevelReport report = taskMonitorService.getWorkbasketLevelReport(null, null, null, null, + customField, customFieldValues, columnHeaders); if (LOGGER.isDebugEnabled()) { - LOGGER.debug(reportToString(report, reportLineItemDefinitions)); + LOGGER.debug(reportToString(report, columnHeaders)); } - List line1 = report.getReportLines().get("USER_1_1").getLineItems(); - assertEquals(6, line1.get(0).getNumberOfTasks()); - assertEquals(1, line1.get(1).getNumberOfTasks()); - assertEquals(1, line1.get(2).getNumberOfTasks()); - assertEquals(1, line1.get(3).getNumberOfTasks()); - assertEquals(1, line1.get(4).getNumberOfTasks()); + assertNotNull(report); + assertEquals(3, report.rowSize()); - List line2 = report.getReportLines().get("USER_1_2").getLineItems(); - assertEquals(3, line2.get(0).getNumberOfTasks()); - assertEquals(2, line2.get(1).getNumberOfTasks()); - assertEquals(2, line2.get(2).getNumberOfTasks()); - assertEquals(3, line2.get(3).getNumberOfTasks()); - assertEquals(1, line2.get(4).getNumberOfTasks()); + int[] row1 = report.getRow("USER_1_1").getCells(); + assertArrayEquals(new int[] {6, 1, 1, 1, 1}, row1); - List line3 = report.getReportLines().get("USER_1_3").getLineItems(); - assertEquals(2, line3.get(0).getNumberOfTasks()); - assertEquals(1, line3.get(1).getNumberOfTasks()); - assertEquals(0, line3.get(2).getNumberOfTasks()); - assertEquals(0, line3.get(3).getNumberOfTasks()); - assertEquals(1, line3.get(4).getNumberOfTasks()); + int[] row2 = report.getRow("USER_1_2").getCells(); + assertArrayEquals(new int[] {3, 2, 2, 3, 1}, row2); + + int[] row3 = report.getRow("USER_1_3").getCells(); + assertArrayEquals(new int[] {2, 1, 0, 0, 1}, row3); } - private List getListOfReportLineItemDefinitions() { - List reportLineItemDefinitions = new ArrayList<>(); - reportLineItemDefinitions.add(new ReportLineItemDefinition(Integer.MIN_VALUE, -11)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(-10, -6)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(-5, -2)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(-1)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(0)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(1)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(2, 5)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(6, 10)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(11, Integer.MAX_VALUE)); - return reportLineItemDefinitions; + private List getListOfColumnHeaders() { + List columnHeaders = new ArrayList<>(); + columnHeaders.add(new TimeIntervalColumnHeader(Integer.MIN_VALUE, -11)); + columnHeaders.add(new TimeIntervalColumnHeader(-10, -6)); + columnHeaders.add(new TimeIntervalColumnHeader(-5, -2)); + columnHeaders.add(new TimeIntervalColumnHeader(-1)); + columnHeaders.add(new TimeIntervalColumnHeader(0)); + columnHeaders.add(new TimeIntervalColumnHeader(1)); + columnHeaders.add(new TimeIntervalColumnHeader(2, 5)); + columnHeaders.add(new TimeIntervalColumnHeader(6, 10)); + columnHeaders.add(new TimeIntervalColumnHeader(11, Integer.MAX_VALUE)); + return columnHeaders; } - private List getShortListOfReportLineItemDefinitions() { - List reportLineItemDefinitions = new ArrayList<>(); - reportLineItemDefinitions.add(new ReportLineItemDefinition(Integer.MIN_VALUE, -6)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(-5, -1)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(0)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(1, 5)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(6, Integer.MAX_VALUE)); - return reportLineItemDefinitions; + private List getShortListOfColumnHeaders() { + List columnHeaders = new ArrayList<>(); + columnHeaders.add(new TimeIntervalColumnHeader(Integer.MIN_VALUE, -6)); + columnHeaders.add(new TimeIntervalColumnHeader(-5, -1)); + columnHeaders.add(new TimeIntervalColumnHeader(0)); + columnHeaders.add(new TimeIntervalColumnHeader(1, 5)); + columnHeaders.add(new TimeIntervalColumnHeader(6, Integer.MAX_VALUE)); + return columnHeaders; } - private String reportToString(Report report) { + private String reportToString(WorkbasketLevelReport report) { return reportToString(report, null); } - private String reportToString(Report report, List reportLineItemDefinitions) { + private String reportToString(WorkbasketLevelReport report, + List reportLineItemDefinitions) { String formatColumWidth = "| %-7s "; String formatFirstColumn = "| %-36s %-4s "; String formatFirstColumnFirstLine = "| %-29s %12s "; @@ -402,7 +340,7 @@ public class ProvideWorkbasketLevelReportAccTest { builder.append("\n"); builder.append(String.format(formatFirstColumnFirstLine, "Workbasket levels", "Total")); if (reportLineItemDefinitions != null) { - for (ReportLineItemDefinition def : reportLineItemDefinitions) { + for (TimeIntervalColumnHeader def : reportLineItemDefinitions) { if (def.getLowerAgeLimit() == Integer.MIN_VALUE) { builder.append(String.format(formatColumWidth, "< " + def.getUpperAgeLimit())); } else if (def.getUpperAgeLimit() == Integer.MAX_VALUE) { @@ -426,12 +364,12 @@ public class ProvideWorkbasketLevelReportAccTest { } builder.append("\n"); - for (String rl : report.getReportLines().keySet()) { + for (String rl : report.getRowTitles()) { builder - .append(String.format(formatFirstColumn, rl, report.getReportLines().get(rl).getTotalNumberOfTasks())); + .append(String.format(formatFirstColumn, rl, report.getRow(rl).getTotalValue())); if (reportLineItemDefinitions != null) { - for (ReportLineItem reportLineItem : report.getReportLines().get(rl).getLineItems()) { - builder.append(String.format(formatColumWidth, reportLineItem.getNumberOfTasks())); + for (int cell : report.getRow(rl).getCells()) { + builder.append(String.format(formatColumWidth, cell)); } } builder.append("|\n"); @@ -440,9 +378,9 @@ public class ProvideWorkbasketLevelReportAccTest { } builder.append("\n"); } - builder.append(String.format(formatFirstColumnSumLine, "Total", report.getSumLine().getTotalNumberOfTasks())); - for (ReportLineItem sumLine : report.getSumLine().getLineItems()) { - builder.append(String.format(formatColumWidth, sumLine.getNumberOfTasks())); + builder.append(String.format(formatFirstColumnSumLine, "Total", report.getSumRow().getTotalValue())); + for (int cell : report.getSumRow().getCells()) { + builder.append(String.format(formatColumWidth, cell)); } builder.append("|\n"); for (int i = 0; i < reportWidth; i++) { diff --git a/lib/taskana-core/src/test/java/acceptance/task/CreateTaskAccTest.java b/lib/taskana-core/src/test/java/acceptance/task/CreateTaskAccTest.java index 1b34e4885..4d33c7b40 100644 --- a/lib/taskana-core/src/test/java/acceptance/task/CreateTaskAccTest.java +++ b/lib/taskana-core/src/test/java/acceptance/task/CreateTaskAccTest.java @@ -10,8 +10,7 @@ import static org.junit.Assert.fail; import java.sql.SQLException; import java.time.Duration; import java.time.Instant; -import java.util.ArrayList; -import java.util.Arrays; +import java.util.Collections; import java.util.Map; import org.apache.ibatis.session.Configuration; @@ -34,9 +33,9 @@ import pro.taskana.exceptions.TaskAlreadyExistException; import pro.taskana.exceptions.TaskNotFoundException; import pro.taskana.exceptions.WorkbasketNotFoundException; import pro.taskana.impl.DaysToWorkingDaysConverter; -import pro.taskana.impl.ReportLineItemDefinition; import pro.taskana.impl.TaskanaEngineImpl; import pro.taskana.impl.TaskanaEngineProxyForTest; +import pro.taskana.impl.report.impl.TimeIntervalColumnHeader; import pro.taskana.mappings.AttachmentMapper; import pro.taskana.mappings.TaskTestMapper; import pro.taskana.security.CurrentUserContext; @@ -287,7 +286,7 @@ public class CreateTaskAccTest extends AbstractAccTest { assertTrue(readTask.getPriority() == 99); DaysToWorkingDaysConverter converter = DaysToWorkingDaysConverter - .initialize(new ArrayList<>(Arrays.asList(new ReportLineItemDefinition(0))), Instant.now()); + .initialize(Collections.singletonList(new TimeIntervalColumnHeader(0)), Instant.now()); long calendarDays = converter.convertWorkingDaysToDays(readTask.getPlanned(), 1); assertTrue(readTask.getDue().equals(readTask.getPlanned().plus(Duration.ofDays(calendarDays)))); diff --git a/lib/taskana-core/src/test/java/acceptance/task/UpdateTaskAttachmentsAccTest.java b/lib/taskana-core/src/test/java/acceptance/task/UpdateTaskAttachmentsAccTest.java index d320dfd8c..625266e56 100644 --- a/lib/taskana-core/src/test/java/acceptance/task/UpdateTaskAttachmentsAccTest.java +++ b/lib/taskana-core/src/test/java/acceptance/task/UpdateTaskAttachmentsAccTest.java @@ -12,7 +12,7 @@ import java.sql.SQLException; import java.time.Duration; import java.time.Instant; import java.util.ArrayList; -import java.util.Arrays; +import java.util.Collections; import java.util.List; import org.junit.Test; @@ -35,8 +35,8 @@ import pro.taskana.exceptions.TaskNotFoundException; import pro.taskana.exceptions.WorkbasketNotFoundException; import pro.taskana.impl.AttachmentImpl; import pro.taskana.impl.DaysToWorkingDaysConverter; -import pro.taskana.impl.ReportLineItemDefinition; import pro.taskana.impl.TaskImpl; +import pro.taskana.impl.report.impl.TimeIntervalColumnHeader; import pro.taskana.security.CurrentUserContext; import pro.taskana.security.JAASRunner; import pro.taskana.security.WithAccessId; @@ -364,7 +364,7 @@ public class UpdateTaskAttachmentsAccTest extends AbstractAccTest { assertTrue(task.getPriority() == 99); DaysToWorkingDaysConverter converter = DaysToWorkingDaysConverter - .initialize(new ArrayList<>(Arrays.asList(new ReportLineItemDefinition(0))), Instant.now()); + .initialize(Collections.singletonList(new TimeIntervalColumnHeader(0)), Instant.now()); long calendarDays = converter.convertWorkingDaysToDays(task.getDue(), 16); assertTrue(task.getDue().equals(task.getPlanned().plus(Duration.ofDays(calendarDays)))); @@ -477,8 +477,8 @@ public class UpdateTaskAttachmentsAccTest extends AbstractAccTest { assertTrue(readTask.getPriority() == 99); - DaysToWorkingDaysConverter converter = DaysToWorkingDaysConverter - .initialize(new ArrayList<>(Arrays.asList(new ReportLineItemDefinition(0))), Instant.now()); + DaysToWorkingDaysConverter converter = DaysToWorkingDaysConverter.initialize( + Collections.singletonList(new TimeIntervalColumnHeader(0)), Instant.now()); long calendarDays = converter.convertWorkingDaysToDays(readTask.getPlanned(), 1); assertTrue(readTask.getDue().equals(readTask.getPlanned().plus(Duration.ofDays(calendarDays)))); diff --git a/lib/taskana-core/src/test/java/pro/taskana/impl/DaysToWorkingDaysConverterTest.java b/lib/taskana-core/src/test/java/pro/taskana/impl/DaysToWorkingDaysConverterTest.java index 181bf4423..883501487 100644 --- a/lib/taskana-core/src/test/java/pro/taskana/impl/DaysToWorkingDaysConverterTest.java +++ b/lib/taskana-core/src/test/java/pro/taskana/impl/DaysToWorkingDaysConverterTest.java @@ -8,12 +8,14 @@ import java.time.Instant; import java.time.LocalDate; import java.util.ArrayList; import java.util.Arrays; +import java.util.Collections; import java.util.List; import org.junit.BeforeClass; import org.junit.Test; import pro.taskana.exceptions.InvalidArgumentException; +import pro.taskana.impl.report.impl.TimeIntervalColumnHeader; /** * Test for the DaysToWorkingDaysConverter. @@ -31,11 +33,11 @@ public class DaysToWorkingDaysConverterTest { @Test public void testInitializeForDifferentReportLineItemDefinitions() throws InvalidArgumentException { DaysToWorkingDaysConverter instance1 = DaysToWorkingDaysConverter - .initialize(getShortListOfReportLineItemDefinitions(), Instant.parse("2018-02-03T00:00:00.000Z")); + .initialize(getShortListOfColumnHeaders(), Instant.parse("2018-02-03T00:00:00.000Z")); DaysToWorkingDaysConverter instance2 = DaysToWorkingDaysConverter - .initialize(getShortListOfReportLineItemDefinitions(), Instant.parse("2018-02-03T00:00:00.000Z")); + .initialize(getShortListOfColumnHeaders(), Instant.parse("2018-02-03T00:00:00.000Z")); DaysToWorkingDaysConverter instance3 = DaysToWorkingDaysConverter - .initialize(getLargeListOfReportLineItemDefinitions(), Instant.parse("2018-02-03T00:00:00.000Z")); + .initialize(getLargeListOfColumnHeaders(), Instant.parse("2018-02-03T00:00:00.000Z")); assertEquals(instance1, instance2); assertNotEquals(instance1, instance3); @@ -43,7 +45,7 @@ public class DaysToWorkingDaysConverterTest { @Test public void testConvertWorkingDaysToDaysForTasks() { - List reportItems = new ArrayList<>(Arrays.asList(new ReportLineItemDefinition(0))); + List reportItems = Collections.singletonList(new TimeIntervalColumnHeader(0)); try { DaysToWorkingDaysConverter converter = DaysToWorkingDaysConverter.initialize(reportItems, Instant.now()); @@ -100,9 +102,9 @@ public class DaysToWorkingDaysConverterTest { @Test public void testInitializeForDifferentDates() throws InvalidArgumentException { DaysToWorkingDaysConverter instance1 = DaysToWorkingDaysConverter - .initialize(getShortListOfReportLineItemDefinitions(), Instant.parse("2018-02-04T00:00:00.000Z")); + .initialize(getShortListOfColumnHeaders(), Instant.parse("2018-02-04T00:00:00.000Z")); DaysToWorkingDaysConverter instance2 = DaysToWorkingDaysConverter - .initialize(getShortListOfReportLineItemDefinitions(), Instant.parse("2018-02-05T00:00:00.000Z")); + .initialize(getShortListOfColumnHeaders(), Instant.parse("2018-02-05T00:00:00.000Z")); assertNotEquals(instance1, instance2); } @@ -110,7 +112,7 @@ public class DaysToWorkingDaysConverterTest { @Test public void testConvertDaysToWorkingDays() throws InvalidArgumentException { DaysToWorkingDaysConverter instance = DaysToWorkingDaysConverter - .initialize(getLargeListOfReportLineItemDefinitions(), Instant.parse("2018-02-06T00:00:00.000Z")); + .initialize(getLargeListOfColumnHeaders(), Instant.parse("2018-02-06T00:00:00.000Z")); assertEquals(-16, instance.convertDaysToWorkingDays(-16)); assertEquals(-11, instance.convertDaysToWorkingDays(-15)); @@ -134,7 +136,7 @@ public class DaysToWorkingDaysConverterTest { @Test public void testConvertWorkingDaysToDays() throws InvalidArgumentException { DaysToWorkingDaysConverter instance = DaysToWorkingDaysConverter - .initialize(getLargeListOfReportLineItemDefinitions(), Instant.parse("2018-02-27T00:00:00.000Z")); + .initialize(getLargeListOfColumnHeaders(), Instant.parse("2018-02-27T00:00:00.000Z")); assertEquals(Arrays.asList(-13), instance.convertWorkingDaysToDays(-13)); assertEquals(Arrays.asList(-12), instance.convertWorkingDaysToDays(-12)); @@ -167,7 +169,7 @@ public class DaysToWorkingDaysConverterTest { @Test public void testConvertWorkingDaysToDaysAtWeekend() throws InvalidArgumentException { DaysToWorkingDaysConverter instance = DaysToWorkingDaysConverter - .initialize(getLargeListOfReportLineItemDefinitions(), Instant.parse("2018-03-10T00:00:00.000Z")); + .initialize(getLargeListOfColumnHeaders(), Instant.parse("2018-03-10T00:00:00.000Z")); assertEquals(Arrays.asList(-13), instance.convertWorkingDaysToDays(-13)); assertEquals(Arrays.asList(-12), instance.convertWorkingDaysToDays(-12)); @@ -200,7 +202,7 @@ public class DaysToWorkingDaysConverterTest { @Test public void testConvertWorkingDaysToDaysOnEasterSunday() throws InvalidArgumentException { DaysToWorkingDaysConverter instance = DaysToWorkingDaysConverter - .initialize(getLargeListOfReportLineItemDefinitions(), Instant.parse("2018-04-01T00:00:00.000Z")); + .initialize(getLargeListOfColumnHeaders(), Instant.parse("2018-04-01T00:00:00.000Z")); assertEquals(Arrays.asList(-13), instance.convertWorkingDaysToDays(-13)); assertEquals(Arrays.asList(-12), instance.convertWorkingDaysToDays(-12)); @@ -233,7 +235,7 @@ public class DaysToWorkingDaysConverterTest { @Test public void testEasterHolidays() throws InvalidArgumentException { DaysToWorkingDaysConverter instance = DaysToWorkingDaysConverter - .initialize(getLargeListOfReportLineItemDefinitions(), Instant.parse("2018-03-28T00:00:00.000Z")); + .initialize(getLargeListOfColumnHeaders(), Instant.parse("2018-03-28T00:00:00.000Z")); assertEquals(0, instance.convertDaysToWorkingDays(0)); assertEquals(1, instance.convertDaysToWorkingDays(1)); @@ -247,7 +249,7 @@ public class DaysToWorkingDaysConverterTest { @Test public void testWhitsunHolidays() throws InvalidArgumentException { DaysToWorkingDaysConverter instance = DaysToWorkingDaysConverter - .initialize(getLargeListOfReportLineItemDefinitions(), Instant.parse("2018-05-16T00:00:00.000Z")); + .initialize(getLargeListOfColumnHeaders(), Instant.parse("2018-05-16T00:00:00.000Z")); assertEquals(0, instance.convertDaysToWorkingDays(0)); assertEquals(1, instance.convertDaysToWorkingDays(1)); @@ -261,7 +263,7 @@ public class DaysToWorkingDaysConverterTest { @Test public void testLabourDayHoliday() throws InvalidArgumentException { DaysToWorkingDaysConverter instance = DaysToWorkingDaysConverter - .initialize(getLargeListOfReportLineItemDefinitions(), Instant.parse("2018-04-26T00:00:00.000Z")); + .initialize(getLargeListOfColumnHeaders(), Instant.parse("2018-04-26T00:00:00.000Z")); assertEquals(0, instance.convertDaysToWorkingDays(0)); assertEquals(1, instance.convertDaysToWorkingDays(1)); @@ -276,7 +278,7 @@ public class DaysToWorkingDaysConverterTest { @Test public void testAscensionDayHoliday() throws InvalidArgumentException { DaysToWorkingDaysConverter instance = DaysToWorkingDaysConverter - .initialize(getLargeListOfReportLineItemDefinitions(), Instant.parse("2018-05-07T00:00:00.000Z")); + .initialize(getLargeListOfColumnHeaders(), Instant.parse("2018-05-07T00:00:00.000Z")); assertEquals(0, instance.convertDaysToWorkingDays(0)); assertEquals(1, instance.convertDaysToWorkingDays(1)); @@ -291,7 +293,7 @@ public class DaysToWorkingDaysConverterTest { @Test public void testDayOfGermanUnityHoliday() throws InvalidArgumentException { DaysToWorkingDaysConverter instance = DaysToWorkingDaysConverter - .initialize(getLargeListOfReportLineItemDefinitions(), Instant.parse("2018-10-01T00:00:00.000Z")); + .initialize(getLargeListOfColumnHeaders(), Instant.parse("2018-10-01T00:00:00.000Z")); assertEquals(0, instance.convertDaysToWorkingDays(0)); assertEquals(1, instance.convertDaysToWorkingDays(1)); @@ -306,7 +308,7 @@ public class DaysToWorkingDaysConverterTest { @Test public void testChristmasAndNewYearHolidays() throws InvalidArgumentException { DaysToWorkingDaysConverter instance = DaysToWorkingDaysConverter - .initialize(getLargeListOfReportLineItemDefinitions(), Instant.parse("2018-12-20T00:00:00.000Z")); + .initialize(getLargeListOfColumnHeaders(), Instant.parse("2018-12-20T00:00:00.000Z")); assertEquals(0, instance.convertDaysToWorkingDays(0)); assertEquals(1, instance.convertDaysToWorkingDays(1)); @@ -328,7 +330,7 @@ public class DaysToWorkingDaysConverterTest { @Test public void testCustomHolidaysWithDayOfReformationAndAllSaintsDay() throws InvalidArgumentException { DaysToWorkingDaysConverter instance = DaysToWorkingDaysConverter - .initialize(getLargeListOfReportLineItemDefinitions(), Instant.parse("2018-10-26T00:00:00.000Z")); + .initialize(getLargeListOfColumnHeaders(), Instant.parse("2018-10-26T00:00:00.000Z")); assertEquals(0, instance.convertDaysToWorkingDays(0)); assertEquals(0, instance.convertDaysToWorkingDays(1)); @@ -344,7 +346,7 @@ public class DaysToWorkingDaysConverterTest { @Test public void testGetEasterSunday() throws InvalidArgumentException { DaysToWorkingDaysConverter instance = DaysToWorkingDaysConverter - .initialize(getShortListOfReportLineItemDefinitions(), Instant.parse("2018-02-27T00:00:00.000Z")); + .initialize(getShortListOfColumnHeaders(), Instant.parse("2018-02-27T00:00:00.000Z")); assertEquals(LocalDate.of(2018, 4, 1), instance.getEasterSunday(2018)); assertEquals(LocalDate.of(2019, 4, 21), instance.getEasterSunday(2019)); @@ -370,27 +372,27 @@ public class DaysToWorkingDaysConverterTest { } - private List getShortListOfReportLineItemDefinitions() { - List reportLineItemDefinitions = new ArrayList<>(); - reportLineItemDefinitions.add(new ReportLineItemDefinition(Integer.MIN_VALUE, -3)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(-1, -2)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(0)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(1, 2)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(3, Integer.MAX_VALUE)); - return reportLineItemDefinitions; + private List getShortListOfColumnHeaders() { + List columnHeaders = new ArrayList<>(); + columnHeaders.add(new TimeIntervalColumnHeader(Integer.MIN_VALUE, -3)); + columnHeaders.add(new TimeIntervalColumnHeader(-1, -2)); + columnHeaders.add(new TimeIntervalColumnHeader(0)); + columnHeaders.add(new TimeIntervalColumnHeader(1, 2)); + columnHeaders.add(new TimeIntervalColumnHeader(3, Integer.MAX_VALUE)); + return columnHeaders; } - private List getLargeListOfReportLineItemDefinitions() { - List reportLineItemDefinitions = new ArrayList<>(); - reportLineItemDefinitions.add(new ReportLineItemDefinition(Integer.MIN_VALUE, -11)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(-10, -6)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(-5, -2)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(-1)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(0)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(1)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(2, 5)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(6, 10)); - reportLineItemDefinitions.add(new ReportLineItemDefinition(11, Integer.MAX_VALUE)); - return reportLineItemDefinitions; + private List getLargeListOfColumnHeaders() { + List columnHeaders = new ArrayList<>(); + columnHeaders.add(new TimeIntervalColumnHeader(Integer.MIN_VALUE, -11)); + columnHeaders.add(new TimeIntervalColumnHeader(-10, -6)); + columnHeaders.add(new TimeIntervalColumnHeader(-5, -2)); + columnHeaders.add(new TimeIntervalColumnHeader(-1)); + columnHeaders.add(new TimeIntervalColumnHeader(0)); + columnHeaders.add(new TimeIntervalColumnHeader(1)); + columnHeaders.add(new TimeIntervalColumnHeader(2, 5)); + columnHeaders.add(new TimeIntervalColumnHeader(6, 10)); + columnHeaders.add(new TimeIntervalColumnHeader(11, Integer.MAX_VALUE)); + return columnHeaders; } } diff --git a/lib/taskana-core/src/test/java/pro/taskana/impl/TaskMonitorServiceImplTest.java b/lib/taskana-core/src/test/java/pro/taskana/impl/TaskMonitorServiceImplTest.java index 714d82a0c..1a3432bc7 100644 --- a/lib/taskana-core/src/test/java/pro/taskana/impl/TaskMonitorServiceImplTest.java +++ b/lib/taskana-core/src/test/java/pro/taskana/impl/TaskMonitorServiceImplTest.java @@ -10,6 +10,7 @@ import static org.mockito.Mockito.verifyNoMoreInteractions; import java.util.ArrayList; import java.util.Arrays; +import java.util.Collections; import java.util.List; import org.junit.Before; @@ -25,6 +26,14 @@ import pro.taskana.CustomField; import pro.taskana.TaskState; import pro.taskana.configuration.TaskanaEngineConfiguration; import pro.taskana.exceptions.InvalidArgumentException; +import pro.taskana.impl.report.impl.CategoryReport; +import pro.taskana.impl.report.impl.ClassificationReport; +import pro.taskana.impl.report.impl.CustomFieldValueReport; +import pro.taskana.impl.report.impl.DetailedClassificationReport; +import pro.taskana.impl.report.impl.DetailedMonitorQueryItem; +import pro.taskana.impl.report.impl.DetailedReportRow; +import pro.taskana.impl.report.impl.TimeIntervalColumnHeader; +import pro.taskana.impl.report.impl.WorkbasketLevelReport; import pro.taskana.mappings.TaskMonitorMapper; /** @@ -57,22 +66,23 @@ public class TaskMonitorServiceImplTest { @Test public void testGetTotalNumbersOfWorkbasketLevelReport() throws InvalidArgumentException { - List workbasketIds = Arrays.asList("WBI:000000000000000000000000000000000001"); + List workbasketIds = Collections.singletonList("WBI:000000000000000000000000000000000001"); List states = Arrays.asList(TaskState.CLAIMED, TaskState.READY); - List categories = Arrays.asList("EXTERN"); - List domains = Arrays.asList("DOMAIN_A"); + List categories = Collections.singletonList("EXTERN"); + List domains = Collections.singletonList("DOMAIN_A"); CustomField customField = CustomField.CUSTOM_1; - List customFieldValues = Arrays.asList("Geschaeftsstelle A"); + List customFieldValues = Collections.singletonList("Geschaeftsstelle A"); - List expectedResult = new ArrayList<>(); - MonitorQueryItem monitorQueryItem = new MonitorQueryItem(); + List expectedResult = new ArrayList<>(); + pro.taskana.impl.report.impl.MonitorQueryItem monitorQueryItem = new pro.taskana.impl.report.impl.MonitorQueryItem(); monitorQueryItem.setKey("WBI:000000000000000000000000000000000001"); monitorQueryItem.setNumberOfTasks(1); expectedResult.add(monitorQueryItem); doReturn(expectedResult).when(taskMonitorMapperMock).getTaskCountOfWorkbaskets(workbasketIds, states, categories, domains, customField, customFieldValues); - Report actualResult = cut.getWorkbasketLevelReport(workbasketIds, states, categories, domains, customField, + WorkbasketLevelReport actualResult = cut.getWorkbasketLevelReport(workbasketIds, states, categories, domains, + customField, customFieldValues); verify(taskanaEngineImplMock, times(1)).openConnection(); @@ -86,23 +96,23 @@ public class TaskMonitorServiceImplTest { assertNotNull(actualResult); assertEquals( - actualResult.getReportLines().get("WBI:000000000000000000000000000000000001").getTotalNumberOfTasks(), 1); - assertEquals(actualResult.getSumLine().getTotalNumberOfTasks(), 1); + actualResult.getRow("WBI:000000000000000000000000000000000001").getTotalValue(), 1); + assertEquals(actualResult.getSumRow().getTotalValue(), 1); } @Test public void testGetWorkbasketLevelReportWithReportLineItemDefinitions() throws InvalidArgumentException { - List workbasketIds = Arrays.asList("WBI:000000000000000000000000000000000001"); + List workbasketIds = Collections.singletonList("WBI:000000000000000000000000000000000001"); List states = Arrays.asList(TaskState.CLAIMED, TaskState.READY); - List categories = Arrays.asList("EXTERN"); - List domains = Arrays.asList("DOMAIN_A"); + List categories = Collections.singletonList("EXTERN"); + List domains = Collections.singletonList("DOMAIN_A"); CustomField customField = CustomField.CUSTOM_1; - List customFieldValues = Arrays.asList("Geschaeftsstelle A"); - List reportLineItemDefinitions = Arrays.asList(new ReportLineItemDefinition(), - new ReportLineItemDefinition()); + List customFieldValues = Collections.singletonList("Geschaeftsstelle A"); + List reportLineItemDefinitions = Collections.singletonList( + new TimeIntervalColumnHeader(0, 0)); - List expectedResult = new ArrayList<>(); - MonitorQueryItem monitorQueryItem = new MonitorQueryItem(); + List expectedResult = new ArrayList<>(); + pro.taskana.impl.report.impl.MonitorQueryItem monitorQueryItem = new pro.taskana.impl.report.impl.MonitorQueryItem(); monitorQueryItem.setKey("WBI:000000000000000000000000000000000001"); monitorQueryItem.setAgeInDays(0); monitorQueryItem.setNumberOfTasks(1); @@ -110,7 +120,8 @@ public class TaskMonitorServiceImplTest { doReturn(expectedResult).when(taskMonitorMapperMock).getTaskCountOfWorkbaskets(workbasketIds, states, categories, domains, customField, customFieldValues); - Report actualResult = cut.getWorkbasketLevelReport(workbasketIds, states, categories, domains, customField, + WorkbasketLevelReport actualResult = cut.getWorkbasketLevelReport(workbasketIds, states, categories, domains, + customField, customFieldValues, reportLineItemDefinitions); verify(taskanaEngineImplMock, times(1)).openConnection(); @@ -123,35 +134,30 @@ public class TaskMonitorServiceImplTest { assertNotNull(actualResult); assertEquals( - actualResult.getReportLines().get("WBI:000000000000000000000000000000000001").getTotalNumberOfTasks(), 1); - assertEquals( - actualResult.getReportLines() - .get("WBI:000000000000000000000000000000000001") - .getLineItems() - .get(0) - .getNumberOfTasks(), - 1); - assertEquals(actualResult.getSumLine().getTotalNumberOfTasks(), 1); + actualResult.getRow("WBI:000000000000000000000000000000000001").getTotalValue(), 1); + assertEquals(actualResult.getRow("WBI:000000000000000000000000000000000001").getCells()[0], 1); + assertEquals(actualResult.getSumRow().getTotalValue(), 1); } @Test public void testGetTotalNumbersOfCatgoryReport() throws InvalidArgumentException { - List workbasketIds = Arrays.asList("WBI:000000000000000000000000000000000001"); + List workbasketIds = Collections.singletonList("WBI:000000000000000000000000000000000001"); List states = Arrays.asList(TaskState.CLAIMED, TaskState.READY); - List categories = Arrays.asList("EXTERN"); - List domains = Arrays.asList("DOMAIN_A"); + List categories = Collections.singletonList("EXTERN"); + List domains = Collections.singletonList("DOMAIN_A"); CustomField customField = CustomField.CUSTOM_1; - List customFieldValues = Arrays.asList("Geschaeftsstelle A"); + List customFieldValues = Collections.singletonList("Geschaeftsstelle A"); - List expectedResult = new ArrayList<>(); - MonitorQueryItem monitorQueryItem = new MonitorQueryItem(); + List expectedResult = new ArrayList<>(); + pro.taskana.impl.report.impl.MonitorQueryItem monitorQueryItem = new pro.taskana.impl.report.impl.MonitorQueryItem(); monitorQueryItem.setKey("EXTERN"); monitorQueryItem.setNumberOfTasks(1); expectedResult.add(monitorQueryItem); doReturn(expectedResult).when(taskMonitorMapperMock).getTaskCountOfCategories(workbasketIds, states, categories, domains, customField, customFieldValues); - Report actualResult = cut.getCategoryReport(workbasketIds, states, categories, domains, customField, + CategoryReport actualResult = cut.getCategoryReport(workbasketIds, states, categories, domains, + customField, customFieldValues); verify(taskanaEngineImplMock, times(1)).openConnection(); @@ -163,23 +169,23 @@ public class TaskMonitorServiceImplTest { verifyNoMoreInteractions(taskanaEngineImplMock, taskMonitorMapperMock, taskanaEngineConfiguration); assertNotNull(actualResult); - assertEquals(actualResult.getReportLines().get("EXTERN").getTotalNumberOfTasks(), 1); - assertEquals(actualResult.getSumLine().getTotalNumberOfTasks(), 1); + assertEquals(actualResult.getRow("EXTERN").getTotalValue(), 1); + assertEquals(actualResult.getSumRow().getTotalValue(), 1); } @Test public void testGetCategoryReportWithReportLineItemDefinitions() throws InvalidArgumentException { - List workbasketIds = Arrays.asList("WBI:000000000000000000000000000000000001"); + List workbasketIds = Collections.singletonList("WBI:000000000000000000000000000000000001"); List states = Arrays.asList(TaskState.CLAIMED, TaskState.READY); - List categories = Arrays.asList("EXTERN"); - List domains = Arrays.asList("DOMAIN_A"); + List categories = Collections.singletonList("EXTERN"); + List domains = Collections.singletonList("DOMAIN_A"); CustomField customField = CustomField.CUSTOM_1; - List customFieldValues = Arrays.asList("Geschaeftsstelle A"); - List reportLineItemDefinitions = Arrays.asList(new ReportLineItemDefinition(), - new ReportLineItemDefinition()); + List customFieldValues = Collections.singletonList("Geschaeftsstelle A"); + List reportLineItemDefinitions = Collections.singletonList( + new TimeIntervalColumnHeader(0, 0)); - List expectedResult = new ArrayList<>(); - MonitorQueryItem monitorQueryItem = new MonitorQueryItem(); + List expectedResult = new ArrayList<>(); + pro.taskana.impl.report.impl.MonitorQueryItem monitorQueryItem = new pro.taskana.impl.report.impl.MonitorQueryItem(); monitorQueryItem.setKey("EXTERN"); monitorQueryItem.setAgeInDays(0); monitorQueryItem.setNumberOfTasks(1); @@ -187,7 +193,8 @@ public class TaskMonitorServiceImplTest { doReturn(expectedResult).when(taskMonitorMapperMock).getTaskCountOfCategories(workbasketIds, states, categories, domains, customField, customFieldValues); - Report actualResult = cut.getCategoryReport(workbasketIds, states, categories, domains, customField, + CategoryReport actualResult = cut.getCategoryReport(workbasketIds, states, categories, domains, + customField, customFieldValues, reportLineItemDefinitions); verify(taskanaEngineImplMock, times(1)).openConnection(); @@ -199,22 +206,22 @@ public class TaskMonitorServiceImplTest { verifyNoMoreInteractions(taskanaEngineImplMock, taskMonitorMapperMock, taskanaEngineConfiguration); assertNotNull(actualResult); - assertEquals(actualResult.getReportLines().get("EXTERN").getTotalNumberOfTasks(), 1); - assertEquals(actualResult.getReportLines().get("EXTERN").getLineItems().get(0).getNumberOfTasks(), 1); - assertEquals(actualResult.getSumLine().getTotalNumberOfTasks(), 1); + assertEquals(actualResult.getRow("EXTERN").getTotalValue(), 1); + assertEquals(actualResult.getRow("EXTERN").getCells()[0], 1); + assertEquals(actualResult.getSumRow().getTotalValue(), 1); } @Test public void testGetTotalNumbersOfClassificationReport() throws InvalidArgumentException { - List workbasketIds = Arrays.asList("WBI:000000000000000000000000000000000001"); + List workbasketIds = Collections.singletonList("WBI:000000000000000000000000000000000001"); List states = Arrays.asList(TaskState.CLAIMED, TaskState.READY); - List categories = Arrays.asList("EXTERN"); - List domains = Arrays.asList("DOMAIN_A"); + List categories = Collections.singletonList("EXTERN"); + List domains = Collections.singletonList("DOMAIN_A"); CustomField customField = CustomField.CUSTOM_1; - List customFieldValues = Arrays.asList("Geschaeftsstelle A"); + List customFieldValues = Collections.singletonList("Geschaeftsstelle A"); - List expectedResult = new ArrayList<>(); - MonitorQueryItem monitorQueryItem = new MonitorQueryItem(); + List expectedResult = new ArrayList<>(); + pro.taskana.impl.report.impl.MonitorQueryItem monitorQueryItem = new pro.taskana.impl.report.impl.MonitorQueryItem(); monitorQueryItem.setKey("CLI:000000000000000000000000000000000001"); monitorQueryItem.setNumberOfTasks(1); expectedResult.add(monitorQueryItem); @@ -234,24 +241,24 @@ public class TaskMonitorServiceImplTest { assertNotNull(actualResult); assertEquals( - actualResult.getReportLines().get("CLI:000000000000000000000000000000000001").getTotalNumberOfTasks(), 1); - assertEquals(actualResult.getSumLine().getTotalNumberOfTasks(), 1); + actualResult.getRow("CLI:000000000000000000000000000000000001").getTotalValue(), 1); + assertEquals(actualResult.getSumRow().getTotalValue(), 1); } @Test public void testGetClassificationReportWithReportLineItemDefinitions() throws InvalidArgumentException { - List workbasketIds = Arrays.asList("WBI:000000000000000000000000000000000001"); + List workbasketIds = Collections.singletonList("WBI:000000000000000000000000000000000001"); List states = Arrays.asList(TaskState.CLAIMED, TaskState.READY); - List categories = Arrays.asList("EXTERN"); - List domains = Arrays.asList("DOMAIN_A"); + List categories = Collections.singletonList("EXTERN"); + List domains = Collections.singletonList("DOMAIN_A"); CustomField customField = CustomField.CUSTOM_1; - List customFieldValues = Arrays.asList("Geschaeftsstelle A"); + List customFieldValues = Collections.singletonList("Geschaeftsstelle A"); - List reportLineItemDefinitions = Arrays.asList(new ReportLineItemDefinition(), - new ReportLineItemDefinition()); + List reportLineItemDefinitions = Collections.singletonList( + new TimeIntervalColumnHeader(0, 0)); - List expectedResult = new ArrayList<>(); - MonitorQueryItem monitorQueryItem = new MonitorQueryItem(); + List expectedResult = new ArrayList<>(); + pro.taskana.impl.report.impl.MonitorQueryItem monitorQueryItem = new pro.taskana.impl.report.impl.MonitorQueryItem(); monitorQueryItem.setKey("CLI:000000000000000000000000000000000001"); monitorQueryItem.setAgeInDays(0); monitorQueryItem.setNumberOfTasks(1); @@ -272,23 +279,19 @@ public class TaskMonitorServiceImplTest { assertNotNull(actualResult); assertEquals( - actualResult.getReportLines().get("CLI:000000000000000000000000000000000001").getTotalNumberOfTasks(), 1); - assertEquals(actualResult.getReportLines() - .get("CLI:000000000000000000000000000000000001") - .getLineItems() - .get(0) - .getNumberOfTasks(), 1); - assertEquals(actualResult.getSumLine().getTotalNumberOfTasks(), 1); + actualResult.getRow("CLI:000000000000000000000000000000000001").getTotalValue(), 1); + assertEquals(actualResult.getRow("CLI:000000000000000000000000000000000001").getCells()[0], 1); + assertEquals(actualResult.getSumRow().getTotalValue(), 1); } @Test public void testGetTotalNumbersOfDetailedClassificationReport() throws InvalidArgumentException { - List workbasketIds = Arrays.asList("WBI:000000000000000000000000000000000001"); + List workbasketIds = Collections.singletonList("WBI:000000000000000000000000000000000001"); List states = Arrays.asList(TaskState.CLAIMED, TaskState.READY); - List categories = Arrays.asList("EXTERN"); - List domains = Arrays.asList("DOMAIN_A"); + List categories = Collections.singletonList("EXTERN"); + List domains = Collections.singletonList("DOMAIN_A"); CustomField customField = CustomField.CUSTOM_1; - List customFieldValues = Arrays.asList("Geschaeftsstelle A"); + List customFieldValues = Collections.singletonList("Geschaeftsstelle A"); List expectedResult = new ArrayList<>(); DetailedMonitorQueryItem detailedMonitorQueryItem = new DetailedMonitorQueryItem(); @@ -311,24 +314,23 @@ public class TaskMonitorServiceImplTest { verify(taskanaEngineImplMock, times(1)).returnConnection(); verifyNoMoreInteractions(taskanaEngineImplMock, taskMonitorMapperMock, taskanaEngineConfiguration); - DetailedReportLine line = (DetailedReportLine) actualResult.getReportLines() - .get("CLI:000000000000000000000000000000000001"); + DetailedReportRow line = actualResult.getRow("CLI:000000000000000000000000000000000001"); assertNotNull(actualResult); - assertEquals(line.getTotalNumberOfTasks(), 1); - assertEquals(line.getDetailLines().get("CLI:000000000000000000000000000000000006").getTotalNumberOfTasks(), 1); - assertEquals(actualResult.getSumLine().getTotalNumberOfTasks(), 1); + assertEquals(line.getTotalValue(), 1); + assertEquals(line.getDetailRows().get("CLI:000000000000000000000000000000000006").getTotalValue(), 1); + assertEquals(actualResult.getSumRow().getTotalValue(), 1); } @Test public void testGetDetailedClassificationReportWithReportLineItemDefinitions() throws InvalidArgumentException { - List workbasketIds = Arrays.asList("WBI:000000000000000000000000000000000001"); + List workbasketIds = Collections.singletonList("WBI:000000000000000000000000000000000001"); List states = Arrays.asList(TaskState.CLAIMED, TaskState.READY); - List categories = Arrays.asList("EXTERN"); - List domains = Arrays.asList("DOMAIN_A"); + List categories = Collections.singletonList("EXTERN"); + List domains = Collections.singletonList("DOMAIN_A"); CustomField customField = CustomField.CUSTOM_1; - List customFieldValues = Arrays.asList("Geschaeftsstelle A"); - List reportLineItemDefinitions = Arrays.asList(new ReportLineItemDefinition(), - new ReportLineItemDefinition()); + List customFieldValues = Collections.singletonList("Geschaeftsstelle A"); + List reportLineItemDefinitions = Collections.singletonList( + new TimeIntervalColumnHeader(0, 0)); List expectedResult = new ArrayList<>(); DetailedMonitorQueryItem detailedMonitorQueryItem = new DetailedMonitorQueryItem(); @@ -352,32 +354,27 @@ public class TaskMonitorServiceImplTest { verify(taskanaEngineImplMock, times(1)).returnConnection(); verifyNoMoreInteractions(taskanaEngineImplMock, taskMonitorMapperMock, taskanaEngineConfiguration); - DetailedReportLine line = (DetailedReportLine) actualResult.getReportLines() - .get("CLI:000000000000000000000000000000000001"); + DetailedReportRow line = actualResult.getRow("CLI:000000000000000000000000000000000001"); assertNotNull(actualResult); - assertEquals(line.getTotalNumberOfTasks(), 1); - assertEquals(line.getDetailLines().get("CLI:000000000000000000000000000000000006").getTotalNumberOfTasks(), 1); - assertEquals(line.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); + assertEquals(line.getTotalValue(), 1); + assertEquals(line.getDetailRows().get("CLI:000000000000000000000000000000000006").getTotalValue(), 1); + assertEquals(line.getCells()[0], 1); + assertEquals(line.getDetailRows().get("CLI:000000000000000000000000000000000006").getCells()[0], 1); + assertEquals(actualResult.getSumRow().getTotalValue(), 1); + assertEquals(actualResult.getSumRow().getCells()[0], 1); } @Test public void testGetTotalNumbersOfCustomFieldValueReport() throws InvalidArgumentException { - List workbasketIds = Arrays.asList("WBI:000000000000000000000000000000000001"); + List workbasketIds = Collections.singletonList("WBI:000000000000000000000000000000000001"); List states = Arrays.asList(TaskState.CLAIMED, TaskState.READY); - List categories = Arrays.asList("EXTERN"); - List domains = Arrays.asList("DOMAIN_A"); + List categories = Collections.singletonList("EXTERN"); + List domains = Collections.singletonList("DOMAIN_A"); CustomField customField = CustomField.CUSTOM_1; - List customFieldValues = Arrays.asList("Geschaeftsstelle A"); + List customFieldValues = Collections.singletonList("Geschaeftsstelle A"); - List expectedResult = new ArrayList<>(); - MonitorQueryItem monitorQueryItem = new MonitorQueryItem(); + List expectedResult = new ArrayList<>(); + pro.taskana.impl.report.impl.MonitorQueryItem monitorQueryItem = new pro.taskana.impl.report.impl.MonitorQueryItem(); monitorQueryItem.setKey("Geschaeftsstelle A"); monitorQueryItem.setNumberOfTasks(1); expectedResult.add(monitorQueryItem); @@ -385,7 +382,7 @@ public class TaskMonitorServiceImplTest { .getTaskCountOfCustomFieldValues(workbasketIds, states, categories, domains, customField, customFieldValues); - Report actualResult = cut.getCustomFieldValueReport(workbasketIds, states, categories, domains, + CustomFieldValueReport actualResult = cut.getCustomFieldValueReport(workbasketIds, states, categories, domains, customField, customFieldValues); verify(taskanaEngineImplMock, times(1)).openConnection(); @@ -398,23 +395,23 @@ public class TaskMonitorServiceImplTest { verifyNoMoreInteractions(taskanaEngineImplMock, taskMonitorMapperMock, taskanaEngineConfiguration); assertNotNull(actualResult); - assertEquals(actualResult.getReportLines().get("Geschaeftsstelle A").getTotalNumberOfTasks(), 1); - assertEquals(actualResult.getSumLine().getTotalNumberOfTasks(), 1); + assertEquals(actualResult.getRow("Geschaeftsstelle A").getTotalValue(), 1); + assertEquals(actualResult.getSumRow().getTotalValue(), 1); } @Test public void testGetCustomFieldValueReportWithReportLineItemDefinitions() throws InvalidArgumentException { - List workbasketIds = Arrays.asList("WBI:000000000000000000000000000000000001"); + List workbasketIds = Collections.singletonList("WBI:000000000000000000000000000000000001"); List states = Arrays.asList(TaskState.CLAIMED, TaskState.READY); - List categories = Arrays.asList("EXTERN"); - List domains = Arrays.asList("DOMAIN_A"); + List categories = Collections.singletonList("EXTERN"); + List domains = Collections.singletonList("DOMAIN_A"); CustomField customField = CustomField.CUSTOM_1; - List customFieldValues = Arrays.asList("Geschaeftsstelle A"); - List reportLineItemDefinitions = Arrays.asList(new ReportLineItemDefinition(), - new ReportLineItemDefinition()); + List customFieldValues = Collections.singletonList("Geschaeftsstelle A"); + List reportLineItemDefinitions = Collections.singletonList( + new TimeIntervalColumnHeader(0, 0)); - List expectedResult = new ArrayList<>(); - MonitorQueryItem monitorQueryItem = new MonitorQueryItem(); + List expectedResult = new ArrayList<>(); + pro.taskana.impl.report.impl.MonitorQueryItem monitorQueryItem = new pro.taskana.impl.report.impl.MonitorQueryItem(); monitorQueryItem.setKey("Geschaeftsstelle A"); monitorQueryItem.setAgeInDays(0); monitorQueryItem.setNumberOfTasks(1); @@ -423,7 +420,7 @@ public class TaskMonitorServiceImplTest { .getTaskCountOfCustomFieldValues(workbasketIds, states, categories, domains, customField, customFieldValues); - Report actualResult = cut.getCustomFieldValueReport(workbasketIds, states, categories, domains, + CustomFieldValueReport actualResult = cut.getCustomFieldValueReport(workbasketIds, states, categories, domains, customField, customFieldValues, reportLineItemDefinitions); verify(taskanaEngineImplMock, times(1)).openConnection(); @@ -436,30 +433,29 @@ public class TaskMonitorServiceImplTest { verifyNoMoreInteractions(taskanaEngineImplMock, taskMonitorMapperMock, taskanaEngineConfiguration); assertNotNull(actualResult); - assertEquals(actualResult.getReportLines().get("Geschaeftsstelle A").getTotalNumberOfTasks(), 1); - assertEquals(actualResult.getReportLines().get("Geschaeftsstelle A").getLineItems().get(0).getNumberOfTasks(), - 1); - assertEquals(actualResult.getSumLine().getTotalNumberOfTasks(), 1); + assertEquals(actualResult.getRow("Geschaeftsstelle A").getTotalValue(), 1); + assertEquals(actualResult.getRow("Geschaeftsstelle A").getCells()[0], 1); + assertEquals(actualResult.getSumRow().getTotalValue(), 1); } @Test public void testGetTaskIdsOfCategoryReportLineItems() throws InvalidArgumentException { - List workbasketIds = Arrays.asList("WBI:000000000000000000000000000000000001"); + List workbasketIds = Collections.singletonList("WBI:000000000000000000000000000000000001"); List states = Arrays.asList(TaskState.CLAIMED, TaskState.READY); - List categories = Arrays.asList("EXTERN"); - List domains = Arrays.asList("DOMAIN_A"); + List categories = Collections.singletonList("EXTERN"); + List domains = Collections.singletonList("DOMAIN_A"); CustomField customField = CustomField.CUSTOM_1; - List customFieldValues = Arrays.asList("Geschaeftsstelle A"); - List reportLineItemDefinitions = Arrays.asList(new ReportLineItemDefinition(), - new ReportLineItemDefinition()); + List customFieldValues = Collections.singletonList("Geschaeftsstelle A"); + List reportLineItemDefinitions = Collections.singletonList( + new TimeIntervalColumnHeader(0, 0)); SelectedItem selectedItem = new SelectedItem(); selectedItem.setKey("EXTERN"); selectedItem.setLowerAgeLimit(1); selectedItem.setUpperAgeLimit(5); - List selectedItems = Arrays.asList(selectedItem); + List selectedItems = Collections.singletonList(selectedItem); - List expectedResult = Arrays.asList("TKI:000000000000000000000000000000000001"); + List expectedResult = Collections.singletonList("TKI:000000000000000000000000000000000001"); doReturn(expectedResult).when(taskMonitorMapperMock).getTaskIdsOfCategoriesBySelectedItems(workbasketIds, states, categories, domains, customField, customFieldValues, selectedItems);