TSK-221: set multiple Authorisations at once.

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

@@ -5,6 +5,15 @@ package pro.taskana;
  */
 public interface WorkbasketAccessItemQuery extends BaseQuery<WorkbasketAccessItem> {
 
+    /**
+     * Add your unique entry id to your query as filter.
+     *
+     * @param ids
+     *            the unique entry IDs
+     * @return the query
+     */
+    WorkbasketAccessItemQuery idIn(String... ids);
+
     /**
      * Add your workbasket id to your query.
      *
@@ -42,4 +51,14 @@ public interface WorkbasketAccessItemQuery extends BaseQuery<WorkbasketAccessIte
      * @return the query
      */
     WorkbasketAccessItemQuery orderByAccessId(SortDirection sortDirection);
+
+    /**
+     * Sort the query result by Id.
+     *
+     * @param sortDirection
+     *            Determines whether the result is sorted in ascending or descending order. If sortDirection is null,
+     *            the result is sorted in ascending order
+     * @return the query
+     */
+    WorkbasketAccessItemQuery orderById(SortDirection sortDirection);
 }

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

@@ -96,8 +96,11 @@ public interface WorkbasketService {
      * @param workbasketAccessItem
      *            the new workbasketAccessItem
      * @return the created WorkbasketAccessItem
+     * @throws InvalidArgumentException
+     *             when the preconditions doesn´t match the required ones.
      */
-    WorkbasketAccessItem createWorkbasketAuthorization(WorkbasketAccessItem workbasketAccessItem);
+    WorkbasketAccessItem createWorkbasketAuthorization(WorkbasketAccessItem workbasketAccessItem)
+        throws InvalidArgumentException;
 
     /**
      * This method updates an Workbasket Authorization.
@@ -156,6 +159,20 @@ public interface WorkbasketService {
      */
     List<WorkbasketAccessItem> getWorkbasketAuthorizations(String workbasketId);
 
+    /**
+     * Setting up the new WorkbasketAccessItems for a Workbasket. Already stored values will be completely replaced by
+     * the current ones.
+     *
+     * @param workbasketId
+     *            ID of the access-target workbasket.
+     * @param wbAccessItems
+     *            List of WorkbasketAccessItems which does replace all current stored ones.
+     * @throws InvalidArgumentException
+     *             will be thrown when the parameter is NULL or member doesn´t match the preconditions
+     */
+    void setWorkbasketAuthorizations(String workbasketId, List<WorkbasketAccessItem> wbAccessItems)
+        throws InvalidArgumentException;
+
     /**
      * This method returns the workbaskets for which the current user has all permissions specified in the permissions
      * list.
@@ -321,5 +338,4 @@ public interface WorkbasketService {
      */
     List<WorkbasketSummary> getDistributionSources(String workbasketKey, String domain)
         throws NotAuthorizedException, WorkbasketNotFoundException;
-
 }

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

@@ -27,6 +27,7 @@ public class WorkbasketAccessItemQueryImpl implements WorkbasketAccessItemQuery
     private static final Logger LOGGER = LoggerFactory.getLogger(WorkbasketQueryImpl.class);
     private String[] accessIdIn;
     private String[] workbasketIdIn;
+    private String[] idIn;
 
     private TaskanaEngineImpl taskanaEngineImpl;
     private List<String> orderBy;
@@ -36,6 +37,12 @@ public class WorkbasketAccessItemQueryImpl implements WorkbasketAccessItemQuery
         orderBy = new ArrayList<>();
     }
 
+    @Override
+    public WorkbasketAccessItemQuery idIn(String... ids) {
+        this.idIn = ids;
+        return this;
+    }
+
     @Override
     public WorkbasketAccessItemQuery workbasketIdIn(String... id) {
         this.workbasketIdIn = id;
@@ -49,6 +56,11 @@ public class WorkbasketAccessItemQueryImpl implements WorkbasketAccessItemQuery
         return this;
     }
 
+    @Override
+    public WorkbasketAccessItemQuery orderById(SortDirection sortDirection) {
+        return addOrderCriteria("ID", sortDirection);
+    }
+
     @Override
     public WorkbasketAccessItemQuery orderByWorkbasketId(SortDirection sortDirection) {
         return addOrderCriteria("WORKBASKET_ID", sortDirection);
@@ -145,6 +157,10 @@ public class WorkbasketAccessItemQueryImpl implements WorkbasketAccessItemQuery
         return this;
     }
 
+    public String[] getIdIn() {
+        return this.idIn;
+    }
+
     public String[] getAccessIdIn() {
         return accessIdIn;
     }
@@ -160,7 +176,9 @@ public class WorkbasketAccessItemQueryImpl implements WorkbasketAccessItemQuery
     @Override
     public String toString() {
         StringBuilder builder = new StringBuilder();
-        builder.append("WorkbasketAccessItemQueryImpl [accessIdIn=");
+        builder.append("WorkbasketAccessItemQueryImpl [idIn=");
+        builder.append(Arrays.toString(idIn));
+        builder.append(", accessIdIn=");
         builder.append(Arrays.toString(accessIdIn));
         builder.append(", workbasketIdIn=");
         builder.append(Arrays.toString(workbasketIdIn));

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

@@ -200,12 +200,19 @@ public class WorkbasketServiceImpl implements WorkbasketService {
     }
 
     @Override
-    public WorkbasketAccessItem createWorkbasketAuthorization(WorkbasketAccessItem workbasketAccessItem) {
+    public WorkbasketAccessItem createWorkbasketAuthorization(WorkbasketAccessItem workbasketAccessItem)
+        throws InvalidArgumentException {
         LOGGER.debug("entry to createWorkbasketAuthorization(workbasketAccessItem = {})", workbasketAccessItem);
         WorkbasketAccessItemImpl accessItem = (WorkbasketAccessItemImpl) workbasketAccessItem;
         try {
             taskanaEngine.openConnection();
             accessItem.setId(IdGenerator.generateWithPrefix(ID_PREFIX_WORKBASKET_AUTHORIZATION));
+            if (workbasketAccessItem.getId() == null || workbasketAccessItem.getAccessId() == null
+                || workbasketAccessItem.getWorkbasketId() == null) {
+                throw new InvalidArgumentException(
+                    "Checking the preconditions of the current WorkbasketAccessItem failed. WorkbasketAccessItem="
+                        + workbasketAccessItem.toString());
+            }
             workbasketAccessMapper.insert(accessItem);
             LOGGER.debug("Method createWorkbasketAuthorization() created workbaskteAccessItem {}",
                 accessItem);
@@ -218,12 +225,51 @@ public class WorkbasketServiceImpl implements WorkbasketService {
     }
 
     @Override
-    public void deleteWorkbasketAuthorization(String id) {
+    public void setWorkbasketAuthorizations(String workbasketId, List<WorkbasketAccessItem> wbAccessItems)
-        LOGGER.debug("entry to deleteWorkbasketAuthorization(id = {})", id);
+        throws InvalidArgumentException {
+        List<WorkbasketAccessItemImpl> newItems = new ArrayList<>();
+        try {
+            LOGGER.debug("entry to setWorkbasketAuthorizations(workbasketAccessItems = {})", wbAccessItems.toString());
+            taskanaEngine.openConnection();
+            // Check pre-conditions and set ID
+            if (!wbAccessItems.isEmpty()) {
+                for (WorkbasketAccessItem workbasketAccessItem : wbAccessItems) {
+                    WorkbasketAccessItemImpl wbAccessItemImpl = (WorkbasketAccessItemImpl) workbasketAccessItem;
+                    if (wbAccessItemImpl.getWorkbasketId() == null) {
+                        throw new InvalidArgumentException(
+                            "Checking the preconditions of the current WorkbasketAccessItem failed - WBID is NULL. WorkbasketAccessItem="
+                                + workbasketAccessItem.toString());
+                    } else if (!wbAccessItemImpl.getWorkbasketId().equals(workbasketId)) {
+                        throw new InvalidArgumentException(
+                            "Checking the preconditions of the current WorkbasketAccessItem failed - the WBID does not match. Target-WBID='"
+                                + workbasketId + "' WorkbasketAccessItem="
+                                + workbasketAccessItem.toString());
+                    }
+                    if (wbAccessItemImpl.getId() == null || wbAccessItemImpl.getId().isEmpty()) {
+                        wbAccessItemImpl.setId(IdGenerator.generateWithPrefix(ID_PREFIX_WORKBASKET_AUTHORIZATION));
+                    }
+                    newItems.add(wbAccessItemImpl);
+                }
+
+                // delete all current ones
+                workbasketAccessMapper.deleteAllAccessItemsForWorkbasketId(workbasketId);
+
+                // add all
+                newItems.stream().forEach(item -> workbasketAccessMapper.insert(item));
+            }
+        } finally {
+            taskanaEngine.returnConnection();
+            LOGGER.debug("exit from setWorkbasketAuthorizations(workbasketAccessItems = {})", wbAccessItems.toString());
+        }
+    }
+
+    @Override
+    public void deleteWorkbasketAuthorization(String accessItemId) {
+        LOGGER.debug("entry to deleteWorkbasketAuthorization(id = {})", accessItemId);
         try {
             taskanaEngine.openConnection();
-            workbasketAccessMapper.delete(id);
+            workbasketAccessMapper.delete(accessItemId);
-            LOGGER.debug("Method deleteWorkbasketAuthorization() deleted workbasketAccessItem wit Id {}", id);
+            LOGGER.debug("Method deleteWorkbasketAuthorization() deleted workbasketAccessItem wit Id {}", accessItemId);
         } finally {
             taskanaEngine.returnConnection();
             LOGGER.debug("exit from deleteWorkbasketAuthorization(id).");
@@ -613,7 +659,7 @@ public class WorkbasketServiceImpl implements WorkbasketService {
             // delete workbasket and sub-tables
             distributionTargetMapper.deleteAllDistributionTargetsBySourceId(wb.getId());
             distributionTargetMapper.deleteAllDistributionTargetsByTargetId(wb.getId());
-            workbasketAccessMapper.deleteAllForWorkbasketId(wb.getId());
+            workbasketAccessMapper.deleteAllAccessItemsForWorkbasketId(wb.getId());
             workbasketMapper.delete(workbasketId);
         } finally {
             taskanaEngine.returnConnection();

lib/taskana-core/src/main/java/pro/taskana/mappings/QueryMapper.java

@@ -273,6 +273,7 @@ public interface QueryMapper {
         + "PERM_CUSTOM_3, PERM_CUSTOM_4, PERM_CUSTOM_5, PERM_CUSTOM_6, PERM_CUSTOM_7, PERM_CUSTOM_8, PERM_CUSTOM_9, PERM_CUSTOM_10, PERM_CUSTOM_11, PERM_CUSTOM_12 "
         + "from WORKBASKET_ACCESS_LIST "
         + "<where>"
+        + "<if test='idIn != null'>AND ID IN(<foreach item='item' collection='idIn' separator=',' >#{item}</foreach>)</if> "
         + "<if test='workbasketIdIn != null'>AND WORKBASKET_ID IN(<foreach item='item' collection='workbasketIdIn' separator=',' >#{item}</foreach>)</if> "
         + "<if test='accessIdIn != null'>AND ACCESS_ID IN(<foreach item='item' collection='accessIdIn' separator=',' >#{item}</foreach>) </if> "
         + "</where>"

lib/taskana-core/src/main/java/pro/taskana/mappings/WorkbasketAccessMapper.java

@@ -77,11 +77,11 @@ public interface WorkbasketAccessMapper {
         + "WHERE id = #{workbasketAccessItem.id}")
     void update(@Param("workbasketAccessItem") WorkbasketAccessItemImpl workbasketAccessItem);
 
-    @Delete("DELETE FROM WORKBASKET_ACCESS_LIST where id = #{id}")
+    @Delete("DELETE FROM WORKBASKET_ACCESS_LIST WHERE ID = #{id}")
     void delete(@Param("id") String id);
 
-    @Delete("DELETE FROM WORKBASKET_ACCESS_LIST where WORKBASKET_ID = #{workbasketId}")
+    @Delete("DELETE FROM WORKBASKET_ACCESS_LIST WHERE WORKBASKET_ID = #{workbasketId}")
-    void deleteAllForWorkbasketId(@Param("workbasketId") String workbasketId);
+    void deleteAllAccessItemsForWorkbasketId(@Param("workbasketId") String workbasketId);
 
     @Select("<script>SELECT MAX(PERM_READ) AS P_READ, MAX(PERM_OPEN) AS P_OPEN, MAX(PERM_APPEND) AS P_APPEND, MAX(PERM_TRANSFER) AS P_TRANSFER, MAX(PERM_DISTRIBUTE) AS P_DISTRIBUTE, MAX(PERM_CUSTOM_1) AS P_CUSTOM_1, MAX(PERM_CUSTOM_2) AS P_CUSTOM_2, MAX(PERM_CUSTOM_3) AS P_CUSTOM_3, MAX(PERM_CUSTOM_4) AS P_CUSTOM_4, MAX(PERM_CUSTOM_5) AS P_CUSTOM_5, MAX(PERM_CUSTOM_6) AS P_CUSTOM_6, MAX(PERM_CUSTOM_7) AS P_CUSTOM_7, MAX(PERM_CUSTOM_8) AS P_CUSTOM_8, MAX(PERM_CUSTOM_9) AS P_CUSTOM_9, MAX(PERM_CUSTOM_10) AS P_CUSTOM_10, MAX(PERM_CUSTOM_11) AS P_CUSTOM_11, MAX(PERM_CUSTOM_12) AS P_CUSTOM_12 "
         + "FROM WORKBASKET_ACCESS_LIST "

lib/taskana-core/src/main/resources/sql/taskana-schema.sql

@@ -108,7 +108,7 @@ CREATE TABLE DISTRIBUTION_TARGETS(
 CREATE TABLE WORKBASKET_ACCESS_LIST(
         ID CHAR(40) NOT NULL,
         WORKBASKET_ID CHAR(40) NOT NULL,
-        ACCESS_ID VARCHAR(255) NULL,
+        ACCESS_ID VARCHAR(255) NOT NULL,
         PERM_READ BOOLEAN NOT NULL,
         PERM_OPEN BOOLEAN NOT NULL,
         PERM_APPEND BOOLEAN NOT NULL,

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

@@ -1,5 +1,10 @@
 package acceptance.workbasket;
 
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.hamcrest.core.IsNot.not;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
 import java.sql.SQLException;
@@ -26,6 +31,7 @@ import pro.taskana.exceptions.NotAuthorizedToQueryWorkbasketException;
 import pro.taskana.exceptions.TaskAlreadyExistException;
 import pro.taskana.exceptions.WorkbasketNotFoundException;
 import pro.taskana.impl.WorkbasketAccessItemImpl;
+import pro.taskana.security.CurrentUserContext;
 import pro.taskana.security.JAASRunner;
 import pro.taskana.security.WithAccessId;
 
@@ -126,6 +132,7 @@ public class UpdateWorkbasketAuthorizationsAccTest extends AbstractAccTest {
             .workbasketKeyDomainIn(new KeyDomain(wbKey, "DOMAIN_A"))
             .list();
         Assert.assertEquals(1, tasks.size());
+        assertThat(createdTask, not(equalTo(null)));
 
         List<WorkbasketAccessItem> accessItems = workbasketService
             .getWorkbasketAuthorizations("WBI:100000000000000000000000000000000008");
@@ -146,7 +153,86 @@ public class UpdateWorkbasketAuthorizationsAccTest extends AbstractAccTest {
         } catch (NotAuthorizedToQueryWorkbasketException ignored) {
             // nothing to do
         }
+    }
 
+    @WithAccessId(
+        userName = "teamlead_1",
+        groupNames = {"group_1"})
+    @Test
+    public void testUpdatedAccessItemList() throws InvalidArgumentException {
+        WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
+        final String wbId = "WBI:100000000000000000000000000000000004";
+        List<WorkbasketAccessItem> accessItems = workbasketService
+            .getWorkbasketAuthorizations(wbId);
+        int countBefore = accessItems.size();
+
+        // update some values
+        WorkbasketAccessItem item0 = accessItems.get(0);
+        item0.setPermAppend(false);
+        item0.setPermOpen(false);
+        item0.setPermTransfer(false);
+        final String updateId0 = item0.getId();
+        WorkbasketAccessItem item1 = accessItems.get(1);
+        item1.setPermAppend(false);
+        item1.setPermOpen(false);
+        item1.setPermTransfer(false);
+        final String updateId1 = item1.getId();
+
+        workbasketService.setWorkbasketAuthorizations(wbId, accessItems);
+
+        List<WorkbasketAccessItem> updatedAccessItems = workbasketService
+            .getWorkbasketAuthorizations(wbId);
+        int countAfter = updatedAccessItems.size();
+        assertThat(countAfter, equalTo(countBefore));
+
+        item0 = updatedAccessItems.stream().filter(i -> i.getId().equals(updateId0)).findFirst().get();
+        assertFalse(item0.isPermAppend());
+        assertFalse(item0.isPermOpen());
+        assertFalse(item0.isPermTransfer());
+
+        item1 = updatedAccessItems.stream().filter(i -> i.getId().equals(updateId1)).findFirst().get();
+        assertFalse(item1.isPermAppend());
+        assertFalse(item1.isPermOpen());
+        assertFalse(item1.isPermTransfer());
+    }
+
+    @WithAccessId(
+        userName = "teamlead_1",
+        groupNames = {"group_1"})
+    @Test
+    public void testInsertAccessItemList() throws InvalidArgumentException {
+        WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
+        final String wbId = "WBI:100000000000000000000000000000000004";
+        List<WorkbasketAccessItem> accessItems = workbasketService
+            .getWorkbasketAuthorizations(wbId);
+        int countBefore = accessItems.size();
+
+        // update some values
+        WorkbasketAccessItem item0 = accessItems.get(0);
+        item0.setPermAppend(false);
+        item0.setPermOpen(false);
+        item0.setPermTransfer(false);
+        final String updateId0 = item0.getId();
+        // insert new entry
+        WorkbasketAccessItem newItem = workbasketService.newWorkbasketAccessItem(wbId, CurrentUserContext.getUserid());
+        newItem.setPermRead(true);
+        newItem.setPermOpen(true);
+        newItem.setPermCustom12(true);
+        accessItems.add(newItem);
+
+        workbasketService.setWorkbasketAuthorizations(wbId, accessItems);
+
+        List<WorkbasketAccessItem> updatedAccessItems = workbasketService
+            .getWorkbasketAuthorizations(wbId);
+        int countAfter = updatedAccessItems.size();
+        assertTrue((countBefore + 1) == countAfter);
+
+        item0 = updatedAccessItems.stream().filter(i -> i.getId().equals(updateId0)).findFirst().get();
+        assertFalse(item0.isPermAppend());
+        assertFalse(item0.isPermOpen());
+        assertFalse(item0.isPermTransfer());
+        assertFalse(item0.isPermAppend());
+        assertFalse(item0.isPermTransfer());
     }
 
     @AfterClass

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

@@ -516,7 +516,7 @@ public class WorkbasketServiceImplTest {
         verify(taskQueryMock, times(1)).list();
         verify(distributionTargetMapperMock, times(1)).deleteAllDistributionTargetsBySourceId(wb.getId());
         verify(distributionTargetMapperMock, times(1)).deleteAllDistributionTargetsByTargetId(wb.getId());
-        verify(workbasketAccessMapperMock, times(1)).deleteAllForWorkbasketId(wb.getId());
+        verify(workbasketAccessMapperMock, times(1)).deleteAllAccessItemsForWorkbasketId(wb.getId());
         verify(workbasketMapperMock, times(1)).delete(wb.getId());
         verify(taskanaEngineImplMock, times(1)).returnConnection();
         verifyNoMoreInteractions(taskQueryMock, taskServiceMock, workbasketMapperMock, workbasketAccessMapperMock,

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

@@ -401,7 +401,7 @@ public class TaskServiceImplIntAutocommitTest {
     }
 
     private void createWorkbasketWithSecurity(Workbasket wb, String accessId, boolean permOpen,
-        boolean permRead, boolean permAppend, boolean permTransfer) {
+        boolean permRead, boolean permAppend, boolean permTransfer) throws InvalidArgumentException {
         WorkbasketAccessItem accessItem = workbasketService.newWorkbasketAccessItem(wb.getId(), accessId);
         accessItem.setPermOpen(permOpen);
         accessItem.setPermRead(permRead);

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

@@ -540,7 +540,7 @@ public class TaskServiceImplIntExplicitTest {
         return task;
     }
 
-    private void generateSampleAccessItems() {
+    private void generateSampleAccessItems() throws InvalidArgumentException {
         WorkbasketAccessItem accessItem = workbasketService.newWorkbasketAccessItem("1", "Elena");
         accessItem.setPermAppend(true);
         accessItem.setPermRead(true);
@@ -554,7 +554,7 @@ public class TaskServiceImplIntExplicitTest {
     }
 
     private void createWorkbasketWithSecurity(Workbasket wb, String accessId, boolean permOpen,
-        boolean permRead, boolean permAppend, boolean permTransfer) {
+        boolean permRead, boolean permAppend, boolean permTransfer) throws InvalidArgumentException {
         WorkbasketAccessItem accessItem = workbasketService.newWorkbasketAccessItem(wb.getId(), accessId);
         accessItem.setPermOpen(permOpen);
         accessItem.setPermRead(permRead);

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

@@ -132,7 +132,8 @@ public class WorkbasketServiceImplIntAutocommitTest {
     @WithAccessId(userName = "Elena")
     @Test
     public void testSelectWorkbasket()
-        throws WorkbasketNotFoundException, NotAuthorizedException, InvalidWorkbasketException {
+        throws WorkbasketNotFoundException, NotAuthorizedException, InvalidWorkbasketException,
+        InvalidArgumentException {
         String id = IdGenerator.generateWithPrefix("TWB");
         Workbasket workbasket = createTestWorkbasket(id, "key0", "novatec", "Superbasket", WorkbasketType.GROUP);
         workbasket = workBasketService.createWorkbasket(workbasket);
@@ -150,7 +151,8 @@ public class WorkbasketServiceImplIntAutocommitTest {
     @WithAccessId(userName = "Elena")
     @Test
     public void testSelectWorkbasketWithDistribution()
-        throws WorkbasketNotFoundException, NotAuthorizedException, InvalidWorkbasketException {
+        throws WorkbasketNotFoundException, NotAuthorizedException, InvalidWorkbasketException,
+        InvalidArgumentException {
         String id = IdGenerator.generateWithPrefix("TWB");
         Workbasket wbDist1 = createTestWorkbasket(id, "key0", "novatec", "Superbasket", WorkbasketType.GROUP);
         wbDist1 = workBasketService.createWorkbasket(wbDist1);
@@ -191,7 +193,7 @@ public class WorkbasketServiceImplIntAutocommitTest {
         workbasket2 = workBasketService.createWorkbasket(workbasket2);
         createWorkbasketWithSecurity(workbasket2, "Elena", true, true, false, false);
         List<String> distTargets = new ArrayList<>(Arrays.asList(workbasket0.getId(), workbasket1.getId()));
-        Thread.sleep(20L);
+        Thread.sleep(SLEEP_TIME);
         workBasketService.setDistributionTargets(workbasket2.getId(), distTargets);
 
         String id3 = IdGenerator.generateWithPrefix("TWB");
@@ -201,7 +203,7 @@ public class WorkbasketServiceImplIntAutocommitTest {
         createWorkbasketWithSecurity(workbasket3, "Elena", true, true, false, false);
 
         List<String> newDistTargets = new ArrayList<>(Arrays.asList(workbasket3.getId()));
-        Thread.sleep(20L);
+        Thread.sleep(SLEEP_TIME);
         workBasketService.setDistributionTargets(workbasket2.getId(), newDistTargets);
 
         Workbasket foundBasket = workBasketService.getWorkbasket(workbasket2.getId());
@@ -219,7 +221,7 @@ public class WorkbasketServiceImplIntAutocommitTest {
     }
 
     @Test
-    public void testInsertWorkbasketAccessUser() throws NotAuthorizedException {
+    public void testInsertWorkbasketAccessUser() throws NotAuthorizedException, InvalidArgumentException {
         WorkbasketAccessItem accessItem = workBasketService
             .newWorkbasketAccessItem("k100000000000000000000000000000000000000", "Arthur Dent");
         accessItem.setPermOpen(true);
@@ -298,7 +300,7 @@ public class WorkbasketServiceImplIntAutocommitTest {
             assertTrue("Basket1".equals(name) || "Basket2".equals(name) || "Basket3".equals(name));
         }
 
-        Thread.sleep(20L);
+        Thread.sleep(SLEEP_TIME);
         WorkbasketQuery query5 = workBasketService.createWorkbasketQuery()
             .modifiedWithin(
                 new TimeInterval(Instant.now().minus(Duration.ofDays(31)), Instant.now().minus(Duration.ofDays(14))));
@@ -329,7 +331,8 @@ public class WorkbasketServiceImplIntAutocommitTest {
     }
 
     private void generateSampleDataForQuery()
-        throws InvalidWorkbasketException, WorkbasketNotFoundException, NotAuthorizedException {
+        throws InvalidWorkbasketException, WorkbasketNotFoundException, NotAuthorizedException,
+        InvalidArgumentException {
         WorkbasketImpl basket1 = (WorkbasketImpl) workBasketService.newWorkbasket("k1", "novatec");
         basket1.setId("1000000000000000000000000000000000000000");
         basket1.setName("Basket1");
@@ -412,7 +415,7 @@ public class WorkbasketServiceImplIntAutocommitTest {
     }
 
     private void createWorkbasketWithSecurity(Workbasket wb, String accessId, boolean permOpen,
-        boolean permRead, boolean permAppend, boolean permTransfer) {
+        boolean permRead, boolean permAppend, boolean permTransfer) throws InvalidArgumentException {
         WorkbasketAccessItem accessItem = workBasketService.newWorkbasketAccessItem(wb.getId(), accessId);
         accessItem.setPermOpen(permOpen);
         accessItem.setPermRead(permRead);

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

@@ -26,6 +26,7 @@ import pro.taskana.WorkbasketAccessItem;
 import pro.taskana.WorkbasketService;
 import pro.taskana.WorkbasketSummary;
 import pro.taskana.configuration.TaskanaEngineConfiguration;
+import pro.taskana.exceptions.InvalidArgumentException;
 import pro.taskana.exceptions.InvalidWorkbasketException;
 import pro.taskana.exceptions.NotAuthorizedException;
 import pro.taskana.exceptions.WorkbasketNotFoundException;
@@ -123,7 +124,8 @@ public class WorkbasketServiceImplIntExplicitTest {
     @WithAccessId(userName = "Elena")
     @Test
     public void testSelectWorkbasket()
-        throws WorkbasketNotFoundException, NotAuthorizedException, SQLException, InvalidWorkbasketException {
+        throws WorkbasketNotFoundException, NotAuthorizedException, SQLException, InvalidWorkbasketException,
+        InvalidArgumentException {
         Connection connection = dataSource.getConnection();
         taskanaEngineImpl.setConnection(connection);
         workBasketService = taskanaEngine.getWorkbasketService();
@@ -143,7 +145,8 @@ public class WorkbasketServiceImplIntExplicitTest {
     @WithAccessId(userName = "Elena")
     @Test(expected = NotAuthorizedException.class)
     public void testGetWorkbasketFail()
-        throws WorkbasketNotFoundException, SQLException, InvalidWorkbasketException, NotAuthorizedException {
+        throws WorkbasketNotFoundException, SQLException, InvalidWorkbasketException, NotAuthorizedException,
+        InvalidArgumentException {
         Connection connection = dataSource.getConnection();
         taskanaEngineImpl.setConnection(connection);
         workBasketService = taskanaEngine.getWorkbasketService();
@@ -159,7 +162,8 @@ public class WorkbasketServiceImplIntExplicitTest {
     @WithAccessId(userName = "Elena")
     @Test
     public void testSelectWorkbasketWithDistribution()
-        throws WorkbasketNotFoundException, NotAuthorizedException, SQLException, InvalidWorkbasketException {
+        throws WorkbasketNotFoundException, NotAuthorizedException, SQLException, InvalidWorkbasketException,
+        InvalidArgumentException {
         Connection connection = dataSource.getConnection();
         taskanaEngineImpl.setConnection(connection);
         workBasketService = taskanaEngine.getWorkbasketService();
@@ -210,7 +214,7 @@ public class WorkbasketServiceImplIntExplicitTest {
         createWorkbasketWithSecurity(workbasket2, "Elena", true, true, false, false);
 
         List<String> distTargets = new ArrayList<>(Arrays.asList(workbasket0.getId(), workbasket1.getId()));
-        Thread.sleep(20L);
+        Thread.sleep(SLEEP_TIME);
         workBasketService.setDistributionTargets(workbasket2.getId(), distTargets);
 
         String id3 = IdGenerator.generateWithPrefix("TWB");
@@ -220,7 +224,7 @@ public class WorkbasketServiceImplIntExplicitTest {
         createWorkbasketWithSecurity(workbasket3, "Elena", true, true, false, false);
 
         List<String> newDistTargets = new ArrayList<>(Arrays.asList(workbasket3.getId()));
-        Thread.sleep(20L);
+        Thread.sleep(SLEEP_TIME);
         workBasketService.setDistributionTargets(workbasket2.getId(), newDistTargets);
 
         Workbasket foundBasket = workBasketService.getWorkbasket(workbasket2.getId());
@@ -238,7 +242,7 @@ public class WorkbasketServiceImplIntExplicitTest {
     }
 
     @Test
-    public void testInsertWorkbasketAccessUser() throws NotAuthorizedException, SQLException {
+    public void testInsertWorkbasketAccessUser() throws NotAuthorizedException, SQLException, InvalidArgumentException {
         Connection connection = dataSource.getConnection();
         taskanaEngineImpl.setConnection(connection);
         workBasketService = taskanaEngine.getWorkbasketService();
@@ -254,7 +258,7 @@ public class WorkbasketServiceImplIntExplicitTest {
     }
 
     @Test
-    public void testUpdateWorkbasketAccessUser() throws NotAuthorizedException, SQLException {
+    public void testUpdateWorkbasketAccessUser() throws NotAuthorizedException, SQLException, InvalidArgumentException {
         Connection connection = dataSource.getConnection();
         taskanaEngineImpl.setConnection(connection);
         workBasketService = taskanaEngine.getWorkbasketService();
@@ -271,7 +275,7 @@ public class WorkbasketServiceImplIntExplicitTest {
     }
 
     private void createWorkbasketWithSecurity(Workbasket wb, String accessId, boolean permOpen,
-        boolean permRead, boolean permAppend, boolean permTransfer) {
+        boolean permRead, boolean permAppend, boolean permTransfer) throws InvalidArgumentException {
         WorkbasketAccessItem accessItem = workBasketService.newWorkbasketAccessItem(
             wb.getId(), accessId);
         accessItem.setPermOpen(permOpen);

rest/src/main/java/pro/taskana/rest/WorkbasketController.java

@@ -1,5 +1,6 @@
 package pro.taskana.rest;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.stream.Collectors;
@@ -17,6 +18,7 @@ import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.PutMapping;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
 
@@ -188,19 +190,46 @@ public class WorkbasketController {
     @Transactional(rollbackFor = Exception.class)
     public ResponseEntity<WorkbasketAccessItemResource> createWorkbasketAuthorization(
         @RequestBody WorkbasketAccessItemResource workbasketAccessItemResource) {
-        WorkbasketAccessItem workbasketAccessItem = workbasketAccessItemMapper.toModel(workbasketAccessItemResource);
+        try {
-        workbasketAccessItem = workbasketService.createWorkbasketAuthorization(workbasketAccessItem);
+            WorkbasketAccessItem workbasketAccessItem = workbasketAccessItemMapper
-        return new ResponseEntity<>(workbasketAccessItemMapper.toResource(workbasketAccessItem), HttpStatus.OK);
+                .toModel(workbasketAccessItemResource);
+            workbasketAccessItem = workbasketService.createWorkbasketAuthorization(workbasketAccessItem);
+            return new ResponseEntity<>(workbasketAccessItemMapper.toResource(workbasketAccessItem), HttpStatus.OK);
+        } catch (InvalidArgumentException e) {
+            return new ResponseEntity<>(HttpStatus.PRECONDITION_FAILED);
+        }
     }
 
     @PutMapping(path = "/authorizations/{authId}")
     @Transactional(rollbackFor = Exception.class)
     public ResponseEntity<WorkbasketAccessItemResource> updateWorkbasketAuthorization(
         @PathVariable(value = "authId") String authId,
-        @RequestBody WorkbasketAccessItemResource workbasketAccessItemResource) throws InvalidArgumentException {
+        @RequestBody WorkbasketAccessItemResource workbasketAccessItemResource) {
-        WorkbasketAccessItem workbasketAccessItem = workbasketAccessItemMapper.toModel(workbasketAccessItemResource);
+        try {
-        workbasketAccessItem = workbasketService.updateWorkbasketAuthorization(workbasketAccessItem);
+            WorkbasketAccessItem workbasketAccessItem = workbasketAccessItemMapper
-        return new ResponseEntity<>(workbasketAccessItemMapper.toResource(workbasketAccessItem), HttpStatus.OK);
+                .toModel(workbasketAccessItemResource);
+            workbasketAccessItem = workbasketService.updateWorkbasketAuthorization(workbasketAccessItem);
+            return new ResponseEntity<>(workbasketAccessItemMapper.toResource(workbasketAccessItem), HttpStatus.OK);
+        } catch (InvalidArgumentException e) {
+            return new ResponseEntity<>(HttpStatus.PRECONDITION_FAILED);
+        }
+    }
+
+    @RequestMapping(value = "/{workbasketId}/authorizations/", method = RequestMethod.PUT)
+    public ResponseEntity<?> setWorkbasketAuthorizations(@PathVariable(value = "workbasketId") String workbasketId,
+        @RequestBody List<WorkbasketAccessItemResource> workbasketAccessResourceItems) {
+        try {
+            if (workbasketAccessResourceItems == null) {
+                throw new InvalidArgumentException("Can´t create something with NULL body-value.");
+            }
+            List<WorkbasketAccessItem> wbAccessItems = new ArrayList<>();
+            workbasketAccessResourceItems.stream()
+                .forEach(item -> wbAccessItems.add(workbasketAccessItemMapper.toModel(item)));
+            workbasketService.setWorkbasketAuthorizations(workbasketId, wbAccessItems);
+            return new ResponseEntity<>(HttpStatus.NO_CONTENT);
+        } catch (InvalidArgumentException | NullPointerException e) {
+            return new ResponseEntity<>(HttpStatus.PRECONDITION_FAILED);
+        }
     }
 
     @DeleteMapping(path = "/authorizations/{authId}")

rest/src/main/java/pro/taskana/rest/WorkbasketDefinitionController.java

@@ -23,6 +23,7 @@ import pro.taskana.Workbasket;
 import pro.taskana.WorkbasketQuery;
 import pro.taskana.WorkbasketService;
 import pro.taskana.WorkbasketSummary;
+import pro.taskana.exceptions.InvalidArgumentException;
 import pro.taskana.exceptions.InvalidWorkbasketException;
 import pro.taskana.exceptions.NotAuthorizedException;
 import pro.taskana.exceptions.WorkbasketNotFoundException;
@@ -73,24 +74,27 @@ public class WorkbasketDefinitionController {
     }
 
     /**
-     * This method imports a <b>list of {@link WorkbasketDefinition}</b>.
+     * This method imports a <b>list of {@link WorkbasketDefinition}</b>. This does not exactly match the REST norm, but
-     * This does not exactly match the REST norm, but we want to have an option to import all settings at once.
+     * we want to have an option to import all settings at once. When a logical equal (key and domain are equal)
-     * When a logical equal (key and domain are equal) workbasket already exists an update will be executed.
+     * workbasket already exists an update will be executed. Otherwise a new workbasket will be created.
-     * Otherwise a new workbasket will be created.
      *
-     * @param definitions the list of workbasket definitions which will be imported to the current system.
+     * @param definitions
-     * @return Return answer is determined by the status code:
+     *            the list of workbasket definitions which will be imported to the current system.
-     * 200 - all good
+     * @return Return answer is determined by the status code: 200 - all good 400 - list state error (referring to non
-     * 400 - list state error (referring to non existing id's)
+     *         existing id's) 401 - not authorized
-     * 401 - not authorized
+     * @throws InvalidArgumentException
+     *             When the pre-conditions of a workbasket doesn´t match.
      */
     @PostMapping(path = "/import")
     @Transactional(rollbackFor = Exception.class)
-    public ResponseEntity<String> importWorkbaskets(@RequestBody List<WorkbasketDefinition> definitions) {
+    public ResponseEntity<String> importWorkbaskets(@RequestBody List<WorkbasketDefinition> definitions)
+        throws InvalidArgumentException {
         try {
             // key: logical ID
             // value: system ID (in database)
-            Map<String, String> systemIds = workbasketService.createWorkbasketQuery().list().stream()
+            Map<String, String> systemIds = workbasketService.createWorkbasketQuery()
+                .list()
+                .stream()
                 .collect(Collectors.toMap(this::logicalId, WorkbasketSummary::getId));
 
             // key: old system ID
@@ -105,18 +109,15 @@ public class WorkbasketDefinitionController {
                     String oldId = res.workbasketId;
                     res.workbasketId = systemIds.get(logicalId(res));
                     workbasket = workbasketService.updateWorkbasket(
-                        workbasketMapper.toModel(res)
+                        workbasketMapper.toModel(res));
-                    );
                     res.workbasketId = oldId;
                 } else {
                     workbasket = workbasketService.createWorkbasket(
-                        workbasketMapper.toModel(res)
+                        workbasketMapper.toModel(res));
-                    );
                 }
                 for (WorkbasketAccessItemResource authorization : definition.authorizations) {
                     workbasketService.createWorkbasketAuthorization(
-                        workbasketAccessItemMapper.toModel(authorization)
+                        workbasketAccessItemMapper.toModel(authorization));
-                    );
                 }
                 idConversion.put(definition.workbasketResource.workbasketId, workbasket.getId());
             }
@@ -132,15 +133,13 @@ public class WorkbasketDefinitionController {
                         throw new WorkbasketNotFoundException(
                             String.format(
                                 "invalid import state: Workbasket '%s' does not exist in the given import list",
-                                oldId)
+                                oldId));
-                        );
                     }
                 }
 
                 workbasketService.setDistributionTargets(
                     // no verification necessary since the workbasket was already imported in step 1.
-                    idConversion.get(definition.workbasketResource.workbasketId), distributionTargets
+                    idConversion.get(definition.workbasketResource.workbasketId), distributionTargets);
-                );
             }
 
             return new ResponseEntity<>(HttpStatus.OK);