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

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

@@ -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: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: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: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: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:000000000000000000000000000000000012', 'TKI:000000000000000000000000000000000004', 'some text in textfield', 'user-1-1', '2017-01-29 15:55:00', '2018-01-30 15:55:00');

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

@@ -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: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', ''					, ''							,''								,'2old_val'	,'new_val2'	,'custom1'	,''			, 'custom2'	,''           ,'someDetails'			),
+('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'			, ''		, ''		, 'L140101'				, 'TASK'						,'DOCTYPE_DEFAULT'				,''			,''			,'custom1'	,''			, 'custom3'	,''	          ,'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', ''					, ''							,''								,'2old_val'	,'new_val2'	,'custom1'	,''			, 'custom2'	,''           ,'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'			, ''		, ''		, 'L140101'				, 'TASK'						,'DOCTYPE_DEFAULT'				,''			,''			,'custom1'	,''			, 'custom3'	,''	          ,'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', ''					, ''							,''								,'2old_val'	,'new_val2'	,'custom1'	,''			, 'custom2'	,''           ,'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'			, ''		, ''		, 'L140101'				, 'TASK'						,'DOCTYPE_DEFAULT'				,''			,''			,'custom1'	,''			, 'custom3'	,''	          ,'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', ''					, ''							,''								,'2old_val'	,'new_val2'	,'custom1'	,''			, 'custom2'	,''           ,'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'			, ''		, ''		, 'L140101'				, 'TASK'						,'DOCTYPE_DEFAULT'				,''			,''			,'custom1'	,''			, 'custom3'	,''	          ,'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', ''					, ''							,''								,'2old_val'	,'new_val2'	,'custom1'	,''			, 'custom2'	,''           ,'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'			, ''		, ''		, 'L140101'				, 'TASK'						,'DOCTYPE_DEFAULT'				,''			,''			,'custom1'	,''			, 'custom3'	,''	          ,'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', ''					, ''							,''								,'2old_val'	,'new_val2'	,'custom1'	,''			, 'custom2'	,''           ,'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'			, ''		, ''		, 'L140101'				, 'TASK'						,'DOCTYPE_DEFAULT'				,''			,''			,'custom1'	,''			, 'custom3'	,''	          ,'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'		)
 ;

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

@@ -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) {

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

@@ -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);

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

@@ -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);

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

@@ -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"),

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

@@ -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> "

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

@@ -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();
 

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

@@ -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();
+  }
 }

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

@@ -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")

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

@@ -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(results)
-    assertThat(query.domainLike().count()).isEqualTo(13);
+        .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();
+  }
 }

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

@@ -65,8 +65,8 @@ class SimpleHistoryServiceImplTest {
     doReturn(taskanaEngine).when(taskanaEngineConfiguration).buildTaskanaEngine();
     cutSpy.initialize(taskanaEngineConfiguration.buildTaskanaEngine());
 
-    verify(sqlSessionManagerMock, times(3)).getMapper(any());
+    verify(sqlSessionManagerMock, times(4)).getMapper(any());
-    verify(taskanaHistoryEngineMock, times(3)).getSqlSession();
+    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));
 

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

@@ -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;
-  }
-}

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

@@ -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());

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

@@ -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="

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

@@ -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))

lib/taskana-core/src/main/java/pro/taskana/TaskanaEngineConfiguration.java

@@ -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;
   }

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

@@ -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);

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

@@ -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="

lib/taskana-core/src/main/java/pro/taskana/task/api/TaskCommentQuery.java

@@ -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);
+}

lib/taskana-core/src/main/java/pro/taskana/task/api/TaskCommentQueryColumnName.java

@@ -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;
+  }
+
+
+}

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

@@ -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

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

@@ -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"),

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

@@ -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

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

@@ -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.
    *

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

@@ -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.
    *

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

@@ -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 "

lib/taskana-core/src/main/java/pro/taskana/task/internal/TaskCommentQueryImpl.java

@@ -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
+        + "]";
+  }
+}

lib/taskana-core/src/main/java/pro/taskana/task/internal/TaskCommentQueryMapper.java

@@ -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);
+}

lib/taskana-core/src/main/java/pro/taskana/task/internal/TaskCommentQuerySqlProvider.java

@@ -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>";
+  }
+}

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

@@ -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;

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

@@ -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
         + "]";
   }
 }

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

@@ -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")

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

@@ -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);
+    whereIn("ownerLongNameIn", "u.LONG_NAME", sb);
-    whereNotIn("priorityNotIn", "t.PRIORITY", 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> ");

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

@@ -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);

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

@@ -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="

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

@@ -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="

lib/taskana-core/src/test/java/acceptance/AbstractAccTest.java

@@ -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();
   }

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

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

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

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

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

@@ -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")

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

@@ -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 {

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

@@ -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());
         };
 

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

@@ -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

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

@@ -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 completedTask = taskService.completeTask("TKI:000000000000000000000000000000000002");
-    Task completedTask2 = TASK_SERVICE.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 createdTask = taskService.createTask(newTaskImpl);
-    Task completedTask = TASK_SERVICE.forceCompleteTask(createdTask.getId());
+    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 createdTask = taskService.createTask(newTaskImpl);
-    Task completedTask = TASK_SERVICE.forceCompleteTask(createdTask.getId());
+    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);
+    Task before = taskService.getTask(id);
-    BulkOperationResults<String, TaskanaException> results = TASK_SERVICE.completeTasks(taskIdList);
+    BulkOperationResults<String, TaskanaException> results = taskService.completeTasks(taskIdList);
-    Task after = TASK_SERVICE.getTask(id);
+    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);
+        taskService.forceCompleteTasks(taskIdList);
-    Task after = TASK_SERVICE.getTask(id);
+    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);
+        taskService.forceCompleteTasks(taskIdList);
-    Task afterClaim = TASK_SERVICE.getTask(id);
+    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())

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

@@ -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();
 

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

@@ -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() {

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

@@ -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() {

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

@@ -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());
+  }
 }

lib/taskana-core/src/test/java/acceptance/task/QueryTaskCommentAccTest.java

@@ -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();
+  }
+}

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

@@ -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);
   }
 }

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

@@ -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);
   }
 }

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

@@ -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)

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

@@ -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);

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

@@ -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

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

@@ -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();
   }

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

@@ -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() {

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

@@ -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 task = taskService.getTask("TKI:000000000000000000000000000000000003");
-    TASK_SERVICE.claim(task.getId());
+    taskService.claim(task.getId());
-    TASK_SERVICE.setTaskRead(task.getId(), true);
+    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 task = taskService.getTask("TKI:000000000000000000000000000000000003");
-    TASK_SERVICE.claim(task.getId());
+    taskService.claim(task.getId());
-    TASK_SERVICE.setTaskRead(task.getId(), true);
+    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 task = taskService.getTask("TKI:000000000000000000000000000000000003");
-    TASK_SERVICE.claim(task.getId());
+    taskService.claim(task.getId());
-    TASK_SERVICE.setTaskRead(task.getId(), true);
+    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 task = taskService.getTask("TKI:000000000000000000000000000000000003");
-    TASK_SERVICE.claim(task.getId());
+    taskService.claim(task.getId());
-    TASK_SERVICE.setTaskRead(task.getId(), true);
+    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",

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

@@ -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 {

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

@@ -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(

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

@@ -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")

lib/taskana-core/src/test/resources/taskana.properties

@@ -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
 

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

@@ -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
+   * @param request the HTTP request
-   *     primary sort value is the same, the second one will be used.
+   * @param filterParameter the filter parameters
-   * @param order The order direction for each sort value. This value requires the use of 'sort-by'.
+   * @param sortParameter the sort parameters
-   *     The amount of sort-by and order declarations have to match. Alternatively the value can be
+   * @param pagingParameter the paging parameters
-   *     omitted. In this case the default sort order (ASCENDING) will be applied to every sort-by
-   *     value.
    * @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,
+      HttpServletRequest request,
-      @RequestParam(required = false) List<SortDirection> order)
+      TaskCommentQueryFilterParameter filterParameter,
-      throws NotAuthorizedException, TaskNotFoundException, InvalidArgumentException {
+      TaskCommentQuerySortParameter sortParameter,
-    Optional<Comparator<TaskComment>> comparator = getTaskCommentComparator(sortBy, order);
+      QueryPagingParameter<TaskComment, TaskCommentQuery> pagingParameter) {
-    List<TaskComment> taskComments = taskService.getTaskComments(taskId);
+
-    comparator.ifPresent(taskComments::sort);
+    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(
+  public enum TaskCommentQuerySortBy implements QuerySortBy<TaskCommentQuery> {
-      List<TaskCommentsSortBy> sortBy, List<SortDirection> order) throws InvalidArgumentException {
+    CREATED(TaskCommentQuery::orderByCreated),
-    QuerySortParameter.verifyNotOnlyOrderByExists(sortBy, order);
+    MODIFIED(TaskCommentQuery::orderByModified);
-    QuerySortParameter.verifyAmountOfSortByAndOrderByMatches(sortBy, order);
+
-    Comparator<TaskComment> comparator = null;
+    private final BiConsumer<TaskCommentQuery, SortDirection> consumer;
-    if (sortBy != null) {
+
-      for (int i = 0; i < sortBy.size(); i++) {
+    TaskCommentQuerySortBy(BiConsumer<TaskCommentQuery, SortDirection> consumer) {
-        SortDirection sortDirection = order == null ? SortDirection.ASCENDING : order.get(i);
+      this.consumer = consumer;
-        Comparator<TaskComment> temp = sortBy.get(i).getComparator();
+    }
-        if (sortDirection == SortDirection.DESCENDING) {
+
-          temp = temp.reversed();
+    @Override
-        }
+    public void applySortByForQuery(TaskCommentQuery query, SortDirection sortDirection) {
-        comparator = comparator == null ? temp : comparator.thenComparing(temp);
+      consumer.accept(query, sortDirection);
-      }
     }
-    return Optional.ofNullable(comparator);
   }
 
-  enum TaskCommentsSortBy {
+  public static class TaskCommentQuerySortParameter
-    CREATED(Comparator.comparing(TaskComment::getCreated)),
+      extends QuerySortParameter<TaskCommentQuery, TaskCommentQuerySortBy> {
-    MODIFIED(Comparator.comparing(TaskComment::getModified));
 
-    private final Comparator<TaskComment> comparator;
+    @ConstructorProperties({"sort-by", "order"})
-
+    public TaskCommentQuerySortParameter(
-    TaskCommentsSortBy(Comparator<TaskComment> comparing) {
+        List<TaskCommentQuerySortBy> sortBy, List<SortDirection> order)
-      comparator = comparing;
+        throws InvalidArgumentException {
+      super(sortBy, order);
     }
 
-    public Comparator<TaskComment> getComparator() {
+    // this getter is necessary for the documentation!
-      return comparator;
+    @Override
+    public List<TaskCommentQuerySortBy> getSortBy() {
+      return super.getSortBy();
     }
   }
 }

rest/taskana-rest-spring/src/main/java/pro/taskana/task/rest/TaskCommentQueryFilterParameter.java

@@ -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;
+  }
+}

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

@@ -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;

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

@@ -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());

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

@@ -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());

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

@@ -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;
   }

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

@@ -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;
   }

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

@@ -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);
-          TEMPLATE.exchange(url, HttpMethod.GET, auth, TASK_COMMENT_PAGE_MODEL_TYPE);
-        };
 
-    assertThatThrownBy(httpCall)
+    assertThat(taskComments.getBody().getContent()).isEmpty();
-        .extracting(HttpStatusCodeException.class::cast)
-        .extracting(HttpStatusCodeException::getStatusCode)
-        .isEqualTo(HttpStatus.FORBIDDEN);
   }
 
   @Test

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

@@ -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());
   }

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

@@ -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);

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

@@ -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());