From b66e4d9f862a14fc740e1c25c00e80e81c74abe9 Mon Sep 17 00:00:00 2001
From: Mustapha Zorgati <15628173+mustaphazorgati@users.noreply.github.com>
Date: Wed, 19 May 2021 12:19:42 +0200
Subject: [PATCH] TSK-1642: now setting details attribute for
 TaskTransferHistoryEvent

---
 .../util/ObjectAttributeChangeDetector.java   |   2 +-
 .../taskana/common/internal/util/Pair.java    |   2 +-
 .../taskana/common/internal/util/Triplet.java |   6 +-
 ...eateHistoryEventOnTaskTransferAccTest.java | 173 ++++++++++-----
 .../api/events/task/TaskTransferredEvent.java |  11 +-
 .../pro/taskana/task/internal/TaskMapper.java |   5 +-
 .../task/internal/TaskServiceImpl.java        |  18 +-
 .../task/internal/TaskTransferrer.java        | 204 +++++++++--------
 .../task/internal/models/TaskSummaryImpl.java |   2 +-
 .../acceptance/task/QueryTasksAccTest.java    |  33 ++-
 .../acceptance/task/TransferTaskAccTest.java  | 208 +++++++-----------
 11 files changed, 355 insertions(+), 309 deletions(-)

diff --git a/common/taskana-common/src/main/java/pro/taskana/common/internal/util/ObjectAttributeChangeDetector.java b/common/taskana-common/src/main/java/pro/taskana/common/internal/util/ObjectAttributeChangeDetector.java
index 2ee632b82..ff3889ecd 100644
--- a/common/taskana-common/src/main/java/pro/taskana/common/internal/util/ObjectAttributeChangeDetector.java
+++ b/common/taskana-common/src/main/java/pro/taskana/common/internal/util/ObjectAttributeChangeDetector.java
@@ -57,7 +57,7 @@ public class ObjectAttributeChangeDetector {
             .peek(field -> field.setAccessible(true))
             .map(
                 CheckedFunction.wrap(
-                    field -> new Triplet<>(field, field.get(oldObject), field.get(newObject))))
+                    field -> Triplet.of(field, field.get(oldObject), field.get(newObject))))
             .filter(areFieldsNotEqual.and(isFieldNotCustomAttributes))
             .map(
                 fieldAndValuePairTriplet -> {
diff --git a/common/taskana-common/src/main/java/pro/taskana/common/internal/util/Pair.java b/common/taskana-common/src/main/java/pro/taskana/common/internal/util/Pair.java
index d2c1d15df..453edf248 100644
--- a/common/taskana-common/src/main/java/pro/taskana/common/internal/util/Pair.java
+++ b/common/taskana-common/src/main/java/pro/taskana/common/internal/util/Pair.java
@@ -8,7 +8,7 @@ public final class Pair<L, R> {
 
   private final R right;
 
-  public Pair(L left, R right) {
+  private Pair(L left, R right) {
     this.left = left;
     this.right = right;
   }
diff --git a/common/taskana-common/src/main/java/pro/taskana/common/internal/util/Triplet.java b/common/taskana-common/src/main/java/pro/taskana/common/internal/util/Triplet.java
index 9556e8343..c6736b339 100644
--- a/common/taskana-common/src/main/java/pro/taskana/common/internal/util/Triplet.java
+++ b/common/taskana-common/src/main/java/pro/taskana/common/internal/util/Triplet.java
@@ -6,12 +6,16 @@ public class Triplet<L, M, R> {
   private final M middle;
   private final R right;
 
-  public Triplet(L left, M middle, R right) {
+  private Triplet(L left, M middle, R right) {
     this.left = left;
     this.middle = middle;
     this.right = right;
   }
 
+  public static <L, M, R> Triplet<L, M, R> of(L left, M middle, R right) {
+    return new Triplet<>(left, middle, right);
+  }
+
   public L getLeft() {
     return left;
   }
diff --git a/history/taskana-simplehistory-provider/src/test/java/acceptance/events/task/CreateHistoryEventOnTaskTransferAccTest.java b/history/taskana-simplehistory-provider/src/test/java/acceptance/events/task/CreateHistoryEventOnTaskTransferAccTest.java
index a000b8f9c..475ce54d4 100644
--- a/history/taskana-simplehistory-provider/src/test/java/acceptance/events/task/CreateHistoryEventOnTaskTransferAccTest.java
+++ b/history/taskana-simplehistory-provider/src/test/java/acceptance/events/task/CreateHistoryEventOnTaskTransferAccTest.java
@@ -1,13 +1,20 @@
 package acceptance.events.task;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static pro.taskana.common.internal.util.CheckedConsumer.wrap;
 
 import acceptance.AbstractAccTest;
-import java.util.ArrayList;
 import java.util.List;
-import org.junit.jupiter.api.Test;
+import java.util.function.Consumer;
+import java.util.stream.Stream;
+import org.json.JSONArray;
+import org.json.JSONObject;
+import org.junit.jupiter.api.DynamicTest;
+import org.junit.jupiter.api.TestFactory;
 import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.function.ThrowingConsumer;
 
+import pro.taskana.common.internal.util.Triplet;
 import pro.taskana.common.test.security.JaasExtension;
 import pro.taskana.common.test.security.WithAccessId;
 import pro.taskana.simplehistory.impl.SimpleHistoryServiceImpl;
@@ -16,6 +23,8 @@ import pro.taskana.simplehistory.impl.task.TaskHistoryQueryMapper;
 import pro.taskana.spi.history.api.events.task.TaskHistoryEvent;
 import pro.taskana.spi.history.api.events.task.TaskHistoryEventType;
 import pro.taskana.task.api.TaskService;
+import pro.taskana.workbasket.api.WorkbasketService;
+import pro.taskana.workbasket.api.models.Workbasket;
 
 @ExtendWith(JaasExtension.class)
 class CreateHistoryEventOnTaskTransferAccTest extends AbstractAccTest {
@@ -24,76 +33,140 @@ class CreateHistoryEventOnTaskTransferAccTest extends AbstractAccTest {
   private final SimpleHistoryServiceImpl historyService = getHistoryService();
 
   @WithAccessId(user = "admin")
-  @Test
-  void should_CreateTransferredHistoryEvent_When_TaskIstransferred() throws Exception {
+  @TestFactory
+  Stream<DynamicTest> should_CreateTransferredHistoryEvent_When_TaskIsTransferred() {
+    List<Triplet<String, String, Consumer<String>>> testCases =
+        List.of(
+            Triplet.of(
+                "Using WorkbasketId",
+                "TKI:000000000000000000000000000000000003",
+                wrap(
+                    (String taskId) ->
+                        taskService.transfer(taskId, "WBI:100000000000000000000000000000000006"))),
+            Triplet.of(
+                "Using WorkbasketKey and Domain",
+                "TKI:000000000000000000000000000000000004",
+                wrap((String taskId) -> taskService.transfer(taskId, "USER-1-1", "DOMAIN_A"))));
 
-    final String taskId = "TKI:000000000000000000000000000000000003";
+    ThrowingConsumer<Triplet<String, String, Consumer<String>>> test =
+        t -> {
+          String taskId = t.getMiddle();
+          Consumer<String> transferMethod = t.getRight();
 
-    TaskHistoryQueryMapper taskHistoryQueryMapper = getHistoryQueryMapper();
+          TaskHistoryQueryMapper taskHistoryQueryMapper = getHistoryQueryMapper();
 
-    List<TaskHistoryEvent> events =
-        taskHistoryQueryMapper.queryHistoryEvents(
-            (TaskHistoryQueryImpl) historyService.createTaskHistoryQuery().taskIdIn(taskId));
+          List<TaskHistoryEvent> events =
+              taskHistoryQueryMapper.queryHistoryEvents(
+                  (TaskHistoryQueryImpl) historyService.createTaskHistoryQuery().taskIdIn(taskId));
 
-    assertThat(events).isEmpty();
+          assertThat(events).isEmpty();
 
-    taskService.transfer(taskId, "WBI:100000000000000000000000000000000006");
+          transferMethod.accept(taskId);
 
-    events =
-        taskHistoryQueryMapper.queryHistoryEvents(
-            (TaskHistoryQueryImpl) historyService.createTaskHistoryQuery().taskIdIn(taskId));
+          events =
+              taskHistoryQueryMapper.queryHistoryEvents(
+                  (TaskHistoryQueryImpl) historyService.createTaskHistoryQuery().taskIdIn(taskId));
 
-    assertThat(events).hasSize(1);
+          assertThat(events).hasSize(1);
+          assertTransferHistoryEvent(
+              events.get(0).getId(),
+              "WBI:100000000000000000000000000000000001",
+              "WBI:100000000000000000000000000000000006",
+              "admin");
+        };
 
-    String eventType = events.get(0).getEventType();
-
-    assertThat(eventType).isEqualTo(TaskHistoryEventType.TRANSFERRED.getName());
+    return DynamicTest.stream(testCases.iterator(), Triplet::getLeft, test);
   }
 
   @WithAccessId(user = "admin")
-  @Test
-  void should_CreateTransferredHistoryEvents_When_TaskBulkTransfer() throws Exception {
+  @TestFactory
+  Stream<DynamicTest> should_CreateTransferredHistoryEvents_When_TaskBulkTransfer() {
+    List<Triplet<String, List<String>, Consumer<List<String>>>> testCases =
+        List.of(
+            Triplet.of(
+                "Using WorkbasketId",
+                List.of(
+                    "TKI:000000000000000000000000000000000021",
+                    "TKI:000000000000000000000000000000000022"),
+                wrap(
+                    (List<String> taskIds) ->
+                        taskService.transferTasks(
+                            "WBI:100000000000000000000000000000000007", taskIds))),
+            Triplet.of(
+                "Using WorkbasketKey and Domain",
+                List.of(
+                    "TKI:000000000000000000000000000000000023",
+                    "TKI:000000000000000000000000000000000024"),
+                wrap(
+                    (List<String> taskIds) ->
+                        taskService.transferTasks("USER-1-2", "DOMAIN_A", taskIds))));
 
-    final String taskId = "TKI:000000000000000000000000000000000004";
-    final String taskId2 = "TKI:000000000000000000000000000000000002";
+    ThrowingConsumer<Triplet<String, List<String>, Consumer<List<String>>>> test =
+        t -> {
+          List<String> taskIds = t.getMiddle();
+          Consumer<List<String>> transferMethod = t.getRight();
 
-    final String destinationWorkbasketKey = "WBI:100000000000000000000000000000000007";
+          TaskHistoryQueryMapper taskHistoryQueryMapper = getHistoryQueryMapper();
 
-    List<String> taskIds = new ArrayList<>();
+          List<TaskHistoryEvent> events =
+              taskHistoryQueryMapper.queryHistoryEvents(
+                  (TaskHistoryQueryImpl)
+                      historyService
+                          .createTaskHistoryQuery()
+                          .taskIdIn(taskIds.toArray(new String[0])));
 
-    taskIds.add(taskId);
-    taskIds.add(taskId2);
+          assertThat(events).isEmpty();
 
-    TaskHistoryQueryMapper taskHistoryQueryMapper = getHistoryQueryMapper();
+          transferMethod.accept(taskIds);
 
-    List<TaskHistoryEvent> events =
-        taskHistoryQueryMapper.queryHistoryEvents(
-            (TaskHistoryQueryImpl)
-                historyService.createTaskHistoryQuery().taskIdIn(taskIds.toArray(new String[0])));
+          events =
+              taskHistoryQueryMapper.queryHistoryEvents(
+                  (TaskHistoryQueryImpl)
+                      historyService
+                          .createTaskHistoryQuery()
+                          .taskIdIn(taskIds.toArray(new String[0])));
 
-    assertThat(events).isEmpty();
+          assertThat(events)
+              .extracting(TaskHistoryEvent::getTaskId)
+              .containsExactlyInAnyOrderElementsOf(taskIds);
 
-    taskService.transferTasks(destinationWorkbasketKey, taskIds);
-    events =
-        taskHistoryQueryMapper.queryHistoryEvents(
-            (TaskHistoryQueryImpl)
-                historyService
-                    .createTaskHistoryQuery()
-                    .taskIdIn(taskIds.stream().toArray(String[]::new)));
+          for (TaskHistoryEvent event : events) {
+            assertTransferHistoryEvent(
+                event.getId(),
+                "WBI:100000000000000000000000000000000001",
+                "WBI:100000000000000000000000000000000007",
+                "admin");
+          }
+        };
 
-    assertThat(events).hasSize(2);
+    return DynamicTest.stream(testCases.iterator(), Triplet::getLeft, test);
+  }
 
-    assertThat(events)
-        .extracting(TaskHistoryEvent::getEventType)
-        .containsOnly(TaskHistoryEventType.TRANSFERRED.getName());
+  private void assertTransferHistoryEvent(
+      String eventId, String expectedOldValue, String expectedNewValue, String expectedUser)
+      throws Exception {
+    TaskHistoryEvent event = historyService.getTaskHistoryEvent(eventId);
+    assertThat(event.getDetails()).isNotNull();
+    JSONArray changes = new JSONObject(event.getDetails()).getJSONArray("changes");
 
-    assertThat(events)
-        .extracting(TaskHistoryEvent::getOldValue)
-        .containsExactlyInAnyOrder(
-            "WBI:100000000000000000000000000000000006", "WBI:100000000000000000000000000000000001");
+    assertThat(changes.length()).isPositive();
+    for (int i = 0; i < changes.length(); i++) {
+      JSONObject change = changes.getJSONObject(i);
+      if (change.get("fieldName").equals("workbasketSummary")) {
+        String oldWorkbasketStr = (String) change.get("oldValue");
+        String newWorkbasketStr = (String) change.get("newValue");
+        WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
+        Workbasket oldWorkbasket = workbasketService.getWorkbasket(expectedOldValue);
+        assertThat(oldWorkbasket.asSummary()).hasToString(oldWorkbasketStr);
+        Workbasket newWorkbasket = workbasketService.getWorkbasket(expectedNewValue);
+        assertThat(newWorkbasket.asSummary()).hasToString(newWorkbasketStr);
+      }
+    }
 
-    assertThat(events)
-        .extracting(TaskHistoryEvent::getNewValue)
-        .containsOnly("WBI:100000000000000000000000000000000007");
+    assertThat(event.getId()).startsWith("THI:");
+    assertThat(event.getOldValue()).isEqualTo(expectedOldValue);
+    assertThat(event.getNewValue()).isEqualTo(expectedNewValue);
+    assertThat(event.getUserId()).isEqualTo(expectedUser);
+    assertThat(event.getEventType()).isEqualTo(TaskHistoryEventType.TRANSFERRED.getName());
   }
 }
diff --git a/lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/task/TaskTransferredEvent.java b/lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/task/TaskTransferredEvent.java
index 1b426e263..40dc7226f 100644
--- a/lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/task/TaskTransferredEvent.java
+++ b/lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/task/TaskTransferredEvent.java
@@ -1,13 +1,18 @@
 package pro.taskana.spi.history.api.events.task;
 
-import pro.taskana.task.api.models.Task;
+import pro.taskana.task.api.models.TaskSummary;
 
 /** Event fired if a task is transferred. */
 public class TaskTransferredEvent extends TaskHistoryEvent {
 
   public TaskTransferredEvent(
-      String id, Task task, String oldWorkbasketId, String newWorkbasketId, String userId) {
-    super(id, task, userId, null);
+      String id,
+      TaskSummary task,
+      String oldWorkbasketId,
+      String newWorkbasketId,
+      String userId,
+      String details) {
+    super(id, task, userId, details);
     eventType = TaskHistoryEventType.TRANSFERRED.getName();
     created = task.getModified();
     this.oldValue = oldWorkbasketId;
diff --git a/lib/taskana-core/src/main/java/pro/taskana/task/internal/TaskMapper.java b/lib/taskana-core/src/main/java/pro/taskana/task/internal/TaskMapper.java
index 34f0feae4..d784a8b4a 100644
--- a/lib/taskana-core/src/main/java/pro/taskana/task/internal/TaskMapper.java
+++ b/lib/taskana-core/src/main/java/pro/taskana/task/internal/TaskMapper.java
@@ -3,6 +3,7 @@ package pro.taskana.task.internal;
 import java.time.Instant;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import org.apache.ibatis.annotations.Delete;
 import org.apache.ibatis.annotations.Insert;
 import org.apache.ibatis.annotations.Options;
@@ -18,7 +19,6 @@ import pro.taskana.task.api.CallbackState;
 import pro.taskana.task.api.models.TaskSummary;
 import pro.taskana.task.internal.models.MinimalTaskSummary;
 import pro.taskana.task.internal.models.TaskImpl;
-import pro.taskana.task.internal.models.TaskSummaryImpl;
 
 /** This class is the mybatis mapping of task. */
 @SuppressWarnings("checkstyle:LineLength")
@@ -146,8 +146,7 @@ public interface TaskMapper {
           + " WHERE ID IN <foreach item='taskId' index='index' separator=',' open='(' close=')' collection='taskIds'>#{taskId}</foreach>"
           + "</script>")
   void updateTransfered(
-      @Param("taskIds") List<String> taskIds,
-      @Param("referencetask") TaskSummaryImpl referencetask);
+      @Param("taskIds") Set<String> taskIds, @Param("referencetask") TaskImpl referencetask);
 
   @Update(
       "<script>"
diff --git a/lib/taskana-core/src/main/java/pro/taskana/task/internal/TaskServiceImpl.java b/lib/taskana-core/src/main/java/pro/taskana/task/internal/TaskServiceImpl.java
index 7a4d181ed..8655ad840 100644
--- a/lib/taskana-core/src/main/java/pro/taskana/task/internal/TaskServiceImpl.java
+++ b/lib/taskana-core/src/main/java/pro/taskana/task/internal/TaskServiceImpl.java
@@ -884,7 +884,7 @@ public class TaskServiceImpl implements TaskService {
     Pair<List<MinimalTaskSummary>, BulkLog> filteredPair =
         filterTasksAuthorizedForAndLogErrorsForNotAuthorized(minimalTaskSummaries);
     bulkLog.addAllErrors(filteredPair.getRight());
-    return new Pair<>(filteredPair.getLeft(), bulkLog);
+    return Pair.of(filteredPair.getLeft(), bulkLog);
   }
 
   Pair<List<MinimalTaskSummary>, BulkLog> filterTasksAuthorizedForAndLogErrorsForNotAuthorized(
@@ -892,7 +892,7 @@ public class TaskServiceImpl implements TaskService {
     BulkLog bulkLog = new BulkLog();
     // check authorization only for non-admin or task-admin users
     if (taskanaEngine.getEngine().isUserInRole(TaskanaRole.ADMIN, TaskanaRole.TASK_ADMIN)) {
-      return new Pair<>(existingTasks, bulkLog);
+      return Pair.of(existingTasks, bulkLog);
     } else {
       List<String> taskIds =
           existingTasks.stream().map(MinimalTaskSummary::getTaskId).collect(Collectors.toList());
@@ -911,7 +911,7 @@ public class TaskServiceImpl implements TaskService {
           existingTasks.stream()
               .filter(t -> taskIds.contains(t.getTaskId()))
               .collect(Collectors.toList());
-      return new Pair<>(tasksAuthorizedFor, bulkLog);
+      return Pair.of(tasksAuthorizedFor, bulkLog);
     }
   }
 
@@ -932,16 +932,12 @@ public class TaskServiceImpl implements TaskService {
 
   List<TaskSummary> augmentTaskSummariesByContainedSummariesWithPartitioning(
       List<TaskSummaryImpl> taskSummaries) {
-
     // splitting Augmentation into steps of maximal 32000 tasks
     // reason: DB2 has a maximum for parameters in a query
-    List<TaskSummary> result =
-        CollectionUtil.partitionBasedOnSize(taskSummaries, 32000).stream()
-            .map(this::augmentTaskSummariesByContainedSummariesWithoutPartitioning)
-            .flatMap(Collection::stream)
-            .collect(Collectors.toList());
-
-    return result;
+    return CollectionUtil.partitionBasedOnSize(taskSummaries, 32000).stream()
+        .map(this::augmentTaskSummariesByContainedSummariesWithoutPartitioning)
+        .flatMap(Collection::stream)
+        .collect(Collectors.toList());
   }
 
   private List<TaskSummaryImpl> augmentTaskSummariesByContainedSummariesWithoutPartitioning(
diff --git a/lib/taskana-core/src/main/java/pro/taskana/task/internal/TaskTransferrer.java b/lib/taskana-core/src/main/java/pro/taskana/task/internal/TaskTransferrer.java
index f7e22fac4..8041acc4a 100644
--- a/lib/taskana-core/src/main/java/pro/taskana/task/internal/TaskTransferrer.java
+++ b/lib/taskana-core/src/main/java/pro/taskana/task/internal/TaskTransferrer.java
@@ -2,8 +2,13 @@ package pro.taskana.task.internal;
 
 import java.time.Instant;
 import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 
 import pro.taskana.common.api.BulkOperationResults;
@@ -12,14 +17,16 @@ import pro.taskana.common.api.exceptions.NotAuthorizedException;
 import pro.taskana.common.api.exceptions.TaskanaException;
 import pro.taskana.common.internal.InternalTaskanaEngine;
 import pro.taskana.common.internal.util.IdGenerator;
+import pro.taskana.common.internal.util.ObjectAttributeChangeDetector;
 import pro.taskana.spi.history.api.events.task.TaskTransferredEvent;
 import pro.taskana.spi.history.internal.HistoryEventManager;
 import pro.taskana.task.api.TaskState;
 import pro.taskana.task.api.exceptions.InvalidStateException;
 import pro.taskana.task.api.exceptions.TaskNotFoundException;
 import pro.taskana.task.api.models.Task;
-import pro.taskana.task.internal.models.MinimalTaskSummary;
+import pro.taskana.task.api.models.TaskSummary;
 import pro.taskana.task.internal.models.TaskImpl;
+import pro.taskana.task.internal.models.TaskSummaryImpl;
 import pro.taskana.workbasket.api.WorkbasketPermission;
 import pro.taskana.workbasket.api.WorkbasketService;
 import pro.taskana.workbasket.api.exceptions.WorkbasketNotFoundException;
@@ -29,14 +36,6 @@ import pro.taskana.workbasket.internal.WorkbasketQueryImpl;
 /** This class is responsible for the transfer of Tasks to another Workbasket. */
 final class TaskTransferrer {
 
-  private static final String TASK_ID_LIST_NULL_OR_EMPTY = "TaskIds must not be null or empty.";
-  private static final String TASK_IN_END_STATE =
-      "Task '%s' is in end state and cannot be transferred.";
-  private static final String TASK_NOT_FOUND = "Task '%s' was not found.";
-  private static final String WORKBASKET_MARKED_FOR_DELETION =
-      "Workbasket '%s' was marked for deletion.";
-  private static final String WORKBASKET_WITHOUT_TRANSFER_PERMISSION =
-      "Workbasket of Task '%s' got no TRANSFER permission.";
   private final InternalTaskanaEngine taskanaEngine;
   private final WorkbasketService workbasketService;
   private final TaskServiceImpl taskService;
@@ -56,7 +55,7 @@ final class TaskTransferrer {
       throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException,
           InvalidStateException {
     WorkbasketSummary destinationWorkbasket =
-        workbasketService.getWorkbasket(destinationWorkbasketId);
+        workbasketService.getWorkbasket(destinationWorkbasketId).asSummary();
     return transferSingleTask(taskId, destinationWorkbasket, setTransferFlag);
   }
 
@@ -68,7 +67,7 @@ final class TaskTransferrer {
       throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException,
           InvalidStateException {
     WorkbasketSummary destinationWorkbasket =
-        workbasketService.getWorkbasket(destinationWorkbasketKey, destinationDomain);
+        workbasketService.getWorkbasket(destinationWorkbasketKey, destinationDomain).asSummary();
     return transferSingleTask(taskId, destinationWorkbasket, setTransferFlag);
   }
 
@@ -76,7 +75,7 @@ final class TaskTransferrer {
       List<String> taskIds, String destinationWorkbasketId, boolean setTransferFlag)
       throws NotAuthorizedException, WorkbasketNotFoundException, InvalidArgumentException {
     WorkbasketSummary destinationWorkbasket =
-        workbasketService.getWorkbasket(destinationWorkbasketId);
+        workbasketService.getWorkbasket(destinationWorkbasketId).asSummary();
     checkDestinationWorkbasket(destinationWorkbasket);
 
     return transferMultipleTasks(taskIds, destinationWorkbasket, setTransferFlag);
@@ -89,7 +88,7 @@ final class TaskTransferrer {
       boolean setTransferFlag)
       throws NotAuthorizedException, WorkbasketNotFoundException, InvalidArgumentException {
     WorkbasketSummary destinationWorkbasket =
-        workbasketService.getWorkbasket(destinationWorkbasketKey, destinationDomain);
+        workbasketService.getWorkbasket(destinationWorkbasketKey, destinationDomain).asSummary();
     checkDestinationWorkbasket(destinationWorkbasket);
 
     return transferMultipleTasks(taskIds, destinationWorkbasket, setTransferFlag);
@@ -99,17 +98,21 @@ final class TaskTransferrer {
       String taskId, WorkbasketSummary destinationWorkbasket, boolean setTransferFlag)
       throws NotAuthorizedException, TaskNotFoundException, WorkbasketNotFoundException,
           InvalidStateException {
-    TaskImpl task = new TaskImpl();
     try {
       taskanaEngine.openConnection();
-      task = (TaskImpl) taskService.getTask(taskId);
+      TaskImpl task = (TaskImpl) taskService.getTask(taskId);
+      TaskImpl oldTask = task.copy();
+      oldTask.setId(task.getId());
+      oldTask.setExternalId(task.getExternalId());
+
       WorkbasketSummary originWorkbasket = task.getWorkbasketSummary();
       checkPreconditionsForTransferTask(task, destinationWorkbasket, originWorkbasket);
 
-      modifyTaskParameters(task, destinationWorkbasket, setTransferFlag);
+      applyTransferValuesForTask(task, destinationWorkbasket, setTransferFlag);
       taskMapper.update(task);
       if (HistoryEventManager.isHistoryEnabled()) {
-        createTransferredEvent(task, originWorkbasket.getId(), destinationWorkbasket.getId());
+        createTransferredEvent(
+            oldTask, task, originWorkbasket.getId(), destinationWorkbasket.getId());
       }
 
       return task;
@@ -124,7 +127,7 @@ final class TaskTransferrer {
       boolean setTransferFlag)
       throws InvalidArgumentException {
     if (taskToBeTransferred == null || taskToBeTransferred.isEmpty()) {
-      throw new InvalidArgumentException(TASK_ID_LIST_NULL_OR_EMPTY);
+      throw new InvalidArgumentException("TaskIds must not be null or empty.");
     }
     BulkOperationResults<String, TaskanaException> bulkLog = new BulkOperationResults<>();
     List<String> taskIds = new ArrayList<>(taskToBeTransferred);
@@ -132,9 +135,14 @@ final class TaskTransferrer {
     try {
       taskanaEngine.openConnection();
 
-      List<MinimalTaskSummary> taskSummaries = taskMapper.findExistingTasks(taskIds, null);
-      removeNotTransferableTasks(taskIds, taskSummaries, bulkLog);
-      updateTransferableTasks(taskIds, taskSummaries, destinationWorkbasket, setTransferFlag);
+      List<TaskSummary> taskSummaries =
+          taskanaEngine
+              .getEngine()
+              .runAsAdmin(
+                  () -> taskService.createTaskQuery().idIn(taskIds.toArray(new String[0])).list());
+      taskSummaries =
+          filterOutTasksWhichDoNotMatchTransferCriteria(taskIds, taskSummaries, bulkLog);
+      updateTransferableTasks(taskSummaries, destinationWorkbasket, setTransferFlag);
 
       return bulkLog;
     } finally {
@@ -146,7 +154,8 @@ final class TaskTransferrer {
       Task task, WorkbasketSummary destinationWorkbasket, WorkbasketSummary originWorkbasket)
       throws NotAuthorizedException, WorkbasketNotFoundException, InvalidStateException {
     if (task.getState().isEndState()) {
-      throw new InvalidStateException(String.format(TASK_IN_END_STATE, task.getId()));
+      throw new InvalidStateException(
+          String.format("Task '%s' is in end state and cannot be transferred.", task.getId()));
     }
     workbasketService.checkAuthorization(originWorkbasket.getId(), WorkbasketPermission.TRANSFER);
     checkDestinationWorkbasket(destinationWorkbasket);
@@ -160,101 +169,107 @@ final class TaskTransferrer {
     if (destinationWorkbasket.isMarkedForDeletion()) {
       throw new WorkbasketNotFoundException(
           destinationWorkbasket.getId(),
-          String.format(WORKBASKET_MARKED_FOR_DELETION, destinationWorkbasket.getId()));
+          String.format("Workbasket '%s' was marked for deletion.", destinationWorkbasket.getId()));
     }
   }
 
-  private void removeNotTransferableTasks(
+  private List<TaskSummary> filterOutTasksWhichDoNotMatchTransferCriteria(
       List<String> taskIds,
-      List<MinimalTaskSummary> taskSummaries,
+      List<TaskSummary> taskSummaries,
       BulkOperationResults<String, TaskanaException> bulkLog) {
-    List<WorkbasketSummary> sourceWorkbaskets =
-        getSourceWorkbasketsWithTransferPermission(taskSummaries);
 
-    taskIds.removeIf(id -> !taskIsTransferable(id, taskSummaries, sourceWorkbaskets, bulkLog));
-    taskSummaries.removeIf(task -> !taskIds.contains(task.getTaskId()));
+    Map<String, TaskSummary> taskIdToTaskSummary =
+        taskSummaries.stream().collect(Collectors.toMap(TaskSummary::getId, Function.identity()));
+
+    Set<String> workbasketIds = getSourceWorkbasketIdsWithTransferPermission(taskSummaries);
+
+    List<TaskSummary> filteredOutTasks = new ArrayList<>(taskIds.size());
+
+    for (String taskId : new HashSet<>(taskIds)) {
+      TaskSummary taskSummary = taskIdToTaskSummary.get(taskId);
+      Optional<TaskanaException> error =
+          checkTaskForTransferCriteria(workbasketIds, taskId, taskSummary);
+      if (error.isPresent()) {
+        bulkLog.addError(taskId, error.get());
+      } else {
+        filteredOutTasks.add(taskSummary);
+      }
+    }
+    return filteredOutTasks;
   }
 
-  private List<WorkbasketSummary> getSourceWorkbasketsWithTransferPermission(
-      List<MinimalTaskSummary> taskSummaries) {
-    Set<String> workbasketIds =
-        taskSummaries.stream().map(MinimalTaskSummary::getWorkbasketId).collect(Collectors.toSet());
+  private Optional<TaskanaException> checkTaskForTransferCriteria(
+      Set<String> sourceWorkbasketIds, String taskId, TaskSummary taskSummary) {
+    TaskanaException error = null;
+    if (taskId == null || taskId.isEmpty()) {
+      error = new InvalidArgumentException("TaskId should not be null or empty");
+    } else if (taskSummary == null) {
+      error =
+          new TaskNotFoundException(
+              taskId, String.format("Task with id '%s' was not found.", taskId));
+    } else if (taskSummary.getState().isEndState()) {
+      error =
+          new InvalidStateException(
+              String.format("Task in end state with id '%s' cannot be transferred.", taskId));
+    } else if (!sourceWorkbasketIds.contains(taskSummary.getWorkbasketSummary().getId())) {
+      error =
+          new NotAuthorizedException(
+              "The workbasket of this task got not TRANSFER permissions. TaskId=" + taskId,
+              taskanaEngine.getEngine().getCurrentUserContext().getUserid());
+    }
+    return Optional.ofNullable(error);
+  }
+
+  private Set<String> getSourceWorkbasketIdsWithTransferPermission(
+      List<TaskSummary> taskSummaries) {
+    if (taskSummaries.isEmpty()) {
+      return Collections.emptySet();
+    }
 
     WorkbasketQueryImpl query = (WorkbasketQueryImpl) workbasketService.createWorkbasketQuery();
     query.setUsedToAugmentTasks(true);
-
-    List<WorkbasketSummary> sourceWorkbaskets = new ArrayList<>();
-    if (!workbasketIds.isEmpty()) {
-      sourceWorkbaskets.addAll(
-          query
-              .callerHasPermission(WorkbasketPermission.TRANSFER)
-              .idIn(workbasketIds.toArray(new String[0]))
-              .list());
-    }
-    return sourceWorkbaskets;
-  }
-
-  private boolean taskIsTransferable(
-      String currentTaskId,
-      List<MinimalTaskSummary> taskSummaries,
-      List<WorkbasketSummary> sourceWorkbaskets,
-      BulkOperationResults<String, TaskanaException> bulkLog) {
-    if (currentTaskId == null || currentTaskId.isEmpty()) {
-      return false;
-    }
-    MinimalTaskSummary currentTaskSummary =
+    String[] workbasketIds =
         taskSummaries.stream()
-            .filter(t -> currentTaskId.equals(t.getTaskId()))
-            .findFirst()
-            .orElse(null);
+            .map(TaskSummary::getWorkbasketSummary)
+            .map(WorkbasketSummary::getId)
+            .distinct()
+            .toArray(String[]::new);
 
-    if (currentTaskSummary == null) {
-      bulkLog.addError(
-          currentTaskId,
-          new TaskNotFoundException(currentTaskId, String.format(TASK_NOT_FOUND, currentTaskId)));
-      return false;
-    } else if (currentTaskSummary.getTaskState().isEndState()) {
-      bulkLog.addError(
-          currentTaskId,
-          new InvalidStateException(String.format(TASK_IN_END_STATE, currentTaskId)));
-      return false;
-    } else if (sourceWorkbaskets.stream()
-        .noneMatch(wb -> currentTaskSummary.getWorkbasketId().equals(wb.getId()))) {
-      bulkLog.addError(
-          currentTaskId,
-          new NotAuthorizedException(
-              String.format(WORKBASKET_WITHOUT_TRANSFER_PERMISSION, currentTaskId),
-              taskanaEngine.getEngine().getCurrentUserContext().getUserid()));
-      return false;
-    }
-    return true;
+    List<WorkbasketSummary> sourceWorkbaskets =
+        query.callerHasPermission(WorkbasketPermission.TRANSFER).idIn(workbasketIds).list();
+    return sourceWorkbaskets.stream().map(WorkbasketSummary::getId).collect(Collectors.toSet());
   }
 
   private void updateTransferableTasks(
-      List<String> taskIds,
-      List<MinimalTaskSummary> taskSummaries,
+      List<TaskSummary> taskSummaries,
       WorkbasketSummary destinationWorkbasket,
       boolean setTransferFlag) {
-    if (!taskIds.isEmpty()) {
+    if (!taskSummaries.isEmpty()) {
       TaskImpl updateObject = new TaskImpl();
-      modifyTaskParameters(updateObject, destinationWorkbasket, setTransferFlag);
-      taskMapper.updateTransfered(taskIds, updateObject);
+      applyTransferValuesForTask(updateObject, destinationWorkbasket, setTransferFlag);
+      taskMapper.updateTransfered(
+          taskSummaries.stream().map(TaskSummary::getId).collect(Collectors.toSet()), updateObject);
 
       if (HistoryEventManager.isHistoryEnabled()) {
         taskSummaries.forEach(
-            task -> {
-              updateObject.setId(task.getTaskId());
+            oldSummary -> {
+              TaskSummaryImpl newSummary = (TaskSummaryImpl) oldSummary.copy();
+              newSummary.setId(oldSummary.getId());
+              newSummary.setExternalId(oldSummary.getExternalId());
+              applyTransferValuesForTask(newSummary, destinationWorkbasket, setTransferFlag);
+
               createTransferredEvent(
-                  updateObject,
-                  task.getWorkbasketId(),
-                  updateObject.getWorkbasketSummary().getId());
+                  oldSummary,
+                  newSummary,
+                  oldSummary.getWorkbasketSummary().getId(),
+                  newSummary.getWorkbasketSummary().getId());
             });
       }
     }
   }
 
-  private void modifyTaskParameters(
-      TaskImpl task, WorkbasketSummary workbasket, boolean setTransferFlag) {
+  private void applyTransferValuesForTask(
+      TaskSummaryImpl task, WorkbasketSummary workbasket, boolean setTransferFlag) {
     task.setRead(false);
     task.setTransferred(setTransferFlag);
     task.setState(TaskState.READY);
@@ -265,13 +280,18 @@ final class TaskTransferrer {
   }
 
   private void createTransferredEvent(
-      Task task, String originWorkbasketId, String destinationWorkbasketId) {
+      TaskSummary oldTask,
+      TaskSummary newTask,
+      String originWorkbasketId,
+      String destinationWorkbasketId) {
+    String details = ObjectAttributeChangeDetector.determineChangesInAttributes(oldTask, newTask);
     historyEventManager.createEvent(
         new TaskTransferredEvent(
             IdGenerator.generateWithPrefix(IdGenerator.ID_PREFIX_TASK_HISTORY_EVENT),
-            task,
+            newTask,
             originWorkbasketId,
             destinationWorkbasketId,
-            taskanaEngine.getEngine().getCurrentUserContext().getUserid()));
+            taskanaEngine.getEngine().getCurrentUserContext().getUserid(),
+            details));
   }
 }
diff --git a/lib/taskana-core/src/main/java/pro/taskana/task/internal/models/TaskSummaryImpl.java b/lib/taskana-core/src/main/java/pro/taskana/task/internal/models/TaskSummaryImpl.java
index 0700c752c..6453dbbd4 100644
--- a/lib/taskana-core/src/main/java/pro/taskana/task/internal/models/TaskSummaryImpl.java
+++ b/lib/taskana-core/src/main/java/pro/taskana/task/internal/models/TaskSummaryImpl.java
@@ -17,7 +17,7 @@ import pro.taskana.task.api.models.TaskSummary;
 import pro.taskana.workbasket.api.models.WorkbasketSummary;
 import pro.taskana.workbasket.internal.models.WorkbasketSummaryImpl;
 
-/** Entity which contains the most important informations about a Task. */
+/** Entity which contains the most important information about a Task. */
 public class TaskSummaryImpl implements TaskSummary {
 
   protected String id;
diff --git a/lib/taskana-core/src/test/java/acceptance/task/QueryTasksAccTest.java b/lib/taskana-core/src/test/java/acceptance/task/QueryTasksAccTest.java
index ee8a5b8ad..8bda79f1f 100644
--- a/lib/taskana-core/src/test/java/acceptance/task/QueryTasksAccTest.java
+++ b/lib/taskana-core/src/test/java/acceptance/task/QueryTasksAccTest.java
@@ -276,23 +276,22 @@ class QueryTasksAccTest extends AbstractAccTest {
   Stream<DynamicTest> testQueryForCustomX() {
     List<Triplet<TaskCustomField, String[], Integer>> list =
         List.of(
-            new Triplet<>(
-                TaskCustomField.CUSTOM_1, new String[] {"custom%", "p%", "%xyz%", "efg"}, 3),
-            new Triplet<>(TaskCustomField.CUSTOM_2, new String[] {"custom%", "a%"}, 2),
-            new Triplet<>(TaskCustomField.CUSTOM_3, new String[] {"ffg"}, 1),
-            new Triplet<>(TaskCustomField.CUSTOM_4, new String[] {"%ust%", "%ty"}, 2),
-            new Triplet<>(TaskCustomField.CUSTOM_5, new String[] {"ew", "al"}, 6),
-            new Triplet<>(TaskCustomField.CUSTOM_6, new String[] {"%custom6%", "%vvg%", "11%"}, 5),
-            new Triplet<>(TaskCustomField.CUSTOM_7, new String[] {"%"}, 2),
-            new Triplet<>(TaskCustomField.CUSTOM_8, new String[] {"%"}, 2),
-            new Triplet<>(TaskCustomField.CUSTOM_9, new String[] {"%"}, 2),
-            new Triplet<>(TaskCustomField.CUSTOM_10, new String[] {"%"}, 3),
-            new Triplet<>(TaskCustomField.CUSTOM_11, new String[] {"%"}, 3),
-            new Triplet<>(TaskCustomField.CUSTOM_12, new String[] {"%"}, 3),
-            new Triplet<>(TaskCustomField.CUSTOM_13, new String[] {"%"}, 3),
-            new Triplet<>(TaskCustomField.CUSTOM_14, new String[] {"%"}, 88),
-            new Triplet<>(TaskCustomField.CUSTOM_15, new String[] {"%"}, 3),
-            new Triplet<>(TaskCustomField.CUSTOM_16, new String[] {"%"}, 3));
+            Triplet.of(TaskCustomField.CUSTOM_1, new String[] {"custom%", "p%", "%xyz%", "efg"}, 3),
+            Triplet.of(TaskCustomField.CUSTOM_2, new String[] {"custom%", "a%"}, 2),
+            Triplet.of(TaskCustomField.CUSTOM_3, new String[] {"ffg"}, 1),
+            Triplet.of(TaskCustomField.CUSTOM_4, new String[] {"%ust%", "%ty"}, 2),
+            Triplet.of(TaskCustomField.CUSTOM_5, new String[] {"ew", "al"}, 6),
+            Triplet.of(TaskCustomField.CUSTOM_6, new String[] {"%custom6%", "%vvg%", "11%"}, 5),
+            Triplet.of(TaskCustomField.CUSTOM_7, new String[] {"%"}, 2),
+            Triplet.of(TaskCustomField.CUSTOM_8, new String[] {"%"}, 2),
+            Triplet.of(TaskCustomField.CUSTOM_9, new String[] {"%"}, 2),
+            Triplet.of(TaskCustomField.CUSTOM_10, new String[] {"%"}, 3),
+            Triplet.of(TaskCustomField.CUSTOM_11, new String[] {"%"}, 3),
+            Triplet.of(TaskCustomField.CUSTOM_12, new String[] {"%"}, 3),
+            Triplet.of(TaskCustomField.CUSTOM_13, new String[] {"%"}, 3),
+            Triplet.of(TaskCustomField.CUSTOM_14, new String[] {"%"}, 88),
+            Triplet.of(TaskCustomField.CUSTOM_15, new String[] {"%"}, 3),
+            Triplet.of(TaskCustomField.CUSTOM_16, new String[] {"%"}, 3));
     assertThat(list).hasSameSizeAs(TaskCustomField.values());
 
     return DynamicTest.stream(
diff --git a/lib/taskana-core/src/test/java/acceptance/task/TransferTaskAccTest.java b/lib/taskana-core/src/test/java/acceptance/task/TransferTaskAccTest.java
index 4fa559859..f7c850350 100644
--- a/lib/taskana-core/src/test/java/acceptance/task/TransferTaskAccTest.java
+++ b/lib/taskana-core/src/test/java/acceptance/task/TransferTaskAccTest.java
@@ -7,8 +7,8 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import acceptance.AbstractAccTest;
 import java.time.Instant;
 import java.time.temporal.ChronoUnit;
-import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
 import org.junit.jupiter.api.Test;
@@ -34,21 +34,18 @@ import pro.taskana.workbasket.api.models.Workbasket;
 @ExtendWith(JaasExtension.class)
 class TransferTaskAccTest extends AbstractAccTest {
 
-  TransferTaskAccTest() {
-    super();
-  }
+  private static final TaskService TASK_SERVICE = taskanaEngine.getTaskService();
 
   @WithAccessId(user = "teamlead-1", groups = GROUP_1_DN)
   @Test
   void should_TransferTaskToWorkbasket_When_WorkbasketIdIsProvided() throws Exception {
-    TaskService taskService = taskanaEngine.getTaskService();
-    Task task = taskService.getTask("TKI:000000000000000000000000000000000003");
-    taskService.claim(task.getId());
-    taskService.setTaskRead(task.getId(), true);
+    Task task = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000003");
+    TASK_SERVICE.claim(task.getId());
+    TASK_SERVICE.setTaskRead(task.getId(), true);
 
-    taskService.transfer(task.getId(), "WBI:100000000000000000000000000000000006");
+    TASK_SERVICE.transfer(task.getId(), "WBI:100000000000000000000000000000000006");
 
-    Task transferredTask = taskService.getTask("TKI:000000000000000000000000000000000003");
+    Task transferredTask = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000003");
     assertThat(transferredTask).isNotNull();
     assertThat(transferredTask.isTransferred()).isTrue();
     assertThat(transferredTask.isRead()).isFalse();
@@ -60,14 +57,13 @@ class TransferTaskAccTest extends AbstractAccTest {
   @TestTemplate
   void should_TransferTask_When_NoExplicitPermissionsButUserIsInAdministrativeRole()
       throws Exception {
-    TaskService taskService = taskanaEngine.getTaskService();
-    Task task = taskService.getTask("TKI:000000000000000000000000000000000003");
-    taskService.claim(task.getId());
-    taskService.setTaskRead(task.getId(), true);
+    Task task = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000003");
+    TASK_SERVICE.claim(task.getId());
+    TASK_SERVICE.setTaskRead(task.getId(), true);
 
-    taskService.transfer(task.getId(), "WBI:100000000000000000000000000000000006");
+    TASK_SERVICE.transfer(task.getId(), "WBI:100000000000000000000000000000000006");
 
-    Task transferredTask = taskService.getTask("TKI:000000000000000000000000000000000003");
+    Task transferredTask = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000003");
     assertThat(transferredTask).isNotNull();
     assertThat(transferredTask.isTransferred()).isTrue();
     assertThat(transferredTask.isRead()).isFalse();
@@ -77,14 +73,13 @@ class TransferTaskAccTest extends AbstractAccTest {
   @WithAccessId(user = "teamlead-1", groups = GROUP_1_DN)
   @Test
   void should_TransferTaskToWorkbasket_When_WorkbasketKeyAndDomainIsProvided() throws Exception {
-    TaskService taskService = taskanaEngine.getTaskService();
-    Task task = taskService.getTask("TKI:000000000000000000000000000000000003");
-    taskService.claim(task.getId());
-    taskService.setTaskRead(task.getId(), true);
+    Task task = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000003");
+    TASK_SERVICE.claim(task.getId());
+    TASK_SERVICE.setTaskRead(task.getId(), true);
 
-    taskService.transfer(task.getId(), "USER-1-1", "DOMAIN_A");
+    TASK_SERVICE.transfer(task.getId(), "USER-1-1", "DOMAIN_A");
 
-    Task transferredTask = taskService.getTask("TKI:000000000000000000000000000000000003");
+    Task transferredTask = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000003");
     assertThat(transferredTask).isNotNull();
     assertThat(transferredTask.isTransferred()).isTrue();
     assertThat(transferredTask.isRead()).isFalse();
@@ -94,11 +89,10 @@ class TransferTaskAccTest extends AbstractAccTest {
   @WithAccessId(user = "user-1-1", groups = GROUP_1_DN)
   @Test
   void should_ChangeDomain_When_TransferringTaskToWorkbasketWithDifferentDomain() throws Exception {
-    TaskService taskService = taskanaEngine.getTaskService();
-    Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
+    Task task = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000000");
     String domain1 = task.getDomain();
 
-    Task transferredTask = taskService.transfer(task.getId(), "GPK_B_KSC_1", "DOMAIN_B");
+    Task transferredTask = TASK_SERVICE.transfer(task.getId(), "GPK_B_KSC_1", "DOMAIN_B");
 
     assertThat(transferredTask).isNotNull();
     assertThat(transferredTask.getDomain()).isNotEqualTo(domain1);
@@ -107,54 +101,40 @@ class TransferTaskAccTest extends AbstractAccTest {
   @WithAccessId(user = "user-1-1")
   @Test
   void should_ThrowException_When_UserHasNoTransferAuthorization() throws Exception {
-    TaskService taskService = taskanaEngine.getTaskService();
-    Task task = taskService.getTask("TKI:000000000000000000000000000000000001");
+    Task task = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000001");
 
     ThrowingCallable call =
-        () -> {
-          taskService.transfer(task.getId(), "WBI:100000000000000000000000000000000005");
-        };
+        () -> TASK_SERVICE.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 {
-    TaskService taskService = taskanaEngine.getTaskService();
-    Task task = taskService.getTask("TKI:000000000000000000000000000000000003");
-    taskService.claim(task.getId());
-    taskService.setTaskRead(task.getId(), true);
+    Task task = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000003");
+    TASK_SERVICE.claim(task.getId());
+    TASK_SERVICE.setTaskRead(task.getId(), true);
 
-    ThrowingCallable call =
-        () -> {
-          taskService.transfer(task.getId(), "INVALID");
-        };
+    ThrowingCallable call = () -> TASK_SERVICE.transfer(task.getId(), "INVALID");
     assertThatThrownBy(call).isInstanceOf(WorkbasketNotFoundException.class);
   }
 
   @WithAccessId(user = "teamlead-1")
   @Test
   void should_ThrowException_When_TaskToTransferDoesNotExist() {
-    TaskService taskService = taskanaEngine.getTaskService();
-
     ThrowingCallable call =
-        () -> {
-          taskService.transfer("Invalid", "WBI:100000000000000000000000000000000005");
-        };
+        () -> TASK_SERVICE.transfer("Invalid", "WBI:100000000000000000000000000000000005");
     assertThatThrownBy(call).isInstanceOf(TaskNotFoundException.class);
   }
 
   @WithAccessId(user = "teamlead-1")
   @Test
   void should_ThrowException_When_TransferWithNoTransferAuthorization() {
-    TaskService taskService = taskanaEngine.getTaskService();
-
     ThrowingCallable call =
-        () -> {
-          taskService.transfer(
-              "TKI:200000000000000000000000000000000007",
-              "WBI:100000000000000000000000000000000001");
-        };
+        () ->
+            TASK_SERVICE.transfer(
+                "TKI:200000000000000000000000000000000007",
+                "WBI:100000000000000000000000000000000001");
     assertThatThrownBy(call)
         .isInstanceOf(NotAuthorizedException.class)
         .extracting(Throwable::getMessage)
@@ -167,13 +147,10 @@ class TransferTaskAccTest extends AbstractAccTest {
   @WithAccessId(user = "user-1-1", groups = GROUP_1_DN)
   @Test
   void should_ThrowException_When_TransferWithNoAppendAuthorization() throws Exception {
-    TaskService taskService = taskanaEngine.getTaskService();
-    Task task = taskService.getTask("TKI:000000000000000000000000000000000002");
+    Task task = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000002");
 
     ThrowingCallable call =
-        () -> {
-          taskService.transfer(task.getId(), "WBI:100000000000000000000000000000000008");
-        };
+        () -> TASK_SERVICE.transfer(task.getId(), "WBI:100000000000000000000000000000000008");
     assertThatThrownBy(call)
         .isInstanceOf(NotAuthorizedException.class)
         .extracting(Throwable::getMessage)
@@ -186,13 +163,10 @@ class TransferTaskAccTest extends AbstractAccTest {
   @WithAccessId(user = "teamlead-1")
   @Test
   void should_ThrowException_When_TaskToTransferIsAlreadyCompleted() throws Exception {
-    TaskService taskService = taskanaEngine.getTaskService();
-    Task task = taskService.getTask("TKI:100000000000000000000000000000000006");
+    Task task = TASK_SERVICE.getTask("TKI:100000000000000000000000000000000006");
 
     ThrowingCallable call =
-        () -> {
-          taskService.transfer(task.getId(), "WBI:100000000000000000000000000000000005");
-        };
+        () -> TASK_SERVICE.transfer(task.getId(), "WBI:100000000000000000000000000000000005");
     assertThatThrownBy(call).isInstanceOf(InvalidStateException.class);
   }
 
@@ -200,18 +174,17 @@ class TransferTaskAccTest extends AbstractAccTest {
   @Test
   void should_BulkTransferTasks_When_WorkbasketIdIsProvided() throws Exception {
     final Instant before = Instant.now().truncatedTo(ChronoUnit.MILLIS);
-    TaskService taskService = taskanaEngine.getTaskService();
-    ArrayList<String> taskIdList = new ArrayList<>();
-    taskIdList.add("TKI:000000000000000000000000000000000004");
-    taskIdList.add("TKI:000000000000000000000000000000000005");
+    List<String> taskIdList =
+        List.of(
+            "TKI:000000000000000000000000000000000004", "TKI:000000000000000000000000000000000005");
 
     BulkOperationResults<String, TaskanaException> results =
-        taskService.transferTasks("WBI:100000000000000000000000000000000006", taskIdList);
+        TASK_SERVICE.transferTasks("WBI:100000000000000000000000000000000006", taskIdList);
     assertThat(results.containsErrors()).isFalse();
 
     final Workbasket wb =
         taskanaEngine.getWorkbasketService().getWorkbasket("USER-1-1", "DOMAIN_A");
-    Task transferredTask = taskService.getTask("TKI:000000000000000000000000000000000004");
+    Task transferredTask = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000004");
     assertThat(transferredTask).isNotNull();
     assertThat(transferredTask.isTransferred()).isTrue();
     assertThat(transferredTask.isRead()).isFalse();
@@ -220,7 +193,7 @@ class TransferTaskAccTest extends AbstractAccTest {
     assertThat(transferredTask.getDomain()).isEqualTo(wb.getDomain());
     assertThat(transferredTask.getModified().isBefore(before)).isFalse();
     assertThat(transferredTask.getOwner()).isNull();
-    transferredTask = taskService.getTask("TKI:000000000000000000000000000000000005");
+    transferredTask = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000005");
     assertThat(transferredTask).isNotNull();
     assertThat(transferredTask.isTransferred()).isTrue();
     assertThat(transferredTask.isRead()).isFalse();
@@ -235,24 +208,26 @@ class TransferTaskAccTest extends AbstractAccTest {
   @Test
   void should_BulkTransferOnlyValidTasks_When_SomeTasksToTransferCauseExceptions()
       throws Exception {
-    TaskService taskService = taskanaEngine.getTaskService();
     final Workbasket wb =
         taskanaEngine.getWorkbasketService().getWorkbasket("USER-1-1", "DOMAIN_A");
     final Instant before = Instant.now().truncatedTo(ChronoUnit.MILLIS);
-    ArrayList<String> taskIdList = new ArrayList<>();
-    taskIdList.add("TKI:000000000000000000000000000000000006"); // working
-    taskIdList.add("TKI:000000000000000000000000000000000041"); // NotAuthorized READ
-    taskIdList.add("TKI:200000000000000000000000000000000008"); // NotAuthorized TRANSFER
-    taskIdList.add(""); // InvalidArgument
-    taskIdList.add(null); // InvalidArgument
-    taskIdList.add("TKI:000000000000000000000000000000000099"); // not existing
-    taskIdList.add("TKI:100000000000000000000000000000000006"); // already completed
+    // we can't use List.of because of the null value we insert
+    List<String> taskIdList =
+        Arrays.asList(
+            "TKI:000000000000000000000000000000000006", // working
+            "TKI:000000000000000000000000000000000041", // NotAuthorized READ
+            "TKI:000000000000000000000000000000000041", // NotAuthorized READ
+            "TKI:200000000000000000000000000000000008", // NotAuthorized TRANSFER
+            "", // InvalidArgument
+            null, // InvalidArgument
+            "TKI:000000000000000000000000000000000099", // not existing
+            "TKI:100000000000000000000000000000000006"); // already completed
 
     BulkOperationResults<String, TaskanaException> results =
-        taskService.transferTasks("WBI:100000000000000000000000000000000006", taskIdList);
+        TASK_SERVICE.transferTasks("WBI:100000000000000000000000000000000006", taskIdList);
     // check for exceptions in bulk
     assertThat(results.containsErrors()).isTrue();
-    assertThat(results.getErrorMap().values()).hasSize(4);
+    assertThat(results.getErrorMap().values()).hasSize(6);
     assertThat(results.getErrorForId("TKI:000000000000000000000000000000000041").getClass())
         .isEqualTo(NotAuthorizedException.class);
     assertThat(results.getErrorForId("TKI:200000000000000000000000000000000008").getClass())
@@ -261,9 +236,11 @@ class TransferTaskAccTest extends AbstractAccTest {
         .isEqualTo(TaskNotFoundException.class);
     assertThat(results.getErrorForId("TKI:100000000000000000000000000000000006").getClass())
         .isEqualTo(InvalidStateException.class);
+    assertThat(results.getErrorForId("").getClass()).isEqualTo(InvalidArgumentException.class);
+    assertThat(results.getErrorForId(null).getClass()).isEqualTo(InvalidArgumentException.class);
 
     // verify valid requests
-    Task transferredTask = taskService.getTask("TKI:000000000000000000000000000000000006");
+    Task transferredTask = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000006");
     assertThat(transferredTask).isNotNull();
     assertThat(transferredTask.isTransferred()).isTrue();
     assertThat(transferredTask.isRead()).isFalse();
@@ -273,12 +250,12 @@ class TransferTaskAccTest extends AbstractAccTest {
     assertThat(transferredTask.getModified().isBefore(before)).isFalse();
     assertThat(transferredTask.getOwner()).isNull();
 
-    transferredTask = taskService.getTask("TKI:200000000000000000000000000000000008");
+    transferredTask = TASK_SERVICE.getTask("TKI:200000000000000000000000000000000008");
     assertThat(transferredTask).isNotNull();
     assertThat(transferredTask.isTransferred()).isFalse();
     assertThat(transferredTask.getWorkbasketKey()).isEqualTo("TPK_VIP");
 
-    transferredTask = taskService.getTask("TKI:100000000000000000000000000000000006");
+    transferredTask = TASK_SERVICE.getTask("TKI:100000000000000000000000000000000006");
     assertThat(transferredTask).isNotNull();
     assertThat(transferredTask.isTransferred()).isFalse();
     assertThat(transferredTask.getWorkbasketKey()).isEqualTo("TEAMLEAD-1");
@@ -287,15 +264,14 @@ class TransferTaskAccTest extends AbstractAccTest {
   @WithAccessId(user = "teamlead-1")
   @Test
   void should_ThrowException_When_BulkTransferTasksWithoutAppendPermissionOnTarget() {
-    TaskService taskService = taskanaEngine.getTaskService();
-    ArrayList<String> taskIdList = new ArrayList<>();
-    taskIdList.add("TKI:000000000000000000000000000000000006"); // working
-    taskIdList.add("TKI:000000000000000000000000000000000041"); // NotAuthorized READ
+
+    List<String> taskIdList =
+        List.of(
+            "TKI:000000000000000000000000000000000006", // working
+            "TKI:000000000000000000000000000000000041"); // NotAuthorized READ
 
     ThrowingCallable call =
-        () -> {
-          taskService.transferTasks("WBI:100000000000000000000000000000000010", taskIdList);
-        };
+        () -> TASK_SERVICE.transferTasks("WBI:100000000000000000000000000000000010", taskIdList);
     assertThatThrownBy(call)
         .isInstanceOf(NotAuthorizedException.class)
         .hasMessageContaining("APPEND");
@@ -304,13 +280,10 @@ class TransferTaskAccTest extends AbstractAccTest {
   @WithAccessId(user = "teamlead-1", groups = GROUP_1_DN)
   @Test
   void should_TransferTasks_When_TransferringTasksWithListNotSupportingRemove() {
-    TaskService taskService = taskanaEngine.getTaskService();
     List<String> taskIds = List.of("TKI:000000000000000000000000000000000006");
 
     ThrowingCallable call =
-        () -> {
-          taskService.transferTasks("WBI:100000000000000000000000000000000006", taskIds);
-        };
+        () -> TASK_SERVICE.transferTasks("WBI:100000000000000000000000000000000006", taskIds);
 
     assertThatCode(call).doesNotThrowAnyException();
   }
@@ -318,39 +291,20 @@ class TransferTaskAccTest extends AbstractAccTest {
   @WithAccessId(user = "teamlead-1", groups = GROUP_1_DN)
   @Test
   void should_ThrowException_When_TransferredTaskListIsNull() {
-    TaskService taskService = taskanaEngine.getTaskService();
-    // test with invalid list
-
     ThrowingCallable call =
-        () -> taskService.transferTasks("WBI:100000000000000000000000000000000006", null);
+        () -> TASK_SERVICE.transferTasks("WBI:100000000000000000000000000000000006", null);
     assertThatThrownBy(call)
         .isInstanceOf(InvalidArgumentException.class)
         .hasMessage("TaskIds must not be null or empty.");
   }
 
-  @WithAccessId(user = "teamlead-1", groups = GROUP_1_DN)
-  @Test
-  void should_ThrowException_When_TransferringTasksWithOnlyInvalidTasksIds() throws Exception {
-    TaskService taskService = taskanaEngine.getTaskService();
-
-    // test with list containing only invalid arguments
-    BulkOperationResults<String, TaskanaException> bulklog =
-        taskService.transferTasks(
-            "WBI:100000000000000000000000000000000006",
-            /* we can't use List.of because of the null value we insert */
-            Arrays.asList("", "", "", null));
-    assertThat(bulklog.getFailedIds()).isEmpty();
-  }
-
   @WithAccessId(user = "teamlead-1", groups = GROUP_1_DN)
   @Test
   void should_ThrowException_When_TransferringEmptyTaskIdList() {
-    TaskService taskService = taskanaEngine.getTaskService();
-    List<String> taskIds = new ArrayList<>();
     ThrowingCallable call =
-        () -> {
-          taskService.transferTasks("WBI:100000000000000000000000000000000006", taskIds);
-        };
+        () ->
+            TASK_SERVICE.transferTasks(
+                "WBI:100000000000000000000000000000000006", Collections.emptyList());
     assertThatThrownBy(call).isInstanceOf(InvalidArgumentException.class);
   }
 
@@ -358,19 +312,17 @@ class TransferTaskAccTest extends AbstractAccTest {
   @Test
   void should_BulkTransferTasks_When_WorkbasketKeyAndDomainIsProvided() throws Exception {
     final Instant before = Instant.now().truncatedTo(ChronoUnit.MILLIS);
-    TaskService taskService = taskanaEngine.getTaskService();
-    List<String> taskIdList = new ArrayList<>();
-
-    taskIdList.add("TKI:000000000000000000000000000000000023");
-    taskIdList.add("TKI:000000000000000000000000000000000024");
+    List<String> taskIdList =
+        List.of(
+            "TKI:000000000000000000000000000000000023", "TKI:000000000000000000000000000000000024");
 
     BulkOperationResults<String, TaskanaException> results =
-        taskService.transferTasks("GPK_B_KSC_1", "DOMAIN_B", taskIdList);
+        TASK_SERVICE.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 = taskService.getTask("TKI:000000000000000000000000000000000023");
+    Task transferredTask = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000023");
     assertThat(transferredTask).isNotNull();
     assertThat(transferredTask.isTransferred()).isTrue();
     assertThat(transferredTask.isRead()).isFalse();
@@ -379,7 +331,7 @@ class TransferTaskAccTest extends AbstractAccTest {
     assertThat(transferredTask.getDomain()).isEqualTo(wb.getDomain());
     assertThat(transferredTask.getModified().isBefore(before)).isFalse();
     assertThat(transferredTask.getOwner()).isNull();
-    transferredTask = taskService.getTask("TKI:000000000000000000000000000000000024");
+    transferredTask = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000024");
     assertThat(transferredTask).isNotNull();
     assertThat(transferredTask.isTransferred()).isTrue();
     assertThat(transferredTask.isRead()).isFalse();
@@ -393,13 +345,12 @@ class TransferTaskAccTest extends AbstractAccTest {
   @WithAccessId(user = "admin")
   @Test
   void should_NotSetTheTransferFlag_When_SetTransferFlagNotRequested() throws Exception {
-    TaskService taskService = taskanaEngine.getTaskService();
-    taskService.transfer(
+    TASK_SERVICE.transfer(
         "TKI:000000000000000000000000000000000003",
         "WBI:100000000000000000000000000000000006",
         false);
 
-    Task transferredTask = taskService.getTask("TKI:000000000000000000000000000000000003");
+    Task transferredTask = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000003");
     assertThat(transferredTask).isNotNull();
     assertThat(transferredTask.isTransferred()).isFalse();
   }
@@ -408,8 +359,7 @@ class TransferTaskAccTest extends AbstractAccTest {
   @Test
   void should_NotSetTheTransferFlagWithinBulkTransfer_When_SetTransferFlagNotRequested()
       throws Exception {
-    TaskService taskService = taskanaEngine.getTaskService();
-    taskService.transferTasks(
+    TASK_SERVICE.transferTasks(
         "WBI:100000000000000000000000000000000006",
         List.of(
             "TKI:000000000000000000000000000000000003",
@@ -418,7 +368,7 @@ class TransferTaskAccTest extends AbstractAccTest {
         false);
 
     List<TaskSummary> transferredTasks =
-        taskService
+        TASK_SERVICE
             .createTaskQuery()
             .idIn(
                 "TKI:000000000000000000000000000000000004",