TSK-1131 updateOwner on multiple tasks

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

@@ -249,7 +249,9 @@ public interface TaskService {
    *     cannot be found
    * @throws NotAuthorizedException if the current user is not authorized to update the task
    * @throws AttachmentPersistenceException if an Attachment with ID will be added multiple times
-   *     without using the task-methods.
+   *     without using the task-methods
+   * @throws InvalidStateException if an attempt is made to change the owner of the task and the
+   *     task is not in state READY .
    */
   Task updateTask(Task task)
       throws InvalidArgumentException, TaskNotFoundException, ConcurrencyException,
@@ -373,4 +375,14 @@ public interface TaskService {
    */
   BulkOperationResults<String, TaskanaException> setCallbackStateForTasks(
       List<String> externalIds, CallbackState state);
+
+  /**
+   * Sets the owner on a list of tasks. The owner will only be set on tasks that are in state READY.
+   *
+   * @param owner the new owner of the tasks
+   * @param taskIds the IDs of the tasks on which the owner is to be set.
+   * @return the result of the operations with Id and Exception for each failed task deletion.
+   */
+  BulkOperationResults<String, TaskanaException> setOwnerOfTasks(
+      String owner, List<String> taskIds);
 }

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

@@ -0,0 +1,13 @@
+package pro.taskana.task.api.exceptions;
+
+import pro.taskana.common.api.exceptions.TaskanaException;
+
+/** This exception will be thrown if a specific task is not in the database. */
+public class UpdateFailedException extends TaskanaException {
+
+  private static final long serialVersionUID = 1L;
+
+  public UpdateFailedException(String msg) {
+    super(msg);
+  }
+}

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

@@ -1,5 +1,6 @@
 package pro.taskana.task.internal;
 
+import java.time.Instant;
 import java.util.List;
 import java.util.Map;
 import org.apache.ibatis.annotations.Delete;
@@ -132,6 +133,16 @@ public interface TaskMapper {
   void setCallbackStateMultiple(
       @Param("externalIds") List<String> externalIds, @Param("state") CallbackState state);
 
+  @Update(
+      "<script>UPDATE TASK SET OWNER = #{owner}, MODIFIED = #{modified} "
+          + "WHERE STATE = 'READY' "
+          + "AND ID IN <foreach item='taskId' index='index' separator=',' open='(' close=')' collection='taskIds'>#{taskId}</foreach> "
+          + "</script>")
+  int setOwnerOfTasks(
+      @Param("owner") String owner,
+      @Param("taskIds") List<String> taskIds,
+      @Param("modified") Instant modified);
+
   @Select(
       "<script>SELECT ID, EXTERNAL_ID, CREATED, CLAIMED, COMPLETED, MODIFIED, PLANNED, DUE, NAME, CREATOR, DESCRIPTION, PRIORITY, STATE, CLASSIFICATION_CATEGORY, CLASSIFICATION_KEY, CLASSIFICATION_ID, WORKBASKET_ID, WORKBASKET_KEY, DOMAIN, BUSINESS_PROCESS_ID, PARENT_BUSINESS_PROCESS_ID, OWNER, POR_COMPANY, POR_SYSTEM, POR_INSTANCE, POR_TYPE, POR_VALUE, IS_READ, IS_TRANSFERRED, CUSTOM_ATTRIBUTES, CUSTOM_1, CUSTOM_2, CUSTOM_3, CUSTOM_4, CUSTOM_5, CUSTOM_6, CUSTOM_7, "
           + "CUSTOM_8, CUSTOM_9, CUSTOM_10, CUSTOM_11, CUSTOM_12, CUSTOM_13, CUSTOM_14, CUSTOM_15, CUSTOM_16 "
@@ -214,7 +225,7 @@ public interface TaskMapper {
       @Param("referencetask") TaskSummaryImpl referencetask);
 
   @Select(
-      "<script>SELECT ID, EXTERNAL_ID, STATE, WORKBASKET_ID, CALLBACK_STATE FROM TASK "
+      "<script>SELECT ID, EXTERNAL_ID, STATE, WORKBASKET_ID, OWNER, CALLBACK_STATE FROM TASK "
           + "<where> "
           + "<if test='taskIds != null'>ID IN(<foreach item='item' collection='taskIds' separator=',' >#{item}</foreach>)</if> "
           + "<if test='externalIds != null'>EXTERNAL_ID IN(<foreach item='item' collection='externalIds' separator=',' >#{item}</foreach>)</if> "
@@ -226,6 +237,7 @@ public interface TaskMapper {
         @Result(property = "taskId", column = "ID"),
         @Result(property = "externalId", column = "EXTERNAL_ID"),
         @Result(property = "workbasketId", column = "WORKBASKET_ID"),
+        @Result(property = "owner", column = "OWNER"),
         @Result(property = "taskState", column = "STATE"),
         @Result(property = "callbackState", column = "CALLBACK_STATE")
       })
@@ -274,4 +286,25 @@ public interface TaskMapper {
           + "</script>")
   @Results(value = {@Result(property = "taskId", column = "ID")})
   List<String> filterTaskIdsForNotCompleted(@Param("taskIds") List<String> taskIds);
+
+  @Select(
+      "<script> "
+          + "SELECT t.ID FROM TASK t WHERE t.ID IN(<foreach item='item' collection='taskIds' separator=',' >#{item}</foreach>)"
+          + "<if test='accessIds != null'> "
+          + "AND NOT (t.WORKBASKET_ID IN ( "
+          + "<choose>"
+          + "<when test=\"_databaseId == 'db2'\">"
+          + "SELECT WID from (SELECT WORKBASKET_ID as WID, MAX(PERM_READ) as MAX_READ FROM WORKBASKET_ACCESS_LIST AS s where "
+          + "</when>"
+          + "<otherwise>"
+          + "SELECT WID from (SELECT WORKBASKET_ID as WID, MAX(PERM_READ::int) as MAX_READ FROM WORKBASKET_ACCESS_LIST AS s where "
+          + "</otherwise>"
+          + "</choose>"
+          + "ACCESS_ID IN (<foreach item='item' collection='accessIds' separator=',' >#{item}</foreach>) "
+          + "group by WORKBASKET_ID ) AS f where max_read = 1 ))"
+          + "</if> "
+          + "</script>")
+  @Results(value = {@Result(property = "id", column = "ID")})
+  List<String> filterTaskIdsNotAuthorizedFor(
+      @Param("taskIds") List<String> taskIds, @Param("accessIds") List<String> accessIds);
 }

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

@@ -16,6 +16,7 @@ import org.apache.ibatis.exceptions.PersistenceException;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import pro.taskana.TaskanaEngineConfiguration;
 import pro.taskana.classification.api.ClassificationService;
 import pro.taskana.classification.api.exceptions.ClassificationNotFoundException;
 import pro.taskana.classification.api.models.Classification;
@@ -48,6 +49,7 @@ import pro.taskana.task.api.exceptions.InvalidOwnerException;
 import pro.taskana.task.api.exceptions.InvalidStateException;
 import pro.taskana.task.api.exceptions.TaskAlreadyExistException;
 import pro.taskana.task.api.exceptions.TaskNotFoundException;
+import pro.taskana.task.api.exceptions.UpdateFailedException;
 import pro.taskana.task.api.models.Attachment;
 import pro.taskana.task.api.models.ObjectReference;
 import pro.taskana.task.api.models.Task;
@@ -617,6 +619,55 @@ public class TaskServiceImpl implements TaskService {
     }
   }
 
+  @Override
+  public BulkOperationResults<String, TaskanaException> setOwnerOfTasks(
+      String owner, List<String> argTaskIds) {
+    if (LOGGER.isDebugEnabled()) {
+      LOGGER.debug(
+          "entry to setOwnerOfTasks(owner = {}, tasks = {})",
+          owner,
+          LoggerUtils.listToString(argTaskIds));
+    }
+    try {
+      taskanaEngine.openConnection();
+      BulkOperationResults<String, TaskanaException> bulkLog = new BulkOperationResults<>();
+      if (argTaskIds == null || argTaskIds.isEmpty()) {
+        return bulkLog;
+      }
+      // remove duplicates
+      List<String> taskIds = argTaskIds.stream().sorted().distinct().collect(Collectors.toList());
+      final int requestSize = taskIds.size();
+      // use only elements we are authorized for
+      taskIds = filterForAuthorized(taskIds, bulkLog);
+      // set the Owner of these tasks we are authorized for
+      if (taskIds.isEmpty()) {
+        return bulkLog;
+      } else {
+        final int numberOfAffectedTasks = taskMapper.setOwnerOfTasks(owner, taskIds, Instant.now());
+        // check the outcome
+        List<MinimalTaskSummary> existingMinimalTaskSummaries =
+            taskMapper.findExistingTasks(taskIds, null);
+        // check for tasks that don't exist
+        handleNonExistingTasks(taskIds, existingMinimalTaskSummaries, bulkLog);
+        // add all errors that occured to bulkLog
+        addErrorsToResultObject(owner, bulkLog, existingMinimalTaskSummaries);
+        LOGGER.debug(
+            "Received the Request to set owner on "
+                + requestSize
+                + " tasks, "
+                + "actually modified tasks = "
+                + numberOfAffectedTasks
+                + ", could not set owner on "
+                + bulkLog.getFailedIds().size()
+                + " tasks.");
+        return bulkLog;
+      }
+    } finally {
+      LOGGER.debug("exit from setOwnerOfTasks()");
+      taskanaEngine.returnConnection();
+    }
+  }
+
   public Set<String> findTasksIdsAffectedByClassificationChange(String classificationId) {
     LOGGER.debug(
         "entry to findTasksIdsAffectedByClassificationChange(classificationId = {})",
@@ -757,6 +808,77 @@ public class TaskServiceImpl implements TaskService {
     return result;
   }
 
+  private void addErrorsToResultObject(
+      String owner,
+      BulkOperationResults<String, TaskanaException> bulkLog,
+      List<MinimalTaskSummary> existingMinimalTaskSummaries) {
+    for (MinimalTaskSummary taskSummary : existingMinimalTaskSummaries) {
+      if (!owner.equals(taskSummary.getOwner())) { // owner was not set
+        if (!taskSummary.getTaskState().equals(TaskState.READY)) { // due to invalid state
+          bulkLog.addError(
+              taskSummary.getTaskId(),
+              new InvalidStateException(
+                  "Task "
+                      + taskSummary.getTaskId()
+                      + " is in state "
+                      + taskSummary.getTaskState()));
+        } else { // due to unknown reason
+          bulkLog.addError(
+              taskSummary.getTaskId(),
+              new UpdateFailedException(
+                  "Could not set owner of Task " + taskSummary.getTaskId() + "."));
+        }
+      }
+    }
+  }
+
+  private void handleNonExistingTasks(
+      List<String> taskIds,
+      List<MinimalTaskSummary> existingMinimalTaskSummaries,
+      BulkOperationResults<String, TaskanaException> bulkLog) {
+    List<String> nonExistingTaskIds = new ArrayList<>(taskIds);
+    List<String> existingTaskIds =
+        existingMinimalTaskSummaries.stream()
+            .map(MinimalTaskSummary::getTaskId)
+            .collect(Collectors.toList());
+    nonExistingTaskIds.removeAll(existingTaskIds);
+    for (String taskId : nonExistingTaskIds) {
+      bulkLog.addError(taskId, new TaskNotFoundException(taskId, "Task was not found"));
+    }
+  }
+
+  private List<String> filterForAuthorized(
+      List<String> taskIds, BulkOperationResults<String, TaskanaException> bulkLog) {
+    List<String> accessIds = getAccessIds();
+    List<String> tasksAuthorizedFor = new ArrayList<>(taskIds);
+    if (accessIds != null) {
+      List<String> tasksNotAuthorizedFor =
+          taskMapper.filterTaskIdsNotAuthorizedFor(taskIds, accessIds);
+      tasksAuthorizedFor.removeAll(tasksNotAuthorizedFor);
+      String currentUserId = CurrentUserContext.getUserid();
+      for (String taskId : tasksNotAuthorizedFor) {
+        bulkLog.addError(
+            taskId,
+            new NotAuthorizedException(
+                "Current user not authorized for task " + taskId, currentUserId));
+      }
+    }
+    return tasksAuthorizedFor;
+  }
+
+  private List<String> getAccessIds() {
+    List<String> accessIds;
+    if (taskanaEngine.getEngine().isUserInRole(TaskanaRole.ADMIN)) {
+      accessIds = null;
+    } else {
+      accessIds = CurrentUserContext.getAccessIds();
+      if (TaskanaEngineConfiguration.shouldUseLowerCaseForAccessIds()) {
+        accessIds = accessIds.stream().map(String::toLowerCase).collect(Collectors.toList());
+      }
+    }
+    return accessIds;
+  }
+
   private Task claim(String taskId, boolean forceClaim)
       throws TaskNotFoundException, InvalidStateException, InvalidOwnerException,
           NotAuthorizedException {

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

@@ -9,6 +9,7 @@ public class MinimalTaskSummary {
   private String taskId;
   private String externalId;
   private String workbasketId;
+  private String owner;
   private TaskState taskState;
   private CallbackState callbackState;
 
@@ -38,6 +39,14 @@ public class MinimalTaskSummary {
     this.workbasketId = workbasketKey;
   }
 
+  public String getOwner() {
+    return owner;
+  }
+
+  public void setOwner(String owner) {
+    this.owner = owner;
+  }
+
   public TaskState getTaskState() {
     return taskState;
   }
@@ -58,10 +67,16 @@ public class MinimalTaskSummary {
   public String toString() {
     return "MinimalTaskSummary [taskId="
         + taskId
+        + ", externalId="
+        + externalId
         + ", workbasketId="
         + workbasketId
+        + ", owner="
+        + owner
         + ", taskState="
         + taskState
+        + ", callbackState="
+        + callbackState
         + "]";
   }
 }

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

@@ -0,0 +1,46 @@
+package pro.taskana.task.internal.models;
+
+import pro.taskana.task.api.TaskState;
+
+public class TaskIdOwnerState {
+  private String taskId;
+  private String owner;
+  private TaskState taskState;
+
+  TaskIdOwnerState() {}
+
+  public String getTaskId() {
+    return taskId;
+  }
+
+  public void setTaskId(String taskId) {
+    this.taskId = taskId;
+  }
+
+  public String getOwner() {
+    return owner;
+  }
+
+  public void setOwner(String owner) {
+    this.owner = owner;
+  }
+
+  public TaskState getTaskState() {
+    return taskState;
+  }
+
+  public void setTaskState(TaskState taskState) {
+    this.taskState = taskState;
+  }
+
+  @Override
+  public String toString() {
+    return "TaskIdOwnerState [taskId="
+               + taskId
+               + ", owner="
+               + owner
+               + ", taskState="
+               + taskState
+               + "]";
+  }
+}

lib/taskana-core/src/main/java/pro/taskana/workbasket/api/WorkbasketService.java

@@ -66,6 +66,9 @@ public interface WorkbasketService {
    * @param workbasket The Workbasket to update
    * @return the updated Workbasket
    * @throws NotAuthorizedException if the current user is not authorized to update the work basket
+   * @throws WorkbasketNotFoundException if the workbasket cannot be found.
+   * @throws ConcurrencyException if an attempt is made to update the workbasket and another user
+   *     updated it already
    */
   Workbasket updateWorkbasket(Workbasket workbasket)
       throws NotAuthorizedException, WorkbasketNotFoundException, ConcurrencyException;

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

@@ -0,0 +1,265 @@
+package acceptance.task;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import acceptance.AbstractAccTest;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+import pro.taskana.classification.api.exceptions.ClassificationNotFoundException;
+import pro.taskana.common.api.BulkOperationResults;
+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.api.exceptions.TaskanaException;
+import pro.taskana.common.internal.TaskanaEngineProxyForTest;
+import pro.taskana.security.JaasExtension;
+import pro.taskana.security.WithAccessId;
+import pro.taskana.task.api.TaskService;
+import pro.taskana.task.api.TaskState;
+import pro.taskana.task.api.exceptions.AttachmentPersistenceException;
+import pro.taskana.task.api.exceptions.InvalidOwnerException;
+import pro.taskana.task.api.exceptions.InvalidStateException;
+import pro.taskana.task.api.exceptions.TaskNotFoundException;
+import pro.taskana.task.api.models.Task;
+import pro.taskana.task.api.models.TaskSummary;
+
+/** Acceptance test for all "update task" scenarios. */
+@ExtendWith(JaasExtension.class)
+public class SetOwnerAccTest extends AbstractAccTest {
+
+  @WithAccessId(
+      userName = "user_1_2",
+      groupNames = {"group_1"})
+  @Test
+  void testSetOwnerAndSubsequentClaimSucceeds()
+      throws TaskNotFoundException, NotAuthorizedException, InvalidStateException,
+          InvalidOwnerException, ClassificationNotFoundException, InvalidArgumentException,
+          ConcurrencyException, AttachmentPersistenceException {
+
+    TaskService taskService = taskanaEngine.getTaskService();
+    String taskReadyId = "TKI:000000000000000000000000000000000025";
+    Task taskReady = taskService.getTask(taskReadyId);
+    assertThat(taskReady.getState()).isEqualTo(TaskState.READY);
+    assertThat(taskReady.getOwner()).isNull();
+    String anyUserName = "TestUser27";
+    Task modifiedTaskReady = setOwner(taskReadyId, anyUserName);
+
+    assertThat(modifiedTaskReady.getState()).isEqualTo(TaskState.READY);
+    assertThat(modifiedTaskReady.getOwner()).isEqualTo(anyUserName);
+    Task taskClaimed = taskService.claim(taskReadyId);
+    assertThat(taskClaimed.getState()).isEqualTo(TaskState.CLAIMED);
+    assertThat(taskClaimed.getOwner()).isEqualTo("user_1_2");
+  }
+
+  @WithAccessId(
+      userName = "user_1_2",
+      groupNames = {"group_1"})
+  @Test
+  void testSetOwnerViaUpdateTaskNotAuthorized()
+      throws TaskNotFoundException, NotAuthorizedException, InvalidStateException,
+          InvalidOwnerException {
+
+    TaskService taskService = taskanaEngine.getTaskService();
+    String taskReadyId = "TKI:000000000000000000000000000000000024";
+    String anyUserName = "TestUser3";
+
+    assertThatThrownBy(() -> taskService.getTask(taskReadyId))
+        .isInstanceOf(NotAuthorizedException.class);
+    assertThatThrownBy(() -> setOwner(taskReadyId, anyUserName))
+        .isInstanceOf(NotAuthorizedException.class);
+  }
+
+  @WithAccessId(
+      userName = "user_1_2",
+      groupNames = {"group_1"})
+  @Test
+  void testSetOwnerOfClaimedTaskFails()
+      throws TaskNotFoundException, NotAuthorizedException, InvalidStateException,
+          InvalidOwnerException {
+
+    TaskService taskService = taskanaEngine.getTaskService();
+    String taskClaimedId = "TKI:000000000000000000000000000000000026";
+    String anyUserName = "TestUser007";
+    Task taskClaimed = taskService.getTask(taskClaimedId);
+    assertThat(taskClaimed.getState()).isEqualTo(TaskState.CLAIMED);
+    assertThat(taskClaimed.getOwner()).isEqualTo("user_1_1");
+    assertThatThrownBy(() -> setOwner(taskClaimedId, anyUserName))
+        .isInstanceOf(InvalidStateException.class);
+  }
+
+  @WithAccessId(
+      userName = "user_1_2",
+      groupNames = {"group_1"})
+  @Test
+  void testSetOwnerNotAuthorized()
+      throws TaskNotFoundException, NotAuthorizedException, InvalidStateException,
+          InvalidOwnerException {
+
+    TaskService taskService = taskanaEngine.getTaskService();
+    String taskReadyId = "TKI:000000000000000000000000000000000024";
+    String anyUserName = "TestUser3";
+
+    assertThatThrownBy(() -> taskService.getTask(taskReadyId))
+        .isInstanceOf(NotAuthorizedException.class);
+    BulkOperationResults<String, TaskanaException> results =
+        taskService.setOwnerOfTasks(anyUserName, Arrays.asList(taskReadyId));
+    assertThat(results.containsErrors()).isTrue();
+    assertThat(results.getErrorForId(taskReadyId)).isInstanceOf(NotAuthorizedException.class);
+  }
+
+  @WithAccessId(
+      userName = "user_3_2",
+      groupNames = {"group_2"})
+  @Test
+  void testSetOwnerOfTasksWithDuplicatesSucceeds() {
+
+    List<String> taskIds =
+        Arrays.asList(
+            "TKI:000000000000000000000000000000000058",
+            "TKI:000000000000000000000000000000000059",
+            "TKI:000000000000000000000000000000000058",
+            "TKI:000000000000000000000000000000000060");
+    BulkOperationResults<String, TaskanaException> results =
+        taskanaEngine.getTaskService().setOwnerOfTasks("someUser", taskIds);
+    assertThat(results.containsErrors()).isFalse();
+  }
+
+  @WithAccessId(
+      userName = "user_3_2",
+      groupNames = {"group_2"})
+  @Test
+  void testSetOwnerOfTasksWithDuplicatesAndNotExistingSucceeds() {
+    List<String> taskIds =
+        Arrays.asList(
+            "TKI:000000000000000000000000000000000058",
+            "TKI:000000000000000000000000000047110059",
+            "TKI:000000000000000000000000000000000059",
+            "TKI:000000000000000000000000000000000058",
+            "TKI:000000000000000000000000000000000060");
+    BulkOperationResults<String, TaskanaException> results =
+        taskanaEngine.getTaskService().setOwnerOfTasks("someUser", taskIds);
+    assertThat(results.containsErrors()).isTrue();
+    assertThat(results.getErrorMap().size()).isEqualTo(1);
+    assertThat(results.getErrorForId("TKI:000000000000000000000000000047110059"))
+        .isInstanceOf(TaskNotFoundException.class);
+  }
+
+  @WithAccessId(
+      userName = "user_3_2",
+      groupNames = {"group_2"})
+  @Test
+  void testSetOwnerOfTasksWithNoQualifyingTasks() {
+
+    List<String> taskIds =
+        Arrays.asList(
+            "TKI:000000000000000000000000000000000008",
+            "TKI:000000000000000000000000000000000009",
+            "TKI:000000000000000000000000000000000008",
+            "TKI:000000000000000000000000000000000010");
+    BulkOperationResults<String, TaskanaException> results =
+        taskanaEngine.getTaskService().setOwnerOfTasks("someUser", taskIds);
+    assertThat(results.containsErrors()).isTrue();
+    assertThat(results.getErrorMap().size()).isEqualTo(3);
+  }
+
+  @WithAccessId(
+      userName = "user_3_2",
+      groupNames = {"group_2"})
+  @Test
+  void testSetOwnerWithEmptyList() {
+    List<String> taskIds = new ArrayList<>();
+    BulkOperationResults<String, TaskanaException> results =
+        taskanaEngine.getTaskService().setOwnerOfTasks("someUser", taskIds);
+    assertThat(results.containsErrors()).isFalse();
+  }
+
+  @WithAccessId(
+      userName = "user_1_2",
+      groupNames = {"group_2"})
+  @Test
+  void testSetOwnerWithAllTasksAndVariousExceptions()
+      throws NoSuchFieldException, IllegalAccessException, SQLException {
+    resetDb(false);
+    List<TaskSummary> allTaskSummaries =
+        new TaskanaEngineProxyForTest(taskanaEngine)
+            .getEngine()
+            .runAsAdmin(
+                () -> {
+                  return taskanaEngine.getTaskService().createTaskQuery().list();
+                });
+    List<String> allTaskIds =
+        allTaskSummaries.stream().map(TaskSummary::getId).collect(Collectors.toList());
+    BulkOperationResults<String, TaskanaException> results =
+        taskanaEngine.getTaskService().setOwnerOfTasks("theWorkaholic", allTaskIds);
+    assertThat(allTaskSummaries.size()).isEqualTo(73);
+    assertThat(results.containsErrors()).isTrue();
+    assertThat(results.getErrorMap().size()).isEqualTo(48);
+    long numberOfInvalidStateExceptions =
+        results.getErrorMap().entrySet().stream()
+            .filter(
+                e ->
+                    e.getValue()
+                        .getClass()
+                        .getName()
+                        .equals(InvalidStateException.class.getCanonicalName()))
+            .count();
+    assertThat(numberOfInvalidStateExceptions).isEqualTo(25);
+
+    long numberOfNotAuthorizedExceptions =
+        results.getErrorMap().entrySet().stream()
+            .filter(
+                e ->
+                    e.getValue()
+                        .getClass()
+                        .getName()
+                        .equals(NotAuthorizedException.class.getCanonicalName()))
+            .count();
+    assertThat(numberOfNotAuthorizedExceptions).isEqualTo(23);
+  }
+
+  @WithAccessId(
+      userName = "admin",
+      groupNames = {"group_2"})
+  @Test
+  void testSetOwnerWithAllTasksAndVariousExceptionsAsAdmin()
+      throws NoSuchFieldException, IllegalAccessException, SQLException {
+    resetDb(false);
+    List<TaskSummary> allTaskSummaries = taskanaEngine.getTaskService().createTaskQuery().list();
+    List<String> allTaskIds =
+        allTaskSummaries.stream().map(TaskSummary::getId).collect(Collectors.toList());
+    BulkOperationResults<String, TaskanaException> results =
+        taskanaEngine.getTaskService().setOwnerOfTasks("theWorkaholic", allTaskIds);
+    assertThat(allTaskSummaries.size()).isEqualTo(73);
+    assertThat(results.containsErrors()).isTrue();
+    assertThat(results.getErrorMap().size()).isEqualTo(26);
+    long numberOfInvalidStateExceptions =
+        results.getErrorMap().entrySet().stream()
+            .filter(
+                e ->
+                    e.getValue()
+                        .getClass()
+                        .getName()
+                        .equals(InvalidStateException.class.getCanonicalName()))
+            .count();
+    assertThat(numberOfInvalidStateExceptions).isEqualTo(26);
+  }
+
+
+  private Task setOwner(String taskReadyId, String anyUserName)
+      throws TaskNotFoundException, NotAuthorizedException, ClassificationNotFoundException,
+          InvalidArgumentException, ConcurrencyException, AttachmentPersistenceException,
+          InvalidStateException {
+    TaskService taskService = taskanaEngine.getTaskService();
+    Task task = taskService.getTask(taskReadyId);
+    task.setOwner(anyUserName);
+    task = taskService.updateTask(task);
+    return task;
+  }
+}

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

@@ -22,7 +22,6 @@ import pro.taskana.security.WithAccessId;
 import pro.taskana.task.api.TaskService;
 import pro.taskana.task.api.TaskState;
 import pro.taskana.task.api.exceptions.AttachmentPersistenceException;
-import pro.taskana.task.api.exceptions.InvalidOwnerException;
 import pro.taskana.task.api.exceptions.InvalidStateException;
 import pro.taskana.task.api.exceptions.TaskAlreadyExistException;
 import pro.taskana.task.api.exceptions.TaskNotFoundException;
@@ -337,75 +336,4 @@ class UpdateTaskAccTest extends AbstractAccTest {
 
     assertThat(retrievedUpdatedTask.getCallbackInfo()).isEqualTo(callbackInfo);
   }
-
-  @WithAccessId(
-      userName = "user_1_2",
-      groupNames = {"group_1"})
-  @Test
-  void testSetOwnerAndSubsequentClaimSucceeds()
-      throws TaskNotFoundException, NotAuthorizedException, InvalidStateException,
-          InvalidOwnerException, ClassificationNotFoundException, InvalidArgumentException,
-          ConcurrencyException, AttachmentPersistenceException {
-
-    TaskService taskService = taskanaEngine.getTaskService();
-    String taskReadyId = "TKI:000000000000000000000000000000000025";
-    Task taskReady = taskService.getTask(taskReadyId);
-    assertThat(taskReady.getState()).isEqualTo(TaskState.READY);
-    assertThat(taskReady.getOwner()).isNull();
-    String anyUserName = "Holger";
-    Task modifiedTaskReady = setOwner(taskReadyId, anyUserName);
-
-    assertThat(modifiedTaskReady.getState()).isEqualTo(TaskState.READY);
-    assertThat(modifiedTaskReady.getOwner()).isEqualTo(anyUserName);
-    Task taskClaimed = taskService.claim(taskReadyId);
-    assertThat(taskClaimed.getState()).isEqualTo(TaskState.CLAIMED);
-    assertThat(taskClaimed.getOwner()).isEqualTo("user_1_2");
-  }
-
-  @WithAccessId(
-      userName = "user_1_2",
-      groupNames = {"group_1"})
-  @Test
-  void testSetOwnerNotAuthorized()
-      throws TaskNotFoundException, NotAuthorizedException, InvalidStateException,
-          InvalidOwnerException {
-
-    TaskService taskService = taskanaEngine.getTaskService();
-    String taskReadyId = "TKI:000000000000000000000000000000000024";
-    String anyUserName = "Benjamin";
-
-    assertThatThrownBy(() -> taskService.getTask(taskReadyId))
-        .isInstanceOf(NotAuthorizedException.class);
-    assertThatThrownBy(() -> setOwner(taskReadyId, anyUserName))
-        .isInstanceOf(NotAuthorizedException.class);
-  }
-
-  @WithAccessId(
-      userName = "user_1_2",
-      groupNames = {"group_1"})
-  @Test
-  void testSetOwnerOfClaimedTaskFails()
-      throws TaskNotFoundException, NotAuthorizedException, InvalidStateException,
-          InvalidOwnerException {
-
-    TaskService taskService = taskanaEngine.getTaskService();
-    String taskClaimedId = "TKI:000000000000000000000000000000000026";
-    String anyUserName = "Mustapha";
-    Task taskClaimed = taskService.getTask(taskClaimedId);
-    assertThat(taskClaimed.getState()).isEqualTo(TaskState.CLAIMED);
-    assertThat(taskClaimed.getOwner()).isEqualTo("user_1_1");
-    assertThatThrownBy(() -> setOwner(taskClaimedId, anyUserName))
-        .isInstanceOf(InvalidStateException.class);
-  }
-
-  private Task setOwner(String taskReadyId, String anyUserName)
-      throws TaskNotFoundException, NotAuthorizedException, ClassificationNotFoundException,
-          InvalidArgumentException, ConcurrencyException, AttachmentPersistenceException,
-          InvalidStateException {
-    TaskService taskService = taskanaEngine.getTaskService();
-    Task task = taskService.getTask(taskReadyId);
-    task.setOwner(anyUserName);
-    task = taskService.updateTask(task);
-    return task;
-  }
 }