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

TSK-1267: All TimeIntervalReports are now based on any TaskTimestamp

This commit is contained in:
Mustapha Zorgati 2020-07-21 07:10:26 +02:00
parent 83a79eab18
commit 97443641af
50 changed files with 648 additions and 1161 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
history/taskana-simplehistory-provider/src/main/java/pro/taskana/simplehistory/impl/TaskanaHistoryEngineImpl.java
View File

@ -70,8 +70,7 @@ public class TaskanaHistoryEngineImpl implements TaskanaHistoryEngine {
.map(role -> getConfiguration().getRoleMap().get(role))
.collect(HashSet::new, Set::addAll, Set::addAll);
return CurrentUserContext.getAccessIds().stream()
.anyMatch(rolesMembers::contains);
return CurrentUserContext.getAccessIds().stream().anyMatch(rolesMembers::contains);
}
public void checkRoleMembership(TaskanaRole... roles) throws NotAuthorizedException {

8
history/taskana-simplehistory-provider/src/test/java/acceptance/query/QueryHistoryAccTest.java
View File

@ -53,13 +53,9 @@ class QueryHistoryAccTest extends AbstractAccTest {
.orderByCreated(SortDirection.DESCENDING);
List<HistoryEventImpl> results = query.list();
assertThat(results)
.extracting(TaskanaHistoryEvent::getUserId)
.containsOnly("admin", "peter");
assertThat(results).extracting(TaskanaHistoryEvent::getUserId).containsOnly("admin", "peter");
results = query.orderByUserId(SortDirection.DESCENDING).list();
assertThat(results)
.extracting(TaskanaHistoryEvent::getUserId)
.containsOnly("admin", "peter");
assertThat(results).extracting(TaskanaHistoryEvent::getUserId).containsOnly("admin", "peter");
assertThat(query.domainLike().count()).isEqualTo(13);
}

15
history/taskana-simplehistory-provider/src/test/java/acceptance/security/JaasExtension.java
View File

@ -87,8 +87,7 @@ public class JaasExtension implements InvocationInterceptor, TestTemplateInvocat
Invocation<T> invocation,
ReflectiveInvocationContext<Method> invocationContext,
ExtensionContext extensionContext) {
WithAccessIds annotation = invocationContext.getExecutable().getAnnotation(
WithAccessIds.class);
WithAccessIds annotation = invocationContext.getExecutable().getAnnotation(WithAccessIds.class);
if (annotation != null) {
// our goal is to run each test returned from the test factory X times. X is the amount of
// WithAccessId annotations. In order to achieve this we are wrapping the result from the
@ -236,8 +235,7 @@ public class JaasExtension implements InvocationInterceptor, TestTemplateInvocat
private static <T> T extractAccessIdAndPerformInvocation(
Invocation<T> invocation, AnnotatedElement executable) {
return performInvocationWithAccessId(invocation, executable.getAnnotation(
WithAccessId.class));
return performInvocationWithAccessId(invocation, executable.getAnnotation(WithAccessId.class));
}
private static <T> T performInvocationWithAccessId(
@ -250,8 +248,7 @@ public class JaasExtension implements InvocationInterceptor, TestTemplateInvocat
return Subject.doAs(subject, performInvocation);
}
private static List<Principal> getPrincipals(
WithAccessId withAccessId) {
private static List<Principal> getPrincipals(WithAccessId withAccessId) {
if (withAccessId != null) {
return Stream.concat(
Stream.of(withAccessId.user()).map(UserPrincipal::new),
@ -289,16 +286,14 @@ public class JaasExtension implements InvocationInterceptor, TestTemplateInvocat
return context.getStore(Namespace.create(getClass(), context.getRequiredTestMethod()));
}
private static String getDisplayNameForAccessId(
WithAccessId withAccessId) {
private static String getDisplayNameForAccessId(WithAccessId withAccessId) {
return String.format("for user '%s'", withAccessId.user());
}
private static class JaasExtensionInvocationContext implements TestTemplateInvocationContext {
private final WithAccessId withAccessId;
private JaasExtensionInvocationContext(
WithAccessId withAccessId) {
private JaasExtensionInvocationContext(WithAccessId withAccessId) {
this.withAccessId = withAccessId;
}

4
history/taskana-simplehistory-rest-spring/src/test/java/pro/taskana/doc/api/TaskHistoryEventControllerRestDocumentation.java
View File

@ -173,7 +173,9 @@ public class TaskHistoryEventControllerRestDocumentation {
this.mockMvc
.perform(
RestDocumentationRequestBuilders.get(
"http://127.0.0.1:" + port + "/api/v1/task-history-event/HEI:000000000000000000000000000000000000")
"http://127.0.0.1:"
+ port
+ "/api/v1/task-history-event/HEI:000000000000000000000000000000000000")
.accept("application/hal+json")
.header("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x"))
.andExpect(MockMvcResultMatchers.status().isOk())

2
lib/taskana-core/src/main/java/pro/taskana/common/api/WorkingDaysToDaysConverter.java
View File

@ -22,7 +22,7 @@ import pro.taskana.common.api.exceptions.SystemException;
* The WorkingDaysToDaysConverter provides a method to convert an age in working days into an age in
* days.
*/
public final class WorkingDaysToDaysConverter {
public class WorkingDaysToDaysConverter {
// offset in days from easter sunday
private static final long OFFSET_GOOD_FRIDAY = -2; // Good Friday

1
lib/taskana-core/src/main/java/pro/taskana/common/internal/util/CheckedBiConsumer.java
View File

@ -4,5 +4,4 @@ package pro.taskana.common.internal.util;
public interface CheckedBiConsumer<T, U, E extends Throwable> {
void accept(T t, U u) throws E;
}

11
lib/taskana-core/src/main/java/pro/taskana/monitor/api/MonitorService.java
View File

@ -1,6 +1,6 @@
package pro.taskana.monitor.api;
import pro.taskana.monitor.api.reports.CategoryReport;
import pro.taskana.monitor.api.reports.ClassificationCategoryReport;
import pro.taskana.monitor.api.reports.ClassificationReport;
import pro.taskana.monitor.api.reports.CustomFieldValueReport;
import pro.taskana.monitor.api.reports.TaskStatusReport;
@ -20,12 +20,13 @@ public interface MonitorService {
WorkbasketReport.Builder createWorkbasketReportBuilder();
/**
* Provides a {@link CategoryReport.Builder} for creating a {@link CategoryReport}, list the task
* ids of this report and list the values of an entered custom attribute.
* Provides a {@link ClassificationCategoryReport.Builder} for creating a {@link
* ClassificationCategoryReport}, list the task ids of this report and list the values of an
* entered custom attribute.
*
* @return a {@link CategoryReport.Builder}
* @return a {@link ClassificationCategoryReport.Builder}
*/
CategoryReport.Builder createCategoryReportBuilder();
ClassificationCategoryReport.Builder createCategoryReportBuilder();
/**
* Provides a {@link ClassificationReport.Builder} for creating a {@link ClassificationReport} or

4
lib/taskana-core/src/main/java/pro/taskana/task/api/Timestamp.java → lib/taskana-core/src/main/java/pro/taskana/monitor/api/TaskTimestamp.java
View File

@ -1,9 +1,9 @@
package pro.taskana.task.api;
package pro.taskana.monitor.api;
import pro.taskana.task.api.models.Task;
/** This enum contains all timestamps saved in the database table for a {@link Task}. */
public enum Timestamp {
public enum TaskTimestamp {
CREATED,
CLAIMED,
COMPLETED,

15
lib/taskana-core/src/main/java/pro/taskana/monitor/api/reports/CategoryReport.java → lib/taskana-core/src/main/java/pro/taskana/monitor/api/reports/ClassificationCategoryReport.java
View File

@ -4,6 +4,7 @@ import java.util.List;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.monitor.api.TaskTimestamp;
import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
import pro.taskana.monitor.api.reports.item.MonitorQueryItem;
@ -15,17 +16,23 @@ import pro.taskana.monitor.api.reports.item.MonitorQueryItem;
* also the number of tasks of the respective cluster. The age of the tasks can be counted in days
* or in working days. Tasks with Timestamp DUE = null are not considered.
*/
public class CategoryReport extends Report<MonitorQueryItem, TimeIntervalColumnHeader> {
public class ClassificationCategoryReport
extends Report<MonitorQueryItem, TimeIntervalColumnHeader> {
public CategoryReport(List<TimeIntervalColumnHeader> timeIntervalColumnHeaders) {
public ClassificationCategoryReport(List<TimeIntervalColumnHeader> timeIntervalColumnHeaders) {
super(timeIntervalColumnHeaders, new String[] {"CLASSIFICATION CATEGORIES"});
}
/** Builder for {@link CategoryReport}. */
/** Builder for {@link ClassificationCategoryReport}. */
public interface Builder
extends TimeIntervalReportBuilder<Builder, MonitorQueryItem, TimeIntervalColumnHeader> {
@Override
CategoryReport buildReport() throws NotAuthorizedException, InvalidArgumentException;
ClassificationCategoryReport buildReport()
throws NotAuthorizedException, InvalidArgumentException;
@Override
ClassificationCategoryReport buildReport(TaskTimestamp timestamp)
throws NotAuthorizedException, InvalidArgumentException;
}
}

8
lib/taskana-core/src/main/java/pro/taskana/monitor/api/reports/ClassificationReport.java
View File

@ -4,6 +4,7 @@ import java.util.List;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.monitor.api.TaskTimestamp;
import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
import pro.taskana.monitor.api.reports.item.DetailedMonitorQueryItem;
import pro.taskana.monitor.api.reports.item.MonitorQueryItem;
@ -28,6 +29,10 @@ public class ClassificationReport extends Report<MonitorQueryItem, TimeIntervalC
@Override
ClassificationReport buildReport() throws NotAuthorizedException, InvalidArgumentException;
@Override
ClassificationReport buildReport(TaskTimestamp timestamp)
throws NotAuthorizedException, InvalidArgumentException;
/**
* Returns a {@link DetailedClassificationReport} containing all tasks after applying the
* filters. If the column headers are set the report is subdivided into clusters. Its {@link
@ -40,6 +45,9 @@ public class ClassificationReport extends Report<MonitorQueryItem, TimeIntervalC
*/
DetailedClassificationReport buildDetailedReport()
throws InvalidArgumentException, NotAuthorizedException;
DetailedClassificationReport buildDetailedReport(TaskTimestamp timestamp)
throws InvalidArgumentException, NotAuthorizedException;
}
/**

5
lib/taskana-core/src/main/java/pro/taskana/monitor/api/reports/CustomFieldValueReport.java
View File

@ -4,6 +4,7 @@ import java.util.List;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.monitor.api.TaskTimestamp;
import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
import pro.taskana.monitor.api.reports.item.MonitorQueryItem;
@ -27,5 +28,9 @@ public class CustomFieldValueReport extends Report<MonitorQueryItem, TimeInterva
@Override
CustomFieldValueReport buildReport() throws NotAuthorizedException, InvalidArgumentException;
@Override
CustomFieldValueReport buildReport(TaskTimestamp timestamp)
throws NotAuthorizedException, InvalidArgumentException;
}
}

6
lib/taskana-core/src/main/java/pro/taskana/monitor/api/reports/Report.java
View File

@ -27,10 +27,10 @@ import pro.taskana.monitor.api.reports.row.SingleRow;
*/
public abstract class Report<I extends QueryItem, H extends ColumnHeader<? super I>> {
private final Map<String, Row<I>> reportRows = new LinkedHashMap<>();
private final Row<I> sumRow;
private final String[] rowDesc;
protected List<H> columnHeaders;
private Map<String, Row<I>> reportRows = new LinkedHashMap<>();
private Row<I> sumRow;
private String[] rowDesc;
protected Report(List<H> columnHeaders, String[] rowDesc) {
this.rowDesc = rowDesc;

12
lib/taskana-core/src/main/java/pro/taskana/monitor/api/reports/TimeIntervalReportBuilder.java
View File

@ -6,6 +6,7 @@ import java.util.Map;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.monitor.api.SelectedItem;
import pro.taskana.monitor.api.TaskTimestamp;
import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
import pro.taskana.monitor.api.reports.item.AgeQueryItem;
import pro.taskana.task.api.CustomField;
@ -59,13 +60,13 @@ public interface TimeIntervalReportBuilder<
B stateIn(List<TaskState> states);
/**
* Adds a list of categories to the builder. The created report contains only tasks with a
* category in this list.
* Adds a list of classificationCategories to the builder. The created report contains only tasks
* with a category in this list.
*
* @param categories a list of categories
* @param classificationCategory a list of classificationCategories
* @return the TimeIntervalReportBuilder
*/
B categoryIn(List<String> categories);
B classificationCategoryIn(List<String> classificationCategory);
/**
* Adds a list of classificationIds to the builder. The created report contains only tasks with a
@ -123,4 +124,7 @@ public interface TimeIntervalReportBuilder<
*/
List<String> listCustomAttributeValuesForCustomAttributeName(CustomField customField)
throws NotAuthorizedException;
Report<I, H> buildReport(TaskTimestamp timestamp)
throws NotAuthorizedException, InvalidArgumentException;
}

4
lib/taskana-core/src/main/java/pro/taskana/monitor/api/reports/TimestampReport.java
View File

@ -4,10 +4,10 @@ import java.util.List;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.monitor.api.TaskTimestamp;
import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
import pro.taskana.monitor.api.reports.item.TimestampQueryItem;
import pro.taskana.monitor.api.reports.row.TimestampRow;
import pro.taskana.task.api.Timestamp;
/** A {@link TimestampReport} displays created and competed tasks for a specific dates. */
public class TimestampReport extends Report<TimestampQueryItem, TimeIntervalColumnHeader> {
@ -35,6 +35,6 @@ public class TimestampReport extends Report<TimestampQueryItem, TimeIntervalColu
@Override
TimestampReport buildReport() throws NotAuthorizedException, InvalidArgumentException;
Builder withTimestamps(List<Timestamp> statuses);
Builder withTimestamps(List<TaskTimestamp> statuses);
}
}

11
lib/taskana-core/src/main/java/pro/taskana/monitor/api/reports/WorkbasketReport.java
View File

@ -5,6 +5,7 @@ import java.util.List;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.monitor.api.CombinedClassificationFilter;
import pro.taskana.monitor.api.TaskTimestamp;
import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
import pro.taskana.monitor.api.reports.item.MonitorQueryItem;
@ -30,14 +31,8 @@ public class WorkbasketReport extends Report<MonitorQueryItem, TimeIntervalColum
@Override
WorkbasketReport buildReport() throws NotAuthorizedException, InvalidArgumentException;
/**
* buildPlannedDateBasedReport is querying grouping by plannedDate instead of due date.
*
* @return the built workbasketReport
* @throws NotAuthorizedException when the current user is not authorized to perform this action
* @throws InvalidArgumentException when the arguments given to the builder do not match
*/
WorkbasketReport buildPlannedDateBasedReport()
@Override
WorkbasketReport buildReport(TaskTimestamp timestamp)
throws NotAuthorizedException, InvalidArgumentException;
/**

4
lib/taskana-core/src/main/java/pro/taskana/monitor/api/reports/item/TimestampQueryItem.java
View File

@ -1,14 +1,14 @@
package pro.taskana.monitor.api.reports.item;
import pro.taskana.monitor.api.TaskTimestamp;
import pro.taskana.monitor.api.reports.TimestampReport;
import pro.taskana.task.api.Timestamp;
/** The TimestampQueryItem contains the necessary information for the {@link TimestampReport}. */
public class TimestampQueryItem implements AgeQueryItem {
private static final String N_A = "N/A";
private int count;
private Timestamp status;
private TaskTimestamp status;
private int ageInDays;
private String orgLevel1;
private String orgLevel2;

145
lib/taskana-core/src/main/java/pro/taskana/monitor/internal/MonitorMapper.java
View File

@ -9,13 +9,13 @@ import org.apache.ibatis.annotations.Select;
import pro.taskana.monitor.api.CombinedClassificationFilter;
import pro.taskana.monitor.api.SelectedItem;
import pro.taskana.monitor.api.TaskTimestamp;
import pro.taskana.monitor.api.reports.item.DetailedMonitorQueryItem;
import pro.taskana.monitor.api.reports.item.MonitorQueryItem;
import pro.taskana.monitor.api.reports.item.TaskQueryItem;
import pro.taskana.monitor.api.reports.item.TimestampQueryItem;
import pro.taskana.task.api.CustomField;
import pro.taskana.task.api.TaskState;
import pro.taskana.task.api.Timestamp;
/** This class is the mybatis mapping of task monitoring. */
@SuppressWarnings({"checkstyle:LineLength", "checkstyle:Indentation"})
@ -24,9 +24,9 @@ public interface MonitorMapper {
@Select(
"<script>"
+ "SELECT B.WORKBASKET_KEY, B.AGE_IN_DAYS, COUNT(B.AGE_IN_DAYS) AS NUMBER_OF_TASKS FROM ("
+ "<if test=\"_databaseId == 'db2'\">SELECT T.WORKBASKET_KEY, (DAYS(T.DUE) - DAYS(CURRENT_TIMESTAMP)) as AGE_IN_DAYS </if> "
+ "<if test=\"_databaseId == 'h2'\">SELECT T.WORKBASKET_KEY, DATEDIFF('DAY', CURRENT_TIMESTAMP, T.DUE) as AGE_IN_DAYS </if> "
+ "<if test=\"_databaseId == 'postgres'\">SELECT T.WORKBASKET_KEY, DATE_PART('DAY', T.DUE - CURRENT_TIMESTAMP) as AGE_IN_DAYS </if> "
+ "<if test=\"_databaseId == 'db2'\">SELECT T.WORKBASKET_KEY, (DAYS(T.${timestamp}) - DAYS(CURRENT_TIMESTAMP)) as AGE_IN_DAYS </if> "
+ "<if test=\"_databaseId == 'h2'\">SELECT T.WORKBASKET_KEY, DATEDIFF('DAY', CURRENT_TIMESTAMP, T.${timestamp}) as AGE_IN_DAYS </if> "
+ "<if test=\"_databaseId == 'postgres'\">SELECT T.WORKBASKET_KEY, DATE_PART('DAY', T.${timestamp} - CURRENT_TIMESTAMP) as AGE_IN_DAYS </if> "
+ "FROM TASK AS T LEFT JOIN ATTACHMENT AS A ON T.ID = A.TASK_ID "
+ "<where>"
+ "<if test=\"workbasketIds != null\">"
@ -35,8 +35,8 @@ public interface MonitorMapper {
+ "<if test=\"states != null\">"
+ "AND T.STATE IN (<foreach collection='states' item='state' separator=','>#{state}</foreach>) "
+ "</if>"
+ "<if test=\"categories != null\">"
+ "AND T.CLASSIFICATION_CATEGORY IN (<foreach collection='categories' item='category' separator=','>#{category}</foreach>) "
+ "<if test=\"classificationCategories != null\">"
+ "AND T.CLASSIFICATION_CATEGORY IN (<foreach collection='classificationCategories' item='category' separator=','>#{category}</foreach>) "
+ "</if>"
+ "<if test=\"domains != null\">"
+ "AND T.DOMAIN IN (<foreach collection='domains' item='domain' separator=','>#{domain}</foreach>) "
@ -69,66 +69,9 @@ public interface MonitorMapper {
List<MonitorQueryItem> getTaskCountOfWorkbaskets(
@Param("workbasketIds") List<String> workbasketIds,
@Param("states") List<TaskState> states,
@Param("categories") List<String> categories,
@Param("domains") List<String> domains,
@Param("classificationIds") List<String> classificationIds,
@Param("excludedClassificationIds") List<String> excludedClassificationIds,
@Param("customAttributeFilter") Map<CustomField, String> customAttributeFilter,
@Param("combinedClassificationFilter")
List<CombinedClassificationFilter> combinedClassificationFilter);
@Select(
"<script>"
+ "SELECT B.WORKBASKET_KEY, B.AGE_IN_DAYS, COUNT(B.AGE_IN_DAYS) AS NUMBER_OF_TASKS FROM ("
+ "<if test=\"_databaseId == 'db2'\">SELECT T.WORKBASKET_KEY, (DAYS(T.PLANNED) - DAYS(CURRENT_TIMESTAMP)) as AGE_IN_DAYS </if> "
+ "<if test=\"_databaseId == 'h2'\">SELECT T.WORKBASKET_KEY, DATEDIFF('DAY', CURRENT_TIMESTAMP, T.PLANNED) as AGE_IN_DAYS </if> "
+ "<if test=\"_databaseId == 'postgres'\">SELECT T.WORKBASKET_KEY, DATE_PART('DAY', T.PLANNED - CURRENT_TIMESTAMP) as AGE_IN_DAYS </if> "
+ "FROM TASK AS T LEFT JOIN ATTACHMENT AS A ON T.ID = A.TASK_ID "
+ "<where>"
+ "<if test=\"workbasketIds != null\">"
+ "T.WORKBASKET_ID IN (<foreach collection='workbasketIds' item='workbasketId' separator=','>#{workbasketId}</foreach>) "
+ "</if>"
+ "<if test=\"states != null\">"
+ "AND T.STATE IN (<foreach collection='states' item='state' separator=','>#{state}</foreach>) "
+ "</if>"
+ "<if test=\"categories != null\">"
+ "AND T.CLASSIFICATION_CATEGORY IN (<foreach collection='categories' item='category' separator=','>#{category}</foreach>) "
+ "</if>"
+ "<if test=\"domains != null\">"
+ "AND T.DOMAIN IN (<foreach collection='domains' item='domain' separator=','>#{domain}</foreach>) "
+ "</if>"
+ "<if test='classificationIds != null'>"
+ "AND CLASSIFICATION_ID IN (<foreach collection='classificationIds' item='classificationId' separator=','>#{classificationId}</foreach>) "
+ "</if>"
+ "<if test='excludedClassificationIds != null'>"
+ "AND CLASSIFICATION_ID NOT IN (<foreach collection='excludedClassificationIds' item='excludedClassificationId' separator=','>#{excludedClassificationId}</foreach>) "
+ "</if>"
+ "<if test='customAttributeFilter != null'>"
+ "AND (<foreach collection='customAttributeFilter.keys' item='key' separator=' AND '>(${key} = '${customAttributeFilter.get(key)}')</foreach>) "
+ "</if>"
+ "<if test=\"combinedClassificationFilter != null\">"
+ "AND <foreach collection='combinedClassificationFilter' item='item' separator='OR'> "
+ "T.CLASSIFICATION_ID = #{item.taskClassificationId}"
+ "<if test=\"item.attachmentClassificationId != null\">"
+ "AND A.CLASSIFICATION_ID = #{item.attachmentClassificationId}"
+ "</if>"
+ "</foreach>"
+ "</if>"
+ "AND T.PLANNED IS NOT NULL "
+ "</where>"
+ ") AS B "
+ "GROUP BY B.WORKBASKET_KEY, B.AGE_IN_DAYS"
+ "</script>")
@Results({
@Result(column = "WORKBASKET_KEY", property = "key"),
@Result(column = "AGE_IN_DAYS", property = "ageInDays"),
@Result(column = "NUMBER_OF_TASKS", property = "numberOfTasks")
})
List<MonitorQueryItem> getTaskCountOfWorkbasketsBasedOnPlannedDate(
@Param("workbasketIds") List<String> workbasketIds,
@Param("states") List<TaskState> states,
@Param("categories") List<String> categories,
@Param("classificationCategories") List<String> classificationCategories,
@Param("domains") List<String> domains,
@Param("timestamp") TaskTimestamp timestamp,
@Param("classificationIds") List<String> classificationIds,
@Param("excludedClassificationIds") List<String> excludedClassificationIds,
@Param("customAttributeFilter") Map<CustomField, String> customAttributeFilter,
@ -138,9 +81,9 @@ public interface MonitorMapper {
@Select(
"<script>"
+ "SELECT B.CLASSIFICATION_CATEGORY, B.AGE_IN_DAYS, COUNT(B.AGE_IN_DAYS) AS NUMBER_OF_TASKS FROM ("
+ "<if test=\"_databaseId == 'db2'\">SELECT CLASSIFICATION_CATEGORY, (DAYS(DUE) - DAYS(CURRENT_TIMESTAMP)) as AGE_IN_DAYS </if> "
+ "<if test=\"_databaseId == 'h2'\">SELECT CLASSIFICATION_CATEGORY, DATEDIFF('DAY', CURRENT_TIMESTAMP, DUE) as AGE_IN_DAYS </if> "
+ "<if test=\"_databaseId == 'postgres'\">SELECT CLASSIFICATION_CATEGORY, DATE_PART('DAY', DUE - CURRENT_TIMESTAMP) as AGE_IN_DAYS </if> "
+ "<if test=\"_databaseId == 'db2'\">SELECT CLASSIFICATION_CATEGORY, (DAYS(${timestamp}) - DAYS(CURRENT_TIMESTAMP)) as AGE_IN_DAYS </if> "
+ "<if test=\"_databaseId == 'h2'\">SELECT CLASSIFICATION_CATEGORY, DATEDIFF('DAY', CURRENT_TIMESTAMP, ${timestamp}) as AGE_IN_DAYS </if> "
+ "<if test=\"_databaseId == 'postgres'\">SELECT CLASSIFICATION_CATEGORY, DATE_PART('DAY', ${timestamp} - CURRENT_TIMESTAMP) as AGE_IN_DAYS </if> "
+ "FROM TASK "
+ "<where>"
+ "<if test=\"workbasketIds != null\">"
@ -149,8 +92,8 @@ public interface MonitorMapper {
+ "<if test=\"states != null\">"
+ "AND STATE IN (<foreach collection='states' item='state' separator=','>#{state}</foreach>) "
+ "</if>"
+ "<if test=\"categories != null\">"
+ "AND CLASSIFICATION_CATEGORY IN (<foreach collection='categories' item='category' separator=','>#{category}</foreach>) "
+ "<if test=\"classificationCategories != null\">"
+ "AND CLASSIFICATION_CATEGORY IN (<foreach collection='classificationCategories' item='category' separator=','>#{category}</foreach>) "
+ "</if>"
+ "<if test=\"domains != null\">"
+ "AND DOMAIN IN (<foreach collection='domains' item='domain' separator=','>#{domain}</foreach>) "
@ -177,8 +120,9 @@ public interface MonitorMapper {
List<MonitorQueryItem> getTaskCountOfCategories(
@Param("workbasketIds") List<String> workbasketIds,
@Param("states") List<TaskState> states,
@Param("categories") List<String> categories,
@Param("classificationCategories") List<String> classificationCategories,
@Param("domains") List<String> domains,
@Param("timestamp") TaskTimestamp timestamp,
@Param("classificationIds") List<String> classificationIds,
@Param("excludedClassificationIds") List<String> excludedClassificationIds,
@Param("customAttributeFilter") Map<CustomField, String> customAttributeFilter);
@ -186,9 +130,9 @@ public interface MonitorMapper {
@Select(
"<script>"
+ "SELECT B.CLASSIFICATION_KEY, B.AGE_IN_DAYS, COUNT(B.AGE_IN_DAYS) AS NUMBER_OF_TASKS FROM ("
+ "<if test=\"_databaseId == 'db2'\">SELECT CLASSIFICATION_KEY, (DAYS(DUE) - DAYS(CURRENT_TIMESTAMP)) as AGE_IN_DAYS </if> "
+ "<if test=\"_databaseId == 'h2'\">SELECT CLASSIFICATION_KEY, DATEDIFF('DAY', CURRENT_TIMESTAMP, DUE) as AGE_IN_DAYS </if> "
+ "<if test=\"_databaseId == 'postgres'\">SELECT CLASSIFICATION_KEY, DATE_PART('DAY', DUE - CURRENT_TIMESTAMP) as AGE_IN_DAYS </if> "
+ "<if test=\"_databaseId == 'db2'\">SELECT CLASSIFICATION_KEY, (DAYS(${timestamp}) - DAYS(CURRENT_TIMESTAMP)) as AGE_IN_DAYS </if> "
+ "<if test=\"_databaseId == 'h2'\">SELECT CLASSIFICATION_KEY, DATEDIFF('DAY', CURRENT_TIMESTAMP, ${timestamp}) as AGE_IN_DAYS </if> "
+ "<if test=\"_databaseId == 'postgres'\">SELECT CLASSIFICATION_KEY, DATE_PART('DAY', ${timestamp} - CURRENT_TIMESTAMP) as AGE_IN_DAYS </if> "
+ "FROM TASK "
+ "<where>"
+ "<if test=\"workbasketIds != null\">"
@ -197,8 +141,8 @@ public interface MonitorMapper {
+ "<if test=\"states != null\">"
+ "AND STATE IN (<foreach collection='states' item='state' separator=','>#{state}</foreach>) "
+ "</if>"
+ "<if test=\"categories != null\">"
+ "AND CLASSIFICATION_CATEGORY IN (<foreach collection='categories' item='category' separator=','>#{category}</foreach>) "
+ "<if test=\"classificationCategories != null\">"
+ "AND CLASSIFICATION_CATEGORY IN (<foreach collection='classificationCategories' item='category' separator=','>#{category}</foreach>) "
+ "</if>"
+ "<if test=\"domains != null\">"
+ "AND DOMAIN IN (<foreach collection='domains' item='domain' separator=','>#{domain}</foreach>) "
@ -225,8 +169,9 @@ public interface MonitorMapper {
List<MonitorQueryItem> getTaskCountOfClassifications(
@Param("workbasketIds") List<String> workbasketIds,
@Param("states") List<TaskState> states,
@Param("categories") List<String> categories,
@Param("classificationCategories") List<String> classificationCategories,
@Param("domains") List<String> domains,
@Param("timestamp") TaskTimestamp timestamp,
@Param("classificationIds") List<String> classificationIds,
@Param("excludedClassificationIds") List<String> excludedClassificationIds,
@Param("customAttributeFilter") Map<CustomField, String> customAttributeFilter);
@ -234,9 +179,9 @@ public interface MonitorMapper {
@Select(
"<script>"
+ "SELECT B.TASK_CLASSIFICATION_KEY, B.ATTACHMENT_CLASSIFICATION_KEY, B.AGE_IN_DAYS, COUNT(B.AGE_IN_DAYS) AS NUMBER_OF_TASKS FROM ("
+ "<if test=\"_databaseId == 'db2'\">SELECT T.CLASSIFICATION_KEY as TASK_CLASSIFICATION_KEY, A.CLASSIFICATION_KEY as ATTACHMENT_CLASSIFICATION_KEY, (DAYS(DUE) - DAYS(CURRENT_TIMESTAMP)) as AGE_IN_DAYS </if> "
+ "<if test=\"_databaseId == 'h2'\">SELECT T.CLASSIFICATION_KEY as TASK_CLASSIFICATION_KEY, A.CLASSIFICATION_KEY as ATTACHMENT_CLASSIFICATION_KEY, DATEDIFF('DAY', CURRENT_TIMESTAMP, DUE) as AGE_IN_DAYS </if> "
+ "<if test=\"_databaseId == 'postgres'\">SELECT T.CLASSIFICATION_KEY as TASK_CLASSIFICATION_KEY, A.CLASSIFICATION_KEY as ATTACHMENT_CLASSIFICATION_KEY, DATE_PART('DAY', DUE - CURRENT_TIMESTAMP) as AGE_IN_DAYS </if> "
+ "<if test=\"_databaseId == 'db2'\">SELECT T.CLASSIFICATION_KEY as TASK_CLASSIFICATION_KEY, A.CLASSIFICATION_KEY as ATTACHMENT_CLASSIFICATION_KEY, (DAYS(T.${timestamp}) - DAYS(CURRENT_TIMESTAMP)) as AGE_IN_DAYS </if> "
+ "<if test=\"_databaseId == 'h2'\">SELECT T.CLASSIFICATION_KEY as TASK_CLASSIFICATION_KEY, A.CLASSIFICATION_KEY as ATTACHMENT_CLASSIFICATION_KEY, DATEDIFF('DAY', CURRENT_TIMESTAMP, T.${timestamp}) as AGE_IN_DAYS </if> "
+ "<if test=\"_databaseId == 'postgres'\">SELECT T.CLASSIFICATION_KEY as TASK_CLASSIFICATION_KEY, A.CLASSIFICATION_KEY as ATTACHMENT_CLASSIFICATION_KEY, DATE_PART('DAY', T.${timestamp} - CURRENT_TIMESTAMP) as AGE_IN_DAYS </if> "
+ "FROM TASK AS T LEFT JOIN ATTACHMENT AS A ON T.ID = A.TASK_ID "
+ "<where>"
+ "<if test=\"workbasketIds != null\">"
@ -245,8 +190,8 @@ public interface MonitorMapper {
+ "<if test=\"states != null\">"
+ "AND STATE IN (<foreach collection='states' item='state' separator=','>#{state}</foreach>) "
+ "</if>"
+ "<if test=\"categories != null\">"
+ "AND CLASSIFICATION_CATEGORY IN (<foreach collection='categories' item='category' separator=','>#{category}</foreach>) "
+ "<if test=\"classificationCategories != null\">"
+ "AND CLASSIFICATION_CATEGORY IN (<foreach collection='classificationCategories' item='category' separator=','>#{category}</foreach>) "
+ "</if>"
+ "<if test=\"domains != null\">"
+ "AND DOMAIN IN (<foreach collection='domains' item='domain' separator=','>#{domain}</foreach>) "
@ -274,8 +219,9 @@ public interface MonitorMapper {
List<DetailedMonitorQueryItem> getTaskCountOfDetailedClassifications(
@Param("workbasketIds") List<String> workbasketIds,
@Param("states") List<TaskState> states,
@Param("categories") List<String> categories,
@Param("classificationCategories") List<String> classificationCategories,
@Param("domains") List<String> domains,
@Param("timestamp") TaskTimestamp timestamp,
@Param("classificationIds") List<String> classificationIds,
@Param("excludedClassificationIds") List<String> excludedClassificationIds,
@Param("customAttributeFilter") Map<CustomField, String> customAttributeFilter);
@ -283,9 +229,9 @@ public interface MonitorMapper {
@Select(
"<script>"
+ "SELECT B.CUSTOM_FIELD, B.AGE_IN_DAYS, COUNT(B.AGE_IN_DAYS) AS NUMBER_OF_TASKS FROM ("
+ "<if test=\"_databaseId == 'db2'\">SELECT ${customField} as CUSTOM_FIELD, (DAYS(DUE) - DAYS(CURRENT_TIMESTAMP)) as AGE_IN_DAYS </if> "
+ "<if test=\"_databaseId == 'h2'\">SELECT ${customField} as CUSTOM_FIELD, DATEDIFF('DAY', CURRENT_TIMESTAMP, DUE) as AGE_IN_DAYS </if> "
+ "<if test=\"_databaseId == 'postgres'\">SELECT ${customField} as CUSTOM_FIELD, DATE_PART('DAY', DUE - CURRENT_TIMESTAMP) as AGE_IN_DAYS </if> "
+ "<if test=\"_databaseId == 'db2'\">SELECT ${customField} as CUSTOM_FIELD, (DAYS(${timestamp}) - DAYS(CURRENT_TIMESTAMP)) as AGE_IN_DAYS </if> "
+ "<if test=\"_databaseId == 'h2'\">SELECT ${customField} as CUSTOM_FIELD, DATEDIFF('DAY', CURRENT_TIMESTAMP, ${timestamp}) as AGE_IN_DAYS </if> "
+ "<if test=\"_databaseId == 'postgres'\">SELECT ${customField} as CUSTOM_FIELD, DATE_PART('DAY', ${timestamp} - CURRENT_TIMESTAMP) as AGE_IN_DAYS </if> "
+ "FROM TASK "
+ "<where>"
+ "<if test=\"workbasketIds != null\">"
@ -294,8 +240,8 @@ public interface MonitorMapper {
+ "<if test=\"states != null\">"
+ "AND STATE IN (<foreach collection='states' item='state' separator=','>#{state}</foreach>) "
+ "</if>"
+ "<if test=\"categories != null\">"
+ "AND CLASSIFICATION_CATEGORY IN (<foreach collection='categories' item='category' separator=','>#{category}</foreach>) "
+ "<if test=\"classificationCategories != null\">"
+ "AND CLASSIFICATION_CATEGORY IN (<foreach collection='classificationCategories' item='category' separator=','>#{category}</foreach>) "
+ "</if>"
+ "<if test=\"domains != null\">"
+ "AND DOMAIN IN (<foreach collection='domains' item='domain' separator=','>#{domain}</foreach>) "
@ -323,8 +269,9 @@ public interface MonitorMapper {
@Param("customField") CustomField customField,
@Param("workbasketIds") List<String> workbasketIds,
@Param("states") List<TaskState> states,
@Param("categories") List<String> categories,
@Param("classificationCategories") List<String> classificationCategories,
@Param("domains") List<String> domains,
@Param("timestamp") TaskTimestamp timestamp,
@Param("classificationIds") List<String> classificationIds,
@Param("excludedClassificationIds") List<String> excludedClassificationIds,
@Param("customAttributeFilter") Map<CustomField, String> customAttributeFilter);
@ -342,8 +289,8 @@ public interface MonitorMapper {
+ "<if test=\"states != null\">"
+ "AND T.STATE IN (<foreach collection='states' item='state' separator=','>#{state}</foreach>) "
+ "</if>"
+ "<if test=\"categories != null\">"
+ "AND T.CLASSIFICATION_CATEGORY IN (<foreach collection='categories' item='category' separator=','>#{category}</foreach>) "
+ "<if test=\"classificationCategories != null\">"
+ "AND T.CLASSIFICATION_CATEGORY IN (<foreach collection='classificationCategories' item='category' separator=','>#{category}</foreach>) "
+ "</if>"
+ "<if test=\"domains != null\">"
+ "AND DOMAIN IN (<foreach collection='domains' item='domain' separator=','>#{domain}</foreach>) "
@ -382,7 +329,7 @@ public interface MonitorMapper {
List<String> getTaskIdsForSelectedItems(
@Param("workbasketIds") List<String> workbasketIds,
@Param("states") List<TaskState> states,
@Param("categories") List<String> categories,
@Param("classificationCategories") List<String> classificationCategories,
@Param("domains") List<String> domains,
@Param("classificationIds") List<String> classificationIds,
@Param("excludedClassificationIds") List<String> excludedClassificationIds,
@ -424,8 +371,8 @@ public interface MonitorMapper {
+ "<if test='states != null'>"
+ "AND STATE IN (<foreach collection='states' item='state' separator=','>#{state}</foreach>) "
+ "</if>"
+ "<if test='categories != null'>"
+ "AND CLASSIFICATION_CATEGORY IN (<foreach collection='categories' item='category' separator=','>#{category}</foreach>) "
+ "<if test='classificationCategories != null'>"
+ "AND CLASSIFICATION_CATEGORY IN (<foreach collection='classificationCategories' item='category' separator=','>#{category}</foreach>) "
+ "</if>"
+ "<if test='domains != null'>"
+ "AND DOMAIN IN (<foreach collection='domains' item='domain' separator=','>#{domain}</foreach>) "
@ -444,7 +391,7 @@ public interface MonitorMapper {
List<String> getCustomAttributeValuesForReport(
@Param("workbasketIds") List<String> workbasketIds,
@Param("states") List<TaskState> states,
@Param("categories") List<String> categories,
@Param("classificationCategories") List<String> classificationCategories,
@Param("domains") List<String> domains,
@Param("classificationIds") List<String> classificationIds,
@Param("excludedClassificationIds") List<String> excludedClassificationIds,
@ -471,8 +418,8 @@ public interface MonitorMapper {
+ "<if test=\"status.name() == 'COMPLETED'\">"
+ "T.COMPLETED IS NOT NULL"
+ "</if>"
+ "<if test='categories != null'>"
+ "AND CLASSIFICATION_CATEGORY IN (<foreach collection='categories' item='category' separator=','>#{category}</foreach>) "
+ "<if test='classificationCategories != null'>"
+ "AND CLASSIFICATION_CATEGORY IN (<foreach collection='classificationCategories' item='category' separator=','>#{category}</foreach>) "
+ "</if>"
+ "<if test='classificationIds != null'>"
+ "AND CLASSIFICATION_ID IN (<foreach collection='classificationIds' item='classificationId' separator=','>#{classificationId}</foreach>) "
@ -500,8 +447,8 @@ public interface MonitorMapper {
@Result(column = "ORG_LEVEL_4", property = "orgLevel4")
})
List<TimestampQueryItem> getTasksCountForStatusGroupedByOrgLevel(
@Param("status") Timestamp status,
@Param("categories") List<String> categories,
@Param("status") TaskTimestamp status,
@Param("classificationCategories") List<String> classificationCategories,
@Param("classificationIds") List<String> classificationIds,
@Param("excludedClassificationIds") List<String> excludedClassificationIds,
@Param("domains") List<String> domains,

8
lib/taskana-core/src/main/java/pro/taskana/monitor/internal/MonitorServiceImpl.java
View File

@ -2,13 +2,13 @@ package pro.taskana.monitor.internal;
import pro.taskana.common.internal.InternalTaskanaEngine;
import pro.taskana.monitor.api.MonitorService;
import pro.taskana.monitor.api.reports.CategoryReport;
import pro.taskana.monitor.api.reports.ClassificationCategoryReport;
import pro.taskana.monitor.api.reports.ClassificationReport;
import pro.taskana.monitor.api.reports.CustomFieldValueReport;
import pro.taskana.monitor.api.reports.TaskStatusReport;
import pro.taskana.monitor.api.reports.TimestampReport;
import pro.taskana.monitor.api.reports.WorkbasketReport;
import pro.taskana.monitor.internal.reports.CategoryReportBuilderImpl;
import pro.taskana.monitor.internal.reports.ClassificationCategoryReportBuilderImpl;
import pro.taskana.monitor.internal.reports.ClassificationReportBuilderImpl;
import pro.taskana.monitor.internal.reports.CustomFieldValueReportBuilderImpl;
import pro.taskana.monitor.internal.reports.TaskStatusReportBuilderImpl;
@ -34,8 +34,8 @@ public class MonitorServiceImpl implements MonitorService {
}
@Override
public CategoryReport.Builder createCategoryReportBuilder() {
return new CategoryReportBuilderImpl(taskanaEngine, monitorMapper);
public ClassificationCategoryReport.Builder createCategoryReportBuilder() {
return new ClassificationCategoryReportBuilderImpl(taskanaEngine, monitorMapper);
}
@Override

30
lib/taskana-core/src/main/java/pro/taskana/monitor/internal/reports/CategoryReportBuilderImpl.java → lib/taskana-core/src/main/java/pro/taskana/monitor/internal/reports/ClassificationCategoryReportBuilderImpl.java
View File

@ -8,38 +8,48 @@ import pro.taskana.common.api.TaskanaRole;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.InternalTaskanaEngine;
import pro.taskana.monitor.api.reports.CategoryReport;
import pro.taskana.monitor.api.reports.CategoryReport.Builder;
import pro.taskana.monitor.api.TaskTimestamp;
import pro.taskana.monitor.api.reports.ClassificationCategoryReport;
import pro.taskana.monitor.api.reports.ClassificationCategoryReport.Builder;
import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
import pro.taskana.monitor.api.reports.item.MonitorQueryItem;
import pro.taskana.monitor.internal.MonitorMapper;
import pro.taskana.monitor.internal.preprocessor.DaysToWorkingDaysReportPreProcessor;
/** The implementation of CategoryReportBuilder. */
public class CategoryReportBuilderImpl
public class ClassificationCategoryReportBuilderImpl
extends TimeIntervalReportBuilderImpl<Builder, MonitorQueryItem, TimeIntervalColumnHeader>
implements CategoryReport.Builder {
implements ClassificationCategoryReport.Builder {
private static final Logger LOGGER = LoggerFactory.getLogger(CategoryReport.Builder.class);
private static final Logger LOGGER =
LoggerFactory.getLogger(ClassificationCategoryReportBuilderImpl.class);
public CategoryReportBuilderImpl(
public ClassificationCategoryReportBuilderImpl(
InternalTaskanaEngine taskanaEngine, MonitorMapper monitorMapper) {
super(taskanaEngine, monitorMapper);
}
@Override
public CategoryReport buildReport() throws InvalidArgumentException, NotAuthorizedException {
public ClassificationCategoryReport buildReport()
throws NotAuthorizedException, InvalidArgumentException {
return buildReport(TaskTimestamp.DUE);
}
@Override
public ClassificationCategoryReport buildReport(TaskTimestamp timestamp)
throws InvalidArgumentException, NotAuthorizedException {
LOGGER.debug("entry to buildReport(), this = {}", this);
this.taskanaEngine.getEngine().checkRoleMembership(TaskanaRole.MONITOR);
try {
this.taskanaEngine.openConnection();
CategoryReport report = new CategoryReport(this.columnHeaders);
ClassificationCategoryReport report = new ClassificationCategoryReport(this.columnHeaders);
List<MonitorQueryItem> monitorQueryItems =
this.monitorMapper.getTaskCountOfCategories(
this.workbasketIds,
this.states,
this.categories,
this.classificationCategory,
this.domains,
timestamp,
this.classificationIds,
this.excludedClassificationIds,
this.customAttributeFilter);
@ -55,7 +65,7 @@ public class CategoryReportBuilderImpl
}
@Override
protected CategoryReport.Builder _this() {
protected ClassificationCategoryReport.Builder _this() {
return this;
}

22
lib/taskana-core/src/main/java/pro/taskana/monitor/internal/reports/ClassificationReportBuilderImpl.java
View File

@ -8,6 +8,7 @@ import pro.taskana.common.api.TaskanaRole;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.InternalTaskanaEngine;
import pro.taskana.monitor.api.TaskTimestamp;
import pro.taskana.monitor.api.reports.ClassificationReport;
import pro.taskana.monitor.api.reports.ClassificationReport.Builder;
import pro.taskana.monitor.api.reports.ClassificationReport.DetailedClassificationReport;
@ -22,7 +23,8 @@ public class ClassificationReportBuilderImpl
extends TimeIntervalReportBuilderImpl<Builder, MonitorQueryItem, TimeIntervalColumnHeader>
implements ClassificationReport.Builder {
private static final Logger LOGGER = LoggerFactory.getLogger(ClassificationReport.Builder.class);
private static final Logger LOGGER =
LoggerFactory.getLogger(ClassificationReportBuilderImpl.class);
public ClassificationReportBuilderImpl(
InternalTaskanaEngine taskanaEngine, MonitorMapper monitorMapper) {
@ -31,6 +33,12 @@ public class ClassificationReportBuilderImpl
@Override
public ClassificationReport buildReport()
throws NotAuthorizedException, InvalidArgumentException {
return buildReport(TaskTimestamp.DUE);
}
@Override
public ClassificationReport buildReport(TaskTimestamp timestamp)
throws InvalidArgumentException, NotAuthorizedException {
LOGGER.debug("entry to buildReport(), this = {}", this);
this.taskanaEngine.getEngine().checkRoleMembership(TaskanaRole.MONITOR, TaskanaRole.ADMIN);
@ -41,8 +49,9 @@ public class ClassificationReportBuilderImpl
this.monitorMapper.getTaskCountOfClassifications(
this.workbasketIds,
this.states,
this.categories,
this.classificationCategory,
this.domains,
timestamp,
this.classificationIds,
this.excludedClassificationIds,
this.customAttributeFilter);
@ -60,6 +69,12 @@ public class ClassificationReportBuilderImpl
@Override
public DetailedClassificationReport buildDetailedReport()
throws InvalidArgumentException, NotAuthorizedException {
return buildDetailedReport(TaskTimestamp.DUE);
}
@Override
public DetailedClassificationReport buildDetailedReport(TaskTimestamp timestamp)
throws InvalidArgumentException, NotAuthorizedException {
LOGGER.debug("entry to buildDetailedReport(), this = {}", this);
this.taskanaEngine.getEngine().checkRoleMembership(TaskanaRole.MONITOR, TaskanaRole.ADMIN);
try {
@ -69,8 +84,9 @@ public class ClassificationReportBuilderImpl
this.monitorMapper.getTaskCountOfDetailedClassifications(
this.workbasketIds,
this.states,
this.categories,
this.classificationCategory,
this.domains,
timestamp,
this.classificationIds,
this.excludedClassificationIds,
this.customAttributeFilter);

12
lib/taskana-core/src/main/java/pro/taskana/monitor/internal/reports/CustomFieldValueReportBuilderImpl.java
View File

@ -8,6 +8,7 @@ import pro.taskana.common.api.TaskanaRole;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.InternalTaskanaEngine;
import pro.taskana.monitor.api.TaskTimestamp;
import pro.taskana.monitor.api.reports.CustomFieldValueReport;
import pro.taskana.monitor.api.reports.CustomFieldValueReport.Builder;
import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
@ -24,7 +25,7 @@ public class CustomFieldValueReportBuilderImpl
private static final Logger LOGGER =
LoggerFactory.getLogger(CustomFieldValueReportBuilderImpl.class);
private CustomField customField;
private final CustomField customField;
public CustomFieldValueReportBuilderImpl(
InternalTaskanaEngine taskanaEngine, MonitorMapper monitorMapper, CustomField customField) {
@ -34,6 +35,12 @@ public class CustomFieldValueReportBuilderImpl
@Override
public CustomFieldValueReport buildReport()
throws NotAuthorizedException, InvalidArgumentException {
return buildReport(TaskTimestamp.DUE);
}
@Override
public CustomFieldValueReport buildReport(TaskTimestamp timestamp)
throws InvalidArgumentException, NotAuthorizedException {
LOGGER.debug("entry to buildReport(customField = {}), this = {}", this.customField, this);
this.taskanaEngine.getEngine().checkRoleMembership(TaskanaRole.MONITOR);
@ -45,8 +52,9 @@ public class CustomFieldValueReportBuilderImpl
this.customField,
this.workbasketIds,
this.states,
this.categories,
this.classificationCategory,
this.domains,
timestamp,
this.classificationIds,
this.excludedClassificationIds,
this.customAttributeFilter);

10
lib/taskana-core/src/main/java/pro/taskana/monitor/internal/reports/TimeIntervalReportBuilderImpl.java
View File

@ -44,7 +44,7 @@ abstract class TimeIntervalReportBuilderImpl<
protected boolean inWorkingDays;
protected List<String> workbasketIds;
protected List<TaskState> states;
protected List<String> categories;
protected List<String> classificationCategory;
protected List<String> domains;
protected List<String> classificationIds;
protected List<String> excludedClassificationIds;
@ -83,8 +83,8 @@ abstract class TimeIntervalReportBuilderImpl<
}
@Override
public B categoryIn(List<String> categories) {
this.categories = new ArrayList<>(categories);
public B classificationCategoryIn(List<String> classificationCategory) {
this.classificationCategory = new ArrayList<>(classificationCategory);
return _this();
}
@ -141,7 +141,7 @@ abstract class TimeIntervalReportBuilderImpl<
return this.monitorMapper.getTaskIdsForSelectedItems(
this.workbasketIds,
this.states,
this.categories,
this.classificationCategory,
this.domains,
this.classificationIds,
this.excludedClassificationIds,
@ -168,7 +168,7 @@ abstract class TimeIntervalReportBuilderImpl<
return monitorMapper.getCustomAttributeValuesForReport(
this.workbasketIds,
this.states,
this.categories,
this.classificationCategory,
this.domains,
this.classificationIds,
this.excludedClassificationIds,

31
lib/taskana-core/src/main/java/pro/taskana/monitor/internal/reports/TimestampReportBuilderImpl.java
View File

@ -13,6 +13,8 @@ import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.InternalTaskanaEngine;
import pro.taskana.monitor.api.SelectedItem;
import pro.taskana.monitor.api.TaskTimestamp;
import pro.taskana.monitor.api.reports.Report;
import pro.taskana.monitor.api.reports.TimestampReport;
import pro.taskana.monitor.api.reports.TimestampReport.Builder;
import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
@ -20,15 +22,15 @@ import pro.taskana.monitor.api.reports.item.TimestampQueryItem;
import pro.taskana.monitor.internal.MonitorMapper;
import pro.taskana.monitor.internal.preprocessor.DaysToWorkingDaysReportPreProcessor;
import pro.taskana.task.api.TaskState;
import pro.taskana.task.api.Timestamp;
/** The implementation of {@link TimestampReport.Builder}. */
public class TimestampReportBuilderImpl
extends TimeIntervalReportBuilderImpl<Builder, TimestampQueryItem, TimeIntervalColumnHeader>
implements TimestampReport.Builder {
private static final Logger LOGGER = LoggerFactory.getLogger(TimestampReport.Builder.class);
private List<Timestamp> status = Arrays.asList(Timestamp.CREATED, Timestamp.COMPLETED);
private static final Logger LOGGER = LoggerFactory.getLogger(TimestampReportBuilderImpl.class);
private List<TaskTimestamp> status =
Arrays.asList(TaskTimestamp.CREATED, TaskTimestamp.COMPLETED);
public TimestampReportBuilderImpl(
InternalTaskanaEngine taskanaEngine, MonitorMapper monitorMapper) {
@ -47,33 +49,36 @@ public class TimestampReportBuilderImpl
}
@Override
public TimestampReport.Builder withTimestamps(List<Timestamp> statuses) {
public TimestampReport.Builder withTimestamps(List<TaskTimestamp> statuses) {
this.status = new ArrayList<>(statuses);
return _this();
}
@Override
public Report<TimestampQueryItem, TimeIntervalColumnHeader> buildReport(TaskTimestamp timestamp)
throws NotAuthorizedException, InvalidArgumentException {
return buildReport();
}
@Override
public TimestampReport buildReport() throws NotAuthorizedException, InvalidArgumentException {
LOGGER.debug("entry to buildDetailedReport(), this = {}", this);
this.taskanaEngine.getEngine().checkRoleMembership(TaskanaRole.MONITOR, TaskanaRole.ADMIN);
try {
this.taskanaEngine.openConnection();
TimestampReport report = new TimestampReport(this.columnHeaders);
TimestampReport report = new TimestampReport(columnHeaders);
List<TimestampQueryItem> items =
status.stream()
// This can also be implemented into a single sql query which combines all statuses
// with the union
// operator. That would reduce the readability of the sql template. That's why "the
// loop" is done
// outside of mybatis.
// with the union operator. That would reduce the readability of the sql template.
// That's why "the loop" is done outside of mybatis.
.map(this::getTasksCountForStatusGroupedByOrgLevel)
.flatMap(Collection::stream)
.collect(Collectors.toList());
report.addItems(
items,
new DaysToWorkingDaysReportPreProcessor<>(
this.columnHeaders, converter, this.inWorkingDays));
new DaysToWorkingDaysReportPreProcessor<>(columnHeaders, converter, inWorkingDays));
return report;
} finally {
this.taskanaEngine.returnConnection();
@ -91,10 +96,10 @@ public class TimestampReportBuilderImpl
throw new UnsupportedOperationException();
}
private List<TimestampQueryItem> getTasksCountForStatusGroupedByOrgLevel(Timestamp s) {
private List<TimestampQueryItem> getTasksCountForStatusGroupedByOrgLevel(TaskTimestamp s) {
return monitorMapper.getTasksCountForStatusGroupedByOrgLevel(
s,
categories,
classificationCategory,
classificationIds,
excludedClassificationIds,
domains,

41
lib/taskana-core/src/main/java/pro/taskana/monitor/internal/reports/WorkbasketReportBuilderImpl.java
View File

@ -9,6 +9,7 @@ import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.InternalTaskanaEngine;
import pro.taskana.monitor.api.CombinedClassificationFilter;
import pro.taskana.monitor.api.TaskTimestamp;
import pro.taskana.monitor.api.reports.WorkbasketReport;
import pro.taskana.monitor.api.reports.WorkbasketReport.Builder;
import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
@ -30,7 +31,13 @@ public class WorkbasketReportBuilderImpl
}
@Override
public WorkbasketReport buildReport() throws InvalidArgumentException, NotAuthorizedException {
public WorkbasketReport buildReport() throws NotAuthorizedException, InvalidArgumentException {
return buildReport(TaskTimestamp.DUE);
}
@Override
public WorkbasketReport buildReport(TaskTimestamp timestamp)
throws InvalidArgumentException, NotAuthorizedException {
LOGGER.debug("entry to buildReport(), this = {}", this);
this.taskanaEngine.getEngine().checkRoleMembership(TaskanaRole.MONITOR, TaskanaRole.ADMIN);
try {
@ -40,8 +47,9 @@ public class WorkbasketReportBuilderImpl
this.monitorMapper.getTaskCountOfWorkbaskets(
this.workbasketIds,
this.states,
this.categories,
this.classificationCategory,
this.domains,
timestamp,
this.classificationIds,
this.excludedClassificationIds,
this.customAttributeFilter,
@ -57,35 +65,6 @@ public class WorkbasketReportBuilderImpl
}
}
@Override
public WorkbasketReport buildPlannedDateBasedReport()
throws NotAuthorizedException, InvalidArgumentException {
LOGGER.debug("entry to buildPlannedDateReport(), this = {}", this);
this.taskanaEngine.getEngine().checkRoleMembership(TaskanaRole.MONITOR, TaskanaRole.ADMIN);
try {
this.taskanaEngine.openConnection();
WorkbasketReport report = new WorkbasketReport(this.columnHeaders);
List<MonitorQueryItem> monitorQueryItems =
this.monitorMapper.getTaskCountOfWorkbasketsBasedOnPlannedDate(
this.workbasketIds,
this.states,
this.categories,
this.domains,
this.classificationIds,
this.excludedClassificationIds,
this.customAttributeFilter,
this.combinedClassificationFilter);
report.addItems(
monitorQueryItems,
new DaysToWorkingDaysReportPreProcessor<>(
this.columnHeaders, converter, this.inWorkingDays));
return report;
} finally {
this.taskanaEngine.returnConnection();
LOGGER.debug("exit from buildPlannedDateReport().");
}
}
@Override
public WorkbasketReport.Builder combinedClassificationFilterIn(
List<CombinedClassificationFilter> combinedClassificationFilter) {

19
lib/taskana-core/src/main/java/pro/taskana/spi/history/internal/HistoryEventManager.java
View File

@ -12,9 +12,7 @@ import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.spi.history.api.TaskanaHistory;
import pro.taskana.spi.history.api.events.TaskanaHistoryEvent;
/**
* Creates and deletes events and emits them to the registered history service providers.
*/
/** Creates and deletes events and emits them to the registered history service providers. */
public final class HistoryEventManager {
private static final Logger LOGGER = LoggerFactory.getLogger(HistoryEventManager.class);
@ -53,12 +51,13 @@ public final class HistoryEventManager {
public void deleteEvents(List<String> taskIds) {
LOGGER.debug("Sending taskIds to history service providers: {}", taskIds);
serviceLoader.forEach(historyProvider -> {
try {
historyProvider.deleteHistoryEventsByTaskIds(taskIds);
} catch (InvalidArgumentException | NotAuthorizedException e) {
LOGGER.warn("Caught an exception while trying to delete HistoryEvents", e);
}
});
serviceLoader.forEach(
historyProvider -> {
try {
historyProvider.deleteHistoryEventsByTaskIds(taskIds);
} catch (InvalidArgumentException | NotAuthorizedException e) {
LOGGER.warn("Caught an exception while trying to delete HistoryEvents", e);
}
});
}
}

1
lib/taskana-core/src/main/java/pro/taskana/task/internal/TaskQueryMapper.java
View File

@ -337,7 +337,6 @@ public interface TaskQueryMapper {
+ "</if>"
+ "<if test=\"addAttachmentClassificationNameToSelectClauseForOrdering\">"
+ ", ACNAME "
+ "</if>"
+ ", FLAG ) "
+ "AS "

5
lib/taskana-core/src/test/java/acceptance/report/AbstractReportAccTest.java
View File

@ -9,14 +9,11 @@ import pro.taskana.common.internal.TaskanaEngineTestConfiguration;
import pro.taskana.sampledata.SampleDataGenerator;
/** Abstract test class for all report building tests. */
public class AbstractReportAccTest {
public abstract class AbstractReportAccTest {
protected static TaskanaEngineConfiguration taskanaEngineConfiguration;
protected static TaskanaEngine taskanaEngine;
// checkstyle needs this constructor, since this is only a "utility" class
protected AbstractReportAccTest() {}
protected static void resetDb() throws Exception {
DataSource dataSource = TaskanaEngineTestConfiguration.getDataSource();
String schemaName = TaskanaEngineTestConfiguration.getSchemaName();

4
lib/taskana-core/src/test/java/acceptance/report/GetTaskIdsOfCategoryReportAccTest.java → lib/taskana-core/src/test/java/acceptance/report/GetTaskIdsOfClassificationCategoryReportAccTest.java
View File

@ -25,7 +25,7 @@ import pro.taskana.task.api.TaskState;
/** Acceptance test for all "get task ids of category report" scenarios. */
@ExtendWith(JaasExtension.class)
class GetTaskIdsOfCategoryReportAccTest extends AbstractReportAccTest {
class GetTaskIdsOfClassificationCategoryReportAccTest extends AbstractReportAccTest {
@Test
void testRoleCheck() {
@ -211,7 +211,7 @@ class GetTaskIdsOfCategoryReportAccTest extends AbstractReportAccTest {
.createCategoryReportBuilder()
.withColumnHeaders(columnHeaders)
.inWorkingDays()
.categoryIn(categories)
.classificationCategoryIn(categories)
.listTaskIdsForSelectedItems(selectedItems);
assertThat(ids)

2
lib/taskana-core/src/test/java/acceptance/report/GetTaskIdsOfCustomFieldValueReportAccTest.java
View File

@ -211,7 +211,7 @@ class GetTaskIdsOfCustomFieldValueReportAccTest extends AbstractReportAccTest {
.createCustomFieldValueReportBuilder(CustomField.CUSTOM_1)
.withColumnHeaders(columnHeaders)
.inWorkingDays()
.categoryIn(categories)
.classificationCategoryIn(categories)
.listTaskIdsForSelectedItems(selectedItems);
assertThat(ids).hasSize(3);

240
lib/taskana-core/src/test/java/acceptance/report/ProvideCategoryReportAccTest.java → lib/taskana-core/src/test/java/acceptance/report/ProvideClassificationCategoryReportAccTest.java
View File

@ -1,60 +1,51 @@
package acceptance.report;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatCode;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.stream.IntStream;
import java.util.stream.Stream;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.DynamicTest;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestFactory;
import org.junit.jupiter.api.extension.ExtendWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.junit.jupiter.api.function.ThrowingConsumer;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
import pro.taskana.monitor.api.MonitorService;
import pro.taskana.monitor.api.reports.CategoryReport;
import pro.taskana.monitor.api.TaskTimestamp;
import pro.taskana.monitor.api.reports.ClassificationCategoryReport;
import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
import pro.taskana.task.api.CustomField;
import pro.taskana.task.api.TaskState;
/** Acceptance test for all "category report" scenarios. */
@ExtendWith(JaasExtension.class)
class ProvideCategoryReportAccTest extends AbstractReportAccTest {
class ProvideClassificationCategoryReportAccTest extends AbstractReportAccTest {
private static final Logger LOGGER = LoggerFactory.getLogger(ProvideCategoryReportAccTest.class);
private static final MonitorService MONITOR_SERVICE = taskanaEngine.getMonitorService();
@Test
void testRoleCheck() {
MonitorService monitorService = taskanaEngine.getMonitorService();
// Assertions.assertThrows(
// NotAuthorizedException.class,
// () -> monitorService.createCategoryReportBuilder().buildReport());
ThrowingCallable call =
() -> {
monitorService.createCategoryReportBuilder().buildReport();
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
assertThatThrownBy(() -> MONITOR_SERVICE.createCategoryReportBuilder().buildReport())
.isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(user = "monitor")
@Test
void testGetTotalNumbersOfTasksOfCategoryReport() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
CategoryReport report = monitorService.createCategoryReportBuilder().buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report));
}
ClassificationCategoryReport report =
MONITOR_SERVICE.createCategoryReportBuilder().buildReport();
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
@ -62,32 +53,24 @@ class ProvideCategoryReportAccTest extends AbstractReportAccTest {
assertThat(report.getRow("EXTERN").getTotalValue()).isEqualTo(33);
assertThat(report.getRow("AUTOMATIC").getTotalValue()).isEqualTo(7);
assertThat(report.getRow("MANUAL").getTotalValue()).isEqualTo(10);
assertThat(report.getRow("EXTERN").getCells().length).isEqualTo(0);
assertThat(report.getRow("AUTOMATIC").getCells().length).isEqualTo(0);
assertThat(report.getRow("MANUAL").getCells().length).isEqualTo(0);
assertThat(report.getRow("EXTERN").getCells()).isEmpty();
assertThat(report.getRow("AUTOMATIC").getCells()).isEmpty();
assertThat(report.getRow("MANUAL").getCells()).isEmpty();
assertThat(report.getSumRow().getTotalValue()).isEqualTo(50);
}
@WithAccessId(user = "monitor")
@Test
void testGetCategoryReportWithReportLineItemDefinitions() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
CategoryReport report =
monitorService
ClassificationCategoryReport report =
MONITOR_SERVICE
.createCategoryReportBuilder()
.withColumnHeaders(columnHeaders)
.inWorkingDays()
.buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
final int sumLineCount = IntStream.of(report.getSumRow().getCells()).sum();
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
@ -98,27 +81,20 @@ class ProvideCategoryReportAccTest extends AbstractReportAccTest {
int[] sumRow = report.getSumRow().getCells();
assertThat(sumRow).isEqualTo(new int[] {10, 9, 11, 0, 4, 0, 7, 4, 5});
assertThat(report.getSumRow().getTotalValue()).isEqualTo(50);
assertThat(sumLineCount).isEqualTo(50);
}
@WithAccessId(user = "monitor")
@Test
void testEachItemOfCategoryReport() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
CategoryReport report =
monitorService
ClassificationCategoryReport report =
MONITOR_SERVICE
.createCategoryReportBuilder()
.withColumnHeaders(columnHeaders)
.inWorkingDays()
.buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
@ -133,18 +109,53 @@ class ProvideCategoryReportAccTest extends AbstractReportAccTest {
}
@WithAccessId(user = "monitor")
@Test
void testEachItemOfCategoryReportNotInWorkingDays() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
@TestFactory
Stream<DynamicTest> should_NotThrowError_When_buildReportForTaskState() {
Iterator<TaskTimestamp> iterator = Arrays.stream(TaskTimestamp.values()).iterator();
ThrowingConsumer<TaskTimestamp> test =
timestamp -> {
ThrowingCallable callable =
() -> MONITOR_SERVICE.createCategoryReportBuilder().buildReport(timestamp);
assertThatCode(callable).doesNotThrowAnyException();
};
return DynamicTest.stream(iterator, t -> "for TaskState " + t, test);
}
@WithAccessId(user = "monitor")
@Test
void should_computeNumbersAccordingToPlannedDate_When_BuildReportForPlanned() throws Exception {
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
CategoryReport report =
monitorService.createCategoryReportBuilder().withColumnHeaders(columnHeaders).buildReport();
ClassificationCategoryReport report =
MONITOR_SERVICE
.createCategoryReportBuilder()
.withColumnHeaders(columnHeaders)
.inWorkingDays()
.buildReport(TaskTimestamp.PLANNED);
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
int[] row1 = report.getRow("EXTERN").getCells();
assertThat(row1).isEqualTo(new int[] {0, 3, 30, 0, 0});
int[] row2 = report.getRow("AUTOMATIC").getCells();
assertThat(row2).isEqualTo(new int[] {0, 0, 7, 0, 0});
int[] row3 = report.getRow("MANUAL").getCells();
assertThat(row3).isEqualTo(new int[] {0, 0, 10, 0, 0});
}
@WithAccessId(user = "monitor")
@Test
void testEachItemOfCategoryReportNotInWorkingDays() throws Exception {
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
ClassificationCategoryReport report =
MONITOR_SERVICE
.createCategoryReportBuilder()
.withColumnHeaders(columnHeaders)
.buildReport();
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
@ -162,24 +173,18 @@ class ProvideCategoryReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfCategoryReportWithWorkbasketFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<String> workbasketIds =
Collections.singletonList("WBI:000000000000000000000000000000000001");
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
CategoryReport report =
monitorService
ClassificationCategoryReport report =
MONITOR_SERVICE
.createCategoryReportBuilder()
.withColumnHeaders(columnHeaders)
.inWorkingDays()
.workbasketIdIn(workbasketIds)
.buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
@ -196,23 +201,17 @@ class ProvideCategoryReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfCategoryReportWithStateFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TaskState> states = Collections.singletonList(TaskState.READY);
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
CategoryReport report =
monitorService
ClassificationCategoryReport report =
MONITOR_SERVICE
.createCategoryReportBuilder()
.withColumnHeaders(columnHeaders)
.stateIn(states)
.inWorkingDays()
.buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
@ -229,23 +228,17 @@ class ProvideCategoryReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfCategoryReportWithCategoryFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<String> categories = Arrays.asList("AUTOMATIC", "MANUAL");
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
CategoryReport report =
monitorService
ClassificationCategoryReport report =
MONITOR_SERVICE
.createCategoryReportBuilder()
.withColumnHeaders(columnHeaders)
.categoryIn(categories)
.classificationCategoryIn(categories)
.inWorkingDays()
.buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(2);
@ -259,23 +252,17 @@ class ProvideCategoryReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfCategoryReportWithDomainFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<String> domains = Collections.singletonList("DOMAIN_A");
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
CategoryReport report =
monitorService
ClassificationCategoryReport report =
MONITOR_SERVICE
.createCategoryReportBuilder()
.withColumnHeaders(columnHeaders)
.domainIn(domains)
.inWorkingDays()
.buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
@ -292,24 +279,18 @@ class ProvideCategoryReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfCategoryReportWithCustomFieldValueFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
Map<CustomField, String> customAttributeFilter = new HashMap<>();
customAttributeFilter.put(CustomField.CUSTOM_1, "Geschaeftsstelle A");
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
CategoryReport report =
monitorService
ClassificationCategoryReport report =
MONITOR_SERVICE
.createCategoryReportBuilder()
.withColumnHeaders(columnHeaders)
.customAttributeFilterIn(customAttributeFilter)
.inWorkingDays()
.buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
@ -346,75 +327,4 @@ class ProvideCategoryReportAccTest extends AbstractReportAccTest {
columnHeaders.add(new TimeIntervalColumnHeader(6, Integer.MAX_VALUE));
return columnHeaders;
}
private String reportToString(CategoryReport report) {
return reportToString(report, null);
}
private String reportToString(
CategoryReport report, List<TimeIntervalColumnHeader> columnHeaders) {
final String formatColumWidth = "| %-7s ";
final String formatFirstColumn = "| %-36s %-4s ";
final String formatFirstColumnFirstLine = "| %-29s %12s ";
final String formatFirstColumnSumLine = "| %-36s %-5s";
int reportWidth = columnHeaders == null ? 46 : columnHeaders.size() * 10 + 46;
StringBuilder builder = new StringBuilder();
builder.append("\n");
for (int i = 0; i < reportWidth; i++) {
builder.append("-");
}
builder.append("\n");
builder.append(String.format(formatFirstColumnFirstLine, "Categories", "Total"));
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) {
builder.append(String.format(formatColumWidth, "> " + def.getLowerAgeLimit()));
} else if (def.getLowerAgeLimit() == def.getUpperAgeLimit()) {
if (def.getLowerAgeLimit() == 0) {
builder.append(String.format(formatColumWidth, "today"));
} else {
builder.append(String.format(formatColumWidth, def.getLowerAgeLimit()));
}
} else {
builder.append(
String.format(
formatColumWidth, def.getLowerAgeLimit() + ".." + def.getUpperAgeLimit()));
}
}
}
builder.append("|\n");
for (int i = 0; i < reportWidth; i++) {
builder.append("-");
}
builder.append("\n");
for (String rl : report.rowTitles()) {
builder.append(String.format(formatFirstColumn, rl, report.getRow(rl).getTotalValue()));
if (columnHeaders != null) {
for (int cell : report.getRow(rl).getCells()) {
builder.append(String.format(formatColumWidth, cell));
}
}
builder.append("|\n");
for (int i = 0; i < reportWidth; i++) {
builder.append("-");
}
builder.append("\n");
}
builder.append(
String.format(formatFirstColumnSumLine, "Total", report.getSumRow().getTotalValue()));
for (int cell : report.getSumRow().getCells()) {
builder.append(String.format(formatColumWidth, cell));
}
builder.append("|\n");
for (int i = 0; i < reportWidth; i++) {
builder.append("-");
}
builder.append("\n");
return builder.toString();
}
}

226
lib/taskana-core/src/test/java/acceptance/report/ProvideClassificationReportAccTest.java
View File

@ -1,25 +1,29 @@
package acceptance.report;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatCode;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.stream.IntStream;
import java.util.stream.Stream;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.DynamicTest;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestFactory;
import org.junit.jupiter.api.extension.ExtendWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.junit.jupiter.api.function.ThrowingConsumer;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
import pro.taskana.monitor.api.MonitorService;
import pro.taskana.monitor.api.TaskTimestamp;
import pro.taskana.monitor.api.reports.ClassificationReport;
import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
import pro.taskana.task.api.CustomField;
@ -29,30 +33,18 @@ import pro.taskana.task.api.TaskState;
@ExtendWith(JaasExtension.class)
class ProvideClassificationReportAccTest extends AbstractReportAccTest {
private static final Logger LOGGER =
LoggerFactory.getLogger(ProvideClassificationReportAccTest.class);
private static final MonitorService MONITOR_SERVICE = taskanaEngine.getMonitorService();
@Test
void testRoleCheck() {
MonitorService monitorService = taskanaEngine.getMonitorService();
ThrowingCallable call =
() -> {
monitorService.createClassificationReportBuilder().buildReport();
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
assertThatThrownBy(() -> MONITOR_SERVICE.createClassificationReportBuilder().buildReport())
.isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(user = "monitor")
@Test
void testGetTotalNumbersOfTasksOfClassificationReport() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
ClassificationReport report = monitorService.createClassificationReportBuilder().buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report));
}
ClassificationReport report = MONITOR_SERVICE.createClassificationReportBuilder().buildReport();
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(5);
@ -73,23 +65,15 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetClassificationReportWithReportLineItemDefinitions() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnsHeaders();
ClassificationReport report =
monitorService
MONITOR_SERVICE
.createClassificationReportBuilder()
.withColumnHeaders(columnHeaders)
.inWorkingDays()
.buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
final int sumLineCount = IntStream.of(report.getSumRow().getCells()).sum();
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(5);
@ -99,37 +83,22 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
assertThat(report.getRow("L40000").getTotalValue()).isEqualTo(10);
assertThat(report.getRow("L50000").getTotalValue()).isEqualTo(13);
assertThat(report.getSumRow().getCells()[0]).isEqualTo(10);
assertThat(report.getSumRow().getCells()[1]).isEqualTo(9);
assertThat(report.getSumRow().getCells()[2]).isEqualTo(11);
assertThat(report.getSumRow().getCells()[3]).isEqualTo(0);
assertThat(report.getSumRow().getCells()[4]).isEqualTo(4);
assertThat(report.getSumRow().getCells()[5]).isEqualTo(0);
assertThat(report.getSumRow().getCells()[6]).isEqualTo(7);
assertThat(report.getSumRow().getCells()[7]).isEqualTo(4);
assertThat(report.getSumRow().getCells()[8]).isEqualTo(5);
assertThat(report.getSumRow().getCells()).isEqualTo(new int[] {10, 9, 11, 0, 4, 0, 7, 4, 5});
assertThat(report.getSumRow().getTotalValue()).isEqualTo(50);
assertThat(sumLineCount).isEqualTo(50);
}
@WithAccessId(user = "monitor")
@Test
void testEachItemOfClassificationReport() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
ClassificationReport report =
monitorService
MONITOR_SERVICE
.createClassificationReportBuilder()
.withColumnHeaders(columnHeaders)
.inWorkingDays()
.buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(5);
@ -150,22 +119,60 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
}
@WithAccessId(user = "monitor")
@Test
void testEachItemOfClassificationReportNotInWorkingDays() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
@TestFactory
Stream<DynamicTest> should_NotThrowError_When_buildReportForTaskState() {
Iterator<TaskTimestamp> iterator = Arrays.stream(TaskTimestamp.values()).iterator();
ThrowingConsumer<TaskTimestamp> test =
timestamp -> {
ThrowingCallable callable =
() -> MONITOR_SERVICE.createClassificationReportBuilder().buildReport(timestamp);
assertThatCode(callable).doesNotThrowAnyException();
};
return DynamicTest.stream(iterator, t -> "for TaskState " + t, test);
}
@WithAccessId(user = "monitor")
@Test
void should_computeNumbersAccordingToPlannedDate_When_BuildReportForPlanned() throws Exception {
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
ClassificationReport report =
monitorService
MONITOR_SERVICE
.createClassificationReportBuilder()
.withColumnHeaders(columnHeaders)
.inWorkingDays()
.buildReport(TaskTimestamp.PLANNED);
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(5);
int[] row1 = report.getRow("L10000").getCells();
assertThat(row1).isEqualTo(new int[] {0, 2, 8, 0, 0});
int[] row2 = report.getRow("L20000").getCells();
assertThat(row2).isEqualTo(new int[] {0, 1, 9, 0, 0});
int[] row3 = report.getRow("L30000").getCells();
assertThat(row3).isEqualTo(new int[] {0, 0, 7, 0, 0});
int[] row4 = report.getRow("L40000").getCells();
assertThat(row4).isEqualTo(new int[] {0, 0, 10, 0, 0});
int[] row5 = report.getRow("L50000").getCells();
assertThat(row5).isEqualTo(new int[] {0, 0, 13, 0, 0});
}
@WithAccessId(user = "monitor")
@Test
void testEachItemOfClassificationReportNotInWorkingDays() throws Exception {
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
ClassificationReport report =
MONITOR_SERVICE
.createClassificationReportBuilder()
.withColumnHeaders(columnHeaders)
.buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(5);
@ -188,24 +195,18 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfClassificationReportWithWorkbasketFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<String> workbasketIds =
Collections.singletonList("WBI:000000000000000000000000000000000001");
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
ClassificationReport report =
monitorService
MONITOR_SERVICE
.createClassificationReportBuilder()
.withColumnHeaders(columnHeaders)
.workbasketIdIn(workbasketIds)
.inWorkingDays()
.buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(5);
@ -228,23 +229,17 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfClassificationReportWithStateFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TaskState> states = Collections.singletonList(TaskState.READY);
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
ClassificationReport report =
monitorService
MONITOR_SERVICE
.createClassificationReportBuilder()
.withColumnHeaders(columnHeaders)
.stateIn(states)
.inWorkingDays()
.buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(5);
@ -267,23 +262,17 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfClassificationReportWithCategoryFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<String> categories = Arrays.asList("AUTOMATIC", "MANUAL");
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
ClassificationReport report =
monitorService
MONITOR_SERVICE
.createClassificationReportBuilder()
.withColumnHeaders(columnHeaders)
.categoryIn(categories)
.classificationCategoryIn(categories)
.inWorkingDays()
.buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(2);
@ -297,23 +286,17 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfClassificationReportWithDomainFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<String> domains = Collections.singletonList("DOMAIN_A");
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
ClassificationReport report =
monitorService
MONITOR_SERVICE
.createClassificationReportBuilder()
.withColumnHeaders(columnHeaders)
.domainIn(domains)
.inWorkingDays()
.buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(5);
@ -336,24 +319,18 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfClassificationReportWithCustomFieldValueFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
Map<CustomField, String> customAttributeFilter = new HashMap<>();
customAttributeFilter.put(CustomField.CUSTOM_1, "Geschaeftsstelle A");
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
ClassificationReport report =
monitorService
MONITOR_SERVICE
.createClassificationReportBuilder()
.withColumnHeaders(columnHeaders)
.customAttributeFilterIn(customAttributeFilter)
.inWorkingDays()
.buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(5);
@ -396,75 +373,4 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
reportLineItemDefinitions.add(new TimeIntervalColumnHeader(6, Integer.MAX_VALUE));
return reportLineItemDefinitions;
}
private String reportToString(ClassificationReport report) {
return reportToString(report, null);
}
private String reportToString(
ClassificationReport report, List<TimeIntervalColumnHeader> columnHeaders) {
final String formatColumWidth = "| %-7s ";
final String formatFirstColumn = "| %-36s %-4s ";
final String formatFirstColumnFirstLine = "| %-29s %12s ";
final String formatFirstColumnSumLine = "| %-36s %-5s";
int reportWidth = columnHeaders == null ? 46 : columnHeaders.size() * 10 + 46;
StringBuilder builder = new StringBuilder();
builder.append("\n");
for (int i = 0; i < reportWidth; i++) {
builder.append("-");
}
builder.append("\n");
builder.append(String.format(formatFirstColumnFirstLine, "Classifications", "Total"));
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) {
builder.append(String.format(formatColumWidth, "> " + def.getLowerAgeLimit()));
} else if (def.getLowerAgeLimit() == def.getUpperAgeLimit()) {
if (def.getLowerAgeLimit() == 0) {
builder.append(String.format(formatColumWidth, "today"));
} else {
builder.append(String.format(formatColumWidth, def.getLowerAgeLimit()));
}
} else {
builder.append(
String.format(
formatColumWidth, def.getLowerAgeLimit() + ".." + def.getUpperAgeLimit()));
}
}
}
builder.append("|\n");
for (int i = 0; i < reportWidth; i++) {
builder.append("-");
}
builder.append("\n");
for (String rl : report.rowTitles()) {
builder.append(String.format(formatFirstColumn, rl, report.getRow(rl).getTotalValue()));
if (columnHeaders != null) {
for (int cell : report.getRow(rl).getCells()) {
builder.append(String.format(formatColumWidth, cell));
}
}
builder.append("|\n");
for (int i = 0; i < reportWidth; i++) {
builder.append("-");
}
builder.append("\n");
}
builder.append(
String.format(formatFirstColumnSumLine, "Total", report.getSumRow().getTotalValue()));
for (int cell : report.getSumRow().getCells()) {
builder.append(String.format(formatColumWidth, cell));
}
builder.append("|\n");
for (int i = 0; i < reportWidth; i++) {
builder.append("-");
}
builder.append("\n");
return builder.toString();
}
}

212
lib/taskana-core/src/test/java/acceptance/report/ProvideCustomFieldValueReportAccTest.java
View File

@ -1,24 +1,29 @@
package acceptance.report;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatCode;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.stream.Stream;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.DynamicTest;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestFactory;
import org.junit.jupiter.api.extension.ExtendWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.junit.jupiter.api.function.ThrowingConsumer;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
import pro.taskana.monitor.api.MonitorService;
import pro.taskana.monitor.api.TaskTimestamp;
import pro.taskana.monitor.api.reports.CustomFieldValueReport;
import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
import pro.taskana.task.api.CustomField;
@ -28,16 +33,13 @@ import pro.taskana.task.api.TaskState;
@ExtendWith(JaasExtension.class)
class ProvideCustomFieldValueReportAccTest extends AbstractReportAccTest {
private static final Logger LOGGER =
LoggerFactory.getLogger(ProvideCustomFieldValueReportAccTest.class);
private static final MonitorService MONITOR_SERVICE = taskanaEngine.getMonitorService();
@Test
void testRoleCheck() {
MonitorService monitorService = taskanaEngine.getMonitorService();
ThrowingCallable call =
() -> {
monitorService.createCustomFieldValueReportBuilder(CustomField.CUSTOM_1).buildReport();
MONITOR_SERVICE.createCustomFieldValueReportBuilder(CustomField.CUSTOM_1).buildReport();
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@ -45,14 +47,8 @@ class ProvideCustomFieldValueReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetTotalNumbersOfTasksOfCustomFieldValueReportForCustom1() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
CustomFieldValueReport report =
monitorService.createCustomFieldValueReportBuilder(CustomField.CUSTOM_1).buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report));
}
MONITOR_SERVICE.createCustomFieldValueReportBuilder(CustomField.CUSTOM_1).buildReport();
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
@ -70,14 +66,8 @@ class ProvideCustomFieldValueReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetTotalNumbersOfTasksOfCustomFieldValueReportForCustom2() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
CustomFieldValueReport report =
monitorService.createCustomFieldValueReportBuilder(CustomField.CUSTOM_2).buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report));
}
MONITOR_SERVICE.createCustomFieldValueReportBuilder(CustomField.CUSTOM_2).buildReport();
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(2);
@ -94,22 +84,16 @@ class ProvideCustomFieldValueReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetCustomFieldValueReportWithReportLineItemDefinitions() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
CustomField customField = CustomField.CUSTOM_1;
List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
CustomFieldValueReport report =
monitorService
MONITOR_SERVICE
.createCustomFieldValueReportBuilder(customField)
.withColumnHeaders(columnHeaders)
.inWorkingDays()
.buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
@ -122,24 +106,34 @@ class ProvideCustomFieldValueReportAccTest extends AbstractReportAccTest {
assertThat(report.getSumRow().getTotalValue()).isEqualTo(50);
}
@WithAccessId(user = "monitor")
@TestFactory
Stream<DynamicTest> should_NotThrowError_When_buildReportForTaskState() {
Iterator<TaskTimestamp> iterator = Arrays.stream(TaskTimestamp.values()).iterator();
ThrowingConsumer<TaskTimestamp> test =
timestamp -> {
ThrowingCallable callable =
() ->
MONITOR_SERVICE
.createCustomFieldValueReportBuilder(CustomField.CUSTOM_1)
.buildReport(timestamp);
assertThatCode(callable).doesNotThrowAnyException();
};
return DynamicTest.stream(iterator, t -> "for TaskState " + t, test);
}
@WithAccessId(user = "monitor")
@Test
void testEachItemOfCustomFieldValueReport() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
CustomFieldValueReport report =
monitorService
MONITOR_SERVICE
.createCustomFieldValueReportBuilder(CustomField.CUSTOM_1)
.withColumnHeaders(columnHeaders)
.inWorkingDays()
.buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
@ -155,21 +149,40 @@ class ProvideCustomFieldValueReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfCustomFieldValueReportNotInWorkingDays() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
void should_computeNumbersAccordingToPlannedDate_When_BuildReportForPlanned() throws Exception {
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
CustomFieldValueReport report =
monitorService
MONITOR_SERVICE
.createCustomFieldValueReportBuilder(CustomField.CUSTOM_1)
.withColumnHeaders(columnHeaders)
.inWorkingDays()
.buildReport(TaskTimestamp.PLANNED);
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
int[] row1 = report.getRow("Geschaeftsstelle A").getCells();
assertThat(row1).isEqualTo(new int[] {0, 1, 24, 0, 0});
int[] row2 = report.getRow("Geschaeftsstelle B").getCells();
assertThat(row2).isEqualTo(new int[] {0, 1, 9, 0, 0});
int[] row3 = report.getRow("Geschaeftsstelle C").getCells();
assertThat(row3).isEqualTo(new int[] {0, 1, 14, 0, 0});
}
@WithAccessId(user = "monitor")
@Test
void testEachItemOfCustomFieldValueReportNotInWorkingDays() throws Exception {
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
CustomFieldValueReport report =
MONITOR_SERVICE
.createCustomFieldValueReportBuilder(CustomField.CUSTOM_1)
.withColumnHeaders(columnHeaders)
.buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
@ -186,24 +199,18 @@ class ProvideCustomFieldValueReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfCustomFieldValueReportWithWorkbasketFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<String> workbasketIds =
Collections.singletonList("WBI:000000000000000000000000000000000001");
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
CustomFieldValueReport report =
monitorService
MONITOR_SERVICE
.createCustomFieldValueReportBuilder(CustomField.CUSTOM_1)
.withColumnHeaders(columnHeaders)
.inWorkingDays()
.workbasketIdIn(workbasketIds)
.buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
@ -220,23 +227,17 @@ class ProvideCustomFieldValueReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfCustomFieldValueReportWithStateFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TaskState> states = Collections.singletonList(TaskState.READY);
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
CustomFieldValueReport report =
monitorService
MONITOR_SERVICE
.createCustomFieldValueReportBuilder(CustomField.CUSTOM_1)
.withColumnHeaders(columnHeaders)
.inWorkingDays()
.stateIn(states)
.buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
@ -253,23 +254,17 @@ class ProvideCustomFieldValueReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfCustomFieldValueReportWithCategoryFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<String> categories = Arrays.asList("AUTOMATIC", "MANUAL");
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
CustomFieldValueReport report =
monitorService
MONITOR_SERVICE
.createCustomFieldValueReportBuilder(CustomField.CUSTOM_1)
.withColumnHeaders(columnHeaders)
.inWorkingDays()
.categoryIn(categories)
.classificationCategoryIn(categories)
.buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
@ -286,23 +281,17 @@ class ProvideCustomFieldValueReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfCustomFieldValueReportWithDomainFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<String> domains = Collections.singletonList("DOMAIN_A");
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
CustomFieldValueReport report =
monitorService
MONITOR_SERVICE
.createCustomFieldValueReportBuilder(CustomField.CUSTOM_1)
.withColumnHeaders(columnHeaders)
.inWorkingDays()
.domainIn(domains)
.buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
@ -319,24 +308,18 @@ class ProvideCustomFieldValueReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfCustomFieldValueReportWithCustomFieldValueFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
Map<CustomField, String> customAttributeFilter = new HashMap<>();
customAttributeFilter.put(CustomField.CUSTOM_1, "Geschaeftsstelle A");
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
CustomFieldValueReport report =
monitorService
MONITOR_SERVICE
.createCustomFieldValueReportBuilder(CustomField.CUSTOM_1)
.customAttributeFilterIn(customAttributeFilter)
.withColumnHeaders(columnHeaders)
.inWorkingDays()
.buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(1);
@ -367,75 +350,4 @@ class ProvideCustomFieldValueReportAccTest extends AbstractReportAccTest {
columnHeaders.add(new TimeIntervalColumnHeader(6, Integer.MAX_VALUE));
return columnHeaders;
}
private String reportToString(CustomFieldValueReport report) {
return reportToString(report, null);
}
private String reportToString(
CustomFieldValueReport report, List<TimeIntervalColumnHeader> columnHeaders) {
String formatColumWidth = "| %-7s ";
String formatFirstColumn = "| %-36s %-4s ";
final String formatFirstColumnFirstLine = "| %-29s %12s ";
final String formatFirstColumnSumLine = "| %-36s %-5s";
int reportWidth = columnHeaders == null ? 46 : columnHeaders.size() * 10 + 46;
StringBuilder builder = new StringBuilder();
builder.append("\n");
for (int i = 0; i < reportWidth; i++) {
builder.append("-");
}
builder.append("\n");
builder.append(String.format(formatFirstColumnFirstLine, "Custom field values", "Total"));
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) {
builder.append(String.format(formatColumWidth, "> " + def.getLowerAgeLimit()));
} else if (def.getLowerAgeLimit() == def.getUpperAgeLimit()) {
if (def.getLowerAgeLimit() == 0) {
builder.append(String.format(formatColumWidth, "today"));
} else {
builder.append(String.format(formatColumWidth, def.getLowerAgeLimit()));
}
} else {
builder.append(
String.format(
formatColumWidth, def.getLowerAgeLimit() + ".." + def.getUpperAgeLimit()));
}
}
}
builder.append("|\n");
for (int i = 0; i < reportWidth; i++) {
builder.append("-");
}
builder.append("\n");
for (String rl : report.rowTitles()) {
builder.append(String.format(formatFirstColumn, rl, report.getRow(rl).getTotalValue()));
if (columnHeaders != null) {
for (int cell : report.getRow(rl).getCells()) {
builder.append(String.format(formatColumWidth, cell));
}
}
builder.append("|\n");
for (int i = 0; i < reportWidth; i++) {
builder.append("-");
}
builder.append("\n");
}
builder.append(
String.format(formatFirstColumnSumLine, "Total", report.getSumRow().getTotalValue()));
for (int cell : report.getSumRow().getCells()) {
builder.append(String.format(formatColumWidth, cell));
}
builder.append("|\n");
for (int i = 0; i < reportWidth; i++) {
builder.append("-");
}
builder.append("\n");
return builder.toString();
}
}

248
lib/taskana-core/src/test/java/acceptance/report/ProvideDetailedClassificationReportAccTest.java
View File

@ -1,24 +1,29 @@
package acceptance.report;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatCode;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.stream.Stream;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.DynamicTest;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestFactory;
import org.junit.jupiter.api.extension.ExtendWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.junit.jupiter.api.function.ThrowingConsumer;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
import pro.taskana.monitor.api.MonitorService;
import pro.taskana.monitor.api.TaskTimestamp;
import pro.taskana.monitor.api.reports.ClassificationReport.DetailedClassificationReport;
import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
import pro.taskana.monitor.api.reports.item.DetailedMonitorQueryItem;
@ -31,31 +36,20 @@ import pro.taskana.task.api.TaskState;
@ExtendWith(JaasExtension.class)
class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
private static final Logger LOGGER =
LoggerFactory.getLogger(ProvideDetailedClassificationReportAccTest.class);
private static final MonitorService MONITOR_SERVICE = taskanaEngine.getMonitorService();
@Test
void testRoleCheck() {
MonitorService monitorService = taskanaEngine.getMonitorService();
ThrowingCallable call =
() -> {
monitorService.createClassificationReportBuilder().buildDetailedReport();
};
() -> MONITOR_SERVICE.createClassificationReportBuilder().buildDetailedReport();
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(user = "monitor")
@Test
void testGetTotalNumbersOfTasksOfDetailedClassificationReport() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
DetailedClassificationReport report =
monitorService.createClassificationReportBuilder().buildDetailedReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report));
}
MONITOR_SERVICE.createClassificationReportBuilder().buildDetailedReport();
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(5);
@ -100,21 +94,15 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetDetailedClassificationReportWithReportLineItemDefinitions() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
DetailedClassificationReport report =
monitorService
MONITOR_SERVICE
.createClassificationReportBuilder()
.inWorkingDays()
.withColumnHeaders(columnHeaders)
.buildDetailedReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(5);
@ -129,24 +117,34 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
assertThat(report.getSumRow().getTotalValue()).isEqualTo(50);
}
@WithAccessId(user = "monitor")
@TestFactory
Stream<DynamicTest> should_NotThrowError_When_buildReportForTaskState() {
Iterator<TaskTimestamp> iterator = Arrays.stream(TaskTimestamp.values()).iterator();
ThrowingConsumer<TaskTimestamp> test =
timestamp -> {
ThrowingCallable callable =
() ->
MONITOR_SERVICE
.createClassificationReportBuilder()
.buildDetailedReport(timestamp);
assertThatCode(callable).doesNotThrowAnyException();
};
return DynamicTest.stream(iterator, t -> "for TaskState " + t, test);
}
@WithAccessId(user = "monitor")
@Test
void testEachItemOfDetailedClassificationReport() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
DetailedClassificationReport report =
monitorService
MONITOR_SERVICE
.createClassificationReportBuilder()
.inWorkingDays()
.withColumnHeaders(columnHeaders)
.buildDetailedReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(5);
@ -195,25 +193,77 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfDetailedClassificationReportWithWorkbasketFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
void should_computeNumbersAccordingToPlannedDate_When_BuildReportForPlanned() throws Exception {
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
DetailedClassificationReport report =
MONITOR_SERVICE
.createClassificationReportBuilder()
.inWorkingDays()
.withColumnHeaders(columnHeaders)
.buildDetailedReport(TaskTimestamp.PLANNED);
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(5);
FoldableRow<DetailedMonitorQueryItem> line1 = report.getRow("L10000");
assertThat(line1.getCells()).isEqualTo(new int[] {0, 2, 8, 0, 0});
Row<DetailedMonitorQueryItem> detailedLine1 = line1.getFoldableRow("L11000");
assertThat(detailedLine1.getCells()).isEqualTo(new int[] {0, 1, 2, 0, 0});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment1 = line1.getFoldableRow("N/A");
assertThat(detailedLineNoAttachment1.getCells()).isEqualTo(new int[] {0, 1, 6, 0, 0});
FoldableRow<DetailedMonitorQueryItem> line2 = report.getRow("L20000");
assertThat(line2.getCells()).isEqualTo(new int[] {0, 1, 9, 0, 0});
Row<DetailedMonitorQueryItem> detailedLine2 = line2.getFoldableRow("L22000");
assertThat(detailedLine2.getCells()).isEqualTo(new int[] {0, 0, 4, 0, 0});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment2 = line2.getFoldableRow("N/A");
assertThat(detailedLineNoAttachment2.getCells()).isEqualTo(new int[] {0, 1, 5, 0, 0});
FoldableRow<DetailedMonitorQueryItem> line3 = report.getRow("L30000");
assertThat(line3.getCells()).isEqualTo(new int[] {0, 0, 7, 0, 0});
Row<DetailedMonitorQueryItem> detailedLine3a = line3.getFoldableRow("L33000");
assertThat(detailedLine3a.getCells()).isEqualTo(new int[] {0, 0, 3, 0, 0});
Row<DetailedMonitorQueryItem> detailedLine3b = line3.getFoldableRow("L99000");
assertThat(detailedLine3b.getCells()).isEqualTo(new int[] {0, 0, 1, 0, 0});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment3 = line3.getFoldableRow("N/A");
assertThat(detailedLineNoAttachment3.getCells()).isEqualTo(new int[] {0, 0, 3, 0, 0});
FoldableRow<DetailedMonitorQueryItem> line4 = report.getRow("L40000");
assertThat(line4.getCells()).isEqualTo(new int[] {0, 0, 10, 0, 0});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment4 = line4.getFoldableRow("N/A");
assertThat(detailedLineNoAttachment4.getCells()).isEqualTo(new int[] {0, 0, 10, 0, 0});
FoldableRow<DetailedMonitorQueryItem> line5 = report.getRow("L50000");
assertThat(line5.getCells()).isEqualTo(new int[] {0, 0, 13, 0, 0});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment5 = line5.getFoldableRow("N/A");
assertThat(detailedLineNoAttachment5.getCells()).isEqualTo(new int[] {0, 0, 13, 0, 0});
}
@WithAccessId(user = "monitor")
@Test
void testEachItemOfDetailedClassificationReportWithWorkbasketFilter() throws Exception {
List<String> workbasketIds =
Collections.singletonList("WBI:000000000000000000000000000000000001");
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
DetailedClassificationReport report =
monitorService
MONITOR_SERVICE
.createClassificationReportBuilder()
.workbasketIdIn(workbasketIds)
.inWorkingDays()
.withColumnHeaders(columnHeaders)
.buildDetailedReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(5);
@ -260,23 +310,17 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfDetailedClassificationReportWithStateFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TaskState> states = Collections.singletonList(TaskState.READY);
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
DetailedClassificationReport report =
monitorService
MONITOR_SERVICE
.createClassificationReportBuilder()
.stateIn(states)
.inWorkingDays()
.withColumnHeaders(columnHeaders)
.buildDetailedReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(5);
@ -323,20 +367,14 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfDetailedClassificationReportNotInWorkingDays() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
DetailedClassificationReport report =
monitorService
MONITOR_SERVICE
.createClassificationReportBuilder()
.withColumnHeaders(columnHeaders)
.buildDetailedReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(5);
@ -386,23 +424,17 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfDetailedClassificationReportWithCategoryFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<String> categories = Arrays.asList("AUTOMATIC", "MANUAL");
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
DetailedClassificationReport report =
monitorService
MONITOR_SERVICE
.createClassificationReportBuilder()
.categoryIn(categories)
.classificationCategoryIn(categories)
.inWorkingDays()
.withColumnHeaders(columnHeaders)
.buildDetailedReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(2);
@ -428,23 +460,17 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfDetailedClassificationReportWithDomainFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<String> domains = Collections.singletonList("DOMAIN_A");
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
DetailedClassificationReport report =
monitorService
MONITOR_SERVICE
.createClassificationReportBuilder()
.inWorkingDays()
.withColumnHeaders(columnHeaders)
.domainIn(domains)
.buildDetailedReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(5);
@ -491,24 +517,18 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfDetailedClassificationReportWithCustomFieldValueFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
Map<CustomField, String> customAttributeFilter = new HashMap<>();
customAttributeFilter.put(CustomField.CUSTOM_1, "Geschaeftsstelle A");
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
DetailedClassificationReport report =
monitorService
MONITOR_SERVICE
.createClassificationReportBuilder()
.customAttributeFilterIn(customAttributeFilter)
.inWorkingDays()
.withColumnHeaders(columnHeaders)
.buildDetailedReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(5);
@ -575,86 +595,4 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
columnHeaders.add(new TimeIntervalColumnHeader(6, Integer.MAX_VALUE));
return columnHeaders;
}
private String reportToString(DetailedClassificationReport report) {
return reportToString(report, null);
}
private String reportToString(
DetailedClassificationReport report, List<TimeIntervalColumnHeader> columnHeaders) {
String formatColumWidth = "| %-7s ";
String formatFirstColumn = "| %-36s %-4s ";
final String formatFirstColumnFirstLine = "| %-29s %12s ";
final String formatFirstColumnDetailLines = "| + %-34s %-4s ";
final String formatFirstColumnSumLine = "| %-36s %-5s";
int reportWidth = columnHeaders == null ? 46 : columnHeaders.size() * 10 + 46;
StringBuilder builder = new StringBuilder();
builder.append("\n");
for (int i = 0; i < reportWidth; i++) {
builder.append("-");
}
builder.append("\n");
builder.append(
String.format(formatFirstColumnFirstLine, "Classifications + Attachments", "Total"));
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) {
builder.append(String.format(formatColumWidth, "> " + def.getLowerAgeLimit()));
} else if (def.getLowerAgeLimit() == def.getUpperAgeLimit()) {
if (def.getLowerAgeLimit() == 0) {
builder.append(String.format(formatColumWidth, "today"));
} else {
builder.append(String.format(formatColumWidth, def.getLowerAgeLimit()));
}
} else {
builder.append(
String.format(
formatColumWidth, def.getLowerAgeLimit() + ".." + def.getUpperAgeLimit()));
}
}
}
builder.append("|\n");
for (int i = 0; i < reportWidth; i++) {
builder.append("-");
}
builder.append("\n");
for (String rl : report.rowTitles()) {
builder.append(String.format(formatFirstColumn, rl, report.getRow(rl).getTotalValue()));
if (columnHeaders != null) {
for (int cell : report.getRow(rl).getCells()) {
builder.append(String.format(formatColumWidth, cell));
}
}
builder.append("|\n");
for (String detaileLine : report.getRow(rl).getFoldableRowKeySet()) {
Row<DetailedMonitorQueryItem> reportLine = report.getRow(rl).getFoldableRow(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++) {
builder.append("-");
}
builder.append("\n");
}
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++) {
builder.append("-");
}
builder.append("\n");
return builder.toString();
}
}

65
lib/taskana-core/src/test/java/acceptance/report/ProvideTaskStatusReportAccTest.java
View File

@ -7,20 +7,16 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestTemplate;
import org.junit.jupiter.api.extension.ExtendWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
import pro.taskana.monitor.api.MonitorService;
import pro.taskana.monitor.api.reports.TaskStatusReport;
import pro.taskana.monitor.api.reports.header.TaskStatusColumnHeader;
import pro.taskana.monitor.api.reports.item.TaskQueryItem;
import pro.taskana.monitor.api.reports.row.Row;
import pro.taskana.task.api.TaskService;
@ -30,9 +26,6 @@ import pro.taskana.task.api.TaskState;
@ExtendWith(JaasExtension.class)
class ProvideTaskStatusReportAccTest extends AbstractReportAccTest {
private static final Logger LOGGER =
LoggerFactory.getLogger(ProvideWorkbasketReportAccTest.class);
MonitorService monitorService = taskanaEngine.getMonitorService();
@BeforeEach
@ -69,9 +62,6 @@ class ProvideTaskStatusReportAccTest extends AbstractReportAccTest {
void testCompleteTaskStatusReport() throws Exception {
TaskStatusReport report = monitorService.createTaskStatusReportBuilder().buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
@ -101,9 +91,6 @@ class ProvideTaskStatusReportAccTest extends AbstractReportAccTest {
.domainIn(asList("DOMAIN_C", "DOMAIN_A"))
.buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(2);
@ -129,9 +116,6 @@ class ProvideTaskStatusReportAccTest extends AbstractReportAccTest {
.stateIn(Collections.singletonList(TaskState.READY))
.buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
@ -177,53 +161,4 @@ class ProvideTaskStatusReportAccTest extends AbstractReportAccTest {
assertThat(summaryNumbers[3]).isEqualTo(2); // number of cancelled tasks
assertThat(summaryNumbers[4]).isEqualTo(3); // number of terminated tasks
}
private String reportToString(TaskStatusReport report) {
List<TaskStatusColumnHeader> columnHeaders = report.getColumnHeaders();
String formatColumnWidth = "| %-7s ";
String formatFirstColumn = "| %-36s %-4s ";
final String formatFirstColumnFirstLine = "| %-29s %12s ";
final String formatFirstColumnSumLine = "| %-36s %-5s";
int reportWidth = columnHeaders.size() * 10 + 46;
StringBuilder builder = new StringBuilder();
builder.append("\n");
for (int i = 0; i < reportWidth; i++) {
builder.append("-");
}
builder.append("\n");
builder.append(String.format(formatFirstColumnFirstLine, "Domain", "Total"));
for (TaskStatusColumnHeader def : columnHeaders) {
builder.append(String.format(formatColumnWidth, def.getDisplayName()));
}
builder.append("|\n");
for (int i = 0; i < reportWidth; i++) {
builder.append("-");
}
builder.append("\n");
for (String rl : report.rowTitles()) {
builder.append(String.format(formatFirstColumn, rl, report.getRow(rl).getTotalValue()));
for (int cell : report.getRow(rl).getCells()) {
builder.append(String.format(formatColumnWidth, cell));
}
builder.append("|\n");
for (int i = 0; i < reportWidth; i++) {
builder.append("-");
}
builder.append("\n");
}
builder.append(
String.format(formatFirstColumnSumLine, "Total", report.getSumRow().getTotalValue()));
for (int cell : report.getSumRow().getCells()) {
builder.append(String.format(formatColumnWidth, cell));
}
builder.append("|\n");
for (int i = 0; i < reportWidth; i++) {
builder.append("-");
}
builder.append("\n");
return builder.toString();
}
}

6
lib/taskana-core/src/test/java/acceptance/report/ProvideTimestampReportAccTest.java
View File

@ -51,8 +51,7 @@ class ProvideTimestampReportAccTest extends AbstractReportAccTest {
assertThat(timestampReport.getRows().keySet())
.isEqualTo(new HashSet<>(Arrays.asList("CREATED", "COMPLETED")));
// * * * * * * * * * * * * * * * * * * * * * TEST THE CREATED ROW * * * * * * * * * * * * * *
// * * * * * * *
// * * * * * * * * * * * * * * * * * * TEST THE CREATED ROW * * * * * * * * * * * * * * * * * *
TimestampRow statusRow = timestampReport.getRow("CREATED");
assertThat(statusRow.getFoldableRowCount()).isEqualTo(2);
@ -123,8 +122,7 @@ class ProvideTimestampReportAccTest extends AbstractReportAccTest {
assertThat(org4Row.getCells()).isEqualTo(org3Row.getCells());
assertThat(org4Row.getTotalValue()).isEqualTo(org3Row.getTotalValue());
// * * * * * * * * * * * * * * * * * * * * * TEST THE COMPLETED ROW * * * * * * * * * * * * *
// * * * * * * * *
// * * * * * * * * * * * * * * * * * * TEST THE COMPLETED ROW * * * * * * * * * * * * * * * * *
statusRow = timestampReport.getRow("COMPLETED");
assertThat(statusRow.getFoldableRowCount()).isEqualTo(2);

222
lib/taskana-core/src/test/java/acceptance/report/ProvideWorkbasketReportAccTest.java
View File

@ -1,26 +1,31 @@
package acceptance.report;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatCode;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.stream.IntStream;
import java.util.stream.Stream;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.DynamicTest;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestFactory;
import org.junit.jupiter.api.extension.ExtendWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.junit.jupiter.api.function.ThrowingConsumer;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
import pro.taskana.monitor.api.CombinedClassificationFilter;
import pro.taskana.monitor.api.MonitorService;
import pro.taskana.monitor.api.TaskTimestamp;
import pro.taskana.monitor.api.reports.WorkbasketReport;
import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
import pro.taskana.task.api.CustomField;
@ -30,29 +35,18 @@ import pro.taskana.task.api.TaskState;
@ExtendWith(JaasExtension.class)
class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
private static final Logger LOGGER =
LoggerFactory.getLogger(ProvideWorkbasketReportAccTest.class);
private static final MonitorService MONITOR_SERVICE = taskanaEngine.getMonitorService();
@Test
void testRoleCheck() {
MonitorService monitorService = taskanaEngine.getMonitorService();
ThrowingCallable call =
() -> {
monitorService.createWorkbasketReportBuilder().buildReport();
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
assertThatThrownBy(() -> MONITOR_SERVICE.createWorkbasketReportBuilder().buildReport())
.isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(user = "monitor")
@Test
void testGetTotalNumbersOfTasksOfWorkbasketReportBasedOnDueDate() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
WorkbasketReport report = monitorService.createWorkbasketReportBuilder().buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report));
}
WorkbasketReport report = MONITOR_SERVICE.createWorkbasketReportBuilder().buildReport();
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
@ -67,21 +61,15 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetWorkbasketReportWithReportLineItemDefinitions() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
WorkbasketReport report =
monitorService
MONITOR_SERVICE
.createWorkbasketReportBuilder()
.withColumnHeaders(columnHeaders)
.inWorkingDays()
.buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
final int sumLineCount = IntStream.of(report.getSumRow().getCells()).sum();
assertThat(report).isNotNull();
@ -98,24 +86,31 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
assertThat(sumLineCount).isEqualTo(50);
}
@WithAccessId(user = "monitor")
@TestFactory
Stream<DynamicTest> should_NotThrowError_When_buildReportForTaskState() {
Iterator<TaskTimestamp> iterator = Arrays.stream(TaskTimestamp.values()).iterator();
ThrowingConsumer<TaskTimestamp> test =
timestamp -> {
ThrowingCallable callable =
() -> MONITOR_SERVICE.createWorkbasketReportBuilder().buildReport(timestamp);
assertThatCode(callable).doesNotThrowAnyException();
};
return DynamicTest.stream(iterator, t -> "for TaskState " + t, test);
}
@WithAccessId(user = "monitor")
@Test
void testEachItemOfWorkbasketReport() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
WorkbasketReport report =
monitorService
MONITOR_SERVICE
.createWorkbasketReportBuilder()
.withColumnHeaders(columnHeaders)
.inWorkingDays()
.buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
@ -131,21 +126,39 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfWorkbasketReportNotInWorkingDays() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
void should_computeNumbersAccordingToPlannedDate_When_BuildReportForPlanned() throws Exception {
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
WorkbasketReport report =
monitorService
MONITOR_SERVICE
.createWorkbasketReportBuilder()
.withColumnHeaders(columnHeaders)
.inWorkingDays()
.buildReport(TaskTimestamp.PLANNED);
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
int[] row1 = report.getRow("USER-1-1").getCells();
assertThat(row1).isEqualTo(new int[] {0, 2, 18, 0, 0});
int[] row2 = report.getRow("USER-1-2").getCells();
assertThat(row2).isEqualTo(new int[] {0, 1, 19, 0, 0});
int[] row3 = report.getRow("USER-1-3").getCells();
assertThat(row3).isEqualTo(new int[] {0, 0, 10, 0, 0});
}
@WithAccessId(user = "monitor")
@Test
void testEachItemOfWorkbasketReportNotInWorkingDays() throws Exception {
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
WorkbasketReport report =
MONITOR_SERVICE
.createWorkbasketReportBuilder()
.withColumnHeaders(columnHeaders)
.buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
@ -162,24 +175,18 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfWorkbasketReportWithWorkbasketFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<String> workbasketIds =
Collections.singletonList("WBI:000000000000000000000000000000000001");
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
WorkbasketReport report =
monitorService
MONITOR_SERVICE
.createWorkbasketReportBuilder()
.withColumnHeaders(columnHeaders)
.workbasketIdIn(workbasketIds)
.inWorkingDays()
.buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(1);
@ -190,23 +197,17 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfWorkbasketReportWithStateFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TaskState> states = Collections.singletonList(TaskState.READY);
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
WorkbasketReport report =
monitorService
MONITOR_SERVICE
.createWorkbasketReportBuilder()
.withColumnHeaders(columnHeaders)
.stateIn(states)
.inWorkingDays()
.buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
@ -223,23 +224,17 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfWorkbasketReportWithCategoryFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<String> categories = Arrays.asList("AUTOMATIC", "MANUAL");
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
WorkbasketReport report =
monitorService
MONITOR_SERVICE
.createWorkbasketReportBuilder()
.withColumnHeaders(columnHeaders)
.categoryIn(categories)
.classificationCategoryIn(categories)
.inWorkingDays()
.buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
@ -256,23 +251,17 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfWorkbasketReportWithDomainFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<String> domains = Collections.singletonList("DOMAIN_A");
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
WorkbasketReport report =
monitorService
MONITOR_SERVICE
.createWorkbasketReportBuilder()
.withColumnHeaders(columnHeaders)
.domainIn(domains)
.inWorkingDays()
.buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
@ -289,24 +278,18 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfWorkbasketReportWithCustomFieldValueFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
Map<CustomField, String> customAttributeFilter = new HashMap<>();
customAttributeFilter.put(CustomField.CUSTOM_1, "Geschaeftsstelle A");
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
WorkbasketReport report =
monitorService
MONITOR_SERVICE
.createWorkbasketReportBuilder()
.withColumnHeaders(columnHeaders)
.customAttributeFilterIn(customAttributeFilter)
.inWorkingDays()
.buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
@ -323,8 +306,6 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfWorkbasketReportForSelectedClassifications() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
List<CombinedClassificationFilter> combinedClassificationFilter = new ArrayList<>();
combinedClassificationFilter.add(
@ -343,17 +324,13 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
new CombinedClassificationFilter("CLI:000000000000000000000000000000000005"));
WorkbasketReport report =
monitorService
MONITOR_SERVICE
.createWorkbasketReportBuilder()
.withColumnHeaders(columnHeaders)
.combinedClassificationFilterIn(combinedClassificationFilter)
.inWorkingDays()
.buildReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
@ -371,18 +348,13 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
@Test
void testGetTotalNumbersOfTasksOfWorkbasketReportBasedOnPlannedDateWithReportLineItemDefinitions()
throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
WorkbasketReport report =
monitorService
MONITOR_SERVICE
.createWorkbasketReportBuilder()
.withColumnHeaders(columnHeaders)
.buildPlannedDateBasedReport();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report));
}
.buildReport(TaskTimestamp.PLANNED);
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
@ -419,76 +391,4 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
columnHeaders.add(new TimeIntervalColumnHeader(6, Integer.MAX_VALUE));
return columnHeaders;
}
private String reportToString(WorkbasketReport report) {
return reportToString(report, null);
}
private String reportToString(
WorkbasketReport report, List<TimeIntervalColumnHeader> reportLineItemDefinitions) {
String formatColumWidth = "| %-7s ";
String formatFirstColumn = "| %-36s %-4s ";
final String formatFirstColumnFirstLine = "| %-29s %12s ";
final String formatFirstColumnSumLine = "| %-36s %-5s";
int reportWidth =
reportLineItemDefinitions == null ? 46 : reportLineItemDefinitions.size() * 10 + 46;
StringBuilder builder = new StringBuilder();
builder.append("\n");
for (int i = 0; i < reportWidth; i++) {
builder.append("-");
}
builder.append("\n");
builder.append(String.format(formatFirstColumnFirstLine, "Workbaskets", "Total"));
if (reportLineItemDefinitions != null) {
for (TimeIntervalColumnHeader def : reportLineItemDefinitions) {
if (def.getLowerAgeLimit() == Integer.MIN_VALUE) {
builder.append(String.format(formatColumWidth, "< " + def.getUpperAgeLimit()));
} else if (def.getUpperAgeLimit() == Integer.MAX_VALUE) {
builder.append(String.format(formatColumWidth, "> " + def.getLowerAgeLimit()));
} else if (def.getLowerAgeLimit() == def.getUpperAgeLimit()) {
if (def.getLowerAgeLimit() == 0) {
builder.append(String.format(formatColumWidth, "today"));
} else {
builder.append(String.format(formatColumWidth, def.getLowerAgeLimit()));
}
} else {
builder.append(
String.format(
formatColumWidth, def.getLowerAgeLimit() + ".." + def.getUpperAgeLimit()));
}
}
}
builder.append("|\n");
for (int i = 0; i < reportWidth; i++) {
builder.append("-");
}
builder.append("\n");
for (String rl : report.rowTitles()) {
builder.append(String.format(formatFirstColumn, rl, report.getRow(rl).getTotalValue()));
if (reportLineItemDefinitions != null) {
for (int cell : report.getRow(rl).getCells()) {
builder.append(String.format(formatColumWidth, cell));
}
}
builder.append("|\n");
for (int i = 0; i < reportWidth; i++) {
builder.append("-");
}
builder.append("\n");
}
builder.append(
String.format(formatFirstColumnSumLine, "Total", report.getSumRow().getTotalValue()));
for (int cell : report.getSumRow().getCells()) {
builder.append(String.format(formatColumWidth, cell));
}
builder.append("|\n");
for (int i = 0; i < reportWidth; i++) {
builder.append("-");
}
builder.append("\n");
return builder.toString();
}
}

6
lib/taskana-core/src/test/java/pro/taskana/classification/internal/ClassificationQueryImplTest.java
View File

@ -32,7 +32,7 @@ class ClassificationQueryImplTest {
@Mock private SqlSession sqlSession;
@Test
void should_ReturnList_when_BuilderIsUsed() {
void should_ReturnList_When_BuilderIsUsed() {
when(internalTaskanaEngine.getSqlSession()).thenReturn(sqlSession);
when(sqlSession.selectList(any(), any())).thenReturn(new ArrayList<>());
@ -47,7 +47,7 @@ class ClassificationQueryImplTest {
}
@Test
void should_ReturnListWithOffset_when_BuilderIsUsed() {
void should_ReturnListWithOffset_When_BuilderIsUsed() {
when(internalTaskanaEngine.getSqlSession()).thenReturn(sqlSession);
when(sqlSession.selectList(any(), any(), any())).thenReturn(new ArrayList<>());
@ -62,7 +62,7 @@ class ClassificationQueryImplTest {
}
@Test
void should_ReturnOneItem_when_BuilderIsUsed() {
void should_ReturnOneItem_When_BuilderIsUsed() {
when(internalTaskanaEngine.getSqlSession()).thenReturn(sqlSession);
when(sqlSession.selectOne(any(), any())).thenReturn(new ClassificationSummaryImpl());

35
lib/taskana-core/src/test/java/pro/taskana/monitor/internal/CategoryReportBuilderImplTest.java → lib/taskana-core/src/test/java/pro/taskana/monitor/internal/ClassificationClassificationCategoryReportBuilderImplTest.java
View File

@ -25,7 +25,8 @@ import pro.taskana.TaskanaEngineConfiguration;
import pro.taskana.common.api.TaskanaEngine;
import pro.taskana.common.internal.InternalTaskanaEngine;
import pro.taskana.monitor.api.SelectedItem;
import pro.taskana.monitor.api.reports.CategoryReport;
import pro.taskana.monitor.api.TaskTimestamp;
import pro.taskana.monitor.api.reports.ClassificationCategoryReport;
import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
import pro.taskana.monitor.api.reports.item.MonitorQueryItem;
import pro.taskana.task.api.CustomField;
@ -33,7 +34,7 @@ import pro.taskana.task.api.TaskState;
/** Unit Test for CategoryBuilderImpl. */
@ExtendWith(MockitoExtension.class)
class CategoryReportBuilderImplTest {
class ClassificationClassificationCategoryReportBuilderImplTest {
@InjectMocks private MonitorServiceImpl cut;
@ -72,16 +73,17 @@ class CategoryReportBuilderImplTest {
states,
categories,
domains,
TaskTimestamp.DUE,
classificationIds,
excludedClassificationIds,
customAttributeFilter))
.thenReturn(expectedResult);
final CategoryReport actualResult =
final ClassificationCategoryReport actualResult =
cut.createCategoryReportBuilder()
.workbasketIdIn(workbasketIds)
.stateIn(states)
.categoryIn(categories)
.classificationCategoryIn(categories)
.domainIn(domains)
.classificationIdIn(classificationIds)
.excludedClassificationIdIn(excludedClassificationIds)
@ -93,7 +95,7 @@ class CategoryReportBuilderImplTest {
verify(taskanaEngineMock).checkRoleMembership(any());
verify(taskanaEngineMock).getWorkingDaysToDaysConverter();
verify(monitorMapperMock)
.getTaskCountOfCategories(any(), any(), any(), any(), any(), any(), any());
.getTaskCountOfCategories(any(), any(), any(), any(), any(), any(), any(), any());
verify(internalTaskanaEngineMock).returnConnection();
verifyNoMoreInteractions(
internalTaskanaEngineMock,
@ -102,8 +104,8 @@ class CategoryReportBuilderImplTest {
taskanaEngineConfiguration);
assertThat(actualResult).isNotNull();
assertThat(1).isEqualTo(actualResult.getRow("EXTERN").getTotalValue());
assertThat(1).isEqualTo(actualResult.getSumRow().getTotalValue());
assertThat(actualResult.getRow("EXTERN").getTotalValue()).isOne();
assertThat(actualResult.getSumRow().getTotalValue()).isOne();
}
@Test
@ -131,16 +133,17 @@ class CategoryReportBuilderImplTest {
states,
categories,
domains,
TaskTimestamp.DUE,
classificationIds,
excludedClassificationIds,
customAttributeFilter))
.thenReturn(expectedResult);
final CategoryReport actualResult =
final ClassificationCategoryReport actualResult =
cut.createCategoryReportBuilder()
.workbasketIdIn(workbasketIds)
.stateIn(states)
.categoryIn(categories)
.classificationCategoryIn(categories)
.domainIn(domains)
.classificationIdIn(classificationIds)
.excludedClassificationIdIn(excludedClassificationIds)
@ -153,7 +156,7 @@ class CategoryReportBuilderImplTest {
verify(taskanaEngineMock).checkRoleMembership(any());
verify(taskanaEngineMock).getWorkingDaysToDaysConverter();
verify(monitorMapperMock)
.getTaskCountOfCategories(any(), any(), any(), any(), any(), any(), any());
.getTaskCountOfCategories(any(), any(), any(), any(), any(), any(), any(), any());
verify(internalTaskanaEngineMock).returnConnection();
verifyNoMoreInteractions(
internalTaskanaEngineMock,
@ -162,9 +165,9 @@ class CategoryReportBuilderImplTest {
taskanaEngineConfiguration);
assertThat(actualResult).isNotNull();
assertThat(1).isEqualTo(actualResult.getRow("EXTERN").getTotalValue());
assertThat(1).isEqualTo(actualResult.getRow("EXTERN").getCells()[0]);
assertThat(1).isEqualTo(actualResult.getSumRow().getTotalValue());
assertThat(actualResult.getRow("EXTERN").getTotalValue()).isOne();
assertThat(actualResult.getRow("EXTERN").getCells()[0]).isOne();
assertThat(actualResult.getSumRow().getTotalValue()).isOne();
}
@Test
@ -206,7 +209,7 @@ class CategoryReportBuilderImplTest {
cut.createCategoryReportBuilder()
.workbasketIdIn(workbasketIds)
.stateIn(states)
.categoryIn(categories)
.classificationCategoryIn(categories)
.domainIn(domains)
.classificationIdIn(classificationIds)
.excludedClassificationIdIn(excludedClassificationIds)
@ -228,7 +231,6 @@ class CategoryReportBuilderImplTest {
monitorMapperMock,
taskanaEngineConfiguration);
assertThat(actualResult).isNotNull();
assertThat(actualResult).isEqualTo(expectedResult);
}
@ -276,7 +278,7 @@ class CategoryReportBuilderImplTest {
cut.createCategoryReportBuilder()
.workbasketIdIn(workbasketIds)
.stateIn(states)
.categoryIn(categories)
.classificationCategoryIn(categories)
.domainIn(domains)
.classificationIdIn(classificationIds)
.excludedClassificationIdIn(excludedClassificationIds)
@ -297,7 +299,6 @@ class CategoryReportBuilderImplTest {
monitorMapperMock,
taskanaEngineConfiguration);
assertThat(actualResult).isNotNull();
assertThat(actualResult).isEqualTo(expectedResult);
}

27
lib/taskana-core/src/test/java/pro/taskana/monitor/internal/ClassificationReportBuilderImplTest.java
View File

@ -25,6 +25,7 @@ import pro.taskana.TaskanaEngineConfiguration;
import pro.taskana.common.api.TaskanaEngine;
import pro.taskana.common.internal.InternalTaskanaEngine;
import pro.taskana.monitor.api.SelectedItem;
import pro.taskana.monitor.api.TaskTimestamp;
import pro.taskana.monitor.api.reports.ClassificationReport;
import pro.taskana.monitor.api.reports.ClassificationReport.DetailedClassificationReport;
import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
@ -75,6 +76,7 @@ class ClassificationReportBuilderImplTest {
states,
categories,
domains,
TaskTimestamp.DUE,
classificationIds,
excludedClassificationIds,
customAttributeFilter))
@ -84,7 +86,7 @@ class ClassificationReportBuilderImplTest {
cut.createClassificationReportBuilder()
.workbasketIdIn(workbasketIds)
.stateIn(states)
.categoryIn(categories)
.classificationCategoryIn(categories)
.domainIn(domains)
.classificationIdIn(classificationIds)
.excludedClassificationIdIn(excludedClassificationIds)
@ -97,7 +99,7 @@ class ClassificationReportBuilderImplTest {
verify(internalTaskanaEngineMock, times(2)).getEngine();
verify(monitorMapperMock)
.getTaskCountOfClassifications(any(), any(), any(), any(), any(), any(), any());
.getTaskCountOfClassifications(any(), any(), any(), any(), any(), any(), any(), any());
verify(internalTaskanaEngineMock).returnConnection();
verifyNoMoreInteractions(
internalTaskanaEngineMock,
@ -137,6 +139,7 @@ class ClassificationReportBuilderImplTest {
states,
categories,
domains,
TaskTimestamp.DUE,
classificationIds,
excludedClassificationIds,
customAttributeFilter))
@ -146,7 +149,7 @@ class ClassificationReportBuilderImplTest {
cut.createClassificationReportBuilder()
.workbasketIdIn(workbasketIds)
.stateIn(states)
.categoryIn(categories)
.classificationCategoryIn(categories)
.domainIn(domains)
.classificationIdIn(classificationIds)
.excludedClassificationIdIn(excludedClassificationIds)
@ -160,7 +163,7 @@ class ClassificationReportBuilderImplTest {
verify(internalTaskanaEngineMock, times(2)).getEngine();
verify(monitorMapperMock)
.getTaskCountOfClassifications(any(), any(), any(), any(), any(), any(), any());
.getTaskCountOfClassifications(any(), any(), any(), any(), any(), any(), any(), any());
verify(internalTaskanaEngineMock).returnConnection();
verifyNoMoreInteractions(
internalTaskanaEngineMock,
@ -199,6 +202,7 @@ class ClassificationReportBuilderImplTest {
states,
categories,
domains,
TaskTimestamp.DUE,
classificationIds,
excludedClassificationIds,
customAttributeFilter))
@ -208,7 +212,7 @@ class ClassificationReportBuilderImplTest {
cut.createClassificationReportBuilder()
.workbasketIdIn(workbasketIds)
.stateIn(states)
.categoryIn(categories)
.classificationCategoryIn(categories)
.domainIn(domains)
.classificationIdIn(classificationIds)
.excludedClassificationIdIn(excludedClassificationIds)
@ -221,7 +225,8 @@ class ClassificationReportBuilderImplTest {
verify(internalTaskanaEngineMock, times(2)).getEngine();
verify(monitorMapperMock)
.getTaskCountOfDetailedClassifications(any(), any(), any(), any(), any(), any(), any());
.getTaskCountOfDetailedClassifications(
any(), any(), any(), any(), any(), any(), any(), any());
verify(internalTaskanaEngineMock).returnConnection();
verifyNoMoreInteractions(
internalTaskanaEngineMock,
@ -264,6 +269,7 @@ class ClassificationReportBuilderImplTest {
states,
categories,
domains,
TaskTimestamp.DUE,
classificationIds,
excludedClassificationIds,
customAttributeFilter))
@ -273,7 +279,7 @@ class ClassificationReportBuilderImplTest {
cut.createClassificationReportBuilder()
.workbasketIdIn(workbasketIds)
.stateIn(states)
.categoryIn(categories)
.classificationCategoryIn(categories)
.domainIn(domains)
.classificationIdIn(classificationIds)
.excludedClassificationIdIn(excludedClassificationIds)
@ -287,7 +293,8 @@ class ClassificationReportBuilderImplTest {
verify(internalTaskanaEngineMock, times(2)).getEngine();
verify(monitorMapperMock)
.getTaskCountOfDetailedClassifications(any(), any(), any(), any(), any(), any(), any());
.getTaskCountOfDetailedClassifications(
any(), any(), any(), any(), any(), any(), any(), any());
verify(internalTaskanaEngineMock).returnConnection();
verifyNoMoreInteractions(
internalTaskanaEngineMock,
@ -347,7 +354,7 @@ class ClassificationReportBuilderImplTest {
cut.createClassificationReportBuilder()
.workbasketIdIn(workbasketIds)
.stateIn(states)
.categoryIn(categories)
.classificationCategoryIn(categories)
.domainIn(domains)
.classificationIdIn(classificationIds)
.excludedClassificationIdIn(excludedClassificationIds)
@ -421,7 +428,7 @@ class ClassificationReportBuilderImplTest {
cut.createClassificationReportBuilder()
.workbasketIdIn(workbasketIds)
.stateIn(states)
.categoryIn(categories)
.classificationCategoryIn(categories)
.domainIn(domains)
.classificationIdIn(classificationIds)
.excludedClassificationIdIn(excludedClassificationIds)

15
lib/taskana-core/src/test/java/pro/taskana/monitor/internal/CustomFieldValueReportBuilderImplTest.java
View File

@ -24,6 +24,7 @@ import pro.taskana.TaskanaEngineConfiguration;
import pro.taskana.common.api.TaskanaEngine;
import pro.taskana.common.internal.InternalTaskanaEngine;
import pro.taskana.monitor.api.SelectedItem;
import pro.taskana.monitor.api.TaskTimestamp;
import pro.taskana.monitor.api.reports.CustomFieldValueReport;
import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
import pro.taskana.monitor.api.reports.item.MonitorQueryItem;
@ -72,6 +73,7 @@ class CustomFieldValueReportBuilderImplTest {
states,
categories,
domains,
TaskTimestamp.DUE,
classificationIds,
excludedClassificationIds,
customAttributeFilter))
@ -81,7 +83,7 @@ class CustomFieldValueReportBuilderImplTest {
cut.createCustomFieldValueReportBuilder(CustomField.CUSTOM_1)
.workbasketIdIn(workbasketIds)
.stateIn(states)
.categoryIn(categories)
.classificationCategoryIn(categories)
.domainIn(domains)
.classificationIdIn(classificationIds)
.excludedClassificationIdIn(excludedClassificationIds)
@ -93,7 +95,8 @@ class CustomFieldValueReportBuilderImplTest {
verify(taskanaEngineMock).getWorkingDaysToDaysConverter();
verify(internalTaskanaEngineMock, times(2)).getEngine();
verify(monitorMapperMock)
.getTaskCountOfCustomFieldValues(any(), any(), any(), any(), any(), any(), any(), any());
.getTaskCountOfCustomFieldValues(
any(), any(), any(), any(), any(), any(), any(), any(), any());
verify(internalTaskanaEngineMock).returnConnection();
verifyNoMoreInteractions(
internalTaskanaEngineMock,
@ -132,6 +135,7 @@ class CustomFieldValueReportBuilderImplTest {
states,
categories,
domains,
TaskTimestamp.DUE,
classificationIds,
excludedClassificationIds,
customAttributeFilter))
@ -141,7 +145,7 @@ class CustomFieldValueReportBuilderImplTest {
cut.createCustomFieldValueReportBuilder(CustomField.CUSTOM_1)
.workbasketIdIn(workbasketIds)
.stateIn(states)
.categoryIn(categories)
.classificationCategoryIn(categories)
.domainIn(domains)
.classificationIdIn(classificationIds)
.excludedClassificationIdIn(excludedClassificationIds)
@ -154,7 +158,8 @@ class CustomFieldValueReportBuilderImplTest {
verify(taskanaEngineMock).getWorkingDaysToDaysConverter();
verify(internalTaskanaEngineMock, times(2)).getEngine();
verify(monitorMapperMock)
.getTaskCountOfCustomFieldValues(any(), any(), any(), any(), any(), any(), any(), any());
.getTaskCountOfCustomFieldValues(
any(), any(), any(), any(), any(), any(), any(), any(), any());
verify(internalTaskanaEngineMock).returnConnection();
verifyNoMoreInteractions(
internalTaskanaEngineMock,
@ -203,7 +208,7 @@ class CustomFieldValueReportBuilderImplTest {
cut.createCustomFieldValueReportBuilder(CustomField.CUSTOM_1)
.workbasketIdIn(workbasketIds)
.stateIn(states)
.categoryIn(categories)
.classificationCategoryIn(categories)
.domainIn(domains)
.classificationIdIn(classificationIds)
.excludedClassificationIdIn(excludedClassificationIds)

25
lib/taskana-core/src/test/java/pro/taskana/monitor/internal/WorkbasketReportBuilderImplTest.java
View File

@ -29,6 +29,7 @@ import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.internal.InternalTaskanaEngine;
import pro.taskana.monitor.api.CombinedClassificationFilter;
import pro.taskana.monitor.api.SelectedItem;
import pro.taskana.monitor.api.TaskTimestamp;
import pro.taskana.monitor.api.reports.WorkbasketReport;
import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
import pro.taskana.monitor.api.reports.item.MonitorQueryItem;
@ -79,6 +80,7 @@ class WorkbasketReportBuilderImplTest {
states,
categories,
domains,
TaskTimestamp.DUE,
classificationIds,
excludedClassificationIds,
customAttributeFilter,
@ -89,7 +91,7 @@ class WorkbasketReportBuilderImplTest {
cut.createWorkbasketReportBuilder()
.workbasketIdIn(workbasketIds)
.stateIn(states)
.categoryIn(categories)
.classificationCategoryIn(categories)
.domainIn(domains)
.classificationIdIn(classificationIds)
.excludedClassificationIdIn(excludedClassificationIds)
@ -102,7 +104,7 @@ class WorkbasketReportBuilderImplTest {
verify(taskanaEngineMock).getWorkingDaysToDaysConverter();
verify(internalTaskanaEngineMock, times(2)).getEngine();
verify(monitorMapperMock)
.getTaskCountOfWorkbaskets(any(), any(), any(), any(), any(), any(), any(), any());
.getTaskCountOfWorkbaskets(any(), any(), any(), any(), any(), any(), any(), any(), any());
verify(internalTaskanaEngineMock).returnConnection();
verifyNoMoreInteractions(internalTaskanaEngineMock, taskanaEngineMock, monitorMapperMock);
@ -142,6 +144,7 @@ class WorkbasketReportBuilderImplTest {
states,
categories,
domains,
TaskTimestamp.DUE,
classificationIds,
excludedClassificationIds,
customAttributeFilter,
@ -152,7 +155,7 @@ class WorkbasketReportBuilderImplTest {
cut.createWorkbasketReportBuilder()
.workbasketIdIn(workbasketIds)
.stateIn(states)
.categoryIn(categories)
.classificationCategoryIn(categories)
.domainIn(domains)
.classificationIdIn(classificationIds)
.excludedClassificationIdIn(excludedClassificationIds)
@ -166,7 +169,7 @@ class WorkbasketReportBuilderImplTest {
verify(taskanaEngineMock).getWorkingDaysToDaysConverter();
verify(internalTaskanaEngineMock, times(2)).getEngine();
verify(monitorMapperMock)
.getTaskCountOfWorkbaskets(any(), any(), any(), any(), any(), any(), any(), any());
.getTaskCountOfWorkbaskets(any(), any(), any(), any(), any(), any(), any(), any(), any());
verify(internalTaskanaEngineMock).returnConnection();
verifyNoMoreInteractions(internalTaskanaEngineMock, taskanaEngineMock, monitorMapperMock);
@ -217,7 +220,7 @@ class WorkbasketReportBuilderImplTest {
cut.createWorkbasketReportBuilder()
.workbasketIdIn(workbasketIds)
.stateIn(states)
.categoryIn(categories)
.classificationCategoryIn(categories)
.domainIn(domains)
.classificationIdIn(classificationIds)
.excludedClassificationIdIn(excludedClassificationIds)
@ -288,7 +291,7 @@ class WorkbasketReportBuilderImplTest {
cut.createWorkbasketReportBuilder()
.workbasketIdIn(workbasketIds)
.stateIn(states)
.categoryIn(categories)
.classificationCategoryIn(categories)
.domainIn(domains)
.classificationIdIn(classificationIds)
.excludedClassificationIdIn(excludedClassificationIds)
@ -340,11 +343,12 @@ class WorkbasketReportBuilderImplTest {
monitorQueryItem.setKey("WBI:000000000000000000000000000000000001");
monitorQueryItem.setNumberOfTasks(1);
expectedResult.add(monitorQueryItem);
when(monitorMapperMock.getTaskCountOfWorkbasketsBasedOnPlannedDate(
when(monitorMapperMock.getTaskCountOfWorkbaskets(
workbasketIds,
states,
categories,
domains,
TaskTimestamp.PLANNED,
classificationIds,
excludedClassificationIds,
customAttributeFilter,
@ -355,24 +359,25 @@ class WorkbasketReportBuilderImplTest {
cut.createWorkbasketReportBuilder()
.workbasketIdIn(workbasketIds)
.stateIn(states)
.categoryIn(categories)
.classificationCategoryIn(categories)
.domainIn(domains)
.classificationIdIn(classificationIds)
.excludedClassificationIdIn(excludedClassificationIds)
.customAttributeFilterIn(customAttributeFilter)
.combinedClassificationFilterIn(combinedClassificationFilter)
.buildPlannedDateBasedReport();
.buildReport(TaskTimestamp.PLANNED);
verify(internalTaskanaEngineMock).openConnection();
verify(taskanaEngineMock).checkRoleMembership(TaskanaRole.MONITOR, TaskanaRole.ADMIN);
verify(taskanaEngineMock).getWorkingDaysToDaysConverter();
verify(internalTaskanaEngineMock, times(2)).getEngine();
verify(monitorMapperMock)
.getTaskCountOfWorkbasketsBasedOnPlannedDate(
.getTaskCountOfWorkbaskets(
workbasketIds,
states,
categories,
domains,
TaskTimestamp.PLANNED,
classificationIds,
excludedClassificationIds,
customAttributeFilter,

6
lib/taskana-core/src/test/java/pro/taskana/task/internal/ObjectReferenceQueryImplTest.java
View File

@ -36,7 +36,7 @@ class ObjectReferenceQueryImplTest {
}
@Test
void should_ReturnList_when_BuilderIsUsed() {
void should_ReturnList_When_BuilderIsUsed() {
when(taskanaEngine.getSqlSession()).thenReturn(sqlSession);
when(sqlSession.selectList(any(), any())).thenReturn(new ArrayList<>());
@ -51,7 +51,7 @@ class ObjectReferenceQueryImplTest {
}
@Test
void should_ReturnListWithOffset_when_BuilderIsUsed() {
void should_ReturnListWithOffset_When_BuilderIsUsed() {
when(taskanaEngine.getSqlSession()).thenReturn(sqlSession);
when(sqlSession.selectList(any(), any(), any())).thenReturn(new ArrayList<>());
@ -66,7 +66,7 @@ class ObjectReferenceQueryImplTest {
}
@Test
void should_ReturnOneItem_when_BuilderIsUsed() {
void should_ReturnOneItem_When_BuilderIsUsed() {
when(taskanaEngine.getSqlSession()).thenReturn(sqlSession);
when(sqlSession.selectOne(any(), any())).thenReturn(new ObjectReference());

6
lib/taskana-core/src/test/java/pro/taskana/task/internal/TaskQueryImplTest.java
View File

@ -50,7 +50,7 @@ class TaskQueryImplTest {
}
@Test
void should_ReturnList_when_BuilderIsUsed() {
void should_ReturnList_When_BuilderIsUsed() {
when(sqlSession.selectList(any(), any())).thenReturn(new ArrayList<>());
List<TaskSummary> intermediate = new ArrayList<>();
intermediate.add(new TaskSummaryImpl());
@ -66,7 +66,7 @@ class TaskQueryImplTest {
}
@Test
void should_ReturnListWithOffset_when_BuilderIsUsed() {
void should_ReturnListWithOffset_When_BuilderIsUsed() {
when(sqlSession.selectList(any(), any(), any())).thenReturn(new ArrayList<>());
List<TaskSummary> intermediate = new ArrayList<>();
intermediate.add(new TaskSummaryImpl());
@ -82,7 +82,7 @@ class TaskQueryImplTest {
}
@Test
void should_ReturnOneItem_when_BuilderIsUsed() {
void should_ReturnOneItem_When_BuilderIsUsed() {
when(sqlSession.selectOne(any(), any())).thenReturn(new TaskSummaryImpl());
List<TaskSummary> intermediate = new ArrayList<>();
intermediate.add(new TaskSummaryImpl());

2
lib/taskana-core/src/test/java/pro/taskana/task/internal/TaskServiceImplIntAutocommitTest.java
View File

@ -140,7 +140,7 @@ class TaskServiceImplIntAutocommitTest {
}
@Test
void should_ReturnList_when_BuilderIsUsed() throws Exception {
void should_ReturnList_When_BuilderIsUsed() throws Exception {
Workbasket wb = workbasketService.newWorkbasket("key", "DOMAIN_A");
wb.setName("workbasket");
wb.setType(WorkbasketType.GROUP);

2
lib/taskana-core/src/test/java/pro/taskana/task/internal/TaskServiceImplIntExplicitTest.java
View File

@ -218,7 +218,7 @@ class TaskServiceImplIntExplicitTest {
@WithAccessId(user = "user-1-1", groups = "businessadmin")
@Test
void should_ReturnList_when_BuilderIsUsed() throws Exception {
void should_ReturnList_When_BuilderIsUsed() throws Exception {
try (Connection connection = dataSource.getConnection()) {
taskanaEngineImpl.setConnection(connection);
WorkbasketImpl workbasket =

6
lib/taskana-core/src/test/java/pro/taskana/workbasket/internal/WorkbasketAccessItemQueryImplTest.java
View File

@ -32,7 +32,7 @@ class WorkbasketAccessItemQueryImplTest {
@Mock private SqlSession sqlSession;
@Test
void should_ReturnList_when_BuilderIsUsed() {
void should_ReturnList_When_BuilderIsUsed() {
when(internalTaskanaEngine.openAndReturnConnection(any())).thenReturn(new ArrayList<>());
List<WorkbasketAccessItem> result =
@ -41,7 +41,7 @@ class WorkbasketAccessItemQueryImplTest {
}
@Test
void should_ReturnListWithOffset_when_BuilderIsUsed() {
void should_ReturnListWithOffset_When_BuilderIsUsed() {
when(internalTaskanaEngine.getSqlSession()).thenReturn(sqlSession);
when(sqlSession.selectList(any(), any(), any())).thenReturn(new ArrayList<>());
@ -51,7 +51,7 @@ class WorkbasketAccessItemQueryImplTest {
}
@Test
void should_ReturnOneItem_when_BuilderIsUsed() {
void should_ReturnOneItem_When_BuilderIsUsed() {
when(internalTaskanaEngine.getSqlSession()).thenReturn(sqlSession);
when(sqlSession.selectOne(any(), any())).thenReturn(new WorkbasketAccessItemImpl());

6
lib/taskana-core/src/test/java/pro/taskana/workbasket/internal/WorkbasketQueryImplTest.java
View File

@ -41,7 +41,7 @@ class WorkbasketQueryImplTest {
}
@Test
void should_ReturnList_when_BuilderIsUsed() {
void should_ReturnList_When_BuilderIsUsed() {
when(internalTaskanaEngine.getSqlSession()).thenReturn(sqlSession);
when(sqlSession.selectList(any(), any())).thenReturn(new ArrayList<>());
@ -54,7 +54,7 @@ class WorkbasketQueryImplTest {
}
@Test
void should_ReturnListWithOffset_when_BuilderIsUsed() {
void should_ReturnListWithOffset_When_BuilderIsUsed() {
when(internalTaskanaEngine.getSqlSession()).thenReturn(sqlSession);
when(sqlSession.selectList(any(), any(), any())).thenReturn(new ArrayList<>());
@ -67,7 +67,7 @@ class WorkbasketQueryImplTest {
}
@Test
void should_ReturnOneItem_when_BuilderIsUsed() {
void should_ReturnOneItem_When_BuilderIsUsed() {
when(internalTaskanaEngine.getSqlSession()).thenReturn(sqlSession);
when(sqlSession.selectOne(any(), any())).thenReturn(new WorkbasketSummaryImpl());

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

@ -20,6 +20,7 @@ import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.rest.Mapping;
import pro.taskana.monitor.api.MonitorService;
import pro.taskana.monitor.api.TaskTimestamp;
import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
import pro.taskana.monitor.rest.assembler.ReportRepresentationModelAssembler;
import pro.taskana.monitor.rest.models.ReportRepresentationModel;
@ -109,7 +110,7 @@ public class MonitorController {
.createWorkbasketReportBuilder()
.stateIn(states)
.withColumnHeaders(getDateTimeInterval(daysInPast))
.buildPlannedDateBasedReport(),
.buildReport(TaskTimestamp.PLANNED),
daysInPast,
states);
if (LOGGER.isDebugEnabled()) {

6
rest/taskana-rest-spring/src/test/java/pro/taskana/doc/api/TaskCommentControllerRestDocumentation.java
View File

@ -95,8 +95,7 @@ class TaskCommentControllerRestDocumentation extends BaseRestDocumentation {
.perform(
RestDocumentationRequestBuilders.get(
restHelper.toUrl(
Mapping.URL_TASK_COMMENTS,
"TKI:000000000000000000000000000000000000"))
Mapping.URL_TASK_COMMENTS, "TKI:000000000000000000000000000000000000"))
.accept(MediaTypes.HAL_JSON)
.header("Authorization", ADMIN_CREDENTIALS))
.andExpect(MockMvcResultMatchers.status().isOk())
@ -172,8 +171,7 @@ class TaskCommentControllerRestDocumentation extends BaseRestDocumentation {
.perform(
RestDocumentationRequestBuilders.post(
restHelper.toUrl(
Mapping.URL_TASK_COMMENTS,
"TKI:000000000000000000000000000000000000"))
Mapping.URL_TASK_COMMENTS, "TKI:000000000000000000000000000000000000"))
.contentType(MediaTypes.HAL_JSON)
.content(createTaskCommentContent)
.header("Authorization", ADMIN_CREDENTIALS))

2
rest/taskana-rest-spring/src/test/java/pro/taskana/doc/api/TaskControllerRestDocumentation.java
View File

@ -544,7 +544,7 @@ class TaskControllerRestDocumentation extends BaseRestDocumentation {
this.mockMvc
.perform(
RestDocumentationRequestBuilders.post(
restHelper.toUrl(Mapping.URL_TASKS_ID_SELECT_AND_CLAIM) + "?custom14=abc")
restHelper.toUrl(Mapping.URL_TASKS_ID_SELECT_AND_CLAIM) + "?custom14=abc")
.accept("application/hal+json")
.header("Authorization", ADMIN_CREDENTIALS))
.andExpect(MockMvcResultMatchers.status().isOk())