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

TSK-1726: Implemented option to include long name on Task / TaskComment / TaskHistoryEvent

This commit is contained in:
Joerg Heffner 2021-09-14 16:47:21 +02:00 committed by gitgoodjhe
parent 5bce09adab
commit e264a20389
73 changed files with 2508 additions and 498 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
common/taskana-common-data/src/main/resources/sql/test-data/task-comment.sql
View File

@ -11,8 +11,8 @@ INSERT INTO TASK_COMMENT VALUES('TCI:000000000000000000000000000000000005', 'TKI
INSERT INTO TASK_COMMENT VALUES('TCI:000000000000000000000000000000000006', 'TKI:000000000000000000000000000000000002', 'some text in textfield', 'user-1-1', '2018-01-29 15:55:00', '2018-01-30 15:55:00');
INSERT INTO TASK_COMMENT VALUES('TCI:000000000000000000000000000000000007', 'TKI:000000000000000000000000000000000002', 'some other text in textfield', 'user-1-1', '2018-01-29 15:55:00', '2018-01-30 15:55:00');
-- TaskComments for CreateTaskCommentAccTest
INSERT INTO TASK_COMMENT VALUES('TCI:000000000000000000000000000000000008', 'TKI:000000000000000000000000000000000026', 'some text in textfield', 'user_1_1', '2016-01-29 15:55:00', '2030-01-30 15:55:00');
INSERT INTO TASK_COMMENT VALUES('TCI:000000000000000000000000000000000009', 'TKI:000000000000000000000000000000000026', 'some other text in textfield', 'user_1_1', '2015-01-29 15:55:00', '2000-01-30 15:55:00');
INSERT INTO TASK_COMMENT VALUES('TCI:000000000000000000000000000000000010', 'TKI:000000000000000000000000000000000027', 'some text in textfield', 'user_1_1', '2020-01-29 15:55:00', '2024-01-30 15:55:00');
INSERT INTO TASK_COMMENT VALUES('TCI:000000000000000000000000000000000011', 'TKI:000000000000000000000000000000000027', 'some other text in textfield', 'user_1_1', '2018-01-29 15:55:00', '1988-01-30 15:55:00');
INSERT INTO TASK_COMMENT VALUES('TCI:000000000000000000000000000000000012', 'TKI:000000000000000000000000000000000004', 'some text in textfield', 'user_1_1', '2017-01-29 15:55:00', '2018-01-30 15:55:00');
INSERT INTO TASK_COMMENT VALUES('TCI:000000000000000000000000000000000008', 'TKI:000000000000000000000000000000000026', 'some text in textfield', 'user-b-1', '2016-01-29 15:55:00', '2030-01-30 15:55:00');
INSERT INTO TASK_COMMENT VALUES('TCI:000000000000000000000000000000000009', 'TKI:000000000000000000000000000000000026', 'some other text in textfield', 'user-1-1', '2015-01-29 15:55:00', '2000-01-30 15:55:00');
INSERT INTO TASK_COMMENT VALUES('TCI:000000000000000000000000000000000010', 'TKI:000000000000000000000000000000000027', 'some text in textfield', 'user-1-1', '2020-01-29 15:55:00', '2024-01-30 15:55:00');
INSERT INTO TASK_COMMENT VALUES('TCI:000000000000000000000000000000000011', 'TKI:000000000000000000000000000000000027', 'some other text in textfield', 'user-1-1', '2018-01-29 15:55:00', '1988-01-30 15:55:00');
INSERT INTO TASK_COMMENT VALUES('TCI:000000000000000000000000000000000012', 'TKI:000000000000000000000000000000000004', 'some text in textfield', 'user-1-1', '2017-01-29 15:55:00', '2018-01-30 15:55:00');

29
common/taskana-common-data/src/main/resources/sql/test-data/task-history-event.sql
View File

@ -1,17 +1,18 @@
INSERT INTO TASK_HISTORY_EVENT (ID,BUSINESS_PROCESS_ID, PARENT_BUSINESS_PROCESS_ID, TASK_ID, EVENT_TYPE, CREATED, USER_ID, DOMAIN, WORKBASKET_KEY, POR_COMPANY, POR_SYSTEM, POR_INSTANCE, POR_TYPE, POR_VALUE, TASK_CLASSIFICATION_KEY,
INSERT INTO TASK_HISTORY_EVENT (ID,BUSINESS_PROCESS_ID, PARENT_BUSINESS_PROCESS_ID, TASK_ID, EVENT_TYPE, CREATED, USER_ID, DOMAIN, WORKBASKET_KEY, POR_COMPANY, POR_SYSTEM, POR_INSTANCE, POR_TYPE, POR_VALUE, TASK_OWNER, TASK_CLASSIFICATION_KEY,
TASK_CLASSIFICATION_CATEGORY, ATTACHMENT_CLASSIFICATION_KEY, OLD_VALUE, NEW_VALUE, CUSTOM_1, CUSTOM_2, CUSTOM_3, CUSTOM_4, DETAILS) VALUES
-- BUSINESS_PROCESS_ID, PARENT_BUSINESS_PROCESS_ID, TASK_ID, EVENT_TYPE, CREATED, USER_ID, DOMAIN, WORKBASKET_KEY, POR_COMPANY , POR_SYSTEM, POR_INSTANCE , POR_TYPE , POR_VALUE , TASK_CLASSIFICATION_KEY, TASK_CLASSIFICATION_CATEGORY , ATTACHMENT_CLASSIFICATION_KEY , OLD_VALUE , NEW_VALUE , CUSTOM_1 , CUSTOM_2 , CUSTOM_3 , CUSTOM_4, details
('THI:000000000000000000000000000000000000','BPI:01' ,'' ,'TKI:000000000000000000000000000000000000', 'UPDATED', '2018-01-29 15:55:00' , 'admin', 'DOMAIN_B', 'WBI:100000000000000000000000000000000001', '00' , 'PASystem', '00' , 'VNR' , '11223344', 'L140101' , 'TASK' ,'' ,'old_val' ,'new_val' ,'custom1' ,'custom2' , 'custom3' ,'custom4', '{"changes":[{"newValue":"BPI:01","fieldName":"businessProcessId","oldValue":"BPI:02"},{"newValue":"admin","fieldName":"owner","oldValue":"owner1"}]}' ),
('THI:000000000000000000000000000000000001','BPI:02' ,'' ,'TKI:000000000000000000000000000000000000', 'CREATED', '2018-01-29 15:55:01','peter', 'DOMAIN_A', 'WBI:100000000000000000000000000000000001', '00' , 'PASystem', '00' , 'VNR' , '11223344', '' , '' ,'' ,'2old_val' ,'new_val2' ,'custom1' ,'' , 'custom2' ,'' ,'someDetails' ),
('THI:000000000000000000000000000000000002','BPI:03' ,'BPI:01','TKI:000000000000000000000000000000000036','CREATED', '2018-01-29 15:55:02' , 'admin', 'DOMAIN_A', 'WBI:100000000000000000000000000000000002', '11' , '' , '22' , '' , '' , 'L140101' , 'TASK' ,'DOCTYPE_DEFAULT' ,'' ,'' ,'custom1' ,'' , 'custom3' ,'' ,'someDetails' ),
('THI:000000000000000000000000000000000003','BPI:02' ,'' ,'TKI:000000000000000000000000000000000036', 'CREATED', '2018-01-29 15:55:03','peter', 'DOMAIN_A', 'WBI:100000000000000000000000000000000001', '00' , 'PASystem', '00' , 'VNR' , '11223344', '' , '' ,'' ,'2old_val' ,'new_val2' ,'custom1' ,'' , 'custom2' ,'' ,'someDetails' ),
('THI:000000000000000000000000000000000004','BPI:03' ,'BPI:01','TKI:000000000000000000000000000000000037','CREATED', '2018-01-29 15:55:04' , 'admin', 'DOMAIN_A', 'WBI:100000000000000000000000000000000002', '11' , '' , '22' , '' , '' , 'L140101' , 'TASK' ,'DOCTYPE_DEFAULT' ,'' ,'' ,'custom1' ,'' , 'custom3' ,'' ,'someDetails' ),
('THI:000000000000000000000000000000000005','BPI:02' ,'' ,'TKI:000000000000000000000000000000000038', 'CREATED', '2018-01-29 15:55:05','peter', 'DOMAIN_A', 'WBI:100000000000000000000000000000000001', '00' , 'PASystem', '00' , 'VNR' , '11223344', '' , '' ,'' ,'2old_val' ,'new_val2' ,'custom1' ,'' , 'custom2' ,'' ,'someDetails' ),
('THI:000000000000000000000000000000000006','BPI:03' ,'BPI:01','TKI:000000000000000000000000000000000038','CREATED', '2018-01-29 15:55:06' , 'admin', 'DOMAIN_A', 'WBI:100000000000000000000000000000000002', '11' , '' , '22' , '' , '' , 'L140101' , 'TASK' ,'DOCTYPE_DEFAULT' ,'' ,'' ,'custom1' ,'' , 'custom3' ,'' ,'someDetails' ),
('THI:000000000000000000000000000000000007','BPI:02' ,'' ,'TKI:000000000000000000000000000000000039', 'CREATED', '2018-01-29 15:55:07','peter', 'DOMAIN_A', 'WBI:100000000000000000000000000000000001', '00' , 'PASystem', '00' , 'VNR' , '11223344', '' , '' ,'' ,'2old_val' ,'new_val2' ,'custom1' ,'' , 'custom2' ,'' ,'someDetails' ),
('THI:000000000000000000000000000000000008','BPI:03' ,'BPI:01','TKI:000000000000000000000000000000000039','CREATED', '2018-01-29 15:55:08' , 'admin', 'DOMAIN_A', 'WBI:100000000000000000000000000000000002', '11' , '' , '22' , '' , '' , 'L140101' , 'TASK' ,'DOCTYPE_DEFAULT' ,'' ,'' ,'custom1' ,'' , 'custom3' ,'' ,'someDetails' ),
('THI:000000000000000000000000000000000009','BPI:02' ,'' ,'TKI:000000000000000000000000000000000040', 'CREATED', '2018-01-29 15:55:09','peter', 'DOMAIN_A', 'WBI:100000000000000000000000000000000001', '00' , 'PASystem', '00' , 'VNR' , '11223344', '' , '' ,'' ,'2old_val' ,'new_val2' ,'custom1' ,'' , 'custom2' ,'' ,'someDetails' ),
('THI:000000000000000000000000000000000010','BPI:03' ,'BPI:01','TKI:000000000000000000000000000000000040','CREATED', '2018-01-29 15:55:10' , 'admin', 'DOMAIN_A', 'WBI:100000000000000000000000000000000002', '11' , '' , '22' , '' , '' , 'L140101' , 'TASK' ,'DOCTYPE_DEFAULT' ,'' ,'' ,'custom1' ,'' , 'custom3' ,'' ,'someDetails' ),
('THI:000000000000000000000000000000000011','BPI:02' ,'' ,'TKI:000000000000000000000000000000000066', 'CREATED', '2018-01-29 15:55:11','peter', 'DOMAIN_A', 'WBI:100000000000000000000000000000000001', '00' , 'PASystem', '00' , 'VNR' , '11223344', '' , '' ,'' ,'2old_val' ,'new_val2' ,'custom1' ,'' , 'custom2' ,'' ,'someDetails' ),
('THI:000000000000000000000000000000000012','BPI:03' ,'BPI:01','TKI:000000000000000000000000000000000066','CREATED', '2018-01-29 15:55:12' , 'admin', 'DOMAIN_A', 'WBI:100000000000000000000000000000000002', '11' , '' , '22' , '' , '' , 'L140101' , 'TASK' ,'DOCTYPE_DEFAULT' ,'' ,'' ,'custom1' ,'' , 'custom3' ,'' ,'someDetails' )
('THI:000000000000000000000000000000000000','BPI:01' ,'' ,'TKI:000000000000000000000000000000000000', 'UPDATED', '2018-01-29 15:55:00' , 'user-1-1', 'DOMAIN_B', 'WBI:100000000000000000000000000000000001', '00' , 'PASystem', '00' , 'VNR' , '11223344', 'user-1-1', 'L140101' , 'TASK' ,'' ,'old_val' ,'new_val' ,'custom1' ,'custom2' , 'custom3' ,'custom4', '{"changes":[{"newValue":"BPI:01","fieldName":"businessProcessId","oldValue":"BPI:02"},{"newValue":"user-1-1","fieldName":"owner","oldValue":"owner1"}]}' ),
('THI:000000000000000000000000000000000001','BPI:02' ,'' ,'TKI:000000000000000000000000000000000000', 'CREATED', '2018-01-29 15:55:01','peter', 'DOMAIN_A', 'WBI:100000000000000000000000000000000001', '00' , 'PASystem', '00' , 'VNR' , '11223344', 'user-1-1', '' , '' ,'' ,'2old_val' ,'new_val2' ,'custom1' ,'' , 'custom2' ,'' ,'someDetails' ),
('THI:000000000000000000000000000000000002','BPI:03' ,'BPI:01','TKI:000000000000000000000000000000000036','CREATED', '2018-01-29 15:55:02' , 'admin', 'DOMAIN_A', 'WBI:100000000000000000000000000000000002', '11' , '' , '22' , '' , '' , 'user-1-2', 'L140101' , 'TASK' ,'DOCTYPE_DEFAULT' ,'' ,'' ,'custom1' ,'' , 'custom3' ,'' ,'someDetails' ),
('THI:000000000000000000000000000000000003','BPI:02' ,'' ,'TKI:000000000000000000000000000000000036', 'CREATED', '2018-01-29 15:55:03','peter', 'DOMAIN_A', 'WBI:100000000000000000000000000000000001', '00' , 'PASystem', '00' , 'VNR' , '11223344', 'user-1-2', '' , '' ,'' ,'2old_val' ,'new_val2' ,'custom1' ,'' , 'custom2' ,'' ,'someDetails' ),
('THI:000000000000000000000000000000000004','BPI:03' ,'BPI:01','TKI:000000000000000000000000000000000037','CREATED', '2018-01-29 15:55:04' , 'admin', 'DOMAIN_A', 'WBI:100000000000000000000000000000000002', '11' , '' , '22' , '' , '' , 'user-1-2', 'L140101' , 'TASK' ,'DOCTYPE_DEFAULT' ,'' ,'' ,'custom1' ,'' , 'custom3' ,'' ,'someDetails' ),
('THI:000000000000000000000000000000000005','BPI:02' ,'' ,'TKI:000000000000000000000000000000000038', 'CREATED', '2018-01-29 15:55:05','peter', 'DOMAIN_A', 'WBI:100000000000000000000000000000000001', '00' , 'PASystem', '00' , 'VNR' , '11223344', 'user-1-2', '' , '' ,'' ,'2old_val' ,'new_val2' ,'custom1' ,'' , 'custom2' ,'' ,'someDetails' ),
('THI:000000000000000000000000000000000006','BPI:03' ,'BPI:01','TKI:000000000000000000000000000000000038','CREATED', '2018-01-29 15:55:06' , 'admin', 'DOMAIN_A', 'WBI:100000000000000000000000000000000002', '11' , '' , '22' , '' , '' , 'user-1-2', 'L140101' , 'TASK' ,'DOCTYPE_DEFAULT' ,'' ,'' ,'custom1' ,'' , 'custom3' ,'' ,'someDetails' ),
('THI:000000000000000000000000000000000007','BPI:02' ,'' ,'TKI:000000000000000000000000000000000039', 'CREATED', '2018-01-29 15:55:07','peter', 'DOMAIN_A', 'WBI:100000000000000000000000000000000001', '00' , 'PASystem', '00' , 'VNR' , '11223344', 'user-1-2', '' , '' ,'' ,'2old_val' ,'new_val2' ,'custom1' ,'' , 'custom2' ,'' ,'someDetails' ),
('THI:000000000000000000000000000000000008','BPI:03' ,'BPI:01','TKI:000000000000000000000000000000000039','CREATED', '2018-01-29 15:55:08' , 'admin', 'DOMAIN_A', 'WBI:100000000000000000000000000000000002', '11' , '' , '22' , '' , '' , 'user-1-2', 'L140101' , 'TASK' ,'DOCTYPE_DEFAULT' ,'' ,'' ,'custom1' ,'' , 'custom3' ,'' ,'someDetails' ),
('THI:000000000000000000000000000000000009','BPI:02' ,'' ,'TKI:000000000000000000000000000000000040', 'CREATED', '2018-01-29 15:55:09','peter', 'DOMAIN_A', 'WBI:100000000000000000000000000000000001', '00' , 'PASystem', '00' , 'VNR' , '11223344', 'user-1-2', '' , '' ,'' ,'2old_val' ,'new_val2' ,'custom1' ,'' , 'custom2' ,'' ,'someDetails' ),
('THI:000000000000000000000000000000000010','BPI:03' ,'BPI:01','TKI:000000000000000000000000000000000040','CREATED', '2018-01-29 15:55:10' , 'admin', 'DOMAIN_A', 'WBI:100000000000000000000000000000000002', '11' , '' , '22' , '' , '' , 'user-1-2', 'L140101' , 'TASK' ,'DOCTYPE_DEFAULT' ,'' ,'' ,'custom1' ,'' , 'custom3' ,'' ,'someDetails' ),
('THI:000000000000000000000000000000000011','BPI:02' ,'' ,'TKI:000000000000000000000000000000000066', 'CREATED', '2018-01-29 15:55:11','peter', 'DOMAIN_A', 'WBI:100000000000000000000000000000000001', '00' , 'PASystem', '00' , 'VNR' , '11223344', 'user-1-1', '' , '' ,'' ,'2old_val' ,'new_val2' ,'custom1' ,'' , 'custom2' ,'' ,'someDetails' ),
('THI:000000000000000000000000000000000012','BPI:03' ,'BPI:01','TKI:000000000000000000000000000000000066','CREATED', '2018-01-29 15:55:12' , 'admin', 'DOMAIN_A', 'WBI:100000000000000000000000000000000002', '11' , '' , '22' , '' , '' , 'user-1-1', 'L140101' , 'TASK' ,'DOCTYPE_DEFAULT' ,'' ,'' ,'custom1' ,'' , 'custom3' ,'' ,'someDetails' ),
('THI:000000000000000000000000000000000013','BPI:03' ,'BPI:01','TKI:000000000000000000000000000000000000','CREATED', '2018-01-29 15:55:12' , 'user-1-2', 'DOMAIN_A', 'WBI:100000000000000000000000000000000002', '11' , '' , '22' , '' , '' , 'user-1-1', 'L140101' , 'TASK' ,'DOCTYPE_DEFAULT' ,'' ,'' ,'custom1' ,'' , 'custom3' ,'' ,'someDetails' )
;

10
history/taskana-simplehistory-provider/src/main/java/pro/taskana/simplehistory/impl/SimpleHistoryServiceImpl.java
View File

@ -21,6 +21,8 @@ import pro.taskana.spi.history.api.events.classification.ClassificationHistoryEv
import pro.taskana.spi.history.api.events.task.TaskHistoryEvent;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEvent;
import pro.taskana.spi.history.api.exceptions.TaskanaHistoryEventNotFoundException;
import pro.taskana.user.api.models.User;
import pro.taskana.user.internal.UserMapper;
/** This is the implementation of TaskanaHistory. */
public class SimpleHistoryServiceImpl implements TaskanaHistory {
@ -30,6 +32,7 @@ public class SimpleHistoryServiceImpl implements TaskanaHistory {
private TaskHistoryEventMapper taskHistoryEventMapper;
private WorkbasketHistoryEventMapper workbasketHistoryEventMapper;
private ClassificationHistoryEventMapper classificationHistoryEventMapper;
private UserMapper userMapper;
public void initialize(TaskanaEngine taskanaEngine) {
@ -47,6 +50,7 @@ public class SimpleHistoryServiceImpl implements TaskanaHistory {
this.taskanaHistoryEngine.getSqlSession().getMapper(WorkbasketHistoryEventMapper.class);
this.classificationHistoryEventMapper =
this.taskanaHistoryEngine.getSqlSession().getMapper(ClassificationHistoryEventMapper.class);
this.userMapper = taskanaHistoryEngine.getSqlSession().getMapper(UserMapper.class);
}
@Override
@ -127,6 +131,12 @@ public class SimpleHistoryServiceImpl implements TaskanaHistory {
throw new TaskanaHistoryEventNotFoundException(historyEventId);
}
if (taskanaHistoryEngine.getConfiguration().getAddAdditionalUserInfo()) {
User user = userMapper.findById(resultEvent.getUserId());
if (user != null) {
resultEvent.setUserLongName(user.getLongName());
}
}
return resultEvent;
} catch (SQLException e) {

12
history/taskana-simplehistory-provider/src/main/java/pro/taskana/simplehistory/impl/TaskHistoryQueryImpl.java
View File

@ -32,6 +32,7 @@ public class TaskHistoryQueryImpl implements TaskHistoryQuery {
private final TaskanaHistoryEngineImpl taskanaHistoryEngine;
private final List<String> orderBy;
private final List<String> orderColumns;
private boolean joinWithUserInfo;
@SuppressWarnings("unused")
private TaskHistoryQueryColumnName columnName;
@ -59,7 +60,6 @@ public class TaskHistoryQueryImpl implements TaskHistoryQuery {
private String[] custom2In;
private String[] custom3In;
private String[] custom4In;
private String[] businessProcessIdLike;
private String[] parentBusinessProcessIdLike;
private String[] taskIdLike;
@ -82,10 +82,12 @@ public class TaskHistoryQueryImpl implements TaskHistoryQuery {
private String[] custom3Like;
private String[] custom4Like;
public TaskHistoryQueryImpl(TaskanaHistoryEngineImpl taskanaHistoryEngine) {
public TaskHistoryQueryImpl(
TaskanaHistoryEngineImpl taskanaHistoryEngine) {
this.taskanaHistoryEngine = taskanaHistoryEngine;
this.orderBy = new ArrayList<>();
this.orderColumns = new ArrayList<>();
this.joinWithUserInfo = taskanaHistoryEngine.getConfiguration().getAddAdditionalUserInfo();
}
public String[] getIdIn() {
@ -264,6 +266,7 @@ public class TaskHistoryQueryImpl implements TaskHistoryQuery {
return custom4Like;
}
@Override
public TaskHistoryQuery idIn(String... idIn) {
this.idIn = toUpperCopy(idIn);
@ -664,6 +667,11 @@ public class TaskHistoryQueryImpl implements TaskHistoryQuery {
this.orderBy.clear();
this.addOrderCriteria(columnName.toString(), sortDirection);
if (columnName == TaskHistoryQueryColumnName.USER_LONG_NAME
|| columnName == TaskHistoryQueryColumnName.TASK_OWNER_LONG_NAME) {
joinWithUserInfo = true;
}
try {
taskanaHistoryEngine.openConnection();
result = taskanaHistoryEngine.getSqlSession().selectList(LINK_TO_VALUE_MAPPER, this);

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

@ -35,6 +35,7 @@ import pro.taskana.simplehistory.impl.task.TaskHistoryQueryMapper;
import pro.taskana.simplehistory.impl.workbasket.WorkbasketHistoryEventMapper;
import pro.taskana.simplehistory.impl.workbasket.WorkbasketHistoryQueryMapper;
import pro.taskana.spi.history.api.TaskanaHistory;
import pro.taskana.user.internal.UserMapper;
/** This is the implementation of TaskanaHistoryEngine. */
public class TaskanaHistoryEngineImpl implements TaskanaHistoryEngine {
@ -118,6 +119,7 @@ public class TaskanaHistoryEngineImpl implements TaskanaHistoryEngine {
configuration.addMapper(WorkbasketHistoryQueryMapper.class);
configuration.addMapper(ClassificationHistoryEventMapper.class);
configuration.addMapper(ClassificationHistoryQueryMapper.class);
configuration.addMapper(UserMapper.class);
SqlSessionFactory localSessionFactory = new SqlSessionFactoryBuilder().build(configuration);
return SqlSessionManager.newInstance(localSessionFactory);

4
history/taskana-simplehistory-provider/src/main/java/pro/taskana/simplehistory/impl/task/TaskHistoryQueryColumnName.java
View File

@ -10,7 +10,8 @@ public enum TaskHistoryQueryColumnName implements QueryColumnName {
TASK_ID("task_id"),
EVENT_TYPE("event_type"),
CREATED("created"),
USER_ID("user_id"),
USER_ID("t.user_id"),
USER_LONG_NAME("u.long_name"),
DOMAIN("domain"),
WORKBASKET_KEY("workbasket_key"),
POR_COMPANY("por_company"),
@ -18,6 +19,7 @@ public enum TaskHistoryQueryColumnName implements QueryColumnName {
POR_INSTANCE("por_instance"),
POR_TYPE("por_type"),
POR_VALUE("por_value"),
TASK_OWNER_LONG_NAME("o.long_name"),
TASK_CLASSIFICATION_KEY("task_classification_key"),
TASK_CLASSIFICATION_CATEGORY("task_classification_category"),
ATTACHMENT_CLASSIFICATION_KEY("attachment_classification_key"),

21
history/taskana-simplehistory-provider/src/main/java/pro/taskana/simplehistory/impl/task/TaskHistoryQueryMapper.java
View File

@ -13,10 +13,15 @@ public interface TaskHistoryQueryMapper {
@Select(
"<script>"
+ "SELECT ID, BUSINESS_PROCESS_ID, PARENT_BUSINESS_PROCESS_ID, TASK_ID, EVENT_TYPE, CREATED, USER_ID, DOMAIN, WORKBASKET_KEY, "
+ "SELECT ID, BUSINESS_PROCESS_ID, PARENT_BUSINESS_PROCESS_ID, TASK_ID, EVENT_TYPE, CREATED, t.USER_ID, DOMAIN, WORKBASKET_KEY, "
+ "POR_COMPANY, POR_SYSTEM, POR_INSTANCE, POR_TYPE, POR_VALUE, TASK_CLASSIFICATION_KEY, TASK_CLASSIFICATION_CATEGORY,"
+ "ATTACHMENT_CLASSIFICATION_KEY, OLD_VALUE, NEW_VALUE, CUSTOM_1, CUSTOM_2, CUSTOM_3, CUSTOM_4 "
+ "FROM TASK_HISTORY_EVENT"
+ "<if test=\"joinWithUserInfo\">, u.LONG_NAME AS USER_LONG_NAME, o.LONG_NAME AS TASK_OWNER_LONG_NAME </if>"
+ "FROM TASK_HISTORY_EVENT t "
+ "<if test=\"joinWithUserInfo\">"
+ "LEFT JOIN USER_INFO AS u ON t.USER_ID = u.USER_ID "
+ "LEFT JOIN USER_INFO AS o ON TASK_OWNER = o.USER_ID "
+ "</if>"
+ "<where>"
// IN-Queries
+ "<if test='idIn != null'>AND UPPER(ID) IN (<foreach item='item' collection='idIn' separator=',' >#{item}</foreach>)</if> "
@ -25,7 +30,7 @@ public interface TaskHistoryQueryMapper {
+ "<if test='taskIdIn != null'>AND UPPER(TASK_ID) IN (<foreach item='item' collection='taskIdIn' separator=',' >#{item}</foreach>)</if> "
+ "<if test='eventTypeIn != null'>AND UPPER(EVENT_TYPE) IN (<foreach item='item' collection='eventTypeIn' separator=',' >#{item}</foreach>)</if> "
+ "<if test='createdIn !=null'> AND ( <foreach item='item' collection='createdIn' separator=',' > ( <if test='item.begin!=null'> CREATED &gt;= #{item.begin} </if> <if test='item.begin!=null and item.end!=null'> AND </if><if test='item.end!=null'> CREATED &lt;=#{item.end} </if>)</foreach>)</if> "
+ "<if test='userIdIn != null'>AND UPPER(USER_ID) IN (<foreach item='item' collection='userIdIn' separator=',' >#{item}</foreach>)</if> "
+ "<if test='userIdIn != null'>AND UPPER(t.USER_ID) IN (<foreach item='item' collection='userIdIn' separator=',' >#{item}</foreach>)</if> "
+ "<if test='domainIn != null'>AND UPPER(DOMAIN) IN (<foreach item='item' collection='domainIn' separator=',' >#{item}</foreach>)</if> "
+ "<if test='workbasketKeyIn != null'>AND UPPER(WORKBASKET_KEY) IN (<foreach item='item' collection='workbasketKeyIn' separator=',' >#{item}</foreach>)</if> "
+ "<if test='porCompanyIn != null'>AND UPPER(POR_COMPANY) IN (<foreach item='item' collection='porCompanyIn' separator=',' >#{item}</foreach>)</if> "
@ -47,7 +52,7 @@ public interface TaskHistoryQueryMapper {
+ "<if test='parentBusinessProcessIdLike != null'>AND (<foreach item='item' collection='parentBusinessProcessIdLike' separator=' OR ' >UPPER(PARENT_BUSINESS_PROCESS_ID) LIKE #{item}</foreach>)</if> "
+ "<if test='taskIdLike != null'>AND (<foreach item='item' collection='taskIdLike' separator=' OR ' >UPPER(TASK_ID) LIKE #{item}</foreach>)</if> "
+ "<if test='eventTypeLike != null'>AND (<foreach item='item' collection='eventTypeLike' separator=' OR ' >UPPER(EVENT_TYPE) LIKE #{item}</foreach>)</if> "
+ "<if test='userIdLike != null'>AND (<foreach item='item' collection='userIdLike' separator=' OR ' >UPPER(USER_ID) LIKE #{item}</foreach>)</if> "
+ "<if test='userIdLike != null'>AND (<foreach item='item' collection='userIdLike' separator=' OR ' >UPPER(t.USER_ID) LIKE #{item}</foreach>)</if> "
+ "<if test='domainLike != null'>AND (<foreach item='item' collection='domainLike' separator=' OR ' >UPPER(DOMAIN) LIKE #{item}</foreach>)</if> "
+ "<if test='workbasketKeyLike != null'>AND (<foreach item='item' collection='workbasketKeyLike' separator=' OR ' >UPPER(WORKBASKET_KEY) LIKE #{item}</foreach>)</if> "
+ "<if test='porCompanyLike != null'>AND (<foreach item='item' collection='porCompanyLike' separator=' OR ' >UPPER(POR_COMPANY) LIKE #{item}</foreach>)</if> "
@ -71,9 +76,11 @@ public interface TaskHistoryQueryMapper {
@Result(property = "businessProcessId", column = "BUSINESS_PROCESS_ID")
@Result(property = "parentBusinessProcessId", column = "PARENT_BUSINESS_PROCESS_ID")
@Result(property = "taskId", column = "TASK_ID")
@Result(property = "taskOwnerLongName", column = "TASK_OWNER_LONG_NAME")
@Result(property = "eventType", column = "EVENT_TYPE")
@Result(property = "created", column = "CREATED")
@Result(property = "userId", column = "USER_ID")
@Result(property = "userLongName", column = "USER_LONG_NAME")
@Result(property = "domain", column = "DOMAIN")
@Result(property = "workbasketKey", column = "WORKBASKET_KEY")
@Result(property = "porCompany", column = "POR_COMPANY")
@ -148,7 +155,11 @@ public interface TaskHistoryQueryMapper {
@Select(
"<script>SELECT DISTINCT ${columnName} "
+ "FROM TASK_HISTORY_EVENT"
+ "FROM TASK_HISTORY_EVENT AS t"
+ "<if test=\"joinWithUserInfo\">"
+ "LEFT JOIN USER_INFO AS u ON t.USER_ID = u.USER_ID "
+ "LEFT JOIN USER_INFO AS o ON TASK_OWNER = o.USER_ID "
+ "</if>"
+ "<where>"
// IN-Queries
+ "<if test='idIn != null'>AND UPPER(ID) IN (<foreach item='item' collection='idIn' separator=',' >#{item}</foreach>)</if> "

4
history/taskana-simplehistory-provider/src/test/java/acceptance/events/task/CreateHistoryEventOnTaskUpdateAccTest.java
View File

@ -34,7 +34,7 @@ class CreateHistoryEventOnTaskUpdateAccTest extends AbstractAccTest {
taskHistoryQueryMapper.queryHistoryEvents(
(TaskHistoryQueryImpl) historyService.createTaskHistoryQuery().taskIdIn(taskId));
assertThat(events).hasSize(2);
assertThat(events).hasSize(3);
Task task = taskService.getTask(taskId);
task.setName("someUpdatedName");
@ -44,7 +44,7 @@ class CreateHistoryEventOnTaskUpdateAccTest extends AbstractAccTest {
taskHistoryQueryMapper.queryHistoryEvents(
(TaskHistoryQueryImpl) historyService.createTaskHistoryQuery().taskIdIn(taskId));
assertThat(events).hasSize(3);
assertThat(events).hasSize(4);
String eventType = events.get(0).getEventType();

33
history/taskana-simplehistory-provider/src/test/java/acceptance/events/task/GetTaskHistoryEventAccTest.java
View File

@ -18,15 +18,44 @@ class GetTaskHistoryEventAccTest extends AbstractAccTest {
+ "\"newValue\":\"BPI:01\","
+ "\"fieldName\":\"businessProcessId\","
+ "\"oldValue\":\"BPI:02\"},"
+ "{\"newValue\":\"admin\","
+ "{\"newValue\":\"user-1-1\","
+ "\"fieldName\":\"owner\","
+ "\"oldValue\":\"owner1\"}]}";
TaskHistoryEvent taskHistoryEvent =
getHistoryService().getTaskHistoryEvent("THI:000000000000000000000000000000000000");
assertThat(taskHistoryEvent.getBusinessProcessId()).isEqualTo("BPI:01");
assertThat(taskHistoryEvent.getUserId()).isEqualTo("admin");
assertThat(taskHistoryEvent.getUserId()).isEqualTo("user-1-1");
assertThat(taskHistoryEvent.getEventType()).isEqualTo(TaskHistoryEventType.UPDATED.getName());
assertThat(taskHistoryEvent.getDetails()).isEqualTo(detailsJson);
}
@Test
void should_SetTaskOwnerLongNameOfTask_When_PropertyEnabled() throws Exception {
taskanaEngineConfiguration.setAddAdditionalUserInfo(true);
TaskHistoryEvent taskHistoryEvent =
getHistoryService().getTaskHistoryEvent("THI:000000000000000000000000000000000000");
assertThat(taskHistoryEvent.getUserId()).isEqualTo("user-1-1");
String userLongName =
taskanaEngine.getUserService().getUser(taskHistoryEvent.getUserId()).getLongName();
assertThat(taskHistoryEvent)
.extracting(TaskHistoryEvent::getUserLongName)
.isEqualTo(userLongName);
}
@Test
void should_NotSetTaskOwnerLongNameOfTask_When_PropertyDisabled() throws Exception {
taskanaEngineConfiguration.setAddAdditionalUserInfo(false);
TaskHistoryEvent taskHistoryEvent =
getHistoryService().getTaskHistoryEvent("THI:000000000000000000000000000000000000");
assertThat(taskHistoryEvent.getUserId()).isEqualTo("user-1-1");
assertThat(taskHistoryEvent).extracting(TaskHistoryEvent::getUserLongName).isNull();
}
}

30
history/taskana-simplehistory-provider/src/test/java/acceptance/jobs/HistoryCleanupJobAccTest.java
View File

@ -40,7 +40,7 @@ class HistoryCleanupJobAccTest extends AbstractAccTest {
void should_CleanHistoryEventsUntilDate_When_SameParentBusinessTrueAndEventsQualified()
throws Exception {
assertThat(getHistoryService().createTaskHistoryQuery().count()).isEqualTo(13);
assertThat(getHistoryService().createTaskHistoryQuery().count()).isEqualTo(14);
TaskHistoryEvent eventToBeCleaned =
createTaskHistoryEvent(
@ -115,21 +115,21 @@ class HistoryCleanupJobAccTest extends AbstractAccTest {
getHistoryService().create(eventToBeCleaned5);
getHistoryService().create(eventToBeCleaned6);
assertThat(getHistoryService().createTaskHistoryQuery().count()).isEqualTo(19);
assertThat(getHistoryService().createTaskHistoryQuery().count()).isEqualTo(20);
taskanaEngine.getConfiguration().setTaskCleanupJobAllCompletedSameParentBusiness(true);
HistoryCleanupJob job = new HistoryCleanupJob(taskanaEngine, null, null);
job.run();
assertThat(getHistoryService().createTaskHistoryQuery().count()).isEqualTo(13);
assertThat(getHistoryService().createTaskHistoryQuery().count()).isEqualTo(14);
}
@Test
@WithAccessId(user = "admin")
void should_NotCleanHistoryEventsUntilDate_When_MinimumAgeNotReached() throws Exception {
assertThat(getHistoryService().createTaskHistoryQuery().count()).isEqualTo(13);
assertThat(getHistoryService().createTaskHistoryQuery().count()).isEqualTo(14);
TaskHistoryEvent eventToBeCleaned =
createTaskHistoryEvent(
@ -156,12 +156,12 @@ class HistoryCleanupJobAccTest extends AbstractAccTest {
getHistoryService().create(eventToBeCleaned);
getHistoryService().create(eventToBeCleaned2);
assertThat(getHistoryService().createTaskHistoryQuery().count()).isEqualTo(15);
assertThat(getHistoryService().createTaskHistoryQuery().count()).isEqualTo(16);
HistoryCleanupJob job = new HistoryCleanupJob(taskanaEngine, null, null);
job.run();
assertThat(getHistoryService().createTaskHistoryQuery().count()).isEqualTo(15);
assertThat(getHistoryService().createTaskHistoryQuery().count()).isEqualTo(16);
}
@Test
@ -169,7 +169,7 @@ class HistoryCleanupJobAccTest extends AbstractAccTest {
void should_NotCleanHistoryEvents_When_SameParentBusinessTrueAndActiveTaskInParentBusiness()
throws Exception {
assertThat(getHistoryService().createTaskHistoryQuery().count()).isEqualTo(13);
assertThat(getHistoryService().createTaskHistoryQuery().count()).isEqualTo(14);
TaskHistoryEvent eventToBeCleaned =
createTaskHistoryEvent(
@ -208,14 +208,14 @@ class HistoryCleanupJobAccTest extends AbstractAccTest {
getHistoryService().create(eventToBeCleaned2);
getHistoryService().create(eventToBeCleaned3);
assertThat(getHistoryService().createTaskHistoryQuery().count()).isEqualTo(16);
assertThat(getHistoryService().createTaskHistoryQuery().count()).isEqualTo(17);
taskanaEngine.getConfiguration().setTaskCleanupJobAllCompletedSameParentBusiness(true);
HistoryCleanupJob job = new HistoryCleanupJob(taskanaEngine, null, null);
job.run();
assertThat(getHistoryService().createTaskHistoryQuery().count()).isEqualTo(16);
assertThat(getHistoryService().createTaskHistoryQuery().count()).isEqualTo(17);
}
@Test
@ -223,7 +223,7 @@ class HistoryCleanupJobAccTest extends AbstractAccTest {
void should_NotCleanHistoryEvents_When_MinimumAgeOfOtherEndtstateEventInParentBusinessNotReached()
throws Exception {
assertThat(getHistoryService().createTaskHistoryQuery().count()).isEqualTo(13);
assertThat(getHistoryService().createTaskHistoryQuery().count()).isEqualTo(14);
TaskHistoryEvent eventToBeCleaned =
createTaskHistoryEvent(
@ -274,21 +274,21 @@ class HistoryCleanupJobAccTest extends AbstractAccTest {
getHistoryService().create(eventToBeCleaned3);
getHistoryService().create(eventToBeCleaned4);
assertThat(getHistoryService().createTaskHistoryQuery().count()).isEqualTo(17);
assertThat(getHistoryService().createTaskHistoryQuery().count()).isEqualTo(18);
taskanaEngine.getConfiguration().setTaskCleanupJobAllCompletedSameParentBusiness(true);
HistoryCleanupJob job = new HistoryCleanupJob(taskanaEngine, null, null);
job.run();
assertThat(getHistoryService().createTaskHistoryQuery().count()).isEqualTo(17);
assertThat(getHistoryService().createTaskHistoryQuery().count()).isEqualTo(18);
}
@Test
@WithAccessId(user = "admin")
void should_CleanHistoryEventsUntilDate_When_SameParentBusinessFalse() throws Exception {
assertThat(getHistoryService().createTaskHistoryQuery().count()).isEqualTo(13);
assertThat(getHistoryService().createTaskHistoryQuery().count()).isEqualTo(14);
TaskHistoryEvent eventToBeCleaned =
createTaskHistoryEvent(
@ -363,14 +363,14 @@ class HistoryCleanupJobAccTest extends AbstractAccTest {
getHistoryService().create(eventToBeCleaned5);
getHistoryService().create(eventToBeCleaned6);
assertThat(getHistoryService().createTaskHistoryQuery().count()).isEqualTo(19);
assertThat(getHistoryService().createTaskHistoryQuery().count()).isEqualTo(20);
taskanaEngine.getConfiguration().setTaskCleanupJobAllCompletedSameParentBusiness(false);
HistoryCleanupJob job = new HistoryCleanupJob(taskanaEngine, null, null);
job.run();
assertThat(getHistoryService().createTaskHistoryQuery().count()).isEqualTo(15);
assertThat(getHistoryService().createTaskHistoryQuery().count()).isEqualTo(16);
}
@WithAccessId(user = "admin")

155
history/taskana-simplehistory-provider/src/test/java/acceptance/query/QueryTaskHistoryAccTest.java
View File

@ -10,16 +10,21 @@ import java.util.Collections;
import java.util.List;
import org.apache.ibatis.exceptions.TooManyResultsException;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.common.api.BaseQuery.SortDirection;
import pro.taskana.common.api.TimeInterval;
import pro.taskana.common.test.security.JaasExtension;
import pro.taskana.common.test.security.WithAccessId;
import pro.taskana.simplehistory.impl.task.TaskHistoryQuery;
import pro.taskana.simplehistory.impl.task.TaskHistoryQueryColumnName;
import pro.taskana.spi.history.api.events.task.TaskHistoryCustomField;
import pro.taskana.spi.history.api.events.task.TaskHistoryEvent;
import pro.taskana.spi.history.api.events.task.TaskHistoryEventType;
import pro.taskana.task.api.models.TaskSummary;
/** Test for Task History queries. */
@ExtendWith(JaasExtension.class)
class QueryTaskHistoryAccTest extends AbstractAccTest {
@Test
@ -54,10 +59,14 @@ class QueryTaskHistoryAccTest extends AbstractAccTest {
.orderByCreated(SortDirection.DESCENDING);
List<TaskHistoryEvent> results = query.list();
assertThat(results).extracting(TaskHistoryEvent::getUserId).containsOnly("admin", "peter");
assertThat(results)
.extracting(TaskHistoryEvent::getUserId)
.containsOnly("admin", "peter", "user-1-2");
results = query.orderByUserId(SortDirection.DESCENDING).list();
assertThat(results).extracting(TaskHistoryEvent::getUserId).containsOnly("admin", "peter");
assertThat(query.domainLike().count()).isEqualTo(13);
assertThat(results)
.extracting(TaskHistoryEvent::getUserId)
.containsOnly("admin", "peter", "user-1-2");
assertThat(query.domainLike().count()).isEqualTo(14);
}
@Test
@ -75,7 +84,7 @@ class QueryTaskHistoryAccTest extends AbstractAccTest {
@Test
void should_ReturnEmptyList_When_ProvidingWrongConstraints() {
List<TaskHistoryEvent> result = getHistoryService().createTaskHistoryQuery().list(1, 1000);
assertThat(result).hasSize(12);
assertThat(result).hasSize(13);
result = getHistoryService().createTaskHistoryQuery().list(100, 1000);
assertThat(result).isEmpty();
@ -115,7 +124,7 @@ class QueryTaskHistoryAccTest extends AbstractAccTest {
assertThat(count).isEqualTo(6);
count = getHistoryService().createTaskHistoryQuery().count();
assertThat(count).isEqualTo(13);
assertThat(count).isEqualTo(14);
count =
getHistoryService().createTaskHistoryQuery().userIdIn("klaus", "arnold", "benni").count();
@ -156,31 +165,31 @@ class QueryTaskHistoryAccTest extends AbstractAccTest {
returnValues =
getHistoryService().createTaskHistoryQuery().parentBusinessProcessIdIn("BPI:01").list();
assertThat(returnValues).hasSize(6);
assertThat(returnValues).hasSize(7);
returnValues =
getHistoryService()
.createTaskHistoryQuery()
.taskIdIn("TKI:000000000000000000000000000000000000")
.list();
assertThat(returnValues).hasSize(2);
assertThat(returnValues).hasSize(3);
returnValues =
getHistoryService()
.createTaskHistoryQuery()
.eventTypeIn(TaskHistoryEventType.CREATED.getName())
.list();
assertThat(returnValues).hasSize(12);
assertThat(returnValues).hasSize(13);
TimeInterval timeInterval = new TimeInterval(Instant.now().minusSeconds(10), Instant.now());
returnValues = getHistoryService().createTaskHistoryQuery().createdWithin(timeInterval).list();
assertThat(returnValues).isEmpty();
returnValues = getHistoryService().createTaskHistoryQuery().userIdIn("admin").list();
assertThat(returnValues).hasSize(7);
assertThat(returnValues).hasSize(6);
returnValues = getHistoryService().createTaskHistoryQuery().domainIn("DOMAIN_A").list();
assertThat(returnValues).hasSize(12);
assertThat(returnValues).hasSize(13);
returnValues =
getHistoryService()
@ -196,7 +205,7 @@ class QueryTaskHistoryAccTest extends AbstractAccTest {
assertThat(returnValues).hasSize(7);
returnValues = getHistoryService().createTaskHistoryQuery().porInstanceIn("22").list();
assertThat(returnValues).hasSize(6);
assertThat(returnValues).hasSize(7);
returnValues = getHistoryService().createTaskHistoryQuery().porTypeIn("VN").list();
assertThat(returnValues).isEmpty();
@ -206,25 +215,25 @@ class QueryTaskHistoryAccTest extends AbstractAccTest {
returnValues =
getHistoryService().createTaskHistoryQuery().taskClassificationKeyIn("L140101").list();
assertThat(returnValues).hasSize(7);
assertThat(returnValues).hasSize(8);
returnValues =
getHistoryService().createTaskHistoryQuery().taskClassificationCategoryIn("TASK").list();
assertThat(returnValues).hasSize(7);
assertThat(returnValues).hasSize(8);
returnValues =
getHistoryService()
.createTaskHistoryQuery()
.attachmentClassificationKeyIn("DOCTYPE_DEFAULT")
.list();
assertThat(returnValues).hasSize(6);
assertThat(returnValues).hasSize(7);
returnValues =
getHistoryService()
.createTaskHistoryQuery()
.customAttributeIn(TaskHistoryCustomField.CUSTOM_1, "custom1")
.list();
assertThat(returnValues).hasSize(13);
assertThat(returnValues).hasSize(14);
returnValues =
getHistoryService()
@ -238,7 +247,7 @@ class QueryTaskHistoryAccTest extends AbstractAccTest {
.createTaskHistoryQuery()
.customAttributeIn(TaskHistoryCustomField.CUSTOM_3, "custom3")
.list();
assertThat(returnValues).hasSize(7);
assertThat(returnValues).hasSize(8);
returnValues =
getHistoryService()
@ -264,18 +273,18 @@ class QueryTaskHistoryAccTest extends AbstractAccTest {
void should_ReturnHistoryEvents_For_DifferentLikeAttributes() {
List<TaskHistoryEvent> returnValues =
getHistoryService().createTaskHistoryQuery().businessProcessIdLike("BPI:0%").list();
assertThat(returnValues).hasSize(13);
assertThat(returnValues).hasSize(14);
returnValues =
getHistoryService()
.createTaskHistoryQuery()
.parentBusinessProcessIdLike("BPI:01", " %")
.list();
assertThat(returnValues).hasSize(6);
assertThat(returnValues).hasSize(7);
returnValues =
getHistoryService().createTaskHistoryQuery().taskIdLike("TKI:000000000000000%").list();
assertThat(returnValues).hasSize(13);
assertThat(returnValues).hasSize(14);
returnValues = getHistoryService().createTaskHistoryQuery().oldValueLike("old%").list();
assertThat(returnValues).hasSize(1);
@ -290,7 +299,7 @@ class QueryTaskHistoryAccTest extends AbstractAccTest {
getHistoryService()
.createTaskHistoryQuery()
.listValues(TaskHistoryQueryColumnName.ID, null);
assertThat(returnedList).hasSize(13);
assertThat(returnedList).hasSize(14);
returnedList =
getHistoryService()
@ -326,7 +335,13 @@ class QueryTaskHistoryAccTest extends AbstractAccTest {
getHistoryService()
.createTaskHistoryQuery()
.listValues(TaskHistoryQueryColumnName.USER_ID, null);
assertThat(returnedList).hasSize(2);
assertThat(returnedList).hasSize(4);
returnedList =
getHistoryService()
.createTaskHistoryQuery()
.listValues(TaskHistoryQueryColumnName.USER_LONG_NAME, null);
assertThat(returnedList).hasSize(3);
returnedList =
getHistoryService()
@ -370,6 +385,12 @@ class QueryTaskHistoryAccTest extends AbstractAccTest {
.listValues(TaskHistoryQueryColumnName.POR_VALUE, null);
assertThat(returnedList).hasSize(2);
returnedList =
getHistoryService()
.createTaskHistoryQuery()
.listValues(TaskHistoryQueryColumnName.TASK_OWNER_LONG_NAME, null);
assertThat(returnedList).hasSize(2);
returnedList =
getHistoryService()
.createTaskHistoryQuery()
@ -424,4 +445,96 @@ class QueryTaskHistoryAccTest extends AbstractAccTest {
.listValues(TaskHistoryQueryColumnName.CUSTOM_4, null);
assertThat(returnedList).hasSize(2);
}
@WithAccessId(user = "user-1-1")
@Test
void should_SetUserLongNameOfTask_When_PropertyEnabled() throws Exception {
taskanaEngineConfiguration.setAddAdditionalUserInfo(true);
List<TaskHistoryEvent> taskHistoryEvents =
getHistoryService()
.createTaskHistoryQuery()
.idIn("THI:000000000000000000000000000000000013")
.list();
assertThat(taskHistoryEvents).hasSize(1);
String userLongName =
taskanaEngine.getUserService().getUser(taskHistoryEvents.get(0).getUserId()).getLongName();
assertThat(taskHistoryEvents.get(0))
.extracting(TaskHistoryEvent::getUserLongName)
.isEqualTo(userLongName);
}
@WithAccessId(user = "user-1-1")
@Test
void should_SetTaskOwnerLongNameOfTaskHistoryEvent_When_PropertyEnabled() throws Exception {
taskanaEngineConfiguration.setAddAdditionalUserInfo(true);
List<TaskHistoryEvent> taskHistoryEvents =
getHistoryService()
.createTaskHistoryQuery()
.idIn("THI:000000000000000000000000000000000013")
.list();
assertThat(taskHistoryEvents).hasSize(1);
TaskSummary task =
taskanaEngine
.getTaskService()
.createTaskQuery()
.idIn(taskHistoryEvents.get(0).getTaskId())
.single();
assertThat(task).isNotNull();
String taskOwnerLongName =
taskanaEngine.getUserService().getUser(task.getOwner()).getLongName();
assertThat(taskHistoryEvents.get(0))
.extracting(TaskHistoryEvent::getTaskOwnerLongName)
.isEqualTo(taskOwnerLongName);
}
@WithAccessId(user = "user-1-1")
@Test
void should_NotSetUserLongNameOfTaskHistoryEvent_When_PropertyDisabled() {
taskanaEngineConfiguration.setAddAdditionalUserInfo(false);
List<TaskHistoryEvent> taskHistoryEvents =
getHistoryService()
.createTaskHistoryQuery()
.idIn("THI:000000000000000000000000000000000013")
.list();
assertThat(taskHistoryEvents).hasSize(1);
assertThat(taskHistoryEvents.get(0))
.extracting(TaskHistoryEvent::getUserLongName)
.isNull();
}
@WithAccessId(user = "user-1-1")
@Test
void should_NotSetTaskOwnerLongNameOfTaskHistoryEvent_When_PropertyDisabled() {
taskanaEngineConfiguration.setAddAdditionalUserInfo(false);
List<TaskHistoryEvent> taskHistoryEvents =
getHistoryService()
.createTaskHistoryQuery()
.idIn("THI:000000000000000000000000000000000013")
.list();
assertThat(taskHistoryEvents).hasSize(1);
assertThat(taskHistoryEvents.get(0))
.extracting(TaskHistoryEvent::getTaskOwnerLongName)
.isNull();
}
@WithAccessId(user = "user-1-1")
@Test
void should_SetUserLongNameOfTaskHistoryEventToNull_When_NotExistingAsUserInDatabase() {
taskanaEngineConfiguration.setAddAdditionalUserInfo(true);
List<TaskHistoryEvent> taskHistoryEvents =
getHistoryService()
.createTaskHistoryQuery()
.idIn("THI:000000000000000000000000000000000001")
.list();
assertThat(taskHistoryEvents).hasSize(1);
assertThat(taskHistoryEvents.get(0))
.extracting(TaskHistoryEvent::getUserLongName)
.isNull();
}
}

7
history/taskana-simplehistory-provider/src/test/java/pro/taskana/simplehistory/impl/SimpleHistoryServiceImplTest.java
View File

@ -65,8 +65,8 @@ class SimpleHistoryServiceImplTest {
doReturn(taskanaEngine).when(taskanaEngineConfiguration).buildTaskanaEngine();
cutSpy.initialize(taskanaEngineConfiguration.buildTaskanaEngine());
verify(sqlSessionManagerMock, times(3)).getMapper(any());
verify(taskanaHistoryEngineMock, times(3)).getSqlSession();
verify(sqlSessionManagerMock, times(4)).getMapper(any());
verify(taskanaHistoryEngineMock, times(4)).getSqlSession();
}
@Test
@ -102,6 +102,9 @@ class SimpleHistoryServiceImplTest {
AbstractAccTest.createTaskHistoryEvent(
"wbKey1", "taskId1", "type1", "wbKey2", "someUserId", "someDetails"));
when(taskanaHistoryEngineMock.getConfiguration()).thenReturn(taskanaEngineConfiguration);
when(taskanaEngineConfiguration.getAddAdditionalUserInfo()).thenReturn(false);
when(taskanaHistoryEngineMock.getSqlSession()).thenReturn(sqlSessionMock);
when(sqlSessionMock.selectList(any(), any())).thenReturn(new ArrayList<>(returnList));

79
history/taskana-simplehistory-provider/src/test/java/pro/taskana/simplehistory/impl/TaskHistoryQueryImplTest.java
View File

@ -1,79 +0,0 @@
package pro.taskana.simplehistory.impl;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.validateMockitoUsage;
import static org.mockito.Mockito.when;
import java.time.Instant;
import java.util.ArrayList;
import java.util.List;
import org.apache.ibatis.session.SqlSession;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import pro.taskana.common.api.TimeInterval;
import pro.taskana.common.internal.util.IdGenerator;
import pro.taskana.spi.history.api.events.task.TaskHistoryEvent;
/** Unit Test for TaskHistoryQueryImplTest. */
@ExtendWith(MockitoExtension.class)
class TaskHistoryQueryImplTest {
private TaskHistoryQueryImpl historyQueryImpl;
@Mock private TaskanaHistoryEngineImpl taskanaHistoryEngineMock;
@Mock private SqlSession sqlSessionMock;
@BeforeEach
void setup() {
historyQueryImpl = new TaskHistoryQueryImpl(taskanaHistoryEngineMock);
}
@Test
void should_ReturnList_When_CallingListMethodOnTaskHistoryQuery() throws Exception {
List<TaskHistoryEvent> returnList = new ArrayList<>();
returnList.add(createHistoryEvent("abcd", "T22", "car", "BV", "this was important", null));
TimeInterval interval = new TimeInterval(Instant.now().minusNanos(1000), Instant.now());
doNothing().when(taskanaHistoryEngineMock).openConnection();
doNothing().when(taskanaHistoryEngineMock).returnConnection();
when(taskanaHistoryEngineMock.getSqlSession()).thenReturn(sqlSessionMock);
when(sqlSessionMock.selectList(any(), any())).thenReturn(new ArrayList<>(returnList));
List<TaskHistoryEvent> result =
historyQueryImpl
.taskIdIn("TKI:01")
.workbasketKeyIn(
"T22", "some_long_long, long loooooooooooooooooooooooooooooooooooong String.")
.userIdIn("BV")
.createdWithin(interval)
.list();
validateMockitoUsage();
assertThat(result).isEqualTo(returnList);
}
private TaskHistoryEvent createHistoryEvent(
String taskId,
String workbasketKey,
String type,
String userId,
String details,
Instant created) {
TaskHistoryEvent he = new TaskHistoryEvent();
he.setId(IdGenerator.generateWithPrefix(IdGenerator.ID_PREFIX_TASK_HISTORY_EVENT));
he.setUserId(userId);
he.setDetails(details);
he.setTaskId(taskId);
he.setWorkbasketKey(workbasketKey);
he.setEventType(type);
he.setCreated(created);
return he;
}
}

2
history/taskana-simplehistory-rest-spring/src/main/java/pro/taskana/simplehistory/rest/assembler/TaskHistoryEventRepresentationModelAssembler.java
View File

@ -34,6 +34,7 @@ public class TaskHistoryEventRepresentationModelAssembler
repModel.setEventType(historyEvent.getEventType());
repModel.setCreated(historyEvent.getCreated());
repModel.setUserId(historyEvent.getUserId());
repModel.setUserLongName(historyEvent.getUserLongName());
repModel.setDomain(historyEvent.getDomain());
repModel.setWorkbasketKey(historyEvent.getWorkbasketKey());
repModel.setPorCompany(historyEvent.getPorCompany());
@ -41,6 +42,7 @@ public class TaskHistoryEventRepresentationModelAssembler
repModel.setPorInstance(historyEvent.getPorInstance());
repModel.setPorSystem(historyEvent.getPorSystem());
repModel.setPorValue(historyEvent.getPorValue());
repModel.setTaskOwnerLongName(historyEvent.getTaskOwnerLongName());
repModel.setTaskClassificationKey(historyEvent.getTaskClassificationKey());
repModel.setTaskClassificationCategory(historyEvent.getTaskClassificationCategory());
repModel.setAttachmentClassificationKey(historyEvent.getAttachmentClassificationKey());

26
history/taskana-simplehistory-rest-spring/src/main/java/pro/taskana/simplehistory/rest/models/TaskHistoryEventRepresentationModel.java
View File

@ -27,6 +27,8 @@ public class TaskHistoryEventRepresentationModel
private Instant created;
/** The Id of the user. */
private String userId;
/** The long name of the user. */
private String userLongName;
/** Domain. */
private String domain;
/** The key of the Workbasket. */
@ -41,6 +43,8 @@ public class TaskHistoryEventRepresentationModel
private String porInstance;
/** The value of the primary object reference. */
private String porValue;
/** The long name of the task owner. */
private String taskOwnerLongName;
/** The key of the task's classification. */
private String taskClassificationKey;
/** The category of the task's classification. */
@ -118,6 +122,14 @@ public class TaskHistoryEventRepresentationModel
this.userId = userId;
}
public String getUserLongName() {
return userLongName;
}
public void setUserLongName(String userLongName) {
this.userLongName = userLongName;
}
public String getDomain() {
return domain;
}
@ -182,6 +194,14 @@ public class TaskHistoryEventRepresentationModel
this.taskClassificationKey = taskClassificationKey;
}
public String getTaskOwnerLongName() {
return taskOwnerLongName;
}
public void setTaskOwnerLongName(String taskOwnerLongName) {
this.taskOwnerLongName = taskOwnerLongName;
}
public String getTaskClassificationCategory() {
return taskClassificationCategory;
}
@ -256,7 +276,7 @@ public class TaskHistoryEventRepresentationModel
@Override
public String toString() {
return "TaskHistoryEventRepresentationModel [taskHistoryEventId="
return "TaskHistoryEventRepresentationModel [taskHistoryId="
+ taskHistoryId
+ ", businessProcessId="
+ businessProcessId
@ -270,6 +290,8 @@ public class TaskHistoryEventRepresentationModel
+ created
+ ", userId="
+ userId
+ ", userLongName="
+ userLongName
+ ", domain="
+ domain
+ ", workbasketKey="
@ -284,6 +306,8 @@ public class TaskHistoryEventRepresentationModel
+ porInstance
+ ", porValue="
+ porValue
+ ", taskOwnerLongName="
+ taskOwnerLongName
+ ", taskClassificationKey="
+ taskClassificationKey
+ ", taskClassificationCategory="

6
history/taskana-simplehistory-rest-spring/src/test/java/pro/taskana/simplehistory/rest/assembler/TaskHistoryEventRepresentationModelAssemblerTest.java
View File

@ -35,6 +35,7 @@ class TaskHistoryEventRepresentationModelAssemblerTest {
historyEvent.setDomain("DOMAIN_A");
historyEvent.setWorkbasketKey("WorkbasketKey");
historyEvent.setAttachmentClassificationKey("L1050");
historyEvent.setUserLongName("userLongName");
historyEvent.setCreated(Instant.now());
historyEvent.setOldValue("oldValue");
historyEvent.setNewValue("newValue");
@ -42,6 +43,7 @@ class TaskHistoryEventRepresentationModelAssemblerTest {
historyEvent.setPorSystem("porSystem");
historyEvent.setPorType("porType");
historyEvent.setPorValue("porValue");
historyEvent.setTaskOwnerLongName("taskOwner");
historyEvent.setCustomAttribute(TaskHistoryCustomField.CUSTOM_1, "custom1");
historyEvent.setCustomAttribute(TaskHistoryCustomField.CUSTOM_2, "custom2");
historyEvent.setCustomAttribute(TaskHistoryCustomField.CUSTOM_3, "custom3");
@ -85,6 +87,10 @@ class TaskHistoryEventRepresentationModelAssemblerTest {
.isEqualTo(taskHistoryEventRepresentationModel.getPorType());
assertThat(historyEvent.getPorValue())
.isEqualTo(taskHistoryEventRepresentationModel.getPorValue());
assertThat(historyEvent.getUserLongName())
.isEqualTo(taskHistoryEventRepresentationModel.getUserLongName());
assertThat(historyEvent.getTaskOwnerLongName())
.isEqualTo(taskHistoryEventRepresentationModel.getTaskOwnerLongName());
assertThat(historyEvent.getCustomAttribute(TaskHistoryCustomField.CUSTOM_1))
.isEqualTo(taskHistoryEventRepresentationModel.getCustom1());
assertThat(historyEvent.getCustomAttribute(TaskHistoryCustomField.CUSTOM_2))

14
lib/taskana-core/src/main/java/pro/taskana/TaskanaEngineConfiguration.java
View File

@ -77,6 +77,7 @@ public class TaskanaEngineConfiguration {
"taskana.history.deletion.on.task.deletion.enabled";
private static final String TASKANA_VALIDATION_ALLOW_TIMESTAMP_SERVICE_LEVEL_MISMATCH =
"taskana.validation.allowTimestampServiceLevelMismatch";
private static final String TASKANA_ADD_ADDITIONAL_USER_INFO = "taskana.addAdditionalUserInfo";
// TASKANA_SCHEMA_VERSION
private static final String DEFAULT_SCHEMA_NAME = "TASKANA";
@ -109,8 +110,11 @@ public class TaskanaEngineConfiguration {
private Instant cleanupJobFirstRun = Instant.parse("2018-01-01T00:00:00Z");
private Duration cleanupJobRunEvery = Duration.parse("P1D");
private Duration cleanupJobMinimumAge = Duration.parse("P14D");
// TASKANA behavior
private boolean taskCleanupJobAllCompletedSameParentBusiness = true;
private boolean validationAllowTimestampServiceLevelMismatch = false;
//Property to enable/disable the addition of user full/long name through joins
private boolean addAdditionalUserInfo = false;
private int priorityJobBatchSize = 100;
private Instant priorityJobFirstRun = Instant.parse("2018-01-01T00:00:00Z");
@ -182,6 +186,8 @@ public class TaskanaEngineConfiguration {
props,
TASKANA_VALIDATION_ALLOW_TIMESTAMP_SERVICE_LEVEL_MISMATCH,
this::setValidationAllowTimestampServiceLevelMismatch);
initBooleanProperty(
props, TASKANA_ADD_ADDITIONAL_USER_INFO, this::setAddAdditionalUserInfo);
initCustomHolidays(props, separator);
}
@ -317,6 +323,14 @@ public class TaskanaEngineConfiguration {
this.domains = domains;
}
public boolean getAddAdditionalUserInfo() {
return addAdditionalUserInfo;
}
public void setAddAdditionalUserInfo(boolean addAdditionalUserInfo) {
this.addAdditionalUserInfo = addAdditionalUserInfo;
}
public List<String> getClassificationTypes() {
return classificationTypes;
}

5
lib/taskana-core/src/main/java/pro/taskana/common/internal/TaskanaEngineImpl.java
View File

@ -58,6 +58,7 @@ import pro.taskana.task.api.TaskService;
import pro.taskana.task.internal.AttachmentMapper;
import pro.taskana.task.internal.ObjectReferenceMapper;
import pro.taskana.task.internal.TaskCommentMapper;
import pro.taskana.task.internal.TaskCommentQueryMapper;
import pro.taskana.task.internal.TaskMapper;
import pro.taskana.task.internal.TaskQueryMapper;
import pro.taskana.task.internal.TaskServiceImpl;
@ -139,7 +140,8 @@ public class TaskanaEngineImpl implements TaskanaEngine {
internalTaskanaEngineImpl,
sessionManager.getMapper(TaskMapper.class),
sessionManager.getMapper(TaskCommentMapper.class),
sessionManager.getMapper(AttachmentMapper.class));
sessionManager.getMapper(AttachmentMapper.class),
sessionManager.getMapper(UserMapper.class));
}
@Override
@ -345,6 +347,7 @@ public class TaskanaEngineImpl implements TaskanaEngine {
configuration.addMapper(WorkbasketQueryMapper.class);
configuration.addMapper(TaskQueryMapper.class);
configuration.addMapper(TaskCommentMapper.class);
configuration.addMapper(TaskCommentQueryMapper.class);
configuration.addMapper(ClassificationQueryMapper.class);
configuration.addMapper(AttachmentMapper.class);
configuration.addMapper(JobMapper.class);

24
lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/task/TaskHistoryEvent.java
View File

@ -17,6 +17,7 @@ public class TaskHistoryEvent {
protected String eventType;
protected Instant created;
protected String userId;
protected String userLongName;
protected String domain;
protected String workbasketKey;
protected String porCompany;
@ -24,6 +25,7 @@ public class TaskHistoryEvent {
protected String porInstance;
protected String porType;
protected String porValue;
protected String taskOwnerLongName;
protected String taskClassificationKey;
protected String taskClassificationCategory;
protected String attachmentClassificationKey;
@ -177,6 +179,14 @@ public class TaskHistoryEvent {
this.porValue = porValue;
}
public String getTaskOwnerLongName() {
return taskOwnerLongName;
}
public void setTaskOwnerLongName(String taskOwnerLongName) {
this.taskOwnerLongName = taskOwnerLongName;
}
public String getTaskClassificationKey() {
return taskClassificationKey;
}
@ -233,6 +243,14 @@ public class TaskHistoryEvent {
this.userId = userId;
}
public String getUserLongName() {
return userLongName;
}
public void setUserLongName(String userLongName) {
this.userLongName = userLongName;
}
public String getOldValue() {
return oldValue;
}
@ -323,7 +341,7 @@ public class TaskHistoryEvent {
@Override
public String toString() {
return "TaskEvent [id="
return "TaskHistoryEvent [id="
+ id
+ ", businessProcessId="
+ businessProcessId
@ -337,6 +355,10 @@ public class TaskHistoryEvent {
+ created
+ ", userId="
+ userId
+ ", userLongName="
+ userLongName
+ ", taskOwnerLongName="
+ taskOwnerLongName
+ ", domain="
+ domain
+ ", workbasketKey="

203
lib/taskana-core/src/main/java/pro/taskana/task/api/TaskCommentQuery.java Normal file
View File

@ -0,0 +1,203 @@
package pro.taskana.task.api;
import pro.taskana.common.api.BaseQuery;
import pro.taskana.common.api.TimeInterval;
import pro.taskana.task.api.models.Task;
import pro.taskana.task.api.models.TaskComment;
/** TaskCommentQuery for generating dynamic sql. */
public interface TaskCommentQuery extends BaseQuery<TaskComment, TaskCommentQueryColumnName> {
/**
* Filter for {@linkplain TaskComment}s which are containing one of the given taskCommentIds.
*
* @param taskCommentIds The ids of the searched-for {@linkplain TaskComment}s.
* @return the query
*/
TaskCommentQuery idIn(String... taskCommentIds);
/**
* Filter for {@linkplain TaskComment}s which are containing non of the given taskCommentIds.
*
* @param taskCommentIds The ids of the searched-for {@linkplain TaskComment}s.
* @return the query
*/
TaskCommentQuery idNotIn(String... taskCommentIds);
/**
* Add your taskCommentIds for pattern matching to your query. It will be compared in SQL with a
* LIKE. If you use a wildcard like % then it will be transmitted to the database.
*
* @param taskCommentIds The ids of the searched-for {@linkplain TaskComment}s.
* @return the query
*/
TaskCommentQuery idLike(String... taskCommentIds);
/**
* Add your taskCommentIds for pattern matching to your query, which should not be contained. It
* will be compared in SQL with a LIKE. If you use a wildcard like % then it will be transmitted
* to the database.
*
* @param taskCommentIds The ids of the searched-for {@linkplain TaskComment}s.
* @return the query
*/
TaskCommentQuery idNotLike(String... taskCommentIds);
/**
* Add your {@linkplain Task} ids to your query.
*
* @param taskIds the {@linkplain Task} ids as Strings
* @return the query
*/
TaskCommentQuery taskIdIn(String... taskIds);
/**
* Add your {@linkplain Task} ids to your query, which should not be contained.
*
* @param taskIds the {@linkplain Task} ids as Strings
* @return the query
*/
TaskCommentQuery taskIdNotIn(String... taskIds);
/**
* Add your {@linkplain Task} ids for pattern matching to your query. It 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 taskIds your {@linkplain Task} ids
* @return the query
*/
TaskCommentQuery taskIdLike(String... taskIds);
/**
* Add your {@linkplain Task} ids for pattern matching to your query, which should not be
* contained. It 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 taskIds your {@linkplain Task} ids
* @return the query
*/
TaskCommentQuery taskIdNotLike(String... taskIds);
/**
* Add your texts for pattern matching to your query. It 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 texts your texts of the {@linkplain TaskComment}
* @return the query
*/
TaskCommentQuery textFieldLike(String... texts);
/**
* Add your texts for pattern matching to your query, which should not be contained. It 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 texts your texts of the {@linkplain TaskComment}
* @return the query
*/
TaskCommentQuery textFieldNotLike(String... texts);
/**
* Add the UserIds of the creator to your query.
*
* @param creators of the queried {@linkplain TaskComment}s
* @return the query
*/
TaskCommentQuery creatorIn(String... creators);
/**
* Add the UserIds of the creator to your query, which should not be contained.
*
* @param creators of the queried {@linkplain TaskComment}s
* @return the query
*/
TaskCommentQuery creatorNotIn(String... creators);
/**
* Add the UserIds of the creator for pattern matching to your query. It 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 creators of the queried {@linkplain TaskComment}s
* @return the query
*/
TaskCommentQuery creatorLike(String... creators);
/**
* Add the UserIds of the creator for pattern matching to your query, which should not be
* contained. It 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 creators of the queried {@linkplain TaskComment}s
* @return the query
*/
TaskCommentQuery creatorNotLike(String... creators);
/**
* Add the time intervals within which the {@linkplain TaskComment} was created to your query. For
* each time interval, the database query will search for tasks whose created timestamp is after
* or at the interval's begin and before or at the interval's end. If more than one interval is
* specified, the query will connect them with the OR keyword. If either begin or end of an
* interval are null, these values will not be specified in the query.
*
* @param intervals - the TimeIntervals within which the {@linkplain TaskComment} was created
* @return the query
*/
TaskCommentQuery createdWithin(TimeInterval... intervals);
/**
* Add the time intervals within which the {@linkplain TaskComment} was not created to your query.
* For each time interval, the database query will search for tasks whose created timestamp is
* after or at the interval's begin and before or at the interval's end. If more than one interval
* is specified, the query will connect them with the OR keyword. If either begin or end of an
* interval are null, these values will not be specified in the query.
*
* @param intervals - the TimeIntervals within which the {@linkplain TaskComment} was created
* @return the query
*/
TaskCommentQuery createdNotWithin(TimeInterval... intervals);
/**
* Add the time intervals within which the {@linkplain TaskComment} was modified to your query.
* For each time interval, the database query will search for tasks whose modified timestamp is
* after or at the interval's begin and before or at the interval's end. If more than one interval
* is specified, the query will connect them with the OR keyword. If either begin or end of an
* interval are null, these values will not be specified in the query.
*
* @param intervals - the TimeIntervals within which the {@linkplain TaskComment} was modified
* @return the query
*/
TaskCommentQuery modifiedWithin(TimeInterval... intervals);
/**
* Add the time intervals within which the {@linkplain TaskComment} was not modified to your
* query. For each time interval, the database query will search for tasks whose modified
* timestamp is after or at the interval's begin and before or at the interval's end. If more than
* one interval is specified, the query will connect them with the OR keyword. If either begin or
* end of an interval are null, these values will not be specified in the query.
*
* @param intervals - the TimeIntervals within which the {@linkplain TaskComment} was modified
* @return the query
*/
TaskCommentQuery modifiedNotWithin(TimeInterval... intervals);
/**
* This method sorts the query result according to the created timestamp.
*
* @param sortDirection Determines whether the result is sorted in ascending or descending order.
* If sortDirection is null, the result is sorted in ascending order
* @return the query
*/
TaskCommentQuery orderByCreated(SortDirection sortDirection);
/**
* This method sorts the query result according to the modified timestamp.
*
* @param sortDirection Determines whether the result is sorted in ascending or descending order.
* If sortDirection is null, the result is sorted in ascending order
* @return the query
*/
TaskCommentQuery orderByModified(SortDirection sortDirection);
}

27
lib/taskana-core/src/main/java/pro/taskana/task/api/TaskCommentQueryColumnName.java Normal file
View File

@ -0,0 +1,27 @@
package pro.taskana.task.api;
import pro.taskana.common.api.QueryColumnName;
public enum TaskCommentQueryColumnName implements QueryColumnName {
ID("tc.id"),
TASK_ID("tc.task_id"),
TEXT_FIELD("tc.text_field"),
CREATOR("tc.creator"),
CREATOR_LONG_NAME("u.long_name"),
CREATED("tc.created"),
MODIFIED("tc.modified");
private final String name;
TaskCommentQueryColumnName(String name) {
this.name = name;
}
@Override
public String toString() {
return name;
}
}

49
lib/taskana-core/src/main/java/pro/taskana/task/api/TaskQuery.java
View File

@ -719,6 +719,45 @@ public interface TaskQuery extends BaseQuery<TaskSummary, TaskQueryColumnName> {
// endregion
// region businessProcessId
/**
* Adds the long names of the owners to your query.
*
* @param longNames the long names as String
* @return the query
*/
TaskQuery ownerLongNameIn(String... longNames);
/**
* Adds the long names of the owners to your query, which should not be contained.
*
* @param longNames the long names as String
* @return the query
*/
TaskQuery ownerLongNameNotIn(String... longNames);
/**
* Adds the long names of the owner for pattern matching to your query. It will be compared in SQL
* with the LIKE operator. You may use a wildcard like % to specify the pattern.
*
* <p>If you specify multiple arguments they are combined with the OR keyword.
*
* @param longNames the owners of the searched tasks
* @return the query
*/
TaskQuery ownerLongNameLike(String... longNames);
/**
* Adds the long names of the owner for pattern matching to your query, which should not be
* contained. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to
* specify the pattern.
*
* <p>If you specify multiple arguments they are combined with the OR keyword.
*
* @param longNames the owners of the searched tasks
* @return the query
*/
TaskQuery ownerLongNameNotLike(String... longNames);
/**
* Add the business process ids for exact matching to your query.
*
@ -1298,6 +1337,16 @@ public interface TaskQuery extends BaseQuery<TaskSummary, TaskQueryColumnName> {
*/
TaskQuery attachmentChannelNotIn(String... attachmentChannel);
/**
* This method sorts the query result according to the owner's long name. (Should only be used if
* each Task has an owner. Otherwise, the result is wrong.)
*
* @param sortDirection Determines whether the result is sorted in ascending or descending order.
* If sortDirection is null, the result is sorted in ascending order
* @return the query
*/
TaskQuery orderByOwnerLongName(SortDirection sortDirection);
/**
* Add the values of attachment channel for pattern matching to your query. They will be compared
* in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you

1
lib/taskana-core/src/main/java/pro/taskana/task/api/TaskQueryColumnName.java
View File

@ -29,6 +29,7 @@ public enum TaskQueryColumnName implements QueryColumnName {
BUSINESS_PROCESS_ID("t.business_process_id"),
PARENT_BUSINESS_PROCESS_ID("t.parent_business_process_id"),
OWNER("t.owner"),
OWNER_LONG_NAME("u.long_name"),
POR_COMPANY("t.por_company"),
POR_SYSTEM("t.por_system"),
POR_INSTANCE("t.por_instance"),

7
lib/taskana-core/src/main/java/pro/taskana/task/api/TaskService.java
View File

@ -262,6 +262,13 @@ public interface TaskService {
*/
TaskQuery createTaskQuery();
/**
* This method provides a query builder for querying the database.
*
* @return a {@link TaskCommentQuery}
*/
TaskCommentQuery createTaskCommentQuery();
/**
* Returns a not inserted instance of {@link Task}. The returned task has no workbasket Id set.
* When createTask() is invoked for this task, TaskService will call the TaskRouting SPI to

7
lib/taskana-core/src/main/java/pro/taskana/task/api/models/TaskComment.java
View File

@ -26,6 +26,13 @@ public interface TaskComment {
*/
String getCreator();
/**
* Gets the long name of the task comment creator.
*
* @return the long Name of the creator
*/
String getCreatorLongName();
/**
* Gets the text field of the task comment.
*

7
lib/taskana-core/src/main/java/pro/taskana/task/api/models/TaskSummary.java
View File

@ -168,6 +168,13 @@ public interface TaskSummary {
*/
String getOwner();
/**
* Gets the owner's long name of the Task.
*
* @return the long name of the Task owner
*/
String getOwnerLongName();
/**
* Gets the primary ObjectReference of the task.
*

16
lib/taskana-core/src/main/java/pro/taskana/task/internal/TaskCommentMapper.java
View File

@ -1,6 +1,5 @@
package pro.taskana.task.internal;
import java.util.List;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Param;
@ -26,21 +25,6 @@ public interface TaskCommentMapper {
@Delete("DELETE FROM TASK_COMMENT WHERE ID = #{taskCommentId}")
void delete(String taskCommentId);
@Select(
"<script> SELECT ID, TASK_ID, TEXT_FIELD, CREATOR, CREATED, MODIFIED"
+ " FROM TASK_COMMENT "
+ "WHERE TASK_ID = #{taskId} "
+ " ORDER BY CREATED ASC "
+ "<if test=\"_databaseId == 'db2'\">with UR </if> "
+ "</script>")
@Result(property = "id", column = "ID")
@Result(property = "taskId", column = "TASK_ID")
@Result(property = "textField", column = "TEXT_FIELD")
@Result(property = "creator", column = "CREATOR")
@Result(property = "created", column = "CREATED")
@Result(property = "modified", column = "MODIFIED")
List<TaskCommentImpl> findByTaskId(@Param("taskId") String taskId);
@Select(
"<script> SELECT ID, TASK_ID, TEXT_FIELD, CREATOR, CREATED, MODIFIED"
+ " FROM TASK_COMMENT "

397
lib/taskana-core/src/main/java/pro/taskana/task/internal/TaskCommentQueryImpl.java Normal file
View File

@ -0,0 +1,397 @@
package pro.taskana.task.internal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.apache.ibatis.session.RowBounds;
import pro.taskana.common.api.TaskanaRole;
import pro.taskana.common.api.TimeInterval;
import pro.taskana.common.internal.InternalTaskanaEngine;
import pro.taskana.task.api.TaskCommentQuery;
import pro.taskana.task.api.TaskCommentQueryColumnName;
import pro.taskana.task.api.models.TaskComment;
import pro.taskana.workbasket.internal.WorkbasketQueryImpl;
/** TaskCommentQuery for generating dynamic sql. */
public class TaskCommentQueryImpl implements TaskCommentQuery {
private static final String LINK_TO_MAPPER =
"pro.taskana.task.internal.TaskCommentQueryMapper.queryTaskComments";
private static final String LINK_TO_VALUE_MAPPER =
"pro.taskana.task.internal.TaskCommentQueryMapper.queryTaskCommentColumnValues";
private static final String LINK_TO_COUNTER =
"pro.taskana.task.internal.TaskCommentQueryMapper.countQueryTaskComments";
private final InternalTaskanaEngine taskanaEngine;
private final TaskServiceImpl taskService;
private final List<String> orderBy;
private final List<String> orderColumns;
private TaskCommentQueryColumnName queryColumnName;
private String[] idIn;
private String[] idNotIn;
private String[] idLike;
private String[] idNotLike;
private String[] taskIdIn;
private String[] taskIdNotIn;
private String[] taskIdLike;
private String[] taskIdNotLike;
private String[] creatorIn;
private String[] creatorNotIn;
private String[] creatorLike;
private String[] creatorNotLike;
private String[] textFieldLike;
private String[] textFieldNotLike;
private TimeInterval[] modifiedIn;
private TimeInterval[] modifiedNotIn;
private TimeInterval[] createdIn;
private TimeInterval[] createdNotIn;
private String[] accessIdIn;
private boolean joinWithUserInfo;
TaskCommentQueryImpl(InternalTaskanaEngine taskanaEngine) {
this.taskanaEngine = taskanaEngine;
this.taskService = (TaskServiceImpl) taskanaEngine.getEngine().getTaskService();
this.orderBy = new ArrayList<>();
this.orderColumns = new ArrayList<>();
this.joinWithUserInfo = taskanaEngine.getEngine().getConfiguration().getAddAdditionalUserInfo();
}
@Override
public TaskCommentQuery idIn(String... taskCommentIds) {
this.idIn = taskCommentIds;
return this;
}
@Override
public TaskCommentQuery idNotIn(String... taskCommentIds) {
this.idNotIn = taskCommentIds;
return this;
}
@Override
public TaskCommentQuery idLike(String... taskCommentIds) {
this.idLike = toUpperCopy(taskCommentIds);
return this;
}
@Override
public TaskCommentQuery idNotLike(String... taskCommentIds) {
this.idNotLike = toUpperCopy(taskCommentIds);
return this;
}
@Override
public TaskCommentQuery taskIdIn(String... taskIds) {
this.taskIdIn = taskIds;
return this;
}
@Override
public TaskCommentQuery taskIdNotIn(String... taskIds) {
this.taskIdNotIn = taskIds;
return this;
}
@Override
public TaskCommentQuery taskIdLike(String... taskIds) {
this.taskIdLike = toUpperCopy(taskIds);
return this;
}
@Override
public TaskCommentQuery taskIdNotLike(String... taskIds) {
this.taskIdNotLike = toUpperCopy(taskIds);
return this;
}
@Override
public TaskCommentQuery textFieldLike(String... texts) {
this.textFieldLike = toUpperCopy(texts);
return this;
}
@Override
public TaskCommentQuery textFieldNotLike(String... texts) {
this.textFieldNotLike = toUpperCopy(texts);
return this;
}
@Override
public TaskCommentQuery creatorIn(String... creators) {
this.creatorIn = creators;
return this;
}
@Override
public TaskCommentQuery creatorNotIn(String... creators) {
this.creatorNotIn = creators;
return this;
}
@Override
public TaskCommentQuery creatorLike(String... creators) {
this.creatorLike = toUpperCopy(creators);
return this;
}
@Override
public TaskCommentQuery creatorNotLike(String... creators) {
this.creatorNotLike = toUpperCopy(creators);
return this;
}
@Override
public TaskCommentQuery createdWithin(TimeInterval... intervals) {
validateAllIntervals(intervals);
this.createdIn = intervals;
return this;
}
@Override
public TaskCommentQuery createdNotWithin(TimeInterval... intervals) {
this.createdNotIn = intervals;
return this;
}
@Override
public TaskCommentQuery modifiedWithin(TimeInterval... intervals) {
validateAllIntervals(intervals);
this.modifiedIn = intervals;
return this;
}
@Override
public TaskCommentQuery modifiedNotWithin(TimeInterval... intervals) {
this.modifiedNotIn = intervals;
return this;
}
@Override
public List<TaskComment> list() {
setupAccessIds();
return taskanaEngine.executeInDatabaseConnection(
() -> taskanaEngine.getSqlSession().selectList(LINK_TO_MAPPER, this));
}
@Override
public List<TaskComment> list(int offset, int limit) {
setupAccessIds();
RowBounds rowBounds = new RowBounds(offset, limit);
return taskanaEngine.executeInDatabaseConnection(
() -> taskanaEngine.getSqlSession().selectList(LINK_TO_MAPPER, this, rowBounds));
}
@Override
public List<String> listValues(
TaskCommentQueryColumnName columnName, SortDirection sortDirection) {
setupAccessIds();
queryColumnName = columnName;
// TO-DO: order?
if (columnName == TaskCommentQueryColumnName.CREATOR_LONG_NAME) {
joinWithUserInfo = true;
}
return taskanaEngine.executeInDatabaseConnection(
() -> taskanaEngine.getSqlSession().selectList(LINK_TO_VALUE_MAPPER, this));
}
@Override
public TaskComment single() {
setupAccessIds();
return taskanaEngine.executeInDatabaseConnection(
() -> taskanaEngine.getSqlSession().selectOne(LINK_TO_MAPPER, this));
}
@Override
public long count() {
setupAccessIds();
Long rowCount =
taskanaEngine.executeInDatabaseConnection(
() -> taskanaEngine.getSqlSession().selectOne(LINK_TO_COUNTER, this));
return (rowCount == null) ? 0L : rowCount;
}
public TaskCommentQueryColumnName getQueryColumnName() {
return queryColumnName;
}
public String[] getIdIn() {
return idIn;
}
public String[] getIdNotIn() {
return idNotIn;
}
public String[] getIdLike() {
return idLike;
}
public String[] getIdNotLike() {
return idNotLike;
}
public String[] getTaskIdIn() {
return taskIdIn;
}
public String[] getTaskIdNotIn() {
return taskIdNotIn;
}
public String[] getTaskIdLike() {
return taskIdLike;
}
public String[] getTaskIdNotLike() {
return taskIdNotLike;
}
public String[] getCreatorIn() {
return creatorIn;
}
public String[] getCreatorNotIn() {
return creatorNotIn;
}
public String[] getCreatorLike() {
return creatorLike;
}
public String[] getCreatorNotLike() {
return creatorNotLike;
}
public String[] getTextFieldLike() {
return textFieldLike;
}
public String[] getTextFieldNotLike() {
return textFieldNotLike;
}
public TimeInterval[] getModifiedIn() {
return modifiedIn;
}
public TimeInterval[] getModifiedNotIn() {
return modifiedNotIn;
}
public TimeInterval[] getCreatedIn() {
return createdIn;
}
public TimeInterval[] getCreatedNotIn() {
return createdNotIn;
}
public String[] getAccessIdIn() {
return accessIdIn;
}
public boolean isIncludeLongName() {
return joinWithUserInfo;
}
public void setIncludeLongName(boolean joinWithUserInfo) {
this.joinWithUserInfo = joinWithUserInfo;
}
@Override
public TaskCommentQuery orderByCreated(SortDirection sortDirection) {
return addOrderCriteria("CREATED", sortDirection);
}
@Override
public TaskCommentQuery orderByModified(SortDirection sortDirection) {
return addOrderCriteria("MODIFIED", sortDirection);
}
private TaskCommentQuery addOrderCriteria(String columnName, SortDirection sortDirection) {
String orderByDirection =
" " + (sortDirection == null ? SortDirection.ASCENDING : sortDirection);
orderBy.add(columnName + orderByDirection);
orderColumns.add(columnName);
return this;
}
private void setupAccessIds() {
if (taskanaEngine.getEngine().isUserInRole(TaskanaRole.ADMIN, TaskanaRole.TASK_ADMIN)) {
this.accessIdIn = null;
} else if (this.accessIdIn == null) {
String[] accessIds = new String[0];
List<String> ucAccessIds = taskanaEngine.getEngine().getCurrentUserContext().getAccessIds();
if (!ucAccessIds.isEmpty()) {
accessIds = new String[ucAccessIds.size()];
accessIds = ucAccessIds.toArray(accessIds);
}
this.accessIdIn = accessIds;
WorkbasketQueryImpl.lowercaseAccessIds(this.accessIdIn);
}
}
private void validateAllIntervals(TimeInterval[] intervals) {
for (TimeInterval ti : intervals) {
if (!ti.isValid()) {
throw new IllegalArgumentException("TimeInterval " + ti + " is invalid.");
}
}
}
@Override
public String toString() {
return "TaskCommentQueryImpl [taskanaEngine="
+ taskanaEngine
+ ", taskService="
+ taskService
+ ", queryColumnName="
+ queryColumnName
+ ", idIn="
+ Arrays.toString(idIn)
+ ", idNotIn="
+ Arrays.toString(idNotIn)
+ ", idLike="
+ Arrays.toString(idLike)
+ ", idNotLike="
+ Arrays.toString(idNotLike)
+ ", taskIdIn="
+ Arrays.toString(taskIdIn)
+ ", taskIdNotIn="
+ Arrays.toString(taskIdNotIn)
+ ", taskIdLike="
+ Arrays.toString(taskIdLike)
+ ", taskIdNotLike="
+ Arrays.toString(taskIdNotLike)
+ ", creatorIn="
+ Arrays.toString(creatorIn)
+ ", creatorNotIn="
+ Arrays.toString(creatorNotIn)
+ ", creatorLike="
+ Arrays.toString(creatorLike)
+ ", creatorNotLike="
+ Arrays.toString(creatorNotLike)
+ ", textFieldLike="
+ Arrays.toString(textFieldLike)
+ ", textFieldNotLike="
+ Arrays.toString(textFieldNotLike)
+ ", modifiedIn="
+ Arrays.toString(modifiedIn)
+ ", modifiedNotIn="
+ Arrays.toString(modifiedNotIn)
+ ", createdIn="
+ Arrays.toString(createdIn)
+ ", createdNotIn="
+ Arrays.toString(createdNotIn)
+ ", accessIdIn="
+ Arrays.toString(accessIdIn)
+ ", joinWithUserInfo="
+ joinWithUserInfo
+ "]";
}
}

29
lib/taskana-core/src/main/java/pro/taskana/task/internal/TaskCommentQueryMapper.java Normal file
View File

@ -0,0 +1,29 @@
package pro.taskana.task.internal;
import java.util.List;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.SelectProvider;
import org.apache.ibatis.session.RowBounds;
import pro.taskana.task.internal.models.TaskCommentImpl;
/** This class provides a mapper for all task comment queries. */
public interface TaskCommentQueryMapper {
@SelectProvider(type = TaskCommentQuerySqlProvider.class, method = "queryTaskComments")
@Result(property = "id", column = "ID")
@Result(property = "taskId", column = "TASK_ID")
@Result(property = "textField", column = "TEXT_FIELD")
@Result(property = "creator", column = "CREATOR")
@Result(property = "creatorLongName", column = "FULL_NAME")
@Result(property = "created", column = "CREATED")
@Result(property = "modified", column = "MODIFIED")
List<TaskCommentImpl> queryTaskComments(
TaskCommentQueryImpl taskCommentQuery, RowBounds rowBounds);
@SelectProvider(type = TaskCommentQuerySqlProvider.class, method = "countQueryTaskComments")
Long countQueryTaskComments(TaskCommentQueryImpl taskCommentQuery);
@SelectProvider(type = TaskCommentQuerySqlProvider.class, method = "queryTaskCommentColumnValues")
List<String> queryTaskCommentColumnValues(TaskCommentQueryImpl taskCommentQuery);
}

119
lib/taskana-core/src/main/java/pro/taskana/task/internal/TaskCommentQuerySqlProvider.java Normal file
View File

@ -0,0 +1,119 @@
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.DB2_WITH_UR;
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;
import static pro.taskana.common.internal.util.SqlProviderUtil.whereNotIn;
import static pro.taskana.common.internal.util.SqlProviderUtil.whereNotInTime;
import static pro.taskana.common.internal.util.SqlProviderUtil.whereNotLike;
import java.util.Arrays;
import java.util.stream.Collectors;
import pro.taskana.task.api.TaskCommentQueryColumnName;
public class TaskCommentQuerySqlProvider {
private TaskCommentQuerySqlProvider() {}
@SuppressWarnings("unused")
public static String queryTaskComments() {
return OPENING_SCRIPT_TAG
+ "SELECT "
+ commonSelectFields()
+ "<if test=\"joinWithUserInfo\">"
+ ", u.FULL_NAME"
+ "</if>"
+ "FROM TASK_COMMENT tc "
+ "LEFT JOIN Task AS t ON tc.TASK_ID = t.ID "
+ "<if test=\"joinWithUserInfo\">"
+ "LEFT JOIN USER_INFO AS u ON tc.CREATOR = u.USER_ID "
+ "</if>"
+ OPENING_WHERE_TAG
+ checkForAuthorization()
+ commonTaskCommentWhereStatement()
+ CLOSING_WHERE_TAG
+ "<if test='!orderBy.isEmpty()'>"
+ "ORDER BY <foreach item='item' collection='orderBy' separator=',' >${item}</foreach>"
+ "</if> "
+ CLOSING_SCRIPT_TAG;
}
@SuppressWarnings("unused")
public static String countQueryTaskComments() {
return OPENING_SCRIPT_TAG
+ "SELECT COUNT(tc.ID) "
+ "FROM TASK_COMMENT tc "
+ "LEFT JOIN Task AS t ON tc.TASK_ID = t.ID "
+ OPENING_WHERE_TAG
+ checkForAuthorization()
+ commonTaskCommentWhereStatement()
+ CLOSING_WHERE_TAG
+ CLOSING_SCRIPT_TAG;
}
@SuppressWarnings("unused")
public static String queryTaskCommentColumnValues() {
return OPENING_SCRIPT_TAG
+ "SELECT DISTINCT ${queryColumnName} "
+ "FROM TASK_COMMENT tc "
+ "LEFT JOIN Task AS t ON tc.TASK_ID = t.ID "
+ "<if test=\"joinWithUserInfo\">"
+ "LEFT JOIN USER_INFO AS u ON tc.CREATOR = u.USER_ID "
+ "</if>"
+ OPENING_WHERE_TAG
+ checkForAuthorization()
+ commonTaskCommentWhereStatement()
+ CLOSING_WHERE_TAG
+ DB2_WITH_UR
+ CLOSING_SCRIPT_TAG;
}
private static String commonSelectFields() {
// includes only the names that start with tc, because other columns are conditional
return Arrays.stream(TaskCommentQueryColumnName.values())
.map(TaskCommentQueryColumnName::toString)
.filter(column -> column.startsWith("tc"))
.collect(Collectors.joining(", "));
}
private static String commonTaskCommentWhereStatement() {
StringBuilder sb = new StringBuilder();
whereIn("idIn", "tc.ID", sb);
whereNotIn("idNotIn", "tc.ID", sb);
whereLike("idLike", "tc.ID", sb);
whereNotLike("idNotLike", "tc.ID", sb);
whereIn("taskIdIn", "tc.TASK_ID", sb);
whereNotIn("taskIdNotIn", "tc.TASK_ID", sb);
whereLike("taskIdLike", "tc.TASK_ID", sb);
whereNotLike("taskIdNotLike", "tc.TASK_ID", sb);
whereLike("textFieldLike", "tc.TEXT_FIELD", sb);
whereNotLike("textFieldNotLike", "tc.TEXT_FIELD", sb);
whereIn("creatorIn", "tc.CREATOR", sb);
whereNotIn("creatorNotIn", "tc.CREATOR", sb);
whereLike("creatorLike", "tc.CREATOR", sb);
whereNotLike("creatorNotLike", "tc.CREATOR", sb);
whereInTime("createdIn", "tc.CREATED", sb);
whereNotInTime("createdNotIn", "tc.CREATED", sb);
whereInTime("modifiedIn", "tc.MODIFIED", sb);
whereNotInTime("modifiedNotIn", "tc.MODIFIED", sb);
return sb.toString();
}
private static String checkForAuthorization() {
return "<if test='accessIdIn != null'> AND t.WORKBASKET_ID IN ("
+ "SELECT WID "
+ "FROM ("
+ "SELECT WORKBASKET_ID as WID, MAX(PERM_READ::int) as MAX_READ "
+ "FROM WORKBASKET_ACCESS_LIST AS s where ACCESS_ID IN "
+ "(<foreach item='item' collection='accessIdIn' separator=',' >#{item}</foreach>) "
+ "GROUP by WORKBASKET_ID) as f "
+ "WHERE MAX_READ = 1) "
+ "</if>";
}
}

15
lib/taskana-core/src/main/java/pro/taskana/task/internal/TaskCommentServiceImpl.java
View File

@ -1,7 +1,6 @@
package pro.taskana.task.internal;
import java.time.Instant;
import java.util.ArrayList;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -18,6 +17,8 @@ import pro.taskana.task.api.exceptions.TaskCommentNotFoundException;
import pro.taskana.task.api.exceptions.TaskNotFoundException;
import pro.taskana.task.api.models.TaskComment;
import pro.taskana.task.internal.models.TaskCommentImpl;
import pro.taskana.user.api.models.User;
import pro.taskana.user.internal.UserMapper;
class TaskCommentServiceImpl {
@ -26,14 +27,17 @@ class TaskCommentServiceImpl {
private final InternalTaskanaEngine taskanaEngine;
private final TaskServiceImpl taskService;
private final TaskCommentMapper taskCommentMapper;
private final UserMapper userMapper;
TaskCommentServiceImpl(
InternalTaskanaEngine taskanaEngine,
TaskCommentMapper taskCommentMapper,
UserMapper userMapper,
TaskServiceImpl taskService) {
this.taskanaEngine = taskanaEngine;
this.taskService = taskService;
this.taskCommentMapper = taskCommentMapper;
this.userMapper = userMapper;
}
TaskComment newTaskComment(String taskId) {
@ -149,7 +153,7 @@ class TaskCommentServiceImpl {
taskService.getTask(taskId);
List<TaskComment> taskComments = new ArrayList<>(taskCommentMapper.findByTaskId(taskId));
List<TaskComment> taskComments = taskService.createTaskCommentQuery().taskIdIn(taskId).list();
if (taskComments.isEmpty() && LOGGER.isDebugEnabled()) {
LOGGER.debug("getTaskComments() found no comments for the provided taskId");
@ -180,6 +184,13 @@ class TaskCommentServiceImpl {
throw new TaskCommentNotFoundException(taskCommentId);
}
if (taskanaEngine.getEngine().getConfiguration().getAddAdditionalUserInfo()) {
User creator = userMapper.findById(result.getCreator());
if (creator != null) {
result.setCreatorLongName(creator.getFullName());
}
}
taskService.getTask(result.getTaskId());
return result;

72
lib/taskana-core/src/main/java/pro/taskana/task/internal/TaskQueryImpl.java
View File

@ -177,6 +177,11 @@ public class TaskQueryImpl implements TaskQuery {
private String[] ownerLike;
private String[] ownerNotLike;
// endregion
// region ownerLongName
private String[] ownerLongNameIn;
private String[] ownerLongNameNotIn;
private String[] ownerLongNameLike;
private String[] ownerLongNameNotLike;
// region primaryObjectReference
private ObjectReference[] objectReferences;
// endregion
@ -322,12 +327,14 @@ public class TaskQueryImpl implements TaskQuery {
private WildcardSearchField[] wildcardSearchFieldIn;
private String wildcardSearchValueLike;
// endregion
private boolean joinWithUserInfo;
TaskQueryImpl(InternalTaskanaEngine taskanaEngine) {
this.taskanaEngine = taskanaEngine;
this.taskService = (TaskServiceImpl) taskanaEngine.getEngine().getTaskService();
this.orderBy = new ArrayList<>();
this.filterByAccessIdIn = true;
this.joinWithUserInfo = taskanaEngine.getEngine().getConfiguration().getAddAdditionalUserInfo();
}
// region id
@ -905,6 +912,34 @@ public class TaskQueryImpl implements TaskQuery {
}
// endregion
public TaskQuery ownerLongNameIn(String... longNames) {
joinWithUserInfo = true;
this.ownerLongNameIn = longNames;
return this;
}
@Override
public TaskQuery ownerLongNameNotIn(String... longNames) {
joinWithUserInfo = true;
this.ownerLongNameNotIn = longNames;
return this;
}
@Override
public TaskQuery ownerLongNameLike(String... longNames) {
joinWithUserInfo = true;
this.ownerLongNameLike = toUpperCopy(longNames);
return this;
}
@Override
public TaskQuery ownerLongNameNotLike(String... longNames) {
joinWithUserInfo = true;
this.ownerLongNameNotLike = toUpperCopy(longNames);
return this;
}
// region primaryObjectReference
@Override
@ -1302,6 +1337,22 @@ public class TaskQueryImpl implements TaskQuery {
}
// endregion
public String[] getOwnerLongNameIn() {
return ownerLongNameIn;
}
public String[] getOwnerLongNameNotIn() {
return ownerLongNameNotIn;
}
public String[] getOwnerLongNameLike() {
return ownerLongNameLike;
}
public String[] getOwnerLongNameNotLike() {
return ownerLongNameNotLike;
}
// region customAttributes
@Override
@ -1621,6 +1672,13 @@ public class TaskQueryImpl implements TaskQuery {
}
@Override
public TaskQuery orderByOwnerLongName(SortDirection sortDirection) {
joinWithUserInfo = true;
return DB.isDb2(getDatabaseId())
? addOrderCriteria("ULONG_NAME", sortDirection)
: addOrderCriteria("u.LONG_NAME", sortDirection);
}
public List<TaskSummary> list() {
return taskanaEngine.executeInDatabaseConnection(
() -> {
@ -1687,6 +1745,10 @@ public class TaskQueryImpl implements TaskQuery {
joinWithAttachments = true;
}
if (columnName == TaskQueryColumnName.OWNER_LONG_NAME) {
joinWithUserInfo = true;
}
setupJoinAndOrderParameters();
result = taskanaEngine.getSqlSession().selectList(LINK_TO_VALUE_MAPPER, this);
return result;
@ -2043,6 +2105,14 @@ public class TaskQueryImpl implements TaskQuery {
+ Arrays.toString(ownerLike)
+ ", ownerNotLike="
+ Arrays.toString(ownerNotLike)
+ ", ownerLongNameIn="
+ Arrays.toString(ownerLongNameIn)
+ ", ownerLongNameNotIn="
+ Arrays.toString(ownerLongNameNotIn)
+ ", ownerLongNameLike="
+ Arrays.toString(ownerLongNameLike)
+ ", ownerLongNameNotLike="
+ Arrays.toString(ownerLongNameNotLike)
+ ", objectReferences="
+ Arrays.toString(objectReferences)
+ ", porCompanyIn="
@ -2265,6 +2335,8 @@ public class TaskQueryImpl implements TaskQuery {
+ Arrays.toString(wildcardSearchFieldIn)
+ ", wildcardSearchValueLike="
+ wildcardSearchValueLike
+ ", joinWithUserInfo="
+ joinWithUserInfo
+ "]";
}
}

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

@ -35,6 +35,7 @@ public interface TaskQueryMapper {
@Result(property = "businessProcessId", column = "BUSINESS_PROCESS_ID")
@Result(property = "parentBusinessProcessId", column = "PARENT_BUSINESS_PROCESS_ID")
@Result(property = "owner", column = "OWNER")
@Result(property = "ownerLongName", column = "LONG_NAME")
@Result(property = "primaryObjRef.company", column = "POR_COMPANY")
@Result(property = "primaryObjRef.system", column = "POR_SYSTEM")
@Result(property = "primaryObjRef.systemInstance", column = "POR_INSTANCE")
@ -86,6 +87,7 @@ public interface TaskQueryMapper {
@Result(property = "businessProcessId", column = "BUSINESS_PROCESS_ID")
@Result(property = "parentBusinessProcessId", column = "PARENT_BUSINESS_PROCESS_ID")
@Result(property = "owner", column = "OWNER")
@Result(property = "ownerLongName", column = "ULONG_NAME")
@Result(property = "primaryObjRef.company", column = "POR_COMPANY")
@Result(property = "primaryObjRef.system", column = "POR_SYSTEM")
@Result(property = "primaryObjRef.systemInstance", column = "POR_INSTANCE")

27
lib/taskana-core/src/main/java/pro/taskana/task/internal/TaskQuerySqlProvider.java
View File

@ -32,6 +32,7 @@ public class TaskQuerySqlProvider {
+ "<if test=\"addClassificationNameToSelectClauseForOrdering\">, c.NAME </if>"
+ "<if test=\"addAttachmentClassificationNameToSelectClauseForOrdering\">, ac.NAME </if>"
+ "<if test=\"addWorkbasketNameToSelectClauseForOrdering\">, w.NAME </if>"
+ "<if test=\"joinWithUserInfo\">, u.LONG_NAME </if>"
+ "FROM TASK t "
+ "<if test=\"joinWithAttachments\">"
+ "LEFT JOIN ATTACHMENT AS a ON t.ID = a.TASK_ID "
@ -45,6 +46,9 @@ public class TaskQuerySqlProvider {
+ "<if test=\"joinWithWorkbaskets\">"
+ "LEFT JOIN WORKBASKET AS w ON t.WORKBASKET_ID = w.ID "
+ "</if>"
+ "<if test=\"joinWithUserInfo\">"
+ "LEFT JOIN USER_INFO AS u ON t.owner = u.USER_ID "
+ "</if>"
+ OPENING_WHERE_TAG
+ checkForAuthorization()
+ commonTaskWhereStatement()
@ -74,6 +78,7 @@ public class TaskQuerySqlProvider {
+ "<if test=\"addClassificationNameToSelectClauseForOrdering\">, c.NAME </if>"
+ "<if test=\"addAttachmentClassificationNameToSelectClauseForOrdering\">, ac.NAME </if>"
+ "<if test=\"addWorkbasketNameToSelectClauseForOrdering\">, w.NAME </if>"
+ "<if test=\"joinWithUserInfo\">, u.LONG_NAME </if>"
+ "FROM TASK t "
+ "<if test=\"joinWithAttachments\">"
+ "LEFT JOIN ATTACHMENT a ON t.ID = a.TASK_ID "
@ -87,6 +92,9 @@ public class TaskQuerySqlProvider {
+ "<if test=\"joinWithWorkbaskets\">"
+ "LEFT JOIN WORKBASKET AS w ON t.WORKBASKET_ID = w.ID "
+ "</if>"
+ "<if test=\"joinWithUserInfo\">"
+ "LEFT JOIN USER_INFO AS u ON t.owner = u.USER_ID "
+ "</if>"
+ OPENING_WHERE_TAG
+ commonTaskWhereStatement()
+ CLOSING_WHERE_TAG
@ -133,6 +141,9 @@ public class TaskQuerySqlProvider {
+ "<if test=\"joinWithAttachmentClassifications\">"
+ "LEFT JOIN CLASSIFICATION AS ac ON a.CLASSIFICATION_ID = ac.ID "
+ "</if>"
+ "<if test=\"joinWithUserInfo\">"
+ "LEFT JOIN USER_INFO AS u ON t.owner = u.USER_ID "
+ "</if>"
+ OPENING_WHERE_TAG
+ checkForAuthorization()
+ commonTaskWhereStatement()
@ -155,6 +166,9 @@ public class TaskQuerySqlProvider {
+ "<if test=\"joinWithAttachmentClassifications\">"
+ "LEFT JOIN CLASSIFICATION AS ac ON a.CLASSIFICATION_ID = ac.ID "
+ "</if>"
+ "<if test=\"joinWithUserInfo\">"
+ "LEFT JOIN USER_INFO AS u ON t.owner = u.USER_ID "
+ "</if>"
+ OPENING_WHERE_TAG
+ commonTaskWhereStatement()
+ CLOSING_WHERE_TAG
@ -174,6 +188,7 @@ public class TaskQuerySqlProvider {
public static String queryTaskColumnValues() {
return OPENING_SCRIPT_TAG
+ "SELECT DISTINCT ${columnName} "
+ "<if test=\"joinWithUserInfo\">, u.LONG_NAME </if>"
+ "FROM TASK t "
+ "<if test=\"joinWithAttachments\">"
+ "LEFT JOIN ATTACHMENT AS a ON t.ID = a.TASK_ID "
@ -184,6 +199,9 @@ public class TaskQuerySqlProvider {
+ "<if test=\"joinWithAttachmentClassifications\">"
+ "LEFT JOIN CLASSIFICATION AS ac ON a.CLASSIFICATION_ID = ac.ID "
+ "</if>"
+ "<if test=\"joinWithUserInfo\">"
+ "LEFT JOIN USER_INFO AS u ON t.owner = u.USER_ID "
+ "</if>"
+ OPENING_WHERE_TAG
+ checkForAuthorization()
+ commonTaskWhereStatement()
@ -252,7 +270,8 @@ public class TaskQuerySqlProvider {
+ "<if test=\"addAttachmentColumnsToSelectClauseForOrdering\">"
+ ", ACLASSIFICATION_ID, ACLASSIFICATION_KEY, CHANNEL, REF_VALUE, ARECEIVED"
+ "</if>"
+ "<if test=\"addWorkbasketNameToSelectClauseForOrdering\">, WNAME</if>";
+ "<if test=\"addWorkbasketNameToSelectClauseForOrdering\">, WNAME</if>"
+ "<if test=\"joinWithUserInfo\">, ULONG_NAME </if>";
}
private static String checkForAuthorization() {
@ -328,8 +347,8 @@ public class TaskQuerySqlProvider {
whereNotIn("externalIdNotIn", "t.EXTERNAL_ID", sb);
whereIn("priority", "t.PRIORITY", sb);
whereNotIn("priorityNotIn", "t.PRIORITY", sb);
whereIn("priority", "t.PRIORITY", sb);
whereNotIn("priorityNotIn", "t.PRIORITY", sb);
whereIn("ownerLongNameIn", "u.LONG_NAME", sb);
whereNotIn("ownerLongNameNotIn", "u.LONG_NAME", sb);
whereIn("stateIn", "t.STATE", sb);
whereNotIn("stateNotIn", "t.STATE", sb);
whereIn("taskId", "t.ID", sb);
@ -358,6 +377,8 @@ public class TaskQuerySqlProvider {
whereInTime("receivedWithin", "t.RECEIVED", sb);
whereNotInTime("receivedNotWithin", "t.RECEIVED", sb);
whereLike("ownerLongNameLike", "u.LONG_NAME", sb);
whereNotLike("ownerLongNameNotLike", "u.LONG_NAME", sb);
whereCustomStatements("custom", "t.CUSTOM", 16, sb);
sb.append("<if test='isRead != null'>AND IS_READ = #{isRead}</if> ");

26
lib/taskana-core/src/main/java/pro/taskana/task/internal/TaskServiceImpl.java
View File

@ -51,6 +51,7 @@ import pro.taskana.spi.history.internal.HistoryEventManager;
import pro.taskana.spi.priority.internal.PriorityServiceManager;
import pro.taskana.spi.task.internal.CreateTaskPreprocessorManager;
import pro.taskana.task.api.CallbackState;
import pro.taskana.task.api.TaskCommentQuery;
import pro.taskana.task.api.TaskCustomField;
import pro.taskana.task.api.TaskQuery;
import pro.taskana.task.api.TaskService;
@ -75,6 +76,8 @@ import pro.taskana.task.internal.models.AttachmentSummaryImpl;
import pro.taskana.task.internal.models.MinimalTaskSummary;
import pro.taskana.task.internal.models.TaskImpl;
import pro.taskana.task.internal.models.TaskSummaryImpl;
import pro.taskana.user.api.models.User;
import pro.taskana.user.internal.UserMapper;
import pro.taskana.workbasket.api.WorkbasketPermission;
import pro.taskana.workbasket.api.WorkbasketService;
import pro.taskana.workbasket.api.exceptions.MismatchedWorkbasketPermissionException;
@ -99,6 +102,7 @@ public class TaskServiceImpl implements TaskService {
private final ServiceLevelHandler serviceLevelHandler;
private final AttachmentHandler attachmentHandler;
private final AttachmentMapper attachmentMapper;
private final UserMapper userMapper;
private final HistoryEventManager historyEventManager;
private final CreateTaskPreprocessorManager createTaskPreprocessorManager;
private final PriorityServiceManager priorityServiceManager;
@ -107,17 +111,20 @@ public class TaskServiceImpl implements TaskService {
InternalTaskanaEngine taskanaEngine,
TaskMapper taskMapper,
TaskCommentMapper taskCommentMapper,
AttachmentMapper attachmentMapper) {
AttachmentMapper attachmentMapper,
UserMapper userMapper) {
this.taskanaEngine = taskanaEngine;
this.taskMapper = taskMapper;
this.workbasketService = taskanaEngine.getEngine().getWorkbasketService();
this.attachmentMapper = attachmentMapper;
this.userMapper = userMapper;
this.classificationService = taskanaEngine.getEngine().getClassificationService();
this.historyEventManager = taskanaEngine.getHistoryEventManager();
this.createTaskPreprocessorManager = taskanaEngine.getCreateTaskPreprocessorManager();
this.priorityServiceManager = taskanaEngine.getPriorityServiceManager();
this.taskTransferrer = new TaskTransferrer(taskanaEngine, taskMapper, this);
this.taskCommentService = new TaskCommentServiceImpl(taskanaEngine, taskCommentMapper, this);
this.taskCommentService =
new TaskCommentServiceImpl(taskanaEngine, taskCommentMapper, userMapper, this);
this.serviceLevelHandler =
new ServiceLevelHandler(taskanaEngine, taskMapper, attachmentMapper, this);
this.attachmentHandler = new AttachmentHandler(attachmentMapper, classificationService);
@ -320,6 +327,15 @@ public class TaskServiceImpl implements TaskService {
}
resultTask.setClassificationSummary(classification);
if (resultTask.getOwner() != null
&& !resultTask.getOwner().isEmpty()
&& taskanaEngine.getEngine().getConfiguration().getAddAdditionalUserInfo()) {
User owner = userMapper.findById(resultTask.getOwner());
if (owner != null) {
resultTask.setOwnerLongName(owner.getLongName());
}
}
return resultTask;
} else {
throw new TaskNotFoundException(id);
@ -367,6 +383,12 @@ public class TaskServiceImpl implements TaskService {
return new TaskQueryImpl(taskanaEngine);
}
@Override
public TaskCommentQuery createTaskCommentQuery() {
return new TaskCommentQueryImpl(
taskanaEngine);
}
@Override
public Task newTask() {
return newTask(null);

15
lib/taskana-core/src/main/java/pro/taskana/task/internal/models/TaskCommentImpl.java
View File

@ -12,6 +12,7 @@ public class TaskCommentImpl implements TaskComment {
private String taskId;
private String textField;
private String creator;
private String creatorLongName;
private Instant created;
private Instant modified;
@ -52,6 +53,15 @@ public class TaskCommentImpl implements TaskComment {
this.creator = creator;
}
@Override
public String getCreatorLongName() {
return creatorLongName;
}
public void setCreatorLongName(String creatorLongName) {
this.creatorLongName = creatorLongName;
}
public String getTextField() {
return textField;
}
@ -89,7 +99,7 @@ public class TaskCommentImpl implements TaskComment {
@Override
public int hashCode() {
return Objects.hash(id, taskId, textField, creator, created, modified);
return Objects.hash(id, taskId, textField, creator, creatorLongName, created, modified);
}
@Override
@ -110,6 +120,7 @@ public class TaskCommentImpl implements TaskComment {
&& Objects.equals(taskId, other.getTaskId())
&& Objects.equals(textField, other.getTextField())
&& Objects.equals(creator, other.getCreator())
&& Objects.equals(creatorLongName, other.getCreatorLongName())
&& Objects.equals(created, other.getCreated())
&& Objects.equals(modified, other.getModified());
}
@ -124,6 +135,8 @@ public class TaskCommentImpl implements TaskComment {
+ textField
+ ", creator="
+ creator
+ ", creatorLongName="
+ creatorLongName
+ ", created="
+ created
+ ", modified="

15
lib/taskana-core/src/main/java/pro/taskana/task/internal/models/TaskSummaryImpl.java
View File

@ -40,6 +40,7 @@ public class TaskSummaryImpl implements TaskSummary {
protected String businessProcessId;
protected String parentBusinessProcessId;
protected String owner;
protected String ownerLongName;
protected ObjectReference primaryObjRef;
protected boolean isRead;
protected boolean isTransferred;
@ -82,6 +83,7 @@ public class TaskSummaryImpl implements TaskSummary {
businessProcessId = copyFrom.businessProcessId;
parentBusinessProcessId = copyFrom.parentBusinessProcessId;
owner = copyFrom.owner;
ownerLongName = copyFrom.ownerLongName;
primaryObjRef = copyFrom.primaryObjRef;
isRead = copyFrom.isRead;
isTransferred = copyFrom.isTransferred;
@ -305,6 +307,15 @@ public class TaskSummaryImpl implements TaskSummary {
this.owner = owner;
}
@Override
public String getOwnerLongName() {
return ownerLongName;
}
public void setOwnerLongName(String ownerLongName) {
this.ownerLongName = ownerLongName;
}
@Override
public ObjectReference getPrimaryObjRef() {
return primaryObjRef;
@ -576,6 +587,7 @@ public class TaskSummaryImpl implements TaskSummary {
businessProcessId,
parentBusinessProcessId,
owner,
ownerLongName,
primaryObjRef,
isRead,
isTransferred,
@ -632,6 +644,7 @@ public class TaskSummaryImpl implements TaskSummary {
&& Objects.equals(businessProcessId, other.businessProcessId)
&& Objects.equals(parentBusinessProcessId, other.parentBusinessProcessId)
&& Objects.equals(owner, other.owner)
&& Objects.equals(ownerLongName, other.ownerLongName)
&& Objects.equals(primaryObjRef, other.primaryObjRef)
&& Objects.equals(attachmentSummaries, other.attachmentSummaries)
&& Objects.equals(custom1, other.custom1)
@ -694,6 +707,8 @@ public class TaskSummaryImpl implements TaskSummary {
+ parentBusinessProcessId
+ ", owner="
+ owner
+ ", ownerLongName="
+ ownerLongName
+ ", primaryObjRef="
+ primaryObjRef
+ ", isRead="

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

@ -26,6 +26,7 @@ import pro.taskana.common.test.config.DataSourceGenerator;
import pro.taskana.sampledata.SampleDataGenerator;
import pro.taskana.task.api.models.Attachment;
import pro.taskana.task.api.models.ObjectReference;
import pro.taskana.task.internal.TaskServiceImpl;
import pro.taskana.user.api.models.User;
/** Base class for all acceptance tests. */
@ -38,6 +39,8 @@ public abstract class AbstractAccTest {
protected static TaskanaEngineConfiguration taskanaEngineConfiguration;
protected static TaskanaEngine taskanaEngine;
protected static TaskServiceImpl taskService;
protected static WorkingDaysToDaysConverter converter;
@BeforeAll
@ -59,6 +62,8 @@ public abstract class AbstractAccTest {
taskanaEngine =
taskanaEngineConfiguration.buildTaskanaEngine(ConnectionManagementMode.AUTOCOMMIT);
converter = taskanaEngine.getWorkingDaysToDaysConverter();
taskService = (TaskServiceImpl) taskanaEngine.getTaskService();
sampleDataGenerator.clearDb();
sampleDataGenerator.generateTestData();
}

2
lib/taskana-core/src/test/java/acceptance/builder/TaskBuilderTest.java
View File

@ -196,7 +196,7 @@ class TaskBuilderTest {
expectedTask.setCallbackState(CallbackState.CALLBACK_PROCESSING_COMPLETED);
assertThat(task)
.hasNoNullFieldsOrProperties()
.hasNoNullFieldsOrPropertiesExcept("ownerLongName")
.usingRecursiveComparison()
.ignoringFields("id")
.isEqualTo(expectedTask);

2
lib/taskana-core/src/test/java/acceptance/builder/TaskCommentBuilderTest.java
View File

@ -107,7 +107,7 @@ class TaskCommentBuilderTest {
expectedTaskComment.setCreator("user-1-1");
assertThat(taskComment)
.hasNoNullFieldsOrPropertiesExcept()
.hasNoNullFieldsOrPropertiesExcept("creatorLongName")
.usingRecursiveComparison()
.ignoringFields("id")
.isEqualTo(expectedTaskComment);

4
lib/taskana-core/src/test/java/acceptance/jobs/TaskCleanupJobAccTest.java
View File

@ -26,7 +26,6 @@ import pro.taskana.common.internal.JobServiceImpl;
import pro.taskana.common.internal.jobs.JobRunner;
import pro.taskana.common.test.security.JaasExtension;
import pro.taskana.common.test.security.WithAccessId;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.models.Task;
import pro.taskana.task.api.models.TaskSummary;
import pro.taskana.task.internal.jobs.TaskCleanupJob;
@ -36,14 +35,11 @@ import pro.taskana.task.internal.jobs.TaskRefreshJob;
@ExtendWith(JaasExtension.class)
class TaskCleanupJobAccTest extends AbstractAccTest {
TaskService taskService;
@BeforeEach
void before() throws Exception {
// required if single tests modify database
// TODO split test class into readOnly & modifying tests to improve performance
resetDb(false);
taskService = taskanaEngine.getTaskService();
}
@WithAccessId(user = "admin")

2
lib/taskana-core/src/test/java/acceptance/jobs/WorkbasketCleanupJobAccTest.java
View File

@ -15,7 +15,6 @@ import pro.taskana.common.api.BaseQuery;
import pro.taskana.common.api.ScheduledJob;
import pro.taskana.common.test.security.JaasExtension;
import pro.taskana.common.test.security.WithAccessId;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.TaskState;
import pro.taskana.task.internal.jobs.TaskCleanupJob;
import pro.taskana.task.internal.jobs.TaskRefreshJob;
@ -28,7 +27,6 @@ import pro.taskana.workbasket.internal.jobs.WorkbasketCleanupJob;
class WorkbasketCleanupJobAccTest extends AbstractAccTest {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
TaskService taskService = taskanaEngine.getTaskService();
@AfterEach
void after() throws Exception {

11
lib/taskana-core/src/test/java/acceptance/priorityservice/PriorityServiceAccTest.java
View File

@ -22,7 +22,6 @@ import pro.taskana.common.internal.util.Pair;
import pro.taskana.common.test.security.JaasExtension;
import pro.taskana.common.test.security.WithAccessId;
import pro.taskana.task.api.TaskCustomField;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.models.ObjectReference;
import pro.taskana.task.api.models.Task;
@ -31,8 +30,6 @@ import pro.taskana.task.api.models.Task;
@ExtendWith(JaasExtension.class)
class PriorityServiceAccTest extends AbstractAccTest {
private static final TaskService TASK_SERVICE = taskanaEngine.getTaskService();
@WithAccessId(user = "user-1-1")
@TestFactory
Stream<DynamicTest> should_SetThePriorityAccordingToTestProvider_When_CreatingTask() {
@ -40,14 +37,14 @@ class PriorityServiceAccTest extends AbstractAccTest {
ThrowingConsumer<Pair<String, Integer>> test =
x -> {
Task task = TASK_SERVICE.newTask("USER-1-1", "DOMAIN_A");
Task task = taskService.newTask("USER-1-1", "DOMAIN_A");
task.setCustomAttribute(TaskCustomField.CUSTOM_6, x.getLeft());
task.setClassificationKey("T2100");
ObjectReference objectReference =
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567");
task.setPrimaryObjRef(objectReference);
Task createdTask = TASK_SERVICE.createTask(task);
Task createdTask = taskService.createTask(task);
assertThat(createdTask.getPriority()).isEqualTo(x.getRight());
};
@ -59,7 +56,7 @@ class PriorityServiceAccTest extends AbstractAccTest {
Stream<DynamicTest> should_SetThePriorityAccordingToTestProvider_When_UpdatingTask()
throws Exception {
List<Pair<String, Integer>> testCases = List.of(Pair.of("false", 1), Pair.of("true", 10));
Task task = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000000");
Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
int daysSinceCreated =
Math.toIntExact(
TimeUnit.DAYS.convert(
@ -70,7 +67,7 @@ class PriorityServiceAccTest extends AbstractAccTest {
x -> {
task.setCustomAttribute(TaskCustomField.CUSTOM_6, x.getLeft());
Task updatedTask = TASK_SERVICE.updateTask(task);
Task updatedTask = taskService.updateTask(task);
assertThat(updatedTask.getPriority()).isEqualTo(daysSinceCreated * x.getRight());
};

4
lib/taskana-core/src/test/java/acceptance/task/CancelTaskAccTest.java
View File

@ -13,7 +13,6 @@ import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.common.test.security.JaasExtension;
import pro.taskana.common.test.security.WithAccessId;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.TaskState;
import pro.taskana.task.api.exceptions.InvalidStateException;
import pro.taskana.task.api.models.Task;
@ -23,11 +22,8 @@ import pro.taskana.task.api.models.TaskSummary;
@ExtendWith(JaasExtension.class)
class CancelTaskAccTest extends AbstractAccTest {
private TaskService taskService;
CancelTaskAccTest() {
super();
taskService = taskanaEngine.getTaskService();
}
@BeforeEach

137
lib/taskana-core/src/test/java/acceptance/task/CompleteTaskAccTest.java
View File

@ -20,7 +20,6 @@ import pro.taskana.common.api.exceptions.TaskanaException;
import pro.taskana.common.internal.util.EnumUtil;
import pro.taskana.common.test.security.JaasExtension;
import pro.taskana.common.test.security.WithAccessId;
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;
@ -32,14 +31,12 @@ import pro.taskana.task.internal.models.TaskImpl;
@ExtendWith(JaasExtension.class)
class CompleteTaskAccTest extends AbstractAccTest {
private static final TaskService TASK_SERVICE = taskanaEngine.getTaskService();
@WithAccessId(user = "user-1-1")
@Test
void testCompleteTask() throws Exception {
assertThat(TASK_SERVICE.getTask("TKI:000000000000000000000000000000000001").getState())
assertThat(taskService.getTask("TKI:000000000000000000000000000000000001").getState())
.isEqualTo(TaskState.CLAIMED);
Task completedTask = TASK_SERVICE.completeTask("TKI:000000000000000000000000000000000001");
Task completedTask = taskService.completeTask("TKI:000000000000000000000000000000000001");
assertThat(completedTask).isNotNull();
assertThat(completedTask.getCompleted()).isNotNull();
assertThat(completedTask.getState()).isEqualTo(TaskState.COMPLETED);
@ -49,9 +46,9 @@ class CompleteTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void should_completeClaimedTaskByAnotherUser_When_UserIsAdmin() throws Exception {
assertThat(TASK_SERVICE.getTask("TKI:000000000000000000000000000000000029").getState())
assertThat(taskService.getTask("TKI:000000000000000000000000000000000029").getState())
.isEqualTo(TaskState.CLAIMED);
Task completedTask = TASK_SERVICE.completeTask("TKI:000000000000000000000000000000000029");
Task completedTask = taskService.completeTask("TKI:000000000000000000000000000000000029");
assertThat(completedTask).isNotNull();
assertThat(completedTask.getCompleted()).isNotNull();
assertThat(completedTask.getState()).isEqualTo(TaskState.COMPLETED);
@ -65,9 +62,9 @@ class CompleteTaskAccTest extends AbstractAccTest {
throws Exception {
resetDb(false);
assertThat(TASK_SERVICE.getTask("TKI:000000000000000000000000000000000000").getState())
assertThat(taskService.getTask("TKI:000000000000000000000000000000000000").getState())
.isEqualTo(TaskState.CLAIMED);
Task completedTask = TASK_SERVICE.forceCompleteTask("TKI:000000000000000000000000000000000000");
Task completedTask = taskService.forceCompleteTask("TKI:000000000000000000000000000000000000");
assertThat(completedTask).isNotNull();
assertThat(completedTask.getCompleted()).isNotNull();
assertThat(completedTask.getState()).isEqualTo(TaskState.COMPLETED);
@ -77,15 +74,15 @@ class CompleteTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testCompleteTaskTwice() throws Exception {
Task completedTask = TASK_SERVICE.completeTask("TKI:000000000000000000000000000000000002");
Task completedTask2 = TASK_SERVICE.completeTask("TKI:000000000000000000000000000000000002");
Task completedTask = taskService.completeTask("TKI:000000000000000000000000000000000002");
Task completedTask2 = taskService.completeTask("TKI:000000000000000000000000000000000002");
assertThat(completedTask2).isEqualTo(completedTask);
}
@WithAccessId(user = "user-1-1")
@Test
void testForceCompleteAlreadyClaimed() throws Exception {
Task newTask = TASK_SERVICE.newTask("USER-1-1", "DOMAIN_A");
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
newTask.setOwner("other");
newTask.setPrimaryObjRef(
@ -94,8 +91,8 @@ class CompleteTaskAccTest extends AbstractAccTest {
newTaskImpl.setState(TaskState.CLAIMED);
newTaskImpl.setClaimed(Instant.now());
Task createdTask = TASK_SERVICE.createTask(newTaskImpl);
Task completedTask = TASK_SERVICE.forceCompleteTask(createdTask.getId());
Task createdTask = taskService.createTask(newTaskImpl);
Task completedTask = taskService.forceCompleteTask(createdTask.getId());
assertThat(completedTask.getState()).isEqualTo(TaskState.COMPLETED);
assertThat(completedTask.getCompleted()).isNotNull();
@ -106,7 +103,7 @@ class CompleteTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testForceCompleteNotClaimed() throws Exception {
Task newTask = TASK_SERVICE.newTask("USER-1-1", "DOMAIN_A");
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
newTask.setOwner("other");
newTask.setPrimaryObjRef(
@ -114,8 +111,8 @@ class CompleteTaskAccTest extends AbstractAccTest {
TaskImpl newTaskImpl = (TaskImpl) newTask;
newTaskImpl.setClaimed(Instant.now());
Task createdTask = TASK_SERVICE.createTask(newTaskImpl);
Task completedTask = TASK_SERVICE.forceCompleteTask(createdTask.getId());
Task createdTask = taskService.createTask(newTaskImpl);
Task completedTask = taskService.forceCompleteTask(createdTask.getId());
assertThat(completedTask.getState()).isEqualTo(TaskState.COMPLETED);
assertThat(completedTask.getCompleted()).isNotNull();
@ -127,7 +124,7 @@ class CompleteTaskAccTest extends AbstractAccTest {
@Test
void should_ThrowException_When_TaskIsNotFound() {
ThrowingCallable call =
() -> TASK_SERVICE.completeTask("TKI:0000000000000000000000000000000000xx");
() -> taskService.completeTask("TKI:0000000000000000000000000000000000xx");
assertThatThrownBy(call).isInstanceOf(TaskNotFoundException.class);
}
@ -135,7 +132,7 @@ class CompleteTaskAccTest extends AbstractAccTest {
@Test
void should_ThrowException_When_UserIsNotAuthorizedOnTask() {
ThrowingCallable call =
() -> TASK_SERVICE.completeTask("TKI:000000000000000000000000000000000004");
() -> taskService.completeTask("TKI:000000000000000000000000000000000004");
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@ -143,7 +140,7 @@ class CompleteTaskAccTest extends AbstractAccTest {
@Test
void should_ThrowException_When_TaskIsInStateReady() {
ThrowingCallable call =
() -> TASK_SERVICE.completeTask("TKI:000000000000000000000000000000000025");
() -> taskService.completeTask("TKI:000000000000000000000000000000000025");
assertThatThrownBy(call).isInstanceOf(InvalidStateException.class);
}
@ -151,25 +148,25 @@ class CompleteTaskAccTest extends AbstractAccTest {
@Test
void should_ThrowException_When_TaskCallerIsNotTheOwner() {
ThrowingCallable call =
() -> TASK_SERVICE.completeTask("TKI:000000000000000000000000000000000026");
() -> taskService.completeTask("TKI:000000000000000000000000000000000026");
assertThatThrownBy(call).isInstanceOf(InvalidOwnerException.class);
}
@WithAccessId(user = "user-1-1")
@Test
void testClaimTaskWithDefaultFlag() throws Exception {
Task newTask = TASK_SERVICE.newTask("USER-1-1", "DOMAIN_A");
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
newTask.setPrimaryObjRef(
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
newTask.setOwner(null);
Task createdTask = TASK_SERVICE.createTask(newTask);
Task createdTask = taskService.createTask(newTask);
assertThat(createdTask).isNotNull();
assertThat(createdTask.getClaimed()).isNull();
final Instant before = createdTask.getCreated();
Task claimedTask = TASK_SERVICE.claim(createdTask.getId());
Task claimedTask = taskService.claim(createdTask.getId());
assertThat(claimedTask.getOwner()).isNotNull();
assertThat(taskanaEngine.getCurrentUserContext().getUserid()).isEqualTo(claimedTask.getOwner());
@ -183,18 +180,18 @@ class CompleteTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testForceClaimTaskFromOtherUser() throws Exception {
Task newTask = TASK_SERVICE.newTask("USER-1-1", "DOMAIN_A");
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
newTask.setPrimaryObjRef(
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
newTask.setOwner("other_user");
Task createdTask = TASK_SERVICE.createTask(newTask);
Task createdTask = taskService.createTask(newTask);
assertThat(createdTask).isNotNull();
assertThat(createdTask.getOwner()).isEqualTo("other_user");
Instant beforeForceClaim = Instant.now().truncatedTo(ChronoUnit.MILLIS);
Task taskAfterClaim = TASK_SERVICE.forceClaim(createdTask.getId());
Task taskAfterClaim = taskService.forceClaim(createdTask.getId());
assertThat(taskAfterClaim.getOwner())
.isEqualTo(taskanaEngine.getCurrentUserContext().getUserid());
@ -210,21 +207,21 @@ class CompleteTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testClaimTaskNotExisting() {
assertThatThrownBy(() -> TASK_SERVICE.claim("NOT_EXISTING"))
assertThatThrownBy(() -> taskService.claim("NOT_EXISTING"))
.isInstanceOf(TaskNotFoundException.class);
}
@WithAccessId(user = "user-1-2")
@Test
void testClaimTaskWithInvalidState() {
assertThatThrownBy(() -> TASK_SERVICE.forceClaim("TKI:000000000000000000000000000000000036"))
assertThatThrownBy(() -> taskService.forceClaim("TKI:000000000000000000000000000000000036"))
.isInstanceOf(InvalidStateException.class);
}
@WithAccessId(user = "user-1-2")
@Test
void testClaimTaskWithInvalidOwner() {
assertThatThrownBy(() -> TASK_SERVICE.claim("TKI:000000000000000000000000000000000035"))
assertThatThrownBy(() -> taskService.claim("TKI:000000000000000000000000000000000035"))
.isInstanceOf(InvalidOwnerException.class);
}
@ -232,23 +229,23 @@ class CompleteTaskAccTest extends AbstractAccTest {
@Test
void testCancelClaimForcedWithInvalidState() {
ThrowingCallable call =
() -> TASK_SERVICE.forceCancelClaim("TKI:000000000000000000000000000000000036");
() -> taskService.forceCancelClaim("TKI:000000000000000000000000000000000036");
assertThatThrownBy(call).isInstanceOf(InvalidStateException.class);
}
@WithAccessId(user = "user-1-1")
@Test
void testCancelClaimDefaultFlag() throws Exception {
Task newTask = TASK_SERVICE.newTask("USER-1-1", "DOMAIN_A");
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
newTask.setPrimaryObjRef(
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
Task createdTask = TASK_SERVICE.createTask(newTask);
Task createdTask = taskService.createTask(newTask);
assertThat(createdTask).isNotNull();
assertThat(createdTask.getState()).isSameAs(TaskState.READY);
createdTask = TASK_SERVICE.cancelClaim(createdTask.getId());
createdTask = taskService.cancelClaim(createdTask.getId());
assertThat(createdTask).isNotNull();
assertThat(createdTask.getState()).isSameAs(TaskState.READY);
@ -257,14 +254,14 @@ class CompleteTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testForceCancelClaimSuccessfull() throws Exception {
Task taskBefore = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000043");
Task taskBefore = taskService.getTask("TKI:000000000000000000000000000000000043");
assertThat(taskBefore).isNotNull();
assertThat(taskBefore.getState()).isEqualTo(TaskState.CLAIMED);
final Instant before = Instant.now();
Thread.sleep(1);
Task taskAfter = TASK_SERVICE.forceCancelClaim("TKI:000000000000000000000000000000000043");
Task taskAfter = taskService.forceCancelClaim("TKI:000000000000000000000000000000000043");
assertThat(taskAfter).isNotNull();
assertThat(taskAfter.getState()).isEqualTo(TaskState.READY);
@ -277,13 +274,13 @@ class CompleteTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-2")
@Test
void testCancelClaimWithInvalidOwner() {
assertThatThrownBy(() -> TASK_SERVICE.cancelClaim("TKI:000000000000000000000000000000000035"))
assertThatThrownBy(() -> taskService.cancelClaim("TKI:000000000000000000000000000000000035"))
.isInstanceOf(InvalidOwnerException.class);
}
@Test
void should_ThrowException_When_BulkCompleteWithNullList() {
assertThatThrownBy(() -> TASK_SERVICE.completeTasks(null))
assertThatThrownBy(() -> taskService.completeTasks(null))
.isInstanceOf(InvalidArgumentException.class);
}
@ -295,18 +292,18 @@ class CompleteTaskAccTest extends AbstractAccTest {
List<String> taskIdList = List.of(id1, id2);
Instant beforeBulkComplete = Instant.now().truncatedTo(ChronoUnit.MILLIS);
BulkOperationResults<String, TaskanaException> results = TASK_SERVICE.completeTasks(taskIdList);
BulkOperationResults<String, TaskanaException> results = taskService.completeTasks(taskIdList);
assertThat(results.containsErrors()).isFalse();
Task completedTask1 = TASK_SERVICE.getTask(id1);
Task completedTask1 = taskService.getTask(id1);
assertThat(completedTask1.getState()).isEqualTo(TaskState.COMPLETED);
assertThat(completedTask1.getCompleted())
.isEqualTo(completedTask1.getModified())
.isAfterOrEqualTo(beforeBulkComplete);
assertThat(completedTask1.getOwner()).isEqualTo("user-1-2");
Task completedTask2 = TASK_SERVICE.getTask(id2);
Task completedTask2 = taskService.getTask(id2);
assertThat(completedTask2.getState()).isEqualTo(TaskState.COMPLETED);
assertThat(completedTask2.getCompleted())
.isEqualTo(completedTask2.getModified())
@ -322,10 +319,10 @@ class CompleteTaskAccTest extends AbstractAccTest {
List<String> taskIdList = List.of(invalid, validId);
Instant beforeBulkComplete = Instant.now().truncatedTo(ChronoUnit.MILLIS);
BulkOperationResults<String, TaskanaException> results = TASK_SERVICE.completeTasks(taskIdList);
BulkOperationResults<String, TaskanaException> results = taskService.completeTasks(taskIdList);
assertThat(results.containsErrors()).isTrue();
Task completedTask = TASK_SERVICE.getTask(validId);
Task completedTask = taskService.getTask(validId);
assertThat(completedTask.getState()).isEqualTo(TaskState.COMPLETED);
assertThat(completedTask.getCompleted())
.isEqualTo(completedTask.getModified())
@ -343,7 +340,7 @@ class CompleteTaskAccTest extends AbstractAccTest {
// we can't use List.of because of the null value we insert
List<String> taskIdList = Arrays.asList(invalid1, invalid2, invalid3, notAuthorized);
BulkOperationResults<String, TaskanaException> results = TASK_SERVICE.completeTasks(taskIdList);
BulkOperationResults<String, TaskanaException> results = taskService.completeTasks(taskIdList);
assertThat(results.containsErrors()).isTrue();
assertThat(results.getFailedIds())
@ -357,7 +354,7 @@ class CompleteTaskAccTest extends AbstractAccTest {
String id = "TKI:000000000000000000000000000000000025"; // task is not claimed
List<String> taskIdList = List.of(id);
BulkOperationResults<String, TaskanaException> results = TASK_SERVICE.completeTasks(taskIdList);
BulkOperationResults<String, TaskanaException> results = taskService.completeTasks(taskIdList);
assertThat(results.containsErrors()).isTrue();
assertThat(results.getFailedIds()).containsExactlyInAnyOrder(id);
@ -377,7 +374,7 @@ class CompleteTaskAccTest extends AbstractAccTest {
TaskState[] requiredStates =
EnumUtil.allValuesExceptFor(TaskState.TERMINATED, TaskState.CANCELLED);
BulkOperationResults<String, TaskanaException> results = TASK_SERVICE.completeTasks(taskIdList);
BulkOperationResults<String, TaskanaException> results = taskService.completeTasks(taskIdList);
assertThat(results.containsErrors()).isTrue();
assertThat(results.getFailedIds()).containsExactlyInAnyOrder(id1, id2);
@ -398,9 +395,9 @@ class CompleteTaskAccTest extends AbstractAccTest {
String id = "TKI:000000000000000000000000000000000036"; // task is completed
List<String> taskIdList = List.of(id);
Task before = TASK_SERVICE.getTask(id);
BulkOperationResults<String, TaskanaException> results = TASK_SERVICE.completeTasks(taskIdList);
Task after = TASK_SERVICE.getTask(id);
Task before = taskService.getTask(id);
BulkOperationResults<String, TaskanaException> results = taskService.completeTasks(taskIdList);
Task after = taskService.getTask(id);
assertThat(results.containsErrors()).isFalse();
assertThat(before).isEqualTo(after);
@ -412,7 +409,7 @@ class CompleteTaskAccTest extends AbstractAccTest {
String id1 = "TKI:000000000000000000000000000000000035";
List<String> taskIdList = List.of(id1);
BulkOperationResults<String, TaskanaException> results = TASK_SERVICE.completeTasks(taskIdList);
BulkOperationResults<String, TaskanaException> results = taskService.completeTasks(taskIdList);
assertThat(results.containsErrors()).isTrue();
assertThat(results.getFailedIds()).containsExactlyInAnyOrder(id1);
@ -428,18 +425,18 @@ class CompleteTaskAccTest extends AbstractAccTest {
Instant beforeBulkComplete = Instant.now().truncatedTo(ChronoUnit.MILLIS);
BulkOperationResults<String, TaskanaException> results =
TASK_SERVICE.forceCompleteTasks(taskIdList);
taskService.forceCompleteTasks(taskIdList);
assertThat(results.containsErrors()).isFalse();
Task completedTask1 = TASK_SERVICE.getTask(id1);
Task completedTask1 = taskService.getTask(id1);
assertThat(completedTask1.getState()).isEqualTo(TaskState.COMPLETED);
assertThat(completedTask1.getCompleted())
.isEqualTo(completedTask1.getModified())
.isAfterOrEqualTo(beforeBulkComplete);
assertThat(completedTask1.getOwner()).isEqualTo("user-1-2");
Task completedTask2 = TASK_SERVICE.getTask(id2);
Task completedTask2 = taskService.getTask(id2);
assertThat(completedTask2.getState()).isEqualTo(TaskState.COMPLETED);
assertThat(completedTask2.getCompleted())
.isEqualTo(completedTask2.getModified())
@ -456,10 +453,10 @@ class CompleteTaskAccTest extends AbstractAccTest {
Instant beforeBulkComplete = Instant.now().truncatedTo(ChronoUnit.MILLIS);
BulkOperationResults<String, TaskanaException> results =
TASK_SERVICE.forceCompleteTasks(taskIdList);
taskService.forceCompleteTasks(taskIdList);
assertThat(results.containsErrors()).isTrue();
Task completedTask = TASK_SERVICE.getTask(validId);
Task completedTask = taskService.getTask(validId);
assertThat(completedTask.getState()).isEqualTo(TaskState.COMPLETED);
assertThat(completedTask.getCompleted())
.isEqualTo(completedTask.getModified())
@ -478,7 +475,7 @@ class CompleteTaskAccTest extends AbstractAccTest {
List<String> taskIdList = Arrays.asList(invalid1, invalid2, invalid3, notAuthorized);
BulkOperationResults<String, TaskanaException> results =
TASK_SERVICE.forceCompleteTasks(taskIdList);
taskService.forceCompleteTasks(taskIdList);
assertThat(results.containsErrors()).isTrue();
assertThat(results.getFailedIds())
@ -496,7 +493,7 @@ class CompleteTaskAccTest extends AbstractAccTest {
EnumUtil.allValuesExceptFor(TaskState.TERMINATED, TaskState.CANCELLED);
BulkOperationResults<String, TaskanaException> results =
TASK_SERVICE.forceCompleteTasks(taskIdList);
taskService.forceCompleteTasks(taskIdList);
assertThat(results.containsErrors()).isTrue();
assertThat(results.getFailedIds()).containsExactlyInAnyOrder(id1, id2);
@ -517,10 +514,10 @@ class CompleteTaskAccTest extends AbstractAccTest {
String id = "TKI:000000000000000000000000000000000036"; // task is completed
List<String> taskIdList = List.of(id);
Task before = TASK_SERVICE.getTask(id);
Task before = taskService.getTask(id);
BulkOperationResults<String, TaskanaException> results =
TASK_SERVICE.forceCompleteTasks(taskIdList);
Task after = TASK_SERVICE.getTask(id);
taskService.forceCompleteTasks(taskIdList);
Task after = taskService.getTask(id);
assertThat(results.containsErrors()).isFalse();
assertThat(before).isEqualTo(after);
@ -533,12 +530,12 @@ class CompleteTaskAccTest extends AbstractAccTest {
String id = "TKI:000000000000000000000000000000000002";
List<String> taskIdList = List.of(id);
Task beforeClaim = TASK_SERVICE.getTask(id);
Task beforeClaim = taskService.getTask(id);
assertThat(beforeClaim.getOwner()).isNotEqualTo("user-1-2");
final Instant beforeBulkComplete = Instant.now().truncatedTo(ChronoUnit.MILLIS);
BulkOperationResults<String, TaskanaException> results =
TASK_SERVICE.forceCompleteTasks(taskIdList);
Task afterClaim = TASK_SERVICE.getTask(id);
taskService.forceCompleteTasks(taskIdList);
Task afterClaim = taskService.getTask(id);
assertThat(results.containsErrors()).isFalse();
assertThat(afterClaim.getState()).isEqualTo(TaskState.COMPLETED);
@ -555,17 +552,17 @@ class CompleteTaskAccTest extends AbstractAccTest {
String id = "TKI:000000000000000000000000000000000033";
List<String> taskIdList = List.of(id);
Task task = TASK_SERVICE.getTask(id);
Task task = taskService.getTask(id);
assertThat(task.getState()).isSameAs(TaskState.READY);
assertThat(task.getClaimed()).isNull();
final Instant beforeBulkComplete = Instant.now().truncatedTo(ChronoUnit.MILLIS);
BulkOperationResults<String, TaskanaException> results =
TASK_SERVICE.forceCompleteTasks(taskIdList);
taskService.forceCompleteTasks(taskIdList);
assertThat(results.containsErrors()).isFalse();
task = TASK_SERVICE.getTask(id);
task = taskService.getTask(id);
assertThat(task.getState()).isEqualTo(TaskState.COMPLETED);
assertThat(task.getCompleted())
.isEqualTo(task.getClaimed())
@ -581,18 +578,18 @@ class CompleteTaskAccTest extends AbstractAccTest {
String id2 = "TKI:000000000000000000000000000000000044"; // task is ready
List<String> taskIdList = List.of(id1, id2);
Task task = TASK_SERVICE.getTask(id2);
Task task = taskService.getTask(id2);
assertThat(task.getState()).isSameAs(TaskState.READY);
assertThat(task.getClaimed()).isNull();
final Instant beforeBulkComplete = Instant.now().truncatedTo(ChronoUnit.MILLIS);
BulkOperationResults<String, TaskanaException> results =
TASK_SERVICE.forceCompleteTasks(taskIdList);
taskService.forceCompleteTasks(taskIdList);
assertThat(results.containsErrors()).isFalse();
task = TASK_SERVICE.getTask(id1);
task = taskService.getTask(id1);
assertThat(task.getState()).isEqualTo(TaskState.COMPLETED);
// do not update claimed timestamp for already claimed task
assertThat(task.getClaimed()).isBefore(beforeBulkComplete);
@ -601,7 +598,7 @@ class CompleteTaskAccTest extends AbstractAccTest {
.isAfterOrEqualTo(beforeBulkComplete);
assertThat(task.getOwner()).isEqualTo("user-b-2");
task = TASK_SERVICE.getTask(id2);
task = taskService.getTask(id2);
assertThat(task.getState()).isEqualTo(TaskState.COMPLETED);
assertThat(task.getCompleted())
.isEqualTo(task.getClaimed())

1
lib/taskana-core/src/test/java/acceptance/task/CreateTaskAccTest.java
View File

@ -46,7 +46,6 @@ import pro.taskana.workbasket.api.models.Workbasket;
@ExtendWith(JaasExtension.class)
class CreateTaskAccTest extends AbstractAccTest {
private final TaskService taskService = taskanaEngine.getTaskService();
private final ClassificationService classificationService =
taskanaEngine.getClassificationService();

3
lib/taskana-core/src/test/java/acceptance/task/DeleteTaskAccTest.java
View File

@ -16,7 +16,6 @@ import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.api.exceptions.TaskanaException;
import pro.taskana.common.test.security.JaasExtension;
import pro.taskana.common.test.security.WithAccessId;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.exceptions.InvalidStateException;
import pro.taskana.task.api.exceptions.InvalidTaskStateException;
import pro.taskana.task.api.exceptions.TaskNotFoundException;
@ -27,8 +26,6 @@ import pro.taskana.task.internal.AttachmentMapper;
@ExtendWith(JaasExtension.class)
class DeleteTaskAccTest extends AbstractAccTest {
private final TaskService taskService = taskanaEngine.getTaskService();
@WithAccessId(user = "user-1-2")
@Test
void testDeleteSingleTaskNotAuthorized() {

32
lib/taskana-core/src/test/java/acceptance/task/GetTaskAccTest.java
View File

@ -91,6 +91,38 @@ class GetTaskAccTest extends AbstractAccTest {
assertThatThrownBy(call).isInstanceOf(TaskNotFoundException.class);
}
@WithAccessId(user = "admin")
@Test
void should_SetTaskOwnerLongNameOfTask_When_PropertyEnabled() throws Exception {
taskanaEngineConfiguration.setAddAdditionalUserInfo(true);
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
String userLongName =
taskanaEngine.getUserService().getUser(task.getOwner()).getLongName();
assertThat(task)
.extracting(Task::getOwnerLongName)
.isEqualTo(userLongName);
}
@WithAccessId(user = "admin")
@Test
void should_NotSetTaskOwnerLongNameOfTask_When_PropertyDisabled() throws Exception {
taskanaEngineConfiguration.setAddAdditionalUserInfo(false);
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
assertThat(task)
.extracting(Task::getOwnerLongName)
.isNull();
}
@WithAccessId(user = "user-1-2")
@Test
void should_ThrowException_When_UserIsNotAuthorizedToGetTask() {

65
lib/taskana-core/src/test/java/acceptance/task/GetTaskCommentAccTest.java
View File

@ -2,6 +2,7 @@ package acceptance.task;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static pro.taskana.common.internal.util.CheckedConsumer.wrap;
import acceptance.AbstractAccTest;
import java.util.List;
@ -85,4 +86,68 @@ class GetTaskCommentAccTest extends AbstractAccTest {
() -> taskService.getTaskComment("TCI:000000000000000000000000000000000012");
assertThatThrownBy(lambda).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(user = "admin")
@Test
void should_SetCreatorFullNameOfTaskComment_When_PropertyEnabled() throws Exception {
taskanaEngineConfiguration.setAddAdditionalUserInfo(true);
TaskService taskService = taskanaEngine.getTaskService();
TaskComment taskComment =
taskService.getTaskComment("TCI:000000000000000000000000000000000000");
String creatorLongName =
taskanaEngine.getUserService().getUser(taskComment.getCreator()).getFullName();
assertThat(taskComment).extracting(TaskComment::getCreatorLongName).isEqualTo(creatorLongName);
}
@WithAccessId(user = "admin")
@Test
void should_NotSetCreatorFullNameOfTaskComment_When_PropertyDisabled() throws Exception {
taskanaEngineConfiguration.setAddAdditionalUserInfo(false);
TaskService taskService = taskanaEngine.getTaskService();
TaskComment taskComment =
taskService.getTaskComment("TCI:000000000000000000000000000000000000");
assertThat(taskComment).extracting(TaskComment::getCreatorLongName).isNull();
}
@WithAccessId(user = "admin")
@Test
void should_SetCreatorFullNameOfTaskComments_When_PropertyEnabled() throws Exception {
taskanaEngineConfiguration.setAddAdditionalUserInfo(true);
TaskService taskService = taskanaEngine.getTaskService();
List<TaskComment> taskComments =
taskService.getTaskComments("TKI:000000000000000000000000000000000000");
taskComments.forEach(
wrap(
taskComment -> {
String creatorLongName =
taskanaEngine.getUserService().getUser(taskComment.getCreator()).getFullName();
assertThat(taskComment)
.extracting(TaskComment::getCreatorLongName)
.isEqualTo(creatorLongName);
}));
}
@WithAccessId(user = "admin")
@Test
void should_NotSetCreatorFullNameOfTaskComments_When_PropertyDisabled() throws Exception {
taskanaEngineConfiguration.setAddAdditionalUserInfo(false);
TaskService taskService = taskanaEngine.getTaskService();
List<TaskComment> taskComments =
taskService.getTaskComments("TKI:000000000000000000000000000000000000");
taskComments.forEach(
taskComment ->
assertThat(taskComment).extracting(TaskComment::getCreatorLongName).isNull());
}
}

343
lib/taskana-core/src/test/java/acceptance/task/QueryTaskCommentAccTest.java Normal file
View File

@ -0,0 +1,343 @@
package acceptance.task;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.time.Instant;
import java.util.List;
import org.apache.ibatis.exceptions.TooManyResultsException;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.common.api.TimeInterval;
import pro.taskana.common.test.security.JaasExtension;
import pro.taskana.common.test.security.WithAccessId;
import pro.taskana.task.api.TaskCommentQuery;
import pro.taskana.task.api.TaskCommentQueryColumnName;
import pro.taskana.task.api.models.TaskComment;
/** Test for TaskComment queries. */
@ExtendWith(JaasExtension.class)
class QueryTaskCommentAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void should_FilterTaskComments_For_IdIn() {
List<TaskComment> comments =
taskService
.createTaskCommentQuery()
.idIn(
"TCI:000000000000000000000000000000000000",
"TCI:000000000000000000000000000000000002")
.list();
assertThat(comments).hasSize(2);
}
@WithAccessId(user = "admin")
@Test
void should_FilterTaskComments_For_TaskIdIn() {
List<TaskComment> comments =
taskService
.createTaskCommentQuery()
.taskIdIn("TKI:000000000000000000000000000000000000")
.list();
assertThat(comments).hasSize(3);
}
@WithAccessId(user = "admin")
@Test
void should_FilterTaskComments_For_CreatorIn() {
List<TaskComment> comments = taskService.createTaskCommentQuery().creatorIn("user-1-2").list();
assertThat(comments).hasSize(2);
}
@WithAccessId(user = "admin")
@Test
void should_FilterTaskComments_For_CreatedWithin() {
TimeInterval timeInterval = new TimeInterval(Instant.now().minusSeconds(10), Instant.now());
List<TaskComment> comments =
taskService.createTaskCommentQuery().createdWithin(timeInterval).list();
assertThat(comments).isEmpty();
}
@WithAccessId(user = "admin")
@Test
void should_FilterTaskComments_For_ModifiedWithin() {
TimeInterval timeInterval = new TimeInterval(Instant.now().minusSeconds(10), Instant.now());
List<TaskComment> comments =
taskService.createTaskCommentQuery().modifiedWithin(timeInterval).list();
assertThat(comments).isEmpty();
}
@WithAccessId(user = "admin")
@Test
void should_FilterTaskComments_For_IdNotIn() {
List<TaskComment> comments =
taskService
.createTaskCommentQuery()
.idNotIn(
"TCI:000000000000000000000000000000000000",
"TCI:000000000000000000000000000000000002")
.list();
assertThat(comments).hasSize(11);
}
@WithAccessId(user = "admin")
@Test
void should_FilterTaskComments_For_TaskIdNotIn() {
List<TaskComment> comments =
taskService
.createTaskCommentQuery()
.taskIdNotIn("TKI:000000000000000000000000000000000000")
.list();
assertThat(comments).hasSize(10);
}
@WithAccessId(user = "admin")
@Test
void should_FilterTaskComments_For_CreatorNotIn() {
List<TaskComment> comments =
taskService.createTaskCommentQuery().creatorNotIn("user-1-2").list();
assertThat(comments).hasSize(11);
}
@WithAccessId(user = "admin")
@Test
void should_FilterTaskComments_For_CreatedNotWithin() {
TimeInterval timeInterval = new TimeInterval(Instant.now().minusSeconds(10), Instant.now());
List<TaskComment> comments =
taskService.createTaskCommentQuery().createdNotWithin(timeInterval).list();
assertThat(comments).hasSize(13);
}
@WithAccessId(user = "admin")
@Test
void should_FilterTaskComments_For_ModiefiedNotWithin() {
TimeInterval timeInterval = new TimeInterval(Instant.now().minusSeconds(10), Instant.now());
List<TaskComment> comments =
taskService.createTaskCommentQuery().modifiedNotWithin(timeInterval).list();
assertThat(comments).hasSize(13);
}
@WithAccessId(user = "admin")
@Test
void should_FilterTaskComments_For_IdLike() {
List<TaskComment> comments = taskService.createTaskCommentQuery().idLike("%000001%").list();
assertThat(comments).hasSize(4);
}
@WithAccessId(user = "admin")
@Test
void should_FilterTaskComments_For_TaskIdLike() {
List<TaskComment> comments = taskService.createTaskCommentQuery().taskIdLike("%00026%").list();
assertThat(comments).hasSize(2);
}
@WithAccessId(user = "admin")
@Test
void should_FilterTaskComments_For_TextFieldLike() {
List<TaskComment> comments =
taskService.createTaskCommentQuery().textFieldLike("%other%").list();
assertThat(comments).hasSize(6);
}
@WithAccessId(user = "admin")
@Test
void should_FilterTaskComments_For_CreatorLike() {
List<TaskComment> comments = taskService.createTaskCommentQuery().creatorLike("%1-1%").list();
assertThat(comments).hasSize(10);
}
@WithAccessId(user = "admin")
@Test
void should_FilterTaskComments_For_IdNotLike() {
List<TaskComment> comments = taskService.createTaskCommentQuery().idNotLike("%000001%").list();
assertThat(comments).hasSize(9);
}
@WithAccessId(user = "admin")
@Test
void should_FilterTaskComments_For_TaskIdNotLike() {
List<TaskComment> comments =
taskService.createTaskCommentQuery().taskIdNotLike("%00026%").list();
assertThat(comments).hasSize(11);
}
@WithAccessId(user = "admin")
@Test
void should_FilterTaskComments_For_TextFieldNotLike() {
List<TaskComment> comments =
taskService.createTaskCommentQuery().textFieldNotLike("%other%").list();
assertThat(comments).hasSize(7);
}
@WithAccessId(user = "admin")
@Test
void should_FilterTaskComments_For_CreatorNotLike() {
List<TaskComment> comments =
taskService.createTaskCommentQuery().creatorNotLike("%1-1%").list();
assertThat(comments).hasSize(3);
}
@WithAccessId(user = "admin")
@Test
void should_ReturnCountOfEvents_When_UsingCountMethod() {
long count = taskService.createTaskCommentQuery().creatorIn("user-1-1").count();
assertThat(count).isEqualTo(10);
count = taskService.createTaskCommentQuery().creatorNotIn("user-1-1").count();
assertThat(count).isEqualTo(3);
count = taskService.createTaskCommentQuery().count();
assertThat(count).isEqualTo(13);
}
@WithAccessId(user = "admin")
@Test
void should_ReturnListedValues_For_QueryColumnId() {
List<String> listedValues =
taskService.createTaskCommentQuery().listValues(TaskCommentQueryColumnName.ID, null);
assertThat(listedValues).hasSize(13);
}
@WithAccessId(user = "admin")
@Test
void should_ReturnListedValues_For_QueryColumnTaskId() {
List<String> listedValues =
taskService.createTaskCommentQuery().listValues(TaskCommentQueryColumnName.TASK_ID, null);
assertThat(listedValues).hasSize(7);
}
@WithAccessId(user = "admin")
@Test
void should_ReturnListedValues_For_QueryColumnTextField() {
List<String> listedValues =
taskService
.createTaskCommentQuery()
.listValues(TaskCommentQueryColumnName.TEXT_FIELD, null);
assertThat(listedValues).hasSize(2);
}
@WithAccessId(user = "admin")
@Test
void should_ReturnListedValues_For_QueryColumnCreator() {
List<String> listedValues =
taskService.createTaskCommentQuery().listValues(TaskCommentQueryColumnName.CREATOR, null);
assertThat(listedValues).hasSize(3);
}
@WithAccessId(user = "admin")
@Test
void should_ReturnListedValues_For_QueryColumnCreatorLongName() {
taskanaEngineConfiguration.setAddAdditionalUserInfo(false);
List<String> listedValues =
taskService
.createTaskCommentQuery()
.listValues(TaskCommentQueryColumnName.CREATOR_LONG_NAME, null);
assertThat(listedValues).hasSize(3);
}
@WithAccessId(user = "admin")
@Test
void should_ReturnListedValues_For_QueryColumnCreated() {
List<String> listedValues =
taskService.createTaskCommentQuery().listValues(TaskCommentQueryColumnName.CREATED, null);
assertThat(listedValues).hasSize(5);
}
@WithAccessId(user = "admin")
@Test
void should_ReturnListedValues_For_QueryColumnModified() {
List<String> listedValues =
taskService.createTaskCommentQuery().listValues(TaskCommentQueryColumnName.MODIFIED, null);
assertThat(listedValues).hasSize(7);
}
@WithAccessId(user = "admin")
@Test
void should_ConfirmQueryListOffset_When_ProvidingOffsetAndLimit() {
List<TaskComment> offsetAndLimitResult = taskService.createTaskCommentQuery().list(1, 2);
List<TaskComment> regularResult = taskService.createTaskCommentQuery().list();
assertThat(offsetAndLimitResult).hasSize(2);
assertThat(offsetAndLimitResult.get(0).getId()).isNotEqualTo(regularResult.get(0).getId());
assertThat(offsetAndLimitResult.get(0).getId()).isEqualTo(regularResult.get(1).getId());
}
@WithAccessId(user = "admin")
@Test
void should_ReturnEmptyList_When_ProvidingWrongConstraints() {
List<TaskComment> result = taskService.createTaskCommentQuery().list(1, 1000);
assertThat(result).hasSize(12);
result = taskService.createTaskCommentQuery().list(100, 1000);
assertThat(result).isEmpty();
}
@WithAccessId(user = "admin")
@Test
void should_ReturnSingleHistoryEvent_When_UsingSingleMethod() {
TaskComment single =
taskService
.createTaskCommentQuery()
.taskIdIn("TKI:000000000000000000000000000000000000")
.creatorIn("user-1-2")
.single();
assertThat(single.getId()).isEqualTo("TCI:000000000000000000000000000000000001");
}
@WithAccessId(user = "admin")
@Test
void should_ThrowException_When_SingleMethodRetrievesMoreThanOneEventFromDatabase() {
TaskCommentQuery query = taskService.createTaskCommentQuery().creatorIn("user-1-1");
assertThatThrownBy(query::single).isInstanceOf(TooManyResultsException.class);
}
@WithAccessId(user = "admin")
@Test
void should_SetTaskCreatorFullNameOfTaskComment_When_PropertyEnabled() throws Exception {
taskanaEngineConfiguration.setAddAdditionalUserInfo(true);
List<TaskComment> taskComments =
taskService
.createTaskCommentQuery()
.idIn("TCI:000000000000000000000000000000000000")
.list();
assertThat(taskComments).hasSize(1);
String creatorFullName =
taskanaEngine.getUserService().getUser(taskComments.get(0).getCreator()).getFullName();
assertThat(taskComments.get(0))
.extracting(TaskComment::getCreatorLongName)
.isEqualTo(creatorFullName);
}
@WithAccessId(user = "user-1-1")
@Test
void should_NotSetTaskCreatorFullNameOfTaskComment_When_PropertyDisabled() {
taskanaEngineConfiguration.setAddAdditionalUserInfo(false);
List<TaskComment> taskComments =
taskService
.createTaskCommentQuery()
.idIn("TCI:000000000000000000000000000000000000")
.list();
assertThat(taskComments).hasSize(1);
assertThat(taskComments.get(0)).extracting(TaskComment::getCreatorLongName).isNull();
}
@WithAccessId(user = "admin")
@Test
void should_SetTaskCreatorFullNameOfTaskCommentToNull_When_NotExistingAsUserInDatabase() {
taskanaEngineConfiguration.setAddAdditionalUserInfo(true);
List<TaskComment> taskComments =
taskService
.createTaskCommentQuery()
.idIn("TCI:000000000000000000000000000000000008")
.list();
assertThat(taskComments).hasSize(1);
assertThat(taskComments.get(0)).extracting(TaskComment::getCreatorLongName).isNull();
}
}

319
lib/taskana-core/src/test/java/acceptance/task/QueryTasksAccTest.java
View File

@ -20,9 +20,11 @@ import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.SqlSession;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DynamicTest;
import org.junit.jupiter.api.Test;
@ -41,22 +43,21 @@ import pro.taskana.common.test.security.JaasExtension;
import pro.taskana.common.test.security.WithAccessId;
import pro.taskana.task.api.TaskCustomField;
import pro.taskana.task.api.TaskQuery;
import pro.taskana.task.api.TaskQueryColumnName;
import pro.taskana.task.api.TaskState;
import pro.taskana.task.api.models.Attachment;
import pro.taskana.task.api.models.AttachmentSummary;
import pro.taskana.task.api.models.ObjectReference;
import pro.taskana.task.api.models.Task;
import pro.taskana.task.api.models.TaskSummary;
import pro.taskana.task.internal.TaskServiceImpl;
import pro.taskana.task.internal.models.TaskImpl;
import pro.taskana.user.api.exceptions.UserNotFoundException;
import pro.taskana.workbasket.api.models.WorkbasketSummary;
/** Acceptance test for all "query tasks with sorting" scenarios. */
@ExtendWith(JaasExtension.class)
class QueryTasksAccTest extends AbstractAccTest {
private static final TaskServiceImpl TASK_SERVICE =
(TaskServiceImpl) taskanaEngine.getTaskService();
@BeforeEach
void before() throws Exception {
// required if single tests modify database
@ -64,6 +65,184 @@ class QueryTasksAccTest extends AbstractAccTest {
resetDb(false);
}
@WithAccessId(user = "user-1-1")
@Test
void should_SetOwnerLongNameOfTask_When_PropertyEnabled() throws Exception {
taskanaEngineConfiguration.setAddAdditionalUserInfo(true);
List<TaskSummary> tasks =
taskService.createTaskQuery().idIn("TKI:000000000000000000000000000000000000").list();
assertThat(tasks).hasSize(1);
String longName = taskanaEngine.getUserService().getUser(tasks.get(0).getOwner()).getLongName();
assertThat(tasks.get(0)).extracting(TaskSummary::getOwnerLongName).isEqualTo(longName);
}
@WithAccessId(user = "user-1-1")
@Test
void should_NotSetOwnerLongNameOfTask_When_PropertyDisabled() {
taskanaEngineConfiguration.setAddAdditionalUserInfo(false);
List<TaskSummary> tasks =
taskService.createTaskQuery().idIn("TKI:000000000000000000000000000000000000").list();
assertThat(tasks).hasSize(1);
assertThat(tasks.get(0)).extracting(TaskSummary::getOwnerLongName).isNull();
}
@WithAccessId(user = "user-1-2")
@Test
void should_SetOwnerLongNameOfTask_When_FilteringWithOwnerLongNameIn() {
taskanaEngineConfiguration.setAddAdditionalUserInfo(false);
String longName = "Eifrig, Elena - (user-1-2)";
List<TaskSummary> tasks = taskService.createTaskQuery().ownerLongNameIn(longName).list();
assertThat(tasks)
.hasSize(23)
.extracting(TaskSummary::getOwnerLongName)
.doesNotContainNull()
.containsOnly(longName);
}
@WithAccessId(user = "user-1-1")
@Test
void should_SetOwnerLongNameOfTask_When_FilteringWithOwnerLongNameNotIn() {
taskanaEngineConfiguration.setAddAdditionalUserInfo(false);
List<TaskSummary> tasks =
taskService
.createTaskQuery()
.idIn(
"TKI:000000000000000000000000000000000000",
"TKI:000000000000000000000000000000000027")
.ownerLongNameNotIn("Eifrig, Elena - (user-1-2)")
.list();
assertThat(tasks).hasSize(1);
assertThat(tasks.get(0))
.extracting(TaskSummary::getOwnerLongName)
.isEqualTo("Mustermann, Max - (user-1-1)");
}
@WithAccessId(user = "user-1-2")
@Test
void should_SetOwnerLongNameOfTask_When_FilteringWithOwnerLongNameLike() {
taskanaEngineConfiguration.setAddAdditionalUserInfo(false);
List<TaskSummary> tasks = taskService.createTaskQuery().ownerLongNameLike("%1-2%").list();
assertThat(tasks)
.hasSize(23)
.extracting(TaskSummary::getOwnerLongName)
.doesNotContainNull()
.containsOnly("Eifrig, Elena - (user-1-2)");
}
@WithAccessId(user = "user-1-2")
@Test
void should_SetOwnerLongNameOfTask_When_FilteringWithOwnerLongNameNotLike() throws Exception {
taskanaEngineConfiguration.setAddAdditionalUserInfo(false);
List<TaskSummary> tasks = taskService.createTaskQuery().ownerLongNameNotLike("%1-1%").list();
assertThat(tasks)
.hasSize(23)
.extracting(TaskSummary::getOwnerLongName)
.doesNotContainNull()
.containsOnly("Eifrig, Elena - (user-1-2)");
}
@WithAccessId(user = "admin")
@Test
void should_SetOwnerLongNameOfTaskToNull_When_OwnerNotExistingAsUserInDatabase() {
taskanaEngineConfiguration.setAddAdditionalUserInfo(true);
List<TaskSummary> tasks =
taskService.createTaskQuery().idIn("TKI:000000000000000000000000000000000041").list();
assertThat(tasks).hasSize(1);
ThrowingCallable call =
() -> taskanaEngine.getUserService().getUser(tasks.get(0).getOwner()).getLongName();
assertThatThrownBy(call).isInstanceOf(UserNotFoundException.class);
assertThat(tasks.get(0)).extracting(TaskSummary::getOwnerLongName).isNull();
}
@WithAccessId(user = "admin")
@Test
void should_OrderByOwnerLongName_When_QueryingTask() {
taskanaEngineConfiguration.setAddAdditionalUserInfo(false);
List<TaskSummary> tasks =
taskService
.createTaskQuery()
.stateIn(TaskState.CLAIMED)
.ownerNotIn("user-b-1")
.orderByOwnerLongName(ASCENDING)
.list();
assertThat(tasks).extracting(TaskSummary::getOwnerLongName).hasSize(17).isSorted();
tasks =
taskService
.createTaskQuery()
.stateIn(TaskState.CLAIMED)
.ownerNotIn("user-b-1")
.orderByOwnerLongName(DESCENDING)
.list();
assertThat(tasks)
.hasSize(17)
.extracting(TaskSummary::getOwnerLongName)
.isSortedAccordingTo(Comparator.reverseOrder());
}
@WithAccessId(user = "admin")
@Test
void should_ListValues_For_OwnerLongName() {
taskanaEngineConfiguration.setAddAdditionalUserInfo(false);
List<String> longNames =
taskService.createTaskQuery().listValues(TaskQueryColumnName.OWNER_LONG_NAME, ASCENDING)
.stream()
.filter(Objects::nonNull)
.collect(Collectors.toList());
assertThat(longNames)
.hasSize(2)
.isSorted()
.containsExactly("Eifrig, Elena - (user-1-2)", "Mustermann, Max - (user-1-1)");
longNames =
taskService.createTaskQuery().listValues(TaskQueryColumnName.OWNER_LONG_NAME, DESCENDING)
.stream()
.filter(Objects::nonNull)
.collect(Collectors.toList());
;
assertThat(longNames)
.hasSize(2)
.contains("Mustermann, Max - (user-1-1)", "Eifrig, Elena - (user-1-2)")
.isSortedAccordingTo(Comparator.reverseOrder());
}
@WithAccessId(user = "user-1-2")
@Test
void should_ListValuesCorrectly_When_FilteringWithOwnerLongName() {
taskanaEngineConfiguration.setAddAdditionalUserInfo(false);
String longName = "Eifrig, Elena - (user-1-2)";
List<String> listedValues =
taskService
.createTaskQuery()
.ownerLongNameIn(longName)
.orderByTaskId(null)
.listValues(TaskQueryColumnName.ID, null);
assertThat(listedValues).hasSize(23);
List<TaskSummary> query =
taskService.createTaskQuery().ownerLongNameIn(longName).orderByTaskId(null).list();
assertThat(query).hasSize(23).extracting(TaskSummary::getId).isEqualTo(listedValues);
}
@WithAccessId(user = "user-1-2")
@Test
void should_CountCorrectly_When_FilteringWithOwnerLongName() {
taskanaEngineConfiguration.setAddAdditionalUserInfo(false);
String longName = "Eifrig, Elena - (user-1-2)";
long count = taskService.createTaskQuery().ownerLongNameIn(longName).count();
assertThat(count).isEqualTo(23);
List<TaskSummary> query = taskService.createTaskQuery().ownerLongNameIn(longName).list();
assertThat(query.size()).isEqualTo(count);
}
@WithAccessId(user = "admin")
@Test
void should_SplitTaskListIntoChunksOf32000_When_AugmentingTasksAfterTaskQuery() {
@ -72,7 +251,7 @@ class QueryTasksAccTest extends AbstractAccTest {
.when(() -> CollectionUtil.partitionBasedOnSize(any(), anyInt()))
.thenCallRealMethod();
TASK_SERVICE.createTaskQuery().list();
taskService.createTaskQuery().list();
listUtilMock.verify(() -> CollectionUtil.partitionBasedOnSize(any(), eq(32000)));
}
@ -82,7 +261,7 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test
void should_ReturnCorrectResults_When_QueryingForOwnerLike() {
List<TaskSummary> results =
TASK_SERVICE.createTaskQuery().ownerLike("%a%", "%u%").orderByCreated(ASCENDING).list();
taskService.createTaskQuery().ownerLike("%a%", "%u%").orderByCreated(ASCENDING).list();
assertThat(results).hasSize(39).extracting(TaskSummary::getCreated).isSorted();
}
@ -91,7 +270,7 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test
void should_FilterOutOwner_When_OwnerNotInIsSet() {
List<TaskSummary> results =
TASK_SERVICE.createTaskQuery().ownerNotIn("user-1-1", "user-1-2").list();
taskService.createTaskQuery().ownerNotIn("user-1-1", "user-1-2").list();
assertThat(results).hasSize(3).extracting(TaskSummary::getOwner).containsOnly("user-b-1");
}
@ -99,14 +278,14 @@ class QueryTasksAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void should_ReturnCorrectResults_When_QueryingForDescription() {
List<TaskSummary> results = TASK_SERVICE.createTaskQuery().descriptionLike("Lorem%").list();
List<TaskSummary> results = taskService.createTaskQuery().descriptionLike("Lorem%").list();
assertThat(results).hasSize(7);
}
@WithAccessId(user = "admin")
@Test
void should_ReturnCorrectResults_When_QueryingForPriority() {
List<TaskSummary> results = TASK_SERVICE.createTaskQuery().priorityIn(1).list();
List<TaskSummary> results = taskService.createTaskQuery().priorityIn(1).list();
assertThat(results).hasSize(2);
}
@ -114,12 +293,12 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test
void testQueryForName() {
List<TaskSummary> results = TASK_SERVICE.createTaskQuery().nameLike("task%").list();
List<TaskSummary> results = taskService.createTaskQuery().nameLike("task%").list();
assertThat(results).hasSize(7);
String[] ids = results.stream().map(TaskSummary::getName).toArray(String[]::new);
List<TaskSummary> result2 = TASK_SERVICE.createTaskQuery().nameIn(ids).list();
List<TaskSummary> result2 = taskService.createTaskQuery().nameIn(ids).list();
assertThat(result2).hasSize(7);
}
@ -127,21 +306,21 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test
void testQueryForClassificationKey() {
List<TaskSummary> results = TASK_SERVICE.createTaskQuery().classificationKeyLike("L10%").list();
List<TaskSummary> results = taskService.createTaskQuery().classificationKeyLike("L10%").list();
assertThat(results).hasSize(78);
String[] ids =
results.stream().map(t -> t.getClassificationSummary().getKey()).toArray(String[]::new);
List<TaskSummary> result2 = TASK_SERVICE.createTaskQuery().classificationKeyIn(ids).list();
List<TaskSummary> result2 = taskService.createTaskQuery().classificationKeyIn(ids).list();
assertThat(result2).hasSize(78);
List<TaskSummary> result3 =
TASK_SERVICE.createTaskQuery().classificationKeyNotIn("T2100", "T2000").list();
taskService.createTaskQuery().classificationKeyNotIn("T2100", "T2000").list();
assertThat(result3).hasSize(83);
List<TaskSummary> result4 =
TASK_SERVICE.createTaskQuery().classificationKeyNotIn("L1050", "L1060", "T2100").list();
taskService.createTaskQuery().classificationKeyNotIn("L1050", "L1060", "T2100").list();
assertThat(result4).hasSize(10);
}
@ -162,12 +341,12 @@ class QueryTasksAccTest extends AbstractAccTest {
Instant.parse("2018-01-15T00:00:00Z"),
createSimpleCustomPropertyMap(3));
Task task = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000000");
Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
task.addAttachment(attachment);
TASK_SERVICE.updateTask(task);
taskService.updateTask(task);
List<TaskSummary> results =
TASK_SERVICE.createTaskQuery().idIn("TKI:000000000000000000000000000000000000").list();
taskService.createTaskQuery().idIn("TKI:000000000000000000000000000000000000").list();
assertThat(results).hasSize(1);
assertThat(results.get(0).getAttachmentSummaries()).hasSize(3);
@ -206,14 +385,14 @@ class QueryTasksAccTest extends AbstractAccTest {
void testQueryForCustomXLikeAndIn(
TaskCustomField customField, String[] searchArguments, int expectedResult) throws Exception {
List<TaskSummary> results =
TASK_SERVICE.createTaskQuery().customAttributeLike(customField, searchArguments).list();
taskService.createTaskQuery().customAttributeLike(customField, searchArguments).list();
assertThat(results).hasSize(expectedResult);
String[] customAttributes =
results.stream().map(t -> t.getCustomAttribute(customField)).toArray(String[]::new);
List<TaskSummary> result2 =
TASK_SERVICE.createTaskQuery().customAttributeIn(customField, customAttributes).list();
taskService.createTaskQuery().customAttributeIn(customField, customAttributes).list();
assertThat(result2).hasSize(expectedResult);
}
@ -250,14 +429,14 @@ class QueryTasksAccTest extends AbstractAccTest {
void testQueryForCustomXNotIn(
TaskCustomField customField, String[] searchArguments, int expectedCount) throws Exception {
long results =
TASK_SERVICE.createTaskQuery().customAttributeNotIn(customField, searchArguments).count();
taskService.createTaskQuery().customAttributeNotIn(customField, searchArguments).count();
assertThat(results).isEqualTo(expectedCount);
}
@WithAccessId(user = "admin")
@Test
void testQueryForCustom7WithExceptionInLike() {
assertThatThrownBy(() -> TASK_SERVICE.createTaskQuery().customAttributeLike(CUSTOM_7).list())
assertThatThrownBy(() -> taskService.createTaskQuery().customAttributeLike(CUSTOM_7).list())
.isInstanceOf(InvalidArgumentException.class);
}
@ -265,10 +444,10 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test
void testQueryForCustom7WithExceptionInIn() throws Exception {
List<TaskSummary> results =
TASK_SERVICE.createTaskQuery().customAttributeLike(CUSTOM_7, "fsdhfshk%").list();
taskService.createTaskQuery().customAttributeLike(CUSTOM_7, "fsdhfshk%").list();
assertThat(results).isEmpty();
assertThatThrownBy(() -> TASK_SERVICE.createTaskQuery().customAttributeIn(CUSTOM_7).list())
assertThatThrownBy(() -> taskService.createTaskQuery().customAttributeIn(CUSTOM_7).list())
.isInstanceOf(InvalidArgumentException.class);
}
@ -276,27 +455,27 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test
void testQueryForCustom7WithException() throws Exception {
List<TaskSummary> results =
TASK_SERVICE.createTaskQuery().customAttributeLike(CUSTOM_7, "%").list();
taskService.createTaskQuery().customAttributeLike(CUSTOM_7, "%").list();
assertThat(results).hasSize(2);
String[] ids = results.stream().map(t -> t.getCustomAttribute(CUSTOM_7)).toArray(String[]::new);
List<TaskSummary> result2 =
TASK_SERVICE.createTaskQuery().customAttributeIn(CUSTOM_7, ids).list();
taskService.createTaskQuery().customAttributeIn(CUSTOM_7, ids).list();
assertThat(result2).hasSize(2);
}
@WithAccessId(user = "admin")
@Test
void testQueryTaskByCustomAttributes() throws Exception {
Task newTask = TASK_SERVICE.newTask("USER-1-1", "DOMAIN_A");
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
newTask.setPrimaryObjRef(
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
newTask.setClassificationKey("T2100");
Map<String, String> customAttributesForCreate =
createSimpleCustomPropertyMap(20000); // about 1 Meg
newTask.setCustomAttributeMap(customAttributesForCreate);
Task createdTask = TASK_SERVICE.createTask(newTask);
Task createdTask = taskService.createTask(newTask);
assertThat(createdTask).isNotNull();
// query the task by custom attributes
@ -330,7 +509,7 @@ class QueryTasksAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void should_QueryAndCountMatch_When_CalledWithSameQuery() {
TaskQuery taskQuery = TASK_SERVICE.createTaskQuery();
TaskQuery taskQuery = taskService.createTaskQuery();
List<TaskSummary> tasks = taskQuery.nameIn("Task99", "Task01", "Widerruf").list();
long numberOfTasks = taskQuery.nameIn("Task99", "Task01", "Widerruf").count();
assertThat(tasks).hasSize((int) numberOfTasks);
@ -339,7 +518,7 @@ class QueryTasksAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testQueryAllPaged() {
TaskQuery taskQuery = TASK_SERVICE.createTaskQuery();
TaskQuery taskQuery = taskService.createTaskQuery();
long numberOfTasks = taskQuery.count();
assertThat(numberOfTasks).isEqualTo(88);
List<TaskSummary> tasks = taskQuery.orderByDue(DESCENDING).list();
@ -354,12 +533,12 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test
void should_ReturnCorrectResults_When_QueryingForReceivedWithUpperBoundTimeInterval() {
List<TaskSummary> results =
TASK_SERVICE
taskService
.createTaskQuery()
.receivedWithin(new TimeInterval(null, Instant.parse("2018-01-29T15:55:20Z")))
.list();
long resultCount =
TASK_SERVICE
taskService
.createTaskQuery()
.receivedWithin(new TimeInterval(null, Instant.parse("2018-01-29T15:55:20Z")))
.count();
@ -371,12 +550,12 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test
void should_ReturnCorrectResults_When_QueryingForReceivedWithLowerBoundTimeInterval() {
List<TaskSummary> results =
TASK_SERVICE
taskService
.createTaskQuery()
.receivedWithin(new TimeInterval(Instant.parse("2018-01-29T15:55:20Z"), null))
.list();
long resultCount =
TASK_SERVICE
taskService
.createTaskQuery()
.receivedWithin(new TimeInterval(Instant.parse("2018-01-29T15:55:20Z"), null))
.count();
@ -388,7 +567,7 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test
void should_ReturnCorrectResults_When_QueryingForReceivedWithMultipleTimeIntervals() {
long resultCount =
TASK_SERVICE
taskService
.createTaskQuery()
.receivedWithin(
new TimeInterval(null, Instant.parse("2018-01-29T15:55:20Z")),
@ -396,7 +575,7 @@ class QueryTasksAccTest extends AbstractAccTest {
.count();
long resultCount2 =
TASK_SERVICE
taskService
.createTaskQuery()
.receivedWithin(
new TimeInterval(
@ -412,21 +591,21 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test
void testQueryForCreatorIn() {
List<TaskSummary> results =
TASK_SERVICE.createTaskQuery().creatorIn("creator_user_id2", "creator_user_id3").list();
taskService.createTaskQuery().creatorIn("creator_user_id2", "creator_user_id3").list();
assertThat(results).hasSize(4);
}
@WithAccessId(user = "admin")
@Test
void testQueryForCreatorLike() {
List<TaskSummary> results = TASK_SERVICE.createTaskQuery().creatorLike("ersTeLlEr%").list();
List<TaskSummary> results = taskService.createTaskQuery().creatorLike("ersTeLlEr%").list();
assertThat(results).hasSize(3);
}
@WithAccessId(user = "admin")
@Test
void testQueryForNoteLike() {
List<TaskSummary> results = TASK_SERVICE.createTaskQuery().noteLike("Some%").list();
List<TaskSummary> results = taskService.createTaskQuery().noteLike("Some%").list();
assertThat(results).hasSize(7);
}
@ -434,7 +613,7 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test
void testQueryForClassificationCategoryIn() {
List<TaskSummary> results =
TASK_SERVICE.createTaskQuery().classificationCategoryIn("MANUAL", "AUTOMATIC").list();
taskService.createTaskQuery().classificationCategoryIn("MANUAL", "AUTOMATIC").list();
assertThat(results).hasSize(4);
}
@ -442,7 +621,7 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test
void testQueryForClassificationCategoryLike() {
List<TaskSummary> results =
TASK_SERVICE.createTaskQuery().classificationCategoryLike("AUTO%").list();
taskService.createTaskQuery().classificationCategoryLike("AUTO%").list();
assertThat(results).hasSize(1);
}
@ -450,7 +629,7 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test
void testQueryForPrimaryObjectReferenceCompanyLike() {
List<TaskSummary> results =
TASK_SERVICE.createTaskQuery().primaryObjectReferenceCompanyLike("My%").list();
taskService.createTaskQuery().primaryObjectReferenceCompanyLike("My%").list();
assertThat(results).hasSize(7);
}
@ -458,7 +637,7 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test
void testQueryForPrimaryObjectReferenceSystemLike() {
List<TaskSummary> results =
TASK_SERVICE.createTaskQuery().primaryObjectReferenceSystemLike("My%").list();
taskService.createTaskQuery().primaryObjectReferenceSystemLike("My%").list();
assertThat(results).hasSize(7);
}
@ -466,7 +645,7 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test
void testQueryForPrimaryObjectReferenceSystemInstanceLike() {
List<TaskSummary> results =
TASK_SERVICE.createTaskQuery().primaryObjectReferenceSystemInstanceLike("My%").list();
taskService.createTaskQuery().primaryObjectReferenceSystemInstanceLike("My%").list();
assertThat(results).hasSize(7);
}
@ -474,21 +653,21 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test
void testQueryForPrimaryObjectReferenceTypeLike() {
List<TaskSummary> results =
TASK_SERVICE.createTaskQuery().primaryObjectReferenceTypeLike("My%").list();
taskService.createTaskQuery().primaryObjectReferenceTypeLike("My%").list();
assertThat(results).hasSize(7);
}
@WithAccessId(user = "admin")
@Test
void testQueryForReadEquals() {
List<TaskSummary> results = TASK_SERVICE.createTaskQuery().readEquals(true).list();
List<TaskSummary> results = taskService.createTaskQuery().readEquals(true).list();
assertThat(results).hasSize(39);
}
@WithAccessId(user = "admin")
@Test
void testQueryForTransferredEquals() {
List<TaskSummary> results = TASK_SERVICE.createTaskQuery().transferredEquals(true).list();
List<TaskSummary> results = taskService.createTaskQuery().transferredEquals(true).list();
assertThat(results).hasSize(2);
}
@ -496,7 +675,7 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test
void testQueryForBusinessProcessIdIn() {
List<TaskSummary> results =
TASK_SERVICE.createTaskQuery().businessProcessIdIn("PI_0000000000003", "BPI21").list();
taskService.createTaskQuery().businessProcessIdIn("PI_0000000000003", "BPI21").list();
assertThat(results).hasSize(9);
}
@ -504,7 +683,7 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test
void testQueryForAttachmentClassificationKeyIn() {
List<TaskSummary> results =
TASK_SERVICE.createTaskQuery().attachmentClassificationKeyIn("L110102").list();
taskService.createTaskQuery().attachmentClassificationKeyIn("L110102").list();
assertThat(results).hasSize(1);
assertThat(results.get(0).getId()).isEqualTo("TKI:000000000000000000000000000000000002");
}
@ -513,7 +692,7 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test
void testQueryForAttachmentClassificationKeyLike() {
List<TaskSummary> results =
TASK_SERVICE.createTaskQuery().attachmentClassificationKeyLike("%10102").list();
taskService.createTaskQuery().attachmentClassificationKeyLike("%10102").list();
assertThat(results).hasSize(1);
assertThat(results.get(0).getId()).isEqualTo("TKI:000000000000000000000000000000000002");
}
@ -522,7 +701,7 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test
void testQueryForAttachmentClassificationIdIn() {
List<TaskSummary> results =
TASK_SERVICE
taskService
.createTaskQuery()
.attachmentClassificationIdIn("CLI:100000000000000000000000000000000002")
.list();
@ -533,7 +712,7 @@ class QueryTasksAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testQueryForAttachmentChannelLike() {
List<TaskSummary> results = TASK_SERVICE.createTaskQuery().attachmentChannelLike("%6").list();
List<TaskSummary> results = taskService.createTaskQuery().attachmentChannelLike("%6").list();
assertThat(results).hasSize(2);
}
@ -541,7 +720,7 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test
void testQueryForAttachmentReferenceIn() {
List<TaskSummary> results =
TASK_SERVICE.createTaskQuery().attachmentReferenceValueIn("val4").list();
taskService.createTaskQuery().attachmentReferenceValueIn("val4").list();
assertThat(results).hasSize(6);
assertThat(results.get(5).getAttachmentSummaries()).hasSize(1);
}
@ -552,7 +731,7 @@ class QueryTasksAccTest extends AbstractAccTest {
TimeInterval interval =
new TimeInterval(getInstant("2018-01-30T12:00:00"), getInstant("2018-01-31T12:00:00"));
List<TaskSummary> results =
TASK_SERVICE
taskService
.createTaskQuery()
.attachmentReceivedWithin(interval)
.orderByWorkbasketId(DESCENDING)
@ -565,7 +744,7 @@ class QueryTasksAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void should_ReturnOrderedResult_When_OrderByCreatorDescIsSet() {
List<TaskSummary> results = TASK_SERVICE.createTaskQuery().orderByCreator(DESCENDING).list();
List<TaskSummary> results = taskService.createTaskQuery().orderByCreator(DESCENDING).list();
assertThat(results)
.hasSizeGreaterThan(2)
@ -577,7 +756,7 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test
void should_ReturnOrderedResult_When_OrderByWorkbasketIdDescIsSet() {
List<TaskSummary> results =
TASK_SERVICE.createTaskQuery().orderByWorkbasketId(DESCENDING).list();
taskService.createTaskQuery().orderByWorkbasketId(DESCENDING).list();
assertThat(results)
.hasSizeGreaterThan(2)
@ -610,7 +789,7 @@ class QueryTasksAccTest extends AbstractAccTest {
void should_ReturnOrderedResult_When_OrderByCustomFieldInSortDirectionIsSet(
TaskCustomField customField, SortDirection sortDirection) {
List<TaskSummary> results =
TASK_SERVICE.createTaskQuery().orderByCustomAttribute(customField, sortDirection).list();
taskService.createTaskQuery().orderByCustomAttribute(customField, sortDirection).list();
Comparator<String> comparator =
sortDirection == ASCENDING ? CASE_INSENSITIVE_ORDER : CASE_INSENSITIVE_ORDER.reversed();
@ -626,7 +805,7 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test
void testQueryForOrderWithDirectionNull() {
List<TaskSummary> results =
TASK_SERVICE.createTaskQuery().orderByPrimaryObjectReferenceSystemInstance(null).list();
taskService.createTaskQuery().orderByPrimaryObjectReferenceSystemInstance(null).list();
assertThat(results)
.hasSizeGreaterThan(2)
@ -639,7 +818,7 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test
void testQueryForOrderByAttachmentClassificationIdAsc() {
List<TaskSummary> results =
TASK_SERVICE
taskService
.createTaskQuery()
.idIn(
"TKI:000000000000000000000000000000000009",
@ -661,7 +840,7 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test
void testQueryForOrderByAttachmentClassificationIdDesc() {
List<TaskSummary> results =
TASK_SERVICE
taskService
.createTaskQuery()
.idIn(
"TKI:000000000000000000000000000000000009",
@ -683,7 +862,7 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test
void testQueryForOrderByAttachmentClassificationKeyAsc() {
List<TaskSummary> results =
TASK_SERVICE
taskService
.createTaskQuery()
.idIn(
"TKI:000000000000000000000000000000000009",
@ -705,7 +884,7 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test
void testQueryForOrderByAttachmentClassificationKeyDesc() {
List<TaskSummary> results =
TASK_SERVICE
taskService
.createTaskQuery()
.idIn(
"TKI:000000000000000000000000000000000009",
@ -727,7 +906,7 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test
void testQueryForOrderByAttachmentRefValueDesc() {
List<TaskSummary> results =
TASK_SERVICE
taskService
.createTaskQuery()
.idIn(
"TKI:000000000000000000000000000000000010",
@ -748,7 +927,7 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test
void testQueryForOrderByAttachmentReceivedAsc() {
List<TaskSummary> results =
TASK_SERVICE
taskService
.createTaskQuery()
.idIn(
"TKI:000000000000000000000000000000000008",
@ -768,7 +947,7 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test
void testQueryForOrderByAttachmentReceivedDesc() {
List<TaskSummary> results =
TASK_SERVICE
taskService
.createTaskQuery()
.idIn(
"TKI:000000000000000000000000000000000008",
@ -788,7 +967,7 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test
void testQueryForOrderByAttachmentChannelAscAndReferenceDesc() {
List<TaskSummary> results =
TASK_SERVICE
taskService
.createTaskQuery()
.idIn(
"TKI:000000000000000000000000000000000009",
@ -812,7 +991,7 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test
void testQueryForAttachmentChannelLikeAndOrdering() {
List<TaskSummary> results =
TASK_SERVICE
taskService
.createTaskQuery()
.attachmentChannelLike("CH%")
.orderByClassificationKey(DESCENDING)
@ -824,7 +1003,7 @@ class QueryTasksAccTest extends AbstractAccTest {
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed());
results =
TASK_SERVICE
taskService
.createTaskQuery()
.attachmentChannelLike("CH%")
.orderByClassificationKey(ASCENDING)
@ -841,7 +1020,7 @@ class QueryTasksAccTest extends AbstractAccTest {
void testQueryForExternalIdIn() {
List<TaskSummary> results =
TASK_SERVICE
taskService
.createTaskQuery()
.externalIdIn(
"ETI:000000000000000000000000000000000010",
@ -859,7 +1038,7 @@ class QueryTasksAccTest extends AbstractAccTest {
String[] ids = results.stream().map(TaskSummary::getId).toArray(String[]::new);
List<TaskSummary> result2 = TASK_SERVICE.createTaskQuery().idIn(ids).list();
List<TaskSummary> result2 = taskService.createTaskQuery().idIn(ids).list();
assertThat(result2).hasSize(10);
}
}

25
lib/taskana-core/src/test/java/acceptance/task/QueryTasksByObjectReferenceAccTest.java
View File

@ -9,7 +9,6 @@ import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.common.test.security.JaasExtension;
import pro.taskana.common.test.security.WithAccessId;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.models.ObjectReference;
import pro.taskana.task.api.models.TaskSummary;
@ -17,13 +16,11 @@ import pro.taskana.task.api.models.TaskSummary;
@ExtendWith(JaasExtension.class)
class QueryTasksByObjectReferenceAccTest extends AbstractAccTest {
private static final TaskService TASK_SERVICE = taskanaEngine.getTaskService();
@WithAccessId(user = "admin")
@Test
void should_ApplyObjectReferenceFilter_When_ExactValueIsSet() {
List<TaskSummary> results =
TASK_SERVICE.createTaskQuery().primaryObjectReferenceValueIn("11223344", "22334455").list();
taskService.createTaskQuery().primaryObjectReferenceValueIn("11223344", "22334455").list();
assertThat(results).hasSize(33);
}
@ -33,7 +30,7 @@ class QueryTasksByObjectReferenceAccTest extends AbstractAccTest {
ObjectReference objectReference = new ObjectReference();
objectReference.setValue("11223344");
List<TaskSummary> results =
TASK_SERVICE.createTaskQuery().primaryObjectReferenceIn(objectReference).list();
taskService.createTaskQuery().primaryObjectReferenceIn(objectReference).list();
assertThat(results).hasSize(21);
}
@ -43,7 +40,7 @@ class QueryTasksByObjectReferenceAccTest extends AbstractAccTest {
ObjectReference objectReference = new ObjectReference();
objectReference.setType("SDNR");
List<TaskSummary> results =
TASK_SERVICE.createTaskQuery().primaryObjectReferenceIn(objectReference).list();
taskService.createTaskQuery().primaryObjectReferenceIn(objectReference).list();
assertThat(results).hasSize(46);
}
@ -53,7 +50,7 @@ class QueryTasksByObjectReferenceAccTest extends AbstractAccTest {
ObjectReference objectReference = new ObjectReference();
objectReference.setCompany("MyCompany1");
List<TaskSummary> results =
TASK_SERVICE.createTaskQuery().primaryObjectReferenceIn(objectReference).list();
taskService.createTaskQuery().primaryObjectReferenceIn(objectReference).list();
assertThat(results).hasSize(7);
}
@ -63,7 +60,7 @@ class QueryTasksByObjectReferenceAccTest extends AbstractAccTest {
ObjectReference objectReference = new ObjectReference();
objectReference.setSystem("MySystem1");
List<TaskSummary> results =
TASK_SERVICE.createTaskQuery().primaryObjectReferenceIn(objectReference).list();
taskService.createTaskQuery().primaryObjectReferenceIn(objectReference).list();
assertThat(results).hasSize(7);
}
@ -73,7 +70,7 @@ class QueryTasksByObjectReferenceAccTest extends AbstractAccTest {
ObjectReference objectReference = new ObjectReference();
objectReference.setSystemInstance("MyInstance1");
List<TaskSummary> results =
TASK_SERVICE.createTaskQuery().primaryObjectReferenceIn(objectReference).list();
taskService.createTaskQuery().primaryObjectReferenceIn(objectReference).list();
assertThat(results).hasSize(7);
}
@ -85,7 +82,7 @@ class QueryTasksByObjectReferenceAccTest extends AbstractAccTest {
ObjectReference objectReference1 = new ObjectReference();
objectReference1.setValue("11223344");
List<TaskSummary> results =
TASK_SERVICE
taskService
.createTaskQuery()
.primaryObjectReferenceIn(objectReference, objectReference1)
.list();
@ -102,7 +99,7 @@ class QueryTasksByObjectReferenceAccTest extends AbstractAccTest {
objectReference.setType("VNR");
objectReference.setValue("67890123");
List<TaskSummary> results =
TASK_SERVICE.createTaskQuery().primaryObjectReferenceIn(objectReference).list();
taskService.createTaskQuery().primaryObjectReferenceIn(objectReference).list();
assertThat(results).hasSize(1);
}
@ -115,7 +112,7 @@ class QueryTasksByObjectReferenceAccTest extends AbstractAccTest {
objectReference.setSystemInstance("00");
objectReference.setType("VNR");
objectReference.setValue("67890123");
long count = TASK_SERVICE.createTaskQuery().primaryObjectReferenceIn(objectReference).count();
long count = taskService.createTaskQuery().primaryObjectReferenceIn(objectReference).count();
assertThat(count).isEqualTo(1);
}
@ -123,7 +120,7 @@ class QueryTasksByObjectReferenceAccTest extends AbstractAccTest {
@Test
void should_ApplyObjectReferenceFilter_When_ExactValueAndTypeAreSet() {
List<TaskSummary> results =
TASK_SERVICE
taskService
.createTaskQuery()
.primaryObjectReferenceTypeIn("SDNR")
.primaryObjectReferenceValueIn("11223344")
@ -135,7 +132,7 @@ class QueryTasksByObjectReferenceAccTest extends AbstractAccTest {
@Test
void should_ApplyObjectReferenceFilter_When_ValueLikeIsSet() {
List<TaskSummary> results =
TASK_SERVICE.createTaskQuery().primaryObjectReferenceValueLike("%567%").list();
taskService.createTaskQuery().primaryObjectReferenceValueLike("%567%").list();
assertThat(results).hasSize(10);
}
}

14
lib/taskana-core/src/test/java/acceptance/task/QueryTasksByWildcardSearchAccTest.java
View File

@ -12,13 +12,11 @@ import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.common.api.BaseQuery.SortDirection;
import pro.taskana.common.test.security.JaasExtension;
import pro.taskana.common.test.security.WithAccessId;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.WildcardSearchField;
import pro.taskana.task.api.models.TaskSummary;
@ExtendWith(JaasExtension.class)
class QueryTasksByWildcardSearchAccTest extends AbstractAccTest {
private static final TaskService TASK_SERVICE = taskanaEngine.getTaskService();
@WithAccessId(user = "admin")
@Test
@ -28,7 +26,7 @@ class QueryTasksByWildcardSearchAccTest extends AbstractAccTest {
};
List<TaskSummary> foundTasks =
TASK_SERVICE
taskService
.createTaskQuery()
.wildcardSearchFieldsIn(wildcards)
.wildcardSearchValueLike("%99%")
@ -46,7 +44,7 @@ class QueryTasksByWildcardSearchAccTest extends AbstractAccTest {
};
long foundTasks =
TASK_SERVICE
taskService
.createTaskQuery()
.wildcardSearchFieldsIn(wildcards)
.wildcardSearchValueLike("%99%")
@ -62,14 +60,14 @@ class QueryTasksByWildcardSearchAccTest extends AbstractAccTest {
WildcardSearchField[] wildcards = {WildcardSearchField.NAME};
List<TaskSummary> foundTasksCaseSensitive =
TASK_SERVICE
taskService
.createTaskQuery()
.wildcardSearchFieldsIn(wildcards)
.wildcardSearchValueLike("%Wid%")
.list();
List<TaskSummary> foundTasksCaseInsensitive =
TASK_SERVICE
taskService
.createTaskQuery()
.wildcardSearchFieldsIn(wildcards)
.wildcardSearchValueLike("%wid%")
@ -85,7 +83,7 @@ class QueryTasksByWildcardSearchAccTest extends AbstractAccTest {
ThrowingCallable queryAttempt =
() ->
TASK_SERVICE
taskService
.createTaskQuery()
.wildcardSearchValueLike("%99%")
.orderByName(SortDirection.ASCENDING)
@ -95,7 +93,7 @@ class QueryTasksByWildcardSearchAccTest extends AbstractAccTest {
queryAttempt =
() ->
TASK_SERVICE
taskService
.createTaskQuery()
.wildcardSearchFieldsIn(
WildcardSearchField.CUSTOM_1, WildcardSearchField.DESCRIPTION)

22
lib/taskana-core/src/test/java/acceptance/task/QueryTasksListValuesAccTest.java
View File

@ -22,15 +22,11 @@ import pro.taskana.common.api.KeyDomain;
import pro.taskana.common.test.security.JaasExtension;
import pro.taskana.common.test.security.WithAccessId;
import pro.taskana.task.api.TaskQueryColumnName;
import pro.taskana.task.internal.TaskServiceImpl;
/** Acceptance test for listing the column values within a workbasket. */
@ExtendWith(JaasExtension.class)
class QueryTasksListValuesAccTest extends AbstractAccTest {
private static final TaskServiceImpl TASK_SERVICE =
(TaskServiceImpl) taskanaEngine.getTaskService();
@WithAccessId(user = "admin")
@Test
void should_ReturnColumnValues_When_ListValuesForColumnIsInvoked() {
@ -40,7 +36,7 @@ class QueryTasksListValuesAccTest extends AbstractAccTest {
columnName ->
softly
.assertThatCode(
() -> TASK_SERVICE.createTaskQuery().listValues(columnName, ASCENDING))
() -> taskService.createTaskQuery().listValues(columnName, ASCENDING))
.describedAs("Column is not working " + columnName)
.doesNotThrowAnyException());
softly.assertAll();
@ -50,7 +46,7 @@ class QueryTasksListValuesAccTest extends AbstractAccTest {
@Test
void should_ReturnOwnerValues_When_ListValuesForOwnerIsInvoked() {
List<String> columnValueList =
TASK_SERVICE
taskService
.createTaskQuery()
.ownerLike("%user%")
.orderByOwner(DESCENDING)
@ -61,7 +57,7 @@ class QueryTasksListValuesAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void should_ReturnStateValues_When_ListValuesForStateIsInvoked() {
List<String> columnValueList = TASK_SERVICE.createTaskQuery().listValues(STATE, null);
List<String> columnValueList = taskService.createTaskQuery().listValues(STATE, null);
assertThat(columnValueList).hasSize(5);
}
@ -69,28 +65,28 @@ class QueryTasksListValuesAccTest extends AbstractAccTest {
@Test
void should_ReturnAttachmentColumnValues_When_ListValuesForAttachmentColumnsIsInvoked() {
List<String> columnValueList =
TASK_SERVICE
taskService
.createTaskQuery()
.attachmentReferenceValueIn("val4")
.listValues(A_CHANNEL, null);
assertThat(columnValueList).hasSize(2);
columnValueList =
TASK_SERVICE
taskService
.createTaskQuery()
.attachmentReferenceValueLike("%")
.listValues(A_REF_VALUE, null);
assertThat(columnValueList).hasSize(6);
columnValueList =
TASK_SERVICE
taskService
.createTaskQuery()
.orderByAttachmentClassificationId(DESCENDING)
.listValues(A_CLASSIFICATION_ID, null);
assertThat(columnValueList).hasSize(11);
columnValueList =
TASK_SERVICE
taskService
.createTaskQuery()
.orderByClassificationKey(DESCENDING)
.listValues(CLASSIFICATION_KEY, null);
@ -102,7 +98,7 @@ class QueryTasksListValuesAccTest extends AbstractAccTest {
void should_ReturnPorTypes_When_QueryingForListOfPorTypesForWorkbasket() {
KeyDomain keyDomain = new KeyDomain("GPK_KSC", "DOMAIN_A");
List<String> porTypes =
TASK_SERVICE
taskService
.createTaskQuery()
.workbasketKeyDomainIn(keyDomain)
.primaryObjectReferenceCompanyIn("00", "11")
@ -115,7 +111,7 @@ class QueryTasksListValuesAccTest extends AbstractAccTest {
void should_ReturnAttachmentClassificationNames_When_QueryingForListNames() {
KeyDomain keyDomain = new KeyDomain("GPK_KSC", "DOMAIN_A");
List<String> attachmentClassificationNames =
TASK_SERVICE
taskService
.createTaskQuery()
.workbasketKeyDomainIn(keyDomain)
.listValues(TaskQueryColumnName.A_CLASSIFICATION_NAME, SortDirection.ASCENDING);

2
lib/taskana-core/src/test/java/acceptance/task/ServiceLevelOfAllTasksAccTest.java
View File

@ -15,14 +15,12 @@ import pro.taskana.common.api.BulkOperationResults;
import pro.taskana.common.api.exceptions.TaskanaException;
import pro.taskana.common.test.security.JaasExtension;
import pro.taskana.common.test.security.WithAccessId;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.models.Task;
import pro.taskana.task.api.models.TaskSummary;
/** Acceptance test for planned and prio of all tasks. */
@ExtendWith(JaasExtension.class)
class ServiceLevelOfAllTasksAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
@WithAccessId(user = "admin")
@Test

2
lib/taskana-core/src/test/java/acceptance/task/ServiceLevelPriorityAccTest.java
View File

@ -34,12 +34,10 @@ import pro.taskana.task.api.models.Task;
@ExtendWith(JaasExtension.class)
class ServiceLevelPriorityAccTest extends AbstractAccTest {
private final TaskService taskService;
private final ClassificationService classificationService;
private final WorkingDaysToDaysConverter converter;
ServiceLevelPriorityAccTest() {
taskService = taskanaEngine.getTaskService();
classificationService = taskanaEngine.getClassificationService();
converter = taskanaEngine.getWorkingDaysToDaysConverter();
}

8
lib/taskana-core/src/test/java/acceptance/task/TerminateTaskAccTest.java
View File

@ -6,7 +6,6 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.util.List;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestTemplate;
@ -15,7 +14,6 @@ import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.test.security.JaasExtension;
import pro.taskana.common.test.security.WithAccessId;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.TaskState;
import pro.taskana.task.api.exceptions.InvalidStateException;
import pro.taskana.task.api.models.TaskSummary;
@ -23,18 +21,12 @@ import pro.taskana.task.api.models.TaskSummary;
/** Acceptance tests for "terminate task" scenarios. */
@ExtendWith(JaasExtension.class)
class TerminateTaskAccTest extends AbstractAccTest {
private static TaskService taskService;
@BeforeEach
void setupIndividualTest() throws Exception {
resetDb(false);
}
@BeforeAll
static void setup() {
taskService = taskanaEngine.getTaskService();
}
@WithAccessId(user = "user-1-2")
@Test
void should_ReturnAllTerminatedTasks_When_QueryTerminatedState() {

97
lib/taskana-core/src/test/java/acceptance/task/TransferTaskAccTest.java
View File

@ -21,7 +21,6 @@ import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.api.exceptions.TaskanaException;
import pro.taskana.common.test.security.JaasExtension;
import pro.taskana.common.test.security.WithAccessId;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.TaskState;
import pro.taskana.task.api.exceptions.InvalidStateException;
import pro.taskana.task.api.exceptions.InvalidTaskStateException;
@ -36,18 +35,16 @@ import pro.taskana.workbasket.api.models.Workbasket;
@ExtendWith(JaasExtension.class)
class TransferTaskAccTest extends AbstractAccTest {
private static final TaskService TASK_SERVICE = taskanaEngine.getTaskService();
@WithAccessId(user = "teamlead-1", groups = GROUP_1_DN)
@Test
void should_TransferTaskToWorkbasket_When_WorkbasketIdIsProvided() throws Exception {
Task task = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000003");
TASK_SERVICE.claim(task.getId());
TASK_SERVICE.setTaskRead(task.getId(), true);
Task task = taskService.getTask("TKI:000000000000000000000000000000000003");
taskService.claim(task.getId());
taskService.setTaskRead(task.getId(), true);
TASK_SERVICE.transfer(task.getId(), "WBI:100000000000000000000000000000000006");
taskService.transfer(task.getId(), "WBI:100000000000000000000000000000000006");
Task transferredTask = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000003");
Task transferredTask = taskService.getTask("TKI:000000000000000000000000000000000003");
assertThat(transferredTask).isNotNull();
assertThat(transferredTask.isTransferred()).isTrue();
assertThat(transferredTask.isRead()).isFalse();
@ -59,13 +56,13 @@ class TransferTaskAccTest extends AbstractAccTest {
@TestTemplate
void should_TransferTask_When_NoExplicitPermissionsButUserIsInAdministrativeRole()
throws Exception {
Task task = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000003");
TASK_SERVICE.claim(task.getId());
TASK_SERVICE.setTaskRead(task.getId(), true);
Task task = taskService.getTask("TKI:000000000000000000000000000000000003");
taskService.claim(task.getId());
taskService.setTaskRead(task.getId(), true);
TASK_SERVICE.transfer(task.getId(), "WBI:100000000000000000000000000000000006");
taskService.transfer(task.getId(), "WBI:100000000000000000000000000000000006");
Task transferredTask = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000003");
Task transferredTask = taskService.getTask("TKI:000000000000000000000000000000000003");
assertThat(transferredTask).isNotNull();
assertThat(transferredTask.isTransferred()).isTrue();
assertThat(transferredTask.isRead()).isFalse();
@ -75,13 +72,13 @@ class TransferTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "teamlead-1", groups = GROUP_1_DN)
@Test
void should_TransferTaskToWorkbasket_When_WorkbasketKeyAndDomainIsProvided() throws Exception {
Task task = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000003");
TASK_SERVICE.claim(task.getId());
TASK_SERVICE.setTaskRead(task.getId(), true);
Task task = taskService.getTask("TKI:000000000000000000000000000000000003");
taskService.claim(task.getId());
taskService.setTaskRead(task.getId(), true);
TASK_SERVICE.transfer(task.getId(), "USER-1-1", "DOMAIN_A");
taskService.transfer(task.getId(), "USER-1-1", "DOMAIN_A");
Task transferredTask = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000003");
Task transferredTask = taskService.getTask("TKI:000000000000000000000000000000000003");
assertThat(transferredTask).isNotNull();
assertThat(transferredTask.isTransferred()).isTrue();
assertThat(transferredTask.isRead()).isFalse();
@ -91,10 +88,10 @@ class TransferTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1", groups = GROUP_1_DN)
@Test
void should_ChangeDomain_When_TransferringTaskToWorkbasketWithDifferentDomain() throws Exception {
Task task = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000000");
Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
String domain1 = task.getDomain();
Task transferredTask = TASK_SERVICE.transfer(task.getId(), "GPK_B_KSC_1", "DOMAIN_B");
Task transferredTask = taskService.transfer(task.getId(), "GPK_B_KSC_1", "DOMAIN_B");
assertThat(transferredTask).isNotNull();
assertThat(transferredTask.getDomain()).isNotEqualTo(domain1);
@ -103,21 +100,21 @@ class TransferTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_ThrowException_When_UserHasNoTransferAuthorization() throws Exception {
Task task = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000001");
Task task = taskService.getTask("TKI:000000000000000000000000000000000001");
ThrowingCallable call =
() -> TASK_SERVICE.transfer(task.getId(), "WBI:100000000000000000000000000000000005");
() -> taskService.transfer(task.getId(), "WBI:100000000000000000000000000000000005");
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(user = "teamlead-1", groups = GROUP_1_DN)
@Test
void should_ThrowException_When_DestinationWorkbasketDoesNotExist() throws Exception {
Task task = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000003");
TASK_SERVICE.claim(task.getId());
TASK_SERVICE.setTaskRead(task.getId(), true);
Task task = taskService.getTask("TKI:000000000000000000000000000000000003");
taskService.claim(task.getId());
taskService.setTaskRead(task.getId(), true);
ThrowingCallable call = () -> TASK_SERVICE.transfer(task.getId(), "INVALID");
ThrowingCallable call = () -> taskService.transfer(task.getId(), "INVALID");
assertThatThrownBy(call).isInstanceOf(WorkbasketNotFoundException.class);
}
@ -125,7 +122,7 @@ class TransferTaskAccTest extends AbstractAccTest {
@Test
void should_ThrowException_When_TaskToTransferDoesNotExist() {
ThrowingCallable call =
() -> TASK_SERVICE.transfer("Invalid", "WBI:100000000000000000000000000000000005");
() -> taskService.transfer("Invalid", "WBI:100000000000000000000000000000000005");
assertThatThrownBy(call).isInstanceOf(TaskNotFoundException.class);
}
@ -134,7 +131,7 @@ class TransferTaskAccTest extends AbstractAccTest {
void should_ThrowException_When_TransferWithNoTransferAuthorization() {
ThrowingCallable call =
() ->
TASK_SERVICE.transfer(
taskService.transfer(
"TKI:200000000000000000000000000000000007",
"WBI:100000000000000000000000000000000001");
assertThatThrownBy(call)
@ -149,10 +146,10 @@ class TransferTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1", groups = GROUP_1_DN)
@Test
void should_ThrowException_When_TransferWithNoAppendAuthorization() throws Exception {
Task task = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000002");
Task task = taskService.getTask("TKI:000000000000000000000000000000000002");
ThrowingCallable call =
() -> TASK_SERVICE.transfer(task.getId(), "WBI:100000000000000000000000000000000008");
() -> taskService.transfer(task.getId(), "WBI:100000000000000000000000000000000008");
assertThatThrownBy(call)
.isInstanceOf(NotAuthorizedException.class)
.extracting(Throwable::getMessage)
@ -165,10 +162,10 @@ class TransferTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "teamlead-1")
@Test
void should_ThrowException_When_TaskToTransferIsAlreadyCompleted() throws Exception {
Task task = TASK_SERVICE.getTask("TKI:100000000000000000000000000000000006");
Task task = taskService.getTask("TKI:100000000000000000000000000000000006");
ThrowingCallable call =
() -> TASK_SERVICE.transfer(task.getId(), "WBI:100000000000000000000000000000000005");
() -> taskService.transfer(task.getId(), "WBI:100000000000000000000000000000000005");
assertThatThrownBy(call).isInstanceOf(InvalidStateException.class);
}
@ -181,12 +178,12 @@ class TransferTaskAccTest extends AbstractAccTest {
"TKI:000000000000000000000000000000000004", "TKI:000000000000000000000000000000000005");
BulkOperationResults<String, TaskanaException> results =
TASK_SERVICE.transferTasks("WBI:100000000000000000000000000000000006", taskIdList);
taskService.transferTasks("WBI:100000000000000000000000000000000006", taskIdList);
assertThat(results.containsErrors()).isFalse();
final Workbasket wb =
taskanaEngine.getWorkbasketService().getWorkbasket("USER-1-1", "DOMAIN_A");
Task transferredTask = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000004");
Task transferredTask = taskService.getTask("TKI:000000000000000000000000000000000004");
assertThat(transferredTask).isNotNull();
assertThat(transferredTask.isTransferred()).isTrue();
assertThat(transferredTask.isRead()).isFalse();
@ -195,7 +192,7 @@ class TransferTaskAccTest extends AbstractAccTest {
assertThat(transferredTask.getDomain()).isEqualTo(wb.getDomain());
assertThat(transferredTask.getModified().isBefore(before)).isFalse();
assertThat(transferredTask.getOwner()).isNull();
transferredTask = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000005");
transferredTask = taskService.getTask("TKI:000000000000000000000000000000000005");
assertThat(transferredTask).isNotNull();
assertThat(transferredTask.isTransferred()).isTrue();
assertThat(transferredTask.isRead()).isFalse();
@ -226,7 +223,7 @@ class TransferTaskAccTest extends AbstractAccTest {
"TKI:100000000000000000000000000000000006"); // already completed
BulkOperationResults<String, TaskanaException> results =
TASK_SERVICE.transferTasks("WBI:100000000000000000000000000000000006", taskIdList);
taskService.transferTasks("WBI:100000000000000000000000000000000006", taskIdList);
// check for exceptions in bulk
assertThat(results.containsErrors()).isTrue();
assertThat(results.getErrorMap().values()).hasSize(6);
@ -242,7 +239,7 @@ class TransferTaskAccTest extends AbstractAccTest {
assertThat(results.getErrorForId(null).getClass()).isEqualTo(InvalidArgumentException.class);
// verify valid requests
Task transferredTask = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000006");
Task transferredTask = taskService.getTask("TKI:000000000000000000000000000000000006");
assertThat(transferredTask).isNotNull();
assertThat(transferredTask.isTransferred()).isTrue();
assertThat(transferredTask.isRead()).isFalse();
@ -252,12 +249,12 @@ class TransferTaskAccTest extends AbstractAccTest {
assertThat(transferredTask.getModified().isBefore(before)).isFalse();
assertThat(transferredTask.getOwner()).isNull();
transferredTask = TASK_SERVICE.getTask("TKI:200000000000000000000000000000000008");
transferredTask = taskService.getTask("TKI:200000000000000000000000000000000008");
assertThat(transferredTask).isNotNull();
assertThat(transferredTask.isTransferred()).isFalse();
assertThat(transferredTask.getWorkbasketKey()).isEqualTo("TPK_VIP");
transferredTask = TASK_SERVICE.getTask("TKI:100000000000000000000000000000000006");
transferredTask = taskService.getTask("TKI:100000000000000000000000000000000006");
assertThat(transferredTask).isNotNull();
assertThat(transferredTask.isTransferred()).isFalse();
assertThat(transferredTask.getWorkbasketKey()).isEqualTo("TEAMLEAD-1");
@ -273,7 +270,7 @@ class TransferTaskAccTest extends AbstractAccTest {
"TKI:000000000000000000000000000000000041"); // NotAuthorized READ
ThrowingCallable call =
() -> TASK_SERVICE.transferTasks("WBI:100000000000000000000000000000000010", taskIdList);
() -> taskService.transferTasks("WBI:100000000000000000000000000000000010", taskIdList);
assertThatThrownBy(call)
.isInstanceOf(NotAuthorizedException.class)
.hasMessageContaining("APPEND");
@ -285,7 +282,7 @@ class TransferTaskAccTest extends AbstractAccTest {
List<String> taskIds = List.of("TKI:000000000000000000000000000000000006");
ThrowingCallable call =
() -> TASK_SERVICE.transferTasks("WBI:100000000000000000000000000000000006", taskIds);
() -> taskService.transferTasks("WBI:100000000000000000000000000000000006", taskIds);
assertThatCode(call).doesNotThrowAnyException();
}
@ -294,7 +291,7 @@ class TransferTaskAccTest extends AbstractAccTest {
@Test
void should_ThrowException_When_TransferredTaskListIsNull() {
ThrowingCallable call =
() -> TASK_SERVICE.transferTasks("WBI:100000000000000000000000000000000006", null);
() -> taskService.transferTasks("WBI:100000000000000000000000000000000006", null);
assertThatThrownBy(call)
.isInstanceOf(InvalidArgumentException.class)
.hasMessage("TaskIds must not be null or empty.");
@ -305,7 +302,7 @@ class TransferTaskAccTest extends AbstractAccTest {
void should_ThrowException_When_TransferringEmptyTaskIdList() {
ThrowingCallable call =
() ->
TASK_SERVICE.transferTasks(
taskService.transferTasks(
"WBI:100000000000000000000000000000000006", Collections.emptyList());
assertThatThrownBy(call).isInstanceOf(InvalidArgumentException.class);
}
@ -319,12 +316,12 @@ class TransferTaskAccTest extends AbstractAccTest {
"TKI:000000000000000000000000000000000023", "TKI:000000000000000000000000000000000024");
BulkOperationResults<String, TaskanaException> results =
TASK_SERVICE.transferTasks("GPK_B_KSC_1", "DOMAIN_B", taskIdList);
taskService.transferTasks("GPK_B_KSC_1", "DOMAIN_B", taskIdList);
assertThat(results.containsErrors()).isFalse();
final Workbasket wb =
taskanaEngine.getWorkbasketService().getWorkbasket("GPK_B_KSC_1", "DOMAIN_B");
Task transferredTask = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000023");
Task transferredTask = taskService.getTask("TKI:000000000000000000000000000000000023");
assertThat(transferredTask).isNotNull();
assertThat(transferredTask.isTransferred()).isTrue();
assertThat(transferredTask.isRead()).isFalse();
@ -333,7 +330,7 @@ class TransferTaskAccTest extends AbstractAccTest {
assertThat(transferredTask.getDomain()).isEqualTo(wb.getDomain());
assertThat(transferredTask.getModified().isBefore(before)).isFalse();
assertThat(transferredTask.getOwner()).isNull();
transferredTask = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000024");
transferredTask = taskService.getTask("TKI:000000000000000000000000000000000024");
assertThat(transferredTask).isNotNull();
assertThat(transferredTask.isTransferred()).isTrue();
assertThat(transferredTask.isRead()).isFalse();
@ -347,12 +344,12 @@ class TransferTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void should_NotSetTheTransferFlag_When_SetTransferFlagNotRequested() throws Exception {
TASK_SERVICE.transfer(
taskService.transfer(
"TKI:000000000000000000000000000000000003",
"WBI:100000000000000000000000000000000006",
false);
Task transferredTask = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000003");
Task transferredTask = taskService.getTask("TKI:000000000000000000000000000000000003");
assertThat(transferredTask).isNotNull();
assertThat(transferredTask.isTransferred()).isFalse();
}
@ -361,7 +358,7 @@ class TransferTaskAccTest extends AbstractAccTest {
@Test
void should_NotSetTheTransferFlagWithinBulkTransfer_When_SetTransferFlagNotRequested()
throws Exception {
TASK_SERVICE.transferTasks(
taskService.transferTasks(
"WBI:100000000000000000000000000000000006",
List.of(
"TKI:000000000000000000000000000000000003",
@ -370,7 +367,7 @@ class TransferTaskAccTest extends AbstractAccTest {
false);
List<TaskSummary> transferredTasks =
TASK_SERVICE
taskService
.createTaskQuery()
.idIn(
"TKI:000000000000000000000000000000000004",

3
lib/taskana-core/src/test/java/acceptance/task/UpdateTaskAccTest.java
View File

@ -29,7 +29,6 @@ import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.test.security.JaasExtension;
import pro.taskana.common.test.security.WithAccessId;
import pro.taskana.task.api.TaskCustomField;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.TaskState;
import pro.taskana.task.api.exceptions.TaskNotFoundException;
import pro.taskana.task.api.models.ObjectReference;
@ -41,8 +40,6 @@ import pro.taskana.task.internal.models.TaskImpl;
@ExtendWith(JaasExtension.class)
class UpdateTaskAccTest extends AbstractAccTest {
private final TaskService taskService = taskanaEngine.getTaskService();
@WithAccessId(user = "user-1-1")
@Test
void should_UpdatePrimaryObjectReferenceOfTask_When_Requested() throws Exception {

2
lib/taskana-core/src/test/java/acceptance/task/UpdateTaskAttachmentsAccTest.java
View File

@ -39,14 +39,12 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
private Task task;
private Attachment attachment;
private TaskService taskService;
private ClassificationService classificationService;
@BeforeEach
@WithAccessId(user = "admin")
void setUp() throws Exception {
resetDb(false);
taskService = taskanaEngine.getTaskService();
classificationService = taskanaEngine.getClassificationService();
task =
taskService.getTask(

4
lib/taskana-core/src/test/java/acceptance/workbasket/DeleteWorkbasketAccTest.java
View File

@ -15,7 +15,6 @@ import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.test.security.JaasExtension;
import pro.taskana.common.test.security.WithAccessId;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.internal.models.TaskImpl;
import pro.taskana.workbasket.api.WorkbasketPermission;
import pro.taskana.workbasket.api.WorkbasketService;
@ -30,12 +29,9 @@ class DeleteWorkbasketAccTest extends AbstractAccTest {
private WorkbasketService workbasketService;
private TaskService taskService;
@BeforeEach
void setUpMethod() {
workbasketService = taskanaEngine.getWorkbasketService();
taskService = taskanaEngine.getTaskService();
}
@WithAccessId(user = "businessadmin")

1
lib/taskana-core/src/test/resources/taskana.properties
View File

@ -16,4 +16,5 @@ taskana.german.holidays.enabled=true
taskana.german.holidays.corpus-christi.enabled=false
taskana.history.deletion.on.task.deletion.enabled=true
taskana.validation.allowTimestampServiceLevelMismatch=false
taskana.query.includeLongName=false

101
rest/taskana-rest-spring/src/main/java/pro/taskana/task/rest/TaskCommentController.java
View File

@ -1,8 +1,9 @@
package pro.taskana.task.rest;
import java.util.Comparator;
import java.beans.ConstructorProperties;
import java.util.List;
import java.util.Optional;
import java.util.function.BiConsumer;
import javax.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.hateoas.config.EnableHypermediaSupport;
import org.springframework.hateoas.config.EnableHypermediaSupport.HypermediaType;
@ -15,15 +16,18 @@ import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import pro.taskana.common.api.BaseQuery.SortDirection;
import pro.taskana.common.api.exceptions.ConcurrencyException;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.rest.QueryPagingParameter;
import pro.taskana.common.rest.QuerySortBy;
import pro.taskana.common.rest.QuerySortParameter;
import pro.taskana.common.rest.RestEndpoints;
import pro.taskana.common.rest.util.QueryParamsValidator;
import pro.taskana.task.api.TaskCommentQuery;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.exceptions.TaskCommentNotFoundException;
import pro.taskana.task.api.exceptions.TaskNotFoundException;
@ -77,30 +81,35 @@ public class TaskCommentController {
* This endpoint retrieves all Task Comments for a specific Task. Further filters can be applied.
*
* @param taskId the Id of the Task whose comments are requested
* @param sortBy Sort the result by a given field. Multiple sort values can be declared. When the
* primary sort value is the same, the second one will be used.
* @param order The order direction for each sort value. This value requires the use of 'sort-by'.
* The amount of sort-by and order declarations have to match. Alternatively the value can be
* omitted. In this case the default sort order (ASCENDING) will be applied to every sort-by
* value.
* @param request the HTTP request
* @param filterParameter the filter parameters
* @param sortParameter the sort parameters
* @param pagingParameter the paging parameters
* @return a list of Task Comments
* @throws NotAuthorizedException If the current user has no authorization to retrieve a Task
* Comment from a certain Task or is not authorized to access the Task.
* @throws TaskNotFoundException If the given Task Id in the Task Comment does not refer to an
* existing Task
* @throws InvalidArgumentException if some parameters were not supplied correctly
* @title Get a list of all Task Comments for a specific Task
*/
@GetMapping(path = RestEndpoints.URL_TASK_COMMENTS)
@Transactional(readOnly = true, rollbackFor = Exception.class)
public ResponseEntity<TaskCommentCollectionRepresentationModel> getTaskComments(
@PathVariable String taskId,
@RequestParam(name = "sort-by", required = false) List<TaskCommentsSortBy> sortBy,
@RequestParam(required = false) List<SortDirection> order)
throws NotAuthorizedException, TaskNotFoundException, InvalidArgumentException {
Optional<Comparator<TaskComment>> comparator = getTaskCommentComparator(sortBy, order);
List<TaskComment> taskComments = taskService.getTaskComments(taskId);
comparator.ifPresent(taskComments::sort);
HttpServletRequest request,
TaskCommentQueryFilterParameter filterParameter,
TaskCommentQuerySortParameter sortParameter,
QueryPagingParameter<TaskComment, TaskCommentQuery> pagingParameter) {
QueryParamsValidator.validateParams(
request,
TaskCommentQueryFilterParameter.class,
QuerySortParameter.class,
QueryPagingParameter.class);
TaskCommentQuery query = taskService.createTaskCommentQuery();
query.taskIdIn(taskId);
filterParameter.apply(query);
sortParameter.apply(query);
List<TaskComment> taskComments = pagingParameter.apply(query);
TaskCommentCollectionRepresentationModel taskCommentListResource =
taskCommentRepresentationModelAssembler.toTaskanaCollectionModel(taskComments);
@ -195,36 +204,36 @@ public class TaskCommentController {
.body(taskCommentRepresentationModelAssembler.toModel(createdTaskComment));
}
private Optional<Comparator<TaskComment>> getTaskCommentComparator(
List<TaskCommentsSortBy> sortBy, List<SortDirection> order) throws InvalidArgumentException {
QuerySortParameter.verifyNotOnlyOrderByExists(sortBy, order);
QuerySortParameter.verifyAmountOfSortByAndOrderByMatches(sortBy, order);
Comparator<TaskComment> comparator = null;
if (sortBy != null) {
for (int i = 0; i < sortBy.size(); i++) {
SortDirection sortDirection = order == null ? SortDirection.ASCENDING : order.get(i);
Comparator<TaskComment> temp = sortBy.get(i).getComparator();
if (sortDirection == SortDirection.DESCENDING) {
temp = temp.reversed();
}
comparator = comparator == null ? temp : comparator.thenComparing(temp);
}
}
return Optional.ofNullable(comparator);
public enum TaskCommentQuerySortBy implements QuerySortBy<TaskCommentQuery> {
CREATED(TaskCommentQuery::orderByCreated),
MODIFIED(TaskCommentQuery::orderByModified);
private final BiConsumer<TaskCommentQuery, SortDirection> consumer;
TaskCommentQuerySortBy(BiConsumer<TaskCommentQuery, SortDirection> consumer) {
this.consumer = consumer;
}
enum TaskCommentsSortBy {
CREATED(Comparator.comparing(TaskComment::getCreated)),
MODIFIED(Comparator.comparing(TaskComment::getModified));
private final Comparator<TaskComment> comparator;
TaskCommentsSortBy(Comparator<TaskComment> comparing) {
comparator = comparing;
@Override
public void applySortByForQuery(TaskCommentQuery query, SortDirection sortDirection) {
consumer.accept(query, sortDirection);
}
}
public Comparator<TaskComment> getComparator() {
return comparator;
public static class TaskCommentQuerySortParameter
extends QuerySortParameter<TaskCommentQuery, TaskCommentQuerySortBy> {
@ConstructorProperties({"sort-by", "order"})
public TaskCommentQuerySortParameter(
List<TaskCommentQuerySortBy> sortBy, List<SortDirection> order)
throws InvalidArgumentException {
super(sortBy, order);
}
// this getter is necessary for the documentation!
@Override
public List<TaskCommentQuerySortBy> getSortBy() {
return super.getSortBy();
}
}
}

241
rest/taskana-rest-spring/src/main/java/pro/taskana/task/rest/TaskCommentQueryFilterParameter.java Normal file
View File

@ -0,0 +1,241 @@
package pro.taskana.task.rest;
import com.fasterxml.jackson.annotation.JsonProperty;
import java.beans.ConstructorProperties;
import java.time.Instant;
import java.util.Optional;
import pro.taskana.common.rest.QueryParameter;
import pro.taskana.task.api.TaskCommentQuery;
public class TaskCommentQueryFilterParameter implements QueryParameter<TaskCommentQuery, Void> {
/** Filter by the id of the TaskComment. This is an exact match. */
@JsonProperty("id")
private final String[] idIn;
/** Filter by what the id of the TaskComment shouldn't be. This is an exact match. */
@JsonProperty("id-not")
private final String[] idNotIn;
/**
* Filter by the id of the TaskComment. 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("id-like")
private final String[] idLike;
/**
* Filter by what the id of the TaskComment shouldn't be. 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("id-not-like")
private final String[] idNotLike;
/** Filter by the task id of the TaskComment. This is an exact match. */
@JsonProperty("task-id")
private final String[] taskIdIn;
/** Filter by what the task id of the TaskComment shouldn't be. This is an exact match. */
@JsonProperty("task-id-not")
private final String[] taskIdNotIn;
/**
* Filter by the task id of the TaskComment. 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("task-id-like")
private final String[] taskIdLike;
/**
* Filter by what the task id of the TaskComment shouldn't be. 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("task-id-not-like")
private final String[] taskIdNotLike;
/** Filter by the creator of the TaskComment. This is an exact match. */
@JsonProperty("creator")
private final String[] creatorIn;
/** Filter by what the creator of the TaskComment shouldn't be. This is an exact match. */
@JsonProperty("creator-not")
private final String[] creatorNotIn;
/**
* Filter by the creator of the TaskComment. 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("creator-like")
private final String[] creatorLike;
/**
* Filter by what the creator of the TaskComment shouldn't be. 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("creator-not-like")
private final String[] creatorNotLike;
/**
* Filter by the textfield of the TaskComment. 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("textfield-like")
private final String[] textfieldLike;
/**
* Filter by what the textfield of the TaskComment shouldn't be. 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("textfield-not-like")
private final String[] textfieldNotLike;
/**
* Filter by a time interval within which the TaskComment was modified. To create an open interval
* you can just leave it blank.
*
* <p>The format is ISO-8601.
*/
@JsonProperty("modified")
private final Instant[] modifiedWithin;
/**
* Filter by a time interval within which the TaskComment wasn't modified. To create an open
* interval you can just leave it blank.
*
* <p>The format is ISO-8601.
*/
@JsonProperty("modified-not")
private final Instant[] modifiedNotWithin;
/**
* Filter by a time interval within which the TaskComment was created. To create an open interval
* you can just leave it blank.
*
* <p>The format is ISO-8601.
*/
@JsonProperty("created")
private final Instant[] createdWithin;
/**
* Filter by a time interval within which the TaskComment wasn't created. To create an open
* interval you can just leave it blank.
*
* <p>The format is ISO-8601.
*/
@JsonProperty("created-not")
private final Instant[] createdNotWithin;
@SuppressWarnings("indentation")
@ConstructorProperties({
"id",
"id-not",
"id-like",
"id-not-like",
"task-id",
"task-id-not",
"task-id-like",
"task-id-not-like",
"creator",
"creator-not",
"creator-like",
"creator-not-like",
"textfield-like",
"textfield-not-like",
"modified",
"modified-not",
"created",
"created-not"
})
public TaskCommentQueryFilterParameter(
String[] idIn,
String[] idNotIn,
String[] idLike,
String[] idNotLike,
String[] taskIdIn,
String[] taskIdNotIn,
String[] taskIdLike,
String[] taskIdNotLike,
String[] creatorIn,
String[] creatorNotIn,
String[] creatorLike,
String[] creatorNotLike,
String[] textfieldLike,
String[] textfieldNotLike,
Instant[] modifiedWithin,
Instant[] modifiedNotWithin,
Instant[] createdWithin,
Instant[] createdNotWithin) {
this.idIn = idIn;
this.idNotIn = idNotIn;
this.idLike = idLike;
this.idNotLike = idNotLike;
this.taskIdIn = taskIdIn;
this.taskIdNotIn = taskIdNotIn;
this.taskIdLike = taskIdLike;
this.taskIdNotLike = taskIdNotLike;
this.creatorIn = creatorIn;
this.creatorNotIn = creatorNotIn;
this.creatorLike = creatorLike;
this.creatorNotLike = creatorNotLike;
this.textfieldLike = textfieldLike;
this.textfieldNotLike = textfieldNotLike;
this.modifiedWithin = modifiedWithin;
this.modifiedNotWithin = modifiedNotWithin;
this.createdWithin = createdWithin;
this.createdNotWithin = createdNotWithin;
}
@Override
public Void apply(TaskCommentQuery query) {
Optional.ofNullable(idIn).ifPresent(query::idIn);
Optional.ofNullable(idNotIn).ifPresent(query::idNotIn);
Optional.ofNullable(idLike).map(this::wrapElementsInLikeStatement).ifPresent(query::idLike);
Optional.ofNullable(idNotLike)
.map(this::wrapElementsInLikeStatement)
.ifPresent(query::idNotLike);
Optional.ofNullable(taskIdIn).ifPresent(query::taskIdIn);
Optional.ofNullable(taskIdNotIn).ifPresent(query::taskIdNotIn);
Optional.ofNullable(taskIdLike)
.map(this::wrapElementsInLikeStatement)
.ifPresent(query::taskIdLike);
Optional.ofNullable(taskIdNotLike)
.map(this::wrapElementsInLikeStatement)
.ifPresent(query::taskIdNotLike);
Optional.ofNullable(creatorIn).ifPresent(query::creatorIn);
Optional.ofNullable(creatorNotIn).ifPresent(query::creatorNotIn);
Optional.ofNullable(creatorLike)
.map(this::wrapElementsInLikeStatement)
.ifPresent(query::creatorLike);
Optional.ofNullable(creatorNotLike)
.map(this::wrapElementsInLikeStatement)
.ifPresent(query::creatorNotLike);
Optional.ofNullable(textfieldLike)
.map(this::wrapElementsInLikeStatement)
.ifPresent(query::textFieldLike);
Optional.ofNullable(textfieldNotLike)
.map(this::wrapElementsInLikeStatement)
.ifPresent(query::textFieldNotLike);
Optional.ofNullable(modifiedWithin)
.map(this::extractTimeIntervals)
.ifPresent(query::modifiedWithin);
Optional.ofNullable(modifiedNotWithin)
.map(this::extractTimeIntervals)
.ifPresent(query::modifiedNotWithin);
Optional.ofNullable(createdWithin)
.map(this::extractTimeIntervals)
.ifPresent(query::createdWithin);
Optional.ofNullable(createdNotWithin)
.map(this::extractTimeIntervals)
.ifPresent(query::createdNotWithin);
return null;
}
}

2
rest/taskana-rest-spring/src/main/java/pro/taskana/task/rest/assembler/TaskCommentRepresentationModelAssembler.java
View File

@ -38,6 +38,7 @@ public class TaskCommentRepresentationModelAssembler
repModel.setTaskId(taskComment.getTaskId());
repModel.setTextField(taskComment.getTextField());
repModel.setCreator(taskComment.getCreator());
repModel.setCreatorLongName(taskComment.getCreatorLongName());
repModel.setCreated(taskComment.getCreated());
repModel.setModified(taskComment.getModified());
try {
@ -62,6 +63,7 @@ public class TaskCommentRepresentationModelAssembler
taskComment.setId(repModel.getTaskCommentId());
taskComment.setTextField(repModel.getTextField());
taskComment.setCreator(repModel.getCreator());
taskComment.setCreatorLongName(repModel.getCreatorLongName());
taskComment.setCreated(repModel.getCreated());
taskComment.setModified(repModel.getModified());
return taskComment;

2
rest/taskana-rest-spring/src/main/java/pro/taskana/task/rest/assembler/TaskRepresentationModelAssembler.java
View File

@ -72,6 +72,7 @@ public class TaskRepresentationModelAssembler
repModel.setBusinessProcessId(task.getBusinessProcessId());
repModel.setParentBusinessProcessId(task.getParentBusinessProcessId());
repModel.setOwner(task.getOwner());
repModel.setOwnerLongName(task.getOwnerLongName());
repModel.setPrimaryObjRef(objectReferenceAssembler.toModel(task.getPrimaryObjRef()));
repModel.setRead(task.isRead());
repModel.setTransferred(task.isTransferred());
@ -139,6 +140,7 @@ public class TaskRepresentationModelAssembler
task.setBusinessProcessId(repModel.getBusinessProcessId());
task.setParentBusinessProcessId(repModel.getParentBusinessProcessId());
task.setOwner(repModel.getOwner());
task.setOwnerLongName(repModel.getOwnerLongName());
task.setPrimaryObjRef(objectReferenceAssembler.toEntity(repModel.getPrimaryObjRef()));
task.setRead(repModel.isRead());
task.setTransferred(repModel.isTransferred());

2
rest/taskana-rest-spring/src/main/java/pro/taskana/task/rest/assembler/TaskSummaryRepresentationModelAssembler.java
View File

@ -73,6 +73,7 @@ public class TaskSummaryRepresentationModelAssembler
repModel.setBusinessProcessId(taskSummary.getBusinessProcessId());
repModel.setParentBusinessProcessId(taskSummary.getParentBusinessProcessId());
repModel.setOwner(taskSummary.getOwner());
repModel.setOwnerLongName(taskSummary.getOwnerLongName());
repModel.setPrimaryObjRef(objectReferenceAssembler.toModel(taskSummary.getPrimaryObjRef()));
repModel.setRead(taskSummary.isRead());
repModel.setTransferred(taskSummary.isTransferred());
@ -125,6 +126,7 @@ public class TaskSummaryRepresentationModelAssembler
taskSummary.setBusinessProcessId(repModel.getBusinessProcessId());
taskSummary.setParentBusinessProcessId(repModel.getParentBusinessProcessId());
taskSummary.setOwner(repModel.getOwner());
taskSummary.setOwnerLongName(repModel.getOwnerLongName());
taskSummary.setPrimaryObjRef(objectReferenceAssembler.toEntity(repModel.getPrimaryObjRef()));
taskSummary.setRead(repModel.isRead());
taskSummary.setTransferred(repModel.isTransferred());

10
rest/taskana-rest-spring/src/main/java/pro/taskana/task/rest/models/TaskCommentRepresentationModel.java
View File

@ -17,6 +17,8 @@ public class TaskCommentRepresentationModel
private String textField;
/** The creator of the task comment. */
private String creator;
/** The long name of the task comment creator. */
private String creatorLongName;
/** The creation timestamp in the system. */
private Instant created;
/** Timestamp of the last task comment modification. */
@ -54,6 +56,14 @@ public class TaskCommentRepresentationModel
this.creator = creator;
}
public String getCreatorLongName() {
return creatorLongName;
}
public void setCreatorLongName(String creatorLongName) {
this.creatorLongName = creatorLongName;
}
public Instant getCreated() {
return created;
}

11
rest/taskana-rest-spring/src/main/java/pro/taskana/task/rest/models/TaskSummaryRepresentationModel.java
View File

@ -66,6 +66,8 @@ public class TaskSummaryRepresentationModel
protected String parentBusinessProcessId;
/** The owner of the task. The owner is set upon claiming of the task. */
protected String owner;
/** The long name of the task owner. */
protected String ownerLongName;
/** The Objects primary ObjectReference. */
@NotNull protected ObjectReferenceRepresentationModel primaryObjRef;
/** Indicator if the task has been read. */
@ -104,7 +106,6 @@ public class TaskSummaryRepresentationModel
protected String custom15;
/** A custom property with name "16". */
protected String custom16;
/** The attachment summaries of this task. */
private List<AttachmentSummaryRepresentationModel> attachmentSummaries = new ArrayList<>();
@ -269,6 +270,14 @@ public class TaskSummaryRepresentationModel
this.owner = owner;
}
public String getOwnerLongName() {
return ownerLongName;
}
public void setOwnerLongName(String ownerLongName) {
this.ownerLongName = ownerLongName;
}
public ObjectReferenceRepresentationModel getPrimaryObjRef() {
return primaryObjRef;
}

11
rest/taskana-rest-spring/src/test/java/pro/taskana/task/rest/TaskCommentControllerIntTest.java
View File

@ -57,21 +57,16 @@ class TaskCommentControllerIntTest {
}
@Test
void should_FailToReturnTaskComments_When_TaskIstNotVisible() {
void should_ReturnEmptyTaskCommentList_When_TaskIstNotVisible() {
String url =
restHelper.toUrl(
RestEndpoints.URL_TASK_COMMENTS, "TKI:000000000000000000000000000000000004");
HttpEntity<Object> auth = new HttpEntity<>(RestHelper.generateHeadersForUser("user-1-1"));
ThrowingCallable httpCall =
() -> {
ResponseEntity<TaskCommentCollectionRepresentationModel> taskComments =
TEMPLATE.exchange(url, HttpMethod.GET, auth, TASK_COMMENT_PAGE_MODEL_TYPE);
};
assertThatThrownBy(httpCall)
.extracting(HttpStatusCodeException.class::cast)
.extracting(HttpStatusCodeException::getStatusCode)
.isEqualTo(HttpStatus.FORBIDDEN);
assertThat(taskComments.getBody().getContent()).isEmpty();
}
@Test

4
rest/taskana-rest-spring/src/test/java/pro/taskana/task/rest/assembler/TaskCommentRepresentationModelAssemblerTest.java
View File

@ -34,6 +34,7 @@ class TaskCommentRepresentationModelAssemblerTest {
taskComment.setId("taskCommentId");
taskComment.setCreator("user-1-1");
taskComment.setCreatorLongName("longName");
taskComment.setTextField("this is a task comment");
taskComment.setCreated(Instant.parse("2010-01-01T12:00:00Z"));
taskComment.setModified(Instant.parse("2011-11-11T11:00:00Z"));
@ -51,6 +52,7 @@ class TaskCommentRepresentationModelAssemblerTest {
repModel.setTaskId("TKI:000000000000000000000000000000000000");
repModel.setTaskCommentId("TCI:000000000000000000000000000000000000");
repModel.setCreator("user-1-1");
repModel.setCreatorLongName("longName");
repModel.setCreated(Instant.parse("2010-01-01T12:00:00Z"));
repModel.setModified(Instant.parse("2011-11-11T11:00:00Z"));
repModel.setTextField("textField");
@ -66,6 +68,7 @@ class TaskCommentRepresentationModelAssemblerTest {
(TaskCommentImpl) taskService.newTaskComment("TKI:000000000000000000000000000000000000");
taskComment.setId("taskCommentId");
taskComment.setCreator("user-1-1");
taskComment.setCreatorLongName("longName");
taskComment.setTextField("this is a task comment");
taskComment.setCreated(Instant.parse("2010-01-01T12:00:00Z"));
taskComment.setModified(Instant.parse("2011-11-11T11:00:00Z"));
@ -86,6 +89,7 @@ class TaskCommentRepresentationModelAssemblerTest {
assertThat(taskComment.getTaskId()).isEqualTo(repModel.getTaskId());
assertThat(taskComment.getTextField()).isEqualTo(repModel.getTextField());
assertThat(taskComment.getCreator()).isEqualTo(repModel.getCreator());
assertThat(taskComment.getCreatorLongName()).isEqualTo(repModel.getCreatorLongName());
assertThat(taskComment.getCreated()).isEqualTo(repModel.getCreated());
assertThat(taskComment.getModified()).isEqualTo(repModel.getModified());
}

3
rest/taskana-rest-spring/src/test/java/pro/taskana/task/rest/assembler/TaskRepresentationModelAssemblerTest.java
View File

@ -89,6 +89,7 @@ class TaskRepresentationModelAssemblerTest {
repModel.setBusinessProcessId("businessProcessId");
repModel.setParentBusinessProcessId("parentBusinessProcessId");
repModel.setOwner("owner");
repModel.setOwnerLongName("ownerLongName");
repModel.setPrimaryObjRef(primaryObjRef);
repModel.setRead(true);
repModel.setTransferred(true);
@ -180,6 +181,7 @@ class TaskRepresentationModelAssemblerTest {
task.setBusinessProcessId("businessProcessId");
task.setParentBusinessProcessId("parentBusinessProcessId");
task.setOwner("owner");
task.setOwnerLongName("ownerLongName");
task.setPrimaryObjRef(primaryObjRef);
task.setRead(true);
task.setTransferred(true);
@ -243,6 +245,7 @@ class TaskRepresentationModelAssemblerTest {
task.setBusinessProcessId("businessProcessId");
task.setParentBusinessProcessId("parentBusinessProcessId");
task.setOwner("owner");
task.setOwnerLongName("ownerLongName");
task.setPrimaryObjRef(primaryObjRef);
task.setRead(true);
task.setTransferred(true);

4
rest/taskana-rest-spring/src/test/java/pro/taskana/task/rest/assembler/TaskSummaryRepresentationModelAssemblerTest.java
View File

@ -99,6 +99,7 @@ class TaskSummaryRepresentationModelAssemblerTest {
task.setBusinessProcessId("businessProcessId");
task.setParentBusinessProcessId("parentBusinessProcessId");
task.setOwner("owner");
task.setOwnerLongName("ownerLongName");
task.setPrimaryObjRef(primaryObjRef);
task.setRead(true);
task.setTransferred(true);
@ -164,6 +165,7 @@ class TaskSummaryRepresentationModelAssemblerTest {
repModel.setBusinessProcessId("businessProcessId");
repModel.setParentBusinessProcessId("parentBusinessProcessId");
repModel.setOwner("owner");
repModel.setOwnerLongName("ownerLongName");
repModel.setRead(true);
repModel.setTransferred(true);
repModel.setCustom1("custom1");
@ -250,6 +252,7 @@ class TaskSummaryRepresentationModelAssemblerTest {
task.setBusinessProcessId("businessProcessId");
task.setParentBusinessProcessId("parentBusinessProcessId");
task.setOwner("owner");
task.setOwnerLongName("ownerLongName");
task.setPrimaryObjRef(primaryObjRef);
task.setRead(true);
task.setTransferred(true);
@ -303,6 +306,7 @@ class TaskSummaryRepresentationModelAssemblerTest {
assertThat(taskSummary.getParentBusinessProcessId())
.isEqualTo(repModel.getParentBusinessProcessId());
assertThat(taskSummary.getOwner()).isEqualTo(repModel.getOwner());
assertThat(taskSummary.getOwnerLongName()).isEqualTo(repModel.getOwnerLongName());
ObjectReferenceRepresentationModelAssemblerTest.testEquality(
taskSummary.getPrimaryObjRef(), repModel.getPrimaryObjRef());
assertThat(taskSummary.isRead()).isEqualTo(repModel.isRead());