TSK-1914: introduce IN_REVIEW and READY_FOR_REVIEW Task status
This commit is contained in:
ryzheboka
Elena Mokeeva
parent
a0aec39cfa
commit
83890ddd16
|
|
@ -81,6 +81,8 @@ INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000047', 'ETI:0000000
|
|||
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000048', 'ETI:000000000000000000000000000000000048', RELATIVE_DATE(0) , RELATIVE_DATE(0) , null , RELATIVE_DATE(0) , null , RELATIVE_DATE(0) , RELATIVE_DATE(210) , 'Task48', 'teamlead-2', 'Some description.', 'Some custom Note', 1 , -1 , 'CLAIMED', 'MANUAL' , 'L40000' , 'CLI:000000000000000000000000000000000004', 'WBI:000000000000000000000000000000000001', 'USER-1-1' , 'DOMAIN_A', 'BPI21' , 'PBPI21' , 'John', 'MyCompany1', 'MySystem1', 'MyInstance1', 'MyType1', 'MyValue1', true , false , null , 'NONE' , null , 'Geschaeftsstelle A' , 'Vollkasko' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , 'VALUE_48' , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000049', 'ETI:000000000000000000000000000000000049', RELATIVE_DATE(0) , RELATIVE_DATE(0) , null , RELATIVE_DATE(0) , null , RELATIVE_DATE(0) , RELATIVE_DATE(28000) , 'Task49', 'teamlead-2', 'Some description.', 'Some custom Note', 1 , -1 , 'CLAIMED', 'MANUAL' , 'L40000' , 'CLI:000000000000000000000000000000000004', 'WBI:000000000000000000000000000000000003', 'USER-1-3' , 'DOMAIN_A', 'BPI21' , 'PBPI21' , 'John', 'MyCompany1', 'MySystem1', 'MyInstance1', 'MyType1', 'MyValue1', true , false , null , 'NONE' , null , 'Geschaeftsstelle C' , 'Vollkasko' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , 'VALUE_49' , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000050', 'ETI:000000000000000000000000000000000050', RELATIVE_DATE(0) , RELATIVE_DATE(0) , null , RELATIVE_DATE(0) , null , RELATIVE_DATE(0) , RELATIVE_DATE(700000), 'Task50', 'teamlead-2', 'Some description.', 'Some custom Note', 1 , -1 , 'CLAIMED', 'MANUAL' , 'L40000' , 'CLI:000000000000000000000000000000000004', 'WBI:000000000000000000000000000000000002', 'USER-1-2' , 'DOMAIN_C', 'BPI21' , 'PBPI21' , 'John', 'MyCompany1', 'MySystem1', 'MyInstance1', 'MyType1', 'MyValue1', true , false , null , 'NONE' , null , 'Geschaeftsstelle A' , 'Teilkasko' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , 'VALUE_50' , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:100000000000000000000000000000000050', 'ETI:100000000000000000000000000000000050', RELATIVE_DATE(0) , RELATIVE_DATE(0) , null , RELATIVE_DATE(0) , null , RELATIVE_DATE(0) , RELATIVE_DATE(700000), 'Task50', 'teamlead-2', 'Some description.', 'Some custom Note', 1 , -1 , 'IN_REVIEW', 'MANUAL' , 'L40000' , 'CLI:000000000000000000000000000000000004', 'WBI:000000000000000000000000000000000002', 'USER-1-2' , 'DOMAIN_C', 'BPI21' , 'PBPI21' , 'John', 'MyCompany1', 'MySystem1', 'MyInstance1', 'MyType1', 'MyValue1', true , false , null , 'NONE' , null , 'Geschaeftsstelle A' , 'Teilkasko' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , 'VALUE_50' , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:200000000000000000000000000000000050', 'ETI:200000000000000000000000000000000050', RELATIVE_DATE(0) , RELATIVE_DATE(0) , null , RELATIVE_DATE(0) , null , RELATIVE_DATE(0) , RELATIVE_DATE(700000), 'Task50', 'teamlead-2', 'Some description.', 'Some custom Note', 1 , -1 , 'READY_FOR_REVIEW', 'MANUAL' , 'L40000' , 'CLI:000000000000000000000000000000000004', 'WBI:000000000000000000000000000000000002', 'USER-1-2' , 'DOMAIN_C', 'BPI21' , 'PBPI21' , 'John', 'MyCompany1', 'MySystem1', 'MyInstance1', 'MyType1', 'MyValue1', true , false , null , 'NONE' , null , 'Geschaeftsstelle A' , 'Teilkasko' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , 'VALUE_50' , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
-- Task for TransferAccTest
|
||||
INSERT INTO TASK VALUES('TKI:100000000000000000000000000000000098', 'ETI:100000000000000000000000000000000098', RELATIVE_DATE(0) , RELATIVE_DATE(0) , null , RELATIVE_DATE(0) , null , RELATIVE_DATE(0) , RELATIVE_DATE(7) , 'Task51', 'teamlead-1', 'Some description.', 'Some custom Note', 305 , -1 , 'READY' , 'EXTERN' , 'L50000' , 'CLI:000000000000000000000000000000000005', 'WBI:000000000000000000000000000000000005', 'GPK-1' , 'DOMAIN_C', 'BPI21' , 'PBPI21' , 'John', 'MyCompany1', 'MySystem1', 'MyInstance1', 'MyType1', 'MyValue1', true , false , null , 'NONE' , null , 'Geschaeftsstelle B' , 'Teilkasko' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , 'VALUE_41' , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:200000000000000000000000000000000099', 'ETI:200000000000000000000000000000000099', RELATIVE_DATE(0) , RELATIVE_DATE(0) , null , RELATIVE_DATE(0) , null , RELATIVE_DATE(0) , RELATIVE_DATE(14) , 'Task52', 'teamlead-1', 'Some description.', 'Some custom Note', 505 , -1 , 'CLAIMED', 'EXTERN' , 'L50000' , 'CLI:000000000000000000000000000000000005', 'WBI:000000000000000000000000000000000005', 'GPK-1' , 'DOMAIN_C', 'BPI21' , 'PBPI21' , 'John', 'MyCompany1', 'MySystem1', 'MyInstance1', 'MyType1', 'MyValue1', true , false , null , 'NONE' , null , 'Geschaeftsstelle C' , 'Teilkasko' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , 'VALUE_42' , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
|
|
|
|||
|
|
@ -27,9 +27,18 @@ INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000023', 'ETI:0000000
|
|||
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000024', 'ETI:000000000000000000000000000000000024', '2018-01-29 15:55:24', null , null , '2018-01-29 15:55:24', null , '2018-01-29 15:55:00', '2018-01-30 15:55:00', 'Widerruf' , 'creator_user_id' , 'Widerruf' , null , 2 , -1 , 'READY' , 'EXTERN' , 'L1050' , 'CLI:100000000000000000000000000000000003', 'WBI:100000000000000000000000000000000001' , 'GPK_KSC' , 'DOMAIN_A', 'PI_0000000000024' , 'DOC_0000000000000000024' , null , '00' , 'PASystem' , '00' , 'SDNR' , '11223344' , false , false , null , 'NONE' , null , '' , '' , '' , '' , '' , '' , '' , '' , null , '' , '' , '' , '' , 'abc' , '' , '' , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
-- Tasks for WorkOnTaskAccTest
|
||||
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000025', 'ETI:000000000000000000000000000000000025', '2018-01-29 15:55:24', null , null , '2018-01-29 15:55:24', '2018-01-29 15:55:24', '2018-01-29 15:55:00', '2018-01-30 15:55:00', 'Widerruf' , 'creator_user_id' , 'Widerruf' , null , 2 , -1 , 'READY' , 'EXTERN' , 'L1050' , 'CLI:100000000000000000000000000000000003', 'WBI:100000000000000000000000000000000007' , 'USER-1-2' , 'DOMAIN_A', 'PI_0000000000025' , 'DOC_0000000000000000025' , null , 'abcd00' , 'PASystem' , '00' , 'SDNR' , '98765432' , false , false , null , 'NONE' , null , '' , '' , '' , '' , '' , '' , '' , '' , '' , 'ert' , 'ert' , 'ert' , 'ert' , 'abc' , 'ert' , 'ert' , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:100000000000000000000000000000000025', 'ETI:100000000000000000000000000000000025', '2018-01-29 15:55:24', null , null , '2018-01-29 15:55:24', '2018-01-29 15:55:24', '2018-01-29 15:55:00', '2018-01-30 15:55:00', 'Widerruf' , 'creator_user_id' , 'Widerruf' , null , 2 , -1 , 'READY_FOR_REVIEW' , 'EXTERN' , 'L1050' , 'CLI:100000000000000000000000000000000003', 'WBI:100000000000000000000000000000000007' , 'USER-1-2' , 'DOMAIN_A', 'PI_0000000000025' , 'DOC_0000000000000000025' , null , 'abcd00' , 'PASystem' , '00' , 'SDNR' , '98765432' , false , false , null , 'NONE' , null , '' , '' , '' , '' , '' , '' , '' , '' , '' , 'ert' , 'ert' , 'ert' , 'ert' , 'abc' , 'ert' , 'ert' , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:200000000000000000000000000000000025', 'ETI:200000000000000000000000000000000025', '2018-01-29 15:55:24', null , null , '2018-01-29 15:55:24', '2018-01-29 15:55:24', '2018-01-29 15:55:00', '2018-01-30 15:55:00', 'Widerruf' , 'creator_user_id' , 'Widerruf' , null , 2 , -1 , 'IN_REVIEW' , 'EXTERN' , 'L1050' , 'CLI:100000000000000000000000000000000003', 'WBI:100000000000000000000000000000000007' , 'USER-1-2' , 'DOMAIN_A', 'PI_0000000000025' , 'DOC_0000000000000000025' , 'user-1-2' , 'abcd00' , 'PASystem' , '00' , 'SDNR' , '98765432' , false , false , null , 'NONE' , null , '' , '' , '' , '' , '' , '' , '' , '' , '' , 'ert' , 'ert' , 'ert' , 'ert' , 'abc' , 'ert' , 'ert' , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000026', 'ETI:000000000000000000000000000000000026', '2018-01-29 15:55:24', '2018-01-30 15:55:24', null , '2018-01-30 15:55:24', '2018-01-29 15:55:24', '2018-01-29 15:55:00', '2018-01-30 15:55:00', 'Widerruf' , 'creator_user_id' , 'Widerruf' , null , 2 , -1 , 'CLAIMED' , 'EXTERN' , 'L1050' , 'CLI:100000000000000000000000000000000003', 'WBI:100000000000000000000000000000000007' , 'USER-1-2' , 'DOMAIN_A', 'PI_0000000000026' , 'DOC_0000000000000000026' , 'user-1-1' , 'bcde00' , 'PASystem' , '00' , 'SDNR' , '98765432' , true , false , null , 'NONE' , null , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , 'abc' , '' , '' , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000027', 'ETI:000000000000000000000000000000000027', '2018-01-29 15:55:24', '2018-01-30 15:55:24', null , '2018-01-30 15:55:24', '2018-01-29 15:55:24', '2018-01-29 15:55:00', '2018-01-30 15:55:00', 'Widerruf' , 'creator_user_id' , 'Widerruf' , null , 2 , -1 , 'CLAIMED' , 'EXTERN' , 'L1050' , 'CLI:100000000000000000000000000000000003', 'WBI:100000000000000000000000000000000007' , 'USER-1-2' , 'DOMAIN_A', 'PI_0000000000027' , 'DOC_0000000000000000027' , 'user-1-2' , 'cdef00' , 'PASystem' , '00' , 'SDNR' , '98765432' , true , false , null , 'NONE' , null , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , 'abc' , '' , '' , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000028', 'ETI:000000000000000000000000000000000028', '2018-01-29 15:55:24', '2018-01-30 15:55:24', null , '2018-01-30 15:55:24', '2018-01-29 15:55:24', '2018-01-29 15:55:00', '2018-01-30 15:55:00', 'Widerruf' , 'creator_user_id' , 'Widerruf' , null , 2 , -1 , 'CLAIMED' , 'EXTERN' , 'L1050' , 'CLI:100000000000000000000000000000000003', 'WBI:100000000000000000000000000000000007' , 'USER-1-2' , 'DOMAIN_A', 'PI_0000000000028' , 'DOC_0000000000000000028' , 'user-1-1' , 'efgh00' , 'PASystem' , '00' , 'SDNR' , '98765432' , true , false , null , 'NONE' , null , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , 'abc' , '' , '' , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:100000000000000000000000000000000028', 'ETI:100000000000000000000000000000000028', '2018-01-29 15:55:24', '2018-01-30 15:55:24', null , '2018-01-30 15:55:24', '2018-01-29 15:55:24', '2018-01-29 15:55:00', '2018-01-30 15:55:00', 'Widerruf' , 'creator_user_id' , 'Widerruf' , null , 2 , -1 , 'IN_REVIEW' , 'EXTERN' , 'L1050' , 'CLI:100000000000000000000000000000000003', 'WBI:100000000000000000000000000000000007' , 'USER-1-2' , 'DOMAIN_A', 'PI_0000000000028' , 'DOC_0000000000000000028' , null , 'efgh00' , 'PASystem' , '00' , 'SDNR' , '98765432' , true , false , null , 'NONE' , null , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , 'abc' , '' , '' , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:200000000000000000000000000000000028', 'ETI:200000000000000000000000000000000028', '2018-01-29 15:55:24', '2018-01-30 15:55:24', null , '2018-01-30 15:55:24', '2018-01-29 15:55:24', '2018-01-29 15:55:00', '2018-01-30 15:55:00', 'Widerruf' , 'creator_user_id' , 'Widerruf' , null , 2 , -1 , 'IN_REVIEW' , 'EXTERN' , 'L1050' , 'CLI:100000000000000000000000000000000003', 'WBI:100000000000000000000000000000000007' , 'USER-1-2' , 'DOMAIN_A', 'PI_0000000000028' , 'DOC_0000000000000000028' , 'user-1-1' , 'efgh00' , 'PASystem' , '00' , 'SDNR' , '98765432' , true , false , null , 'NONE' , null , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , 'abc' , '' , '' , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:300000000000000000000000000000000028', 'ETI:300000000000000000000000000000000028', '2018-01-29 15:55:24', '2018-01-30 15:55:24', null , '2018-01-30 15:55:24', '2018-01-29 15:55:24', '2018-01-29 15:55:00', '2018-01-30 15:55:00', 'Widerruf' , 'creator_user_id' , 'Widerruf' , null , 2 , -1 , 'IN_REVIEW' , 'EXTERN' , 'L1050' , 'CLI:100000000000000000000000000000000003', 'WBI:100000000000000000000000000000000007' , 'USER-1-2' , 'DOMAIN_A', 'PI_0000000000028' , 'DOC_0000000000000000028' , 'user-1-1' , 'efgh00' , 'PASystem' , '00' , 'SDNR' , '98765432' , true , false , null , 'NONE' , null , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , 'abc' , '' , '' , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:400000000000000000000000000000000028', 'ETI:400000000000000000000000000000000028', '2018-01-29 15:55:24', '2018-01-30 15:55:24', null , '2018-01-30 15:55:24', '2018-01-29 15:55:24', '2018-01-29 15:55:00', '2018-01-30 15:55:00', 'Widerruf' , 'creator_user_id' , 'Widerruf' , null , 2 , -1 , 'IN_REVIEW' , 'EXTERN' , 'L1050' , 'CLI:100000000000000000000000000000000003', 'WBI:100000000000000000000000000000000007' , 'USER-1-2' , 'DOMAIN_A', 'PI_0000000000028' , 'DOC_0000000000000000028' , 'user-1-2' , 'efgh00' , 'PASystem' , '00' , 'SDNR' , '98765432' , true , false , null , 'NONE' , null , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , 'abc' , '' , '' , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:500000000000000000000000000000000028', 'ETI:500000000000000000000000000000000028', '2018-01-29 15:55:24', '2018-01-30 15:55:24', null , '2018-01-30 15:55:24', '2018-01-29 15:55:24', '2018-01-29 15:55:00', '2018-01-30 15:55:00', 'Widerruf' , 'creator_user_id' , 'Widerruf' , null , 2 , -1 , 'READY_FOR_REVIEW' , 'EXTERN' , 'L1050' , 'CLI:100000000000000000000000000000000003', 'WBI:100000000000000000000000000000000007' , 'USER-1-2' , 'DOMAIN_A', 'PI_0000000000028' , 'DOC_0000000000000000028' , 'user-1-1' , 'efgh00' , 'PASystem' , '00' , 'SDNR' , '98765432' , true , false , null , 'NONE' , null , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , 'abc' , '' , '' , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:600000000000000000000000000000000028', 'ETI:600000000000000000000000000000000028', '2018-01-29 15:55:24', '2018-01-30 15:55:24', null , '2018-01-30 15:55:24', '2018-01-29 15:55:24', '2018-01-29 15:55:00', '2018-01-30 15:55:00', 'Widerruf' , 'creator_user_id' , 'Widerruf' , null , 2 , -1 , 'IN_REVIEW' , 'EXTERN' , 'L1050' , 'CLI:100000000000000000000000000000000003', 'WBI:100000000000000000000000000000000007' , 'USER-1-2' , 'DOMAIN_A', 'PI_0000000000028' , 'DOC_0000000000000000028' , 'user-1-1' , 'efgh00' , 'PASystem' , '00' , 'SDNR' , '98765432' , true , false , null , 'NONE' , null , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , 'abc' , '' , '' , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:700000000000000000000000000000000028', 'ETI:700000000000000000000000000000000028', '2018-01-29 15:55:24', '2018-01-30 15:55:24', null , '2018-01-30 15:55:24', '2018-01-29 15:55:24', '2018-01-29 15:55:00', '2018-01-30 15:55:00', 'Widerruf' , 'creator_user_id' , 'Widerruf' , null , 2 , -1 , 'IN_REVIEW' , 'EXTERN' , 'L1050' , 'CLI:100000000000000000000000000000000003', 'WBI:100000000000000000000000000000000007' , 'USER-1-2' , 'DOMAIN_A', 'PI_0000000000028' , 'DOC_0000000000000000028' , 'user-1-1' , 'efgh00' , 'PASystem' , '00' , 'SDNR' , '98765432' , true , false , null , 'NONE' , null , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , 'abc' , '' , '' , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000029', 'ETI:000000000000000000000000000000000029', '2018-01-29 15:55:24', '2018-01-30 15:55:24', null , '2018-01-30 15:55:24', '2018-01-29 15:55:24', '2018-01-29 15:55:00', '2018-01-30 15:55:00', 'Widerruf' , 'creator_user_id' , 'Widerruf' , null , 2 , -1 , 'CLAIMED' , 'EXTERN' , 'L1050' , 'CLI:100000000000000000000000000000000003', 'WBI:100000000000000000000000000000000007' , 'USER-1-2' , 'DOMAIN_A', 'PI_0000000000029' , 'DOC_0000000000000000029' , 'user-1-2' , 'fghj00' , 'PASystem' , '00' , 'SDNR' , '98765432' , true , false , null , 'NONE' , null , '' , '' , '' , '' , '' , '' , '' , '' , '' , 'dde' , 'dde' , 'dde' , 'dde' , 'abc' , 'dde' , 'dde' , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000030', 'ETI:000000000000000000000000000000000030', '2018-01-29 15:55:24', '2018-01-30 15:55:24', null , '2018-01-30 15:55:24', '2018-01-29 15:55:24', '2018-01-29 15:55:00', '2018-01-30 15:55:00', 'Widerruf' , 'creator_user_id' , 'Widerruf' , null , 2 , -1 , 'CLAIMED' , 'EXTERN' , 'L1050' , 'CLI:100000000000000000000000000000000003', 'WBI:100000000000000000000000000000000007' , 'USER-1-2' , 'DOMAIN_A', 'PI_0000000000030' , 'DOC_0000000000000000030' , 'user-1-1' , 'ABCD00' , 'PASystem' , '00' , 'SDNR' , '98765432' , true , false , null , 'NONE' , null , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , 'abc' , '' , '' , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000031', 'ETI:000000000000000000000000000000000031', '2018-01-29 15:55:24', '2018-01-30 15:55:24', null , '2018-01-30 15:55:24', '2018-01-29 15:55:24', '2018-01-29 15:55:00', '2018-01-30 15:55:00', 'Widerruf' , 'creator_user_id' , 'Widerruf' , null , 2 , -1 , 'CLAIMED' , 'EXTERN' , 'L1050' , 'CLI:100000000000000000000000000000000003', 'WBI:100000000000000000000000000000000007' , 'USER-1-2' , 'DOMAIN_A', 'PI_0000000000031' , 'DOC_0000000000000000031' , 'user-1-1' , 'BDCE00' , 'PASystem' , '00' , 'SDNR' , '98765432' , true , false , null , 'NONE' , null , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , 'abc' , '' , '' , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
|
||||
|
|
|
|||
|
|
@ -175,7 +175,8 @@ class CompleteTaskAccTest {
|
|||
InvalidTaskStateException e = catchThrowableOfType(call, InvalidTaskStateException.class);
|
||||
assertThat(e.getTaskId()).isEqualTo(task.getId());
|
||||
assertThat(e.getTaskState()).isEqualTo(task.getState());
|
||||
assertThat(e.getRequiredTaskStates()).containsExactlyInAnyOrder(TaskState.CLAIMED);
|
||||
assertThat(e.getRequiredTaskStates())
|
||||
.containsExactlyInAnyOrder(TaskState.CLAIMED, TaskState.IN_REVIEW);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
|
|
@ -401,8 +402,8 @@ class CompleteTaskAccTest {
|
|||
assertThat(results.getErrorMap().values()).hasOnlyElementsOfType(InvalidStateException.class);
|
||||
assertThat(results.getErrorForId(task.getId()))
|
||||
.hasMessage(
|
||||
"Task with id '%s' is in state: '%s', but must be in one of these states: '[%s]'",
|
||||
task.getId(), TaskState.READY, TaskState.CLAIMED);
|
||||
"Task with id '%s' is in state: '%s', but must be in one of these states: '[%s, %s]'",
|
||||
task.getId(), TaskState.READY, TaskState.CLAIMED, TaskState.IN_REVIEW);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
|
|
|
|||
|
|
@ -2,10 +2,12 @@ package pro.taskana.task.api;
|
|||
|
||||
import java.util.Arrays;
|
||||
|
||||
/** This enum contains all status of the tasks. */
|
||||
/** The TaskState contains all status of a {@linkplain pro.taskana.task.api.models.Task Task}. */
|
||||
public enum TaskState {
|
||||
READY,
|
||||
CLAIMED,
|
||||
READY_FOR_REVIEW,
|
||||
IN_REVIEW,
|
||||
COMPLETED,
|
||||
CANCELLED,
|
||||
TERMINATED;
|
||||
|
|
|
|||
|
|
@ -1196,7 +1196,11 @@ public class TaskServiceImpl implements TaskService {
|
|||
task.setModified(now);
|
||||
task.setClaimed(now);
|
||||
task.setRead(true);
|
||||
task.setState(TaskState.CLAIMED);
|
||||
if (Set.of(TaskState.READY_FOR_REVIEW, TaskState.IN_REVIEW).contains(task.getState())) {
|
||||
task.setState(TaskState.IN_REVIEW);
|
||||
} else {
|
||||
task.setState(TaskState.CLAIMED);
|
||||
}
|
||||
}
|
||||
|
||||
private static void cancelClaimActionsOnTask(TaskSummaryImpl task, Instant now) {
|
||||
|
|
@ -1204,7 +1208,11 @@ public class TaskServiceImpl implements TaskService {
|
|||
task.setModified(now);
|
||||
task.setClaimed(null);
|
||||
task.setRead(true);
|
||||
task.setState(TaskState.READY);
|
||||
if (task.getState() == TaskState.IN_REVIEW) {
|
||||
task.setState(TaskState.READY_FOR_REVIEW);
|
||||
} else {
|
||||
task.setState(TaskState.READY);
|
||||
}
|
||||
}
|
||||
|
||||
private static void completeActionsOnTask(TaskSummaryImpl task, String userId, Instant now) {
|
||||
|
|
@ -1223,13 +1231,16 @@ public class TaskServiceImpl implements TaskService {
|
|||
}
|
||||
|
||||
String userId = taskanaEngine.getEngine().getCurrentUserContext().getUserid();
|
||||
if (!forced && state == TaskState.CLAIMED && !task.getOwner().equals(userId)) {
|
||||
if (!forced
|
||||
&& (state == TaskState.CLAIMED || state == TaskState.IN_REVIEW)
|
||||
&& !task.getOwner().equals(userId)) {
|
||||
throw new InvalidOwnerException(userId, task.getId());
|
||||
}
|
||||
}
|
||||
|
||||
private static boolean taskIsNotClaimed(TaskSummary task) {
|
||||
return task.getClaimed() == null || task.getState() != TaskState.CLAIMED;
|
||||
return task.getClaimed() == null
|
||||
|| (task.getState() != TaskState.CLAIMED && task.getState() != TaskState.IN_REVIEW);
|
||||
}
|
||||
|
||||
private static void checkIfTaskIsTerminatedOrCancelled(TaskSummary task)
|
||||
|
|
@ -1245,7 +1256,8 @@ public class TaskServiceImpl implements TaskService {
|
|||
private void checkPreconditionsForCompleteTask(TaskSummary task)
|
||||
throws InvalidStateException, InvalidOwnerException {
|
||||
if (taskIsNotClaimed(task)) {
|
||||
throw new InvalidTaskStateException(task.getId(), task.getState(), TaskState.CLAIMED);
|
||||
throw new InvalidTaskStateException(
|
||||
task.getId(), task.getState(), TaskState.CLAIMED, TaskState.IN_REVIEW);
|
||||
} else if (!taskanaEngine
|
||||
.getEngine()
|
||||
.getCurrentUserContext()
|
||||
|
|
@ -1275,7 +1287,9 @@ public class TaskServiceImpl implements TaskService {
|
|||
throw new InvalidTaskStateException(
|
||||
taskId, state, EnumUtil.allValuesExceptFor(TaskState.END_STATES));
|
||||
}
|
||||
if (state == TaskState.CLAIMED && !forceUnclaim && !userId.equals(task.getOwner())) {
|
||||
if ((state == TaskState.CLAIMED || state == TaskState.IN_REVIEW)
|
||||
&& !forceUnclaim
|
||||
&& !userId.equals(task.getOwner())) {
|
||||
throw new InvalidOwnerException(userId, taskId);
|
||||
}
|
||||
Instant now = Instant.now();
|
||||
|
|
|
|||
|
|
@ -50,7 +50,7 @@ class TaskCleanupJobAccTest extends AbstractAccTest {
|
|||
taskService.completeTask(taskId);
|
||||
|
||||
long totalTasksCount = taskService.createTaskQuery().count();
|
||||
assertThat(totalTasksCount).isEqualTo(89);
|
||||
assertThat(totalTasksCount).isEqualTo(98);
|
||||
|
||||
taskanaEngine.getConfiguration().setTaskCleanupJobAllCompletedSameParentBusiness(false);
|
||||
|
||||
|
|
@ -58,14 +58,14 @@ class TaskCleanupJobAccTest extends AbstractAccTest {
|
|||
job.run();
|
||||
|
||||
totalTasksCount = taskService.createTaskQuery().count();
|
||||
assertThat(totalTasksCount).isEqualTo(70);
|
||||
assertThat(totalTasksCount).isEqualTo(79);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "admin")
|
||||
@Test
|
||||
void shouldCleanCompletedTasksUntilDateWithSameParentBussiness() throws Exception {
|
||||
long totalTasksCount = taskService.createTaskQuery().count();
|
||||
assertThat(totalTasksCount).isEqualTo(88);
|
||||
assertThat(totalTasksCount).isEqualTo(97);
|
||||
|
||||
taskanaEngine.getConfiguration().setTaskCleanupJobAllCompletedSameParentBusiness(true);
|
||||
|
||||
|
|
@ -84,7 +84,7 @@ class TaskCleanupJobAccTest extends AbstractAccTest {
|
|||
job.run();
|
||||
|
||||
totalTasksCount = taskService.createTaskQuery().count();
|
||||
assertThat(totalTasksCount).isEqualTo(68);
|
||||
assertThat(totalTasksCount).isEqualTo(77);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "admin")
|
||||
|
|
|
|||
|
|
@ -102,7 +102,9 @@ class GetTaskIdsOfWorkbasketReportAccTest extends AbstractReportAccTest {
|
|||
"TKI:000000000000000000000000000000000009",
|
||||
"TKI:000000000000000000000000000000000010",
|
||||
"TKI:000000000000000000000000000000000031",
|
||||
"TKI:000000000000000000000000000000000050");
|
||||
"TKI:000000000000000000000000000000000050",
|
||||
"TKI:100000000000000000000000000000000050",
|
||||
"TKI:200000000000000000000000000000000050");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
|
|
@ -124,7 +126,9 @@ class GetTaskIdsOfWorkbasketReportAccTest extends AbstractReportAccTest {
|
|||
"TKI:000000000000000000000000000000000006",
|
||||
"TKI:000000000000000000000000000000000009",
|
||||
"TKI:000000000000000000000000000000000031",
|
||||
"TKI:000000000000000000000000000000000050");
|
||||
"TKI:000000000000000000000000000000000050",
|
||||
"TKI:100000000000000000000000000000000050",
|
||||
"TKI:200000000000000000000000000000000050");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
|
|
|
|||
|
|
@ -96,11 +96,11 @@ class ProvideClassificationCategoryReportAccTest extends AbstractReportAccTest {
|
|||
|
||||
assertThat(report.getRow("EXTERN").getTotalValue()).isEqualTo(36);
|
||||
assertThat(report.getRow("AUTOMATIC").getTotalValue()).isEqualTo(8);
|
||||
assertThat(report.getRow("MANUAL").getTotalValue()).isEqualTo(10);
|
||||
assertThat(report.getRow("MANUAL").getTotalValue()).isEqualTo(12);
|
||||
assertThat(report.getRow("EXTERN").getCells()).isEmpty();
|
||||
assertThat(report.getRow("AUTOMATIC").getCells()).isEmpty();
|
||||
assertThat(report.getRow("MANUAL").getCells()).isEmpty();
|
||||
assertThat(report.getSumRow().getTotalValue()).isEqualTo(54);
|
||||
assertThat(report.getSumRow().getTotalValue()).isEqualTo(56);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
|
|
@ -120,11 +120,11 @@ class ProvideClassificationCategoryReportAccTest extends AbstractReportAccTest {
|
|||
|
||||
assertThat(report.getRow("EXTERN").getTotalValue()).isEqualTo(36);
|
||||
assertThat(report.getRow("AUTOMATIC").getTotalValue()).isEqualTo(8);
|
||||
assertThat(report.getRow("MANUAL").getTotalValue()).isEqualTo(10);
|
||||
assertThat(report.getRow("MANUAL").getTotalValue()).isEqualTo(12);
|
||||
|
||||
int[] sumRow = report.getSumRow().getCells();
|
||||
assertThat(sumRow).isEqualTo(new int[] {10, 9, 11, 0, 4, 0, 8, 7, 5});
|
||||
assertThat(report.getSumRow().getTotalValue()).isEqualTo(54);
|
||||
assertThat(sumRow).isEqualTo(new int[] {10, 9, 11, 0, 4, 0, 8, 7, 7});
|
||||
assertThat(report.getSumRow().getTotalValue()).isEqualTo(56);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
|
|
@ -149,7 +149,7 @@ class ProvideClassificationCategoryReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(row2).isEqualTo(new int[] {2, 1, 0, 1, 4});
|
||||
|
||||
int[] row3 = report.getRow("MANUAL").getCells();
|
||||
assertThat(row3).isEqualTo(new int[] {2, 2, 2, 0, 4});
|
||||
assertThat(row3).isEqualTo(new int[] {2, 2, 2, 0, 6});
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
|
|
@ -190,7 +190,7 @@ class ProvideClassificationCategoryReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(row2).isEqualTo(new int[] {0, 0, 8, 0, 0});
|
||||
|
||||
int[] row3 = report.getRow("MANUAL").getCells();
|
||||
assertThat(row3).isEqualTo(new int[] {0, 0, 10, 0, 0});
|
||||
assertThat(row3).isEqualTo(new int[] {0, 0, 12, 0, 0});
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
|
|
@ -214,7 +214,7 @@ class ProvideClassificationCategoryReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(row2).isEqualTo(new int[] {3, 0, 0, 0, 5});
|
||||
|
||||
int[] row3 = report.getRow("MANUAL").getCells();
|
||||
assertThat(row3).isEqualTo(new int[] {4, 0, 2, 0, 4});
|
||||
assertThat(row3).isEqualTo(new int[] {4, 0, 2, 0, 6});
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
|
|
@ -292,7 +292,7 @@ class ProvideClassificationCategoryReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(row1).isEqualTo(new int[] {2, 1, 0, 1, 4});
|
||||
|
||||
int[] row2 = report.getRow("MANUAL").getCells();
|
||||
assertThat(row2).isEqualTo(new int[] {2, 2, 2, 0, 4});
|
||||
assertThat(row2).isEqualTo(new int[] {2, 2, 2, 0, 6});
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
|
|
@ -345,7 +345,7 @@ class ProvideClassificationCategoryReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(row2).isEqualTo(new int[] {1, 0, 0, 1, 1});
|
||||
|
||||
int[] row3 = report.getRow("MANUAL").getCells();
|
||||
assertThat(row3).isEqualTo(new int[] {1, 1, 2, 0, 2});
|
||||
assertThat(row3).isEqualTo(new int[] {1, 1, 2, 0, 4});
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
|
|
|
|||
|
|
@ -96,14 +96,14 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(report.getRow("L10000").getTotalValue()).isEqualTo(10);
|
||||
assertThat(report.getRow("L20000").getTotalValue()).isEqualTo(10);
|
||||
assertThat(report.getRow("L30000").getTotalValue()).isEqualTo(8);
|
||||
assertThat(report.getRow("L40000").getTotalValue()).isEqualTo(10);
|
||||
assertThat(report.getRow("L40000").getTotalValue()).isEqualTo(12);
|
||||
assertThat(report.getRow("L50000").getTotalValue()).isEqualTo(16);
|
||||
assertThat(report.getRow("L10000").getCells()).isEmpty();
|
||||
assertThat(report.getRow("L20000").getCells()).isEmpty();
|
||||
assertThat(report.getRow("L30000").getCells()).isEmpty();
|
||||
assertThat(report.getRow("L40000").getCells()).isEmpty();
|
||||
assertThat(report.getRow("L50000").getCells()).isEmpty();
|
||||
assertThat(report.getSumRow().getTotalValue()).isEqualTo(54);
|
||||
assertThat(report.getSumRow().getTotalValue()).isEqualTo(56);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
|
|
@ -124,11 +124,11 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(report.getRow("L10000").getTotalValue()).isEqualTo(10);
|
||||
assertThat(report.getRow("L20000").getTotalValue()).isEqualTo(10);
|
||||
assertThat(report.getRow("L30000").getTotalValue()).isEqualTo(8);
|
||||
assertThat(report.getRow("L40000").getTotalValue()).isEqualTo(10);
|
||||
assertThat(report.getRow("L40000").getTotalValue()).isEqualTo(12);
|
||||
assertThat(report.getRow("L50000").getTotalValue()).isEqualTo(16);
|
||||
|
||||
assertThat(report.getSumRow().getCells()).isEqualTo(new int[] {10, 9, 11, 0, 4, 0, 8, 7, 5});
|
||||
assertThat(report.getSumRow().getTotalValue()).isEqualTo(54);
|
||||
assertThat(report.getSumRow().getCells()).isEqualTo(new int[] {10, 9, 11, 0, 4, 0, 8, 7, 7});
|
||||
assertThat(report.getSumRow().getTotalValue()).isEqualTo(56);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
|
|
@ -156,7 +156,7 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(row3).isEqualTo(new int[] {2, 1, 0, 1, 4});
|
||||
|
||||
int[] row4 = report.getRow("L40000").getCells();
|
||||
assertThat(row4).isEqualTo(new int[] {2, 2, 2, 0, 4});
|
||||
assertThat(row4).isEqualTo(new int[] {2, 2, 2, 0, 6});
|
||||
|
||||
int[] row5 = report.getRow("L50000").getCells();
|
||||
assertThat(row5).isEqualTo(new int[] {3, 3, 0, 6, 4});
|
||||
|
|
@ -200,7 +200,7 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(row3).isEqualTo(new int[] {0, 0, 8, 0, 0});
|
||||
|
||||
int[] row4 = report.getRow("L40000").getCells();
|
||||
assertThat(row4).isEqualTo(new int[] {0, 0, 10, 0, 0});
|
||||
assertThat(row4).isEqualTo(new int[] {0, 0, 12, 0, 0});
|
||||
|
||||
int[] row5 = report.getRow("L50000").getCells();
|
||||
assertThat(row5).isEqualTo(new int[] {0, 0, 16, 0, 0});
|
||||
|
|
@ -230,7 +230,7 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(row3).isEqualTo(new int[] {3, 0, 0, 0, 5});
|
||||
|
||||
int[] row4 = report.getRow("L40000").getCells();
|
||||
assertThat(row4).isEqualTo(new int[] {4, 0, 2, 0, 4});
|
||||
assertThat(row4).isEqualTo(new int[] {4, 0, 2, 0, 6});
|
||||
|
||||
int[] row5 = report.getRow("L50000").getCells();
|
||||
assertThat(row5).isEqualTo(new int[] {6, 0, 0, 0, 10});
|
||||
|
|
@ -323,7 +323,7 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(row1).isEqualTo(new int[] {2, 1, 0, 1, 4});
|
||||
|
||||
int[] row2 = report.getRow("L40000").getCells();
|
||||
assertThat(row2).isEqualTo(new int[] {2, 2, 2, 0, 4});
|
||||
assertThat(row2).isEqualTo(new int[] {2, 2, 2, 0, 6});
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
|
|
@ -386,7 +386,7 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(row3).isEqualTo(new int[] {1, 0, 0, 1, 1});
|
||||
|
||||
int[] row4 = report.getRow("L40000").getCells();
|
||||
assertThat(row4).isEqualTo(new int[] {1, 1, 2, 0, 2});
|
||||
assertThat(row4).isEqualTo(new int[] {1, 1, 2, 0, 4});
|
||||
|
||||
int[] row5 = report.getRow("L50000").getCells();
|
||||
assertThat(row5).isEqualTo(new int[] {1, 2, 0, 2, 0});
|
||||
|
|
|
|||
|
|
@ -152,8 +152,8 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(row3.getFoldableRowCount()).isEqualTo(3);
|
||||
|
||||
FoldableRow<DetailedMonitorQueryItem> row4 = report.getRow("L40000");
|
||||
assertThat(row4.getTotalValue()).isEqualTo(10);
|
||||
assertThat(row4.getFoldableRow("N/A").getTotalValue()).isEqualTo(10);
|
||||
assertThat(row4.getTotalValue()).isEqualTo(12);
|
||||
assertThat(row4.getFoldableRow("N/A").getTotalValue()).isEqualTo(12);
|
||||
assertThat(row4.getCells()).isEmpty();
|
||||
assertThat(row4.getFoldableRowCount()).isEqualTo(1);
|
||||
|
||||
|
|
@ -163,7 +163,7 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(row5.getCells()).isEmpty();
|
||||
assertThat(row5.getFoldableRowCount()).isEqualTo(1);
|
||||
|
||||
assertThat(report.getSumRow().getTotalValue()).isEqualTo(54);
|
||||
assertThat(report.getSumRow().getTotalValue()).isEqualTo(56);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
|
|
@ -184,12 +184,12 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(report.getRow("L10000").getTotalValue()).isEqualTo(10);
|
||||
assertThat(report.getRow("L20000").getTotalValue()).isEqualTo(10);
|
||||
assertThat(report.getRow("L30000").getTotalValue()).isEqualTo(8);
|
||||
assertThat(report.getRow("L40000").getTotalValue()).isEqualTo(10);
|
||||
assertThat(report.getRow("L40000").getTotalValue()).isEqualTo(12);
|
||||
assertThat(report.getRow("L50000").getTotalValue()).isEqualTo(16);
|
||||
|
||||
int[] sumRow = report.getSumRow().getCells();
|
||||
assertThat(sumRow).isEqualTo(new int[] {10, 9, 11, 0, 4, 0, 8, 7, 5});
|
||||
assertThat(report.getSumRow().getTotalValue()).isEqualTo(54);
|
||||
assertThat(sumRow).isEqualTo(new int[] {10, 9, 11, 0, 4, 0, 8, 7, 7});
|
||||
assertThat(report.getSumRow().getTotalValue()).isEqualTo(56);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
|
|
@ -254,10 +254,10 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(detailedLineNoAttachment3.getCells()).isEqualTo(new int[] {2, 0, 0, 0, 2});
|
||||
|
||||
FoldableRow<DetailedMonitorQueryItem> line4 = report.getRow("L40000");
|
||||
assertThat(line4.getCells()).isEqualTo(new int[] {2, 2, 2, 0, 4});
|
||||
assertThat(line4.getCells()).isEqualTo(new int[] {2, 2, 2, 0, 6});
|
||||
|
||||
Row<DetailedMonitorQueryItem> detailedLineNoAttachment4 = line4.getFoldableRow("N/A");
|
||||
assertThat(detailedLineNoAttachment4.getCells()).isEqualTo(new int[] {2, 2, 2, 0, 4});
|
||||
assertThat(detailedLineNoAttachment4.getCells()).isEqualTo(new int[] {2, 2, 2, 0, 6});
|
||||
|
||||
FoldableRow<DetailedMonitorQueryItem> line5 = report.getRow("L50000");
|
||||
assertThat(line5.getCells()).isEqualTo(new int[] {3, 3, 0, 6, 4});
|
||||
|
|
@ -312,10 +312,10 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(detailedLineNoAttachment3.getCells()).isEqualTo(new int[] {0, 0, 4, 0, 0});
|
||||
|
||||
FoldableRow<DetailedMonitorQueryItem> line4 = report.getRow("L40000");
|
||||
assertThat(line4.getCells()).isEqualTo(new int[] {0, 0, 10, 0, 0});
|
||||
assertThat(line4.getCells()).isEqualTo(new int[] {0, 0, 12, 0, 0});
|
||||
|
||||
Row<DetailedMonitorQueryItem> detailedLineNoAttachment4 = line4.getFoldableRow("N/A");
|
||||
assertThat(detailedLineNoAttachment4.getCells()).isEqualTo(new int[] {0, 0, 10, 0, 0});
|
||||
assertThat(detailedLineNoAttachment4.getCells()).isEqualTo(new int[] {0, 0, 12, 0, 0});
|
||||
|
||||
FoldableRow<DetailedMonitorQueryItem> line5 = report.getRow("L50000");
|
||||
assertThat(line5.getCells()).isEqualTo(new int[] {0, 0, 16, 0, 0});
|
||||
|
|
@ -483,10 +483,10 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(detailedLineNoAttachment3.getCells()).isEqualTo(new int[] {2, 0, 0, 0, 2});
|
||||
|
||||
FoldableRow<DetailedMonitorQueryItem> line4 = report.getRow("L40000");
|
||||
assertThat(line4.getCells()).isEqualTo(new int[] {4, 0, 2, 0, 4});
|
||||
assertThat(line4.getCells()).isEqualTo(new int[] {4, 0, 2, 0, 6});
|
||||
|
||||
Row<DetailedMonitorQueryItem> detailedLineNoAttachment4 = line4.getFoldableRow("N/A");
|
||||
assertThat(detailedLineNoAttachment4.getCells()).isEqualTo(new int[] {4, 0, 2, 0, 4});
|
||||
assertThat(detailedLineNoAttachment4.getCells()).isEqualTo(new int[] {4, 0, 2, 0, 6});
|
||||
|
||||
FoldableRow<DetailedMonitorQueryItem> line5 = report.getRow("L50000");
|
||||
assertThat(line5.getCells()).isEqualTo(new int[] {6, 0, 0, 0, 10});
|
||||
|
|
@ -525,10 +525,10 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(detailedLine1WithoutAttachment.getCells()).isEqualTo(new int[] {2, 0, 0, 0, 2});
|
||||
|
||||
FoldableRow<DetailedMonitorQueryItem> line2 = report.getRow("L40000");
|
||||
assertThat(line2.getCells()).isEqualTo(new int[] {2, 2, 2, 0, 4});
|
||||
assertThat(line2.getCells()).isEqualTo(new int[] {2, 2, 2, 0, 6});
|
||||
|
||||
Row<DetailedMonitorQueryItem> detailedLine2WithoutAttachment = line2.getFoldableRow("N/A");
|
||||
assertThat(detailedLine2WithoutAttachment.getCells()).isEqualTo(new int[] {2, 2, 2, 0, 4});
|
||||
assertThat(detailedLine2WithoutAttachment.getCells()).isEqualTo(new int[] {2, 2, 2, 0, 6});
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
|
|
@ -633,10 +633,10 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(detailedLineNoAttachment3.getCells()).isEqualTo(new int[] {1, 0, 0, 0, 1});
|
||||
|
||||
FoldableRow<DetailedMonitorQueryItem> line4 = report.getRow("L40000");
|
||||
assertThat(line4.getCells()).isEqualTo(new int[] {1, 1, 2, 0, 2});
|
||||
assertThat(line4.getCells()).isEqualTo(new int[] {1, 1, 2, 0, 4});
|
||||
|
||||
Row<DetailedMonitorQueryItem> detailedLineNoAttachment4 = line4.getFoldableRow("N/A");
|
||||
assertThat(detailedLineNoAttachment4.getCells()).isEqualTo(new int[] {1, 1, 2, 0, 2});
|
||||
assertThat(detailedLineNoAttachment4.getCells()).isEqualTo(new int[] {1, 1, 2, 0, 4});
|
||||
|
||||
FoldableRow<DetailedMonitorQueryItem> line5 = report.getRow("L50000");
|
||||
assertThat(line5.getCells()).isEqualTo(new int[] {1, 2, 0, 2, 0});
|
||||
|
|
|
|||
|
|
@ -88,14 +88,14 @@ class ProvideTaskCustomFieldValueReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(report).isNotNull();
|
||||
assertThat(report.rowSize()).isEqualTo(3);
|
||||
|
||||
assertThat(report.getRow("Geschaeftsstelle A").getTotalValue()).isEqualTo(25);
|
||||
assertThat(report.getRow("Geschaeftsstelle A").getTotalValue()).isEqualTo(27);
|
||||
assertThat(report.getRow("Geschaeftsstelle B").getTotalValue()).isEqualTo(11);
|
||||
assertThat(report.getRow("Geschaeftsstelle C").getTotalValue()).isEqualTo(18);
|
||||
assertThat(report.getRow("Geschaeftsstelle A").getCells()).isEmpty();
|
||||
assertThat(report.getRow("Geschaeftsstelle B").getCells()).isEmpty();
|
||||
assertThat(report.getRow("Geschaeftsstelle C").getCells()).isEmpty();
|
||||
|
||||
assertThat(report.getSumRow().getTotalValue()).isEqualTo(54);
|
||||
assertThat(report.getSumRow().getTotalValue()).isEqualTo(56);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
|
|
@ -110,12 +110,12 @@ class ProvideTaskCustomFieldValueReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(report.rowSize()).isEqualTo(2);
|
||||
|
||||
assertThat(report.getRow("Vollkasko").getTotalValue()).isEqualTo(22);
|
||||
assertThat(report.getRow("Teilkasko").getTotalValue()).isEqualTo(32);
|
||||
assertThat(report.getRow("Teilkasko").getTotalValue()).isEqualTo(34);
|
||||
|
||||
assertThat(report.getRow("Vollkasko").getCells()).isEmpty();
|
||||
assertThat(report.getRow("Teilkasko").getCells()).isEmpty();
|
||||
|
||||
assertThat(report.getSumRow().getTotalValue()).isEqualTo(54);
|
||||
assertThat(report.getSumRow().getTotalValue()).isEqualTo(56);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
|
|
@ -134,13 +134,13 @@ class ProvideTaskCustomFieldValueReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(report).isNotNull();
|
||||
assertThat(report.rowSize()).isEqualTo(3);
|
||||
|
||||
assertThat(report.getRow("Geschaeftsstelle A").getTotalValue()).isEqualTo(25);
|
||||
assertThat(report.getRow("Geschaeftsstelle A").getTotalValue()).isEqualTo(27);
|
||||
assertThat(report.getRow("Geschaeftsstelle B").getTotalValue()).isEqualTo(11);
|
||||
assertThat(report.getRow("Geschaeftsstelle C").getTotalValue()).isEqualTo(18);
|
||||
|
||||
assertThat(report.getSumRow().getCells()).isEqualTo(new int[] {10, 9, 11, 0, 4, 0, 8, 7, 5});
|
||||
assertThat(report.getSumRow().getCells()).isEqualTo(new int[] {10, 9, 11, 0, 4, 0, 8, 7, 7});
|
||||
|
||||
assertThat(report.getSumRow().getTotalValue()).isEqualTo(54);
|
||||
assertThat(report.getSumRow().getTotalValue()).isEqualTo(56);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
|
|
@ -175,7 +175,7 @@ class ProvideTaskCustomFieldValueReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(report.rowSize()).isEqualTo(3);
|
||||
|
||||
int[] row1 = report.getRow("Geschaeftsstelle A").getCells();
|
||||
assertThat(row1).isEqualTo(new int[] {11, 4, 3, 4, 3});
|
||||
assertThat(row1).isEqualTo(new int[] {11, 4, 3, 4, 5});
|
||||
|
||||
int[] row2 = report.getRow("Geschaeftsstelle B").getCells();
|
||||
assertThat(row2).isEqualTo(new int[] {5, 3, 0, 3, 0});
|
||||
|
|
@ -200,7 +200,7 @@ class ProvideTaskCustomFieldValueReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(report.rowSize()).isEqualTo(3);
|
||||
|
||||
int[] row1 = report.getRow("Geschaeftsstelle A").getCells();
|
||||
assertThat(row1).isEqualTo(new int[] {0, 1, 24, 0, 0});
|
||||
assertThat(row1).isEqualTo(new int[] {0, 1, 26, 0, 0});
|
||||
|
||||
int[] row2 = report.getRow("Geschaeftsstelle B").getCells();
|
||||
assertThat(row2).isEqualTo(new int[] {0, 1, 10, 0, 0});
|
||||
|
|
@ -224,7 +224,7 @@ class ProvideTaskCustomFieldValueReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(report.rowSize()).isEqualTo(3);
|
||||
|
||||
int[] row1 = report.getRow("Geschaeftsstelle A").getCells();
|
||||
assertThat(row1).isEqualTo(new int[] {15, 0, 3, 0, 7});
|
||||
assertThat(row1).isEqualTo(new int[] {15, 0, 3, 0, 9});
|
||||
|
||||
int[] row2 = report.getRow("Geschaeftsstelle B").getCells();
|
||||
assertThat(row2).isEqualTo(new int[] {8, 0, 0, 0, 3});
|
||||
|
|
@ -305,7 +305,7 @@ class ProvideTaskCustomFieldValueReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(report.rowSize()).isEqualTo(3);
|
||||
|
||||
int[] row1 = report.getRow("Geschaeftsstelle A").getCells();
|
||||
assertThat(row1).isEqualTo(new int[] {2, 1, 2, 1, 3});
|
||||
assertThat(row1).isEqualTo(new int[] {2, 1, 2, 1, 5});
|
||||
|
||||
int[] row2 = report.getRow("Geschaeftsstelle B").getCells();
|
||||
assertThat(row2).isEqualTo(new int[] {2, 0, 0, 0, 0});
|
||||
|
|
@ -359,7 +359,7 @@ class ProvideTaskCustomFieldValueReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(report.rowSize()).isEqualTo(1);
|
||||
|
||||
int[] row1 = report.getRow("Geschaeftsstelle A").getCells();
|
||||
assertThat(row1).isEqualTo(new int[] {11, 4, 3, 4, 3});
|
||||
assertThat(row1).isEqualTo(new int[] {11, 4, 3, 4, 5});
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
|
|
|
|||
|
|
@ -21,7 +21,6 @@ import pro.taskana.monitor.api.reports.row.Row;
|
|||
import pro.taskana.task.api.TaskService;
|
||||
import pro.taskana.task.api.TaskState;
|
||||
|
||||
/** Acceptance test for all "task status report" scenarios. */
|
||||
@ExtendWith(JaasExtension.class)
|
||||
class ProvideTaskStatusReportAccTest extends AbstractReportAccTest {
|
||||
|
||||
|
|
@ -90,20 +89,20 @@ class ProvideTaskStatusReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(report.rowSize()).isEqualTo(5);
|
||||
|
||||
Row<TaskQueryItem> row1 = report.getRow("USER-1-1");
|
||||
assertThat(row1.getCells()).isEqualTo(new int[] {18, 2, 0, 0, 0});
|
||||
assertThat(row1.getCells()).isEqualTo(new int[] {18, 2, 0, 0, 0, 0, 0});
|
||||
assertThat(row1.getTotalValue()).isEqualTo(20);
|
||||
|
||||
Row<TaskQueryItem> row2 = report.getRow("USER-1-2");
|
||||
assertThat(row2.getCells()).isEqualTo(new int[] {19, 1, 0, 0, 0});
|
||||
assertThat(row2.getTotalValue()).isEqualTo(20);
|
||||
assertThat(row2.getCells()).isEqualTo(new int[] {19, 1, 1, 1, 0, 0, 0});
|
||||
assertThat(row2.getTotalValue()).isEqualTo(22);
|
||||
|
||||
Row<TaskQueryItem> row3 = report.getRow("USER-1-3");
|
||||
assertThat(row3.getCells()).isEqualTo(new int[] {4, 6, 0, 0, 0});
|
||||
assertThat(row3.getCells()).isEqualTo(new int[] {4, 6, 0, 0, 0, 0, 0});
|
||||
assertThat(row3.getTotalValue()).isEqualTo(10);
|
||||
|
||||
Row<TaskQueryItem> sumRow = report.getSumRow();
|
||||
assertThat(sumRow.getCells()).isEqualTo(new int[] {42, 12, 0, 0, 0});
|
||||
assertThat(sumRow.getTotalValue()).isEqualTo(54);
|
||||
assertThat(sumRow.getCells()).isEqualTo(new int[] {42, 12, 1, 1, 0, 0, 0});
|
||||
assertThat(sumRow.getTotalValue()).isEqualTo(56);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
|
|
@ -119,20 +118,20 @@ class ProvideTaskStatusReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(report.rowSize()).isEqualTo(5);
|
||||
|
||||
Row<TaskQueryItem> row1 = report.getRow("USER-1-1");
|
||||
assertThat(row1.getCells()).isEqualTo(new int[] {15, 2, 0, 0, 0});
|
||||
assertThat(row1.getCells()).isEqualTo(new int[] {15, 2, 0, 0, 0, 0, 0});
|
||||
assertThat(row1.getTotalValue()).isEqualTo(17);
|
||||
|
||||
Row<TaskQueryItem> row2 = report.getRow("USER-1-2");
|
||||
assertThat(row2.getCells()).isEqualTo(new int[] {14, 1, 0, 0, 0});
|
||||
assertThat(row2.getTotalValue()).isEqualTo(15);
|
||||
assertThat(row2.getCells()).isEqualTo(new int[] {14, 1, 1, 1, 0, 0, 0});
|
||||
assertThat(row2.getTotalValue()).isEqualTo(17);
|
||||
|
||||
Row<TaskQueryItem> row3 = report.getRow("USER-1-3");
|
||||
assertThat(row3.getCells()).isEqualTo(new int[] {3, 3, 0, 0, 0});
|
||||
assertThat(row3.getCells()).isEqualTo(new int[] {3, 3, 0, 0, 0, 0, 0});
|
||||
assertThat(row3.getTotalValue()).isEqualTo(6);
|
||||
|
||||
Row<TaskQueryItem> sumRow = report.getSumRow();
|
||||
assertThat(sumRow.getCells()).isEqualTo(new int[] {33, 8, 0, 0, 0});
|
||||
assertThat(sumRow.getTotalValue()).isEqualTo(41);
|
||||
assertThat(sumRow.getCells()).isEqualTo(new int[] {33, 8, 1, 1, 0, 0, 0});
|
||||
assertThat(sumRow.getTotalValue()).isEqualTo(43);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
|
|
@ -202,11 +201,11 @@ class ProvideTaskStatusReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(report.rowSize()).isEqualTo(4);
|
||||
|
||||
Row<TaskQueryItem> row1 = report.getRow("USER-1-1");
|
||||
assertThat(row1.getCells()).isEqualTo(new int[] {3, 1, 0, 0, 0});
|
||||
assertThat(row1.getCells()).isEqualTo(new int[] {3, 1, 0, 0, 0, 0, 0});
|
||||
assertThat(row1.getTotalValue()).isEqualTo(4);
|
||||
|
||||
Row<TaskQueryItem> sumRow = report.getSumRow();
|
||||
assertThat(sumRow.getCells()).isEqualTo(new int[] {4, 5, 0, 0, 0});
|
||||
assertThat(sumRow.getCells()).isEqualTo(new int[] {4, 5, 0, 0, 0, 0, 0});
|
||||
assertThat(sumRow.getTotalValue()).isEqualTo(9);
|
||||
}
|
||||
|
||||
|
|
@ -223,11 +222,11 @@ class ProvideTaskStatusReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(report.rowSize()).isEqualTo(1);
|
||||
|
||||
Row<TaskQueryItem> row1 = report.getRow("USER-1-3");
|
||||
assertThat(row1.getCells()).isEqualTo(new int[] {4, 6, 0, 0, 0});
|
||||
assertThat(row1.getCells()).isEqualTo(new int[] {4, 6, 0, 0, 0, 0, 0});
|
||||
assertThat(row1.getTotalValue()).isEqualTo(10);
|
||||
|
||||
Row<TaskQueryItem> sumRow = report.getSumRow();
|
||||
assertThat(sumRow.getCells()).isEqualTo(new int[] {4, 6, 0, 0, 0});
|
||||
assertThat(sumRow.getCells()).isEqualTo(new int[] {4, 6, 0, 0, 0, 0, 0});
|
||||
assertThat(sumRow.getTotalValue()).isEqualTo(10);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -63,7 +63,7 @@ class ProvideWorkbasketPriorityReportAccTest extends AbstractReportAccTest {
|
|||
.createWorkbasketPriorityReportBuilder()
|
||||
.withColumnHeaders(LOW_TEST_HEADERS)
|
||||
.buildReport();
|
||||
int[] expectedCells = {45, 9};
|
||||
int[] expectedCells = {47, 9};
|
||||
assertThat(priorityReport)
|
||||
.extracting(Report::getSumRow)
|
||||
.extracting(Row::getCells)
|
||||
|
|
@ -224,7 +224,7 @@ class ProvideWorkbasketPriorityReportAccTest extends AbstractReportAccTest {
|
|||
int[] row1 = report.getRow("USER-1-1").getCells();
|
||||
assertThat(row1).isEqualTo(new int[] {8, 0, 0});
|
||||
int[] row2 = report.getRow("USER-1-2").getCells();
|
||||
assertThat(row2).isEqualTo(new int[] {4, 0, 0});
|
||||
assertThat(row2).isEqualTo(new int[] {6, 0, 0});
|
||||
int[] row3 = report.getRow("USER-1-3").getCells();
|
||||
assertThat(row3).isEqualTo(new int[] {5, 0, 0});
|
||||
int[] row4 = report.getRow("TPK-VIP-1").getCells();
|
||||
|
|
|
|||
|
|
@ -72,10 +72,10 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(report.rowSize()).isEqualTo(5);
|
||||
|
||||
assertThat(report.getRow("USER-1-1").getTotalValue()).isEqualTo(20);
|
||||
assertThat(report.getRow("USER-1-2").getTotalValue()).isEqualTo(20);
|
||||
assertThat(report.getRow("USER-1-2").getTotalValue()).isEqualTo(22);
|
||||
assertThat(report.getRow("USER-1-3").getTotalValue()).isEqualTo(10);
|
||||
|
||||
assertThat(report.getSumRow().getTotalValue()).isEqualTo(54);
|
||||
assertThat(report.getSumRow().getTotalValue()).isEqualTo(56);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
|
|
@ -113,12 +113,12 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(report.rowSize()).isEqualTo(5);
|
||||
|
||||
assertThat(report.getRow("USER-1-1").getTotalValue()).isEqualTo(20);
|
||||
assertThat(report.getRow("USER-1-2").getTotalValue()).isEqualTo(20);
|
||||
assertThat(report.getRow("USER-1-2").getTotalValue()).isEqualTo(22);
|
||||
assertThat(report.getRow("USER-1-3").getTotalValue()).isEqualTo(10);
|
||||
|
||||
int[] sumRow = report.getSumRow().getCells();
|
||||
assertThat(sumRow).isEqualTo(new int[] {10, 9, 11, 0, 4, 0, 8, 7, 5});
|
||||
assertThat(report.getSumRow().getTotalValue()).isEqualTo(54);
|
||||
assertThat(sumRow).isEqualTo(new int[] {10, 9, 11, 0, 4, 0, 8, 7, 7});
|
||||
assertThat(report.getSumRow().getTotalValue()).isEqualTo(56);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
|
|
@ -153,7 +153,7 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(row1).isEqualTo(new int[] {13, 3, 1, 1, 2});
|
||||
|
||||
int[] row2 = report.getRow("USER-1-2").getCells();
|
||||
assertThat(row2).isEqualTo(new int[] {4, 6, 3, 6, 1});
|
||||
assertThat(row2).isEqualTo(new int[] {4, 6, 3, 6, 3});
|
||||
|
||||
int[] row3 = report.getRow("USER-1-3").getCells();
|
||||
assertThat(row3).isEqualTo(new int[] {2, 2, 0, 0, 6});
|
||||
|
|
@ -177,7 +177,7 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(row1).isEqualTo(new int[] {0, 2, 18, 0, 0});
|
||||
|
||||
int[] row2 = report.getRow("USER-1-2").getCells();
|
||||
assertThat(row2).isEqualTo(new int[] {0, 1, 19, 0, 0});
|
||||
assertThat(row2).isEqualTo(new int[] {0, 1, 21, 0, 0});
|
||||
|
||||
int[] row3 = report.getRow("USER-1-3").getCells();
|
||||
assertThat(row3).isEqualTo(new int[] {0, 0, 10, 0, 0});
|
||||
|
|
@ -201,7 +201,7 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(row1).isEqualTo(new int[] {16, 0, 1, 0, 3});
|
||||
|
||||
int[] row2 = report.getRow("USER-1-2").getCells();
|
||||
assertThat(row2).isEqualTo(new int[] {10, 0, 3, 0, 7});
|
||||
assertThat(row2).isEqualTo(new int[] {10, 0, 3, 0, 9});
|
||||
|
||||
int[] row3 = report.getRow("USER-1-3").getCells();
|
||||
assertThat(row3).isEqualTo(new int[] {4, 0, 0, 0, 6});
|
||||
|
|
@ -276,7 +276,7 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(row1).isEqualTo(new int[] {3, 1, 1, 1, 2});
|
||||
|
||||
int[] row2 = report.getRow("USER-1-2").getCells();
|
||||
assertThat(row2).isEqualTo(new int[] {1, 1, 1, 0, 1});
|
||||
assertThat(row2).isEqualTo(new int[] {1, 1, 1, 0, 3});
|
||||
|
||||
int[] row3 = report.getRow("USER-1-3").getCells();
|
||||
assertThat(row3).isEqualTo(new int[] {0, 1, 0, 0, 4});
|
||||
|
|
@ -329,7 +329,7 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(row1).isEqualTo(new int[] {6, 1, 1, 1, 1});
|
||||
|
||||
int[] row2 = report.getRow("USER-1-2").getCells();
|
||||
assertThat(row2).isEqualTo(new int[] {3, 2, 2, 3, 1});
|
||||
assertThat(row2).isEqualTo(new int[] {3, 2, 2, 3, 3});
|
||||
|
||||
int[] row3 = report.getRow("USER-1-3").getCells();
|
||||
assertThat(row3).isEqualTo(new int[] {2, 1, 0, 0, 1});
|
||||
|
|
@ -437,12 +437,12 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
|
|||
assertThat(report.rowSize()).isEqualTo(5);
|
||||
|
||||
assertThat(report.getRow("USER-1-1").getTotalValue()).isEqualTo(20);
|
||||
assertThat(report.getRow("USER-1-2").getTotalValue()).isEqualTo(20);
|
||||
assertThat(report.getRow("USER-1-2").getTotalValue()).isEqualTo(22);
|
||||
assertThat(report.getRow("USER-1-3").getTotalValue()).isEqualTo(10);
|
||||
assertThat(report.getRow("USER-1-1").getCells()[2]).isEqualTo(2);
|
||||
assertThat(report.getRow("USER-1-2").getCells()[1]).isEqualTo(1);
|
||||
|
||||
assertThat(report.getSumRow().getTotalValue()).isEqualTo(54);
|
||||
assertThat(report.getSumRow().getTotalValue()).isEqualTo(56);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "monitor")
|
||||
|
|
|
|||
|
|
@ -21,16 +21,14 @@ import pro.taskana.task.api.TaskService;
|
|||
import pro.taskana.task.api.TaskState;
|
||||
import pro.taskana.task.api.exceptions.InvalidOwnerException;
|
||||
import pro.taskana.task.api.exceptions.InvalidStateException;
|
||||
import pro.taskana.task.api.exceptions.TaskNotFoundException;
|
||||
import pro.taskana.task.api.models.Task;
|
||||
|
||||
/** Acceptance test for all "work on task" scenarios. This includes claim, complete... */
|
||||
@ExtendWith(JaasExtension.class)
|
||||
class ClaimTaskAccTest extends AbstractAccTest {
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void testClaimTask() throws Exception {
|
||||
void should_ClaimTask_When_TaskIsReady() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task task = taskService.getTask("TKI:000000000000000000000000000000000025");
|
||||
|
||||
|
|
@ -40,28 +38,55 @@ class ClaimTaskAccTest extends AbstractAccTest {
|
|||
assertThat(claimedTask).isNotNull();
|
||||
assertThat(claimedTask.getState()).isEqualTo(TaskState.CLAIMED);
|
||||
assertThat(claimedTask.getClaimed()).isNotNull();
|
||||
assertThat(claimedTask.getModified()).isNotEqualTo(claimedTask.getCreated());
|
||||
assertThat(claimedTask.getModified()).isEqualTo(claimedTask.getClaimed());
|
||||
assertThat(claimedTask.getModified())
|
||||
.isNotEqualTo(claimedTask.getCreated())
|
||||
.isEqualTo(claimedTask.getClaimed());
|
||||
assertThat(claimedTask.isRead()).isTrue();
|
||||
assertThat(claimedTask.getOwner()).isEqualTo("user-1-2");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void testThrowsExceptionIfTaskIsAlreadyClaimed() throws Exception {
|
||||
void should_ClaimTask_When_TaskIsReadyForReview() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task task = taskService.getTask("TKI:100000000000000000000000000000000025");
|
||||
|
||||
taskService.claim(task.getId());
|
||||
|
||||
Task claimedTask = taskService.getTask("TKI:100000000000000000000000000000000025");
|
||||
assertThat(claimedTask).isNotNull();
|
||||
assertThat(claimedTask.getState()).isEqualTo(TaskState.IN_REVIEW);
|
||||
assertThat(claimedTask.getClaimed()).isNotNull();
|
||||
assertThat(claimedTask.getModified())
|
||||
.isNotEqualTo(claimedTask.getCreated())
|
||||
.isEqualTo(claimedTask.getClaimed());
|
||||
assertThat(claimedTask.isRead()).isTrue();
|
||||
assertThat(claimedTask.getOwner()).isEqualTo("user-1-2");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ThrowException_When_TaskIsAlreadyClaimed() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task task = taskService.getTask("TKI:000000000000000000000000000000000026");
|
||||
|
||||
ThrowingCallable call =
|
||||
() -> {
|
||||
taskService.claim(task.getId());
|
||||
};
|
||||
ThrowingCallable call = () -> taskService.claim(task.getId());
|
||||
assertThatThrownBy(call).isInstanceOf(InvalidOwnerException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void testClaimAlreadyClaimedByCallerTask() throws Exception {
|
||||
void should_ThrowException_When_TaskIsAlreadyInReviewByAnotherUser() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task task = taskService.getTask("TKI:600000000000000000000000000000000028");
|
||||
|
||||
ThrowingCallable call = () -> taskService.claim(task.getId());
|
||||
assertThatThrownBy(call).isInstanceOf(InvalidOwnerException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ClaimTask_When_AlreadyClaimedByCaller() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task task = taskService.getTask("TKI:000000000000000000000000000000000027");
|
||||
|
||||
|
|
@ -71,27 +96,58 @@ class ClaimTaskAccTest extends AbstractAccTest {
|
|||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void testForceClaimTaskWhichIsAlreadyClaimedByAnotherUser() throws Exception {
|
||||
void should_ClaimTask_When_AlreadyInReviewByCaller() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task task = taskService.getTask("TKI:200000000000000000000000000000000025");
|
||||
|
||||
assertThat(task.getState()).isSameAs(TaskState.IN_REVIEW);
|
||||
assertThatCode(() -> taskService.claim(task.getId())).doesNotThrowAnyException();
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ForceClaimTask_When_TaskIsAlreadyClaimedByAnotherUser() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task task = taskService.getTask("TKI:000000000000000000000000000000000028");
|
||||
|
||||
ThrowingCallable call =
|
||||
() -> {
|
||||
taskService.claim(task.getId());
|
||||
};
|
||||
ThrowingCallable call = () -> taskService.claim(task.getId());
|
||||
assertThatThrownBy(call).isInstanceOf(InvalidOwnerException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ForceClaimTask_When_InReviewByAnotherUser() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task task = taskService.getTask("TKI:200000000000000000000000000000000028");
|
||||
|
||||
Task claimedTask = taskService.forceClaim(task.getId());
|
||||
assertThat(claimedTask).isNotNull();
|
||||
assertThat(claimedTask.getState()).isEqualTo(TaskState.IN_REVIEW);
|
||||
assertThat(claimedTask.getClaimed()).isNotNull();
|
||||
assertThat(claimedTask.getModified())
|
||||
.isNotEqualTo(claimedTask.getCreated())
|
||||
.isEqualTo(claimedTask.getClaimed());
|
||||
assertThat(claimedTask.isRead()).isTrue();
|
||||
assertThat(claimedTask.getOwner()).isEqualTo("user-1-2");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-taskrouter")
|
||||
@Test
|
||||
void should_ThrowNotAuthorizedException_When_UserHasNoReadPermission() throws Exception {
|
||||
void should_ThrowNotAuthorizedException_When_UserHasNoReadPermissionAndTaskIsReady() {
|
||||
assertThatThrownBy(() -> taskService.claim("TKI:000000000000000000000000000000000000"))
|
||||
.isInstanceOf(NotAuthorizedException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-taskrouter")
|
||||
@Test
|
||||
void should_ThrowNotAuthorizedException_When_UserHasNoReadPermissionAndTaskIsReadyForReview() {
|
||||
assertThatThrownBy(() -> taskService.claim("TKI:500000000000000000000000000000000028"))
|
||||
.isInstanceOf(NotAuthorizedException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void testCancelClaimTask() throws Exception {
|
||||
void should_CancelClaimTask_When_TaskIsClaimed() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task claimedTask = taskService.getTask("TKI:000000000000000000000000000000000029");
|
||||
|
||||
|
|
@ -107,20 +163,46 @@ class ClaimTaskAccTest extends AbstractAccTest {
|
|||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void testThrowsExceptionIfCancelClaimOfTaskFromAnotherUser() throws Exception {
|
||||
void should_CancelClaimTask_When_TaskIsInReview() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task claimedTask = taskService.getTask("TKI:200000000000000000000000000000000025");
|
||||
|
||||
taskService.cancelClaim(claimedTask.getId());
|
||||
|
||||
Task unclaimedTask = taskService.getTask("TKI:200000000000000000000000000000000025");
|
||||
assertThat(unclaimedTask).isNotNull();
|
||||
assertThat(unclaimedTask.getState()).isEqualTo(TaskState.READY_FOR_REVIEW);
|
||||
assertThat(unclaimedTask.getClaimed()).isNull();
|
||||
assertThat(unclaimedTask.isRead()).isTrue();
|
||||
assertThat(unclaimedTask.getOwner()).isNull();
|
||||
|
||||
// Claim Task, so it can be used in a different test
|
||||
taskService.claim(unclaimedTask.getId());
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ThrowException_When_CancelClaimingATaskClaimedByAnotherUser() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task claimedTask = taskService.getTask("TKI:000000000000000000000000000000000030");
|
||||
|
||||
ThrowingCallable call =
|
||||
() -> {
|
||||
taskService.cancelClaim(claimedTask.getId());
|
||||
};
|
||||
ThrowingCallable call = () -> taskService.cancelClaim(claimedTask.getId());
|
||||
assertThatThrownBy(call).isInstanceOf(InvalidOwnerException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "taskadmin")
|
||||
@Test
|
||||
void should_ThrowException_When_CancelClaimingATaskInReviewByAnotherUser() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task claimedTask = taskService.getTask("TKI:200000000000000000000000000000000025");
|
||||
|
||||
ThrowingCallable call = () -> taskService.cancelClaim(claimedTask.getId());
|
||||
assertThatThrownBy(call).isInstanceOf(InvalidOwnerException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void testForceCancelClaimOfTaskFromAnotherUser() throws Exception {
|
||||
void should_ForceCancelClaim_When_TaskClaimedByAnotherUser() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task claimedTask = taskService.getTask("TKI:000000000000000000000000000000000031");
|
||||
|
||||
|
|
@ -136,7 +218,21 @@ class ClaimTaskAccTest extends AbstractAccTest {
|
|||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void testCompleteTask() throws Exception {
|
||||
void should_ForceCancelClaimTask_When_InReviewByAnotherUser() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task task = taskService.getTask("TKI:100000000000000000000000000000000028");
|
||||
|
||||
Task unclaimedTask = taskService.forceCancelClaim(task.getId());
|
||||
assertThat(unclaimedTask).isNotNull();
|
||||
assertThat(unclaimedTask.getState()).isEqualTo(TaskState.READY_FOR_REVIEW);
|
||||
assertThat(unclaimedTask.getClaimed()).isNull();
|
||||
assertThat(unclaimedTask.isRead()).isTrue();
|
||||
assertThat(unclaimedTask.getOwner()).isNull();
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_CompleteTask_When_TaskIsClaimed() throws Exception {
|
||||
final Instant before = Instant.now().minus(Duration.ofSeconds(3L));
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task claimedTask = taskService.getTask("TKI:000000000000000000000000000000000032");
|
||||
|
|
@ -156,7 +252,27 @@ class ClaimTaskAccTest extends AbstractAccTest {
|
|||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void testForceCompleteUnclaimedTask() throws Exception {
|
||||
void should_CompleteTask_When_TaskIsInReview() throws Exception {
|
||||
final Instant before = Instant.now().minus(Duration.ofSeconds(3L));
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task claimedTask = taskService.getTask("TKI:400000000000000000000000000000000028");
|
||||
|
||||
taskService.completeTask(claimedTask.getId());
|
||||
|
||||
Task completedTask = taskService.getTask("TKI:400000000000000000000000000000000028");
|
||||
assertThat(completedTask).isNotNull();
|
||||
assertThat(completedTask.getState()).isEqualTo(TaskState.COMPLETED);
|
||||
assertThat(completedTask.getCompleted()).isNotNull();
|
||||
assertThat(completedTask.getModified()).isEqualTo(completedTask.getCompleted());
|
||||
assertThat(completedTask.getCompleted().isAfter(before)).isTrue();
|
||||
assertThat(completedTask.getModified().isAfter(before)).isTrue();
|
||||
assertThat(completedTask.isRead()).isTrue();
|
||||
assertThat(completedTask.getOwner()).isEqualTo("user-1-2");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_CompleteTaskUsingForceComplete_When_TaskIsUnclaimed() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task claimedTask = taskService.getTask("TKI:000000000000000000000000000000000033");
|
||||
|
||||
|
|
@ -173,20 +289,44 @@ class ClaimTaskAccTest extends AbstractAccTest {
|
|||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void testThrowsExceptionIfCompletingClaimedTaskOfAnotherUser() throws Exception {
|
||||
void should_CompleteTaskUsingForceComplete_When_TaskIsReadyForReview() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task claimedTask = taskService.getTask("TKI:500000000000000000000000000000000028");
|
||||
|
||||
taskService.forceCompleteTask(claimedTask.getId());
|
||||
|
||||
Task completedTask = taskService.getTask("TKI:500000000000000000000000000000000028");
|
||||
assertThat(completedTask).isNotNull();
|
||||
assertThat(completedTask.getState()).isEqualTo(TaskState.COMPLETED);
|
||||
assertThat(completedTask.getCompleted()).isNotNull();
|
||||
assertThat(completedTask.getModified()).isEqualTo(completedTask.getCompleted());
|
||||
assertThat(completedTask.isRead()).isTrue();
|
||||
assertThat(completedTask.getOwner()).isEqualTo("user-1-2");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ThrowException_When_CompletingTaskClaimedByAnotherUser() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task claimedTask = taskService.getTask("TKI:000000000000000000000000000000000034");
|
||||
|
||||
ThrowingCallable call =
|
||||
() -> {
|
||||
taskService.completeTask(claimedTask.getId());
|
||||
};
|
||||
ThrowingCallable call = () -> taskService.completeTask(claimedTask.getId());
|
||||
assertThatThrownBy(call).isInstanceOf(InvalidOwnerException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void testForceCompleteClaimedTaskOfAnotherUser() throws Exception {
|
||||
void should_ThrowException_When_CompletingTaskInReviewByAnotherUser() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task claimedTask = taskService.getTask("TKI:700000000000000000000000000000000028");
|
||||
|
||||
ThrowingCallable call = () -> taskService.completeTask(claimedTask.getId());
|
||||
assertThatThrownBy(call).isInstanceOf(InvalidOwnerException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ForceCompleteTask_When_ClaimedByAnotherUser() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task claimedTask = taskService.getTask("TKI:000000000000000000000000000000000035");
|
||||
|
||||
|
|
@ -201,13 +341,30 @@ class ClaimTaskAccTest extends AbstractAccTest {
|
|||
assertThat(completedTask.getOwner()).isEqualTo("user-1-2");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ForceCompleteTask_When_InReviewByAnotherUser() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task claimedTask = taskService.getTask("TKI:300000000000000000000000000000000028");
|
||||
|
||||
taskService.forceCompleteTask(claimedTask.getId());
|
||||
|
||||
Task completedTask = taskService.getTask("TKI:300000000000000000000000000000000028");
|
||||
assertThat(completedTask).isNotNull();
|
||||
assertThat(completedTask.getState()).isEqualTo(TaskState.COMPLETED);
|
||||
assertThat(completedTask.getCompleted()).isNotNull();
|
||||
assertThat(completedTask.getModified()).isEqualTo(completedTask.getCompleted());
|
||||
assertThat(completedTask.isRead()).isTrue();
|
||||
assertThat(completedTask.getOwner()).isEqualTo("user-1-2");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "admin")
|
||||
@Test
|
||||
void testBulkDeleteTasksWithException() throws Exception {
|
||||
void should_ReturnExceptions_WhenBulkDeletingInvalidTasks() throws Exception {
|
||||
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
String id1 = "TKI:000000000000000000000000000000000102";
|
||||
String id2 = "TKI:000000000000000000000000000000003333";
|
||||
String id1 = "TKI:000000000000000000000000000000000102"; // claimed by someone
|
||||
String id2 = "TKI:100000000000000000000000000000000028"; // in review by someone
|
||||
List<String> taskIdList = List.of(id1, id2);
|
||||
|
||||
BulkOperationResults<String, TaskanaException> results = taskService.deleteTasks(taskIdList);
|
||||
|
|
@ -215,6 +372,6 @@ class ClaimTaskAccTest extends AbstractAccTest {
|
|||
assertThat(results.containsErrors()).isTrue();
|
||||
assertThat(results.getFailedIds()).containsExactlyInAnyOrder(id1, id2);
|
||||
assertThat(results.getErrorForId(id1)).isInstanceOf(InvalidStateException.class);
|
||||
assertThat(results.getErrorForId(id2)).isInstanceOf(TaskNotFoundException.class);
|
||||
assertThat(results.getErrorForId(id2)).isInstanceOf(InvalidStateException.class);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -166,7 +166,7 @@ class SetOwnerAccTest extends AbstractAccTest {
|
|||
allTaskSummaries.stream().map(TaskSummary::getId).collect(Collectors.toList());
|
||||
BulkOperationResults<String, TaskanaException> results =
|
||||
taskanaEngine.getTaskService().setOwnerOfTasks("theWorkaholic", allTaskIds);
|
||||
assertThat(allTaskSummaries).hasSize(88);
|
||||
assertThat(allTaskSummaries).hasSize(97);
|
||||
assertThat(results.containsErrors()).isTrue();
|
||||
|
||||
Condition<Object> invalidTaskStateException =
|
||||
|
|
@ -177,10 +177,10 @@ class SetOwnerAccTest extends AbstractAccTest {
|
|||
c -> c.getClass() == MismatchedWorkbasketPermissionException.class,
|
||||
"MismatchedWorkbasketPermissionException");
|
||||
assertThat(results.getErrorMap())
|
||||
.hasSize(86)
|
||||
.hasSize(95)
|
||||
.extractingFromEntries(Entry::getValue)
|
||||
.hasOnlyElementsOfTypes(InvalidTaskStateException.class, NotAuthorizedException.class)
|
||||
.areExactly(28, invalidTaskStateException)
|
||||
.areExactly(37, invalidTaskStateException)
|
||||
.areExactly(58, mismatchedWorkbasketPermissionException);
|
||||
}
|
||||
|
||||
|
|
@ -193,10 +193,10 @@ class SetOwnerAccTest extends AbstractAccTest {
|
|||
allTaskSummaries.stream().map(TaskSummary::getId).collect(Collectors.toList());
|
||||
BulkOperationResults<String, TaskanaException> results =
|
||||
taskanaEngine.getTaskService().setOwnerOfTasks("theWorkaholic", allTaskIds);
|
||||
assertThat(allTaskSummaries).hasSize(88);
|
||||
assertThat(allTaskSummaries).hasSize(97);
|
||||
assertThat(results.containsErrors()).isTrue();
|
||||
assertThat(results.getErrorMap())
|
||||
.hasSize(40)
|
||||
.hasSize(49)
|
||||
.extractingFromEntries(Entry::getValue)
|
||||
.hasOnlyElementsOfType(InvalidStateException.class);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -191,16 +191,19 @@ class DeleteTaskAccTest extends AbstractAccTest {
|
|||
List.of(
|
||||
"TKI:000000000000000000000000000000000039",
|
||||
"TKI:000000000000000000000000000000000040",
|
||||
"TKI:000000000000000000000000000000000028");
|
||||
"TKI:000000000000000000000000000000000028",
|
||||
"INVALID_TASK_ID");
|
||||
|
||||
BulkOperationResults<String, TaskanaException> results = taskService.deleteTasks(taskIdList);
|
||||
|
||||
assertThat(results.containsErrors()).isTrue();
|
||||
|
||||
assertThat(results.getErrorMap().keySet())
|
||||
.containsExactly("TKI:000000000000000000000000000000000028");
|
||||
assertThat(results.getErrorMap().values())
|
||||
.hasOnlyElementsOfType(InvalidTaskStateException.class);
|
||||
.containsExactlyInAnyOrder("TKI:000000000000000000000000000000000028", "INVALID_TASK_ID");
|
||||
assertThat(results.getErrorMap().get("TKI:000000000000000000000000000000000028"))
|
||||
.isInstanceOf(InvalidTaskStateException.class);
|
||||
assertThat(results.getErrorMap().get("INVALID_TASK_ID"))
|
||||
.isInstanceOf(TaskNotFoundException.class);
|
||||
|
||||
Task notDeletedTask = taskService.getTask("TKI:000000000000000000000000000000000028");
|
||||
assertThat(notDeletedTask).isNotNull();
|
||||
|
|
|
|||
|
|
@ -87,7 +87,7 @@ class QueryTasksAccTest extends AbstractAccTest {
|
|||
List<TaskSummary> tasks = taskService.createTaskQuery().ownerLongNameIn(longName).list();
|
||||
|
||||
assertThat(tasks)
|
||||
.hasSize(23)
|
||||
.hasSize(25)
|
||||
.extracting(TaskSummary::getOwnerLongName)
|
||||
.doesNotContainNull()
|
||||
.containsOnly(longName);
|
||||
|
|
@ -119,7 +119,7 @@ class QueryTasksAccTest extends AbstractAccTest {
|
|||
List<TaskSummary> tasks = taskService.createTaskQuery().ownerLongNameLike("%1-2%").list();
|
||||
|
||||
assertThat(tasks)
|
||||
.hasSize(23)
|
||||
.hasSize(25)
|
||||
.extracting(TaskSummary::getOwnerLongName)
|
||||
.doesNotContainNull()
|
||||
.containsOnly("Eifrig, Elena - (user-1-2)");
|
||||
|
|
@ -132,7 +132,7 @@ class QueryTasksAccTest extends AbstractAccTest {
|
|||
List<TaskSummary> tasks = taskService.createTaskQuery().ownerLongNameNotLike("%1-1%").list();
|
||||
|
||||
assertThat(tasks)
|
||||
.hasSize(23)
|
||||
.hasSize(25)
|
||||
.extracting(TaskSummary::getOwnerLongName)
|
||||
.doesNotContainNull()
|
||||
.containsOnly("Eifrig, Elena - (user-1-2)");
|
||||
|
|
@ -218,11 +218,11 @@ class QueryTasksAccTest extends AbstractAccTest {
|
|||
.ownerLongNameIn(longName)
|
||||
.orderByTaskId(null)
|
||||
.listValues(TaskQueryColumnName.ID, null);
|
||||
assertThat(listedValues).hasSize(23);
|
||||
assertThat(listedValues).hasSize(25);
|
||||
|
||||
List<TaskSummary> query =
|
||||
taskService.createTaskQuery().ownerLongNameIn(longName).orderByTaskId(null).list();
|
||||
assertThat(query).hasSize(23).extracting(TaskSummary::getId).isEqualTo(listedValues);
|
||||
assertThat(query).hasSize(25).extracting(TaskSummary::getId).isEqualTo(listedValues);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
|
|
@ -231,7 +231,7 @@ class QueryTasksAccTest extends AbstractAccTest {
|
|||
taskanaEngineConfiguration.setAddAdditionalUserInfo(false);
|
||||
String longName = "Eifrig, Elena - (user-1-2)";
|
||||
long count = taskService.createTaskQuery().ownerLongNameIn(longName).count();
|
||||
assertThat(count).isEqualTo(23);
|
||||
assertThat(count).isEqualTo(25);
|
||||
|
||||
List<TaskSummary> query = taskService.createTaskQuery().ownerLongNameIn(longName).list();
|
||||
assertThat(query.size()).isEqualTo(count);
|
||||
|
|
@ -254,7 +254,7 @@ class QueryTasksAccTest extends AbstractAccTest {
|
|||
throws InvalidArgumentException {
|
||||
List<TaskSummary> query =
|
||||
taskService.createTaskQuery().customAttributeIn(TaskCustomField.CUSTOM_1, "").list();
|
||||
assertThat(query).hasSize(85);
|
||||
assertThat(query).hasSize(94);
|
||||
}
|
||||
|
||||
@Nested
|
||||
|
|
@ -276,13 +276,13 @@ class QueryTasksAccTest extends AbstractAccTest {
|
|||
Triplet.of(TaskCustomField.CUSTOM_7, new String[] {"ijk%"}, 1),
|
||||
Triplet.of(TaskCustomField.CUSTOM_8, new String[] {"%lnp"}, 1),
|
||||
Triplet.of(TaskCustomField.CUSTOM_9, new String[] {"%9%"}, 1),
|
||||
Triplet.of(TaskCustomField.CUSTOM_10, new String[] {"ert%"}, 1),
|
||||
Triplet.of(TaskCustomField.CUSTOM_11, new String[] {"%ert"}, 1),
|
||||
Triplet.of(TaskCustomField.CUSTOM_10, new String[] {"ert%"}, 3),
|
||||
Triplet.of(TaskCustomField.CUSTOM_11, new String[] {"%ert"}, 3),
|
||||
Triplet.of(TaskCustomField.CUSTOM_12, new String[] {"dd%"}, 1),
|
||||
Triplet.of(TaskCustomField.CUSTOM_13, new String[] {"%dd_"}, 1),
|
||||
Triplet.of(TaskCustomField.CUSTOM_14, new String[] {"%"}, 88),
|
||||
Triplet.of(TaskCustomField.CUSTOM_15, new String[] {"___"}, 2),
|
||||
Triplet.of(TaskCustomField.CUSTOM_16, new String[] {"___"}, 2));
|
||||
Triplet.of(TaskCustomField.CUSTOM_14, new String[] {"%"}, 97),
|
||||
Triplet.of(TaskCustomField.CUSTOM_15, new String[] {"___"}, 4),
|
||||
Triplet.of(TaskCustomField.CUSTOM_16, new String[] {"___"}, 4));
|
||||
assertThat(list).hasSameSizeAs(TaskCustomField.values());
|
||||
|
||||
return DynamicTest.stream(
|
||||
|
|
@ -312,22 +312,22 @@ class QueryTasksAccTest extends AbstractAccTest {
|
|||
// carefully constructed to always return exactly 2 results
|
||||
List<Triplet<TaskCustomField, String[], Integer>> list =
|
||||
List.of(
|
||||
Triplet.of(TaskCustomField.CUSTOM_1, new String[] {"custom1"}, 87),
|
||||
Triplet.of(TaskCustomField.CUSTOM_1, new String[] {"custom1"}, 96),
|
||||
Triplet.of(TaskCustomField.CUSTOM_2, new String[] {""}, 2),
|
||||
Triplet.of(TaskCustomField.CUSTOM_3, new String[] {"custom3"}, 87),
|
||||
Triplet.of(TaskCustomField.CUSTOM_3, new String[] {"custom3"}, 96),
|
||||
Triplet.of(TaskCustomField.CUSTOM_4, new String[] {""}, 2),
|
||||
Triplet.of(TaskCustomField.CUSTOM_5, new String[] {"ew", "al", "el"}, 81),
|
||||
Triplet.of(TaskCustomField.CUSTOM_6, new String[] {"11", "vvg"}, 84),
|
||||
Triplet.of(TaskCustomField.CUSTOM_7, new String[] {"custom7", "ijk"}, 86),
|
||||
Triplet.of(TaskCustomField.CUSTOM_8, new String[] {"not_existing"}, 88),
|
||||
Triplet.of(TaskCustomField.CUSTOM_9, new String[] {"custom9"}, 87),
|
||||
Triplet.of(TaskCustomField.CUSTOM_10, new String[] {"custom10"}, 87),
|
||||
Triplet.of(TaskCustomField.CUSTOM_11, new String[] {"custom11"}, 87),
|
||||
Triplet.of(TaskCustomField.CUSTOM_12, new String[] {"custom12"}, 87),
|
||||
Triplet.of(TaskCustomField.CUSTOM_13, new String[] {"custom13"}, 87),
|
||||
Triplet.of(TaskCustomField.CUSTOM_5, new String[] {"ew", "al", "el"}, 90),
|
||||
Triplet.of(TaskCustomField.CUSTOM_6, new String[] {"11", "vvg"}, 93),
|
||||
Triplet.of(TaskCustomField.CUSTOM_7, new String[] {"custom7", "ijk"}, 95),
|
||||
Triplet.of(TaskCustomField.CUSTOM_8, new String[] {"not_existing"}, 97),
|
||||
Triplet.of(TaskCustomField.CUSTOM_9, new String[] {"custom9"}, 96),
|
||||
Triplet.of(TaskCustomField.CUSTOM_10, new String[] {"custom10"}, 96),
|
||||
Triplet.of(TaskCustomField.CUSTOM_11, new String[] {"custom11"}, 96),
|
||||
Triplet.of(TaskCustomField.CUSTOM_12, new String[] {"custom12"}, 96),
|
||||
Triplet.of(TaskCustomField.CUSTOM_13, new String[] {"custom13"}, 96),
|
||||
Triplet.of(TaskCustomField.CUSTOM_14, new String[] {"abc"}, 0),
|
||||
Triplet.of(TaskCustomField.CUSTOM_15, new String[] {"custom15"}, 87),
|
||||
Triplet.of(TaskCustomField.CUSTOM_16, new String[] {"custom16"}, 87));
|
||||
Triplet.of(TaskCustomField.CUSTOM_15, new String[] {"custom15"}, 96),
|
||||
Triplet.of(TaskCustomField.CUSTOM_16, new String[] {"custom16"}, 96));
|
||||
assertThat(list).hasSameSizeAs(TaskCustomField.values());
|
||||
|
||||
return DynamicTest.stream(
|
||||
|
|
@ -376,7 +376,7 @@ class QueryTasksAccTest extends AbstractAccTest {
|
|||
throws InvalidArgumentException {
|
||||
List<TaskSummary> results =
|
||||
taskService.createTaskQuery().customAttributeIn(TaskCustomField.CUSTOM_9, "").list();
|
||||
assertThat(results).hasSize(86);
|
||||
assertThat(results).hasSize(95);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "admin")
|
||||
|
|
@ -388,7 +388,7 @@ class QueryTasksAccTest extends AbstractAccTest {
|
|||
.createTaskQuery()
|
||||
.customAttributeIn(TaskCustomField.CUSTOM_9, "", null)
|
||||
.list();
|
||||
assertThat(results).hasSize(87);
|
||||
assertThat(results).hasSize(96);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "admin")
|
||||
|
|
@ -400,14 +400,14 @@ class QueryTasksAccTest extends AbstractAccTest {
|
|||
.createTaskQuery()
|
||||
.customAttributeNotIn(TaskCustomField.CUSTOM_9, new String[] {null})
|
||||
.list();
|
||||
assertThat(results).hasSize(87);
|
||||
assertThat(results).hasSize(96);
|
||||
|
||||
results =
|
||||
taskService
|
||||
.createTaskQuery()
|
||||
.customAttributeNotIn(TaskCustomField.CUSTOM_9, null, "custom9")
|
||||
.list();
|
||||
assertThat(results).hasSize(86);
|
||||
assertThat(results).hasSize(95);
|
||||
|
||||
results =
|
||||
taskService
|
||||
|
|
@ -415,7 +415,7 @@ class QueryTasksAccTest extends AbstractAccTest {
|
|||
.customAttributeNotIn(TaskCustomField.CUSTOM_9, new String[] {null})
|
||||
.customAttributeNotIn(TaskCustomField.CUSTOM_10, "custom10")
|
||||
.list();
|
||||
assertThat(results).hasSize(86);
|
||||
assertThat(results).hasSize(95);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "admin")
|
||||
|
|
|
|||
|
|
@ -48,7 +48,7 @@ class QueryTasksByRoleAccTest extends AbstractAccTest {
|
|||
switch (taskanaEngine.getCurrentUserContext().getUserid()) {
|
||||
case "admin":
|
||||
case "taskadmin":
|
||||
expectedSize = 88;
|
||||
expectedSize = 97;
|
||||
break;
|
||||
case "businessadmin":
|
||||
case "monitor":
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ class QueryTasksByTimeIntervalsAccTest extends AbstractAccTest {
|
|||
.orderByCreated(asc)
|
||||
.list();
|
||||
|
||||
assertThat(results).hasSize(53);
|
||||
assertThat(results).hasSize(62);
|
||||
TaskSummary previousSummary = null;
|
||||
for (TaskSummary taskSummary : results) {
|
||||
Instant cr = taskSummary.getCreated();
|
||||
|
|
@ -93,7 +93,7 @@ class QueryTasksByTimeIntervalsAccTest extends AbstractAccTest {
|
|||
List<TaskSummary> results =
|
||||
taskService.createTaskQuery().createdWithin(interval1).orderByCreated(asc).list();
|
||||
|
||||
assertThat(results).hasSize(52);
|
||||
assertThat(results).hasSize(61);
|
||||
TaskSummary previousSummary = null;
|
||||
for (TaskSummary taskSummary : results) {
|
||||
Instant cr = taskSummary.getCreated();
|
||||
|
|
@ -123,7 +123,7 @@ class QueryTasksByTimeIntervalsAccTest extends AbstractAccTest {
|
|||
.orderByCreated(asc)
|
||||
.list();
|
||||
|
||||
assertThat(results).hasSize(38);
|
||||
assertThat(results).hasSize(45);
|
||||
TaskSummary previousSummary = null;
|
||||
for (TaskSummary taskSummary : results) {
|
||||
Instant cr = taskSummary.getClaimed();
|
||||
|
|
@ -192,7 +192,7 @@ class QueryTasksByTimeIntervalsAccTest extends AbstractAccTest {
|
|||
List<TaskSummary> results =
|
||||
taskService.createTaskQuery().plannedWithin(interval).orderByPlanned(asc).list();
|
||||
|
||||
assertThat(results).hasSize(85);
|
||||
assertThat(results).hasSize(94);
|
||||
TaskSummary previousSummary = null;
|
||||
for (TaskSummary taskSummary : results) {
|
||||
Instant cr = taskSummary.getPlanned();
|
||||
|
|
@ -215,7 +215,7 @@ class QueryTasksByTimeIntervalsAccTest extends AbstractAccTest {
|
|||
List<TaskSummary> results =
|
||||
taskService.createTaskQuery().dueWithin(interval).orderByPlanned(asc).list();
|
||||
|
||||
assertThat(results).hasSize(85);
|
||||
assertThat(results).hasSize(94);
|
||||
TaskSummary previousSummary = null;
|
||||
for (TaskSummary taskSummary : results) {
|
||||
Instant cr = taskSummary.getDue();
|
||||
|
|
@ -265,8 +265,8 @@ class QueryTasksByTimeIntervalsAccTest extends AbstractAccTest {
|
|||
.createTaskQuery()
|
||||
.receivedWithin(new TimeInterval(Instant.parse("2018-01-29T15:55:20Z"), null))
|
||||
.count();
|
||||
assertThat(results).hasSize(41);
|
||||
assertThat(resultCount).isEqualTo(41);
|
||||
assertThat(results).hasSize(50);
|
||||
assertThat(resultCount).isEqualTo(50);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "admin")
|
||||
|
|
@ -293,7 +293,7 @@ class QueryTasksByTimeIntervalsAccTest extends AbstractAccTest {
|
|||
Instant.parse("2018-01-29T15:55:18Z"),
|
||||
Instant.parse("2018-01-29T15:55:21Z")))
|
||||
.count();
|
||||
assertThat(resultCount).isEqualTo(61);
|
||||
assertThat(resultCount).isEqualTo(70);
|
||||
assertThat(resultCount2).isEqualTo(4);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -97,7 +97,7 @@ class QueryTasksByWildcardSearchAccTest extends AbstractAccTest {
|
|||
.wildcardSearchValueLike("%wid%")
|
||||
.list();
|
||||
|
||||
assertThat(foundTasksCaseSensitive).hasSize(81);
|
||||
assertThat(foundTasksCaseSensitive).hasSize(90);
|
||||
assertThat(foundTasksCaseInsensitive).containsExactlyElementsOf(foundTasksCaseSensitive);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -97,7 +97,7 @@ class QueryTasksListValuesAccTest extends AbstractAccTest {
|
|||
@Test
|
||||
void should_ReturnStateValues_When_ListValuesForStateIsInvoked() {
|
||||
List<String> columnValueList = TASK_SERVICE.createTaskQuery().listValues(STATE, null);
|
||||
assertThat(columnValueList).hasSize(5);
|
||||
assertThat(columnValueList).hasSize(7);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "admin")
|
||||
|
|
|
|||
|
|
@ -31,9 +31,9 @@ class QueryTasksWithPaginationAccTest extends AbstractAccTest {
|
|||
void testQueryAllPaged() {
|
||||
TaskQuery taskQuery = taskanaEngine.getTaskService().createTaskQuery();
|
||||
long numberOfTasks = taskQuery.count();
|
||||
assertThat(numberOfTasks).isEqualTo(88);
|
||||
assertThat(numberOfTasks).isEqualTo(97);
|
||||
List<TaskSummary> tasks = taskQuery.orderByDue(DESCENDING).list();
|
||||
assertThat(tasks).hasSize(88);
|
||||
assertThat(tasks).hasSize(97);
|
||||
List<TaskSummary> tasksp = taskQuery.orderByDue(DESCENDING).listPage(4, 5);
|
||||
assertThat(tasksp).hasSize(5);
|
||||
tasksp = taskQuery.orderByDue(DESCENDING).listPage(5, 5);
|
||||
|
|
|
|||
Loading…
Reference in New Issue