nosu
/
taskana
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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

This commit is contained in:
Holger Hagen 2018-04-18 11:21:14 +02:00 committed by Martin Rojas Miguel Angel
parent dc8b0dbc54
commit 5ef112bf97
13 changed files with 94 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
lib/taskana-core/src/main/java/pro/taskana/TaskService.java
View File

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

5
lib/taskana-core/src/test/resources/sql/task.sql
View File

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

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

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

3
rest/taskana-rest-spring/src/main/java/pro/taskana/rest/TaskController.java
View File

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