TSK-424: Exception is thrown if a completed task is getting transferred.

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

@@ -189,9 +189,12 @@ public interface TaskService {
      *             Thrown if the current user is not authorized to transfer this {@link Task} to the target work basket
      * @throws InvalidWorkbasketException
      *             Thrown if either the source or the target workbasket has a missing required property
+     * @throws InvalidStateException
+     *             Thrown if the task is in a state which does not allow transferring
      */
     Task transfer(String taskId, String destinationWorkbasketId)
-        throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException, InvalidWorkbasketException;
+        throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException, InvalidWorkbasketException,
+        InvalidStateException;
 
     /**
      * Transfer a task to another work basket. The transfer sets the transferred flag and resets the read flag.
@@ -211,9 +214,12 @@ public interface TaskService {
      *             Thrown if the current user is not authorized to transfer this {@link Task} to the target work basket
      * @throws InvalidWorkbasketException
      *             Thrown if either the source or the target workbasket has a missing required property
+     * @throws InvalidStateException
+     *             Thrown if the task is in a state which does not allow transferring
      */
     Task transfer(String taskId, String workbasketKey, String domain)
-        throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException, InvalidWorkbasketException;
+        throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException, InvalidWorkbasketException,
+        InvalidStateException;
 
     /**
      * Marks a task as read.

lib/taskana-core/src/main/java/pro/taskana/impl/TaskServiceImpl.java

@@ -398,13 +398,18 @@ public class TaskServiceImpl implements TaskService {
 
     @Override
     public Task transfer(String taskId, String destinationWorkbasketId)
-        throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException, InvalidWorkbasketException {
+        throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException, InvalidWorkbasketException,
+        InvalidStateException {
         LOGGER.debug("entry to transfer(taskId = {}, destinationWorkbasketId = {})", taskId, destinationWorkbasketId);
         TaskImpl task = null;
         try {
             taskanaEngine.openConnection();
             task = (TaskImpl) getTask(taskId);
 
+            if (task.getState() == TaskState.COMPLETED) {
+                throw new InvalidStateException("Completed task with id " + task.getId() + " cannot be transferred.");
+            }
+
             // transfer requires TRANSFER in source and APPEND on destination workbasket
             workbasketService.checkAuthorization(destinationWorkbasketId, WorkbasketPermission.APPEND);
             workbasketService.checkAuthorization(task.getWorkbasketSummary().getId(),
@@ -433,7 +438,8 @@ public class TaskServiceImpl implements TaskService {
 
     @Override
     public Task transfer(String taskId, String destinationWorkbasketKey, String domain)
-        throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException, InvalidWorkbasketException {
+        throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException, InvalidWorkbasketException,
+        InvalidStateException {
         LOGGER.debug("entry to transfer(taskId = {}, destinationWorkbasketKey = {}, domain = {})", taskId,
             destinationWorkbasketKey, domain);
         TaskImpl task = null;
@@ -441,6 +447,10 @@ public class TaskServiceImpl implements TaskService {
             taskanaEngine.openConnection();
             task = (TaskImpl) getTask(taskId);
 
+            if (task.getState() == TaskState.COMPLETED) {
+                throw new InvalidStateException("Completed task with id " + task.getId() + " cannot be transferred.");
+            }
+
             // transfer requires TRANSFER in source and APPEND on destination workbasket
             workbasketService.checkAuthorization(destinationWorkbasketKey, domain, WorkbasketPermission.APPEND);
             workbasketService.checkAuthorization(task.getWorkbasketSummary().getId(),
@@ -550,6 +560,10 @@ public class TaskServiceImpl implements TaskService {
                 bulkLog.addError(currentTaskId,
                     new TaskNotFoundException(currentTaskId, "Task with id " + currentTaskId + " was not found."));
                 taskIdIterator.remove();
+            } else if (taskSummary.getTaskState() == TaskState.COMPLETED) {
+                bulkLog.addError(currentTaskId,
+                    new InvalidStateException("Completed task with id " + currentTaskId + " cannot be transferred."));
+                taskIdIterator.remove();
             } else if (!sourceWorkbaskets.stream()
                 .anyMatch(wb -> taskSummary.getWorkbasketId().equals(wb.getId()))) {
                 bulkLog.addError(currentTaskId,

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

@@ -157,7 +157,7 @@ public class QueryTasksAccTest extends AbstractAccTest {
         List<TaskSummary> results = taskService.createTaskQuery()
             .classificationKeyLike("L10%")
             .list();
-        assertThat(results.size(), equalTo(64));
+        assertThat(results.size(), equalTo(66));
 
         String[] ids = results.stream()
             .map(t -> t.getClassificationSummary().getKey())
@@ -167,7 +167,7 @@ public class QueryTasksAccTest extends AbstractAccTest {
         List<TaskSummary> result2 = taskService.createTaskQuery()
             .classificationKeyIn(ids)
             .list();
-        assertThat(result2.size(), equalTo(64));
+        assertThat(result2.size(), equalTo(66));
     }
 
     @WithAccessId(
@@ -633,7 +633,7 @@ public class QueryTasksAccTest extends AbstractAccTest {
         TaskService taskService = taskanaEngine.getTaskService();
         TaskQuery taskQuery = taskService.createTaskQuery();
         long numberOfTasks = taskQuery.count();
-        Assert.assertEquals(22, numberOfTasks);
+        Assert.assertEquals(24, numberOfTasks);
         List<TaskSummary> tasks = taskQuery
             .orderByDue(SortDirection.DESCENDING)
             .list();
@@ -644,7 +644,7 @@ public class QueryTasksAccTest extends AbstractAccTest {
         tasksp = taskQuery
             .orderByDue(SortDirection.DESCENDING)
             .listPage(5, 5);
-        Assert.assertEquals(2, tasksp.size());
+        Assert.assertEquals(4, tasksp.size());
     }
 
 }

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

@@ -36,7 +36,7 @@ public class QueryTasksByObjectReferenceAccTest extends AbstractAccTest {
         List<TaskSummary> results = taskService.createTaskQuery()
             .primaryObjectReferenceValueIn("11223344", "22334455")
             .list();
-        Assert.assertEquals(32L, results.size());
+        Assert.assertEquals(33L, results.size());
     }
 
     @WithAccessId(

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

@@ -84,7 +84,7 @@ public class QueryTasksByTimeIntervalsAccTest extends AbstractAccTest {
             .orderByCreated(asc)
             .list();
 
-        assertThat(results.size(), equalTo(36));
+        assertThat(results.size(), equalTo(37));
         TaskSummary previousSummary = null;
         for (TaskSummary taskSummary : results) {
             Instant cr = taskSummary.getCreated();
@@ -113,7 +113,7 @@ public class QueryTasksByTimeIntervalsAccTest extends AbstractAccTest {
             .orderByCreated(asc)
             .list();
 
-        assertThat(results.size(), equalTo(36));
+        assertThat(results.size(), equalTo(37));
         TaskSummary previousSummary = null;
         for (TaskSummary taskSummary : results) {
             Instant cr = taskSummary.getCreated();
@@ -146,7 +146,7 @@ public class QueryTasksByTimeIntervalsAccTest extends AbstractAccTest {
             .orderByCreated(asc)
             .list();
 
-        assertThat(results.size(), equalTo(24));
+        assertThat(results.size(), equalTo(25));
         TaskSummary previousSummary = null;
         for (TaskSummary taskSummary : results) {
             Instant cr = taskSummary.getClaimed();
@@ -233,7 +233,7 @@ public class QueryTasksByTimeIntervalsAccTest extends AbstractAccTest {
             .orderByPlanned(asc)
             .list();
 
-        assertThat(results.size(), equalTo(70));
+        assertThat(results.size(), equalTo(71));
         TaskSummary previousSummary = null;
         for (TaskSummary taskSummary : results) {
             Instant cr = taskSummary.getPlanned();
@@ -262,7 +262,7 @@ public class QueryTasksByTimeIntervalsAccTest extends AbstractAccTest {
             .orderByPlanned(asc)
             .list();
 
-        assertThat(results.size(), equalTo(70));
+        assertThat(results.size(), equalTo(71));
         TaskSummary previousSummary = null;
         for (TaskSummary taskSummary : results) {
             Instant cr = taskSummary.getDue();

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

@@ -95,7 +95,8 @@ public class TransferTaskAccTest extends AbstractAccTest {
     @Test
     public void testDomainChangingWhenTransferTask()
         throws SQLException, NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
-        WorkbasketNotFoundException, TaskAlreadyExistException, InvalidWorkbasketException, TaskNotFoundException {
+        WorkbasketNotFoundException, TaskAlreadyExistException, InvalidWorkbasketException, TaskNotFoundException,
+        InvalidStateException {
         TaskService taskService = taskanaEngine.getTaskService();
         Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
         String domain1 = task.getDomain();
@@ -112,20 +113,36 @@ public class TransferTaskAccTest extends AbstractAccTest {
     @Test(expected = NotAuthorizedException.class)
     public void testThrowsExceptionIfTransferWithNoTransferAuthorization()
         throws SQLException, NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
-        WorkbasketNotFoundException, TaskAlreadyExistException, InvalidWorkbasketException, TaskNotFoundException {
+        WorkbasketNotFoundException, TaskAlreadyExistException, InvalidWorkbasketException, TaskNotFoundException,
+        InvalidStateException {
         TaskService taskService = taskanaEngine.getTaskService();
         Task task = taskService.getTask("TKI:000000000000000000000000000000000001");
 
         taskService.transfer(task.getId(), "WBI:100000000000000000000000000000000005");
     }
 
+    @WithAccessId(
+        userName = "teamlead_1",
+        groupNames = {"group_1"})
+    @Test(expected = InvalidStateException.class)
+    public void testThrowsExceptionIfTaskIsAlreadyCompleted()
+        throws SQLException, NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
+        WorkbasketNotFoundException, TaskAlreadyExistException, InvalidWorkbasketException, TaskNotFoundException,
+        InvalidStateException {
+        TaskService taskService = taskanaEngine.getTaskService();
+        Task task = taskService.getTask("TKI:100000000000000000000000000000000006");
+
+        taskService.transfer(task.getId(), "WBI:100000000000000000000000000000000005");
+    }
+
     @WithAccessId(
         userName = "user_1_1",
         groupNames = {"group_1"})
     @Test(expected = NotAuthorizedException.class)
     public void testThrowsExceptionIfTransferWithNoAppendAuthorization()
         throws SQLException, NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
-        WorkbasketNotFoundException, TaskAlreadyExistException, InvalidWorkbasketException, TaskNotFoundException {
+        WorkbasketNotFoundException, TaskAlreadyExistException, InvalidWorkbasketException, TaskNotFoundException,
+        InvalidStateException {
         TaskService taskService = taskanaEngine.getTaskService();
         Task task = taskService.getTask("TKI:000000000000000000000000000000000002");
 
@@ -182,15 +199,17 @@ public class TransferTaskAccTest extends AbstractAccTest {
         Instant before = Instant.now();
         ArrayList<String> taskIdList = new ArrayList<>();
         taskIdList.add("TKI:000000000000000000000000000000000006"); // working
-        taskIdList.add("TKI:000000000000000000000000000000000041"); // NotAuthorized
+        taskIdList.add("TKI:000000000000000000000000000000000041"); // NotAuthorized READ
+        taskIdList.add("TKI:200000000000000000000000000000000006"); // NotAuthorized TRANSFER
         taskIdList.add("");     // InvalidArgument
         taskIdList.add(null);   // InvalidArgument (added with ""), duplicate
         taskIdList.add("TKI:000000000000000000000000000000000099"); // TaskNotFound
+        taskIdList.add("TKI:100000000000000000000000000000000006"); // already completed
 
         BulkOperationResults<String, TaskanaException> results = taskService
             .transferTasks("WBI:100000000000000000000000000000000006", taskIdList);
         assertTrue(results.containsErrors());
-        assertThat(results.getErrorMap().values().size(), equalTo(3));
+        assertThat(results.getErrorMap().values().size(), equalTo(5));
         // react to result
         for (String taskId : results.getErrorMap().keySet()) {
             TaskanaException ex = results.getErrorForId(taskId);
@@ -200,6 +219,8 @@ public class TransferTaskAccTest extends AbstractAccTest {
                 System.out.println("InvalidArgumentException on bulkTransfer for EMPTY/NULL taskId='" + taskId + "'");
             } else if (ex instanceof TaskNotFoundException) {
                 System.out.println("TaskNotFoundException on bulkTransfer for taskId=" + taskId);
+            } else if (ex instanceof InvalidStateException) {
+                System.out.println("InvalidStateException on bulkTransfer for taskId=" + taskId);
             } else {
                 fail("Impossible failure Entry registered");
             }
@@ -218,6 +239,16 @@ public class TransferTaskAccTest extends AbstractAccTest {
         assertNotNull(transferredTask);
         assertFalse(transferredTask.isTransferred());
         assertEquals("USER_1_1", transferredTask.getWorkbasketKey());
+
+        transferredTask = taskService.getTask("TKI:200000000000000000000000000000000006");
+        assertNotNull(transferredTask);
+        assertFalse(transferredTask.isTransferred());
+        assertEquals("TEAMLEAD_2", transferredTask.getWorkbasketKey());
+
+        transferredTask = taskService.getTask("TKI:100000000000000000000000000000000006");
+        assertNotNull(transferredTask);
+        assertFalse(transferredTask.isTransferred());
+        assertEquals("TEAMLEAD_1", transferredTask.getWorkbasketKey());
     }
 
 }

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

@@ -49,11 +49,11 @@ public class DeleteWorkbasketAccTest extends AbstractAccTest {
     @Test
     public void testDeleteWorkbasket()
         throws WorkbasketNotFoundException, NotAuthorizedException, WorkbasketInUseException, InvalidArgumentException {
-        Workbasket wb = workbasketService.getWorkbasket("TEAMLEAD_2", "DOMAIN_A");
+        Workbasket wb = workbasketService.getWorkbasket("USER_2_2", "DOMAIN_A");
         workbasketService.deleteWorkbasket(wb.getId());
 
         try {
-            workbasketService.getWorkbasket("TEAMLEAD_2", "DOMAIN_A");
+            workbasketService.getWorkbasket("USER_2_2", "DOMAIN_A");
             fail("There should be no result for a deleted Workbasket.");
         } catch (WorkbasketNotFoundException e) {
             // Workbasket is deleted

lib/taskana-core/src/test/java/pro/taskana/impl/TaskServiceImplTest.java

@@ -909,7 +909,8 @@ public class TaskServiceImplTest {
     @Test
     public void testTransferTaskToDestinationWorkbasketWithoutSecurity()
         throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException,
-        ClassificationAlreadyExistException, InvalidWorkbasketException, ClassificationNotFoundException {
+        ClassificationAlreadyExistException, InvalidWorkbasketException, ClassificationNotFoundException,
+        InvalidStateException {
         TaskServiceImpl cutSpy = Mockito.spy(cut);
         Workbasket destinationWorkbasket = createWorkbasket("2", "k1");
         Workbasket sourceWorkbasket = createWorkbasket("47", "key47");
@@ -951,7 +952,8 @@ public class TaskServiceImplTest {
     @Test
     public void testTransferTaskToDestinationWorkbasketUsingSecurityTrue()
         throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException,
-        ClassificationAlreadyExistException, InvalidWorkbasketException, ClassificationNotFoundException {
+        ClassificationAlreadyExistException, InvalidWorkbasketException, ClassificationNotFoundException,
+        InvalidStateException {
         TaskServiceImpl cutSpy = Mockito.spy(cut);
         Workbasket destinationWorkbasket = createWorkbasket("2", "k2");
         Classification dummyClassification = createDummyClassification();

lib/taskana-core/src/test/java/pro/taskana/impl/integration/TaskServiceImplIntAutocommitTest.java

@@ -36,6 +36,7 @@ import pro.taskana.exceptions.ClassificationAlreadyExistException;
 import pro.taskana.exceptions.ClassificationNotFoundException;
 import pro.taskana.exceptions.DomainNotFoundException;
 import pro.taskana.exceptions.InvalidArgumentException;
+import pro.taskana.exceptions.InvalidStateException;
 import pro.taskana.exceptions.InvalidWorkbasketException;
 import pro.taskana.exceptions.NotAuthorizedException;
 import pro.taskana.exceptions.SystemException;
@@ -221,7 +222,8 @@ public class TaskServiceImplIntAutocommitTest {
     public void shouldTransferTaskToOtherWorkbasket()
         throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
         ClassificationAlreadyExistException, TaskNotFoundException, InterruptedException, TaskAlreadyExistException,
-        InvalidWorkbasketException, InvalidArgumentException, WorkbasketAlreadyExistException, DomainNotFoundException {
+        InvalidWorkbasketException, InvalidArgumentException, WorkbasketAlreadyExistException, DomainNotFoundException,
+        InvalidStateException {
         Workbasket sourceWB;
         Workbasket destinationWB;
         WorkbasketImpl wb;
@@ -278,7 +280,7 @@ public class TaskServiceImplIntAutocommitTest {
     @Test(expected = TaskNotFoundException.class)
     public void shouldNotTransferAnyTask()
         throws WorkbasketNotFoundException, NotAuthorizedException, TaskNotFoundException, InvalidWorkbasketException,
-        ClassificationNotFoundException {
+        ClassificationNotFoundException, InvalidStateException {
         taskServiceImpl.transfer(UUID.randomUUID() + "_X", "1");
     }
 
@@ -287,7 +289,7 @@ public class TaskServiceImplIntAutocommitTest {
     public void shouldNotTransferByFailingSecurity() throws WorkbasketNotFoundException,
         ClassificationNotFoundException, NotAuthorizedException, ClassificationAlreadyExistException, SQLException,
         TaskNotFoundException, TaskAlreadyExistException, InvalidWorkbasketException, InvalidArgumentException,
-        WorkbasketAlreadyExistException, DomainNotFoundException {
+        WorkbasketAlreadyExistException, DomainNotFoundException, InvalidStateException {
         final String user = CurrentUserContext.getUserid();
 
         // Set up Security for this Test

lib/taskana-core/src/test/java/pro/taskana/impl/integration/TaskServiceImplIntExplicitTest.java

@@ -38,6 +38,7 @@ import pro.taskana.exceptions.ClassificationAlreadyExistException;
 import pro.taskana.exceptions.ClassificationNotFoundException;
 import pro.taskana.exceptions.DomainNotFoundException;
 import pro.taskana.exceptions.InvalidArgumentException;
+import pro.taskana.exceptions.InvalidStateException;
 import pro.taskana.exceptions.InvalidWorkbasketException;
 import pro.taskana.exceptions.NotAuthorizedException;
 import pro.taskana.exceptions.SystemException;
@@ -300,7 +301,7 @@ public class TaskServiceImplIntExplicitTest {
         throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
         ClassificationAlreadyExistException, TaskNotFoundException, InterruptedException, TaskAlreadyExistException,
         SQLException, InvalidWorkbasketException, InvalidArgumentException, WorkbasketAlreadyExistException,
-        DomainNotFoundException {
+        DomainNotFoundException, InvalidStateException {
         Workbasket sourceWB;
         Workbasket destinationWB;
         WorkbasketImpl wb;
@@ -367,7 +368,7 @@ public class TaskServiceImplIntExplicitTest {
     @Test(expected = TaskNotFoundException.class)
     public void shouldNotTransferAnyTask()
         throws WorkbasketNotFoundException, NotAuthorizedException, TaskNotFoundException, SQLException,
-        InvalidWorkbasketException, ClassificationNotFoundException {
+        InvalidWorkbasketException, ClassificationNotFoundException, InvalidStateException {
         Connection connection = dataSource.getConnection();
         taskanaEngineImpl.setConnection(connection);
         taskServiceImpl.transfer(UUID.randomUUID() + "_X", "1");
@@ -378,7 +379,7 @@ public class TaskServiceImplIntExplicitTest {
     public void shouldNotTransferByFailingSecurity() throws WorkbasketNotFoundException,
         ClassificationNotFoundException, NotAuthorizedException, ClassificationAlreadyExistException, SQLException,
         TaskNotFoundException, TaskAlreadyExistException, InvalidWorkbasketException, InvalidArgumentException,
-        WorkbasketAlreadyExistException, DomainNotFoundException {
+        WorkbasketAlreadyExistException, DomainNotFoundException, InvalidStateException {
         final String user = "User";
 
         // Set up Security for this Test

lib/taskana-core/src/test/resources/sql/task.sql

@@ -1,4 +1,4 @@
--- TASK TABLE          (ID                                        , CREATED              , CLAIMED              , COMPLETED            , modified             , planned              , due                  , name                      , creator                      , description                                , note                                     , 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_system_instance, por_type , por_value    , is_read, is_transferred, callback_info, custom_attributes, custom1, custom2, custom3, custom4, custom5, custom6, custom7, custom8, custom9, custom10, custom11, custom12, custom13, custom14, custom15, custom16
+-- TASK TABLE                  (ID                                        , CREATED              , CLAIMED              , COMPLETED            , modified             , planned              , due                  , name                      , creator                      , description                                , note                                     , 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_system_instance, por_type , por_value    , is_read, is_transferred, callback_info, custom_attributes, custom1, custom2, custom3, custom4, custom5, custom6, custom7, custom8, custom9, custom10, custom11, custom12, custom13, custom14, custom15, custom16
 INSERT INTO TASKANA.TASK VALUES('TKI:000000000000000000000000000000000000', '2018-01-29 15:55:00', '2018-01-30 15:55:00', null                 , '2018-01-30 15:55:00', '2018-01-29 15:55:00', '2018-01-30 15:55:00', 'Task99'                  , 'creator_user_id'            , 'Lorem ipsum was n Quatsch dolor sit amet.', 'Some custom Note'                       , 1       , 'CLAIMED'   , 'MANUAL'                 , 'T2000'           , 'CLI:100000000000000000000000000000000016', 'WBI:100000000000000000000000000000000006' , 'USER_1_1'    , 'DOMAIN_A', 'BPI21'            , 'PBPI21'                  , 'user_1_1'  , 'MyCompany1', 'MySystem1', 'MyInstance1'      , 'MyType1', 'MyValue1'     , true   , false         , null         , null             , null   , null   , null   , null   , null   , null   , null   , null   , null     , null    , null    , null    , null    , 'abc'    , null    , null    );
 INSERT INTO TASKANA.TASK VALUES('TKI:000000000000000000000000000000000001', '2018-01-29 15:55:01', '2018-01-30 15:55:00', null                 , '2018-01-30 15:55:01', '2018-01-29 15:55:00', '2018-01-30 15:55:00', 'Task01'                  , 'creator_user_id'            , 'Lorem ipsum was n Quatsch dolor sit amet.', 'Some custom Note'                       , 2       , 'CLAIMED'   , 'EXTERN'                 , 'L110102'         , 'CLI:100000000000000000000000000000000005', 'WBI:100000000000000000000000000000000006' , 'USER_1_1'    , 'DOMAIN_A', 'BPI21'            , 'PBPI21'                  , 'user_1_1'  , 'MyCompany1', 'MySystem1', 'MyInstance1'      , 'MyType1', 'MyValue1'     , true   , false         , null         , null             , 'pqr'  , null   , null   , null   , null   , null   , null   , null   , null     , null    , null    , null    , null    , 'abc'    , null    , null    );
 INSERT INTO TASKANA.TASK VALUES('TKI:000000000000000000000000000000000002', '2018-01-29 15:55:02', '2018-01-30 15:55:00', null                 , '2018-01-30 15:55:02', '2018-01-29 15:55:00', '2018-01-30 15:55:00', 'Task02'                  , 'creator_user_id'            , 'Lorem ipsum was n Quatsch t. Aber stimmt.', 'Some custom Note'                       , 2       , 'CLAIMED'   , 'MANUAL'                 , 'T2000'           , 'CLI:100000000000000000000000000000000016', 'WBI:100000000000000000000000000000000006' , 'USER_1_1'    , 'DOMAIN_A', 'BPI21'            , 'PBPI21'                  , 'user_1_1'  , 'MyCompany1', 'MySystem1', 'MyInstance1'      , 'MyType1', 'MyValue1'     , true   , false         , null         , null             , null   , null   , null   , null   , null   , null   , null   , null   , null     , null    , null    , null    , null    , 'abc'    , null    , null    );
@@ -72,3 +72,6 @@ INSERT INTO TASKANA.TASK VALUES('TKI:000000000000000000000000000000000062', '201
 INSERT INTO TASKANA.TASK VALUES('TKI:000000000000000000000000000000000063', '2018-01-29 15:55:22', null                 , null                 , '2018-01-29 15:55:22', '2018-01-29 15:55:00', '2018-01-30 15:55:00', 'Widerruf'                , 'creator_user_id'            , 'Widerruf'                                 , null                                     , 2       , 'READY'     , 'EXTERN'                 , 'L1060'           , 'CLI:200000000000000000000000000000000017', 'WBI:100000000000000000000000000000000015' , 'USER_3_2'    , 'DOMAIN_B', 'PI_0000000000022' , 'DOC_0000000000000000022' , null        , '00'        , 'PASystem' , '00'               , 'SDNR'   , '11223344'     , false  , false         , null         , null             , null   , null   , null   , null   , null   , null   , null   , null   , null     , null    , null    , null    , null    , 'abc'    , null    , null    );
 INSERT INTO TASKANA.TASK VALUES('TKI:000000000000000000000000000000000064', '2018-01-29 15:55:23', null                 , null                 , '2018-01-29 15:55:23', '2018-01-29 15:55:00', '2018-01-30 15:55:00', 'Widerruf'                , 'creator_user_id'            , 'Widerruf'                                 , null                                     , 2       , 'READY'     , 'EXTERN'                 , 'L1060'           , 'CLI:200000000000000000000000000000000017', 'WBI:100000000000000000000000000000000015' , 'USER_3_2'    , 'DOMAIN_B', 'PI_0000000000020' , 'DOC_0000000000000000021' , null        , '00'        , 'PASystem' , '00'               , 'SDNR'   , '11223344'     , false  , false         , null         , null             , null   , null   , null   , null   , null   , null   , null   , null   , null     , null    , null    , null    , null    , 'abc'    , null    , null    );
 INSERT INTO TASKANA.TASK VALUES('TKI:000000000000000000000000000000000065', '2018-01-29 15:55:24', null                 , null                 , '2018-01-29 15:55:24', '2018-01-29 15:55:00', '2018-01-30 15:55:00', 'Widerruf'                , 'creator_user_id'            , 'Widerruf'                                 , null                                     , 2       , 'READY'     , 'EXTERN'                 , 'L1060'           , 'CLI:200000000000000000000000000000000017', 'WBI:100000000000000000000000000000000015' , 'USER_3_2'    , 'DOMAIN_B', 'PI_0000000000024' , 'DOC_0000000000000000024' , null        , '00'        , 'PASystem' , '00'               , 'SDNR'   , '11223344'     , false  , false         , null         , null             , null   , null   , null   , null   , null   , null   , null   , null   , null     , null    , null    , null    , null    , 'abc'    , null    , null    );
+-- Task for TransferAccTest
+INSERT INTO TASKANA.TASK VALUES('TKI:100000000000000000000000000000000006', '2018-01-29 15:55:06', '2018-01-30 15:55:06', '2018-01-30 16:55:06', '2018-01-30 16:55:06', '2018-01-29 15:55:00', '2018-01-30 15:55:00', 'Widerruf'                , 'creator_user_id'            , 'Widerruf'                                 , null                                     , 2       , 'COMPLETED' , 'EXTERN'                 , 'L1050'           , 'CLI:100000000000000000000000000000000003', 'WBI:100000000000000000000000000000000004' , 'TEAMLEAD_1'  , 'DOMAIN_A', 'PI_0000000000006' , 'DOC_0000000000000000006' , null        , '00'        , 'PASystem' , '00'               , 'VNR'    , '11223344'     , false  , false         , null         , null             , null   , null   , null   , null   , null   , null   , null   , null   , null     , null    , null    , null    , null    , 'abc'    , null    , null    );
+INSERT INTO TASKANA.TASK VALUES('TKI:200000000000000000000000000000000006', '2018-03-29 15:55:06', '2018-03-30 15:55:06', null                 , '2018-03-30 15:55:06', '2018-03-29 15:55:00', '2018-03-30 15:55:00', 'Widerruf'                , 'creator_user_id'            , 'Widerruf'                                 , null                                     , 2       , 'COMPLETED' , 'EXTERN'                 , 'L1050'           , 'CLI:100000000000000000000000000000000003', 'WBI:100000000000000000000000000000000005' , 'TEAMLEAD_2'  , 'DOMAIN_A', 'PI_0000000000006' , 'DOC_0000000000000000006' , null        , '00'        , 'PASystem' , '00'               , 'SDNR'   , '98765432'     , false  , false         , null         , null             , null   , null   , null   , null   , null   , null   , null   , null   , null     , null    , null    , null    , null    , 'abc'    , null    , null    );

lib/taskana-core/src/test/resources/sql/workbasket-access-list.sql

@@ -1,4 +1,4 @@
--- KSC authorizations (                    ID,                                                                             WB_ID,    ACCESS_ID, READ, OPEN, APPEND, TRANSFER, DISTRIBUTE, C1, .., C12)
+-- KSC authorizations                             (ID                                        , WB_ID                                     ,    ACCESS_ID, READ, OPEN, APPEND, TRANSFER, DISTRIBUTE, C1, .., C12)
 -- PPKs
 INSERT INTO TASKANA.WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000001', 'WBI:100000000000000000000000000000000004', 'teamlead_1', true, true, true,   true,     true,       true, true, true, true, true, true, true, true, true, true, true, true);
 INSERT INTO TASKANA.WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000002', 'WBI:100000000000000000000000000000000005', 'teamlead_2', true, true, true,   true,     true,       true, true, true, true, true, true, true, true, true, true, true, true);
@@ -15,11 +15,11 @@ INSERT INTO TASKANA.WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000
 INSERT INTO TASKANA.WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000012', 'WBI:100000000000000000000000000000000009',    'group_2', true, true, true,   true,     false,      false, false, false, false, false, false, false, false, false, false, false, false);
 -- teamlead substitution
 INSERT INTO TASKANA.WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000013', 'WBI:100000000000000000000000000000000004', 'teamlead_2', true, true, true,   true,     false,      false, false, false, false, false, false, false, false, false, false, false, false);
-INSERT INTO TASKANA.WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000014', 'WBI:100000000000000000000000000000000005', 'teamlead_1', true, true, true,   true,     false,      false, false, false, false, false, false, false, false, false, false, false, false);
+INSERT INTO TASKANA.WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000014', 'WBI:100000000000000000000000000000000005', 'teamlead_1', true, true, true,   false,    false,      false, false, false, false, false, false, false, false, false, false, false, false);
 -- cross team tranfers
 INSERT INTO TASKANA.WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000015', 'WBI:100000000000000000000000000000000006',    'group_2', true, false, true,  false,    false,      false, false, false, false, false, false, false, false, false, false, false, false);
 INSERT INTO TASKANA.WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000016', 'WBI:100000000000000000000000000000000007',    'group_2', true, false, true,  false,    false,      false, false, false, false, false, false, false, false, false, false, false, false);
-INSERT INTO TASKANA.WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000017', 'WBI:100000000000000000000000000000000008',    'group_1', true, false, false,  false,    false,      false, false, false, false, false, false, false, false, false, false, false, false);
+INSERT INTO TASKANA.WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000017', 'WBI:100000000000000000000000000000000008',    'group_1', true, false, false, false,    false,      false, false, false, false, false, false, false, false, false, false, false, false);
 INSERT INTO TASKANA.WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000018', 'WBI:100000000000000000000000000000000009',    'group_1', true, false, true,  false,    false,      false, false, false, false, false, false, false, false, false, false, false, false);
 -- Team GPK access
 INSERT INTO TASKANA.WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000019', 'WBI:100000000000000000000000000000000002',    'group_1', true, true, true,   true,     true,       true, true, true, true, true, true, true, true, true, true, true, true);

rest/taskana-rest-spring/src/main/java/pro/taskana/rest/TaskController.java

@@ -169,7 +169,8 @@ public class TaskController extends AbstractPagingController {
     @RequestMapping(path = "/{taskId}/transfer/{workbasketKey}")
     @Transactional(rollbackFor = Exception.class)
     public ResponseEntity<TaskResource> transferTask(@PathVariable String taskId, @PathVariable String workbasketKey)
-        throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException, InvalidWorkbasketException {
+        throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException, InvalidWorkbasketException,
+        InvalidStateException {
         Task updatedTask = taskService.transfer(taskId, workbasketKey);
         ResponseEntity<TaskResource> result = new ResponseEntity<>(taskResourceAssembler.toResource(updatedTask),
             HttpStatus.OK);