TSK-1413: Fix bulk transfer task history event creation

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

@@ -3,6 +3,7 @@ package acceptance.events.task;
 import static org.assertj.core.api.Assertions.assertThat;
 
 import acceptance.AbstractAccTest;
+import java.util.ArrayList;
 import java.util.List;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
@@ -48,4 +49,52 @@ class CreateHistoryEventOnTaskTransferAccTest extends AbstractAccTest {
 
     assertThat(eventType).isEqualTo(TaskHistoryEventType.TRANSFERRED.getName());
   }
+
+  @WithAccessId(user = "admin")
+  @Test
+  void should_CreateTransferredHistoryEvents_When_TaskBulkTransfer() throws Exception {
+
+    final String taskId = "TKI:000000000000000000000000000000000004";
+    final String taskId2 = "TKI:000000000000000000000000000000000002";
+
+    final String destinationWorkbasketKey = "WBI:100000000000000000000000000000000007";
+
+    List<String> taskIds = new ArrayList<>();
+
+    taskIds.add(taskId);
+    taskIds.add(taskId2);
+
+    TaskHistoryQueryMapper taskHistoryQueryMapper = getHistoryQueryMapper();
+
+    List<TaskHistoryEvent> events =
+        taskHistoryQueryMapper.queryHistoryEvents(
+            (TaskHistoryQueryImpl)
+                historyService.createTaskHistoryQuery().taskIdIn(taskIds.toArray(new String[0])));
+
+    assertThat(events).isEmpty();
+
+    taskService.transferTasks(destinationWorkbasketKey, taskIds);
+    events =
+        taskHistoryQueryMapper.queryHistoryEvents(
+            (TaskHistoryQueryImpl)
+                historyService
+                    .createTaskHistoryQuery()
+                    .taskIdIn(taskIds.stream().toArray(String[]::new)));
+
+    assertThat(events).hasSize(2);
+
+    assertThat(events)
+        .extracting(TaskHistoryEvent::getEventType)
+        .containsOnly(TaskHistoryEventType.TRANSFERRED.getName());
+
+    assertThat(events)
+        .extracting(TaskHistoryEvent::getOldValue)
+        .containsExactlyInAnyOrder(
+            "WBI:100000000000000000000000000000000006", "WBI:100000000000000000000000000000000001");
+
+    assertThat(events)
+        .extracting(TaskHistoryEvent::getNewValue)
+        .containsOnly("WBI:100000000000000000000000000000000007");
+
+  }
 }

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

@@ -1,21 +1,16 @@
 package pro.taskana.spi.history.api.events.task;
 
 import pro.taskana.task.api.models.Task;
-import pro.taskana.workbasket.api.models.WorkbasketSummary;
 
 /** Event fired if a task is transferred. */
 public class TaskTransferredEvent extends TaskHistoryEvent {
 
   public TaskTransferredEvent(
-      String id,
+      String id, Task task, String oldWorkbasketId, String newWorkbasketId, String userId) {
-      Task task,
-      WorkbasketSummary oldWorkbasket,
-      WorkbasketSummary newWorkbasket,
-      String userId) {
     super(id, task, userId, null);
     eventType = TaskHistoryEventType.TRANSFERRED.getName();
     created = task.getModified();
-    this.oldValue = oldWorkbasket.getId();
+    this.oldValue = oldWorkbasketId;
-    this.newValue = newWorkbasket.getId();
+    this.newValue = newWorkbasketId;
   }
 }

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

@@ -110,7 +110,8 @@ class TaskTransferrer {
           taskId,
           destinationWorkbasket.getId());
       if (HistoryEventManager.isHistoryEnabled()) {
-        createTaskTransferredEvent(task, oldWorkbasketSummary, destinationWorkbasket.asSummary());
+        createTaskTransferredEvent(
+            task, oldWorkbasketSummary.getId(), destinationWorkbasket.asSummary().getId());
       }
       return task;
     } finally {
@@ -167,7 +168,8 @@ class TaskTransferrer {
           taskId,
           destinationWorkbasketId);
       if (HistoryEventManager.isHistoryEnabled()) {
-        createTaskTransferredEvent(task, oldWorkbasketSummary, destinationWorkbasket.asSummary());
+        createTaskTransferredEvent(
+            task, oldWorkbasketSummary.getId(), destinationWorkbasketId);
       }
       return task;
     } finally {
@@ -358,13 +360,13 @@ class TaskTransferrer {
   }
 
   private void createTaskTransferredEvent(
-      Task task, WorkbasketSummary oldWorkbasketSummary, WorkbasketSummary newWorkbasketSummary) {
+      Task task, String oldWorkbasketId, String newWorkbasketId) {
     historyEventManager.createEvent(
         new TaskTransferredEvent(
             IdGenerator.generateWithPrefix(IdGenerator.ID_PREFIX_TASK_HISTORY_EVENT),
             task,
-            oldWorkbasketSummary,
+            oldWorkbasketId,
-            newWorkbasketSummary,
+            newWorkbasketId,
             taskanaEngine.getEngine().getCurrentUserContext().getUserid()));
   }
 
@@ -408,17 +410,20 @@ class TaskTransferrer {
     taskSummaries
         .forEach(
             task -> {
-              TaskImpl newTask = (TaskImpl) taskService.newTask(task.getWorkbasketId());
+
-              newTask.setWorkbasketSummary(updateObject.getWorkbasketSummary());
+              TaskImpl transferredTask = (TaskImpl) taskService.newTask(task.getWorkbasketId());
-              newTask.setRead(updateObject.isRead());
+              transferredTask.setId(task.getTaskId());
-              newTask.setTransferred(updateObject.isTransferred());
+              transferredTask.setRead(updateObject.isRead());
-              newTask.setWorkbasketSummary(updateObject.getWorkbasketSummary());
+              transferredTask.setTransferred(updateObject.isTransferred());
-              newTask.setDomain(updateObject.getDomain());
+              transferredTask.setWorkbasketSummary(updateObject.getWorkbasketSummary());
-              newTask.setModified(updateObject.getModified());
+              transferredTask.setDomain(updateObject.getDomain());
-              newTask.setState(updateObject.getState());
+              transferredTask.setModified(updateObject.getModified());
-              newTask.setOwner(updateObject.getOwner());
+              transferredTask.setState(updateObject.getState());
+              transferredTask.setOwner(updateObject.getOwner());
               createTaskTransferredEvent(
-                  newTask, newTask.getWorkbasketSummary(), updateObject.getWorkbasketSummary());
+                  transferredTask,
+                  task.getWorkbasketId(),
+                  updateObject.getWorkbasketSummary().getId());
             });
   }
 }