TSK-1659: Expanded TimeIntervalReportBuilder with custom-X filter
Co-authored-by: Tim Gerversmann<72377965+tge20@users.noreply.github.com>
This commit is contained in:
Mustapha Zorgati
parent
55d21a9e8b
commit
6dfb751bee
|
|
@ -12,6 +12,7 @@
|
|||
<list>
|
||||
<option value="clean" />
|
||||
<option value="test-compile" />
|
||||
<option value="-Dcheckstyle.skip" />
|
||||
</list>
|
||||
</option>
|
||||
<option name="pomFileName" />
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
-- TASK TABLE (ID , EXTERNAL_ID , CREATED , CLAIMED , COMPLETED , modified , received , planned , due , name , creator , description , note , priority, manual_priority, state , classification_category , classification_key, classification_id , workbasket_id , workbasket_key, domain , business_process_id, parent_business_process_id, owner , por_company , por_system , por_system_instance, por_type , por_value , is_read, is_transferred, callback_info, callback_state, custom_attributes ,custom1 ,custom2, ,custom3, ,custom4 ,custom5 ,custom6 ,custom7 ,custom8 ,custom9 ,custom10 ,custom11, ,custom12 ,custom13 ,custom14 ,custom15 ,custom16 , custom-int-1, custom-int-2, custom-int-3, custom-int-4, custom-int-5, custom-int-6, custom-int-7, custom-int-8
|
||||
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000000', 'ETI:000000000000000000000000000000000000', RELATIVE_DATE(-1) , RELATIVE_DATE(0) , null , RELATIVE_DATE(0) , RELATIVE_DATE(0) , RELATIVE_DATE(-1) , RELATIVE_DATE(0) , 'Task99' , 'creator_user_id' , 'Lorem ipsum was n Quatsch dolor sit amet.', 'Some custom Note' , 1 , -1 , 'CLAIMED' , 'MANUAL' , 'T2000' , 'CLI:100000000000000000000000000000000016', 'WBI:100000000000000000000000000000000006' , 'USER-1-1' , 'DOMAIN_A', 'BPI21' , 'PBPI21' , 'user-1-1' , 'MyCompany1', 'MySystem1', 'MyInstance1' , 'MyType1', 'MyValue1' , true , false , null , 'NONE' , null , 'custom1' , 'custom2' , 'custom3' , 'custom4' , 'custom5' , 'custom6' , 'custom7' , 'custom8' , 'custom9' , 'custom10' , 'custom11' , 'custom12' , 'custom13' , 'abc' , 'custom15' , 'custom16' , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
-- TASK TABLE (ID , EXTERNAL_ID , CREATED , CLAIMED , COMPLETED , modified , received , planned , due , name , creator , description , note , priority, manual_priority, state , classification_category , classification_key, classification_id , workbasket_id , workbasket_key, domain , business_process_id, parent_business_process_id, owner , por_company , por_system , por_system_instance, por_type , por_value , is_read, is_transferred, callback_info, callback_state, custom_attributes , custom1 , custom2 , custom3, , custom4 , custom5 , custom6 , custom7 ,custom8 ,custom9 ,custom10 ,custom11, ,custom12 ,custom13 ,custom14 ,custom15 ,custom16 , custom-int-1, custom-int-2, custom-int-3, custom-int-4, custom-int-5, custom-int-6, custom-int-7, custom-int-8
|
||||
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000000', 'ETI:000000000000000000000000000000000000', RELATIVE_DATE(-1) , RELATIVE_DATE(0) , null , RELATIVE_DATE(0) , RELATIVE_DATE(0) , RELATIVE_DATE(-1) , RELATIVE_DATE(0) , 'Task99' , 'creator_user_id' , 'Lorem ipsum was n Quatsch dolor sit amet.', 'Some custom Note' , 1 , -1 , 'CLAIMED' , 'MANUAL' , 'T2000' , 'CLI:100000000000000000000000000000000016', 'WBI:100000000000000000000000000000000006' , 'USER-1-1' , 'DOMAIN_A', 'BPI21' , 'PBPI21' , 'user-1-1' , 'MyCompany1', 'MySystem1', 'MyInstance1' , 'MyType1', 'MyValue1' , true , false , null , 'NONE' , null , 'custom1' , 'custom2' , 'custom3' , 'custom4' , 'custom5' , 'custom6' , 'custom7' , 'custom8' , 'custom9' , 'custom10' , 'custom11' , 'custom12' , 'custom13' , 'abc' , 'custom15' , 'custom16' , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000001', 'ETI:000000000000000000000000000000000001', RELATIVE_DATE(-2) , RELATIVE_DATE(0) , null , RELATIVE_DATE(0) , null , RELATIVE_DATE(-2) , RELATIVE_DATE(0) , 'Task01' , 'creator_user_id' , 'Lorem ipsum was n Quatsch dolor sit amet.', 'Some custom Note' , 2 , -1 , 'CLAIMED' , 'EXTERN' , 'L110102' , 'CLI:100000000000000000000000000000000005', 'WBI:100000000000000000000000000000000006' , 'USER-1-1' , 'DOMAIN_A', 'BPI21' , 'PBPI21' , 'user-1-1' , 'MyCompany1', 'MySystem1', 'MyInstance1' , 'MyType1', 'MyValue1' , true , false , null , 'NONE' , null , 'pqr' , null , null , null , null , null , null , null , null , null , null , null , null , 'abc' , null , null , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000002', 'ETI:000000000000000000000000000000000002', RELATIVE_DATE(-2) , RELATIVE_DATE(0) , null , RELATIVE_DATE(0) , RELATIVE_DATE(0) , RELATIVE_DATE(-2) , RELATIVE_DATE(0) , 'Task02' , 'creator_user_id' , 'Lorem ipsum was n Quatsch t. Aber stimmt.', 'Some custom Note' , 2 , -1 , 'CLAIMED' , 'MANUAL' , 'T2000' , 'CLI:100000000000000000000000000000000016', 'WBI:100000000000000000000000000000000006' , 'USER-1-1' , 'DOMAIN_A', 'BPI21' , 'PBPI21' , 'user-1-1' , 'MyCompany1', 'MySystem1', 'MyInstance1' , 'MyType1', 'MyValue1' , true , false , null , 'NONE' , null , null , null , null , null , null , null , null , null , null , null , null , null , null , 'abc' , null , null , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000003', 'ETI:000000000000000000000000000000000003', RELATIVE_DATE(-2) , null , null , RELATIVE_DATE(0) , RELATIVE_DATE(0) , RELATIVE_DATE(-2) , RELATIVE_DATE(0) , 'Widerruf' , 'creator_user_id' , 'Widerruf' , null , 2 , -1 , 'READY' , 'EXTERN' , 'L1050' , 'CLI:100000000000000000000000000000000003', 'WBI:100000000000000000000000000000000001' , 'GPK_KSC' , 'DOMAIN_A', 'PI_0000000000003' , 'DOC_0000000000000000003' , null , '00' , 'PASystem' , '00' , 'VNR' , '11223344' , false , false , null , 'NONE' , null , 'efg' , null , null , null , null , null , null , null , null , null , null , null , null , 'abc' , null , null , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
|
|
@ -48,11 +48,11 @@ INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000039', 'ETI:0000000
|
|||
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000040', 'ETI:000000000000000000000000000000000040', RELATIVE_DATE(-3) , RELATIVE_DATE(-2) , RELATIVE_DATE(-2) , RELATIVE_DATE(-2) , null , RELATIVE_DATE(-3) , RELATIVE_DATE(0) , 'Widerruf' , 'creator_user_id' , 'Widerruf' , null , 2 , -1 , 'COMPLETED' , 'EXTERN' , 'L1050' , 'CLI:100000000000000000000000000000000003', 'WBI:100000000000000000000000000000000007' , 'USER-1-2' , 'DOMAIN_A', 'PI_0000000000040' , 'DOC_0000000000000000040' , 'user-1-2' , '00' , 'PASystem' , '00' , 'SDNR' , '00011122' , true , false , null , 'NONE' , null , null , null , null , null , null , null , null , null , null , null , null , null , null , 'abc' , null , null , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
-- Tasks for QueryTasksWithSortingTest
|
||||
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000041', 'ETI:000000000000000000000000000000000041', RELATIVE_DATE(0) , RELATIVE_DATE(0) , null , RELATIVE_DATE(0) , null , RELATIVE_DATE(0) , RELATIVE_DATE(0) , 'Task99' , 'creator_user_id' , 'Lorem ipsum was n Quatsch dolor sit amet.', 'Some custom Note' , 1 , -1 , 'CLAIMED' , 'AUTOMATIC' , 'T6310' , 'CLI:000000000000000000000000000000000011', 'WBI:100000000000000000000000000000000011' , 'USER-B-2' , 'DOMAIN_B', 'BPI21' , 'PBPI21' , 'user-b-1' , 'MyCompany1', 'MySystem1', 'MyInstance1' , 'MyType1', 'MyValue1' , true , false , null , 'NONE' , null , null , null , null , null , null , null , null , null , null , null , null , null , null , 'abc' , null , null , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000042', 'ETI:000000000000000000000000000000000042', RELATIVE_DATE(0) , RELATIVE_DATE(0) , null , RELATIVE_DATE(0) , null , RELATIVE_DATE(0) , RELATIVE_DATE(0) , 'Task01' , 'creator_user_id' , 'Lorem ipsum was n Quatsch dolor sit amet.', 'Some custom Note' , 2 , -1 , 'CLAIMED' , 'EXTERN' , 'L110102' , 'CLI:100000000000000000000000000000000005', 'WBI:100000000000000000000000000000000015' , 'USER-B-2' , 'DOMAIN_B', 'BPI21' , 'PBPI21' , 'user-b-1' , 'MyCompany1', 'MySystem1', 'MyInstance1' , 'MyType1', 'MyValue1' , true , false , null , 'NONE' , null , null , null , null , null , null , null , null , null , null , null , null , null , null , 'abc' , null , null , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000043', 'ETI:000000000000000000000000000000000043', RELATIVE_DATE(0) , RELATIVE_DATE(0) , null , RELATIVE_DATE(0) , null , RELATIVE_DATE(0) , RELATIVE_DATE(0) , 'Task02' , 'creator_user_id' , 'Lorem ipsum was n Quatsch t. Aber stimmt.', 'Some custom Note' , 2 , -1 , 'CLAIMED' , 'EXTERN' , 'A12' , 'CLI:200000000000000000000000000000000001', 'WBI:100000000000000000000000000000000015' , 'USER-B-2' , 'DOMAIN_B', 'BPI21' , 'PBPI21' , 'user-b-1' , 'MyCompany1', 'MySystem1', 'MyInstance1' , 'MyType1', 'MyValue1' , true , false , null , 'NONE' , null , null , null , null , null , null , null , null , null , null , null , null , null , null , 'abc' , null , null , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000044', 'ETI:000000000000000000000000000000000044', RELATIVE_DATE(0) , null , null , RELATIVE_DATE(0) , null , RELATIVE_DATE(0) , RELATIVE_DATE(0) , 'Widerruf' , 'creator_user_id' , 'Widerruf' , null , 2 , -1 , 'READY' , 'EXTERN' , 'L1060' , 'CLI:200000000000000000000000000000000017', 'WBI:100000000000000000000000000000000015' , 'USER-B-2' , 'DOMAIN_B', 'PI_0000000000003' , 'DOC_0000000000000000003' , null , '00' , 'PASystem' , '00' , 'VNR' , '11223344' , false , false , null , 'NONE' , null , null , null , null , null , null , null , null , null , null , null , null , null , null , 'abc' , null , null , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000045', 'ETI:000000000000000000000000000000000045', RELATIVE_DATE(-1) , null , null , RELATIVE_DATE(0) , null , RELATIVE_DATE(-1) , RELATIVE_DATE(0) , 'Widerruf' , 'creator_user_id' , 'Widerruf' , null , 2 , -1 , 'READY' , 'EXTERN' , 'L1060' , 'CLI:200000000000000000000000000000000017', 'WBI:100000000000000000000000000000000015' , 'USER-B-2' , 'DOMAIN_B', 'PI_0000000000004' , 'DOC_0000000000000000004' , null , '00' , 'PASystem' , '00' , 'VNR' , '11223344' , false , false , null , 'NONE' , null , null , null , null , null , null , null , null , null , null , null , null , null , null , 'abc' , null , null , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000046', 'ETI:000000000000000000000000000000000046', RELATIVE_DATE(-1) , null , null , RELATIVE_DATE(0) , null , RELATIVE_DATE(-1) , RELATIVE_DATE(0) , 'Widerruf' , 'creator_user_id' , 'Widerruf' , null , 2 , -1 , 'READY' , 'EXTERN' , 'L1060' , 'CLI:200000000000000000000000000000000017', 'WBI:100000000000000000000000000000000015' , 'USER-B-2' , 'DOMAIN_B', 'PI_0000000000004' , 'DOC_0000000000000000003' , null , '00' , 'PASystem' , '06' , 'VNR' , '11223344' , false , false , null , 'NONE' , null , null , null , null , null , null , null , null , null , null , null , null , null , null , 'abc' , null , null , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000042', 'ETI:000000000000000000000000000000000042', RELATIVE_DATE(0) , RELATIVE_DATE(0) , null , RELATIVE_DATE(0) , null , RELATIVE_DATE(0) , RELATIVE_DATE(0) , 'Task01' , 'creator_user_id' , 'Lorem ipsum was n Quatsch dolor sit amet.', 'Some custom Note' , 2 , -1 , 'CLAIMED' , 'EXTERN' , 'L110102' , 'CLI:100000000000000000000000000000000005', 'WBI:100000000000000000000000000000000015' , 'USER-B-2' , 'DOMAIN_B', 'BPI21' , 'PBPI21' , 'user-b-1' , 'MyCompany1', 'MySystem1', 'MyInstance1' , 'MyType1', 'MyValue1' , true , false , null , 'NONE' , null , null , null , 'abcd' , 'defg' , 'important', null , null , null , null , null , null , null , null , 'abc' , null , null , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000043', 'ETI:000000000000000000000000000000000043', RELATIVE_DATE(0) , RELATIVE_DATE(0) , null , RELATIVE_DATE(0) , null , RELATIVE_DATE(0) , RELATIVE_DATE(0) , 'Task02' , 'creator_user_id' , 'Lorem ipsum was n Quatsch t. Aber stimmt.', 'Some custom Note' , 2 , -1 , 'CLAIMED' , 'EXTERN' , 'A12' , 'CLI:200000000000000000000000000000000001', 'WBI:100000000000000000000000000000000015' , 'USER-B-2' , 'DOMAIN_B', 'BPI21' , 'PBPI21' , 'user-b-1' , 'MyCompany1', 'MySystem1', 'MyInstance1' , 'MyType1', 'MyValue1' , true , false , null , 'NONE' , null , null , null , 'abbb' , null , 'important', null , null , null , null , null , null , null , null , 'abc' , null , null , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000044', 'ETI:000000000000000000000000000000000044', RELATIVE_DATE(0) , null , null , RELATIVE_DATE(0) , null , RELATIVE_DATE(0) , RELATIVE_DATE(0) , 'Widerruf' , 'creator_user_id' , 'Widerruf' , null , 2 , -1 , 'READY' , 'EXTERN' , 'L1060' , 'CLI:200000000000000000000000000000000017', 'WBI:100000000000000000000000000000000015' , 'USER-B-2' , 'DOMAIN_B', 'PI_0000000000003' , 'DOC_0000000000000000003' , null , '00' , 'PASystem' , '00' , 'VNR' , '11223344' , false , false , null , 'NONE' , null , null , null , 'abcd' , 'defg' , null , null , null , null , null , null , null , null , null , 'abc' , null , null , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000045', 'ETI:000000000000000000000000000000000045', RELATIVE_DATE(-1) , null , null , RELATIVE_DATE(0) , null , RELATIVE_DATE(-1) , RELATIVE_DATE(0) , 'Widerruf' , 'creator_user_id' , 'Widerruf' , null , 2 , -1 , 'READY' , 'EXTERN' , 'L1060' , 'CLI:200000000000000000000000000000000017', 'WBI:100000000000000000000000000000000015' , 'USER-B-2' , 'DOMAIN_B', 'PI_0000000000004' , 'DOC_0000000000000000004' , null , '00' , 'PASystem' , '00' , 'VNR' , '11223344' , false , false , null , 'NONE' , null , null , null , 'abbd' , 'defg' , 'important', null , null , null , null , null , null , null , null , 'abc' , null , null , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000046', 'ETI:000000000000000000000000000000000046', RELATIVE_DATE(-1) , null , null , RELATIVE_DATE(0) , null , RELATIVE_DATE(-1) , RELATIVE_DATE(0) , 'Widerruf' , 'creator_user_id' , 'Widerruf' , null , 2 , -1 , 'READY' , 'EXTERN' , 'L1060' , 'CLI:200000000000000000000000000000000017', 'WBI:100000000000000000000000000000000015' , 'USER-B-2' , 'DOMAIN_B', 'PI_0000000000004' , 'DOC_0000000000000000003' , null , '00' , 'PASystem' , '06' , 'VNR' , '11223344' , false , false , null , 'NONE' , null , null , null , 'abcd' , 'defg' , null , null , null , null , null , null , null , null , null , 'abc' , null , null , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000047', 'ETI:000000000000000000000000000000000047', RELATIVE_DATE(-1) , null , null , RELATIVE_DATE(0) , null , RELATIVE_DATE(-1) , RELATIVE_DATE(0) , 'Widerruf' , 'creator_user_id' , 'Widerruf' , null , 2 , -1 , 'READY' , 'EXTERN' , 'L1060' , 'CLI:200000000000000000000000000000000017', 'WBI:100000000000000000000000000000000015' , 'USER-B-2' , 'DOMAIN_B', 'PI_0000000000004' , 'DOC_0000000000000000003' , null , '00' , 'PASystem' , '00' , 'VNR' , '11223344' , false , false , null , 'NONE' , null , null , null , null , null , null , null , null , null , null , null , null , null , null , 'abc' , null , null , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000048', 'ETI:000000000000000000000000000000000048', RELATIVE_DATE(-1) , null , null , RELATIVE_DATE(0) , null , RELATIVE_DATE(-1) , RELATIVE_DATE(1) , 'Widerruf' , 'creator_user_id' , 'Widerruf' , null , 2 , -1 , 'READY' , 'EXTERN' , 'L1060' , 'CLI:200000000000000000000000000000000017', 'WBI:100000000000000000000000000000000015' , 'USER-B-2' , 'DOMAIN_B', 'PI_0000000000004' , 'DOC_0000000000000000007' , null , '00' , 'PASystem' , '05' , 'VNR' , '11223344' , false , false , null , 'NONE' , null , null , null , null , null , null , null , null , null , null , null , null , null , null , 'abc' , null , null , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000049', 'ETI:000000000000000000000000000000000049', RELATIVE_DATE(-1) , null , null , RELATIVE_DATE(0) , null , RELATIVE_DATE(-1) , RELATIVE_DATE(1) , 'Widerruf' , 'creator_user_id2' , 'Widerruf' , null , 2 , -1 , 'READY' , 'EXTERN' , 'L1060' , 'CLI:200000000000000000000000000000000017', 'WBI:100000000000000000000000000000000015' , 'USER-B-2' , 'DOMAIN_B', 'PI_0000000000008' , 'DOC_0000000000000000003' , null , '00' , 'PASyste1' , '00' , 'VNR' , '22334455' , false , false , null , 'NONE' , null , null , null , null , null , null , null , null , null , null , null , null , null , null , 'abc' , null , null , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
|
|
|
|||
|
|
@ -13,6 +13,6 @@ public class LogSanitizer {
|
|||
* @return sanitized logging message
|
||||
*/
|
||||
public static String stripLineBreakingChars(Object loggingMessage) {
|
||||
return loggingMessage.toString().replaceAll("[\n|\r|\t]", "_");
|
||||
return loggingMessage.toString().replaceAll("[\n\r\t]", "_");
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,6 +1,10 @@
|
|||
package pro.taskana.common.internal.util;
|
||||
|
||||
public class SqlProviderUtil {
|
||||
public static final String OPENING_SCRIPT_TAG = "<script>";
|
||||
public static final String CLOSING_SCRIPT_TAG = "</script>";
|
||||
public static final String OPENING_WHERE_TAG = "<where>";
|
||||
public static final String CLOSING_WHERE_TAG = "</where>";
|
||||
|
||||
private SqlProviderUtil() {}
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,70 @@
|
|||
package pro.taskana.common.internal.util;
|
||||
|
||||
import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
public class LogSanitizerTest {
|
||||
|
||||
@Test
|
||||
void should_NotModifyInput_When_NothingHasToBeStripped() {
|
||||
String input = "this is a regular text with some weird characters: | !\"§$%&(/)=?*'Ä#ä+";
|
||||
|
||||
String output = LogSanitizer.stripLineBreakingChars(input);
|
||||
|
||||
assertThat(output).isEqualTo(input);
|
||||
}
|
||||
|
||||
@Test
|
||||
void should_CallToStringMethod_When_ObjectIsPassed() {
|
||||
class TestObject {
|
||||
@Override
|
||||
public String toString() {
|
||||
return "test string";
|
||||
}
|
||||
}
|
||||
|
||||
Object input = new TestObject();
|
||||
|
||||
String output = LogSanitizer.stripLineBreakingChars(input);
|
||||
|
||||
assertThat(output).isEqualTo(input.toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
void should_ReplaceMultipleLineBreaksWithUnderscore_When_InputContainsLineBreaks() {
|
||||
String input = "This\nis\na\nstring\nwith\na\nlot\nof\nlinebreaks\n";
|
||||
|
||||
String output = LogSanitizer.stripLineBreakingChars(input);
|
||||
|
||||
assertThat(output).isEqualTo("This_is_a_string_with_a_lot_of_linebreaks_");
|
||||
}
|
||||
|
||||
@Test
|
||||
void should_ReplaceMultipleTabsWithUnderscore_When_InputContainsTabs() {
|
||||
String input = "This\tis\ta\tstring\twith\ta\tlot\tof\ttabs\t";
|
||||
|
||||
String output = LogSanitizer.stripLineBreakingChars(input);
|
||||
|
||||
assertThat(output).isEqualTo("This_is_a_string_with_a_lot_of_tabs_");
|
||||
}
|
||||
|
||||
@Test
|
||||
void should_ReplaceMultipleWindowsLineBreaksWithUnderscore_When_InputContainsWindowsLineBreaks() {
|
||||
String input = "This\r\nis\r\na\r\nstring\r\nwith\r\na\r\nlot\r\nof\r\nwindows\r\nlinebreaks";
|
||||
|
||||
String output = LogSanitizer.stripLineBreakingChars(input);
|
||||
|
||||
assertThat(output).isEqualTo("This__is__a__string__with__a__lot__of__windows__linebreaks");
|
||||
}
|
||||
|
||||
@Test
|
||||
void should_ReplaceAllLinebreaksAndTabsWithUnderscore_When_InputContainsDifferentCharacters() {
|
||||
String input = "This\tis\r\na\nstring\twith\r\ntaps,\nlinebreaks\tand\r\nwindows\tlinebreaks";
|
||||
|
||||
String output = LogSanitizer.stripLineBreakingChars(input);
|
||||
|
||||
assertThat(output)
|
||||
.isEqualTo("This_is__a_string_with__taps,_linebreaks_and__windows_linebreaks");
|
||||
}
|
||||
}
|
||||
|
|
@ -76,10 +76,10 @@ public class TaskHistoryEventController {
|
|||
QueryPagingParameter.class);
|
||||
|
||||
TaskHistoryQuery query = simpleHistoryService.createTaskHistoryQuery();
|
||||
filterParameter.applyToQuery(query);
|
||||
sortParameter.applyToQuery(query);
|
||||
filterParameter.apply(query);
|
||||
sortParameter.apply(query);
|
||||
|
||||
List<TaskHistoryEvent> historyEvents = pagingParameter.applyToQuery(query);
|
||||
List<TaskHistoryEvent> historyEvents = pagingParameter.apply(query);
|
||||
|
||||
TaskHistoryEventPagedRepresentationModel pagedResources =
|
||||
assembler.toPagedModel(historyEvents, pagingParameter.getPageMetadata());
|
||||
|
|
|
|||
|
|
@ -362,7 +362,7 @@ public class TaskHistoryQueryFilterParameter implements QueryParameter<TaskHisto
|
|||
}
|
||||
|
||||
@Override
|
||||
public Void applyToQuery(TaskHistoryQuery query) {
|
||||
public Void apply(TaskHistoryQuery query) {
|
||||
ofNullable(eventType).ifPresent(query::eventTypeIn);
|
||||
ofNullable(eventTypeLike)
|
||||
.map(this::wrapElementsInLikeStatement)
|
||||
|
|
|
|||
|
|
@ -2,19 +2,24 @@ package pro.taskana.monitor.api.reports;
|
|||
|
||||
import java.util.List;
|
||||
|
||||
import pro.taskana.classification.api.models.Classification;
|
||||
import pro.taskana.common.api.TimeInterval;
|
||||
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.ColumnHeader;
|
||||
import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
|
||||
import pro.taskana.monitor.api.reports.item.MonitorQueryItem;
|
||||
import pro.taskana.monitor.api.reports.row.Row;
|
||||
import pro.taskana.task.api.models.Task;
|
||||
|
||||
/**
|
||||
* A CategoryReport contains the total numbers of tasks of the respective category as well as the
|
||||
* total number of all tasks. The tasks of the report can be filtered by workbaskets, states,
|
||||
* categories, domains, classifications and values of a custom field. Classifications can also be
|
||||
* excluded from the report. If the {@link TimeIntervalColumnHeader}s are set, the report contains
|
||||
* 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.
|
||||
* A ClassificationCategoryReport aggregates {@linkplain Task} related data.
|
||||
*
|
||||
* <p>Each {@linkplain Row} represents a {@linkplain Classification} {@linkplain
|
||||
* Classification#getCategory() category}.
|
||||
*
|
||||
* <p>Each {@linkplain ColumnHeader} represents a {@linkplain TimeInterval}
|
||||
*/
|
||||
public class ClassificationCategoryReport
|
||||
extends Report<MonitorQueryItem, TimeIntervalColumnHeader> {
|
||||
|
|
|
|||
|
|
@ -2,19 +2,27 @@ package pro.taskana.monitor.api.reports;
|
|||
|
||||
import java.util.List;
|
||||
|
||||
import pro.taskana.classification.api.models.Classification;
|
||||
import pro.taskana.common.api.TimeInterval;
|
||||
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.ColumnHeader;
|
||||
import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
|
||||
import pro.taskana.monitor.api.reports.item.DetailedMonitorQueryItem;
|
||||
import pro.taskana.monitor.api.reports.item.MonitorQueryItem;
|
||||
import pro.taskana.monitor.api.reports.row.DetailedClassificationRow;
|
||||
import pro.taskana.monitor.api.reports.row.FoldableRow;
|
||||
import pro.taskana.monitor.api.reports.row.Row;
|
||||
import pro.taskana.task.api.models.Attachment;
|
||||
import pro.taskana.task.api.models.Task;
|
||||
|
||||
/**
|
||||
* The ClassificationReport extends the Report. The {@link Row}s of the ClassificationReport are
|
||||
* grouped by classifications.
|
||||
* A ClassificationReport aggregates {@linkplain Task} related data.
|
||||
*
|
||||
* <p>Each {@linkplain Row} represents a {@linkplain Classification}.
|
||||
*
|
||||
* <p>Each {@linkplain ColumnHeader} represents a {@linkplain TimeInterval}.
|
||||
*/
|
||||
public class ClassificationReport extends Report<MonitorQueryItem, TimeIntervalColumnHeader> {
|
||||
|
||||
|
|
@ -51,9 +59,12 @@ public class ClassificationReport extends Report<MonitorQueryItem, TimeIntervalC
|
|||
}
|
||||
|
||||
/**
|
||||
* The DetailedClassificationReport is a functional extension of the {@link ClassificationReport}.
|
||||
* Its {@link FoldableRow}s contain an additional list of {@link Row}s for the classifications of
|
||||
* the attachments of the tasks.
|
||||
* A DetailedClassificationReport aggregates {@linkplain Task} related data.
|
||||
*
|
||||
* <p>Each {@linkplain FoldableRow} represents a {@linkplain Classification} and can be expanded
|
||||
* to show the {@linkplain Classification} of {@linkplain Attachment}s.
|
||||
*
|
||||
* <p>Each {@linkplain ColumnHeader} represents a {@linkplain TimeInterval}.
|
||||
*/
|
||||
public static class DetailedClassificationReport
|
||||
extends Report<DetailedMonitorQueryItem, TimeIntervalColumnHeader> {
|
||||
|
|
|
|||
|
|
@ -2,19 +2,23 @@ package pro.taskana.monitor.api.reports;
|
|||
|
||||
import java.util.List;
|
||||
|
||||
import pro.taskana.common.api.TimeInterval;
|
||||
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.ColumnHeader;
|
||||
import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
|
||||
import pro.taskana.monitor.api.reports.item.MonitorQueryItem;
|
||||
import pro.taskana.monitor.api.reports.row.Row;
|
||||
import pro.taskana.task.api.TaskCustomField;
|
||||
import pro.taskana.task.api.models.Task;
|
||||
|
||||
/**
|
||||
* A CustomFieldValueReport contains the total numbers of tasks of the respective custom field as
|
||||
* well as the total number of all tasks. The tasks of the report can be filtered by workbaskets,
|
||||
* states, categories, domains, classifications and values of a custom field. Classifications can
|
||||
* also be excluded from the report. If the {@link TimeIntervalColumnHeader}s are set, the report
|
||||
* contains 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.
|
||||
* A TaskCustomFieldValueReport aggregates {@linkplain Task} related data.
|
||||
*
|
||||
* <p>Each {@linkplain Row} represents a value of the requested {@linkplain TaskCustomField}.
|
||||
*
|
||||
* <p>Each {@linkplain ColumnHeader} represents a {@linkplain TimeInterval}.
|
||||
*/
|
||||
public class TaskCustomFieldValueReport extends Report<MonitorQueryItem, TimeIntervalColumnHeader> {
|
||||
|
||||
|
|
|
|||
|
|
@ -5,14 +5,20 @@ import java.util.stream.Collectors;
|
|||
import java.util.stream.Stream;
|
||||
|
||||
import pro.taskana.common.api.exceptions.NotAuthorizedException;
|
||||
import pro.taskana.monitor.api.reports.header.ColumnHeader;
|
||||
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.TaskState;
|
||||
import pro.taskana.task.api.models.Task;
|
||||
import pro.taskana.workbasket.api.models.Workbasket;
|
||||
|
||||
/**
|
||||
* A TaskStatusReport contains the total number of tasks, clustered in their task status.
|
||||
* Furthermore the report contains a sum line that contains the total numbers of the different
|
||||
* clusters and the total number of all tasks.
|
||||
* A TaskStatusReport aggregates {@linkplain Task} related data.
|
||||
*
|
||||
* <p>Each {@linkplain Row} represents a {@linkplain Workbasket}.
|
||||
*
|
||||
* <p>Each {@linkplain ColumnHeader} represents a {@linkplain TaskState}.
|
||||
*/
|
||||
public class TaskStatusReport extends Report<TaskQueryItem, TaskStatusColumnHeader> {
|
||||
|
||||
|
|
|
|||
|
|
@ -1,7 +1,6 @@
|
|||
package pro.taskana.monitor.api.reports;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
import pro.taskana.common.api.exceptions.InvalidArgumentException;
|
||||
import pro.taskana.common.api.exceptions.NotAuthorizedException;
|
||||
|
|
@ -11,6 +10,7 @@ import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
|
|||
import pro.taskana.monitor.api.reports.item.AgeQueryItem;
|
||||
import pro.taskana.task.api.TaskCustomField;
|
||||
import pro.taskana.task.api.TaskState;
|
||||
import pro.taskana.task.api.models.Task;
|
||||
|
||||
/**
|
||||
* "Super" Interface for all TimeIntervalReportBuilders.
|
||||
|
|
@ -26,7 +26,7 @@ public interface TimeIntervalReportBuilder<
|
|||
extends Report.Builder<I, H> {
|
||||
|
||||
/**
|
||||
* Adds a list {@link TimeIntervalColumnHeader}s to the builder to subdivide the report into
|
||||
* Adds a list {@linkplain TimeIntervalColumnHeader}s to the builder to subdivide the report into
|
||||
* clusters.
|
||||
*
|
||||
* @param columnHeaders the column headers the report should consist of.
|
||||
|
|
@ -96,13 +96,54 @@ public interface TimeIntervalReportBuilder<
|
|||
B domainIn(List<String> domains);
|
||||
|
||||
/**
|
||||
* Adds a map of custom attributes and custom attribute values to the builder. The created report
|
||||
* contains only tasks with a custom attribute value in this list.
|
||||
* Adds the values of a certain {@linkplain TaskCustomField} for exact matching to the builder.
|
||||
*
|
||||
* @param customAttributeFilter a map of custom attributes and custom attribute value
|
||||
* @return the TimeIntervalReportBuilder
|
||||
* <p>The created report contains only tasks with a {@linkplain
|
||||
* Task#getCustomAttribute(TaskCustomField) custom attribute} value exactly matching one of the
|
||||
* items in the list.
|
||||
*
|
||||
* @param customField the specified {@linkplain TaskCustomField}
|
||||
* @param strings the values the specified {@linkplain Task#getCustomAttribute(TaskCustomField)
|
||||
* custom attribute} should match
|
||||
* @return the modified {@linkplain TimeIntervalReportBuilder}
|
||||
* @throws InvalidArgumentException if filter values are not given
|
||||
*/
|
||||
B customAttributeFilterIn(Map<TaskCustomField, String> customAttributeFilter);
|
||||
B customAttributeIn(TaskCustomField customField, String... strings)
|
||||
throws InvalidArgumentException;
|
||||
|
||||
/**
|
||||
* Excludes the values of a certain {@linkplain TaskCustomField} to the builder.
|
||||
*
|
||||
* <p>The created report contains only tasks with a {@linkplain
|
||||
* Task#getCustomAttribute(TaskCustomField) custom attribute} value not matching one of the
|
||||
* items in the list.
|
||||
*
|
||||
* @param customField the specified {@linkplain TaskCustomField}
|
||||
* @param strings the values the specified {@linkplain Task#getCustomAttribute(TaskCustomField)
|
||||
* custom attribute} should not match
|
||||
* @return the modified {@linkplain TimeIntervalReportBuilder}
|
||||
* @throws InvalidArgumentException if filter values are not given
|
||||
*/
|
||||
B customAttributeNotIn(TaskCustomField customField, String... strings)
|
||||
throws InvalidArgumentException;
|
||||
|
||||
/**
|
||||
* Adds the values of a certain {@linkplain TaskCustomField} for pattern matching to the builder.
|
||||
*
|
||||
* <p>The created report contains only tasks with a {@linkplain
|
||||
* Task#getCustomAttribute(TaskCustomField) custom attribute} value pattern-matching one of the
|
||||
* items in the list. They will be compared in SQL with the LIKE operator. You may use a wildcard
|
||||
* like % to specify the pattern. If you specify multiple arguments they are combined with the OR
|
||||
* keyword.
|
||||
*
|
||||
* @param customField the specified {@linkplain TaskCustomField}
|
||||
* @param strings the values the specified {@linkplain Task#getCustomAttribute(TaskCustomField)
|
||||
* custom attribute} should match
|
||||
* @return the modified {@linkplain TimeIntervalReportBuilder}
|
||||
* @throws InvalidArgumentException if filter values are not given
|
||||
*/
|
||||
B customAttributeLike(TaskCustomField customField, String... strings)
|
||||
throws InvalidArgumentException;
|
||||
|
||||
/**
|
||||
* Returns a list of all taskIds of the report that are in the list of selected items.
|
||||
|
|
|
|||
|
|
@ -2,14 +2,26 @@ package pro.taskana.monitor.api.reports;
|
|||
|
||||
import java.util.List;
|
||||
|
||||
import pro.taskana.common.api.TimeInterval;
|
||||
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.ColumnHeader;
|
||||
import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
|
||||
import pro.taskana.monitor.api.reports.item.TimestampQueryItem;
|
||||
import pro.taskana.monitor.api.reports.row.FoldableRow;
|
||||
import pro.taskana.monitor.api.reports.row.TimestampRow;
|
||||
import pro.taskana.task.api.models.Task;
|
||||
import pro.taskana.workbasket.api.models.Workbasket;
|
||||
|
||||
/** A {@link TimestampReport} displays created and competed tasks for a specific dates. */
|
||||
/**
|
||||
* A TimestampReport aggregates {@linkplain Task} related data.
|
||||
*
|
||||
* <p>Each {@linkplain FoldableRow} represents a {@linkplain TaskTimestamp} and can be expanded to
|
||||
* display the four organization levels of the corresponding {@linkplain Workbasket}.
|
||||
*
|
||||
* <p>Each {@linkplain ColumnHeader} represents a {@linkplain TimeInterval}.
|
||||
*/
|
||||
public class TimestampReport extends Report<TimestampQueryItem, TimeIntervalColumnHeader> {
|
||||
|
||||
public TimestampReport(List<TimeIntervalColumnHeader> dates) {
|
||||
|
|
@ -35,6 +47,6 @@ public class TimestampReport extends Report<TimestampQueryItem, TimeIntervalColu
|
|||
@Override
|
||||
TimestampReport buildReport() throws NotAuthorizedException, InvalidArgumentException;
|
||||
|
||||
Builder withTimestamps(List<TaskTimestamp> statuses);
|
||||
Builder withTimestamps(List<TaskTimestamp> taskTimestamps);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2,21 +2,24 @@ package pro.taskana.monitor.api.reports;
|
|||
|
||||
import java.util.List;
|
||||
|
||||
import pro.taskana.common.api.TimeInterval;
|
||||
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.ColumnHeader;
|
||||
import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
|
||||
import pro.taskana.monitor.api.reports.item.MonitorQueryItem;
|
||||
import pro.taskana.monitor.api.reports.row.Row;
|
||||
import pro.taskana.task.api.models.Task;
|
||||
import pro.taskana.workbasket.api.models.Workbasket;
|
||||
|
||||
/**
|
||||
* A WorkbasketReport contains the total numbers of tasks of the respective workbasket as well as
|
||||
* the total number of all tasks. The tasks of the report can be filtered by workbaskets, states,
|
||||
* categories, domains, classifications and values of a custom field. Classifications can also be
|
||||
* excluded from the report. It is also possible to filter by the classifications of the attachments
|
||||
* by using the {@link CombinedClassificationFilter}. If the {@link TimeIntervalColumnHeader}s are
|
||||
* set, the report contains 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.
|
||||
* A WorkbasketReport aggregates {@linkplain Task} related data.
|
||||
*
|
||||
* <p>Each {@linkplain Row} represents a {@linkplain Workbasket}.
|
||||
*
|
||||
* <p>Each {@linkplain ColumnHeader} represents a {@linkplain TimeInterval}.
|
||||
*/
|
||||
public class WorkbasketReport extends Report<MonitorQueryItem, TimeIntervalColumnHeader> {
|
||||
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@ import pro.taskana.task.api.TaskState;
|
|||
/** The TaskStatusColumnHeader represents a column for each {@link TaskState}. */
|
||||
public class TaskStatusColumnHeader implements ColumnHeader<TaskQueryItem> {
|
||||
|
||||
private TaskState state;
|
||||
private final TaskState state;
|
||||
|
||||
public TaskStatusColumnHeader(TaskState state) {
|
||||
this.state = state;
|
||||
|
|
|
|||
|
|
@ -2,14 +2,14 @@ package pro.taskana.monitor.internal;
|
|||
|
||||
import java.time.Instant;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import org.apache.ibatis.annotations.Param;
|
||||
import org.apache.ibatis.annotations.Result;
|
||||
import org.apache.ibatis.annotations.Select;
|
||||
import org.apache.ibatis.annotations.SelectProvider;
|
||||
|
||||
import pro.taskana.monitor.api.CombinedClassificationFilter;
|
||||
import pro.taskana.monitor.api.SelectedItem;
|
||||
import pro.taskana.monitor.api.TaskTimestamp;
|
||||
import pro.taskana.monitor.api.reports.TimeIntervalReportBuilder;
|
||||
import pro.taskana.monitor.api.reports.item.DetailedMonitorQueryItem;
|
||||
import pro.taskana.monitor.api.reports.item.MonitorQueryItem;
|
||||
import pro.taskana.monitor.api.reports.item.TaskQueryItem;
|
||||
|
|
@ -21,327 +21,58 @@ import pro.taskana.task.api.TaskState;
|
|||
@SuppressWarnings({"checkstyle:LineLength", "checkstyle:Indentation"})
|
||||
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.${timestamp}) - DAYS(CAST(#{now} as TIMESTAMP))) as AGE_IN_DAYS </if> "
|
||||
+ "<if test=\"_databaseId == 'h2'\">SELECT T.WORKBASKET_KEY, DATEDIFF('DAY', #{now}, T.${timestamp}) as AGE_IN_DAYS </if> "
|
||||
+ "<if test=\"_databaseId == 'postgres'\">SELECT T.WORKBASKET_KEY, DATE_PART('DAY', T.${timestamp} - #{now}) 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=\"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>) "
|
||||
+ "</if>"
|
||||
+ "<if test='classificationIds != null'>"
|
||||
+ "AND T.CLASSIFICATION_ID IN (<foreach collection='classificationIds' item='classificationId' separator=','>#{classificationId}</foreach>) "
|
||||
+ "</if>"
|
||||
+ "<if test='excludedClassificationIds != null'>"
|
||||
+ "AND T.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 '>(T.${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.${timestamp} IS NOT NULL "
|
||||
+ "</where>"
|
||||
+ ") AS B "
|
||||
+ "GROUP BY B.WORKBASKET_KEY, B.AGE_IN_DAYS"
|
||||
+ "</script>")
|
||||
@SelectProvider(type = MonitorMapperSqlProvider.class, method = "getTaskCountOfWorkbaskets")
|
||||
@Result(column = "WORKBASKET_KEY", property = "key")
|
||||
@Result(column = "AGE_IN_DAYS", property = "ageInDays")
|
||||
@Result(column = "NUMBER_OF_TASKS", property = "numberOfTasks")
|
||||
List<MonitorQueryItem> getTaskCountOfWorkbaskets(
|
||||
@Param("now") Instant now,
|
||||
@Param("workbasketIds") List<String> workbasketIds,
|
||||
@Param("states") List<TaskState> states,
|
||||
@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<TaskCustomField, String> customAttributeFilter,
|
||||
@Param("combinedClassificationFilter")
|
||||
List<CombinedClassificationFilter> combinedClassificationFilter);
|
||||
@Param("report") TimeIntervalReportBuilder<?, ?, ?> report);
|
||||
|
||||
@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(${timestamp}) - DAYS(CAST(#{now} as TIMESTAMP))) as AGE_IN_DAYS </if> "
|
||||
+ "<if test=\"_databaseId == 'h2'\">SELECT CLASSIFICATION_CATEGORY, DATEDIFF('DAY', #{now}, ${timestamp}) as AGE_IN_DAYS </if> "
|
||||
+ "<if test=\"_databaseId == 'postgres'\">SELECT CLASSIFICATION_CATEGORY, DATE_PART('DAY', ${timestamp} - #{now}) as AGE_IN_DAYS </if> "
|
||||
+ "FROM TASK "
|
||||
+ "<where>"
|
||||
+ "<if test=\"workbasketIds != null\">"
|
||||
+ "WORKBASKET_ID IN (<foreach collection='workbasketIds' item='workbasketId' separator=','>#{workbasketId}</foreach>) "
|
||||
+ "</if>"
|
||||
+ "<if test=\"states != null\">"
|
||||
+ "AND STATE IN (<foreach collection='states' item='state' separator=','>#{state}</foreach>) "
|
||||
+ "</if>"
|
||||
+ "<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>) "
|
||||
+ "</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>"
|
||||
+ "AND ${timestamp} IS NOT NULL "
|
||||
+ "</where>"
|
||||
+ ") AS B "
|
||||
+ "GROUP BY B.CLASSIFICATION_CATEGORY, B.AGE_IN_DAYS "
|
||||
+ "</script>")
|
||||
@SelectProvider(type = MonitorMapperSqlProvider.class, method = "getTaskCountOfCategories")
|
||||
@Result(column = "CLASSIFICATION_CATEGORY", property = "key")
|
||||
@Result(column = "AGE_IN_DAYS", property = "ageInDays")
|
||||
@Result(column = "NUMBER_OF_TASKS", property = "numberOfTasks")
|
||||
List<MonitorQueryItem> getTaskCountOfCategories(
|
||||
@Param("now") Instant now,
|
||||
@Param("workbasketIds") List<String> workbasketIds,
|
||||
@Param("states") List<TaskState> states,
|
||||
@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<TaskCustomField, String> customAttributeFilter);
|
||||
@Param("report") TimeIntervalReportBuilder<?, ?, ?> report);
|
||||
|
||||
@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(${timestamp}) - DAYS(CAST(#{now} as TIMESTAMP))) as AGE_IN_DAYS </if> "
|
||||
+ "<if test=\"_databaseId == 'h2'\">SELECT CLASSIFICATION_KEY, DATEDIFF('DAY', #{now}, ${timestamp}) as AGE_IN_DAYS </if> "
|
||||
+ "<if test=\"_databaseId == 'postgres'\">SELECT CLASSIFICATION_KEY, DATE_PART('DAY', ${timestamp} - #{now}) as AGE_IN_DAYS </if> "
|
||||
+ "FROM TASK "
|
||||
+ "<where>"
|
||||
+ "<if test=\"workbasketIds != null\">"
|
||||
+ "WORKBASKET_ID IN (<foreach collection='workbasketIds' item='workbasketId' separator=','>#{workbasketId}</foreach>) "
|
||||
+ "</if>"
|
||||
+ "<if test=\"states != null\">"
|
||||
+ "AND STATE IN (<foreach collection='states' item='state' separator=','>#{state}</foreach>) "
|
||||
+ "</if>"
|
||||
+ "<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>) "
|
||||
+ "</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>"
|
||||
+ "AND ${timestamp} IS NOT NULL "
|
||||
+ "</where>"
|
||||
+ ") AS B "
|
||||
+ "GROUP BY B.CLASSIFICATION_KEY, B.AGE_IN_DAYS "
|
||||
+ "</script>")
|
||||
@SelectProvider(type = MonitorMapperSqlProvider.class, method = "getTaskCountOfClassifications")
|
||||
@Result(column = "CLASSIFICATION_KEY", property = "key")
|
||||
@Result(column = "AGE_IN_DAYS", property = "ageInDays")
|
||||
@Result(column = "NUMBER_OF_TASKS", property = "numberOfTasks")
|
||||
List<MonitorQueryItem> getTaskCountOfClassifications(
|
||||
@Param("now") Instant now,
|
||||
@Param("workbasketIds") List<String> workbasketIds,
|
||||
@Param("states") List<TaskState> states,
|
||||
@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<TaskCustomField, String> customAttributeFilter);
|
||||
@Param("report") TimeIntervalReportBuilder<?, ?, ?> report);
|
||||
|
||||
@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(T.${timestamp}) - DAYS(CAST(#{now} as 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', #{now}, 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} - #{now}) 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 STATE IN (<foreach collection='states' item='state' separator=','>#{state}</foreach>) "
|
||||
+ "</if>"
|
||||
+ "<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>) "
|
||||
+ "</if>"
|
||||
+ "<if test='classificationIds != null'>"
|
||||
+ "AND T.CLASSIFICATION_ID IN (<foreach collection='classificationIds' item='classificationId' separator=','>#{classificationId}</foreach>) "
|
||||
+ "</if>"
|
||||
+ "<if test='excludedClassificationIds != null'>"
|
||||
+ "AND T.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 '>(T.${key} = '${customAttributeFilter.get(key)}')</foreach>) "
|
||||
+ "</if>"
|
||||
+ "AND T.${timestamp} IS NOT NULL "
|
||||
+ "</where>"
|
||||
+ ") AS B "
|
||||
+ "GROUP BY B.TASK_CLASSIFICATION_KEY, B.ATTACHMENT_CLASSIFICATION_KEY, B.AGE_IN_DAYS "
|
||||
+ "</script>")
|
||||
@SelectProvider(type = MonitorMapperSqlProvider.class, method = "getTaskCountOfDetailedClassifications")
|
||||
@Result(column = "TASK_CLASSIFICATION_KEY", property = "key")
|
||||
@Result(column = "ATTACHMENT_CLASSIFICATION_KEY", property = "attachmentKey")
|
||||
@Result(column = "AGE_IN_DAYS", property = "ageInDays")
|
||||
@Result(column = "NUMBER_OF_TASKS", property = "numberOfTasks")
|
||||
List<DetailedMonitorQueryItem> getTaskCountOfDetailedClassifications(
|
||||
@Param("now") Instant now,
|
||||
@Param("workbasketIds") List<String> workbasketIds,
|
||||
@Param("states") List<TaskState> states,
|
||||
@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<TaskCustomField, String> customAttributeFilter);
|
||||
@Param("report") TimeIntervalReportBuilder<?, ?, ?> report);
|
||||
|
||||
@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(${timestamp}) - DAYS(CAST(#{now} as TIMESTAMP))) as AGE_IN_DAYS </if> "
|
||||
+ "<if test=\"_databaseId == 'h2'\">SELECT ${customField} as CUSTOM_FIELD, DATEDIFF('DAY', #{now}, ${timestamp}) as AGE_IN_DAYS </if> "
|
||||
+ "<if test=\"_databaseId == 'postgres'\">SELECT ${customField} as CUSTOM_FIELD, DATE_PART('DAY', ${timestamp} - #{now}) as AGE_IN_DAYS </if> "
|
||||
+ "FROM TASK "
|
||||
+ "<where>"
|
||||
+ "<if test=\"workbasketIds != null\">"
|
||||
+ "WORKBASKET_ID IN (<foreach collection='workbasketIds' item='workbasketId' separator=','>#{workbasketId}</foreach>) "
|
||||
+ "</if>"
|
||||
+ "<if test=\"states != null\">"
|
||||
+ "AND STATE IN (<foreach collection='states' item='state' separator=','>#{state}</foreach>) "
|
||||
+ "</if>"
|
||||
+ "<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>) "
|
||||
+ "</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>"
|
||||
+ "AND ${timestamp} IS NOT NULL "
|
||||
+ "</where>"
|
||||
+ ") AS B "
|
||||
+ "GROUP BY B.CUSTOM_FIELD, B.AGE_IN_DAYS "
|
||||
+ "</script>")
|
||||
@SelectProvider(type = MonitorMapperSqlProvider.class, method = "getTaskCountOfTaskCustomFieldValues")
|
||||
@Result(column = "CUSTOM_FIELD", property = "key")
|
||||
@Result(column = "AGE_IN_DAYS", property = "ageInDays")
|
||||
@Result(column = "NUMBER_OF_TASKS", property = "numberOfTasks")
|
||||
List<MonitorQueryItem> getTaskCountOfTaskCustomFieldValues(
|
||||
@Param("now") Instant now,
|
||||
@Param("customField") TaskCustomField taskCustomField,
|
||||
@Param("workbasketIds") List<String> workbasketIds,
|
||||
@Param("states") List<TaskState> states,
|
||||
@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<TaskCustomField, String> customAttributeFilter);
|
||||
@Param("report") TimeIntervalReportBuilder<?, ?, ?> report);
|
||||
|
||||
@Select(
|
||||
"<script>"
|
||||
+ "SELECT T.ID FROM TASK T "
|
||||
+ "<if test=\"joinWithAttachments\">"
|
||||
+ "LEFT JOIN ATTACHMENT A ON T.ID = A.TASK_ID "
|
||||
+ "</if>"
|
||||
+ "<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=\"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>) "
|
||||
+ "</if>"
|
||||
+ "<if test='classificationIds != null'>"
|
||||
+ "AND T.CLASSIFICATION_ID IN (<foreach collection='classificationIds' item='classificationId' separator=','>#{classificationId}</foreach>) "
|
||||
+ "</if>"
|
||||
+ "<if test='excludedClassificationIds != null'>"
|
||||
+ "AND T.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.${timestamp} IS NOT NULL AND ( "
|
||||
+ "<foreach collection='selectedItems' item='selectedItem' separator=' OR '>"
|
||||
+ "#{selectedItem.key} = T.${groupedBy} AND "
|
||||
+ "<if test=\"joinWithAttachments and combinedClassificationFilter == null\">"
|
||||
+ "<if test='selectedItem.subKey != null'>"
|
||||
+ "A.CLASSIFICATION_KEY = #{selectedItem.subKey} AND "
|
||||
+ "</if>"
|
||||
+ "</if>"
|
||||
+ "<if test=\"_databaseId == 'db2'\">"
|
||||
+ "#{selectedItem.upperAgeLimit} >= (DAYS(${timestamp}) - DAYS(CAST(#{now} as TIMESTAMP))) AND "
|
||||
+ "#{selectedItem.lowerAgeLimit} <= (DAYS(${timestamp}) - DAYS(CAST(#{now} as TIMESTAMP))) "
|
||||
+ "</if> "
|
||||
+ "<if test=\"_databaseId == 'h2'\">"
|
||||
+ "#{selectedItem.upperAgeLimit} >= DATEDIFF('DAY', #{now}, ${timestamp}) AND "
|
||||
+ "#{selectedItem.lowerAgeLimit} <= DATEDIFF('DAY', #{now}, ${timestamp}) "
|
||||
+ "</if> "
|
||||
+ "<if test=\"_databaseId == 'postgres'\">"
|
||||
+ "#{selectedItem.upperAgeLimit} >= DATE_PART('day', ${timestamp} - #{now} ) AND "
|
||||
+ "#{selectedItem.lowerAgeLimit} <= DATE_PART('day', ${timestamp} - #{now} ) "
|
||||
+ "</if> "
|
||||
+ "</foreach>) "
|
||||
+ "</where>"
|
||||
+ "<if test=\"_databaseId == 'db2'\">with UR </if> "
|
||||
+ "</script>")
|
||||
@SelectProvider(
|
||||
type = MonitorMapperSqlProvider.class,
|
||||
method = "getTaskIdsForSelectedItems")
|
||||
List<String> getTaskIdsForSelectedItems(
|
||||
@Param("now") Instant now,
|
||||
@Param("workbasketIds") List<String> workbasketIds,
|
||||
@Param("states") List<TaskState> states,
|
||||
@Param("classificationCategories") List<String> classificationCategories,
|
||||
@Param("domains") List<String> domains,
|
||||
@Param("classificationIds") List<String> classificationIds,
|
||||
@Param("excludedClassificationIds") List<String> excludedClassificationIds,
|
||||
@Param("customAttributeFilter") Map<TaskCustomField, String> customAttributeFilter,
|
||||
@Param("report") TimeIntervalReportBuilder<?, ?, ?> report,
|
||||
@Param("combinedClassificationFilter")
|
||||
List<CombinedClassificationFilter> combinedClassificationFilter,
|
||||
@Param("groupedBy") String groupedBy,
|
||||
|
|
@ -349,26 +80,7 @@ public interface MonitorMapper {
|
|||
@Param("selectedItems") List<SelectedItem> selectedItems,
|
||||
@Param("joinWithAttachments") boolean joinWithAttachments);
|
||||
|
||||
@Select(
|
||||
"<script>"
|
||||
+ "SELECT WORKBASKET_KEY, STATE, COUNT(STATE) as COUNT "
|
||||
+ "FROM TASK "
|
||||
+ "<where>"
|
||||
+ "<if test='domains != null'>"
|
||||
+ "DOMAIN IN (<foreach collection='domains' item='domain' separator=','>#{domain}</foreach>) "
|
||||
+ "</if>"
|
||||
+ "<if test='states != null'>"
|
||||
+ "AND STATE IN (<foreach collection='states' item='state' separator=','>#{state}</foreach>) "
|
||||
+ "</if>"
|
||||
+ "<if test='workbasketIds != null'>"
|
||||
+ "AND WORKBASKET_ID IN (<foreach collection='workbasketIds' item='workbasketId' separator=','>#{workbasketId}</foreach>) "
|
||||
+ "</if>"
|
||||
+ "<if test='priorityMinimum != null'>"
|
||||
+ "AND priority >= #{priorityMinimum} "
|
||||
+ "</if>"
|
||||
+ "</where>"
|
||||
+ "GROUP BY WORKBASKET_KEY, STATE"
|
||||
+ "</script>")
|
||||
@SelectProvider(type = MonitorMapperSqlProvider.class, method = "getTasksCountByState")
|
||||
@Result(column = "WORKBASKET_KEY", property = "workbasketKey")
|
||||
@Result(column = "STATE", property = "state")
|
||||
@Result(column = "COUNT", property = "count")
|
||||
|
|
@ -378,96 +90,18 @@ public interface MonitorMapper {
|
|||
@Param("workbasketIds") List<String> workbasketIds,
|
||||
@Param("priorityMinimum") Integer priorityMinimum);
|
||||
|
||||
@Select(
|
||||
"<script>"
|
||||
+ "SELECT DISTINCT ${customField} "
|
||||
+ "FROM TASK T"
|
||||
+ "<if test=\"combinedClassificationFilter != null\">"
|
||||
+ "LEFT JOIN ATTACHMENT A ON T.ID = A.TASK_ID "
|
||||
+ "</if>"
|
||||
+ "<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='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>) "
|
||||
+ "</if>"
|
||||
+ "<if test='classificationIds != null'>"
|
||||
+ "AND T.CLASSIFICATION_ID IN (<foreach collection='classificationIds' item='classificationId' separator=','>#{classificationId}</foreach>) "
|
||||
+ "</if>"
|
||||
+ "<if test='excludedClassificationIds != null'>"
|
||||
+ "AND T.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 '>(T.${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>"
|
||||
+ "</where>"
|
||||
+ "</script>")
|
||||
@SelectProvider(
|
||||
type = MonitorMapperSqlProvider.class,
|
||||
method = "getCustomAttributeValuesForReport")
|
||||
List<String> getCustomAttributeValuesForReport(
|
||||
@Param("workbasketIds") List<String> workbasketIds,
|
||||
@Param("states") List<TaskState> states,
|
||||
@Param("classificationCategories") List<String> classificationCategories,
|
||||
@Param("domains") List<String> domains,
|
||||
@Param("classificationIds") List<String> classificationIds,
|
||||
@Param("excludedClassificationIds") List<String> excludedClassificationIds,
|
||||
@Param("customAttributeFilter") Map<TaskCustomField, String> customAttributeFilter,
|
||||
@Param("report") TimeIntervalReportBuilder<?, ?, ?> report,
|
||||
@Param("combinedClassificationFilter")
|
||||
List<CombinedClassificationFilter> combinedClassificationFilter,
|
||||
@Param("customField") TaskCustomField taskCustomField);
|
||||
|
||||
@Select(
|
||||
"<script>"
|
||||
+ "SELECT A.AGE_IN_DAYS, A.ORG_LEVEL_1, A.ORG_LEVEL_2, A.ORG_LEVEL_3, A.ORG_LEVEL_4, "
|
||||
+ "'${status}' AS STATUS, COUNT(A.AGE_IN_DAYS) AS COUNT FROM ("
|
||||
// This subquery prevents the repetition of the AGE_IN_DAYS column calculation
|
||||
// (like everywhere else in the Mappers...)in the group by clause.
|
||||
// DB2 is not able to reuse computed columns in the group by statement. Even if this adds
|
||||
// a little
|
||||
// overhead / complexity. It's worth the trade-off of not computing the AGE_IN_DAYS column
|
||||
// twice.
|
||||
+ "SELECT W.ORG_LEVEL_1, W.ORG_LEVEL_2, W.ORG_LEVEL_3, W.ORG_LEVEL_4, "
|
||||
+ "<if test=\"_databaseId == 'db2'\">(DAYS(T.${status}) - DAYS(CAST(#{now} as TIMESTAMP)))</if>"
|
||||
+ "<if test=\"_databaseId == 'h2'\">DATEDIFF('DAY', #{now}, T.${status})</if>"
|
||||
+ "<if test=\"_databaseId == 'postgres'\">DATE_PART('DAY', T.${status} - #{now})</if>"
|
||||
+ " as AGE_IN_DAYS "
|
||||
+ "FROM TASK AS T INNER JOIN WORKBASKET AS W ON T.WORKBASKET_KEY=W.KEY "
|
||||
+ "<where>"
|
||||
+ "<if test=\"status.name() == 'COMPLETED'\">"
|
||||
+ "T.COMPLETED IS NOT NULL "
|
||||
+ "</if>"
|
||||
+ "<if test='classificationCategories != null'>"
|
||||
+ "AND T.CLASSIFICATION_CATEGORY IN (<foreach collection='classificationCategories' item='category' separator=','>#{category}</foreach>) "
|
||||
+ "</if>"
|
||||
+ "<if test='classificationIds != null'>"
|
||||
+ "AND T.CLASSIFICATION_ID IN (<foreach collection='classificationIds' item='classificationId' separator=','>#{classificationId}</foreach>) "
|
||||
+ "</if>"
|
||||
+ "<if test='excludedClassificationIds != null'>"
|
||||
+ "AND T.CLASSIFICATION_ID NOT IN (<foreach collection='excludedClassificationIds' item='excludedClassificationId' separator=','>#{excludedClassificationId}</foreach>) "
|
||||
+ "</if>"
|
||||
+ "<if test='domains != null'>"
|
||||
+ "AND T.DOMAIN IN (<foreach collection='domains' item='domain' separator=','>#{domain}</foreach>) "
|
||||
+ "</if>"
|
||||
+ "<if test='customAttributeFilter != null'>"
|
||||
+ "AND (<foreach collection='customAttributeFilter.keys' item='key' separator=' AND '>(T.${key} = '${customAttributeFilter.get(key)}')</foreach>) "
|
||||
+ "</if>"
|
||||
+ "</where>"
|
||||
+ ") AS A "
|
||||
+ "GROUP BY A.AGE_IN_DAYS, A.ORG_LEVEL_1, A.ORG_LEVEL_2, A.ORG_LEVEL_3, A.ORG_LEVEL_4 "
|
||||
+ "</script>")
|
||||
@SelectProvider(
|
||||
type = MonitorMapperSqlProvider.class,
|
||||
method = "getTasksCountForStatusGroupedByOrgLevel")
|
||||
@Result(column = "STATUS", property = "status")
|
||||
@Result(column = "AGE_IN_DAYS", property = "ageInDays")
|
||||
@Result(column = "COUNT", property = "count")
|
||||
|
|
@ -478,9 +112,5 @@ public interface MonitorMapper {
|
|||
List<TimestampQueryItem> getTasksCountForStatusGroupedByOrgLevel(
|
||||
@Param("now") Instant now,
|
||||
@Param("status") TaskTimestamp status,
|
||||
@Param("classificationCategories") List<String> classificationCategories,
|
||||
@Param("classificationIds") List<String> classificationIds,
|
||||
@Param("excludedClassificationIds") List<String> excludedClassificationIds,
|
||||
@Param("domains") List<String> domains,
|
||||
@Param("customAttributeFilter") Map<TaskCustomField, String> customAttributeFilter);
|
||||
@Param("report") TimeIntervalReportBuilder<?, ?, ?> report);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,304 @@
|
|||
package pro.taskana.monitor.internal;
|
||||
|
||||
import static pro.taskana.common.internal.util.SqlProviderUtil.CLOSING_SCRIPT_TAG;
|
||||
import static pro.taskana.common.internal.util.SqlProviderUtil.CLOSING_WHERE_TAG;
|
||||
import static pro.taskana.common.internal.util.SqlProviderUtil.OPENING_SCRIPT_TAG;
|
||||
import static pro.taskana.common.internal.util.SqlProviderUtil.OPENING_WHERE_TAG;
|
||||
import static pro.taskana.common.internal.util.SqlProviderUtil.whereIn;
|
||||
import static pro.taskana.common.internal.util.SqlProviderUtil.whereLike;
|
||||
import static pro.taskana.common.internal.util.SqlProviderUtil.whereNotIn;
|
||||
|
||||
import java.util.stream.IntStream;
|
||||
|
||||
import pro.taskana.common.internal.util.SqlProviderUtil;
|
||||
|
||||
public class MonitorMapperSqlProvider {
|
||||
private MonitorMapperSqlProvider() {}
|
||||
|
||||
@SuppressWarnings("unused")
|
||||
public static String getTaskCountOfWorkbaskets() {
|
||||
return OPENING_SCRIPT_TAG
|
||||
+ "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.${timestamp}) - DAYS(CAST(#{now} as TIMESTAMP))) "
|
||||
+ "as AGE_IN_DAYS "
|
||||
+ "</if> "
|
||||
+ "<if test=\"_databaseId == 'h2'\">"
|
||||
+ "SELECT T.WORKBASKET_KEY, DATEDIFF('DAY', #{now}, T.${timestamp}) as AGE_IN_DAYS "
|
||||
+ "</if> "
|
||||
+ "<if test=\"_databaseId == 'postgres'\">"
|
||||
+ "SELECT T.WORKBASKET_KEY, DATE_PART('DAY', T.${timestamp} - #{now}) as AGE_IN_DAYS "
|
||||
+ "</if> "
|
||||
+ "FROM TASK AS T LEFT JOIN ATTACHMENT AS A ON T.ID = A.TASK_ID "
|
||||
+ OPENING_WHERE_TAG
|
||||
+ timeIntervalWhereStatements()
|
||||
+ "<if test=\"report.combinedClassificationFilter != null\">"
|
||||
+ "AND <foreach collection='report.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.${timestamp} IS NOT NULL "
|
||||
+ CLOSING_WHERE_TAG
|
||||
+ ") AS B "
|
||||
+ "GROUP BY B.WORKBASKET_KEY, B.AGE_IN_DAYS"
|
||||
+ CLOSING_SCRIPT_TAG;
|
||||
}
|
||||
|
||||
@SuppressWarnings("unused")
|
||||
public static String getTaskCountOfCategories() {
|
||||
return OPENING_SCRIPT_TAG
|
||||
+ "SELECT B.CLASSIFICATION_CATEGORY, B.AGE_IN_DAYS, "
|
||||
+ "COUNT(B.AGE_IN_DAYS) AS NUMBER_OF_TASKS FROM ("
|
||||
+ "SELECT CLASSIFICATION_CATEGORY, "
|
||||
+ "<if test=\"_databaseId == 'db2'\">"
|
||||
+ "(DAYS(${timestamp}) - DAYS(CAST(#{now} as TIMESTAMP))) as AGE_IN_DAYS "
|
||||
+ "</if> "
|
||||
+ "<if test=\"_databaseId == 'h2'\">"
|
||||
+ "DATEDIFF('DAY', #{now}, ${timestamp}) as AGE_IN_DAYS "
|
||||
+ "</if> "
|
||||
+ "<if test=\"_databaseId == 'postgres'\">"
|
||||
+ "DATE_PART('DAY', ${timestamp} - #{now}) as AGE_IN_DAYS "
|
||||
+ "</if> "
|
||||
+ "FROM TASK T "
|
||||
+ OPENING_WHERE_TAG
|
||||
+ timeIntervalWhereStatements()
|
||||
+ "AND ${timestamp} IS NOT NULL "
|
||||
+ CLOSING_WHERE_TAG
|
||||
+ ") AS B "
|
||||
+ "GROUP BY B.CLASSIFICATION_CATEGORY, B.AGE_IN_DAYS "
|
||||
+ CLOSING_SCRIPT_TAG;
|
||||
}
|
||||
|
||||
@SuppressWarnings("unused")
|
||||
public static String getTaskCountOfClassifications() {
|
||||
return OPENING_SCRIPT_TAG
|
||||
+ "SELECT B.CLASSIFICATION_KEY, B.AGE_IN_DAYS, "
|
||||
+ "COUNT(B.AGE_IN_DAYS) AS NUMBER_OF_TASKS FROM ("
|
||||
+ "SELECT CLASSIFICATION_KEY, "
|
||||
+ "<if test=\"_databaseId == 'db2'\">"
|
||||
+ "(DAYS(${timestamp}) - DAYS(CAST(#{now} as TIMESTAMP))) as AGE_IN_DAYS "
|
||||
+ "</if> "
|
||||
+ "<if test=\"_databaseId == 'h2'\">"
|
||||
+ "DATEDIFF('DAY', #{now}, ${timestamp}) as AGE_IN_DAYS "
|
||||
+ "</if> "
|
||||
+ "<if test=\"_databaseId == 'postgres'\">"
|
||||
+ "DATE_PART('DAY', ${timestamp} - #{now}) as AGE_IN_DAYS "
|
||||
+ "</if> "
|
||||
+ "FROM TASK T "
|
||||
+ OPENING_WHERE_TAG
|
||||
+ timeIntervalWhereStatements()
|
||||
+ "AND ${timestamp} IS NOT NULL "
|
||||
+ CLOSING_WHERE_TAG
|
||||
+ ") AS B "
|
||||
+ "GROUP BY B.CLASSIFICATION_KEY, B.AGE_IN_DAYS "
|
||||
+ CLOSING_SCRIPT_TAG;
|
||||
}
|
||||
|
||||
@SuppressWarnings("unused")
|
||||
public static String getTaskCountOfDetailedClassifications() {
|
||||
return OPENING_SCRIPT_TAG
|
||||
+ "SELECT B.TASK_CLASSIFICATION_KEY, B.ATTACHMENT_CLASSIFICATION_KEY, "
|
||||
+ "B.AGE_IN_DAYS, COUNT(B.AGE_IN_DAYS) AS NUMBER_OF_TASKS FROM ("
|
||||
+ "SELECT T.CLASSIFICATION_KEY as TASK_CLASSIFICATION_KEY, "
|
||||
+ "A.CLASSIFICATION_KEY as ATTACHMENT_CLASSIFICATION_KEY, "
|
||||
+ "<if test=\"_databaseId == 'db2'\">"
|
||||
+ "(DAYS(T.${timestamp}) - DAYS(CAST(#{now} as TIMESTAMP))) as AGE_IN_DAYS "
|
||||
+ "</if> "
|
||||
+ "<if test=\"_databaseId == 'h2'\">"
|
||||
+ "DATEDIFF('DAY', #{now}, T.${timestamp}) as AGE_IN_DAYS "
|
||||
+ "</if> "
|
||||
+ "<if test=\"_databaseId == 'postgres'\">"
|
||||
+ "DATE_PART('DAY', T.${timestamp} - #{now}) as AGE_IN_DAYS "
|
||||
+ "</if> "
|
||||
+ "FROM TASK AS T LEFT JOIN ATTACHMENT AS A ON T.ID = A.TASK_ID "
|
||||
+ OPENING_WHERE_TAG
|
||||
+ timeIntervalWhereStatements()
|
||||
+ "AND T.${timestamp} IS NOT NULL "
|
||||
+ CLOSING_WHERE_TAG
|
||||
+ ") AS B "
|
||||
+ "GROUP BY B.TASK_CLASSIFICATION_KEY, B.ATTACHMENT_CLASSIFICATION_KEY, B.AGE_IN_DAYS "
|
||||
+ CLOSING_SCRIPT_TAG;
|
||||
}
|
||||
|
||||
@SuppressWarnings("unused")
|
||||
public static String getTaskCountOfTaskCustomFieldValues() {
|
||||
return OPENING_SCRIPT_TAG
|
||||
+ "SELECT B.CUSTOM_FIELD, B.AGE_IN_DAYS, COUNT(B.AGE_IN_DAYS) AS NUMBER_OF_TASKS FROM ("
|
||||
+ "SELECT ${report.taskCustomField} as CUSTOM_FIELD, "
|
||||
+ "<if test=\"_databaseId == 'db2'\">"
|
||||
+ "(DAYS(${timestamp}) - DAYS(CAST(#{now} as TIMESTAMP))) as AGE_IN_DAYS "
|
||||
+ "</if> "
|
||||
+ "<if test=\"_databaseId == 'h2'\">"
|
||||
+ "DATEDIFF('DAY', #{now}, ${timestamp}) as AGE_IN_DAYS "
|
||||
+ "</if> "
|
||||
+ "<if test=\"_databaseId == 'postgres'\">"
|
||||
+ "DATE_PART('DAY', ${timestamp} - #{now}) as AGE_IN_DAYS "
|
||||
+ "</if> "
|
||||
+ "FROM TASK T "
|
||||
+ OPENING_WHERE_TAG
|
||||
+ timeIntervalWhereStatements()
|
||||
+ "AND ${timestamp} IS NOT NULL "
|
||||
+ CLOSING_WHERE_TAG
|
||||
+ ") AS B "
|
||||
+ "GROUP BY B.CUSTOM_FIELD, B.AGE_IN_DAYS "
|
||||
+ CLOSING_SCRIPT_TAG;
|
||||
}
|
||||
|
||||
@SuppressWarnings("unused")
|
||||
public static String getTaskIdsForSelectedItems() {
|
||||
return OPENING_SCRIPT_TAG
|
||||
+ "SELECT T.ID FROM TASK T "
|
||||
+ "<if test=\"joinWithAttachments\">"
|
||||
+ "LEFT JOIN ATTACHMENT A ON T.ID = A.TASK_ID "
|
||||
+ "</if>"
|
||||
+ OPENING_WHERE_TAG
|
||||
+ timeIntervalWhereStatements()
|
||||
+ "<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.${timestamp} IS NOT NULL AND ( "
|
||||
+ "<foreach collection='selectedItems' item='selectedItem' separator=' OR '>"
|
||||
+ "#{selectedItem.key} = T.${groupedBy} AND "
|
||||
+ "<if test=\"joinWithAttachments and combinedClassificationFilter == null\">"
|
||||
+ "<if test='selectedItem.subKey != null'>"
|
||||
+ "A.CLASSIFICATION_KEY = #{selectedItem.subKey} AND "
|
||||
+ "</if>"
|
||||
+ "</if>"
|
||||
+ "<if test=\"_databaseId == 'db2'\">"
|
||||
+ "#{selectedItem.upperAgeLimit} >= (DAYS(${timestamp})"
|
||||
+ " - DAYS(CAST(#{now} as TIMESTAMP))) AND "
|
||||
+ "#{selectedItem.lowerAgeLimit} <= (DAYS(${timestamp})"
|
||||
+ " - DAYS(CAST(#{now} as TIMESTAMP))) "
|
||||
+ "</if> "
|
||||
+ "<if test=\"_databaseId == 'h2'\">"
|
||||
+ "#{selectedItem.upperAgeLimit} >= DATEDIFF('DAY', #{now}, ${timestamp}) AND "
|
||||
+ "#{selectedItem.lowerAgeLimit} <= DATEDIFF('DAY', #{now}, ${timestamp}) "
|
||||
+ "</if> "
|
||||
+ "<if test=\"_databaseId == 'postgres'\">"
|
||||
+ "#{selectedItem.upperAgeLimit} >= DATE_PART('day', ${timestamp} - #{now} ) AND "
|
||||
+ "#{selectedItem.lowerAgeLimit} <= DATE_PART('day', ${timestamp} - #{now} ) "
|
||||
+ "</if> "
|
||||
+ "</foreach>) "
|
||||
+ CLOSING_WHERE_TAG
|
||||
+ "<if test=\"_databaseId == 'db2'\">with UR </if> "
|
||||
+ CLOSING_SCRIPT_TAG;
|
||||
}
|
||||
|
||||
@SuppressWarnings("unused")
|
||||
public static String getTasksCountByState() {
|
||||
StringBuilder whereStatements = new StringBuilder();
|
||||
whereIn("domains", "DOMAIN", whereStatements);
|
||||
whereIn("states", "STATE", whereStatements);
|
||||
whereIn("workbasketIds", "WORKBASKET_ID", whereStatements);
|
||||
return OPENING_SCRIPT_TAG
|
||||
+ "SELECT WORKBASKET_KEY, STATE, COUNT(STATE) as COUNT "
|
||||
+ "FROM TASK "
|
||||
+ OPENING_WHERE_TAG
|
||||
+ whereStatements
|
||||
+ "<if test='priorityMinimum != null'>"
|
||||
+ "AND priority >= #{priorityMinimum} "
|
||||
+ "</if>"
|
||||
+ CLOSING_WHERE_TAG
|
||||
+ "GROUP BY WORKBASKET_KEY, STATE"
|
||||
+ CLOSING_SCRIPT_TAG;
|
||||
}
|
||||
|
||||
@SuppressWarnings("unused")
|
||||
public static String getTasksCountForStatusGroupedByOrgLevel() {
|
||||
StringBuilder whereStatements = new StringBuilder();
|
||||
whereIn("report.classificationCategory", "T.CLASSIFICATION_CATEGORY", whereStatements);
|
||||
whereIn("report.domains", "T.DOMAIN", whereStatements);
|
||||
whereIn("report.classificationIds", "T.CLASSIFICATION_ID", whereStatements);
|
||||
whereNotIn("report.excludedClassificationIds", "T.CLASSIFICATION_ID", whereStatements);
|
||||
whereCustomStatements(whereStatements);
|
||||
|
||||
return OPENING_SCRIPT_TAG
|
||||
+ "SELECT A.AGE_IN_DAYS, A.ORG_LEVEL_1, A.ORG_LEVEL_2, A.ORG_LEVEL_3, A.ORG_LEVEL_4, "
|
||||
+ "'${status}' AS STATUS, COUNT(A.AGE_IN_DAYS) AS COUNT FROM ("
|
||||
// This subquery prevents the repetition of the AGE_IN_DAYS column calculation
|
||||
// (like everywhere else in the Mappers...)in the group by clause.
|
||||
// DB2 is not able to reuse computed columns in the group by statement. Even if this adds
|
||||
// a little
|
||||
// overhead / complexity. It's worth the trade-off of not computing the AGE_IN_DAYS column
|
||||
// twice.
|
||||
+ "SELECT W.ORG_LEVEL_1, W.ORG_LEVEL_2, W.ORG_LEVEL_3, W.ORG_LEVEL_4, "
|
||||
+ "<if test=\"_databaseId == 'db2'\">"
|
||||
+ "(DAYS(T.${status}) - DAYS(CAST(#{now} as TIMESTAMP)))"
|
||||
+ "</if>"
|
||||
+ "<if test=\"_databaseId == 'h2'\">"
|
||||
+ "DATEDIFF('DAY', #{now}, T.${status})"
|
||||
+ "</if>"
|
||||
+ "<if test=\"_databaseId == 'postgres'\">"
|
||||
+ "DATE_PART('DAY', T.${status} - #{now})"
|
||||
+ "</if>"
|
||||
+ " as AGE_IN_DAYS "
|
||||
+ "FROM TASK AS T INNER JOIN WORKBASKET AS W ON T.WORKBASKET_KEY=W.KEY "
|
||||
+ OPENING_WHERE_TAG
|
||||
+ "<if test=\"status.name() == 'COMPLETED'\">"
|
||||
+ "T.COMPLETED IS NOT NULL "
|
||||
+ "</if>"
|
||||
+ whereStatements
|
||||
+ CLOSING_WHERE_TAG
|
||||
+ ") AS A "
|
||||
+ "GROUP BY A.AGE_IN_DAYS, A.ORG_LEVEL_1, A.ORG_LEVEL_2, A.ORG_LEVEL_3, A.ORG_LEVEL_4 "
|
||||
+ CLOSING_SCRIPT_TAG;
|
||||
}
|
||||
|
||||
@SuppressWarnings("unused")
|
||||
public static String getCustomAttributeValuesForReport() {
|
||||
return OPENING_SCRIPT_TAG
|
||||
+ "SELECT DISTINCT ${customField} "
|
||||
+ "FROM TASK T "
|
||||
+ "<if test=\"combinedClassificationFilter != null\">"
|
||||
+ "LEFT JOIN ATTACHMENT A ON T.ID = A.TASK_ID "
|
||||
+ "</if>"
|
||||
+ OPENING_WHERE_TAG
|
||||
+ timeIntervalWhereStatements()
|
||||
+ "<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>"
|
||||
+ CLOSING_WHERE_TAG
|
||||
+ CLOSING_SCRIPT_TAG;
|
||||
}
|
||||
|
||||
private static String timeIntervalWhereStatements() {
|
||||
StringBuilder sb = new StringBuilder();
|
||||
SqlProviderUtil.whereIn("report.workbasketIds", "T.WORKBASKET_ID", sb);
|
||||
SqlProviderUtil.whereIn("report.states", "T.STATE", sb);
|
||||
SqlProviderUtil.whereIn("report.classificationCategory", "T.CLASSIFICATION_CATEGORY", sb);
|
||||
SqlProviderUtil.whereIn("report.domains", "T.DOMAIN", sb);
|
||||
SqlProviderUtil.whereIn("report.classificationIds", "T.CLASSIFICATION_ID", sb);
|
||||
SqlProviderUtil.whereNotIn("report.excludedClassificationIds", "T.CLASSIFICATION_ID", sb);
|
||||
whereCustomStatements(sb);
|
||||
|
||||
return sb.toString();
|
||||
}
|
||||
|
||||
private static void whereCustomStatements(StringBuilder sb) {
|
||||
IntStream.rangeClosed(1, 16)
|
||||
.forEach(
|
||||
x -> {
|
||||
String collectionIn = "report.custom" + x + "In";
|
||||
String collectionNotIn = "report.custom" + x + "NotIn";
|
||||
String collectionLike = "report.custom" + x + "Like";
|
||||
String column = "T.CUSTOM_" + x;
|
||||
whereIn(collectionIn, column, sb);
|
||||
whereLike(collectionLike, column, sb);
|
||||
whereNotIn(collectionNotIn, column, sb);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
|
@ -34,21 +34,12 @@ public class ClassificationCategoryReportBuilderImpl
|
|||
@Override
|
||||
public ClassificationCategoryReport buildReport(TaskTimestamp timestamp)
|
||||
throws InvalidArgumentException, NotAuthorizedException {
|
||||
this.taskanaEngine.getEngine().checkRoleMembership(TaskanaRole.MONITOR);
|
||||
this.taskanaEngine.getEngine().checkRoleMembership(TaskanaRole.MONITOR, TaskanaRole.ADMIN);
|
||||
try {
|
||||
this.taskanaEngine.openConnection();
|
||||
ClassificationCategoryReport report = new ClassificationCategoryReport(this.columnHeaders);
|
||||
List<MonitorQueryItem> monitorQueryItems =
|
||||
this.monitorMapper.getTaskCountOfCategories(
|
||||
Instant.now(),
|
||||
this.workbasketIds,
|
||||
this.states,
|
||||
this.classificationCategory,
|
||||
this.domains,
|
||||
timestamp,
|
||||
this.classificationIds,
|
||||
this.excludedClassificationIds,
|
||||
this.customAttributeFilter);
|
||||
this.monitorMapper.getTaskCountOfCategories(Instant.now(), timestamp, this);
|
||||
report.addItems(
|
||||
monitorQueryItems,
|
||||
new DaysToWorkingDaysReportPreProcessor<>(
|
||||
|
|
|
|||
|
|
@ -50,16 +50,7 @@ public class ClassificationReportBuilderImpl
|
|||
this.taskanaEngine.openConnection();
|
||||
ClassificationReport report = new ClassificationReport(this.columnHeaders);
|
||||
List<MonitorQueryItem> monitorQueryItems =
|
||||
this.monitorMapper.getTaskCountOfClassifications(
|
||||
Instant.now(),
|
||||
this.workbasketIds,
|
||||
this.states,
|
||||
this.classificationCategory,
|
||||
this.domains,
|
||||
timestamp,
|
||||
this.classificationIds,
|
||||
this.excludedClassificationIds,
|
||||
this.customAttributeFilter);
|
||||
this.monitorMapper.getTaskCountOfClassifications(Instant.now(), timestamp, this);
|
||||
report.addItems(
|
||||
monitorQueryItems,
|
||||
new DaysToWorkingDaysReportPreProcessor<>(
|
||||
|
|
@ -98,16 +89,7 @@ public class ClassificationReportBuilderImpl
|
|||
this.taskanaEngine.openConnection();
|
||||
DetailedClassificationReport report = new DetailedClassificationReport(this.columnHeaders);
|
||||
List<DetailedMonitorQueryItem> detailedMonitorQueryItems =
|
||||
this.monitorMapper.getTaskCountOfDetailedClassifications(
|
||||
Instant.now(),
|
||||
this.workbasketIds,
|
||||
this.states,
|
||||
this.classificationCategory,
|
||||
this.domains,
|
||||
timestamp,
|
||||
this.classificationIds,
|
||||
this.excludedClassificationIds,
|
||||
this.customAttributeFilter);
|
||||
this.monitorMapper.getTaskCountOfDetailedClassifications(Instant.now(), timestamp, this);
|
||||
|
||||
report.addItems(
|
||||
detailedMonitorQueryItems,
|
||||
|
|
|
|||
|
|
@ -40,22 +40,12 @@ public class TaskCustomFieldValueReportBuilderImpl
|
|||
@Override
|
||||
public TaskCustomFieldValueReport buildReport(TaskTimestamp timestamp)
|
||||
throws InvalidArgumentException, NotAuthorizedException {
|
||||
this.taskanaEngine.getEngine().checkRoleMembership(TaskanaRole.MONITOR);
|
||||
this.taskanaEngine.getEngine().checkRoleMembership(TaskanaRole.MONITOR, TaskanaRole.ADMIN);
|
||||
try {
|
||||
this.taskanaEngine.openConnection();
|
||||
TaskCustomFieldValueReport report = new TaskCustomFieldValueReport(this.columnHeaders);
|
||||
List<MonitorQueryItem> monitorQueryItems =
|
||||
this.monitorMapper.getTaskCountOfTaskCustomFieldValues(
|
||||
Instant.now(),
|
||||
this.taskCustomField,
|
||||
this.workbasketIds,
|
||||
this.states,
|
||||
this.classificationCategory,
|
||||
this.domains,
|
||||
timestamp,
|
||||
this.classificationIds,
|
||||
this.excludedClassificationIds,
|
||||
this.customAttributeFilter);
|
||||
this.monitorMapper.getTaskCountOfTaskCustomFieldValues(Instant.now(), timestamp, this);
|
||||
|
||||
report.addItems(
|
||||
monitorQueryItems,
|
||||
|
|
|
|||
|
|
@ -3,15 +3,14 @@ package pro.taskana.monitor.internal.reports;
|
|||
import java.time.Instant;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
import pro.taskana.common.api.TaskanaRole;
|
||||
import pro.taskana.common.api.WorkingDaysToDaysConverter;
|
||||
import pro.taskana.common.api.exceptions.InvalidArgumentException;
|
||||
import pro.taskana.common.api.exceptions.NotAuthorizedException;
|
||||
import pro.taskana.common.api.exceptions.SystemException;
|
||||
import pro.taskana.common.internal.InternalTaskanaEngine;
|
||||
import pro.taskana.monitor.api.CombinedClassificationFilter;
|
||||
import pro.taskana.monitor.api.SelectedItem;
|
||||
|
|
@ -48,7 +47,54 @@ abstract class TimeIntervalReportBuilderImpl<
|
|||
protected List<String> domains;
|
||||
protected List<String> classificationIds;
|
||||
protected List<String> excludedClassificationIds;
|
||||
protected Map<TaskCustomField, String> customAttributeFilter;
|
||||
private String[] custom1In;
|
||||
private String[] custom1NotIn;
|
||||
private String[] custom1Like;
|
||||
private String[] custom2In;
|
||||
private String[] custom2NotIn;
|
||||
private String[] custom2Like;
|
||||
private String[] custom3In;
|
||||
private String[] custom3NotIn;
|
||||
private String[] custom3Like;
|
||||
private String[] custom4In;
|
||||
private String[] custom4NotIn;
|
||||
private String[] custom4Like;
|
||||
private String[] custom5In;
|
||||
private String[] custom5NotIn;
|
||||
private String[] custom5Like;
|
||||
private String[] custom6In;
|
||||
private String[] custom6NotIn;
|
||||
private String[] custom6Like;
|
||||
private String[] custom7In;
|
||||
private String[] custom7NotIn;
|
||||
private String[] custom7Like;
|
||||
private String[] custom8In;
|
||||
private String[] custom8NotIn;
|
||||
private String[] custom8Like;
|
||||
private String[] custom9In;
|
||||
private String[] custom9NotIn;
|
||||
private String[] custom9Like;
|
||||
private String[] custom10In;
|
||||
private String[] custom10NotIn;
|
||||
private String[] custom10Like;
|
||||
private String[] custom11In;
|
||||
private String[] custom11NotIn;
|
||||
private String[] custom11Like;
|
||||
private String[] custom12In;
|
||||
private String[] custom12NotIn;
|
||||
private String[] custom12Like;
|
||||
private String[] custom13In;
|
||||
private String[] custom13NotIn;
|
||||
private String[] custom13Like;
|
||||
private String[] custom14In;
|
||||
private String[] custom14NotIn;
|
||||
private String[] custom14Like;
|
||||
private String[] custom15In;
|
||||
private String[] custom15NotIn;
|
||||
private String[] custom15Like;
|
||||
private String[] custom16In;
|
||||
private String[] custom16NotIn;
|
||||
private String[] custom16Like;
|
||||
protected WorkingDaysToDaysConverter converter;
|
||||
|
||||
TimeIntervalReportBuilderImpl(InternalTaskanaEngine taskanaEngine, MonitorMapper monitorMapper) {
|
||||
|
|
@ -107,8 +153,192 @@ abstract class TimeIntervalReportBuilderImpl<
|
|||
}
|
||||
|
||||
@Override
|
||||
public B customAttributeFilterIn(Map<TaskCustomField, String> customAttributeFilter) {
|
||||
this.customAttributeFilter = new HashMap<>(customAttributeFilter);
|
||||
public B customAttributeIn(TaskCustomField customField, String... strings)
|
||||
throws InvalidArgumentException {
|
||||
if (strings.length == 0) {
|
||||
throw new InvalidArgumentException(
|
||||
"At least one string has to be provided as a search parameter");
|
||||
}
|
||||
switch (customField) {
|
||||
case CUSTOM_1:
|
||||
this.custom1In = strings;
|
||||
break;
|
||||
case CUSTOM_2:
|
||||
this.custom2In = strings;
|
||||
break;
|
||||
case CUSTOM_3:
|
||||
this.custom3In = strings;
|
||||
break;
|
||||
case CUSTOM_4:
|
||||
this.custom4In = strings;
|
||||
break;
|
||||
case CUSTOM_5:
|
||||
this.custom5In = strings;
|
||||
break;
|
||||
case CUSTOM_6:
|
||||
this.custom6In = strings;
|
||||
break;
|
||||
case CUSTOM_7:
|
||||
this.custom7In = strings;
|
||||
break;
|
||||
case CUSTOM_8:
|
||||
this.custom8In = strings;
|
||||
break;
|
||||
case CUSTOM_9:
|
||||
this.custom9In = strings;
|
||||
break;
|
||||
case CUSTOM_10:
|
||||
this.custom10In = strings;
|
||||
break;
|
||||
case CUSTOM_11:
|
||||
this.custom11In = strings;
|
||||
break;
|
||||
case CUSTOM_12:
|
||||
this.custom12In = strings;
|
||||
break;
|
||||
case CUSTOM_13:
|
||||
this.custom13In = strings;
|
||||
break;
|
||||
case CUSTOM_14:
|
||||
this.custom14In = strings;
|
||||
break;
|
||||
case CUSTOM_15:
|
||||
this.custom15In = strings;
|
||||
break;
|
||||
case CUSTOM_16:
|
||||
this.custom16In = strings;
|
||||
break;
|
||||
default:
|
||||
throw new SystemException("Unknown custom attribute '" + customField + "'");
|
||||
}
|
||||
|
||||
return _this();
|
||||
}
|
||||
|
||||
@Override
|
||||
public B customAttributeNotIn(TaskCustomField customField, String... strings)
|
||||
throws InvalidArgumentException {
|
||||
if (strings.length == 0) {
|
||||
throw new InvalidArgumentException(
|
||||
"At least one string has to be provided as a search parameter");
|
||||
}
|
||||
switch (customField) {
|
||||
case CUSTOM_1:
|
||||
this.custom1NotIn = strings;
|
||||
break;
|
||||
case CUSTOM_2:
|
||||
this.custom2NotIn = strings;
|
||||
break;
|
||||
case CUSTOM_3:
|
||||
this.custom3NotIn = strings;
|
||||
break;
|
||||
case CUSTOM_4:
|
||||
this.custom4NotIn = strings;
|
||||
break;
|
||||
case CUSTOM_5:
|
||||
this.custom5NotIn = strings;
|
||||
break;
|
||||
case CUSTOM_6:
|
||||
this.custom6NotIn = strings;
|
||||
break;
|
||||
case CUSTOM_7:
|
||||
this.custom7NotIn = strings;
|
||||
break;
|
||||
case CUSTOM_8:
|
||||
this.custom8NotIn = strings;
|
||||
break;
|
||||
case CUSTOM_9:
|
||||
this.custom9NotIn = strings;
|
||||
break;
|
||||
case CUSTOM_10:
|
||||
this.custom10NotIn = strings;
|
||||
break;
|
||||
case CUSTOM_11:
|
||||
this.custom11NotIn = strings;
|
||||
break;
|
||||
case CUSTOM_12:
|
||||
this.custom12NotIn = strings;
|
||||
break;
|
||||
case CUSTOM_13:
|
||||
this.custom13NotIn = strings;
|
||||
break;
|
||||
case CUSTOM_14:
|
||||
this.custom14NotIn = strings;
|
||||
break;
|
||||
case CUSTOM_15:
|
||||
this.custom15NotIn = strings;
|
||||
break;
|
||||
case CUSTOM_16:
|
||||
this.custom16NotIn = strings;
|
||||
break;
|
||||
default:
|
||||
throw new SystemException("Unknown custom attribute '" + customField + "'");
|
||||
}
|
||||
|
||||
return _this();
|
||||
}
|
||||
|
||||
@Override
|
||||
public B customAttributeLike(TaskCustomField customField, String... strings)
|
||||
throws InvalidArgumentException {
|
||||
if (strings.length == 0) {
|
||||
throw new InvalidArgumentException(
|
||||
"At least one string has to be provided as a search parameter");
|
||||
}
|
||||
|
||||
switch (customField) {
|
||||
case CUSTOM_1:
|
||||
this.custom1Like = toUpperCopy(strings);
|
||||
break;
|
||||
case CUSTOM_2:
|
||||
this.custom2Like = toUpperCopy(strings);
|
||||
break;
|
||||
case CUSTOM_3:
|
||||
this.custom3Like = toUpperCopy(strings);
|
||||
break;
|
||||
case CUSTOM_4:
|
||||
this.custom4Like = toUpperCopy(strings);
|
||||
break;
|
||||
case CUSTOM_5:
|
||||
this.custom5Like = toUpperCopy(strings);
|
||||
break;
|
||||
case CUSTOM_6:
|
||||
this.custom6Like = toUpperCopy(strings);
|
||||
break;
|
||||
case CUSTOM_7:
|
||||
this.custom7Like = toUpperCopy(strings);
|
||||
break;
|
||||
case CUSTOM_8:
|
||||
this.custom8Like = toUpperCopy(strings);
|
||||
break;
|
||||
case CUSTOM_9:
|
||||
this.custom9Like = toUpperCopy(strings);
|
||||
break;
|
||||
case CUSTOM_10:
|
||||
this.custom10Like = toUpperCopy(strings);
|
||||
break;
|
||||
case CUSTOM_11:
|
||||
this.custom11Like = toUpperCopy(strings);
|
||||
break;
|
||||
case CUSTOM_12:
|
||||
this.custom12Like = toUpperCopy(strings);
|
||||
break;
|
||||
case CUSTOM_13:
|
||||
this.custom13Like = toUpperCopy(strings);
|
||||
break;
|
||||
case CUSTOM_14:
|
||||
this.custom14Like = toUpperCopy(strings);
|
||||
break;
|
||||
case CUSTOM_15:
|
||||
this.custom15Like = toUpperCopy(strings);
|
||||
break;
|
||||
case CUSTOM_16:
|
||||
this.custom16Like = toUpperCopy(strings);
|
||||
break;
|
||||
default:
|
||||
throw new SystemException("Unknown custom field '" + customField + "'");
|
||||
}
|
||||
|
||||
return _this();
|
||||
}
|
||||
|
||||
|
|
@ -138,13 +368,7 @@ abstract class TimeIntervalReportBuilderImpl<
|
|||
}
|
||||
return this.monitorMapper.getTaskIdsForSelectedItems(
|
||||
Instant.now(),
|
||||
this.workbasketIds,
|
||||
this.states,
|
||||
this.classificationCategory,
|
||||
this.domains,
|
||||
this.classificationIds,
|
||||
this.excludedClassificationIds,
|
||||
this.customAttributeFilter,
|
||||
this,
|
||||
combinedClassificationFilter,
|
||||
determineGroupedBy(),
|
||||
timestamp,
|
||||
|
|
@ -162,13 +386,7 @@ abstract class TimeIntervalReportBuilderImpl<
|
|||
try {
|
||||
this.taskanaEngine.openConnection();
|
||||
return monitorMapper.getCustomAttributeValuesForReport(
|
||||
this.workbasketIds,
|
||||
this.states,
|
||||
this.classificationCategory,
|
||||
this.domains,
|
||||
this.classificationIds,
|
||||
this.excludedClassificationIds,
|
||||
this.customAttributeFilter,
|
||||
this,
|
||||
getCombinedClassificationFilter(),
|
||||
taskCustomField);
|
||||
} finally {
|
||||
|
|
@ -211,4 +429,19 @@ abstract class TimeIntervalReportBuilderImpl<
|
|||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private String[] toUpperCopy(String... source) {
|
||||
if (source == null || source.length == 0) {
|
||||
// we are currently aware that this is a code smell. Unfortunately the resolution of this
|
||||
// would cause havoc in our queries, since we do not have a concept
|
||||
// for a user input validation yet. As soon as that is done we can resolve this code smell.
|
||||
return null;
|
||||
} else {
|
||||
String[] target = new String[source.length];
|
||||
for (int i = 0; i < source.length; i++) {
|
||||
target[i] = source[i].toUpperCase();
|
||||
}
|
||||
return target;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -48,8 +48,8 @@ public class TimestampReportBuilderImpl
|
|||
}
|
||||
|
||||
@Override
|
||||
public TimestampReport.Builder withTimestamps(List<TaskTimestamp> statuses) {
|
||||
this.status = new ArrayList<>(statuses);
|
||||
public TimestampReport.Builder withTimestamps(List<TaskTimestamp> taskTimestamps) {
|
||||
this.status = new ArrayList<>(taskTimestamps);
|
||||
return _this();
|
||||
}
|
||||
|
||||
|
|
@ -94,13 +94,6 @@ public class TimestampReportBuilderImpl
|
|||
}
|
||||
|
||||
private List<TimestampQueryItem> getTasksCountForStatusGroupedByOrgLevel(TaskTimestamp s) {
|
||||
return monitorMapper.getTasksCountForStatusGroupedByOrgLevel(
|
||||
Instant.now(),
|
||||
s,
|
||||
classificationCategory,
|
||||
classificationIds,
|
||||
excludedClassificationIds,
|
||||
domains,
|
||||
customAttributeFilter);
|
||||
return monitorMapper.getTasksCountForStatusGroupedByOrgLevel(Instant.now(), s, this);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -47,17 +47,7 @@ public class WorkbasketReportBuilderImpl
|
|||
this.taskanaEngine.openConnection();
|
||||
WorkbasketReport report = new WorkbasketReport(this.columnHeaders);
|
||||
List<MonitorQueryItem> monitorQueryItems =
|
||||
this.monitorMapper.getTaskCountOfWorkbaskets(
|
||||
Instant.now(),
|
||||
this.workbasketIds,
|
||||
this.states,
|
||||
this.classificationCategory,
|
||||
this.domains,
|
||||
timestamp,
|
||||
this.classificationIds,
|
||||
this.excludedClassificationIds,
|
||||
this.customAttributeFilter,
|
||||
this.combinedClassificationFilter);
|
||||
this.monitorMapper.getTaskCountOfWorkbaskets(Instant.now(), timestamp, this);
|
||||
report.addItems(
|
||||
monitorQueryItems,
|
||||
new DaysToWorkingDaysReportPreProcessor<>(
|
||||
|
|
|
|||
|
|
@ -1,5 +1,9 @@
|
|||
package pro.taskana.task.internal;
|
||||
|
||||
import static pro.taskana.common.internal.util.SqlProviderUtil.CLOSING_SCRIPT_TAG;
|
||||
import static pro.taskana.common.internal.util.SqlProviderUtil.CLOSING_WHERE_TAG;
|
||||
import static pro.taskana.common.internal.util.SqlProviderUtil.OPENING_SCRIPT_TAG;
|
||||
import static pro.taskana.common.internal.util.SqlProviderUtil.OPENING_WHERE_TAG;
|
||||
import static pro.taskana.common.internal.util.SqlProviderUtil.whereIn;
|
||||
import static pro.taskana.common.internal.util.SqlProviderUtil.whereInTime;
|
||||
import static pro.taskana.common.internal.util.SqlProviderUtil.whereLike;
|
||||
|
|
@ -12,10 +16,6 @@ import java.util.stream.IntStream;
|
|||
import pro.taskana.task.api.TaskQueryColumnName;
|
||||
|
||||
public class TaskQuerySqlProvider {
|
||||
private static final String OPENING_SCRIPT_TAG = "<script>";
|
||||
private static final String CLOSING_SCRIPT_TAG = "</script>";
|
||||
private static final String OPENING_WHERE_TAG = "<where>";
|
||||
private static final String CLOSING_WHERE_TAG = "</where>";
|
||||
private static final String WILDCARD_LIKE_STATEMENT =
|
||||
"<if test='wildcardSearchValueLike != null and wildcardSearchFieldIn != null'>AND ("
|
||||
+ "<foreach item='item' collection='wildcardSearchFieldIn' separator=' OR '>"
|
||||
|
|
@ -26,6 +26,7 @@ public class TaskQuerySqlProvider {
|
|||
|
||||
private TaskQuerySqlProvider() {}
|
||||
|
||||
@SuppressWarnings("unused")
|
||||
public static String queryTaskSummaries() {
|
||||
return OPENING_SCRIPT_TAG
|
||||
+ "SELECT <if test=\"useDistinctKeyword\">DISTINCT</if> "
|
||||
|
|
@ -66,6 +67,7 @@ public class TaskQuerySqlProvider {
|
|||
+ CLOSING_SCRIPT_TAG;
|
||||
}
|
||||
|
||||
@SuppressWarnings("unused")
|
||||
public static String queryTaskSummariesDb2() {
|
||||
return OPENING_SCRIPT_TAG
|
||||
+ "WITH X ("
|
||||
|
|
@ -126,6 +128,7 @@ public class TaskQuerySqlProvider {
|
|||
+ CLOSING_SCRIPT_TAG;
|
||||
}
|
||||
|
||||
@SuppressWarnings("unused")
|
||||
public static String countQueryTasks() {
|
||||
return OPENING_SCRIPT_TAG
|
||||
+ "SELECT COUNT( <if test=\"useDistinctKeyword\">DISTINCT</if> t.ID) "
|
||||
|
|
@ -148,6 +151,7 @@ public class TaskQuerySqlProvider {
|
|||
+ CLOSING_SCRIPT_TAG;
|
||||
}
|
||||
|
||||
@SuppressWarnings("unused")
|
||||
public static String countQueryTasksDb2() {
|
||||
return OPENING_SCRIPT_TAG
|
||||
+ "WITH X (ID, WORKBASKET_ID) AS ("
|
||||
|
|
@ -179,6 +183,7 @@ public class TaskQuerySqlProvider {
|
|||
+ CLOSING_SCRIPT_TAG;
|
||||
}
|
||||
|
||||
@SuppressWarnings("unused")
|
||||
public static String queryTaskColumnValues() {
|
||||
return OPENING_SCRIPT_TAG
|
||||
+ "SELECT DISTINCT ${columnName} "
|
||||
|
|
|
|||
|
|
@ -45,7 +45,8 @@ class JobRunnerAccTest extends AbstractAccTest {
|
|||
// both test threads and therefore test the database lock.
|
||||
// Without the slow down the test threads would execute too fast and
|
||||
// would not request executable jobs from the database at the same time.
|
||||
dataSource = slowDownDatabaseTransaction(dataSource);
|
||||
// TODO: please fix this. With the slowdown the test suite fails often
|
||||
// dataSource = slowDownDatabaseTransaction(dataSource);
|
||||
PlainJavaTransactionProvider transactionProvider =
|
||||
new PlainJavaTransactionProvider(taskanaEngine, dataSource);
|
||||
JobRunner runner = new JobRunner(taskanaEngine);
|
||||
|
|
|
|||
|
|
@ -3,9 +3,7 @@ package acceptance.report;
|
|||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.assertj.core.api.Assertions.assertThatThrownBy;
|
||||
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.api.extension.ExtendWith;
|
||||
|
|
@ -57,15 +55,41 @@ class GetCustomAttributeValuesForReportAccTest extends AbstractReportAccTest {
|
|||
|
||||
@WithAccessId(user = "monitor")
|
||||
@Test
|
||||
void testGetCustomAttributeValuesForCustomAttribute() throws Exception {
|
||||
Map<TaskCustomField, String> customAttributeFilter = new HashMap<>();
|
||||
customAttributeFilter.put(TaskCustomField.CUSTOM_2, "Vollkasko");
|
||||
customAttributeFilter.put(TaskCustomField.CUSTOM_1, "Geschaeftsstelle A");
|
||||
|
||||
void should_ReturnCustomAttributeValuesOfCategoryReport_When_FilteringWithCustomAttributeIn()
|
||||
throws Exception {
|
||||
List<String> values =
|
||||
MONITOR_SERVICE
|
||||
.createClassificationCategoryReportBuilder()
|
||||
.customAttributeFilterIn(customAttributeFilter)
|
||||
.customAttributeIn(TaskCustomField.CUSTOM_2, "Vollkasko")
|
||||
.customAttributeIn(TaskCustomField.CUSTOM_1, "Geschaeftsstelle A")
|
||||
.listCustomAttributeValuesForCustomAttributeName(TaskCustomField.CUSTOM_16);
|
||||
|
||||
assertThat(values).hasSize(12);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
@Test
|
||||
void should_ReturnCustomAttributeValuesOfCategoryReport_When_FilteringWithCustomAttributeNotIn()
|
||||
throws Exception {
|
||||
List<String> values =
|
||||
MONITOR_SERVICE
|
||||
.createClassificationCategoryReportBuilder()
|
||||
.customAttributeNotIn(TaskCustomField.CUSTOM_2, "Vollkasko")
|
||||
.customAttributeNotIn(TaskCustomField.CUSTOM_1, "Geschaeftsstelle A")
|
||||
.listCustomAttributeValuesForCustomAttributeName(TaskCustomField.CUSTOM_16);
|
||||
|
||||
assertThat(values).hasSize(16);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
@Test
|
||||
void should_ReturnCustomAttributeValuesOfCategoryReport_When_FilteringWithCustomAttributeLike()
|
||||
throws Exception {
|
||||
List<String> values =
|
||||
MONITOR_SERVICE
|
||||
.createClassificationCategoryReportBuilder()
|
||||
.customAttributeLike(TaskCustomField.CUSTOM_2, "%ollkas%")
|
||||
.customAttributeLike(TaskCustomField.CUSTOM_1, "%aeftsstelle A")
|
||||
.listCustomAttributeValuesForCustomAttributeName(TaskCustomField.CUSTOM_16);
|
||||
|
||||
assertThat(values).hasSize(12);
|
||||
|
|
|
|||
|
|
@ -6,10 +6,8 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
|
|||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
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;
|
||||
|
|
@ -220,9 +218,7 @@ class GetTaskIdsOfClassificationCategoryReportAccTest extends AbstractReportAccT
|
|||
|
||||
@WithAccessId(user = "monitor")
|
||||
@Test
|
||||
void testGetTaskIdsOfCategoryReportWithCustomFieldValueFilter() throws Exception {
|
||||
Map<TaskCustomField, String> customAttributeFilter = new HashMap<>();
|
||||
customAttributeFilter.put(TaskCustomField.CUSTOM_1, "Geschaeftsstelle A");
|
||||
void should_ReturnTaskIdsOfCategoryReport_When_FilteringWithCustomAttributeIn() throws Exception {
|
||||
final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
|
||||
|
||||
final List<SelectedItem> selectedItems = List.of(EXTERN, AUTOMATIC, MANUAL);
|
||||
|
|
@ -232,7 +228,7 @@ class GetTaskIdsOfClassificationCategoryReportAccTest extends AbstractReportAccT
|
|||
.createClassificationCategoryReportBuilder()
|
||||
.withColumnHeaders(columnHeaders)
|
||||
.inWorkingDays()
|
||||
.customAttributeFilterIn(customAttributeFilter)
|
||||
.customAttributeIn(TaskCustomField.CUSTOM_1, "Geschaeftsstelle A")
|
||||
.listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE);
|
||||
|
||||
assertThat(ids)
|
||||
|
|
@ -244,6 +240,50 @@ class GetTaskIdsOfClassificationCategoryReportAccTest extends AbstractReportAccT
|
|||
"TKI:000000000000000000000000000000000032");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
@Test
|
||||
void should_ReturnTaskIdsOfCategoryReport_When_FilteringWithCustomAttributeNotIn()
|
||||
throws Exception {
|
||||
final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
|
||||
|
||||
final List<SelectedItem> selectedItems = List.of(EXTERN, AUTOMATIC, MANUAL);
|
||||
|
||||
List<String> ids =
|
||||
MONITOR_SERVICE
|
||||
.createClassificationCategoryReportBuilder()
|
||||
.withColumnHeaders(columnHeaders)
|
||||
.inWorkingDays()
|
||||
.customAttributeNotIn(TaskCustomField.CUSTOM_2, "Vollkasko")
|
||||
.customAttributeNotIn(TaskCustomField.CUSTOM_1, "Geschaeftsstelle A")
|
||||
.listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE);
|
||||
|
||||
assertThat(ids)
|
||||
.containsExactlyInAnyOrder(
|
||||
"TKI:000000000000000000000000000000000006",
|
||||
"TKI:000000000000000000000000000000000021",
|
||||
"TKI:000000000000000000000000000000000022",
|
||||
"TKI:000000000000000000000000000000000028");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
@Test
|
||||
void should_ReturnTaskIdsOfCategoryReport_When_FilteringWithCustomAttributeLike()
|
||||
throws Exception {
|
||||
final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
|
||||
|
||||
final List<SelectedItem> selectedItems = List.of(EXTERN, AUTOMATIC, MANUAL);
|
||||
|
||||
List<String> ids =
|
||||
MONITOR_SERVICE
|
||||
.createClassificationCategoryReportBuilder()
|
||||
.withColumnHeaders(columnHeaders)
|
||||
.inWorkingDays()
|
||||
.customAttributeLike(TaskCustomField.CUSTOM_1, "%aeftsstelle A")
|
||||
.listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE);
|
||||
|
||||
assertThat(ids).hasSize(5);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
@Test
|
||||
void testThrowsExceptionIfSubKeysAreUsed() {
|
||||
|
|
|
|||
|
|
@ -6,10 +6,8 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
|
|||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
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;
|
||||
|
|
@ -207,9 +205,8 @@ class GetTaskIdsOfTaskCustomFieldValueReportAccTest extends AbstractReportAccTes
|
|||
|
||||
@WithAccessId(user = "monitor")
|
||||
@Test
|
||||
void testGetTaskIdsOfCustomFieldValueReportWithCustomFieldValueFilter() throws Exception {
|
||||
final Map<TaskCustomField, String> customAttributeFilter = new HashMap<>();
|
||||
customAttributeFilter.put(TaskCustomField.CUSTOM_1, "Geschaeftsstelle A");
|
||||
void should_ReturnTaskIdsOfCustomFieldValueReport_When_FilteringWithCustomAttributeIn()
|
||||
throws Exception {
|
||||
final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
|
||||
List<SelectedItem> selectedItems =
|
||||
List.of(GESCHAEFTSSTELLE_A, GESCHAEFTSSTELLE_B, GESCHAEFTSSTELLE_C);
|
||||
|
|
@ -219,14 +216,39 @@ class GetTaskIdsOfTaskCustomFieldValueReportAccTest extends AbstractReportAccTes
|
|||
.createTaskCustomFieldValueReportBuilder(TaskCustomField.CUSTOM_1)
|
||||
.withColumnHeaders(columnHeaders)
|
||||
.inWorkingDays()
|
||||
.customAttributeFilterIn(customAttributeFilter)
|
||||
.customAttributeIn(TaskCustomField.CUSTOM_1, "Geschaeftsstelle A")
|
||||
.listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE);
|
||||
|
||||
assertThat(ids).hasSize(4);
|
||||
assertThat(ids.contains("TKI:000000000000000000000000000000000020")).isTrue();
|
||||
assertThat(ids.contains("TKI:000000000000000000000000000000000024")).isTrue();
|
||||
assertThat(ids.contains("TKI:000000000000000000000000000000000027")).isTrue();
|
||||
assertThat(ids.contains("TKI:000000000000000000000000000000000029")).isTrue();
|
||||
assertThat(ids)
|
||||
.containsExactlyInAnyOrder(
|
||||
"TKI:000000000000000000000000000000000020",
|
||||
"TKI:000000000000000000000000000000000024",
|
||||
"TKI:000000000000000000000000000000000027",
|
||||
"TKI:000000000000000000000000000000000029");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
@Test
|
||||
void should_ReturnTaskIdsOfCustomFieldValueReport_When_FilteringWithCustomAttributeNotIn()
|
||||
throws Exception {
|
||||
final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
|
||||
List<SelectedItem> selectedItems =
|
||||
List.of(GESCHAEFTSSTELLE_A, GESCHAEFTSSTELLE_B, GESCHAEFTSSTELLE_C);
|
||||
|
||||
List<String> ids =
|
||||
MONITOR_SERVICE
|
||||
.createTaskCustomFieldValueReportBuilder(TaskCustomField.CUSTOM_1)
|
||||
.withColumnHeaders(columnHeaders)
|
||||
.inWorkingDays()
|
||||
.customAttributeNotIn(TaskCustomField.CUSTOM_1, "Geschaeftsstelle A")
|
||||
.listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE);
|
||||
|
||||
assertThat(ids)
|
||||
.containsExactlyInAnyOrder(
|
||||
"TKI:000000000000000000000000000000000002",
|
||||
"TKI:000000000000000000000000000000000006",
|
||||
"TKI:000000000000000000000000000000000009",
|
||||
"TKI:000000000000000000000000000000000033");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
|
|
|
|||
|
|
@ -6,10 +6,8 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
|
|||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
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;
|
||||
|
|
@ -326,16 +324,15 @@ class ProvideClassificationCategoryReportAccTest extends AbstractReportAccTest {
|
|||
|
||||
@WithAccessId(user = "monitor")
|
||||
@Test
|
||||
void testEachItemOfCategoryReportWithCustomFieldValueFilter() throws Exception {
|
||||
Map<TaskCustomField, String> customAttributeFilter = new HashMap<>();
|
||||
customAttributeFilter.put(TaskCustomField.CUSTOM_1, "Geschaeftsstelle A");
|
||||
void should_ReturnItemsOfCategoryReport_When_FilteringWithCustomAttributeIn()
|
||||
throws Exception {
|
||||
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
|
||||
|
||||
ClassificationCategoryReport report =
|
||||
MONITOR_SERVICE
|
||||
.createClassificationCategoryReportBuilder()
|
||||
.withColumnHeaders(columnHeaders)
|
||||
.customAttributeFilterIn(customAttributeFilter)
|
||||
.customAttributeIn(TaskCustomField.CUSTOM_1, "Geschaeftsstelle A")
|
||||
.inWorkingDays()
|
||||
.buildReport();
|
||||
|
||||
|
|
@ -352,6 +349,50 @@ class ProvideClassificationCategoryReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(row3).isEqualTo(new int[] {1, 1, 2, 0, 2});
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
@Test
|
||||
void should_ReturnItemsOfCategoryReport_When_FilteringWithCustomAttributeNotIn()
|
||||
throws Exception {
|
||||
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
|
||||
|
||||
ClassificationCategoryReport report =
|
||||
MONITOR_SERVICE
|
||||
.createClassificationCategoryReportBuilder()
|
||||
.withColumnHeaders(columnHeaders)
|
||||
.customAttributeNotIn(TaskCustomField.CUSTOM_1, "Geschaeftsstelle A")
|
||||
.inWorkingDays()
|
||||
.buildReport();
|
||||
|
||||
assertThat(report).isNotNull();
|
||||
assertThat(report.rowSize()).isEqualTo(3);
|
||||
|
||||
int[] row1 = report.getRow("EXTERN").getCells();
|
||||
assertThat(row1).isEqualTo(new int[] {6, 5, 1, 3, 2});
|
||||
|
||||
int[] row2 = report.getRow("AUTOMATIC").getCells();
|
||||
assertThat(row2).isEqualTo(new int[] {1, 1, 0, 0, 2});
|
||||
|
||||
int[] row3 = report.getRow("MANUAL").getCells();
|
||||
assertThat(row3).isEqualTo(new int[] {1, 1, 0, 0, 2});
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
@Test
|
||||
void should_ReturnItemsOfCategoryReport_When_FilteringWithCustomAttributeLike() throws Exception {
|
||||
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
|
||||
|
||||
ClassificationCategoryReport report =
|
||||
MONITOR_SERVICE
|
||||
.createClassificationCategoryReportBuilder()
|
||||
.withColumnHeaders(columnHeaders)
|
||||
.customAttributeLike(TaskCustomField.CUSTOM_1, "%aeftsstelle A")
|
||||
.inWorkingDays()
|
||||
.buildReport();
|
||||
|
||||
assertThat(report).isNotNull();
|
||||
assertThat(report.rowSize()).isEqualTo(3);
|
||||
}
|
||||
|
||||
private List<TimeIntervalColumnHeader> getListOfColumnHeaders() {
|
||||
List<TimeIntervalColumnHeader> columnHeaders = new ArrayList<>();
|
||||
columnHeaders.add(new TimeIntervalColumnHeader(Integer.MIN_VALUE, -11));
|
||||
|
|
|
|||
|
|
@ -6,10 +6,8 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
|
|||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
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;
|
||||
|
|
@ -363,16 +361,15 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
|
|||
|
||||
@WithAccessId(user = "monitor")
|
||||
@Test
|
||||
void testEachItemOfClassificationReportWithCustomFieldValueFilter() throws Exception {
|
||||
Map<TaskCustomField, String> customAttributeFilter = new HashMap<>();
|
||||
customAttributeFilter.put(TaskCustomField.CUSTOM_1, "Geschaeftsstelle A");
|
||||
void should_ReturnItemsOfClassificationReport_When_FilteringWithCustomAttributeIn()
|
||||
throws Exception {
|
||||
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
|
||||
|
||||
ClassificationReport report =
|
||||
MONITOR_SERVICE
|
||||
.createClassificationReportBuilder()
|
||||
.withColumnHeaders(columnHeaders)
|
||||
.customAttributeFilterIn(customAttributeFilter)
|
||||
.customAttributeIn(TaskCustomField.CUSTOM_1, "Geschaeftsstelle A")
|
||||
.inWorkingDays()
|
||||
.buildReport();
|
||||
|
||||
|
|
@ -395,6 +392,57 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(row5).isEqualTo(new int[] {1, 2, 0, 2, 0});
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
@Test
|
||||
void should_ReturnItemsOfClassificationReport_When_FilteringWithCustomAttributeNotIn()
|
||||
throws Exception {
|
||||
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
|
||||
|
||||
ClassificationReport report =
|
||||
MONITOR_SERVICE
|
||||
.createClassificationReportBuilder()
|
||||
.withColumnHeaders(columnHeaders)
|
||||
.customAttributeNotIn(TaskCustomField.CUSTOM_1, "Geschaeftsstelle A")
|
||||
.inWorkingDays()
|
||||
.buildReport();
|
||||
|
||||
assertThat(report).isNotNull();
|
||||
assertThat(report.rowSize()).isEqualTo(5);
|
||||
|
||||
int[] row1 = report.getRow("L10000").getCells();
|
||||
assertThat(row1).isEqualTo(new int[] {3, 2, 1, 0, 0});
|
||||
|
||||
int[] row2 = report.getRow("L20000").getCells();
|
||||
assertThat(row2).isEqualTo(new int[] {1, 2, 0, 0, 0});
|
||||
|
||||
int[] row3 = report.getRow("L30000").getCells();
|
||||
assertThat(row3).isEqualTo(new int[] {1, 1, 0, 0, 2});
|
||||
|
||||
int[] row4 = report.getRow("L40000").getCells();
|
||||
assertThat(row4).isEqualTo(new int[] {1, 1, 0, 0, 2});
|
||||
|
||||
int[] row5 = report.getRow("L50000").getCells();
|
||||
assertThat(row5).isEqualTo(new int[] {2, 1, 0, 3, 2});
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
@Test
|
||||
void should_ReturnItemsOfClassificationReport_When_FilteringWithCustomAttributeLike()
|
||||
throws Exception {
|
||||
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
|
||||
|
||||
ClassificationReport report =
|
||||
MONITOR_SERVICE
|
||||
.createClassificationReportBuilder()
|
||||
.withColumnHeaders(columnHeaders)
|
||||
.customAttributeLike(TaskCustomField.CUSTOM_1, "_eschaeftsstelle A")
|
||||
.inWorkingDays()
|
||||
.buildReport();
|
||||
|
||||
assertThat(report).isNotNull();
|
||||
assertThat(report.rowSize()).isEqualTo(5);
|
||||
}
|
||||
|
||||
private List<TimeIntervalColumnHeader> getListOfColumnsHeaders() {
|
||||
List<TimeIntervalColumnHeader> columnHeaders = new ArrayList<>();
|
||||
columnHeaders.add(new TimeIntervalColumnHeader(Integer.MIN_VALUE, -11));
|
||||
|
|
|
|||
|
|
@ -6,10 +6,8 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
|
|||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
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;
|
||||
|
|
@ -592,15 +590,14 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
|
|||
|
||||
@WithAccessId(user = "monitor")
|
||||
@Test
|
||||
void testEachItemOfDetailedClassificationReportWithCustomFieldValueFilter() throws Exception {
|
||||
Map<TaskCustomField, String> customAttributeFilter = new HashMap<>();
|
||||
customAttributeFilter.put(TaskCustomField.CUSTOM_1, "Geschaeftsstelle A");
|
||||
void should_ReturnItemsOfDetailedClassificationReport_When_FilteringWithCustomAttributeIn()
|
||||
throws Exception {
|
||||
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
|
||||
|
||||
DetailedClassificationReport report =
|
||||
MONITOR_SERVICE
|
||||
.createClassificationReportBuilder()
|
||||
.customAttributeFilterIn(customAttributeFilter)
|
||||
.customAttributeIn(TaskCustomField.CUSTOM_1, "Geschaeftsstelle A")
|
||||
.inWorkingDays()
|
||||
.withColumnHeaders(columnHeaders)
|
||||
.buildDetailedReport();
|
||||
|
|
@ -648,6 +645,42 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(detailedLineNoAttachment5.getCells()).isEqualTo(new int[] {1, 2, 0, 2, 0});
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
@Test
|
||||
void should_ReturnItemsOfDetailedClassificationReport_When_FilteringWithCustomAttributeNotIn()
|
||||
throws Exception {
|
||||
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
|
||||
|
||||
DetailedClassificationReport report =
|
||||
MONITOR_SERVICE
|
||||
.createClassificationReportBuilder()
|
||||
.customAttributeNotIn(TaskCustomField.CUSTOM_1, "Geschaeftsstelle A")
|
||||
.inWorkingDays()
|
||||
.withColumnHeaders(columnHeaders)
|
||||
.buildDetailedReport();
|
||||
|
||||
assertThat(report).isNotNull();
|
||||
assertThat(report.rowSize()).isEqualTo(5);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
@Test
|
||||
void should_ReturnItemsOfDetailedClassificationReport_When_FilteringWithCustomAttributeLike()
|
||||
throws Exception {
|
||||
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
|
||||
|
||||
DetailedClassificationReport report =
|
||||
MONITOR_SERVICE
|
||||
.createClassificationReportBuilder()
|
||||
.customAttributeLike(TaskCustomField.CUSTOM_1, "%eftsstelle A")
|
||||
.inWorkingDays()
|
||||
.withColumnHeaders(columnHeaders)
|
||||
.buildDetailedReport();
|
||||
|
||||
assertThat(report).isNotNull();
|
||||
assertThat(report.rowSize()).isEqualTo(5);
|
||||
}
|
||||
|
||||
private List<TimeIntervalColumnHeader> getListOfColumnHeaders() {
|
||||
List<TimeIntervalColumnHeader> columnHeaders = new ArrayList<>();
|
||||
columnHeaders.add(new TimeIntervalColumnHeader(Integer.MIN_VALUE, -11));
|
||||
|
|
|
|||
|
|
@ -6,10 +6,8 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
|
|||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
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;
|
||||
|
|
@ -345,15 +343,14 @@ class ProvideTaskCustomFieldValueReportAccTest extends AbstractReportAccTest {
|
|||
|
||||
@WithAccessId(user = "monitor")
|
||||
@Test
|
||||
void testEachItemOfCustomFieldValueReportWithCustomFieldValueFilter() throws Exception {
|
||||
Map<TaskCustomField, String> customAttributeFilter = new HashMap<>();
|
||||
customAttributeFilter.put(TaskCustomField.CUSTOM_1, "Geschaeftsstelle A");
|
||||
void should_ReturnItemsOfCustomFieldValueReport_When_FilteringWithCustomAttributeIn()
|
||||
throws Exception {
|
||||
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
|
||||
|
||||
TaskCustomFieldValueReport report =
|
||||
MONITOR_SERVICE
|
||||
.createTaskCustomFieldValueReportBuilder(TaskCustomField.CUSTOM_1)
|
||||
.customAttributeFilterIn(customAttributeFilter)
|
||||
.customAttributeIn(TaskCustomField.CUSTOM_1, "Geschaeftsstelle A")
|
||||
.withColumnHeaders(columnHeaders)
|
||||
.inWorkingDays()
|
||||
.buildReport();
|
||||
|
|
@ -365,6 +362,42 @@ class ProvideTaskCustomFieldValueReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(row1).isEqualTo(new int[] {11, 4, 3, 4, 3});
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
@Test
|
||||
void should_ReturnItemsOfCustomFieldValueReport_When_FilteringWithCustomAttributeNotIn()
|
||||
throws Exception {
|
||||
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
|
||||
|
||||
TaskCustomFieldValueReport report =
|
||||
MONITOR_SERVICE
|
||||
.createTaskCustomFieldValueReportBuilder(TaskCustomField.CUSTOM_1)
|
||||
.customAttributeNotIn(TaskCustomField.CUSTOM_1, "Geschaeftsstelle A")
|
||||
.withColumnHeaders(columnHeaders)
|
||||
.inWorkingDays()
|
||||
.buildReport();
|
||||
|
||||
assertThat(report).isNotNull();
|
||||
assertThat(report.rowSize()).isEqualTo(2);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
@Test
|
||||
void should_ReturnItemsOfCustomFieldValueReport_When_FilteringWithCustomAttributeLike()
|
||||
throws Exception {
|
||||
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
|
||||
|
||||
TaskCustomFieldValueReport report =
|
||||
MONITOR_SERVICE
|
||||
.createTaskCustomFieldValueReportBuilder(TaskCustomField.CUSTOM_1)
|
||||
.customAttributeLike(TaskCustomField.CUSTOM_1, "%ftsstelle A")
|
||||
.withColumnHeaders(columnHeaders)
|
||||
.inWorkingDays()
|
||||
.buildReport();
|
||||
|
||||
assertThat(report).isNotNull();
|
||||
assertThat(report.rowSize()).isEqualTo(1);
|
||||
}
|
||||
|
||||
private List<TimeIntervalColumnHeader> getListOfColumnHeaders() {
|
||||
List<TimeIntervalColumnHeader> columnHeaders = new ArrayList<>();
|
||||
columnHeaders.add(new TimeIntervalColumnHeader(Integer.MIN_VALUE, -11));
|
||||
|
|
|
|||
|
|
@ -185,7 +185,7 @@ class ProvideTaskStatusReportAccTest extends AbstractReportAccTest {
|
|||
TaskState.TERMINATED))
|
||||
.buildReport();
|
||||
int[] summaryNumbers = report.getSumRow().getCells();
|
||||
assertThat(summaryNumbers.length).isEqualTo(5);
|
||||
assertThat(summaryNumbers).hasSize(5);
|
||||
assertThat(summaryNumbers[3]).isEqualTo(2); // number of cancelled tasks
|
||||
assertThat(summaryNumbers[4]).isEqualTo(3); // number of terminated tasks
|
||||
}
|
||||
|
|
|
|||
|
|
@ -6,10 +6,8 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
|
|||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
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;
|
||||
|
|
@ -313,16 +311,14 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
|
|||
|
||||
@WithAccessId(user = "monitor")
|
||||
@Test
|
||||
void testEachItemOfWorkbasketReportWithCustomFieldValueFilter() throws Exception {
|
||||
Map<TaskCustomField, String> customAttributeFilter = new HashMap<>();
|
||||
customAttributeFilter.put(TaskCustomField.CUSTOM_1, "Geschaeftsstelle A");
|
||||
void should_ReturnItemsOfWorkbasketReport_When_FilteringWithCustomAttributeIn() throws Exception {
|
||||
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
|
||||
|
||||
WorkbasketReport report =
|
||||
MONITOR_SERVICE
|
||||
.createWorkbasketReportBuilder()
|
||||
.withColumnHeaders(columnHeaders)
|
||||
.customAttributeFilterIn(customAttributeFilter)
|
||||
.customAttributeIn(TaskCustomField.CUSTOM_1, "Geschaeftsstelle A")
|
||||
.inWorkingDays()
|
||||
.buildReport();
|
||||
|
||||
|
|
@ -339,6 +335,51 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(row3).isEqualTo(new int[] {2, 1, 0, 0, 1});
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
@Test
|
||||
void should_ReturnItemsOfWorkbasketReport_When_FilteringWithCustomAttributeNotIn()
|
||||
throws Exception {
|
||||
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
|
||||
|
||||
WorkbasketReport report =
|
||||
MONITOR_SERVICE
|
||||
.createWorkbasketReportBuilder()
|
||||
.withColumnHeaders(columnHeaders)
|
||||
.customAttributeNotIn(TaskCustomField.CUSTOM_1, "Geschaeftsstelle A")
|
||||
.inWorkingDays()
|
||||
.buildReport();
|
||||
|
||||
assertThat(report).isNotNull();
|
||||
assertThat(report.rowSize()).isEqualTo(3);
|
||||
|
||||
int[] row1 = report.getRow("USER-1-1").getCells();
|
||||
assertThat(row1).isEqualTo(new int[] {7, 2, 0, 0, 1});
|
||||
|
||||
int[] row2 = report.getRow("USER-1-2").getCells();
|
||||
assertThat(row2).isEqualTo(new int[] {1, 4, 1, 3, 0});
|
||||
|
||||
int[] row3 = report.getRow("USER-1-3").getCells();
|
||||
assertThat(row3).isEqualTo(new int[] {0, 1, 0, 0, 5});
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
@Test
|
||||
void should_ReturnItemsOfWorkbasketReport_When_FilteringWithCustomAttributeLike()
|
||||
throws Exception {
|
||||
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
|
||||
|
||||
WorkbasketReport report =
|
||||
MONITOR_SERVICE
|
||||
.createWorkbasketReportBuilder()
|
||||
.withColumnHeaders(columnHeaders)
|
||||
.customAttributeLike(TaskCustomField.CUSTOM_1, "%ftsstelle A")
|
||||
.inWorkingDays()
|
||||
.buildReport();
|
||||
|
||||
assertThat(report).isNotNull();
|
||||
assertThat(report.rowSize()).isEqualTo(3);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
@Test
|
||||
void testEachItemOfWorkbasketReportForSelectedClassifications() throws Exception {
|
||||
|
|
|
|||
|
|
@ -366,7 +366,7 @@ class CallbackStateAccTest extends AbstractAccTest {
|
|||
.stateIn(TaskState.COMPLETED)
|
||||
.callbackStateIn(CallbackState.CALLBACK_PROCESSING_REQUIRED)
|
||||
.count();
|
||||
assertThat(numOfTasksRemaining).isEqualTo(0);
|
||||
assertThat(numOfTasksRemaining).isZero();
|
||||
}
|
||||
|
||||
private TaskImpl createTask(TaskService taskService, CallbackState callbackState)
|
||||
|
|
|
|||
|
|
@ -551,7 +551,7 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
|
|||
.orElse(null);
|
||||
assertThat(updatedAttachment).isNotNull();
|
||||
assertThat(updatedTask.getModified()).isEqualTo(updatedAttachment.getModified());
|
||||
assertThat(updatedAttachment.getCustomAttributeMap().get("TEST_KEY")).isEqualTo("TEST_VALUE");
|
||||
assertThat(updatedAttachment.getCustomAttributeMap()).containsEntry("TEST_KEY", "TEST_VALUE");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
|
|
|
|||
|
|
@ -51,8 +51,7 @@ class CreateWorkbasketAccTest extends AbstractAccTest {
|
|||
assertThat(after).isEqualTo(before + 1);
|
||||
Workbasket createdWorkbasket = workbasketService.getWorkbasket("NT1234", "DOMAIN_A");
|
||||
assertThat(createdWorkbasket).isNotNull();
|
||||
assertThat(createdWorkbasket.getId()).isNotNull();
|
||||
assertThat(createdWorkbasket.getId().startsWith("WBI")).isTrue();
|
||||
assertThat(createdWorkbasket.getId()).startsWith("WBI");
|
||||
assertThat(createdWorkbasket).isEqualTo(workbasket);
|
||||
Workbasket createdWorkbasket2 = workbasketService.getWorkbasket(createdWorkbasket.getId());
|
||||
assertThat(createdWorkbasket).isNotNull();
|
||||
|
|
|
|||
|
|
@ -25,17 +25,12 @@ import pro.taskana.workbasket.api.models.WorkbasketAccessItem;
|
|||
@ExtendWith(JaasExtension.class)
|
||||
class QueryWorkbasketAccessItemsAccTest extends AbstractAccTest {
|
||||
|
||||
QueryWorkbasketAccessItemsAccTest() {
|
||||
super();
|
||||
}
|
||||
|
||||
@WithAccessId(user = "businessadmin")
|
||||
@Test
|
||||
void testQueryWorkbasketAccessItemValuesForColumnName() throws Exception {
|
||||
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
|
||||
List<String> columnValueList =
|
||||
workbasketService.createWorkbasketAccessItemQuery().listValues(WORKBASKET_ID, null);
|
||||
assertThat(columnValueList).isNotNull();
|
||||
assertThat(columnValueList).hasSize(24);
|
||||
|
||||
columnValueList =
|
||||
|
|
|
|||
|
|
@ -3,7 +3,6 @@ package acceptance.workbasket;
|
|||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
import acceptance.AbstractAccTest;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.api.extension.ExtendWith;
|
||||
|
|
@ -17,20 +16,19 @@ import pro.taskana.workbasket.api.models.WorkbasketAccessItem;
|
|||
@ExtendWith(JaasExtension.class)
|
||||
class UpdateWorkbasketAuthorizations2AccTest extends AbstractAccTest {
|
||||
|
||||
private static final WorkbasketService WORKBASKET_SERVICE = taskanaEngine.getWorkbasketService();
|
||||
|
||||
@WithAccessId(user = "businessadmin")
|
||||
@Test
|
||||
void testUpdatedAccessItemListToEmptyList() throws Exception {
|
||||
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
|
||||
final String wbId = "WBI:100000000000000000000000000000000004";
|
||||
List<WorkbasketAccessItem> accessItems = workbasketService.getWorkbasketAccessItems(wbId);
|
||||
int countBefore = accessItems.size();
|
||||
assertThat(countBefore).isEqualTo(3);
|
||||
List<WorkbasketAccessItem> accessItems = WORKBASKET_SERVICE.getWorkbasketAccessItems(wbId);
|
||||
assertThat(accessItems).hasSize(3);
|
||||
|
||||
workbasketService.setWorkbasketAccessItems(wbId, new ArrayList<>());
|
||||
WORKBASKET_SERVICE.setWorkbasketAccessItems(wbId, List.of());
|
||||
|
||||
List<WorkbasketAccessItem> updatedAccessItems =
|
||||
workbasketService.getWorkbasketAccessItems(wbId);
|
||||
int countAfter = updatedAccessItems.size();
|
||||
assertThat(countAfter).isEqualTo(0);
|
||||
WORKBASKET_SERVICE.getWorkbasketAccessItems(wbId);
|
||||
assertThat(updatedAccessItems).isEmpty();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -137,10 +137,13 @@ include::{snippets}/WorkbasketAccessItemControllerRestDocTest/removeWorkbasketAc
|
|||
|
||||
== Monitoring Resources
|
||||
|
||||
include::{snippets}/MonitorControllerRestDocTest/getTaskStatusReportDocTest/auto-section.adoc[]
|
||||
include::{snippets}/MonitorControllerRestDocTest/getWorkbasketReportDocTest/auto-section.adoc[]
|
||||
include::{snippets}/MonitorControllerRestDocTest/getClassificationReportDocTest/auto-section.adoc[]
|
||||
include::{snippets}/MonitorControllerRestDocTest/getTimestampReportDocTest/auto-section.adoc[]
|
||||
include::{snippets}/MonitorControllerRestDocTest/computeWorkbasketReportDocTest/auto-section.adoc[]
|
||||
include::{snippets}/MonitorControllerRestDocTest/computeClassificationCategoryReportDocTest/auto-section.adoc[]
|
||||
include::{snippets}/MonitorControllerRestDocTest/computeClassificationReportDocTest/auto-section.adoc[]
|
||||
include::{snippets}/MonitorControllerRestDocTest/computeDetailedClassificationReportDocTest/auto-section.adoc[]
|
||||
include::{snippets}/MonitorControllerRestDocTest/computeTaskCustomFieldValueReportDocTest/auto-section.adoc[]
|
||||
include::{snippets}/MonitorControllerRestDocTest/computeTaskStatusReportDocTest/auto-section.adoc[]
|
||||
include::{snippets}/MonitorControllerRestDocTest/computeTimestampReportDocTest/auto-section.adoc[]
|
||||
|
||||
== Access Id Resource
|
||||
|
||||
|
|
|
|||
|
|
@ -87,9 +87,9 @@ public class ClassificationController {
|
|||
QueryPagingParameter.class);
|
||||
|
||||
final ClassificationQuery query = classificationService.createClassificationQuery();
|
||||
filterParameter.applyToQuery(query);
|
||||
sortParameter.applyToQuery(query);
|
||||
List<ClassificationSummary> classificationSummaries = pagingParameter.applyToQuery(query);
|
||||
filterParameter.apply(query);
|
||||
sortParameter.apply(query);
|
||||
List<ClassificationSummary> classificationSummaries = pagingParameter.apply(query);
|
||||
|
||||
return ResponseEntity.ok(
|
||||
summaryModelAssembler.toPagedModel(
|
||||
|
|
|
|||
|
|
@ -159,7 +159,7 @@ public class ClassificationQueryFilterParameter
|
|||
}
|
||||
|
||||
@Override
|
||||
public Void applyToQuery(ClassificationQuery query) {
|
||||
public Void apply(ClassificationQuery query) {
|
||||
Optional.ofNullable(name).ifPresent(query::nameIn);
|
||||
Optional.ofNullable(nameLike).map(this::wrapElementsInLikeStatement).ifPresent(query::nameLike);
|
||||
Optional.ofNullable(key).ifPresent(query::keyIn);
|
||||
|
|
|
|||
|
|
@ -39,7 +39,7 @@ public class QueryPagingParameter<T, Q extends BaseQuery<T, ?>>
|
|||
}
|
||||
|
||||
@Override
|
||||
public List<T> applyToQuery(Q query) {
|
||||
public List<T> apply(Q query) {
|
||||
initPageMetaData(query);
|
||||
List<T> resultList;
|
||||
if (pageMetadata != null) {
|
||||
|
|
|
|||
|
|
@ -5,12 +5,11 @@ import java.util.ArrayList;
|
|||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
|
||||
import pro.taskana.common.api.BaseQuery;
|
||||
import pro.taskana.common.api.TimeInterval;
|
||||
|
||||
public interface QueryParameter<Q extends BaseQuery<?, ?>, R> {
|
||||
public interface QueryParameter<E, R> {
|
||||
|
||||
R applyToQuery(Q query);
|
||||
R apply(E entity);
|
||||
|
||||
default String[] wrapElementsInLikeStatement(String[] list) {
|
||||
return Arrays.stream(list).map(item -> "%" + item + "%").toArray(String[]::new);
|
||||
|
|
|
|||
|
|
@ -35,7 +35,7 @@ public class QuerySortParameter<Q extends BaseQuery<?, ?>, S extends QuerySortBy
|
|||
}
|
||||
|
||||
@Override
|
||||
public Void applyToQuery(Q query) {
|
||||
public Void apply(Q query) {
|
||||
if (sortBy != null) {
|
||||
for (int i = 0; i < sortBy.size(); i++) {
|
||||
SortDirection sortDirection =
|
||||
|
|
@ -49,7 +49,7 @@ public class QuerySortParameter<Q extends BaseQuery<?, ?>, S extends QuerySortBy
|
|||
// this method is only static because there exists no query for the task comment entity
|
||||
public static <T> void verifyAmountOfSortByAndOrderByMatches(
|
||||
List<T> sortBy, List<SortDirection> order) throws InvalidArgumentException {
|
||||
if (sortBy != null && order != null && sortBy.size() != order.size() && order.size() > 0) {
|
||||
if (sortBy != null && order != null && sortBy.size() != order.size() && !order.isEmpty()) {
|
||||
throw new InvalidArgumentException(
|
||||
"The amount of 'sort-by' and 'order' does not match. "
|
||||
+ "Please specify an 'order' for each 'sort-by' or no 'order' parameters at all.");
|
||||
|
|
|
|||
|
|
@ -55,14 +55,16 @@ public final class RestEndpoints {
|
|||
public static final String URL_TASK_COMMENT = API_V1 + "tasks/comments/{taskCommentId}";
|
||||
|
||||
// monitor endpoints
|
||||
public static final String URL_MONITOR_TASKS_STATUS_REPORT =
|
||||
API_V1 + "monitor/tasks-status-report";
|
||||
public static final String URL_MONITOR_TASKS_WORKBASKET_REPORT =
|
||||
API_V1 + "monitor/tasks-workbasket-report";
|
||||
public static final String URL_MONITOR_TASKS_WORKBASKET_PLANNED_REPORT =
|
||||
API_V1 + "monitor/tasks-workbasket-planned-date-report";
|
||||
public static final String URL_MONITOR_TASKS_CLASSIFICATION_REPORT =
|
||||
API_V1 + "monitor/tasks-classification-report";
|
||||
public static final String URL_MONITOR_WORKBASKET_REPORT = API_V1 + "monitor/workbasket-report";
|
||||
public static final String URL_MONITOR_CLASSIFICATION_CATEGORY_REPORT =
|
||||
API_V1 + "monitor/classification-category-report";
|
||||
public static final String URL_MONITOR_CLASSIFICATION_REPORT =
|
||||
API_V1 + "monitor/classification-report";
|
||||
public static final String URL_MONITOR_DETAILED_CLASSIFICATION_REPORT =
|
||||
API_V1 + "monitor/detailed-classification-report";
|
||||
public static final String URL_MONITOR_TASK_CUSTOM_FIELD_VALUE_REPORT =
|
||||
API_V1 + "monitor/task-custom-field-value-report";
|
||||
public static final String URL_MONITOR_TASK_STATUS_REPORT = API_V1 + "monitor/task-status-report";
|
||||
public static final String URL_MONITOR_TIMESTAMP_REPORT = API_V1 + "monitor/timestamp-report";
|
||||
|
||||
private RestEndpoints() {}
|
||||
|
|
|
|||
|
|
@ -1,10 +1,8 @@
|
|||
package pro.taskana.monitor.rest;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
import java.util.stream.Collectors;
|
||||
import java.util.stream.IntStream;
|
||||
import java.util.stream.Stream;
|
||||
import java.util.Optional;
|
||||
import org.springframework.beans.factory.annotation.Autowired;
|
||||
import org.springframework.hateoas.config.EnableHypermediaSupport;
|
||||
import org.springframework.http.HttpStatus;
|
||||
|
|
@ -19,9 +17,14 @@ import pro.taskana.common.api.exceptions.NotAuthorizedException;
|
|||
import pro.taskana.common.rest.RestEndpoints;
|
||||
import pro.taskana.monitor.api.MonitorService;
|
||||
import pro.taskana.monitor.api.TaskTimestamp;
|
||||
import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
|
||||
import pro.taskana.monitor.api.reports.ClassificationCategoryReport;
|
||||
import pro.taskana.monitor.api.reports.ClassificationReport;
|
||||
import pro.taskana.monitor.api.reports.TaskCustomFieldValueReport;
|
||||
import pro.taskana.monitor.api.reports.TimestampReport;
|
||||
import pro.taskana.monitor.api.reports.WorkbasketReport;
|
||||
import pro.taskana.monitor.rest.assembler.ReportRepresentationModelAssembler;
|
||||
import pro.taskana.monitor.rest.models.ReportRepresentationModel;
|
||||
import pro.taskana.task.api.TaskCustomField;
|
||||
import pro.taskana.task.api.TaskState;
|
||||
|
||||
/** Controller for all monitoring endpoints. */
|
||||
|
|
@ -41,24 +44,199 @@ public class MonitorController {
|
|||
this.reportRepresentationModelAssembler = reportRepresentationModelAssembler;
|
||||
}
|
||||
|
||||
/**
|
||||
* This endpoint generates a Workbasket Report.
|
||||
*
|
||||
* <p>Each Row represents a Workbasket.
|
||||
*
|
||||
* <p>Each Column Header represents a Time Interval.
|
||||
*
|
||||
* @title Compute a Workbasket Report
|
||||
* @param filterParameter the filter parameters
|
||||
* @param taskTimestamp determine which Task Timestamp should be used for comparison
|
||||
* @return the computed Report
|
||||
* @throws NotAuthorizedException if the current user is not authorized to compute the Report
|
||||
* @throws InvalidArgumentException TODO: this is never thrown ...
|
||||
*/
|
||||
@GetMapping(path = RestEndpoints.URL_MONITOR_WORKBASKET_REPORT)
|
||||
@Transactional(readOnly = true, rollbackFor = Exception.class)
|
||||
public ResponseEntity<ReportRepresentationModel> computeWorkbasketReport(
|
||||
TimeIntervalReportFilterParameter filterParameter,
|
||||
@RequestParam(name = "task-timestamp", required = false) TaskTimestamp taskTimestamp)
|
||||
throws NotAuthorizedException, InvalidArgumentException {
|
||||
if (taskTimestamp == null) {
|
||||
taskTimestamp = TaskTimestamp.DUE;
|
||||
}
|
||||
|
||||
WorkbasketReport.Builder builder = monitorService.createWorkbasketReportBuilder();
|
||||
filterParameter.apply(builder);
|
||||
|
||||
ReportRepresentationModel report =
|
||||
reportRepresentationModelAssembler.toModel(
|
||||
builder.buildReport(taskTimestamp), filterParameter, taskTimestamp);
|
||||
|
||||
return ResponseEntity.status(HttpStatus.OK).body(report);
|
||||
}
|
||||
|
||||
/**
|
||||
* This endpoint generates a Classification Category Report
|
||||
*
|
||||
* <p>Each Row represents a Classification category.
|
||||
*
|
||||
* <p>Each Column Header represents a Time Interval.
|
||||
*
|
||||
* @title Compute a Classification Category Report
|
||||
* @param filterParameter the filter parameters
|
||||
* @param taskTimestamp determine which Task Timestamp should be used for comparison
|
||||
* @return the computed Report
|
||||
* @throws NotAuthorizedException if the current user is not authorized to compute the Report
|
||||
* @throws InvalidArgumentException TODO: this is never thrown ...
|
||||
*/
|
||||
@GetMapping(path = RestEndpoints.URL_MONITOR_CLASSIFICATION_CATEGORY_REPORT)
|
||||
@Transactional(readOnly = true, rollbackFor = Exception.class)
|
||||
public ResponseEntity<ReportRepresentationModel> computeClassificationCategoryReport(
|
||||
TimeIntervalReportFilterParameter filterParameter,
|
||||
@RequestParam(name = "task-timestamp", required = false) TaskTimestamp taskTimestamp)
|
||||
throws InvalidArgumentException, NotAuthorizedException {
|
||||
if (taskTimestamp == null) {
|
||||
taskTimestamp = TaskTimestamp.DUE;
|
||||
}
|
||||
|
||||
ClassificationCategoryReport.Builder builder =
|
||||
monitorService.createClassificationCategoryReportBuilder();
|
||||
filterParameter.apply(builder);
|
||||
|
||||
ReportRepresentationModel report =
|
||||
reportRepresentationModelAssembler.toModel(
|
||||
builder.buildReport(taskTimestamp), filterParameter, taskTimestamp);
|
||||
|
||||
return ResponseEntity.status(HttpStatus.OK).body(report);
|
||||
}
|
||||
|
||||
/**
|
||||
* This endpoint generates a Classification Report.
|
||||
*
|
||||
* <p>Each Row represents a Classification.
|
||||
*
|
||||
* <p>Each Column Header represents a Time Interval.
|
||||
*
|
||||
* @title Compute a Classification Report
|
||||
* @param filterParameter the filter parameters
|
||||
* @param taskTimestamp determine which Task Timestamp should be used for comparison
|
||||
* @return the computed Report
|
||||
* @throws NotAuthorizedException if the current user is not authorized to compute the Report
|
||||
* @throws InvalidArgumentException TODO: this is never thrown
|
||||
*/
|
||||
@GetMapping(path = RestEndpoints.URL_MONITOR_CLASSIFICATION_REPORT)
|
||||
@Transactional(readOnly = true, rollbackFor = Exception.class)
|
||||
public ResponseEntity<ReportRepresentationModel> computeClassificationReport(
|
||||
TimeIntervalReportFilterParameter filterParameter,
|
||||
@RequestParam(name = "task-timestamp", required = false) TaskTimestamp taskTimestamp)
|
||||
throws NotAuthorizedException, InvalidArgumentException {
|
||||
if (taskTimestamp == null) {
|
||||
taskTimestamp = TaskTimestamp.DUE;
|
||||
}
|
||||
|
||||
ClassificationReport.Builder builder = monitorService.createClassificationReportBuilder();
|
||||
filterParameter.apply(builder);
|
||||
|
||||
ReportRepresentationModel report =
|
||||
reportRepresentationModelAssembler.toModel(
|
||||
builder.buildReport(taskTimestamp), filterParameter, taskTimestamp);
|
||||
|
||||
return ResponseEntity.status(HttpStatus.OK).body(report);
|
||||
}
|
||||
|
||||
/**
|
||||
* This endpoint generates a Detailed Classification Report.
|
||||
*
|
||||
* <p>Each Foldable Row represents a Classification and can be expanded to show the Classification
|
||||
* of Attachments.
|
||||
*
|
||||
* <p>Each Column Header represents a Time Interval.
|
||||
*
|
||||
* @title Compute a Detailed Classification Report
|
||||
* @param filterParameter the filter parameters
|
||||
* @param taskTimestamp determine which Task Timestamp should be used for comparison
|
||||
* @return the computed Report
|
||||
* @throws NotAuthorizedException if the current user is not authorized to compute the Report
|
||||
* @throws InvalidArgumentException TODO: this is never thrown
|
||||
*/
|
||||
@GetMapping(path = RestEndpoints.URL_MONITOR_DETAILED_CLASSIFICATION_REPORT)
|
||||
@Transactional(readOnly = true, rollbackFor = Exception.class)
|
||||
public ResponseEntity<ReportRepresentationModel> computeDetailedClassificationReport(
|
||||
TimeIntervalReportFilterParameter filterParameter,
|
||||
@RequestParam(name = "task-timestamp", required = false) TaskTimestamp taskTimestamp)
|
||||
throws NotAuthorizedException, InvalidArgumentException {
|
||||
if (taskTimestamp == null) {
|
||||
taskTimestamp = TaskTimestamp.DUE;
|
||||
}
|
||||
|
||||
ClassificationReport.Builder builder = monitorService.createClassificationReportBuilder();
|
||||
filterParameter.apply(builder);
|
||||
|
||||
ReportRepresentationModel report =
|
||||
reportRepresentationModelAssembler.toModel(
|
||||
builder.buildDetailedReport(taskTimestamp), filterParameter, taskTimestamp);
|
||||
|
||||
return ResponseEntity.status(HttpStatus.OK).body(report);
|
||||
}
|
||||
|
||||
/**
|
||||
* This endpoint generates a Task Custom Field Value Report.
|
||||
*
|
||||
* <p>Each Row represents a value of the requested Task Custom Field.
|
||||
*
|
||||
* <p>Each Column Header represents a Time Interval
|
||||
*
|
||||
* @title Compute a Detailed Classification Report
|
||||
* @param customField the Task Custom Field whose values are of interest
|
||||
* @param filterParameter the filter parameters
|
||||
* @param taskTimestamp determine which Task Timestamp should be used for comparison
|
||||
* @return the computed Report
|
||||
* @throws NotAuthorizedException if the current user is not authorized to compute the Report
|
||||
* @throws InvalidArgumentException TODO: this is never thrown
|
||||
*/
|
||||
@GetMapping(path = RestEndpoints.URL_MONITOR_TASK_CUSTOM_FIELD_VALUE_REPORT)
|
||||
@Transactional(readOnly = true, rollbackFor = Exception.class)
|
||||
public ResponseEntity<ReportRepresentationModel> computeTaskCustomFieldValueReport(
|
||||
@RequestParam(name = "custom-field") TaskCustomField customField,
|
||||
TimeIntervalReportFilterParameter filterParameter,
|
||||
@RequestParam(name = "task-timestamp", required = false) TaskTimestamp taskTimestamp)
|
||||
throws NotAuthorizedException, InvalidArgumentException {
|
||||
if (taskTimestamp == null) {
|
||||
taskTimestamp = TaskTimestamp.DUE;
|
||||
}
|
||||
|
||||
TaskCustomFieldValueReport.Builder builder =
|
||||
monitorService.createTaskCustomFieldValueReportBuilder(customField);
|
||||
filterParameter.apply(builder);
|
||||
|
||||
ReportRepresentationModel report =
|
||||
reportRepresentationModelAssembler.toModel(
|
||||
builder.buildReport(taskTimestamp), customField, filterParameter, taskTimestamp);
|
||||
|
||||
return ResponseEntity.status(HttpStatus.OK).body(report);
|
||||
}
|
||||
|
||||
/**
|
||||
* This endpoint generates a Task Status Report.
|
||||
*
|
||||
* <p>A Task Status Report contains the total number of tasks, clustered in their Task States and
|
||||
* grouped by Workbaskets. Each row represents a Workbasket while each column represents a Task
|
||||
* State.
|
||||
* <p>Each Row represents a Workbasket.
|
||||
*
|
||||
* @title Get a Task Status Report
|
||||
* <p>Each Column Header represents a Task State
|
||||
*
|
||||
* @title Compute a Task Status Report
|
||||
* @param domains Filter the report values by domains.
|
||||
* @param states Filter the report values by Task states.
|
||||
* @param workbasketIds Filter the report values by Workbasket Ids.
|
||||
* @param priorityMinimum Filter the report values by a minimum priority.
|
||||
* @return the computed TaskStatusReport
|
||||
* @throws NotAuthorizedException if the current user is not authorized to compute the report
|
||||
* @return the computed Report
|
||||
* @throws NotAuthorizedException if the current user is not authorized to compute the Report
|
||||
*/
|
||||
@GetMapping(path = RestEndpoints.URL_MONITOR_TASKS_STATUS_REPORT)
|
||||
@GetMapping(path = RestEndpoints.URL_MONITOR_TASK_STATUS_REPORT)
|
||||
@Transactional(readOnly = true, rollbackFor = Exception.class)
|
||||
public ResponseEntity<ReportRepresentationModel> getTaskStatusReport(
|
||||
public ResponseEntity<ReportRepresentationModel> computeTaskStatusReport(
|
||||
@RequestParam(required = false) List<String> domains,
|
||||
@RequestParam(required = false) List<TaskState> states,
|
||||
@RequestParam(name = "workbasket-ids", required = false) List<String> workbasketIds,
|
||||
|
|
@ -80,144 +258,36 @@ public class MonitorController {
|
|||
priorityMinimum));
|
||||
}
|
||||
|
||||
/**
|
||||
* This endpoint generates a Workbasket Report.
|
||||
*
|
||||
* <p>A WorkbasketReport contains the total numbers of tasks, clustered by the a Task Timestamp
|
||||
* date range and grouped by Workbaskets. Each row represents a Workbasket while each column
|
||||
* represents a date range.
|
||||
*
|
||||
* @title Get a Workbasket Report
|
||||
* @param states Filter the report by task states
|
||||
* @param taskTimestamp determine which task timestamp should be used for comparison
|
||||
* @return the computed report
|
||||
* @throws NotAuthorizedException if the current user is not authorized to compute the report
|
||||
* @throws InvalidArgumentException TODO: this is never thrown ...
|
||||
*/
|
||||
@GetMapping(path = RestEndpoints.URL_MONITOR_TASKS_WORKBASKET_REPORT)
|
||||
@Transactional(readOnly = true, rollbackFor = Exception.class)
|
||||
public ResponseEntity<ReportRepresentationModel> getWorkbasketReport(
|
||||
@RequestParam List<TaskState> states,
|
||||
@RequestParam(required = false) TaskTimestamp taskTimestamp)
|
||||
throws NotAuthorizedException, InvalidArgumentException {
|
||||
if (taskTimestamp == null) {
|
||||
taskTimestamp = TaskTimestamp.DUE;
|
||||
}
|
||||
|
||||
ReportRepresentationModel report =
|
||||
reportRepresentationModelAssembler.toModel(
|
||||
monitorService
|
||||
.createWorkbasketReportBuilder()
|
||||
.withColumnHeaders(getRangeTimeInterval())
|
||||
.stateIn(states)
|
||||
.buildReport(taskTimestamp),
|
||||
states,
|
||||
taskTimestamp);
|
||||
|
||||
return ResponseEntity.status(HttpStatus.OK).body(report);
|
||||
}
|
||||
|
||||
@GetMapping(path = RestEndpoints.URL_MONITOR_TASKS_WORKBASKET_PLANNED_REPORT)
|
||||
@Transactional(readOnly = true, rollbackFor = Exception.class)
|
||||
// TODO: remove this endpoint and replace with general endpoint.
|
||||
public ResponseEntity<ReportRepresentationModel> getTasksWorkbasketPlannedDateReport(
|
||||
@RequestParam(value = "daysInPast") int daysInPast,
|
||||
@RequestParam(value = "states") List<TaskState> states)
|
||||
throws NotAuthorizedException, InvalidArgumentException {
|
||||
ReportRepresentationModel report =
|
||||
reportRepresentationModelAssembler.toModel(
|
||||
monitorService
|
||||
.createWorkbasketReportBuilder()
|
||||
.stateIn(states)
|
||||
.withColumnHeaders(getDateTimeInterval(daysInPast))
|
||||
.buildReport(TaskTimestamp.PLANNED),
|
||||
daysInPast,
|
||||
states);
|
||||
|
||||
return ResponseEntity.status(HttpStatus.OK).body(report);
|
||||
}
|
||||
|
||||
/**
|
||||
* This endpoint generates a Classification Report.
|
||||
*
|
||||
* <p>A Classification Report contains the total numbers of tasks, clustered by the Task Timestamp
|
||||
* date range and grouped by Classifications. Each row represents a Classification while each
|
||||
* column represents a date range.
|
||||
*
|
||||
* @title Get a Classification Report
|
||||
* @param taskTimestamp determine which Task Timestamp should be used for comparison
|
||||
* @return the computed report
|
||||
* @throws NotAuthorizedException if the current user is not authorized to compute the report
|
||||
* @throws InvalidArgumentException TODO: this is never thrown
|
||||
*/
|
||||
@GetMapping(path = RestEndpoints.URL_MONITOR_TASKS_CLASSIFICATION_REPORT)
|
||||
@Transactional(readOnly = true, rollbackFor = Exception.class)
|
||||
public ResponseEntity<ReportRepresentationModel> getClassificationReport(
|
||||
@RequestParam(required = false) TaskTimestamp taskTimestamp)
|
||||
throws NotAuthorizedException, InvalidArgumentException {
|
||||
if (taskTimestamp == null) {
|
||||
taskTimestamp = TaskTimestamp.DUE;
|
||||
}
|
||||
|
||||
ReportRepresentationModel report =
|
||||
reportRepresentationModelAssembler.toModel(
|
||||
monitorService
|
||||
.createClassificationReportBuilder()
|
||||
.withColumnHeaders(getRangeTimeInterval())
|
||||
.buildReport(taskTimestamp),
|
||||
taskTimestamp);
|
||||
|
||||
return ResponseEntity.status(HttpStatus.OK).body(report);
|
||||
}
|
||||
|
||||
/**
|
||||
* This endpoint generates a Timestamp Report.
|
||||
*
|
||||
* <p>A Timestamp Report contains the total number of tasks, clustered by date range and grouped
|
||||
* by its Task Status. Each row represents a Task Status while each column represents a date
|
||||
* range. Each row can be expanded to further group the tasks by their Org Level (1-4)
|
||||
* <p>Each Foldable Row represents a TaskTimestamp and can be expanded to display the four
|
||||
* organization levels of the corresponding Workbasket.
|
||||
*
|
||||
* <p>Each Column Header represents a TimeInterval.
|
||||
*
|
||||
* @title Get a Timestamp Report
|
||||
* @param filterParameter the filter parameter
|
||||
* @param timestamps Filter by the Task Timestamp of the task
|
||||
* @return the computed report
|
||||
* @throws NotAuthorizedException if the current user is not authorized to compute the report
|
||||
* @throws InvalidArgumentException TODO: this is never thrown
|
||||
*/
|
||||
@GetMapping(path = RestEndpoints.URL_MONITOR_TIMESTAMP_REPORT)
|
||||
@Transactional(readOnly = true, rollbackFor = Exception.class)
|
||||
public ResponseEntity<ReportRepresentationModel> getTimestampReport()
|
||||
public ResponseEntity<ReportRepresentationModel> computeTimestampReport(
|
||||
TimeIntervalReportFilterParameter filterParameter,
|
||||
@RequestParam(name = "task-timestamp", required = false) TaskTimestamp[] timestamps)
|
||||
throws NotAuthorizedException, InvalidArgumentException {
|
||||
List<TimeIntervalColumnHeader> columnHeaders =
|
||||
IntStream.range(-14, 0)
|
||||
.mapToObj(TimeIntervalColumnHeader.Date::new)
|
||||
.collect(Collectors.toList());
|
||||
return ResponseEntity.status(HttpStatus.OK)
|
||||
.body(
|
||||
reportRepresentationModelAssembler.toModel(
|
||||
monitorService
|
||||
.createTimestampReportBuilder()
|
||||
.withColumnHeaders(columnHeaders)
|
||||
.buildReport()));
|
||||
}
|
||||
|
||||
private List<TimeIntervalColumnHeader> getRangeTimeInterval() {
|
||||
return Stream.concat(
|
||||
Stream.concat(
|
||||
Stream.of(
|
||||
new TimeIntervalColumnHeader.Range(Integer.MIN_VALUE, -10),
|
||||
new TimeIntervalColumnHeader.Range(-10, -5)),
|
||||
Stream.of(-4, -3, -2, -1, 0, 1, 2, 3, 4).map(TimeIntervalColumnHeader.Range::new)),
|
||||
Stream.of(
|
||||
new TimeIntervalColumnHeader.Range(5, 10),
|
||||
new TimeIntervalColumnHeader.Range(10, Integer.MAX_VALUE)))
|
||||
.collect(Collectors.toList());
|
||||
}
|
||||
TimestampReport.Builder builder = monitorService.createTimestampReportBuilder();
|
||||
filterParameter.apply(builder);
|
||||
Optional.ofNullable(timestamps).map(Arrays::asList).ifPresent(builder::withTimestamps);
|
||||
|
||||
private List<TimeIntervalColumnHeader> getDateTimeInterval(int daysInPast) {
|
||||
ReportRepresentationModel report =
|
||||
reportRepresentationModelAssembler.toModel(
|
||||
builder.buildReport(), filterParameter, timestamps);
|
||||
|
||||
List<TimeIntervalColumnHeader> columnHeaders = new ArrayList<>();
|
||||
for (int i = 0; i <= daysInPast; i++) {
|
||||
columnHeaders.add(new TimeIntervalColumnHeader.Date(i - daysInPast));
|
||||
}
|
||||
return columnHeaders;
|
||||
return ResponseEntity.status(HttpStatus.OK).body(report);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,580 @@
|
|||
package pro.taskana.monitor.rest;
|
||||
|
||||
import static pro.taskana.common.internal.util.CheckedConsumer.wrap;
|
||||
|
||||
import com.fasterxml.jackson.annotation.JsonProperty;
|
||||
import java.beans.ConstructorProperties;
|
||||
import java.util.Arrays;
|
||||
import java.util.Comparator;
|
||||
import java.util.List;
|
||||
import java.util.Optional;
|
||||
import java.util.stream.Collectors;
|
||||
import java.util.stream.Stream;
|
||||
|
||||
import pro.taskana.common.internal.util.Pair;
|
||||
import pro.taskana.common.rest.QueryParameter;
|
||||
import pro.taskana.monitor.api.reports.TimeIntervalReportBuilder;
|
||||
import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
|
||||
import pro.taskana.task.api.TaskCustomField;
|
||||
import pro.taskana.task.api.TaskState;
|
||||
|
||||
public class TimeIntervalReportFilterParameter
|
||||
implements QueryParameter<TimeIntervalReportBuilder<?, ?, TimeIntervalColumnHeader>, Void> {
|
||||
|
||||
/** Determine weather the report should convert the age of the tasks into working days. */
|
||||
@JsonProperty("in-working-days")
|
||||
private final Boolean inWorkingDays;
|
||||
|
||||
/** Filter by workbasket id of the task. This is an exact match. */
|
||||
@JsonProperty("workbasket-id")
|
||||
private final String[] workbasketId;
|
||||
|
||||
/** Filter by the task state. This is an exact match. */
|
||||
@JsonProperty("state")
|
||||
private final TaskState[] state;
|
||||
|
||||
/** Filter by the classification category of the task. This is an exact match. */
|
||||
@JsonProperty("classification-category")
|
||||
private final String[] classificationCategory;
|
||||
|
||||
/** Filter by domain of the task. This is an exact match. */
|
||||
@JsonProperty("domain")
|
||||
private final String[] domain;
|
||||
|
||||
/** Filter by the classification id of the task. This is an exact match. */
|
||||
@JsonProperty("classification-id")
|
||||
private final String[] classificationId;
|
||||
|
||||
/** Filter by the classification id of the task. This is an exact match. */
|
||||
@JsonProperty("excluded-classification-id")
|
||||
private final String[] excludedClassificationId;
|
||||
|
||||
/** Filter by the value of the field custom1 of the task. This is an exact match. */
|
||||
@JsonProperty("custom-1")
|
||||
private final String[] custom1;
|
||||
|
||||
/**
|
||||
* Filter by the custom1 field of the task. This results in a substring search (% is appended to
|
||||
* the front and end of the requested value). Further SQL "LIKE" wildcard characters will be
|
||||
* resolved correctly.
|
||||
*/
|
||||
@JsonProperty("custom-1-like")
|
||||
private final String[] custom1Like;
|
||||
|
||||
/** Filter out by values of the field custom1 of the task. This is an exact match. */
|
||||
@JsonProperty("custom-1-not-in")
|
||||
private final String[] custom1NotIn;
|
||||
|
||||
/** Filter by the value of the field custom2 of the task. This is an exact match. */
|
||||
@JsonProperty("custom-2")
|
||||
private final String[] custom2;
|
||||
|
||||
/**
|
||||
* Filter by the custom2 field of the task. This results in a substring search (% is appended to
|
||||
* the front and end of the requested value). Further SQL "LIKE" wildcard characters will be
|
||||
* resolved correctly.
|
||||
*/
|
||||
@JsonProperty("custom-2-like")
|
||||
private final String[] custom2Like;
|
||||
|
||||
/** Filter out by values of the field custom2 of the task. This is an exact match. */
|
||||
@JsonProperty("custom-2-not-in")
|
||||
private final String[] custom2NotIn;
|
||||
|
||||
/** Filter by the value of the field custom3 of the task. This is an exact match. */
|
||||
@JsonProperty("custom-3")
|
||||
private final String[] custom3;
|
||||
|
||||
/**
|
||||
* Filter by the custom3 field of the task. This results in a substring search (% is appended to
|
||||
* the front and end of the requested value). Further SQL "LIKE" wildcard characters will be
|
||||
* resolved correctly.
|
||||
*/
|
||||
@JsonProperty("custom-3-like")
|
||||
private final String[] custom3Like;
|
||||
|
||||
/** Filter out by values of the field custom3 of the task. This is an exact match. */
|
||||
@JsonProperty("custom-3-not-in")
|
||||
private final String[] custom3NotIn;
|
||||
|
||||
/** Filter by the value of the field custom4 of the task. This is an exact match. */
|
||||
@JsonProperty("custom-4")
|
||||
private final String[] custom4;
|
||||
|
||||
/**
|
||||
* Filter by the custom4 field of the task. This results in a substring search (% is appended to
|
||||
* the front and end of the requested value). Further SQL "LIKE" wildcard characters will be
|
||||
* resolved correctly.
|
||||
*/
|
||||
@JsonProperty("custom-4-like")
|
||||
private final String[] custom4Like;
|
||||
|
||||
/** Filter out by values of the field custom4 of the task. This is an exact match. */
|
||||
@JsonProperty("custom-4-not-in")
|
||||
private final String[] custom4NotIn;
|
||||
|
||||
/** Filter by the value of the field custom5 of the task. This is an exact match. */
|
||||
@JsonProperty("custom-5")
|
||||
private final String[] custom5;
|
||||
|
||||
/**
|
||||
* Filter by the custom5 field of the task. This results in a substring search (% is appended to
|
||||
* the front and end of the requested value). Further SQL "LIKE" wildcard characters will be
|
||||
* resolved correctly.
|
||||
*/
|
||||
@JsonProperty("custom-5-like")
|
||||
private final String[] custom5Like;
|
||||
|
||||
/** Filter out by values of the field custom5 of the task. This is an exact match. */
|
||||
@JsonProperty("custom-5-not-in")
|
||||
private final String[] custom5NotIn;
|
||||
|
||||
/** Filter by the value of the field custom6 of the task. This is an exact match. */
|
||||
@JsonProperty("custom-6")
|
||||
private final String[] custom6;
|
||||
|
||||
/**
|
||||
* Filter by the custom6 field of the task. This results in a substring search (% is appended to
|
||||
* the front and end of the requested value). Further SQL "LIKE" wildcard characters will be
|
||||
* resolved correctly.
|
||||
*/
|
||||
@JsonProperty("custom-6-like")
|
||||
private final String[] custom6Like;
|
||||
|
||||
/** Filter out by values of the field custom6 of the task. This is an exact match. */
|
||||
@JsonProperty("custom-6-not-in")
|
||||
private final String[] custom6NotIn;
|
||||
|
||||
/** Filter by the value of the field custom7 of the task. This is an exact match. */
|
||||
@JsonProperty("custom-7")
|
||||
private final String[] custom7;
|
||||
|
||||
/**
|
||||
* Filter by the custom7 field of the task. This results in a substring search (% is appended to
|
||||
* the front and end of the requested value). Further SQL "LIKE" wildcard characters will be
|
||||
* resolved correctly.
|
||||
*/
|
||||
@JsonProperty("custom-7-like")
|
||||
private final String[] custom7Like;
|
||||
|
||||
/** Filter out by values of the field custom7 of the task. This is an exact match. */
|
||||
@JsonProperty("custom-7-not-in")
|
||||
private final String[] custom7NotIn;
|
||||
|
||||
/** Filter by the value of the field custom8 of the task. This is an exact match. */
|
||||
@JsonProperty("custom-8")
|
||||
private final String[] custom8;
|
||||
|
||||
/**
|
||||
* Filter by the custom8 field of the task. This results in a substring search (% is appended to
|
||||
* the front and end of the requested value). Further SQL "LIKE" wildcard characters will be
|
||||
* resolved correctly.
|
||||
*/
|
||||
@JsonProperty("custom-8-like")
|
||||
private final String[] custom8Like;
|
||||
|
||||
/** Filter out by values of the field custom8 of the task. This is an exact match. */
|
||||
@JsonProperty("custom-8-not-in")
|
||||
private final String[] custom8NotIn;
|
||||
|
||||
/** Filter by the value of the field custom9 of the task. This is an exact match. */
|
||||
@JsonProperty("custom-9")
|
||||
private final String[] custom9;
|
||||
|
||||
/**
|
||||
* Filter by the custom9 field of the task. This results in a substring search (% is appended to
|
||||
* the front and end of the requested value). Further SQL "LIKE" wildcard characters will be
|
||||
* resolved correctly.
|
||||
*/
|
||||
@JsonProperty("custom-9-like")
|
||||
private final String[] custom9Like;
|
||||
|
||||
/** Filter out by values of the field custom9 of the task. This is an exact match. */
|
||||
@JsonProperty("custom-9-not-in")
|
||||
private final String[] custom9NotIn;
|
||||
|
||||
/** Filter by the value of the field custom10 of the task. This is an exact match. */
|
||||
@JsonProperty("custom-10")
|
||||
private final String[] custom10;
|
||||
|
||||
/**
|
||||
* Filter by the custom10 field of the task. This results in a substring search (% is appended to
|
||||
* the front and end of the requested value). Further SQL "LIKE" wildcard characters will be
|
||||
* resolved correctly.
|
||||
*/
|
||||
@JsonProperty("custom-10-like")
|
||||
private final String[] custom10Like;
|
||||
|
||||
/** Filter out by values of the field custom10 of the task. This is an exact match. */
|
||||
@JsonProperty("custom-10-not-in")
|
||||
private final String[] custom10NotIn;
|
||||
|
||||
/** Filter by the value of the field custom11 of the task. This is an exact match. */
|
||||
@JsonProperty("custom-11")
|
||||
private final String[] custom11;
|
||||
|
||||
/**
|
||||
* Filter by the custom11 field of the task. This results in a substring search (% is appended to
|
||||
* the front and end of the requested value). Further SQL "LIKE" wildcard characters will be
|
||||
* resolved correctly.
|
||||
*/
|
||||
@JsonProperty("custom-11-like")
|
||||
private final String[] custom11Like;
|
||||
|
||||
/** Filter out by values of the field custom11 of the task. This is an exact match. */
|
||||
@JsonProperty("custom-11-not-in")
|
||||
private final String[] custom11NotIn;
|
||||
|
||||
/** Filter by the value of the field custom12 of the task. This is an exact match. */
|
||||
@JsonProperty("custom-12")
|
||||
private final String[] custom12;
|
||||
|
||||
/**
|
||||
* Filter by the custom12 field of the task. This results in a substring search (% is appended to
|
||||
* the front and end of the requested value). Further SQL "LIKE" wildcard characters will be
|
||||
* resolved correctly.
|
||||
*/
|
||||
@JsonProperty("custom-12-like")
|
||||
private final String[] custom12Like;
|
||||
|
||||
/** Filter out by values of the field custom12 of the task. This is an exact match. */
|
||||
@JsonProperty("custom-12-not-in")
|
||||
private final String[] custom12NotIn;
|
||||
|
||||
/** Filter by the value of the field custom13 of the task. This is an exact match. */
|
||||
@JsonProperty("custom-13")
|
||||
private final String[] custom13;
|
||||
|
||||
/**
|
||||
* Filter by the custom13 field of the task. This results in a substring search (% is appended to
|
||||
* the front and end of the requested value). Further SQL "LIKE" wildcard characters will be
|
||||
* resolved correctly.
|
||||
*/
|
||||
@JsonProperty("custom-13-like")
|
||||
private final String[] custom13Like;
|
||||
|
||||
/** Filter out by values of the field custom13 of the task. This is an exact match. */
|
||||
@JsonProperty("custom-13-not-in")
|
||||
private final String[] custom13NotIn;
|
||||
|
||||
/** Filter by the value of the field custom14 of the task. This is an exact match. */
|
||||
@JsonProperty("custom-14")
|
||||
private final String[] custom14;
|
||||
|
||||
/**
|
||||
* Filter by the custom14 field of the task. This results in a substring search (% is appended to
|
||||
* the front and end of the requested value). Further SQL "LIKE" wildcard characters will be
|
||||
* resolved correctly.
|
||||
*/
|
||||
@JsonProperty("custom-14-like")
|
||||
private final String[] custom14Like;
|
||||
|
||||
/** Filter out by values of the field custom14 of the task. This is an exact match. */
|
||||
@JsonProperty("custom-14-not-in")
|
||||
private final String[] custom14NotIn;
|
||||
|
||||
/** Filter by the value of the field custom15 of the task. This is an exact match. */
|
||||
@JsonProperty("custom-15")
|
||||
private final String[] custom15;
|
||||
|
||||
/**
|
||||
* Filter by the custom15 field of the task. This results in a substring search (% is appended to
|
||||
* the front and end of the requested value). Further SQL "LIKE" wildcard characters will be
|
||||
* resolved correctly.
|
||||
*/
|
||||
@JsonProperty("custom-15-like")
|
||||
private final String[] custom15Like;
|
||||
|
||||
/** Filter out by values of the field custom15 of the task. This is an exact match. */
|
||||
@JsonProperty("custom-15-not-in")
|
||||
private final String[] custom15NotIn;
|
||||
|
||||
/** Filter by the value of the field custom16 of the task. This is an exact match. */
|
||||
@JsonProperty("custom-16")
|
||||
private final String[] custom16;
|
||||
|
||||
/**
|
||||
* Filter by the custom16 field of the task. This results in a substring search (% is appended to
|
||||
* the front and end of the requested value). Further SQL "LIKE" wildcard characters will be
|
||||
* resolved correctly.
|
||||
*/
|
||||
@JsonProperty("custom-16-like")
|
||||
private final String[] custom16Like;
|
||||
|
||||
/** Filter out by values of the field custom16 of the task. This is an exact match. */
|
||||
@JsonProperty("custom-16-not-in")
|
||||
private final String[] custom16NotIn;
|
||||
|
||||
@ConstructorProperties({
|
||||
"in-working-days",
|
||||
"workbasket-id",
|
||||
"states",
|
||||
"classification-category",
|
||||
"domains",
|
||||
"classification-id",
|
||||
"excluded-classification-id",
|
||||
"custom-1",
|
||||
"custom-1-like",
|
||||
"custom-1-not-in",
|
||||
"custom-2",
|
||||
"custom-2-like",
|
||||
"custom-2-not-in",
|
||||
"custom-3",
|
||||
"custom-3-like",
|
||||
"custom-3-not-in",
|
||||
"custom-4",
|
||||
"custom-4-like",
|
||||
"custom-4-not-in",
|
||||
"custom-5",
|
||||
"custom-5-like",
|
||||
"custom-5-not-in",
|
||||
"custom-6",
|
||||
"custom-6-like",
|
||||
"custom-6-not-in",
|
||||
"custom-7",
|
||||
"custom-7-like",
|
||||
"custom-7-not-in",
|
||||
"custom-8",
|
||||
"custom-8-like",
|
||||
"custom-8-not-in",
|
||||
"custom-9",
|
||||
"custom-9-like",
|
||||
"custom-9-not-in",
|
||||
"custom-10",
|
||||
"custom-10-like",
|
||||
"custom-10-not-in",
|
||||
"custom-11",
|
||||
"custom-11-like",
|
||||
"custom-11-not-in",
|
||||
"custom-12",
|
||||
"custom-12-like",
|
||||
"custom-12-not-in",
|
||||
"custom-13",
|
||||
"custom-13-like",
|
||||
"custom-13-not-in",
|
||||
"custom-14",
|
||||
"custom-14-like",
|
||||
"custom-14-not-in",
|
||||
"custom-15",
|
||||
"custom-15-like",
|
||||
"custom-15-not-in",
|
||||
"custom-16",
|
||||
"custom-16-like",
|
||||
"custom-16-not-in"
|
||||
})
|
||||
public TimeIntervalReportFilterParameter(
|
||||
Boolean inWorkingDays,
|
||||
String[] workbasketId,
|
||||
TaskState[] state,
|
||||
String[] classificationCategory,
|
||||
String[] domain,
|
||||
String[] classificationId,
|
||||
String[] excludedClassificationId,
|
||||
String[] custom1,
|
||||
String[] custom1Like,
|
||||
String[] custom1NotIn,
|
||||
String[] custom2,
|
||||
String[] custom2Like,
|
||||
String[] custom2NotIn,
|
||||
String[] custom3,
|
||||
String[] custom3Like,
|
||||
String[] custom3NotIn,
|
||||
String[] custom4,
|
||||
String[] custom4Like,
|
||||
String[] custom4NotIn,
|
||||
String[] custom5,
|
||||
String[] custom5Like,
|
||||
String[] custom5NotIn,
|
||||
String[] custom6,
|
||||
String[] custom6Like,
|
||||
String[] custom6NotIn,
|
||||
String[] custom7,
|
||||
String[] custom7Like,
|
||||
String[] custom7NotIn,
|
||||
String[] custom8,
|
||||
String[] custom8Like,
|
||||
String[] custom8NotIn,
|
||||
String[] custom9,
|
||||
String[] custom9Like,
|
||||
String[] custom9NotIn,
|
||||
String[] custom10,
|
||||
String[] custom10Like,
|
||||
String[] custom10NotIn,
|
||||
String[] custom11,
|
||||
String[] custom11Like,
|
||||
String[] custom11NotIn,
|
||||
String[] custom12,
|
||||
String[] custom12Like,
|
||||
String[] custom12NotIn,
|
||||
String[] custom13,
|
||||
String[] custom13Like,
|
||||
String[] custom13NotIn,
|
||||
String[] custom14,
|
||||
String[] custom14Like,
|
||||
String[] custom14NotIn,
|
||||
String[] custom15,
|
||||
String[] custom15Like,
|
||||
String[] custom15NotIn,
|
||||
String[] custom16,
|
||||
String[] custom16Like,
|
||||
String[] custom16NotIn) {
|
||||
this.inWorkingDays = inWorkingDays;
|
||||
this.workbasketId = workbasketId;
|
||||
this.state = state;
|
||||
this.classificationCategory = classificationCategory;
|
||||
this.domain = domain;
|
||||
this.classificationId = classificationId;
|
||||
this.excludedClassificationId = excludedClassificationId;
|
||||
this.custom1 = custom1;
|
||||
this.custom1Like = custom1Like;
|
||||
this.custom1NotIn = custom1NotIn;
|
||||
this.custom2 = custom2;
|
||||
this.custom2Like = custom2Like;
|
||||
this.custom2NotIn = custom2NotIn;
|
||||
this.custom3 = custom3;
|
||||
this.custom3Like = custom3Like;
|
||||
this.custom3NotIn = custom3NotIn;
|
||||
this.custom4 = custom4;
|
||||
this.custom4Like = custom4Like;
|
||||
this.custom4NotIn = custom4NotIn;
|
||||
this.custom5 = custom5;
|
||||
this.custom5Like = custom5Like;
|
||||
this.custom5NotIn = custom5NotIn;
|
||||
this.custom6 = custom6;
|
||||
this.custom6Like = custom6Like;
|
||||
this.custom6NotIn = custom6NotIn;
|
||||
this.custom7 = custom7;
|
||||
this.custom7Like = custom7Like;
|
||||
this.custom7NotIn = custom7NotIn;
|
||||
this.custom8 = custom8;
|
||||
this.custom8Like = custom8Like;
|
||||
this.custom8NotIn = custom8NotIn;
|
||||
this.custom9 = custom9;
|
||||
this.custom9Like = custom9Like;
|
||||
this.custom9NotIn = custom9NotIn;
|
||||
this.custom10 = custom10;
|
||||
this.custom10Like = custom10Like;
|
||||
this.custom10NotIn = custom10NotIn;
|
||||
this.custom11 = custom11;
|
||||
this.custom11Like = custom11Like;
|
||||
this.custom11NotIn = custom11NotIn;
|
||||
this.custom12 = custom12;
|
||||
this.custom12Like = custom12Like;
|
||||
this.custom12NotIn = custom12NotIn;
|
||||
this.custom13 = custom13;
|
||||
this.custom13Like = custom13Like;
|
||||
this.custom13NotIn = custom13NotIn;
|
||||
this.custom14 = custom14;
|
||||
this.custom14Like = custom14Like;
|
||||
this.custom14NotIn = custom14NotIn;
|
||||
this.custom15 = custom15;
|
||||
this.custom15Like = custom15Like;
|
||||
this.custom15NotIn = custom15NotIn;
|
||||
this.custom16 = custom16;
|
||||
this.custom16Like = custom16Like;
|
||||
this.custom16NotIn = custom16NotIn;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Void apply(TimeIntervalReportBuilder<?, ?, TimeIntervalColumnHeader> builder) {
|
||||
builder.withColumnHeaders(defaultColumnHeaders());
|
||||
Optional.ofNullable(inWorkingDays)
|
||||
.ifPresent(
|
||||
bool -> {
|
||||
if (bool) {
|
||||
builder.inWorkingDays();
|
||||
}
|
||||
});
|
||||
Optional.ofNullable(workbasketId).map(Arrays::asList).ifPresent(builder::workbasketIdIn);
|
||||
Optional.ofNullable(state).map(Arrays::asList).ifPresent(builder::stateIn);
|
||||
Optional.ofNullable(classificationCategory)
|
||||
.map(Arrays::asList)
|
||||
.ifPresent(builder::classificationCategoryIn);
|
||||
Optional.ofNullable(domain).map(Arrays::asList).ifPresent(builder::domainIn);
|
||||
Optional.ofNullable(classificationId)
|
||||
.map(Arrays::asList)
|
||||
.ifPresent(builder::classificationIdIn);
|
||||
Optional.ofNullable(excludedClassificationId)
|
||||
.map(Arrays::asList)
|
||||
.ifPresent(builder::excludedClassificationIdIn);
|
||||
|
||||
Stream.of(
|
||||
Pair.of(TaskCustomField.CUSTOM_1, custom1),
|
||||
Pair.of(TaskCustomField.CUSTOM_2, custom2),
|
||||
Pair.of(TaskCustomField.CUSTOM_3, custom3),
|
||||
Pair.of(TaskCustomField.CUSTOM_4, custom4),
|
||||
Pair.of(TaskCustomField.CUSTOM_5, custom5),
|
||||
Pair.of(TaskCustomField.CUSTOM_6, custom6),
|
||||
Pair.of(TaskCustomField.CUSTOM_7, custom7),
|
||||
Pair.of(TaskCustomField.CUSTOM_8, custom8),
|
||||
Pair.of(TaskCustomField.CUSTOM_9, custom9),
|
||||
Pair.of(TaskCustomField.CUSTOM_10, custom10),
|
||||
Pair.of(TaskCustomField.CUSTOM_11, custom11),
|
||||
Pair.of(TaskCustomField.CUSTOM_12, custom12),
|
||||
Pair.of(TaskCustomField.CUSTOM_13, custom13),
|
||||
Pair.of(TaskCustomField.CUSTOM_14, custom14),
|
||||
Pair.of(TaskCustomField.CUSTOM_15, custom15),
|
||||
Pair.of(TaskCustomField.CUSTOM_16, custom16))
|
||||
.forEach(
|
||||
pair ->
|
||||
Optional.ofNullable(pair.getRight())
|
||||
.ifPresent(wrap(l -> builder.customAttributeIn(pair.getLeft(), l))));
|
||||
Stream.of(
|
||||
Pair.of(TaskCustomField.CUSTOM_1, custom1Like),
|
||||
Pair.of(TaskCustomField.CUSTOM_2, custom2Like),
|
||||
Pair.of(TaskCustomField.CUSTOM_3, custom3Like),
|
||||
Pair.of(TaskCustomField.CUSTOM_4, custom4Like),
|
||||
Pair.of(TaskCustomField.CUSTOM_5, custom5Like),
|
||||
Pair.of(TaskCustomField.CUSTOM_6, custom6Like),
|
||||
Pair.of(TaskCustomField.CUSTOM_7, custom7Like),
|
||||
Pair.of(TaskCustomField.CUSTOM_8, custom8Like),
|
||||
Pair.of(TaskCustomField.CUSTOM_9, custom9Like),
|
||||
Pair.of(TaskCustomField.CUSTOM_10, custom10Like),
|
||||
Pair.of(TaskCustomField.CUSTOM_11, custom11Like),
|
||||
Pair.of(TaskCustomField.CUSTOM_12, custom12Like),
|
||||
Pair.of(TaskCustomField.CUSTOM_13, custom13Like),
|
||||
Pair.of(TaskCustomField.CUSTOM_14, custom14Like),
|
||||
Pair.of(TaskCustomField.CUSTOM_15, custom15Like),
|
||||
Pair.of(TaskCustomField.CUSTOM_16, custom16Like))
|
||||
.forEach(
|
||||
pair ->
|
||||
Optional.ofNullable(pair.getRight())
|
||||
.map(this::wrapElementsInLikeStatement)
|
||||
.ifPresent(wrap(l -> builder.customAttributeLike(pair.getLeft(), l))));
|
||||
|
||||
Stream.of(
|
||||
Pair.of(TaskCustomField.CUSTOM_1, custom1NotIn),
|
||||
Pair.of(TaskCustomField.CUSTOM_2, custom2NotIn),
|
||||
Pair.of(TaskCustomField.CUSTOM_3, custom3NotIn),
|
||||
Pair.of(TaskCustomField.CUSTOM_4, custom4NotIn),
|
||||
Pair.of(TaskCustomField.CUSTOM_5, custom5NotIn),
|
||||
Pair.of(TaskCustomField.CUSTOM_6, custom6NotIn),
|
||||
Pair.of(TaskCustomField.CUSTOM_7, custom7NotIn),
|
||||
Pair.of(TaskCustomField.CUSTOM_8, custom8NotIn),
|
||||
Pair.of(TaskCustomField.CUSTOM_9, custom9NotIn),
|
||||
Pair.of(TaskCustomField.CUSTOM_10, custom10NotIn),
|
||||
Pair.of(TaskCustomField.CUSTOM_11, custom11NotIn),
|
||||
Pair.of(TaskCustomField.CUSTOM_12, custom12NotIn),
|
||||
Pair.of(TaskCustomField.CUSTOM_13, custom13NotIn),
|
||||
Pair.of(TaskCustomField.CUSTOM_14, custom14NotIn),
|
||||
Pair.of(TaskCustomField.CUSTOM_15, custom15NotIn),
|
||||
Pair.of(TaskCustomField.CUSTOM_16, custom16NotIn))
|
||||
.forEach(
|
||||
pair ->
|
||||
Optional.ofNullable(pair.getRight())
|
||||
.ifPresent(wrap(l -> builder.customAttributeNotIn(pair.getLeft(), l))));
|
||||
return null;
|
||||
}
|
||||
|
||||
private List<TimeIntervalColumnHeader> defaultColumnHeaders() {
|
||||
return Stream.concat(
|
||||
Stream.of(
|
||||
new TimeIntervalColumnHeader.Range(Integer.MIN_VALUE, -10),
|
||||
new TimeIntervalColumnHeader.Range(-10, -5),
|
||||
new TimeIntervalColumnHeader.Range(5, 10),
|
||||
new TimeIntervalColumnHeader.Range(10, Integer.MAX_VALUE)),
|
||||
Stream.of(-4, -3, -2, -1, 0, 1, 2, 3, 4).map(TimeIntervalColumnHeader.Range::new))
|
||||
.sorted(Comparator.comparing(TimeIntervalColumnHeader::getLowerAgeLimit))
|
||||
.collect(Collectors.toList());
|
||||
}
|
||||
}
|
||||
|
|
@ -16,8 +16,11 @@ import org.springframework.stereotype.Component;
|
|||
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.ClassificationCategoryReport;
|
||||
import pro.taskana.monitor.api.reports.ClassificationReport;
|
||||
import pro.taskana.monitor.api.reports.ClassificationReport.DetailedClassificationReport;
|
||||
import pro.taskana.monitor.api.reports.Report;
|
||||
import pro.taskana.monitor.api.reports.TaskCustomFieldValueReport;
|
||||
import pro.taskana.monitor.api.reports.TaskStatusReport;
|
||||
import pro.taskana.monitor.api.reports.TimestampReport;
|
||||
import pro.taskana.monitor.api.reports.WorkbasketReport;
|
||||
|
|
@ -27,14 +30,92 @@ import pro.taskana.monitor.api.reports.row.FoldableRow;
|
|||
import pro.taskana.monitor.api.reports.row.Row;
|
||||
import pro.taskana.monitor.api.reports.row.SingleRow;
|
||||
import pro.taskana.monitor.rest.MonitorController;
|
||||
import pro.taskana.monitor.rest.TimeIntervalReportFilterParameter;
|
||||
import pro.taskana.monitor.rest.models.ReportRepresentationModel;
|
||||
import pro.taskana.monitor.rest.models.ReportRepresentationModel.RowRepresentationModel;
|
||||
import pro.taskana.task.api.TaskCustomField;
|
||||
import pro.taskana.task.api.TaskState;
|
||||
|
||||
/** Transforms any {@link Report} into its {@link ReportRepresentationModel}. */
|
||||
@Component
|
||||
public class ReportRepresentationModelAssembler {
|
||||
|
||||
@NonNull
|
||||
public ReportRepresentationModel toModel(
|
||||
@NonNull WorkbasketReport report,
|
||||
@NonNull TimeIntervalReportFilterParameter filterParameter,
|
||||
@NonNull TaskTimestamp taskTimestamp)
|
||||
throws NotAuthorizedException, InvalidArgumentException {
|
||||
ReportRepresentationModel resource = toReportResource(report);
|
||||
resource.add(
|
||||
linkTo(
|
||||
methodOn(MonitorController.class)
|
||||
.computeWorkbasketReport(filterParameter, taskTimestamp))
|
||||
.withSelfRel());
|
||||
return resource;
|
||||
}
|
||||
|
||||
@NonNull
|
||||
public ReportRepresentationModel toModel(
|
||||
@NonNull ClassificationCategoryReport report,
|
||||
@NonNull TimeIntervalReportFilterParameter filterParameter,
|
||||
@NonNull TaskTimestamp taskTimestamp)
|
||||
throws NotAuthorizedException, InvalidArgumentException {
|
||||
ReportRepresentationModel resource = toReportResource(report);
|
||||
resource.add(
|
||||
linkTo(
|
||||
methodOn(MonitorController.class)
|
||||
.computeClassificationCategoryReport(filterParameter, taskTimestamp))
|
||||
.withSelfRel());
|
||||
return resource;
|
||||
}
|
||||
|
||||
@NonNull
|
||||
public ReportRepresentationModel toModel(
|
||||
@NonNull ClassificationReport report,
|
||||
@NonNull TimeIntervalReportFilterParameter filterParameter,
|
||||
@NonNull TaskTimestamp taskTimestamp)
|
||||
throws NotAuthorizedException, InvalidArgumentException {
|
||||
ReportRepresentationModel resource = toReportResource(report);
|
||||
resource.add(
|
||||
linkTo(
|
||||
methodOn(MonitorController.class)
|
||||
.computeClassificationReport(filterParameter, taskTimestamp))
|
||||
.withSelfRel());
|
||||
return resource;
|
||||
}
|
||||
|
||||
@NonNull
|
||||
public ReportRepresentationModel toModel(
|
||||
@NonNull DetailedClassificationReport report,
|
||||
@NonNull TimeIntervalReportFilterParameter filterParameter,
|
||||
@NonNull TaskTimestamp taskTimestamp)
|
||||
throws NotAuthorizedException, InvalidArgumentException {
|
||||
ReportRepresentationModel resource = toReportResource(report);
|
||||
resource.add(
|
||||
linkTo(
|
||||
methodOn(MonitorController.class)
|
||||
.computeDetailedClassificationReport(filterParameter, taskTimestamp))
|
||||
.withSelfRel());
|
||||
return resource;
|
||||
}
|
||||
|
||||
@NonNull
|
||||
public ReportRepresentationModel toModel(
|
||||
@NonNull TaskCustomFieldValueReport report,
|
||||
@NonNull TaskCustomField customField,
|
||||
@NonNull TimeIntervalReportFilterParameter filterParameter,
|
||||
@NonNull TaskTimestamp taskTimestamp)
|
||||
throws NotAuthorizedException, InvalidArgumentException {
|
||||
ReportRepresentationModel resource = toReportResource(report);
|
||||
resource.add(
|
||||
linkTo(
|
||||
methodOn(MonitorController.class)
|
||||
.computeTaskCustomFieldValueReport(customField, filterParameter, taskTimestamp))
|
||||
.withSelfRel());
|
||||
return resource;
|
||||
}
|
||||
|
||||
@NonNull
|
||||
public ReportRepresentationModel toModel(
|
||||
@NonNull TaskStatusReport report,
|
||||
|
|
@ -47,57 +128,27 @@ public class ReportRepresentationModelAssembler {
|
|||
resource.add(
|
||||
linkTo(
|
||||
methodOn(MonitorController.class)
|
||||
.getTaskStatusReport(domains, states, workbasketIds, priorityMinimum))
|
||||
.computeTaskStatusReport(domains, states, workbasketIds, priorityMinimum))
|
||||
.withSelfRel());
|
||||
return resource;
|
||||
}
|
||||
|
||||
@NonNull
|
||||
public ReportRepresentationModel toModel(
|
||||
@NonNull ClassificationReport report, TaskTimestamp taskTimestamp)
|
||||
throws NotAuthorizedException, InvalidArgumentException {
|
||||
ReportRepresentationModel resource = toReportResource(report);
|
||||
resource.add(
|
||||
linkTo(methodOn(MonitorController.class).getClassificationReport(taskTimestamp))
|
||||
.withSelfRel());
|
||||
return resource;
|
||||
}
|
||||
|
||||
@NonNull
|
||||
public ReportRepresentationModel toModel(
|
||||
@NonNull WorkbasketReport report,
|
||||
@NonNull List<TaskState> states,
|
||||
@NonNull TaskTimestamp taskTimestamp)
|
||||
throws NotAuthorizedException, InvalidArgumentException {
|
||||
ReportRepresentationModel resource = toReportResource(report);
|
||||
resource.add(
|
||||
linkTo(methodOn(MonitorController.class).getWorkbasketReport(states, taskTimestamp))
|
||||
.withSelfRel());
|
||||
return resource;
|
||||
}
|
||||
|
||||
@NonNull
|
||||
public ReportRepresentationModel toModel(
|
||||
@NonNull WorkbasketReport report, int daysInPast, @NonNull List<TaskState> states)
|
||||
@NonNull TimestampReport report,
|
||||
@NonNull TimeIntervalReportFilterParameter filterParameter,
|
||||
TaskTimestamp[] timestamps)
|
||||
throws NotAuthorizedException, InvalidArgumentException {
|
||||
ReportRepresentationModel resource = toReportResource(report);
|
||||
resource.add(
|
||||
linkTo(
|
||||
methodOn(MonitorController.class)
|
||||
.getTasksWorkbasketPlannedDateReport(daysInPast, states))
|
||||
.computeTimestampReport(filterParameter, timestamps))
|
||||
.withSelfRel());
|
||||
return resource;
|
||||
}
|
||||
|
||||
@NonNull
|
||||
public ReportRepresentationModel toModel(@NonNull TimestampReport report)
|
||||
throws NotAuthorizedException, InvalidArgumentException {
|
||||
ReportRepresentationModel resource = toReportResource(report);
|
||||
resource.add(linkTo(methodOn(MonitorController.class).getTimestampReport()).withSelfRel());
|
||||
return resource;
|
||||
}
|
||||
|
||||
public <I extends QueryItem, H extends ColumnHeader<? super I>>
|
||||
<I extends QueryItem, H extends ColumnHeader<? super I>>
|
||||
ReportRepresentationModel toReportResource(Report<I, H> report, Instant time) {
|
||||
String[] header =
|
||||
report.getColumnHeaders().stream().map(H::getDisplayName).toArray(String[]::new);
|
||||
|
|
|
|||
|
|
@ -93,10 +93,10 @@ public class TaskController {
|
|||
|
||||
TaskQuery query = taskService.createTaskQuery();
|
||||
|
||||
filterParameter.applyToQuery(query);
|
||||
sortParameter.applyToQuery(query);
|
||||
filterParameter.apply(query);
|
||||
sortParameter.apply(query);
|
||||
|
||||
List<TaskSummary> taskSummaries = pagingParameter.applyToQuery(query);
|
||||
List<TaskSummary> taskSummaries = pagingParameter.apply(query);
|
||||
|
||||
TaskSummaryPagedRepresentationModel pagedModels =
|
||||
taskSummaryRepresentationModelAssembler.toPagedModel(
|
||||
|
|
@ -121,7 +121,7 @@ public class TaskController {
|
|||
TaskQueryFilterParameter filterParameter)
|
||||
throws InvalidArgumentException, NotAuthorizedException {
|
||||
TaskQuery query = taskService.createTaskQuery();
|
||||
filterParameter.applyToQuery(query);
|
||||
filterParameter.apply(query);
|
||||
|
||||
List<TaskSummary> taskSummaries = query.list();
|
||||
|
||||
|
|
@ -202,8 +202,8 @@ public class TaskController {
|
|||
throws InvalidOwnerException, NotAuthorizedException {
|
||||
TaskQuery query = taskService.createTaskQuery();
|
||||
|
||||
filterParameter.applyToQuery(query);
|
||||
sortParameter.applyToQuery(query);
|
||||
filterParameter.apply(query);
|
||||
sortParameter.apply(query);
|
||||
|
||||
Task selectedAndClaimedTask = taskService.selectAndClaim(query);
|
||||
|
||||
|
|
|
|||
|
|
@ -1125,7 +1125,7 @@ public class TaskQueryFilterParameter implements QueryParameter<TaskQuery, Void>
|
|||
}
|
||||
|
||||
@Override
|
||||
public Void applyToQuery(TaskQuery query) {
|
||||
public Void apply(TaskQuery query) {
|
||||
Optional.ofNullable(name).ifPresent(query::nameIn);
|
||||
Optional.ofNullable(nameLike).map(this::wrapElementsInLikeStatement).ifPresent(query::nameLike);
|
||||
Optional.ofNullable(priority).ifPresent(query::priorityIn);
|
||||
|
|
|
|||
|
|
@ -72,10 +72,10 @@ public class WorkbasketAccessItemController {
|
|||
QueryPagingParameter.class);
|
||||
|
||||
WorkbasketAccessItemQuery query = workbasketService.createWorkbasketAccessItemQuery();
|
||||
filterParameter.applyToQuery(query);
|
||||
sortParameter.applyToQuery(query);
|
||||
filterParameter.apply(query);
|
||||
sortParameter.apply(query);
|
||||
|
||||
List<WorkbasketAccessItem> workbasketAccessItems = pagingParameter.applyToQuery(query);
|
||||
List<WorkbasketAccessItem> workbasketAccessItems = pagingParameter.apply(query);
|
||||
|
||||
WorkbasketAccessItemPagedRepresentationModel pagedResources =
|
||||
modelAssembler.toPagedModel(workbasketAccessItems, pagingParameter.getPageMetadata());
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ public class WorkbasketAccessItemQueryFilterParameter
|
|||
}
|
||||
|
||||
@Override
|
||||
public Void applyToQuery(WorkbasketAccessItemQuery query) {
|
||||
public Void apply(WorkbasketAccessItemQuery query) {
|
||||
Optional.ofNullable(workbasketKey).ifPresent(query::workbasketKeyIn);
|
||||
Optional.ofNullable(workbasketKeyLike)
|
||||
.map(this::wrapElementsInLikeStatement)
|
||||
|
|
|
|||
|
|
@ -105,10 +105,10 @@ public class WorkbasketController {
|
|||
QueryPagingParameter.class);
|
||||
|
||||
WorkbasketQuery query = workbasketService.createWorkbasketQuery();
|
||||
filterParameter.applyToQuery(query);
|
||||
sortParameter.applyToQuery(query);
|
||||
filterParameter.apply(query);
|
||||
sortParameter.apply(query);
|
||||
|
||||
List<WorkbasketSummary> workbasketSummaries = pagingParameter.applyToQuery(query);
|
||||
List<WorkbasketSummary> workbasketSummaries = pagingParameter.apply(query);
|
||||
WorkbasketSummaryPagedRepresentationModel pagedModels =
|
||||
workbasketSummaryRepresentationModelAssembler.toPagedModel(
|
||||
workbasketSummaries, pagingParameter.getPageMetadata());
|
||||
|
|
|
|||
|
|
@ -104,7 +104,7 @@ public class WorkbasketQueryFilterParameter implements QueryParameter<Workbasket
|
|||
}
|
||||
|
||||
@Override
|
||||
public Void applyToQuery(WorkbasketQuery query) {
|
||||
public Void apply(WorkbasketQuery query) {
|
||||
Optional.ofNullable(name).ifPresent(query::nameIn);
|
||||
Optional.ofNullable(nameLike).map(this::wrapElementsInLikeStatement).ifPresent(query::nameLike);
|
||||
Optional.ofNullable(key).ifPresent(query::keyIn);
|
||||
|
|
|
|||
|
|
@ -7,7 +7,6 @@ import com.fasterxml.jackson.annotation.JsonProperty;
|
|||
import com.tngtech.archunit.base.Optional;
|
||||
import com.tngtech.archunit.core.domain.JavaClass;
|
||||
import com.tngtech.archunit.core.domain.JavaClasses;
|
||||
import com.tngtech.archunit.core.domain.JavaField;
|
||||
import com.tngtech.archunit.core.importer.ClassFileImporter;
|
||||
import com.tngtech.archunit.lang.ArchCondition;
|
||||
import com.tngtech.archunit.lang.ArchRule;
|
||||
|
|
@ -41,22 +40,21 @@ public class SpringArchitectureTest {
|
|||
"all fields should have a @JsonProperty or @JsonIgnore annotation") {
|
||||
@Override
|
||||
public void check(JavaClass javaClass, ConditionEvents events) {
|
||||
for (JavaField field : javaClass.getAllFields()) {
|
||||
if (!field.reflect().isSynthetic()) {
|
||||
boolean annotationIsNotPresent =
|
||||
Stream.of(JsonProperty.class, JsonIgnore.class)
|
||||
.map(field::tryGetAnnotationOfType)
|
||||
.noneMatch(Optional::isPresent);
|
||||
if (annotationIsNotPresent) {
|
||||
events.add(
|
||||
SimpleConditionEvent.violated(
|
||||
javaClass,
|
||||
String.format(
|
||||
"Field '%s' in class '%s' is not annotated by @JsonProperty",
|
||||
field, javaClass)));
|
||||
}
|
||||
}
|
||||
}
|
||||
javaClass.getAllFields().stream()
|
||||
.filter(field -> !field.reflect().isSynthetic())
|
||||
.filter(
|
||||
field ->
|
||||
Stream.of(JsonProperty.class, JsonIgnore.class)
|
||||
.map(field::tryGetAnnotationOfType)
|
||||
.noneMatch(Optional::isPresent))
|
||||
.map(
|
||||
field ->
|
||||
SimpleConditionEvent.violated(
|
||||
javaClass,
|
||||
String.format(
|
||||
"Field '%s' in class '%s' is not annotated with a json annotation",
|
||||
field, javaClass)))
|
||||
.forEach(events::add);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
|
|||
|
||||
import pro.taskana.common.test.BaseRestDocTest;
|
||||
|
||||
public class AccessIdControllerRestDocTest extends BaseRestDocTest {
|
||||
class AccessIdControllerRestDocTest extends BaseRestDocTest {
|
||||
|
||||
@Test
|
||||
void searchForAccessIdDocTest() throws Exception {
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@ class QuerySortParameterTest {
|
|||
QuerySortParameter<MockQuery, MockSortBy> sortByParameter =
|
||||
new QuerySortParameter<>(List.of(sortBy), List.of(SortDirection.ASCENDING));
|
||||
|
||||
sortByParameter.applyToQuery(query);
|
||||
sortByParameter.apply(query);
|
||||
|
||||
verify(sortBy).applySortByForQuery(query, SortDirection.ASCENDING);
|
||||
}
|
||||
|
|
@ -35,7 +35,7 @@ class QuerySortParameterTest {
|
|||
QuerySortParameter<MockQuery, MockSortBy> sortByParameter =
|
||||
new QuerySortParameter<>(List.of(sortBy), null);
|
||||
|
||||
sortByParameter.applyToQuery(query);
|
||||
sortByParameter.apply(query);
|
||||
|
||||
verify(sortBy).applySortByForQuery(query, SortDirection.ASCENDING);
|
||||
}
|
||||
|
|
@ -48,7 +48,7 @@ class QuerySortParameterTest {
|
|||
QuerySortParameter<MockQuery, MockSortBy> sortByParameter =
|
||||
new QuerySortParameter<>(List.of(sortBy), List.of());
|
||||
|
||||
sortByParameter.applyToQuery(query);
|
||||
sortByParameter.apply(query);
|
||||
|
||||
verify(sortBy).applySortByForQuery(query, SortDirection.ASCENDING);
|
||||
}
|
||||
|
|
@ -61,7 +61,7 @@ class QuerySortParameterTest {
|
|||
QuerySortParameter<MockQuery, MockSortBy> sortByParameter =
|
||||
new QuerySortParameter<>(List.of(sortBy), List.of(SortDirection.DESCENDING));
|
||||
|
||||
sortByParameter.applyToQuery(query);
|
||||
sortByParameter.apply(query);
|
||||
|
||||
verify(sortBy).applySortByForQuery(query, SortDirection.DESCENDING);
|
||||
}
|
||||
|
|
@ -76,7 +76,7 @@ class QuerySortParameterTest {
|
|||
new QuerySortParameter<>(
|
||||
List.of(sortBy1, sortBy2), List.of(SortDirection.ASCENDING, SortDirection.ASCENDING));
|
||||
|
||||
sortByParameter.applyToQuery(query);
|
||||
sortByParameter.apply(query);
|
||||
|
||||
verify(sortBy1).applySortByForQuery(query, SortDirection.ASCENDING);
|
||||
verify(sortBy2).applySortByForQuery(query, SortDirection.ASCENDING);
|
||||
|
|
|
|||
|
|
@ -11,30 +11,40 @@ import org.springframework.http.HttpEntity;
|
|||
import org.springframework.http.HttpMethod;
|
||||
import org.springframework.http.ResponseEntity;
|
||||
|
||||
import pro.taskana.common.api.TaskanaEngine;
|
||||
import pro.taskana.common.rest.RestEndpoints;
|
||||
import pro.taskana.common.test.rest.RestHelper;
|
||||
import pro.taskana.common.test.rest.TaskanaSpringBootTest;
|
||||
import pro.taskana.monitor.rest.models.ReportRepresentationModel;
|
||||
import pro.taskana.monitor.rest.models.ReportRepresentationModel.RowRepresentationModel;
|
||||
|
||||
/** Test MonitorController. */
|
||||
@TaskanaSpringBootTest
|
||||
class MonitorControllerIntTest {
|
||||
|
||||
private static final ParameterizedTypeReference<ReportRepresentationModel> REPORT_MODEL =
|
||||
new ParameterizedTypeReference<ReportRepresentationModel>() {};
|
||||
private final RestHelper restHelper;
|
||||
private final TaskanaEngine taskanaEngine;
|
||||
|
||||
@Autowired RestHelper restHelper;
|
||||
@Autowired
|
||||
MonitorControllerIntTest(RestHelper restHelper, TaskanaEngine taskanaEngine) {
|
||||
this.restHelper = restHelper;
|
||||
this.taskanaEngine = taskanaEngine;
|
||||
}
|
||||
|
||||
@Test
|
||||
void should_ReturnAllOpenTasksByState_When_QueryingForAWorkbasketAndReadyAndClaimedState() {
|
||||
String url =
|
||||
restHelper.toUrl(RestEndpoints.URL_MONITOR_TASKS_STATUS_REPORT)
|
||||
restHelper.toUrl(RestEndpoints.URL_MONITOR_TASK_STATUS_REPORT)
|
||||
+ "?workbasket-ids=WBI:100000000000000000000000000000000007"
|
||||
+ "&states=READY&states=CLAIMED";
|
||||
HttpEntity<String> auth = new HttpEntity<>(RestHelper.generateHeadersForUser("admin"));
|
||||
|
||||
ResponseEntity<ReportRepresentationModel> response =
|
||||
TEMPLATE.exchange(url, HttpMethod.GET, auth, REPORT_MODEL);
|
||||
TEMPLATE.exchange(
|
||||
url,
|
||||
HttpMethod.GET,
|
||||
auth,
|
||||
ParameterizedTypeReference.forType(ReportRepresentationModel.class));
|
||||
|
||||
assertThat(response.getBody()).isNotNull();
|
||||
assertThat((response.getBody()).getLink(IanaLinkRelations.SELF)).isNotNull();
|
||||
|
|
@ -48,8 +58,8 @@ class MonitorControllerIntTest {
|
|||
|
||||
@Test
|
||||
void should_ReturnAllOpenTasksByState_When_QueryingForSpecificWbAndStateReadyAndMinimumPrio() {
|
||||
String url = restHelper.toUrl(RestEndpoints.URL_MONITOR_TASKS_STATUS_REPORT);
|
||||
HttpEntity<String> auth = new HttpEntity<>(RestHelper.generateHeadersForUser("admin"));
|
||||
String url = restHelper.toUrl(RestEndpoints.URL_MONITOR_TASK_STATUS_REPORT);
|
||||
HttpEntity<?> auth = new HttpEntity<>(RestHelper.generateHeadersForUser("admin"));
|
||||
|
||||
ResponseEntity<ReportRepresentationModel> response =
|
||||
TEMPLATE.exchange(
|
||||
|
|
@ -58,13 +68,40 @@ class MonitorControllerIntTest {
|
|||
+ "&states=READY&priority-minimum=1",
|
||||
HttpMethod.GET,
|
||||
auth,
|
||||
REPORT_MODEL);
|
||||
ParameterizedTypeReference.forType(ReportRepresentationModel.class));
|
||||
|
||||
assertThat(response.getBody()).isNotNull();
|
||||
assertThat((response.getBody()).getLink(IanaLinkRelations.SELF)).isNotNull();
|
||||
int[] tasksInStateReady = response.getBody().getSumRow().get(0).getCells();
|
||||
// should be 2 READY
|
||||
int[] expectedTasksPerState = new int[] {2};
|
||||
assertThat(tasksInStateReady).isEqualTo(expectedTasksPerState);
|
||||
assertThat(tasksInStateReady).isEqualTo(new int[] {2});
|
||||
}
|
||||
|
||||
@Test
|
||||
void should_ApplyAllFiltersAndComputeReport_When_QueryingForAWorkbasketReport() {
|
||||
String url =
|
||||
restHelper.toUrl(RestEndpoints.URL_MONITOR_WORKBASKET_REPORT)
|
||||
+ "?workbasket-id=WBI:100000000000000000000000000000000015"
|
||||
+ "&custom-3=abcd"
|
||||
+ "&custom-3=abbd"
|
||||
+ "&custom-3-not-in=abbb"
|
||||
+ "&custom-4=defg"
|
||||
+ "&custom-5=important";
|
||||
HttpEntity<?> auth = new HttpEntity<>(RestHelper.generateHeadersForUser("monitor"));
|
||||
|
||||
ResponseEntity<ReportRepresentationModel> response =
|
||||
TEMPLATE.exchange(
|
||||
url,
|
||||
HttpMethod.GET,
|
||||
auth,
|
||||
ParameterizedTypeReference.forType(ReportRepresentationModel.class));
|
||||
|
||||
ReportRepresentationModel report = response.getBody();
|
||||
|
||||
assertThat(report).isNotNull();
|
||||
|
||||
assertThat(report.getSumRow())
|
||||
.extracting(RowRepresentationModel::getCells)
|
||||
.containsExactly(new int[] {0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0});
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -11,31 +11,55 @@ import pro.taskana.common.test.BaseRestDocTest;
|
|||
class MonitorControllerRestDocTest extends BaseRestDocTest {
|
||||
|
||||
@Test
|
||||
void getTaskStatusReportDocTest() throws Exception {
|
||||
mockMvc
|
||||
.perform(get(RestEndpoints.URL_MONITOR_TASKS_STATUS_REPORT))
|
||||
.andExpect(MockMvcResultMatchers.status().isOk());
|
||||
}
|
||||
|
||||
@Test
|
||||
void getWorkbasketReportDocTest() throws Exception {
|
||||
void computeWorkbasketReportDocTest() throws Exception {
|
||||
mockMvc
|
||||
.perform(
|
||||
get(
|
||||
RestEndpoints.URL_MONITOR_TASKS_WORKBASKET_REPORT
|
||||
+ "?daysInPast=4&states=READY,CLAIMED,COMPLETED"))
|
||||
RestEndpoints.URL_MONITOR_WORKBASKET_REPORT
|
||||
+ "?states=READY&states=CLAIMED&states=COMPLETED"))
|
||||
.andExpect(MockMvcResultMatchers.status().isOk());
|
||||
}
|
||||
|
||||
@Test
|
||||
void getClassificationReportDocTest() throws Exception {
|
||||
void computeClassificationCategoryReportDocTest() throws Exception {
|
||||
mockMvc
|
||||
.perform(get(RestEndpoints.URL_MONITOR_TASKS_CLASSIFICATION_REPORT))
|
||||
.perform(get(RestEndpoints.URL_MONITOR_CLASSIFICATION_CATEGORY_REPORT))
|
||||
.andExpect(MockMvcResultMatchers.status().isOk());
|
||||
}
|
||||
|
||||
@Test
|
||||
void getTimestampReportDocTest() throws Exception {
|
||||
void computeClassificationReportDocTest() throws Exception {
|
||||
mockMvc
|
||||
.perform(get(RestEndpoints.URL_MONITOR_CLASSIFICATION_REPORT))
|
||||
.andExpect(MockMvcResultMatchers.status().isOk());
|
||||
}
|
||||
|
||||
@Test
|
||||
void computeDetailedClassificationReportDocTest() throws Exception {
|
||||
mockMvc
|
||||
.perform(get(RestEndpoints.URL_MONITOR_DETAILED_CLASSIFICATION_REPORT))
|
||||
.andExpect(MockMvcResultMatchers.status().isOk());
|
||||
}
|
||||
|
||||
@Test
|
||||
void computeTaskCustomFieldValueReportDocTest() throws Exception {
|
||||
mockMvc
|
||||
.perform(
|
||||
get(
|
||||
RestEndpoints.URL_MONITOR_TASK_CUSTOM_FIELD_VALUE_REPORT
|
||||
+ "?custom-field=CUSTOM_14"))
|
||||
.andExpect(MockMvcResultMatchers.status().isOk());
|
||||
}
|
||||
|
||||
@Test
|
||||
void computeTaskStatusReportDocTest() throws Exception {
|
||||
mockMvc
|
||||
.perform(get(RestEndpoints.URL_MONITOR_TASK_STATUS_REPORT))
|
||||
.andExpect(MockMvcResultMatchers.status().isOk());
|
||||
}
|
||||
|
||||
@Test
|
||||
void computeTimestampReportDocTest() throws Exception {
|
||||
mockMvc
|
||||
.perform(get(RestEndpoints.URL_MONITOR_TIMESTAMP_REPORT))
|
||||
.andExpect(MockMvcResultMatchers.status().isOk());
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
package pro.taskana.monitor.rest.models;
|
||||
package pro.taskana.monitor.rest.assembler;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
|
|
@ -19,11 +19,11 @@ import pro.taskana.monitor.api.reports.WorkbasketReport;
|
|||
import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
|
||||
import pro.taskana.monitor.api.reports.item.DetailedMonitorQueryItem;
|
||||
import pro.taskana.monitor.api.reports.item.MonitorQueryItem;
|
||||
import pro.taskana.monitor.rest.assembler.ReportRepresentationModelAssembler;
|
||||
import pro.taskana.monitor.rest.models.ReportRepresentationModel;
|
||||
|
||||
/** Test for {@link ReportRepresentationModelAssembler}. */
|
||||
@TaskanaSpringBootTest
|
||||
class ReportRepresentationModelTest {
|
||||
class ReportRepresentationModelAssemblerTest {
|
||||
|
||||
private final ReportRepresentationModelAssembler reportRepresentationModelAssembler;
|
||||
private int daysDiff;
|
||||
|
|
@ -31,7 +31,7 @@ class ReportRepresentationModelTest {
|
|||
private List<TimeIntervalColumnHeader> headers;
|
||||
|
||||
@Autowired
|
||||
ReportRepresentationModelTest(
|
||||
ReportRepresentationModelAssemblerTest(
|
||||
ReportRepresentationModelAssembler reportRepresentationModelAssembler) {
|
||||
this.reportRepresentationModelAssembler = reportRepresentationModelAssembler;
|
||||
}
|
||||
|
|
@ -635,7 +635,6 @@ class TaskControllerIntTest {
|
|||
assertThat(responseCreate.getBody()).isNotNull();
|
||||
|
||||
String taskIdOfCreatedTask = responseCreate.getBody().getTaskId();
|
||||
assertThat(taskIdOfCreatedTask).isNotNull();
|
||||
assertThat(taskIdOfCreatedTask).startsWith("TKI:");
|
||||
|
||||
String url2 = restHelper.toUrl(RestEndpoints.URL_TASKS_ID, taskIdOfCreatedTask);
|
||||
|
|
|
|||
|
|
@ -16,6 +16,7 @@ import org.junit.jupiter.api.function.ThrowingConsumer;
|
|||
import org.springframework.beans.factory.annotation.Autowired;
|
||||
import org.springframework.core.ParameterizedTypeReference;
|
||||
import org.springframework.hateoas.IanaLinkRelations;
|
||||
import org.springframework.hateoas.Link;
|
||||
import org.springframework.http.HttpEntity;
|
||||
import org.springframework.http.HttpMethod;
|
||||
import org.springframework.http.HttpStatus;
|
||||
|
|
@ -66,14 +67,12 @@ class WorkbasketAccessItemControllerIntTest {
|
|||
TEMPLATE.exchange(
|
||||
url, HttpMethod.GET, auth, WORKBASKET_ACCESS_ITEM_PAGED_REPRESENTATION_MODEL_TYPE);
|
||||
assertThat(response.getBody()).isNotNull();
|
||||
assertThat(response.getBody().getLink(IanaLinkRelations.SELF)).isNotNull();
|
||||
assertThat(
|
||||
response
|
||||
.getBody()
|
||||
.getRequiredLink(IanaLinkRelations.SELF)
|
||||
.getHref()
|
||||
.endsWith(parameters))
|
||||
.isTrue();
|
||||
assertThat(response.getBody().getLink(IanaLinkRelations.SELF))
|
||||
.isNotEmpty()
|
||||
.get()
|
||||
.extracting(Link::getHref)
|
||||
.asString()
|
||||
.endsWith(parameters);
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -90,16 +89,14 @@ class WorkbasketAccessItemControllerIntTest {
|
|||
assertThat(response.getBody().getContent()).hasSize(1);
|
||||
assertThat(response.getBody().getContent().iterator().next().getAccessId())
|
||||
.isEqualTo("user-1-1");
|
||||
assertThat(response.getBody().getLink(IanaLinkRelations.SELF)).isNotNull();
|
||||
assertThat(
|
||||
response
|
||||
.getBody()
|
||||
.getRequiredLink(IanaLinkRelations.SELF)
|
||||
.getHref()
|
||||
.endsWith(parameters))
|
||||
.isTrue();
|
||||
assertThat(response.getBody().getLink(IanaLinkRelations.FIRST)).isNotNull();
|
||||
assertThat(response.getBody().getLink(IanaLinkRelations.LAST)).isNotNull();
|
||||
assertThat(response.getBody().getLink(IanaLinkRelations.SELF))
|
||||
.isNotEmpty()
|
||||
.get()
|
||||
.extracting(Link::getHref)
|
||||
.asString()
|
||||
.endsWith(parameters);
|
||||
assertThat(response.getBody().getLink(IanaLinkRelations.FIRST)).isNotEmpty();
|
||||
assertThat(response.getBody().getLink(IanaLinkRelations.LAST)).isNotEmpty();
|
||||
assertThat(response.getBody().getPageMetadata().getSize()).isEqualTo(9);
|
||||
assertThat(response.getBody().getPageMetadata().getTotalElements()).isEqualTo(1);
|
||||
assertThat(response.getBody().getPageMetadata().getTotalPages()).isEqualTo(1);
|
||||
|
|
|
|||
|
|
@ -33,22 +33,6 @@ import pro.taskana.workbasket.rest.models.WorkbasketSummaryRepresentationModel;
|
|||
@TaskanaSpringBootTest
|
||||
class WorkbasketControllerIntTest {
|
||||
|
||||
private static final ParameterizedTypeReference<WorkbasketRepresentationModel>
|
||||
WORKBASKET_REPRESENTATION_MODEL_TYPE =
|
||||
new ParameterizedTypeReference<WorkbasketRepresentationModel>() {};
|
||||
|
||||
private static final ParameterizedTypeReference<WorkbasketSummaryPagedRepresentationModel>
|
||||
WORKBASKET_SUMMARY_PAGE_MODEL_TYPE =
|
||||
new ParameterizedTypeReference<WorkbasketSummaryPagedRepresentationModel>() {};
|
||||
|
||||
private static final ParameterizedTypeReference<WorkbasketAccessItemCollectionRepresentationModel>
|
||||
WORKBASKET_ACCESS_ITEM_COLLECTION_REPRESENTATION_TYPE =
|
||||
new ParameterizedTypeReference<WorkbasketAccessItemCollectionRepresentationModel>() {};
|
||||
|
||||
private static final ParameterizedTypeReference<DistributionTargetsCollectionRepresentationModel>
|
||||
DISTRIBUTION_TARGETS_COLLECTION_REPRESENTATION_MODEL_TYPE =
|
||||
new ParameterizedTypeReference<DistributionTargetsCollectionRepresentationModel>() {};
|
||||
|
||||
private final RestHelper restHelper;
|
||||
|
||||
@Autowired
|
||||
|
|
@ -64,7 +48,11 @@ class WorkbasketControllerIntTest {
|
|||
HttpEntity<Object> auth = new HttpEntity<>(RestHelper.generateHeadersForUser("teamlead-1"));
|
||||
|
||||
ResponseEntity<WorkbasketRepresentationModel> response =
|
||||
TEMPLATE.exchange(url, HttpMethod.GET, auth, WORKBASKET_REPRESENTATION_MODEL_TYPE);
|
||||
TEMPLATE.exchange(
|
||||
url,
|
||||
HttpMethod.GET,
|
||||
auth,
|
||||
ParameterizedTypeReference.forType(WorkbasketRepresentationModel.class));
|
||||
|
||||
assertThat(response.getBody()).isNotNull();
|
||||
assertThat(response.getBody().getLink(IanaLinkRelations.SELF)).isNotNull();
|
||||
|
|
@ -79,7 +67,11 @@ class WorkbasketControllerIntTest {
|
|||
HttpEntity<Object> auth = new HttpEntity<>(RestHelper.generateHeadersForUser("teamlead-1"));
|
||||
|
||||
ResponseEntity<WorkbasketSummaryPagedRepresentationModel> response =
|
||||
TEMPLATE.exchange(url, HttpMethod.GET, auth, WORKBASKET_SUMMARY_PAGE_MODEL_TYPE);
|
||||
TEMPLATE.exchange(
|
||||
url,
|
||||
HttpMethod.GET,
|
||||
auth,
|
||||
ParameterizedTypeReference.forType(WorkbasketSummaryPagedRepresentationModel.class));
|
||||
|
||||
assertThat(response.getBody()).isNotNull();
|
||||
assertThat(response.getBody().getLink(IanaLinkRelations.SELF)).isNotNull();
|
||||
|
|
@ -91,7 +83,11 @@ class WorkbasketControllerIntTest {
|
|||
HttpEntity<Object> auth = new HttpEntity<>(RestHelper.generateHeadersForUser("teamlead-1"));
|
||||
|
||||
ResponseEntity<WorkbasketSummaryPagedRepresentationModel> response =
|
||||
TEMPLATE.exchange(url, HttpMethod.GET, auth, WORKBASKET_SUMMARY_PAGE_MODEL_TYPE);
|
||||
TEMPLATE.exchange(
|
||||
url,
|
||||
HttpMethod.GET,
|
||||
auth,
|
||||
ParameterizedTypeReference.forType(WorkbasketSummaryPagedRepresentationModel.class));
|
||||
|
||||
assertThat(response.getBody()).isNotNull();
|
||||
assertThat(response.getBody().getRequiredLink(IanaLinkRelations.SELF)).isNotNull();
|
||||
|
|
@ -105,7 +101,11 @@ class WorkbasketControllerIntTest {
|
|||
HttpEntity<Object> auth = new HttpEntity<>(RestHelper.generateHeadersForUser("teamlead-1"));
|
||||
|
||||
ResponseEntity<WorkbasketSummaryPagedRepresentationModel> response =
|
||||
TEMPLATE.exchange(url, HttpMethod.GET, auth, WORKBASKET_SUMMARY_PAGE_MODEL_TYPE);
|
||||
TEMPLATE.exchange(
|
||||
url,
|
||||
HttpMethod.GET,
|
||||
auth,
|
||||
ParameterizedTypeReference.forType(WorkbasketSummaryPagedRepresentationModel.class));
|
||||
|
||||
assertThat(response.getBody()).isNotNull();
|
||||
assertThat(response.getBody().getLink(IanaLinkRelations.SELF)).isNotNull();
|
||||
|
|
@ -126,7 +126,11 @@ class WorkbasketControllerIntTest {
|
|||
HttpEntity<Object> auth = new HttpEntity<>(RestHelper.generateHeadersForUser("teamlead-1"));
|
||||
|
||||
ResponseEntity<WorkbasketRepresentationModel> initialWorkbasketResourceRequestResponse =
|
||||
TEMPLATE.exchange(url, HttpMethod.GET, auth, WORKBASKET_REPRESENTATION_MODEL_TYPE);
|
||||
TEMPLATE.exchange(
|
||||
url,
|
||||
HttpMethod.GET,
|
||||
auth,
|
||||
ParameterizedTypeReference.forType(WorkbasketRepresentationModel.class));
|
||||
WorkbasketRepresentationModel workbasketRepresentationModel =
|
||||
initialWorkbasketResourceRequestResponse.getBody();
|
||||
assertThat(workbasketRepresentationModel).isNotNull();
|
||||
|
|
@ -142,9 +146,13 @@ class WorkbasketControllerIntTest {
|
|||
workbasketRepresentationModel, RestHelper.generateHeadersForUser("teamlead-1"));
|
||||
|
||||
ThrowingCallable httpCall =
|
||||
() -> {
|
||||
TEMPLATE.exchange(url, HttpMethod.PUT, auth2, WORKBASKET_REPRESENTATION_MODEL_TYPE);
|
||||
};
|
||||
() ->
|
||||
TEMPLATE.exchange(
|
||||
url,
|
||||
HttpMethod.PUT,
|
||||
auth2,
|
||||
ParameterizedTypeReference.<WorkbasketRepresentationModel>forType(
|
||||
WorkbasketRepresentationModel.class));
|
||||
assertThatThrownBy(httpCall)
|
||||
.extracting(HttpStatusCodeException.class::cast)
|
||||
.extracting(HttpStatusCodeException::getStatusCode)
|
||||
|
|
@ -159,9 +167,13 @@ class WorkbasketControllerIntTest {
|
|||
HttpEntity<Object> auth = new HttpEntity<>(RestHelper.generateHeadersForUser("businessadmin"));
|
||||
|
||||
ThrowingCallable httpCall =
|
||||
() -> {
|
||||
TEMPLATE.exchange(url, HttpMethod.GET, auth, WORKBASKET_REPRESENTATION_MODEL_TYPE);
|
||||
};
|
||||
() ->
|
||||
TEMPLATE.exchange(
|
||||
url,
|
||||
HttpMethod.GET,
|
||||
auth,
|
||||
ParameterizedTypeReference.<WorkbasketRepresentationModel>forType(
|
||||
WorkbasketRepresentationModel.class));
|
||||
|
||||
assertThatThrownBy(httpCall)
|
||||
.isInstanceOf(HttpStatusCodeException.class)
|
||||
|
|
@ -177,7 +189,11 @@ class WorkbasketControllerIntTest {
|
|||
HttpEntity<Object> auth = new HttpEntity<>(RestHelper.generateHeadersForUser("teamlead-1"));
|
||||
|
||||
ResponseEntity<WorkbasketSummaryPagedRepresentationModel> response =
|
||||
TEMPLATE.exchange(url, HttpMethod.GET, auth, WORKBASKET_SUMMARY_PAGE_MODEL_TYPE);
|
||||
TEMPLATE.exchange(
|
||||
url,
|
||||
HttpMethod.GET,
|
||||
auth,
|
||||
ParameterizedTypeReference.forType(WorkbasketSummaryPagedRepresentationModel.class));
|
||||
|
||||
assertThat(response.getBody()).isNotNull();
|
||||
assertThat(response.getBody().getContent()).hasSize(5);
|
||||
|
|
@ -216,9 +232,7 @@ class WorkbasketControllerIntTest {
|
|||
HttpEntity<Object> auth = new HttpEntity<>(RestHelper.generateHeadersForUser("businessadmin"));
|
||||
|
||||
ThrowingCallable call =
|
||||
() -> {
|
||||
TEMPLATE.exchange(url, HttpMethod.DELETE, auth, Void.class);
|
||||
};
|
||||
() -> TEMPLATE.exchange(url, HttpMethod.DELETE, auth, Void.class);
|
||||
|
||||
assertThatThrownBy(call)
|
||||
.isInstanceOf(HttpStatusCodeException.class)
|
||||
|
|
@ -244,7 +258,11 @@ class WorkbasketControllerIntTest {
|
|||
"WBI:100000000000000000000000000000000002");
|
||||
ResponseEntity<DistributionTargetsCollectionRepresentationModel> response2 =
|
||||
TEMPLATE.exchange(
|
||||
url2, HttpMethod.GET, auth, DISTRIBUTION_TARGETS_COLLECTION_REPRESENTATION_MODEL_TYPE);
|
||||
url2,
|
||||
HttpMethod.GET,
|
||||
auth,
|
||||
ParameterizedTypeReference.forType(
|
||||
DistributionTargetsCollectionRepresentationModel.class));
|
||||
|
||||
assertThat(response2.getStatusCode()).isEqualTo(HttpStatus.OK);
|
||||
assertThat(response2.getBody()).isNotNull();
|
||||
|
|
@ -263,7 +281,11 @@ class WorkbasketControllerIntTest {
|
|||
|
||||
ResponseEntity<WorkbasketAccessItemCollectionRepresentationModel> response =
|
||||
TEMPLATE.exchange(
|
||||
url, HttpMethod.GET, auth, WORKBASKET_ACCESS_ITEM_COLLECTION_REPRESENTATION_TYPE);
|
||||
url,
|
||||
HttpMethod.GET,
|
||||
auth,
|
||||
ParameterizedTypeReference.forType(
|
||||
WorkbasketAccessItemCollectionRepresentationModel.class));
|
||||
|
||||
assertThat(response.getBody()).isNotNull();
|
||||
assertThat(response.getBody().getLink(IanaLinkRelations.SELF)).isNotNull();
|
||||
|
|
@ -281,7 +303,11 @@ class WorkbasketControllerIntTest {
|
|||
|
||||
ResponseEntity<DistributionTargetsCollectionRepresentationModel> response =
|
||||
TEMPLATE.exchange(
|
||||
url, HttpMethod.GET, auth, DISTRIBUTION_TARGETS_COLLECTION_REPRESENTATION_MODEL_TYPE);
|
||||
url,
|
||||
HttpMethod.GET,
|
||||
auth,
|
||||
ParameterizedTypeReference.forType(
|
||||
DistributionTargetsCollectionRepresentationModel.class));
|
||||
|
||||
assertThat(response.getBody()).isNotNull();
|
||||
assertThat(response.getBody().getLink(IanaLinkRelations.SELF)).isNotNull();
|
||||
|
|
@ -300,7 +326,13 @@ class WorkbasketControllerIntTest {
|
|||
HttpEntity<Object> auth = new HttpEntity<>(RestHelper.generateHeadersForUser("teamlead-1"));
|
||||
|
||||
ThrowingCallable httpCall =
|
||||
() -> TEMPLATE.exchange(url, HttpMethod.GET, auth, WORKBASKET_SUMMARY_PAGE_MODEL_TYPE);
|
||||
() ->
|
||||
TEMPLATE.exchange(
|
||||
url,
|
||||
HttpMethod.GET,
|
||||
auth,
|
||||
ParameterizedTypeReference.forType(
|
||||
WorkbasketSummaryPagedRepresentationModel.class));
|
||||
|
||||
assertThatThrownBy(httpCall)
|
||||
.isInstanceOf(HttpStatusCodeException.class)
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@ export class MonitorService {
|
|||
states: [TaskState.READY, TaskState.CLAIMED, TaskState.COMPLETED]
|
||||
};
|
||||
return this.httpClient.get<ReportData>(
|
||||
`${environment.taskanaRestUrl + monitorUrl}tasks-status-report${asUrlQueryString(queryParams)}`
|
||||
`${environment.taskanaRestUrl + monitorUrl}task-status-report${asUrlQueryString(queryParams)}`
|
||||
);
|
||||
}
|
||||
|
||||
|
|
@ -27,22 +27,22 @@ export class MonitorService {
|
|||
states: [TaskState.READY, TaskState.CLAIMED, TaskState.COMPLETED]
|
||||
};
|
||||
return this.httpClient.get<ReportData>(
|
||||
`${environment.taskanaRestUrl + monitorUrl}tasks-workbasket-report${asUrlQueryString(queryParams)}`
|
||||
`${environment.taskanaRestUrl + monitorUrl}workbasket-report${asUrlQueryString(queryParams)}`
|
||||
);
|
||||
}
|
||||
|
||||
getWorkbasketStatisticsQueryingByPlannedDate(): Observable<ReportData> {
|
||||
const queryParams = {
|
||||
daysInPast: 7,
|
||||
'task-timetamp': 'PLANNED',
|
||||
states: [TaskState.READY, TaskState.CLAIMED, TaskState.COMPLETED]
|
||||
};
|
||||
return this.httpClient.get<ReportData>(
|
||||
`${environment.taskanaRestUrl}/v1/monitor/tasks-workbasket-planned-date-report${asUrlQueryString(queryParams)}`
|
||||
`${environment.taskanaRestUrl}/v1/monitor/workbasket-report${asUrlQueryString(queryParams)}`
|
||||
);
|
||||
}
|
||||
|
||||
getClassificationTasksReport(): Observable<ReportData> {
|
||||
return this.httpClient.get<ReportData>(`${environment.taskanaRestUrl + monitorUrl}tasks-classification-report`);
|
||||
return this.httpClient.get<ReportData>(`${environment.taskanaRestUrl + monitorUrl}classification-report`);
|
||||
}
|
||||
|
||||
getDailyEntryExitReport(): Observable<ReportData> {
|
||||
|
|
|
|||
Loading…
Reference in New Issue