TSK-382 add errorhandling to controllers

lib/taskana-core/src/main/java/pro/taskana/exceptions/InvalidRequestException.java

@@ -1,15 +0,0 @@
-package pro.taskana.exceptions;
-
-/**
- * This exception is thrown when a method is called in a context where it must not be called.
- *
- * @author bbr
- */
-public class InvalidRequestException extends TaskanaException {
-
-    public InvalidRequestException(String msg) {
-        super(msg);
-    }
-
-    private static final long serialVersionUID = 1L;
-}

lib/taskana-core/src/test/java/acceptance/security/WorkbasketQueryAccTest.java

@@ -12,7 +12,6 @@ import pro.taskana.WorkbasketPermission;
 import pro.taskana.WorkbasketService;
 import pro.taskana.WorkbasketSummary;
 import pro.taskana.exceptions.InvalidArgumentException;
-import pro.taskana.exceptions.InvalidRequestException;
 import pro.taskana.exceptions.NotAuthorizedException;
 import pro.taskana.security.JAASRunner;
 import pro.taskana.security.WithAccessId;
@@ -29,7 +28,7 @@ public class WorkbasketQueryAccTest extends AbstractAccTest {
 
     @Test
     public void testQueryWorkbasketByUnauthenticated()
-        throws SQLException, NotAuthorizedException, InvalidRequestException, InvalidArgumentException {
+        throws SQLException, NotAuthorizedException, InvalidArgumentException {
         WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
         List<WorkbasketSummary> results = workbasketService.createWorkbasketQuery()
             .nameLike("%")
@@ -52,7 +51,7 @@ public class WorkbasketQueryAccTest extends AbstractAccTest {
         userName = "unknown")
     @Test
     public void testQueryWorkbasketByUnknownUser()
-        throws SQLException, NotAuthorizedException, InvalidRequestException, InvalidArgumentException {
+        throws SQLException, NotAuthorizedException, InvalidArgumentException {
         WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
         List<WorkbasketSummary> results = workbasketService.createWorkbasketQuery()
             .nameLike("%")
@@ -76,7 +75,7 @@ public class WorkbasketQueryAccTest extends AbstractAccTest {
         groupNames = "businessadmin")
     @Test
     public void testQueryWorkbasketByBusinessAdmin()
-        throws SQLException, NotAuthorizedException, InvalidRequestException, InvalidArgumentException {
+        throws SQLException, NotAuthorizedException, InvalidArgumentException {
         WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
         List<WorkbasketSummary> results = workbasketService.createWorkbasketQuery()
             .nameLike("%")
@@ -97,7 +96,7 @@ public class WorkbasketQueryAccTest extends AbstractAccTest {
         groupNames = "admin")
     @Test
     public void testQueryWorkbasketByAdmin()
-        throws SQLException, NotAuthorizedException, InvalidRequestException, InvalidArgumentException {
+        throws SQLException, NotAuthorizedException, InvalidArgumentException {
         WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
         List<WorkbasketSummary> results = workbasketService.createWorkbasketQuery()
             .nameLike("%")

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

@@ -17,7 +17,6 @@ import pro.taskana.WorkbasketService;
 import pro.taskana.WorkbasketSummary;
 import pro.taskana.WorkbasketType;
 import pro.taskana.exceptions.InvalidArgumentException;
-import pro.taskana.exceptions.InvalidRequestException;
 import pro.taskana.exceptions.NotAuthorizedException;
 import pro.taskana.security.JAASRunner;
 import pro.taskana.security.WithAccessId;
@@ -246,7 +245,7 @@ public class QueryWorkbasketAccTest extends AbstractAccTest {
         groupNames = {"group_1"})
     @Test
     public void testQueryWorkbasketByNameStartsWithSortedByNameAscending()
-        throws SQLException, NotAuthorizedException, InvalidRequestException, InvalidArgumentException {
+        throws SQLException, NotAuthorizedException, InvalidArgumentException {
         WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
         List<WorkbasketSummary> results = workbasketService.createWorkbasketQuery()
             .nameLike("%Gruppenpostkorb KSC%")
@@ -271,7 +270,7 @@ public class QueryWorkbasketAccTest extends AbstractAccTest {
         userName = "max")
     @Test
     public void testQueryWorkbasketByNameStartsWithSortedByNameDescending()
-        throws SQLException, NotAuthorizedException, InvalidRequestException, InvalidArgumentException {
+        throws SQLException, NotAuthorizedException, InvalidArgumentException {
         WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
         List<WorkbasketSummary> results = workbasketService.createWorkbasketQuery()
             .nameLike("basxet%")
@@ -293,7 +292,7 @@ public class QueryWorkbasketAccTest extends AbstractAccTest {
         userName = "max")
     @Test
     public void testQueryWorkbasketByNameStartsWithSortedByKeyAscending()
-        throws SQLException, NotAuthorizedException, InvalidArgumentException, InvalidRequestException {
+        throws SQLException, NotAuthorizedException, InvalidArgumentException {
         WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
         List<WorkbasketSummary> results = workbasketService.createWorkbasketQuery()
             .nameLike("basxet%")
@@ -315,7 +314,7 @@ public class QueryWorkbasketAccTest extends AbstractAccTest {
         userName = "max")
     @Test
     public void testQueryWorkbasketByNameStartsWithSortedByKeyDescending()
-        throws SQLException, NotAuthorizedException, InvalidArgumentException, InvalidRequestException {
+        throws SQLException, NotAuthorizedException, InvalidArgumentException {
         WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
         List<WorkbasketSummary> results = workbasketService.createWorkbasketQuery()
             .nameLike("basxet%")
@@ -364,7 +363,7 @@ public class QueryWorkbasketAccTest extends AbstractAccTest {
         groupNames = "admin")
     @Test
     public void testQueryWorkbasketByAdmin()
-        throws SQLException, NotAuthorizedException, InvalidRequestException, InvalidArgumentException {
+        throws SQLException, NotAuthorizedException, InvalidArgumentException {
         WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
         List<WorkbasketSummary> results = workbasketService.createWorkbasketQuery()
             .nameLike("%")

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

@@ -17,7 +17,6 @@ import pro.taskana.WorkbasketPermission;
 import pro.taskana.WorkbasketService;
 import pro.taskana.WorkbasketSummary;
 import pro.taskana.exceptions.InvalidArgumentException;
-import pro.taskana.exceptions.InvalidRequestException;
 import pro.taskana.exceptions.NotAuthorizedException;
 import pro.taskana.exceptions.SystemException;
 import pro.taskana.security.JAASRunner;
@@ -80,8 +79,7 @@ public class QueryWorkbasketByPermissionAccTest extends AbstractAccTest {
         groupNames = {"businessadmin"})
     @Test
     public void testQueryAllTransferTargetsForUserAndGroupSortedByNameAscending()
-        throws SQLException, NotAuthorizedException, InvalidArgumentException, SystemException,
+        throws SQLException, NotAuthorizedException, InvalidArgumentException, SystemException {
-        InvalidRequestException {
         WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
         List<WorkbasketSummary> results = workbasketService.createWorkbasketQuery()
             .accessIdsHavePermission(WorkbasketPermission.APPEND, "user_1_1", "group_1")
@@ -96,8 +94,7 @@ public class QueryWorkbasketByPermissionAccTest extends AbstractAccTest {
         groupNames = {"businessadmin"})
     @Test
     public void testQueryAllTransferTargetsForUserAndGroupSortedByNameDescending()
-        throws SQLException, NotAuthorizedException, InvalidArgumentException, SystemException,
+        throws SQLException, NotAuthorizedException, InvalidArgumentException, SystemException {
-        InvalidRequestException {
         WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
         List<WorkbasketSummary> results = workbasketService.createWorkbasketQuery()
             .accessIdsHavePermission(WorkbasketPermission.APPEND, "user_1_1", "group_1")
@@ -113,8 +110,7 @@ public class QueryWorkbasketByPermissionAccTest extends AbstractAccTest {
         groupNames = {"businessadmin"})
     @Test
     public void testQueryAllTransferSourcesForUserAndGroup()
-        throws SQLException, NotAuthorizedException, InvalidArgumentException, SystemException,
+        throws SQLException, NotAuthorizedException, InvalidArgumentException, SystemException {
-        InvalidRequestException {
         WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
         List<WorkbasketSummary> results = workbasketService.createWorkbasketQuery()
             .accessIdsHavePermission(WorkbasketPermission.DISTRIBUTE, "user_1_1", "group_1")

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

@@ -13,7 +13,6 @@ import acceptance.AbstractAccTest;
 import pro.taskana.BaseQuery.SortDirection;
 import pro.taskana.WorkbasketService;
 import pro.taskana.WorkbasketSummary;
-import pro.taskana.exceptions.InvalidRequestException;
 import pro.taskana.exceptions.NotAuthorizedException;
 import pro.taskana.security.JAASRunner;
 
@@ -33,7 +32,7 @@ public class WorkbasketQueryWithOrderedPaginationAccTest extends AbstractAccTest
     @Ignore
     @Test
     public void testGetFirstPageOfTaskQueryWithOffset()
-        throws NotAuthorizedException, InvalidRequestException {
+        throws NotAuthorizedException {
         WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
         List<WorkbasketSummary> results = workbasketService.createWorkbasketQuery()
             .domainIn("DOMAIN_A")
@@ -55,7 +54,7 @@ public class WorkbasketQueryWithOrderedPaginationAccTest extends AbstractAccTest
     @Ignore
     @Test
     public void testGetSecondPageOfTaskQueryWithOffset()
-        throws NotAuthorizedException, InvalidRequestException {
+        throws NotAuthorizedException {
         WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
         List<WorkbasketSummary> results = workbasketService.createWorkbasketQuery()
             .domainIn("DOMAIN_A")

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

@@ -56,27 +56,20 @@ public class ClassificationController {
 
     @GetMapping(path = "/{classificationId}")
     @Transactional(readOnly = true, rollbackFor = Exception.class)
-    public ResponseEntity<ClassificationResource> getClassification(@PathVariable String classificationId) {
+    public ResponseEntity<ClassificationResource> getClassification(@PathVariable String classificationId)
-        try {
+        throws ClassificationNotFoundException, NotAuthorizedException, ClassificationAlreadyExistException,
-            Classification classification = classificationService.getClassification(classificationId);
+        ConcurrencyException {
-            return ResponseEntity.status(HttpStatus.OK).body(classificationMapper.toResource(classification));
+        Classification classification = classificationService.getClassification(classificationId);
-        } catch (ClassificationNotFoundException e) {
+        return ResponseEntity.status(HttpStatus.OK).body(classificationMapper.toResource(classification));
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
-        }
     }
 
     @GetMapping(path = "/{classificationKey}/{domain}")
     @Transactional(readOnly = true, rollbackFor = Exception.class)
     public ResponseEntity<ClassificationResource> getClassification(@PathVariable String classificationKey,
-        @PathVariable String domain) {
+        @PathVariable String domain) throws ClassificationNotFoundException, NotAuthorizedException,
-        try {
+        ClassificationAlreadyExistException, ConcurrencyException {
-            Classification classification = classificationService.getClassification(classificationKey, domain);
+        Classification classification = classificationService.getClassification(classificationKey, domain);
-            return ResponseEntity.status(HttpStatus.OK).body(classificationMapper.toResource(classification));
+        return ResponseEntity.status(HttpStatus.OK).body(classificationMapper.toResource(classification));
-        } catch (ClassificationNotFoundException e) {
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
-        }
     }
 
     @GetMapping(path = "/domains")
@@ -91,39 +84,21 @@ public class ClassificationController {
     @PostMapping
     @Transactional(rollbackFor = Exception.class)
     public ResponseEntity<ClassificationResource> createClassification(
-        @RequestBody ClassificationResource resource) {
+        @RequestBody ClassificationResource resource)
-        try {
+        throws NotAuthorizedException, ClassificationNotFoundException, ClassificationAlreadyExistException,
-            Classification classification = classificationMapper.toModel(resource);
+        ConcurrencyException {
-            classification = classificationService.createClassification(classification);
+        Classification classification = classificationMapper.toModel(resource);
-            return ResponseEntity.status(HttpStatus.CREATED).body(classificationMapper.toResource(classification));
+        classification = classificationService.createClassification(classification);
-        } catch (ClassificationAlreadyExistException e) {
+        return ResponseEntity.status(HttpStatus.CREATED).body(classificationMapper.toResource(classification));
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return ResponseEntity.status(HttpStatus.CONFLICT).build();
-        } catch (NotAuthorizedException e) {
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
-        } catch (ClassificationNotFoundException e) {
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
-        }
     }
 
     @PutMapping
     @Transactional(rollbackFor = Exception.class)
-    public ResponseEntity<ClassificationResource> updateClassification(@RequestBody ClassificationResource resource) {
+    public ResponseEntity<ClassificationResource> updateClassification(@RequestBody ClassificationResource resource)
-        try {
+        throws NotAuthorizedException, ClassificationNotFoundException, ConcurrencyException,
-            Classification classification = classificationMapper.toModel(resource);
+        ClassificationAlreadyExistException {
-            classification = classificationService.updateClassification(classification);
+        Classification classification = classificationMapper.toModel(resource);
-            return ResponseEntity.status(HttpStatus.OK).body(classificationMapper.toResource(classification));
+        classification = classificationService.updateClassification(classification);
-        } catch (ClassificationNotFoundException e) {
+        return ResponseEntity.status(HttpStatus.OK).body(classificationMapper.toResource(classification));
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
-        } catch (NotAuthorizedException e) {
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
-        } catch (ConcurrencyException e) {
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return ResponseEntity.status(HttpStatus.LOCKED).build();
-        }
     }
 }

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

@@ -10,7 +10,6 @@ import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.transaction.annotation.Transactional;
-import org.springframework.transaction.interceptor.TransactionInterceptor;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
@@ -45,58 +44,41 @@ public class ClassificationDefinitionController {
     @GetMapping
     @Transactional(readOnly = true, rollbackFor = Exception.class)
     public ResponseEntity<List<ClassificationResource>> getClassifications(
-        @RequestParam(required = false) String domain) {
+        @RequestParam(required = false) String domain) throws ClassificationNotFoundException, NotAuthorizedException,
-        try {
+        ClassificationAlreadyExistException, ConcurrencyException {
-            ClassificationQuery query = classificationService.createClassificationQuery();
+        ClassificationQuery query = classificationService.createClassificationQuery();
-            List<ClassificationSummary> summaries = domain != null ? query.domainIn(domain).list() : query.list();
+        List<ClassificationSummary> summaries = domain != null ? query.domainIn(domain).list() : query.list();
-            List<ClassificationResource> export = new ArrayList<>();
+        List<ClassificationResource> export = new ArrayList<>();
 
-            for (ClassificationSummary summary : summaries) {
+        for (ClassificationSummary summary : summaries) {
-                Classification classification = classificationService.getClassification(summary.getKey(),
+            Classification classification = classificationService.getClassification(summary.getKey(),
-                    summary.getDomain());
+                summary.getDomain());
-                export.add(classificationMapper.toResource(classification));
+            export.add(classificationMapper.toResource(classification));
-            }
-            return new ResponseEntity<>(export, HttpStatus.OK);
-        } catch (ClassificationNotFoundException e) {
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
         }
+        return new ResponseEntity<>(export, HttpStatus.OK);
     }
 
     @PostMapping(path = "/import")
     @Transactional(rollbackFor = Exception.class)
     public ResponseEntity<String> importClassifications(
-        @RequestBody List<ClassificationResource> classificationResources) {
+        @RequestBody List<ClassificationResource> classificationResources) throws NotAuthorizedException,
-        try {
+        ClassificationNotFoundException, ConcurrencyException, ClassificationAlreadyExistException {
-            Map<String, String> systemIds = classificationService.createClassificationQuery()
+        Map<String, String> systemIds = classificationService.createClassificationQuery()
-                .list()
+            .list()
-                .stream()
+            .stream()
-                .collect(Collectors.toMap(i -> i.getKey() + "|||" + i.getDomain(), ClassificationSummary::getId));
+            .collect(Collectors.toMap(i -> i.getKey() + "|||" + i.getDomain(), ClassificationSummary::getId));
 
-            for (ClassificationResource classificationResource : classificationResources) {
+        for (ClassificationResource classificationResource : classificationResources) {
-                Classification classification = classificationMapper.toModel(classificationResource);
+            Classification classification = classificationMapper.toModel(classificationResource);
-                if (systemIds.containsKey(classificationResource.key + "|||" + classificationResource.domain)) {
+            if (systemIds.containsKey(classificationResource.key + "|||" + classificationResource.domain)) {
-                    classificationService.updateClassification(classification);
+                classificationService.updateClassification(classification);
 
-                } else {
+            } else {
-                    classificationService.createClassification(classification);
+                classificationService.createClassification(classification);
-                }
             }
-
-            return new ResponseEntity<>(HttpStatus.OK);
-
-        } catch (ClassificationNotFoundException e) {
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
-        } catch (NotAuthorizedException e) {
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return new ResponseEntity<>(HttpStatus.UNAUTHORIZED);
-        } catch (ClassificationAlreadyExistException e) {
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
-        } catch (ConcurrencyException e) {
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return new ResponseEntity<>(HttpStatus.LOCKED);
         }
+
+        return new ResponseEntity<>(HttpStatus.OK);
+
     }
 }

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

@@ -5,6 +5,7 @@ import java.util.List;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
+import org.springframework.transaction.annotation.Transactional;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestParam;
@@ -20,6 +21,7 @@ import pro.taskana.TaskState;
 public class MonitorController {
 
     @GetMapping(path = "/countByState")
+    @Transactional(readOnly = true, rollbackFor = Exception.class)
     public ResponseEntity<?> getTaskcountForState(
         @RequestParam(value = "states") List<TaskState> taskStates) {
         String taskCount = "[{\"state\": \"READY\", \"counter\": 7},{\"state\": \"CLAIMED\",\"counter\": 4},{\"state\": \"COMPLETED\",\"counter\": 4 }]";
@@ -27,6 +29,7 @@ public class MonitorController {
     }
 
     @GetMapping(path = "/taskcountByWorkbasketDaysAndState")
+    @Transactional(readOnly = true, rollbackFor = Exception.class)
     public ResponseEntity<?> getTaskCountByWorkbasketAndDaysInPastAndState(
         @RequestParam(value = "daysInPast") Long daysInPast,
         @RequestParam(value = "states") List<TaskState> states) {

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

@@ -1,6 +1,5 @@
 package pro.taskana.rest;
 
-import java.util.Collections;
 import java.util.List;
 
 import org.slf4j.Logger;
@@ -10,7 +9,6 @@ import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.transaction.annotation.Transactional;
-import org.springframework.transaction.interceptor.TransactionInterceptor;
 import org.springframework.util.MultiValueMap;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
@@ -25,12 +23,15 @@ import pro.taskana.Task;
 import pro.taskana.TaskService;
 import pro.taskana.TaskState;
 import pro.taskana.TaskSummary;
+import pro.taskana.exceptions.ClassificationNotFoundException;
 import pro.taskana.exceptions.InvalidArgumentException;
 import pro.taskana.exceptions.InvalidOwnerException;
 import pro.taskana.exceptions.InvalidStateException;
+import pro.taskana.exceptions.InvalidWorkbasketException;
 import pro.taskana.exceptions.NotAuthorizedException;
-import pro.taskana.exceptions.NotAuthorizedToQueryWorkbasketException;
+import pro.taskana.exceptions.TaskAlreadyExistException;
 import pro.taskana.exceptions.TaskNotFoundException;
+import pro.taskana.exceptions.WorkbasketNotFoundException;
 import pro.taskana.rest.query.TaskFilter;
 
 /**
@@ -50,144 +51,76 @@ public class TaskController {
 
     @GetMapping
     @Transactional(readOnly = true, rollbackFor = Exception.class)
-    public ResponseEntity<List<TaskSummary>> getTasks(@RequestParam MultiValueMap<String, String> params) {
+    public ResponseEntity<List<TaskSummary>> getTasks(@RequestParam MultiValueMap<String, String> params)
-        try {
+        throws NotAuthorizedException, InvalidArgumentException {
-            if (params.keySet().size() == 0) {
+        if (params.keySet().size() == 0) {
-                // get all
+            // get all
-                return ResponseEntity.status(HttpStatus.OK).body(taskLogic.getAll());
+            return ResponseEntity.status(HttpStatus.OK).body(taskLogic.getAll());
-            }
-            return ResponseEntity.status(HttpStatus.OK).body(taskLogic.inspectPrams(params));
-        } catch (NotAuthorizedException e) {
-            LOGGER.error("Something went wrong with the Authorisation, while getting all Tasks.", e);
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
-        } catch (InvalidArgumentException e) {
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return ResponseEntity.status(HttpStatus.PRECONDITION_FAILED).build();
         }
+        return ResponseEntity.status(HttpStatus.OK).body(taskLogic.inspectPrams(params));
     }
 
     @GetMapping(path = "/{taskId}")
     @Transactional(readOnly = true, rollbackFor = Exception.class)
-    public ResponseEntity<Task> getTask(@PathVariable String taskId) {
+    public ResponseEntity<Task> getTask(@PathVariable String taskId)
-        try {
+        throws TaskNotFoundException, NotAuthorizedException {
-            Task task = taskService.getTask(taskId);
+        Task task = taskService.getTask(taskId);
-            return ResponseEntity.status(HttpStatus.OK).body(task);
+        return ResponseEntity.status(HttpStatus.OK).body(task);
-        } catch (TaskNotFoundException e) {
-            LOGGER.error("The searched Task couldn´t be found or does not exist.", e);
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
-        } catch (NotAuthorizedException e) {
-            LOGGER.error("The current user is not authorized to retrieve the task.", e);
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
-        }
     }
 
     @GetMapping(path = "/workbasket/{workbasketId}/state/{taskState}")
     @Transactional(readOnly = true, rollbackFor = Exception.class)
     public ResponseEntity<List<TaskSummary>> getTasksByWorkbasketIdAndState(@PathVariable String workbasketId,
         @PathVariable TaskState taskState) {
-        try {
+        List<TaskSummary> taskList = taskService.createTaskQuery()
-            List<TaskSummary> taskList = taskService.createTaskQuery()
+            .workbasketIdIn(workbasketId)
-                .workbasketIdIn(workbasketId)
+            .stateIn(taskState)
-                .stateIn(taskState)
+            .list();
-                .list();
+        return ResponseEntity.status(HttpStatus.OK).body(taskList);
-            return ResponseEntity.status(HttpStatus.OK).body(taskList);
-        } catch (NotAuthorizedToQueryWorkbasketException e) {
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
-        } catch (Exception e) {
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
-        }
     }
 
     @PostMapping(path = "/{taskId}/claim")
     @Transactional(rollbackFor = Exception.class)
-    public ResponseEntity<Task> claimTask(@PathVariable String taskId, @RequestBody String userName) {
+    public ResponseEntity<Task> claimTask(@PathVariable String taskId, @RequestBody String userName)
+        throws TaskNotFoundException, InvalidStateException, InvalidOwnerException, NotAuthorizedException {
         // TODO verify user
-        try {
+        taskService.claim(taskId);
-            taskService.claim(taskId);
+        Task updatedTask = taskService.getTask(taskId);
-            Task updatedTask = taskService.getTask(taskId);
+        return ResponseEntity.status(HttpStatus.OK).body(updatedTask);
-            return ResponseEntity.status(HttpStatus.OK).body(updatedTask);
-        } catch (TaskNotFoundException e) {
-            LOGGER.error("The given Task coundn´t be found/claimd or does not Exist.", e);
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
-        } catch (InvalidStateException | InvalidOwnerException e) {
-            LOGGER.error("The given Task could not be claimed. Reason: {}", e);
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return ResponseEntity.status(HttpStatus.CONFLICT).build();
-        } catch (NotAuthorizedException e) {
-            LOGGER.error("The current user is not authorized to claim the task.", e);
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
-        }
     }
 
     @RequestMapping(method = RequestMethod.POST, value = "/{taskId}/complete")
     @Transactional(rollbackFor = Exception.class)
-    public ResponseEntity<Task> completeTask(@PathVariable String taskId) {
+    public ResponseEntity<Task> completeTask(@PathVariable String taskId)
-        try {
+        throws TaskNotFoundException, InvalidOwnerException, InvalidStateException, NotAuthorizedException {
-            taskService.completeTask(taskId, true);
+        taskService.completeTask(taskId, true);
-            Task updatedTask = taskService.getTask(taskId);
+        Task updatedTask = taskService.getTask(taskId);
-            return ResponseEntity.status(HttpStatus.OK).body(updatedTask);
+        return ResponseEntity.status(HttpStatus.OK).body(updatedTask);
-        } catch (TaskNotFoundException e) {
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
-        } catch (InvalidStateException | InvalidOwnerException e) {
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return ResponseEntity.status(HttpStatus.PRECONDITION_FAILED).build();
-        } catch (NotAuthorizedException e) {
-            LOGGER.error("The current user is not authorized to complete the task.", e);
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
-        }
     }
 
     @RequestMapping(method = RequestMethod.POST)
     @Transactional(rollbackFor = Exception.class)
-    public ResponseEntity<Task> createTask(@RequestBody Task task) {
+    public ResponseEntity<Task> createTask(@RequestBody Task task)
-        try {
+        throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
-            Task createdTask = taskService.createTask(task);
+        TaskAlreadyExistException, InvalidWorkbasketException, InvalidArgumentException {
-            return ResponseEntity.status(HttpStatus.CREATED).body(createdTask);
+        Task createdTask = taskService.createTask(task);
-        } catch (Exception e) {
+        return ResponseEntity.status(HttpStatus.CREATED).body(createdTask);
-            LOGGER.error("Something went wrong: ", e);
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
-        }
     }
 
     @RequestMapping(path = "/{taskId}/transfer/{workbasketKey}")
     @Transactional(rollbackFor = Exception.class)
-    public ResponseEntity<Task> transferTask(@PathVariable String taskId, @PathVariable String workbasketKey) {
+    public ResponseEntity<Task> transferTask(@PathVariable String taskId, @PathVariable String workbasketKey)
-        try {
+        throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException, InvalidWorkbasketException {
-            Task updatedTask = taskService.transfer(taskId, workbasketKey);
+        Task updatedTask = taskService.transfer(taskId, workbasketKey);
-            return ResponseEntity.status(HttpStatus.CREATED).body(updatedTask);
+        return ResponseEntity.status(HttpStatus.CREATED).body(updatedTask);
-        } catch (Exception e) {
-            LOGGER.error("Something went wrong: ", e);
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
-        }
     }
 
     @GetMapping(path = "/workbasket/{workbasketId}")
     @Transactional(readOnly = true, rollbackFor = Exception.class)
     public ResponseEntity<List<TaskSummary>> getTasksummariesByWorkbasketId(@PathVariable String workbasketId) {
         List<TaskSummary> taskSummaries = null;
-        try {
+        taskSummaries = taskService.createTaskQuery().workbasketIdIn(workbasketId).list();
-            taskSummaries = taskService.createTaskQuery().workbasketIdIn(workbasketId).list();
+        return ResponseEntity.status(HttpStatus.OK).body(taskSummaries);
-            return ResponseEntity.status(HttpStatus.OK).body(taskSummaries);
+
-        } catch (NotAuthorizedToQueryWorkbasketException e) {
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
-        } catch (Exception ex) {
-            if (taskSummaries == null) {
-                taskSummaries = Collections.emptyList();
-            }
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
-        }
     }
 }

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

@@ -0,0 +1,77 @@
+package pro.taskana.rest;
+
+import java.util.Date;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.web.context.request.WebRequest;
+
+/**
+ * This class holds error data.
+ *
+ * @author bbr
+ */
+public class TaskanaErrorData {
+
+    private Date timestamp;
+    private int status;
+    private String error;
+    private String exception;
+    private String message;
+    private String path;
+
+    TaskanaErrorData(HttpStatus stat, Exception ex, WebRequest req) {
+        this.timestamp = new Date();
+        this.status = stat.value();
+        this.error = stat.name();
+        this.exception = ex.getClass().getName();
+        this.message = ex.getMessage();
+        this.path = req.getDescription(false);
+        if (this.path != null && this.path.startsWith("uri=")) {
+            this.path = this.path.substring(4);
+        }
+    }
+
+    public Date getTimestamp() {
+        return timestamp;
+    }
+
+    public int getStatus() {
+        return status;
+    }
+
+    public String getError() {
+        return error;
+    }
+
+    public String getException() {
+        return exception;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+    public String getPath() {
+        return path;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder builder = new StringBuilder();
+        builder.append("TaskanaErrorData [timestamp=");
+        builder.append(timestamp);
+        builder.append(", status=");
+        builder.append(status);
+        builder.append(", error=");
+        builder.append(error);
+        builder.append(", exception=");
+        builder.append(exception);
+        builder.append(", message=");
+        builder.append(message);
+        builder.append(", path=");
+        builder.append(path);
+        builder.append("]");
+        return builder.toString();
+    }
+
+}

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

@@ -0,0 +1,114 @@
+package pro.taskana.rest;
+
+import org.springframework.core.Ordered;
+import org.springframework.core.annotation.Order;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.ControllerAdvice;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.context.request.WebRequest;
+import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;
+
+import pro.taskana.exceptions.ClassificationAlreadyExistException;
+import pro.taskana.exceptions.ClassificationNotFoundException;
+import pro.taskana.exceptions.ConcurrencyException;
+import pro.taskana.exceptions.InvalidArgumentException;
+import pro.taskana.exceptions.InvalidOwnerException;
+import pro.taskana.exceptions.InvalidStateException;
+import pro.taskana.exceptions.InvalidWorkbasketException;
+import pro.taskana.exceptions.NotAuthorizedException;
+import pro.taskana.exceptions.NotAuthorizedToQueryWorkbasketException;
+import pro.taskana.exceptions.TaskAlreadyExistException;
+import pro.taskana.exceptions.TaskNotFoundException;
+import pro.taskana.exceptions.WorkbasketAlreadyExistException;
+import pro.taskana.exceptions.WorkbasketInUseException;
+import pro.taskana.exceptions.WorkbasketNotFoundException;
+
+/**
+ * This class handles taskana exceptions.
+ *
+ * @author bbr
+ */
+@Order(Ordered.HIGHEST_PRECEDENCE)
+@ControllerAdvice
+public class TaskanaRestExceptionHandler extends ResponseEntityExceptionHandler {
+
+    @ExceptionHandler(InvalidArgumentException.class)
+    protected ResponseEntity<Object> handleInvalidArgument(InvalidArgumentException ex, WebRequest req) {
+        return buildResponse(ex, req, HttpStatus.BAD_REQUEST);
+    }
+
+    @ExceptionHandler(NotAuthorizedException.class)
+    protected ResponseEntity<Object> handleNotAuthorized(NotAuthorizedException ex, WebRequest req) {
+        return buildResponse(ex, req, HttpStatus.UNAUTHORIZED);
+    }
+
+    @ExceptionHandler(TaskNotFoundException.class)
+    protected ResponseEntity<Object> handleTaskNotFound(TaskNotFoundException ex, WebRequest req) {
+        return buildResponse(ex, req, HttpStatus.NOT_FOUND);
+    }
+
+    @ExceptionHandler(TaskAlreadyExistException.class)
+    protected ResponseEntity<Object> handleTaskAlreadyExist(TaskAlreadyExistException ex,
+        WebRequest req) {
+        return buildResponse(ex, req, HttpStatus.CONFLICT);
+    }
+
+    @ExceptionHandler(NotAuthorizedToQueryWorkbasketException.class)
+    protected ResponseEntity<Object> handleNotAuthorizedToQueryWorkbasket(NotAuthorizedToQueryWorkbasketException ex,
+        WebRequest req) {
+        return buildResponse(ex, req, HttpStatus.FORBIDDEN);
+    }
+
+    @ExceptionHandler(InvalidStateException.class)
+    protected ResponseEntity<Object> handleInvalidState(InvalidStateException ex, WebRequest req) {
+        return buildResponse(ex, req, HttpStatus.CONFLICT);
+    }
+
+    @ExceptionHandler(InvalidOwnerException.class)
+    protected ResponseEntity<Object> handleInvalidOwner(InvalidOwnerException ex, WebRequest req) {
+        return buildResponse(ex, req, HttpStatus.CONFLICT);
+    }
+
+    @ExceptionHandler(ClassificationNotFoundException.class)
+    protected ResponseEntity<Object> handleClassificationNotFound(ClassificationNotFoundException ex, WebRequest req) {
+        return buildResponse(ex, req, HttpStatus.NOT_FOUND);
+    }
+
+    @ExceptionHandler(ClassificationAlreadyExistException.class)
+    protected ResponseEntity<Object> handleClassificationAlreadyExist(ClassificationAlreadyExistException ex,
+        WebRequest req) {
+        return buildResponse(ex, req, HttpStatus.CONFLICT);
+    }
+
+    @ExceptionHandler(ConcurrencyException.class)
+    protected ResponseEntity<Object> handleConcurrencyException(ConcurrencyException ex, WebRequest req) {
+        return buildResponse(ex, req, HttpStatus.LOCKED);
+    }
+
+    @ExceptionHandler(WorkbasketInUseException.class)
+    protected ResponseEntity<Object> handleWorkbasketInUse(WorkbasketInUseException ex, WebRequest req) {
+        return buildResponse(ex, req, HttpStatus.LOCKED);
+    }
+
+    @ExceptionHandler(WorkbasketAlreadyExistException.class)
+    protected ResponseEntity<Object> handleWorkbasketAlreadyExist(WorkbasketAlreadyExistException ex, WebRequest req) {
+        return buildResponse(ex, req, HttpStatus.CONFLICT);
+    }
+
+    @ExceptionHandler(WorkbasketNotFoundException.class)
+    protected ResponseEntity<Object> handleWorkbasketNotFound(WorkbasketNotFoundException ex, WebRequest req) {
+        return buildResponse(ex, req, HttpStatus.NOT_FOUND);
+    }
+
+    @ExceptionHandler(InvalidWorkbasketException.class)
+    protected ResponseEntity<Object> handleInvalidWorkbasket(InvalidWorkbasketException ex, WebRequest req) {
+        return buildResponse(ex, req, HttpStatus.BAD_REQUEST);
+    }
+
+    private ResponseEntity<Object> buildResponse(Exception ex, WebRequest req, HttpStatus status) {
+        TaskanaErrorData errorData = new TaskanaErrorData(status, ex, req);
+        return new ResponseEntity<>(errorData, status);
+    }
+
+}

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

@@ -12,7 +12,6 @@ import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.transaction.annotation.Transactional;
-import org.springframework.transaction.interceptor.TransactionInterceptor;
 import org.springframework.web.bind.annotation.DeleteMapping;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
@@ -94,106 +93,63 @@ public class WorkbasketController {
         @RequestParam(value = "owner", required = false) String owner,
         @RequestParam(value = "ownerLike", required = false) String ownerLike,
         @RequestParam(value = "type", required = false) String type,
-        @RequestParam(value = "requiredPermission", required = false) String requiredPermission) {
+        @RequestParam(value = "requiredPermission", required = false) String requiredPermission)
-        try {
+        throws WorkbasketNotFoundException, NotAuthorizedException, InvalidArgumentException {
-            WorkbasketQuery query = workbasketService.createWorkbasketQuery();
+        WorkbasketQuery query = workbasketService.createWorkbasketQuery();
-            addSortingToQuery(query, sortBy, order);
+        addSortingToQuery(query, sortBy, order);
-            addAttributeFilter(query, name, nameLike, key, keyLike, descLike, owner, ownerLike, type);
+        addAttributeFilter(query, name, nameLike, key, keyLike, descLike, owner, ownerLike, type);
-            addAuthorizationFilter(query, requiredPermission);
+        addAuthorizationFilter(query, requiredPermission);
-            List<WorkbasketSummary> workbasketSummaries = query.list();
+        List<WorkbasketSummary> workbasketSummaries = query.list();
-            Resources<WorkbasketSummaryResource> workbasketListResource = workbasketListMapper
+        Resources<WorkbasketSummaryResource> workbasketListResource = workbasketListMapper
-                .toResource(workbasketSummaries);
+            .toResource(workbasketSummaries);
-            return new ResponseEntity<>(workbasketListResource, HttpStatus.OK);
+        return new ResponseEntity<>(workbasketListResource, HttpStatus.OK);
-        } catch (InvalidArgumentException ex) {
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
-        }
     }
 
     @GetMapping(path = "/{workbasketId}")
     @Transactional(readOnly = true, rollbackFor = Exception.class)
-    public ResponseEntity<WorkbasketResource> getWorkbasket(@PathVariable(value = "workbasketId") String workbasketId) {
+    public ResponseEntity<WorkbasketResource> getWorkbasket(@PathVariable(value = "workbasketId") String workbasketId)
+        throws WorkbasketNotFoundException, NotAuthorizedException {
         ResponseEntity<WorkbasketResource> result;
-        try {
+        Workbasket workbasket = workbasketService.getWorkbasket(workbasketId);
-            Workbasket workbasket = workbasketService.getWorkbasket(workbasketId);
+        result = new ResponseEntity<>(workbasketMapper.toResource(workbasket), HttpStatus.OK);
-            result = new ResponseEntity<>(workbasketMapper.toResource(workbasket), HttpStatus.OK);
-        } catch (WorkbasketNotFoundException e) {
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            result = new ResponseEntity<>(HttpStatus.NOT_FOUND);
-        } catch (NotAuthorizedException e) {
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            result = new ResponseEntity<>(HttpStatus.UNAUTHORIZED);
-        }
         return result;
     }
 
     @DeleteMapping(path = "/{workbasketId}")
     @Transactional(rollbackFor = Exception.class)
-    public ResponseEntity<?> deleteWorkbasket(@PathVariable(value = "workbasketId") String workbasketId) {
+    public ResponseEntity<?> deleteWorkbasket(@PathVariable(value = "workbasketId") String workbasketId)
+        throws WorkbasketNotFoundException, NotAuthorizedException, WorkbasketInUseException, InvalidArgumentException {
         ResponseEntity<?> result = ResponseEntity.status(HttpStatus.NO_CONTENT).build();
-        try {
+        workbasketService.deleteWorkbasket(workbasketId);
-            workbasketService.deleteWorkbasket(workbasketId);
-        } catch (WorkbasketNotFoundException e) {
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            result = ResponseEntity.status(HttpStatus.NOT_FOUND).build();
-        } catch (NotAuthorizedException e) {
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            result = ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
-        } catch (WorkbasketInUseException e) {
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            result = ResponseEntity.status(HttpStatus.LOCKED).build();
-        } catch (InvalidArgumentException e) {
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            result = ResponseEntity.status(HttpStatus.BAD_REQUEST).build();
-        }
         return result;
     }
 
     @PostMapping
     @Transactional(rollbackFor = Exception.class)
-    public ResponseEntity<WorkbasketResource> createWorkbasket(@RequestBody WorkbasketResource workbasketResource) {
+    public ResponseEntity<WorkbasketResource> createWorkbasket(@RequestBody WorkbasketResource workbasketResource)
-        try {
+        throws InvalidWorkbasketException, NotAuthorizedException, WorkbasketAlreadyExistException,
-            Workbasket workbasket = workbasketMapper.toModel(workbasketResource);
+        WorkbasketNotFoundException {
-            workbasket = workbasketService.createWorkbasket(workbasket);
+        Workbasket workbasket = workbasketMapper.toModel(workbasketResource);
-            return new ResponseEntity<>(workbasketMapper.toResource(workbasket), HttpStatus.CREATED);
+        workbasket = workbasketService.createWorkbasket(workbasket);
-        } catch (InvalidWorkbasketException e) {
+        return new ResponseEntity<>(workbasketMapper.toResource(workbasket), HttpStatus.CREATED);
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
-        } catch (WorkbasketAlreadyExistException e) {
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return new ResponseEntity<>(HttpStatus.CONFLICT);
-        } catch (NotAuthorizedException e) {
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return new ResponseEntity<>(HttpStatus.UNAUTHORIZED);
-        }
     }
 
     @PutMapping(path = "/{workbasketId}")
     @Transactional(rollbackFor = Exception.class)
     public ResponseEntity<WorkbasketResource> updateWorkbasket(
         @PathVariable(value = "workbasketId") String workbasketId,
-        @RequestBody WorkbasketResource workbasketResource) {
+        @RequestBody WorkbasketResource workbasketResource)
+        throws InvalidWorkbasketException, WorkbasketNotFoundException, NotAuthorizedException {
         ResponseEntity<WorkbasketResource> result;
-        try {
+        if (workbasketId.equals(workbasketResource.workbasketId)) {
-            if (workbasketId.equals(workbasketResource.workbasketId)) {
+            Workbasket workbasket = workbasketMapper.toModel(workbasketResource);
-                Workbasket workbasket = workbasketMapper.toModel(workbasketResource);
+            workbasket = workbasketService.updateWorkbasket(workbasket);
-                workbasket = workbasketService.updateWorkbasket(workbasket);
+            result = ResponseEntity.ok(workbasketMapper.toResource(workbasket));
-                result = ResponseEntity.ok(workbasketMapper.toResource(workbasket));
+        } else {
-            } else {
+            throw new InvalidWorkbasketException(
-                throw new InvalidWorkbasketException(
+                "Target-WB-ID('" + workbasketId
-                    "Target-WB-ID('" + workbasketId
+                    + "') is not identical with the WB-ID of to object which should be updated. ID=('"
-                        + "') is not identical with the WB-ID of to object which should be updated. ID=('"
+                    + workbasketResource.getId() + "')");
-                        + workbasketResource.getId() + "')");
-            }
-        } catch (InvalidWorkbasketException e) {
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            result = new ResponseEntity<>(HttpStatus.BAD_REQUEST);
-        } catch (WorkbasketNotFoundException e) {
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            result = new ResponseEntity<>(HttpStatus.NOT_FOUND);
-        } catch (NotAuthorizedException e) {
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            result = new ResponseEntity<>(HttpStatus.UNAUTHORIZED);
         }
 
         return result;
@@ -202,17 +158,15 @@ public class WorkbasketController {
     @GetMapping(path = "/{workbasketId}/workbasketAccessItems")
     @Transactional(readOnly = true, rollbackFor = Exception.class)
     public ResponseEntity<Resources<WorkbasketAccessItemResource>> getWorkbasketAccessItems(
-        @PathVariable(value = "workbasketId") String workbasketId) {
+        @PathVariable(value = "workbasketId") String workbasketId)
+        throws NotAuthorizedException, WorkbasketNotFoundException {
 
         ResponseEntity<Resources<WorkbasketAccessItemResource>> result;
-        try {
+
-            List<WorkbasketAccessItem> accessItems = workbasketService.getWorkbasketAccessItems(workbasketId);
+        List<WorkbasketAccessItem> accessItems = workbasketService.getWorkbasketAccessItems(workbasketId);
-            Resources<WorkbasketAccessItemResource> accessItemListResource = accessItemListMapper
+        Resources<WorkbasketAccessItemResource> accessItemListResource = accessItemListMapper
-                .toResource(workbasketId, accessItems);
+            .toResource(workbasketId, accessItems);
-            result = new ResponseEntity<>(accessItemListResource, HttpStatus.OK);
+        result = new ResponseEntity<>(accessItemListResource, HttpStatus.OK);
-        } catch (NotAuthorizedException e) {
-            result = new ResponseEntity<>(HttpStatus.UNAUTHORIZED);
-        }
         return result;
     }
 
@@ -229,48 +183,34 @@ public class WorkbasketController {
     @Transactional(rollbackFor = Exception.class)
     public ResponseEntity<Resources<WorkbasketAccessItemResource>> setWorkbasketAccessItems(
         @PathVariable(value = "workbasketId") String workbasketId,
-        @RequestBody List<WorkbasketAccessItemResource> workbasketAccessResourceItems) {
+        @RequestBody List<WorkbasketAccessItemResource> workbasketAccessResourceItems)
-        try {
+        throws NotAuthorizedException, InvalidArgumentException, WorkbasketNotFoundException {
-            if (workbasketAccessResourceItems == null) {
+        if (workbasketAccessResourceItems == null) {
-                throw new InvalidArgumentException("Can´t create something with NULL body-value.");
+            throw new InvalidArgumentException("Can´t create something with NULL body-value.");
-            }
-
-            List<WorkbasketAccessItem> wbAccessItems = new ArrayList<>();
-            workbasketAccessResourceItems.forEach(item -> wbAccessItems.add(workbasketAccessItemMapper.toModel(item)));
-            workbasketService.setWorkbasketAccessItems(workbasketId, wbAccessItems);
-
-            List<WorkbasketAccessItem> updatedWbAccessItems = workbasketService.getWorkbasketAccessItems(workbasketId);
-            Resources<WorkbasketAccessItemResource> accessItemListResource = accessItemListMapper
-                .toResource(workbasketId, updatedWbAccessItems);
-
-            return new ResponseEntity<>(accessItemListResource, HttpStatus.OK);
-        } catch (NotAuthorizedException e) {
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return new ResponseEntity<>(HttpStatus.UNAUTHORIZED);
-        } catch (InvalidArgumentException | NullPointerException e) {
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
         }
+
+        List<WorkbasketAccessItem> wbAccessItems = new ArrayList<>();
+        workbasketAccessResourceItems.forEach(item -> wbAccessItems.add(workbasketAccessItemMapper.toModel(item)));
+        workbasketService.setWorkbasketAccessItems(workbasketId, wbAccessItems);
+
+        List<WorkbasketAccessItem> updatedWbAccessItems = workbasketService.getWorkbasketAccessItems(workbasketId);
+        Resources<WorkbasketAccessItemResource> accessItemListResource = accessItemListMapper
+            .toResource(workbasketId, updatedWbAccessItems);
+
+        return new ResponseEntity<>(accessItemListResource, HttpStatus.OK);
     }
 
     @GetMapping(path = "/{workbasketId}/distributiontargets")
     @Transactional(readOnly = true, rollbackFor = Exception.class)
     public ResponseEntity<Resources<DistributionTargetResource>> getDistributionTargets(
-        @PathVariable(value = "workbasketId") String workbasketId) {
+        @PathVariable(value = "workbasketId") String workbasketId)
+        throws WorkbasketNotFoundException, NotAuthorizedException {
 
         ResponseEntity<Resources<DistributionTargetResource>> result;
-        try {
+        List<WorkbasketSummary> distributionTargets = workbasketService.getDistributionTargets(workbasketId);
-            List<WorkbasketSummary> distributionTargets = workbasketService.getDistributionTargets(workbasketId);
+        Resources<DistributionTargetResource> distributionTargetListResource = distributionTargetListMapper
-            Resources<DistributionTargetResource> distributionTargetListResource = distributionTargetListMapper
+            .toResource(workbasketId, distributionTargets);
-                .toResource(workbasketId, distributionTargets);
+        result = new ResponseEntity<>(distributionTargetListResource, HttpStatus.OK);
-            result = new ResponseEntity<>(distributionTargetListResource, HttpStatus.OK);
-        } catch (WorkbasketNotFoundException e) {
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            result = new ResponseEntity<>(HttpStatus.NOT_FOUND);
-        } catch (NotAuthorizedException e) {
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            result = new ResponseEntity<>(HttpStatus.UNAUTHORIZED);
-        }
         return result;
     }
 
@@ -278,22 +218,14 @@ public class WorkbasketController {
     @Transactional(rollbackFor = Exception.class)
     public ResponseEntity<Resources<DistributionTargetResource>> setDistributionTargetsForWorkbasketId(
         @PathVariable(value = "workbasketId") String sourceWorkbasketId,
-        @RequestBody List<String> targetWorkbasketIds) {
+        @RequestBody List<String> targetWorkbasketIds) throws WorkbasketNotFoundException, NotAuthorizedException {
-        try {
+        workbasketService.setDistributionTargets(sourceWorkbasketId, targetWorkbasketIds);
-            workbasketService.setDistributionTargets(sourceWorkbasketId, targetWorkbasketIds);
 
-            List<WorkbasketSummary> distributionTargets = workbasketService.getDistributionTargets(sourceWorkbasketId);
+        List<WorkbasketSummary> distributionTargets = workbasketService.getDistributionTargets(sourceWorkbasketId);
-            Resources<DistributionTargetResource> distributionTargetListResource = distributionTargetListMapper
+        Resources<DistributionTargetResource> distributionTargetListResource = distributionTargetListMapper
-                .toResource(sourceWorkbasketId, distributionTargets);
+            .toResource(sourceWorkbasketId, distributionTargets);
 
-            return new ResponseEntity<>(distributionTargetListResource, HttpStatus.OK);
+        return new ResponseEntity<>(distributionTargetListResource, HttpStatus.OK);
-        } catch (WorkbasketNotFoundException e) {
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
-        } catch (NotAuthorizedException e) {
-            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-            return new ResponseEntity<>(HttpStatus.UNAUTHORIZED);
-        }
     }
 
     private void addAuthorizationFilter(WorkbasketQuery query, String requiredPermission)

rest/taskana-rest-spring/src/main/java/pro/taskana/rest/resource/mapper/ClassificationMapper.java

@@ -11,6 +11,9 @@ import org.springframework.stereotype.Component;
 
 import pro.taskana.Classification;
 import pro.taskana.ClassificationService;
+import pro.taskana.exceptions.ClassificationAlreadyExistException;
+import pro.taskana.exceptions.ClassificationNotFoundException;
+import pro.taskana.exceptions.ConcurrencyException;
 import pro.taskana.exceptions.NotAuthorizedException;
 import pro.taskana.impl.ClassificationImpl;
 import pro.taskana.rest.ClassificationController;
@@ -25,7 +28,8 @@ public class ClassificationMapper {
     @Autowired
     ClassificationService classificationService;
 
-    public ClassificationResource toResource(Classification classification) {
+    public ClassificationResource toResource(Classification classification) throws ClassificationNotFoundException,
+        NotAuthorizedException, ClassificationAlreadyExistException, ConcurrencyException {
         ClassificationResource resource = new ClassificationResource();
         BeanUtils.copyProperties(classification, resource);
         // need to be set by hand, because they are named different, or have different types
@@ -46,7 +50,9 @@ public class ClassificationMapper {
         return classification;
     }
 
-    private ClassificationResource addLinks(ClassificationResource resource, Classification classification) {
+    private ClassificationResource addLinks(ClassificationResource resource, Classification classification)
+        throws ClassificationNotFoundException, NotAuthorizedException, ClassificationAlreadyExistException,
+        ConcurrencyException {
         resource.add(
             linkTo(methodOn(ClassificationController.class).getClassification(classification.getId()))
                 .withSelfRel());

rest/taskana-rest-spring/src/main/java/pro/taskana/rest/resource/mapper/DistributionTargetListMapper.java

@@ -3,15 +3,17 @@ package pro.taskana.rest.resource.mapper;
 import static org.springframework.hateoas.mvc.ControllerLinkBuilder.linkTo;
 import static org.springframework.hateoas.mvc.ControllerLinkBuilder.methodOn;
 
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
-import java.util.stream.Collectors;
 
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.hateoas.Resources;
 import org.springframework.stereotype.Component;
 
 import pro.taskana.WorkbasketSummary;
+import pro.taskana.exceptions.NotAuthorizedException;
+import pro.taskana.exceptions.WorkbasketNotFoundException;
 import pro.taskana.rest.WorkbasketController;
 import pro.taskana.rest.resource.DistributionTargetResource;
 
@@ -25,10 +27,11 @@ public class DistributionTargetListMapper {
     private DistributionTargetMapper distributionTargetMapper;
 
     public Resources<DistributionTargetResource> toResource(String workbasketId,
-        Collection<WorkbasketSummary> distributionTargets) {
+        Collection<WorkbasketSummary> distributionTargets) throws WorkbasketNotFoundException, NotAuthorizedException {
-        List<DistributionTargetResource> resourceList = distributionTargets.stream()
+        List<DistributionTargetResource> resourceList = new ArrayList<>();
-            .map(workbasket -> distributionTargetMapper.toResource(workbasket))
+        for (WorkbasketSummary wb : distributionTargets) {
-            .collect(Collectors.toList());
+            resourceList.add(distributionTargetMapper.toResource(wb));
+        }
         Resources<DistributionTargetResource> distributionTargetListResource = new Resources<>(resourceList);
 
         distributionTargetListResource

rest/taskana-rest-spring/src/main/java/pro/taskana/rest/resource/mapper/DistributionTargetMapper.java

@@ -7,6 +7,8 @@ import org.springframework.beans.BeanUtils;
 import org.springframework.stereotype.Component;
 
 import pro.taskana.WorkbasketSummary;
+import pro.taskana.exceptions.NotAuthorizedException;
+import pro.taskana.exceptions.WorkbasketNotFoundException;
 import pro.taskana.rest.WorkbasketController;
 import pro.taskana.rest.resource.DistributionTargetResource;
 
@@ -16,7 +18,8 @@ import pro.taskana.rest.resource.DistributionTargetResource;
 @Component
 public class DistributionTargetMapper {
 
-    public DistributionTargetResource toResource(WorkbasketSummary summary) {
+    public DistributionTargetResource toResource(WorkbasketSummary summary)
+        throws WorkbasketNotFoundException, NotAuthorizedException {
         DistributionTargetResource resource = new DistributionTargetResource();
         BeanUtils.copyProperties(summary, resource);
         // named different so needs to be set by hand
@@ -25,7 +28,8 @@ public class DistributionTargetMapper {
         return addLinks(resource, summary);
     }
 
-    private DistributionTargetResource addLinks(DistributionTargetResource resource, WorkbasketSummary summary) {
+    private DistributionTargetResource addLinks(DistributionTargetResource resource, WorkbasketSummary summary)
+        throws WorkbasketNotFoundException, NotAuthorizedException {
         resource.add(linkTo(methodOn(WorkbasketController.class).getWorkbasket(summary.getId())).withSelfRel());
         return resource;
     }

rest/taskana-rest-spring/src/main/java/pro/taskana/rest/resource/mapper/WorkbasketAccessItemListMapper.java

@@ -3,9 +3,9 @@ package pro.taskana.rest.resource.mapper;
 import static org.springframework.hateoas.mvc.ControllerLinkBuilder.linkTo;
 import static org.springframework.hateoas.mvc.ControllerLinkBuilder.methodOn;
 
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
-import java.util.stream.Collectors;
 
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.hateoas.Resources;
@@ -13,6 +13,7 @@ import org.springframework.stereotype.Component;
 
 import pro.taskana.WorkbasketAccessItem;
 import pro.taskana.exceptions.NotAuthorizedException;
+import pro.taskana.exceptions.WorkbasketNotFoundException;
 import pro.taskana.rest.WorkbasketController;
 import pro.taskana.rest.resource.WorkbasketAccessItemResource;
 
@@ -26,16 +27,12 @@ public class WorkbasketAccessItemListMapper {
     private WorkbasketAccessItemMapper workbasketAccessItemMapper;
 
     public Resources<WorkbasketAccessItemResource> toResource(String workbasketId,
-        Collection<WorkbasketAccessItem> accessItems) {
+        Collection<WorkbasketAccessItem> accessItems) throws NotAuthorizedException, WorkbasketNotFoundException {
-        List<WorkbasketAccessItemResource> resourceList = accessItems.stream()
+        List<WorkbasketAccessItemResource> resourceList = new ArrayList<>();
-            .map(accessItem -> {
+        for (WorkbasketAccessItem accessItem : accessItems) {
-                try {
+            resourceList.add(workbasketAccessItemMapper.toResource(accessItem));
-                    return workbasketAccessItemMapper.toResource(accessItem);
+        }
-                } catch (NotAuthorizedException e) {
+
-                    return null;
-                }
-            })
-            .collect(Collectors.toList());
         Resources<WorkbasketAccessItemResource> accessItemListResource = new Resources<>(resourceList);
 
         accessItemListResource

rest/taskana-rest-spring/src/main/java/pro/taskana/rest/resource/mapper/WorkbasketAccessItemMapper.java

@@ -10,6 +10,7 @@ import org.springframework.stereotype.Component;
 import pro.taskana.WorkbasketAccessItem;
 import pro.taskana.WorkbasketService;
 import pro.taskana.exceptions.NotAuthorizedException;
+import pro.taskana.exceptions.WorkbasketNotFoundException;
 import pro.taskana.impl.WorkbasketAccessItemImpl;
 import pro.taskana.rest.WorkbasketController;
 import pro.taskana.rest.resource.WorkbasketAccessItemResource;
@@ -24,7 +25,8 @@ public class WorkbasketAccessItemMapper {
     @Autowired
     private WorkbasketService workbasketService;
 
-    public WorkbasketAccessItemResource toResource(WorkbasketAccessItem wbAccItem) throws NotAuthorizedException {
+    public WorkbasketAccessItemResource toResource(WorkbasketAccessItem wbAccItem)
+        throws NotAuthorizedException, WorkbasketNotFoundException {
         WorkbasketAccessItemResource resource = new WorkbasketAccessItemResource();
         BeanUtils.copyProperties(wbAccItem, resource);
         // property is named different, so it needs to be set by hand
@@ -43,7 +45,7 @@ public class WorkbasketAccessItemMapper {
     }
 
     private WorkbasketAccessItemResource addLinks(WorkbasketAccessItemResource resource, WorkbasketAccessItem wbAccItem)
-        throws NotAuthorizedException {
+        throws NotAuthorizedException, WorkbasketNotFoundException {
 
         resource.add(
             linkTo(methodOn(WorkbasketController.class).getWorkbasket(wbAccItem.getWorkbasketId()))

rest/taskana-rest-spring/src/main/java/pro/taskana/rest/resource/mapper/WorkbasketListMapper.java

@@ -2,15 +2,17 @@ package pro.taskana.rest.resource.mapper;
 
 import static org.springframework.hateoas.mvc.ControllerLinkBuilder.linkTo;
 
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
-import java.util.stream.Collectors;
 
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.hateoas.Resources;
 import org.springframework.stereotype.Component;
 
 import pro.taskana.WorkbasketSummary;
+import pro.taskana.exceptions.NotAuthorizedException;
+import pro.taskana.exceptions.WorkbasketNotFoundException;
 import pro.taskana.rest.WorkbasketController;
 import pro.taskana.rest.resource.WorkbasketSummaryResource;
 
@@ -23,10 +25,14 @@ public class WorkbasketListMapper {
     @Autowired
     private WorkbasketSummaryMapper workbasketSummaryMapper;
 
-    public Resources<WorkbasketSummaryResource> toResource(Collection<WorkbasketSummary> workbasketSummaries) {
+    public Resources<WorkbasketSummaryResource> toResource(Collection<WorkbasketSummary> workbasketSummaries)
-        List<WorkbasketSummaryResource> resourceList = workbasketSummaries.stream()
+        throws WorkbasketNotFoundException, NotAuthorizedException {
-            .map(workbasket -> workbasketSummaryMapper.toResource(workbasket))
+
-            .collect(Collectors.toList());
+        List<WorkbasketSummaryResource> resourceList = new ArrayList<>();
+        for (WorkbasketSummary workbasket : workbasketSummaries) {
+            resourceList.add(workbasketSummaryMapper.toResource(workbasket));
+        }
+
         Resources<WorkbasketSummaryResource> workbasketListResource = new Resources<>(resourceList);
 
         workbasketListResource.add(linkTo(WorkbasketController.class).withSelfRel());

rest/taskana-rest-spring/src/main/java/pro/taskana/rest/resource/mapper/WorkbasketMapper.java

@@ -12,6 +12,7 @@ import org.springframework.stereotype.Component;
 import pro.taskana.Workbasket;
 import pro.taskana.WorkbasketService;
 import pro.taskana.exceptions.NotAuthorizedException;
+import pro.taskana.exceptions.WorkbasketNotFoundException;
 import pro.taskana.impl.WorkbasketImpl;
 import pro.taskana.rest.WorkbasketController;
 import pro.taskana.rest.resource.WorkbasketResource;
@@ -25,7 +26,7 @@ public class WorkbasketMapper {
     @Autowired
     private WorkbasketService workbasketService;
 
-    public WorkbasketResource toResource(Workbasket wb) throws NotAuthorizedException {
+    public WorkbasketResource toResource(Workbasket wb) throws NotAuthorizedException, WorkbasketNotFoundException {
         WorkbasketResource resource = new WorkbasketResource();
         BeanUtils.copyProperties(wb, resource);
         // need to be set by hand, since name or type is different
@@ -46,7 +47,8 @@ public class WorkbasketMapper {
         return workbasket;
     }
 
-    private WorkbasketResource addLinks(WorkbasketResource resource, Workbasket wb) throws NotAuthorizedException {
+    private WorkbasketResource addLinks(WorkbasketResource resource, Workbasket wb)
+        throws NotAuthorizedException, WorkbasketNotFoundException {
         resource.add(linkTo(methodOn(WorkbasketController.class).getWorkbasket(wb.getId())).withSelfRel());
         resource.add(linkTo(methodOn(WorkbasketController.class).getDistributionTargets(wb.getId()))
             .withRel("distributionTargets"));

rest/taskana-rest-spring/src/main/java/pro/taskana/rest/resource/mapper/WorkbasketSummaryMapper.java

@@ -7,6 +7,8 @@ import org.springframework.beans.BeanUtils;
 import org.springframework.stereotype.Component;
 
 import pro.taskana.WorkbasketSummary;
+import pro.taskana.exceptions.NotAuthorizedException;
+import pro.taskana.exceptions.WorkbasketNotFoundException;
 import pro.taskana.rest.WorkbasketController;
 import pro.taskana.rest.resource.WorkbasketSummaryResource;
 
@@ -16,7 +18,8 @@ import pro.taskana.rest.resource.WorkbasketSummaryResource;
 @Component
 public class WorkbasketSummaryMapper {
 
-    public WorkbasketSummaryResource toResource(WorkbasketSummary summary) {
+    public WorkbasketSummaryResource toResource(WorkbasketSummary summary)
+        throws WorkbasketNotFoundException, NotAuthorizedException {
         WorkbasketSummaryResource resource = new WorkbasketSummaryResource();
         BeanUtils.copyProperties(summary, resource);
         // named different so needs to be set by hand
@@ -25,7 +28,8 @@ public class WorkbasketSummaryMapper {
         return addLinks(resource, summary);
     }
 
-    private WorkbasketSummaryResource addLinks(WorkbasketSummaryResource resource, WorkbasketSummary summary) {
+    private WorkbasketSummaryResource addLinks(WorkbasketSummaryResource resource, WorkbasketSummary summary)
+        throws WorkbasketNotFoundException, NotAuthorizedException {
         resource.add(linkTo(methodOn(WorkbasketController.class).getWorkbasket(summary.getId())).withSelfRel());
         return resource;
     }

rest/taskana-rest-spring/src/test/java/pro/taskana/rest/resource/mapper/ClassificationMapperTest.java

@@ -12,6 +12,9 @@ import org.springframework.test.context.web.WebAppConfiguration;
 
 import pro.taskana.Classification;
 import pro.taskana.ClassificationService;
+import pro.taskana.exceptions.ClassificationAlreadyExistException;
+import pro.taskana.exceptions.ClassificationNotFoundException;
+import pro.taskana.exceptions.ConcurrencyException;
 import pro.taskana.exceptions.NotAuthorizedException;
 import pro.taskana.impl.ClassificationImpl;
 import pro.taskana.rest.RestConfiguration;
@@ -32,7 +35,8 @@ public class ClassificationMapperTest {
     private ClassificationService classificationService;
 
     @Test
-    public void classificationToResource() {
+    public void classificationToResource() throws ClassificationNotFoundException, NotAuthorizedException,
+        ClassificationAlreadyExistException, ConcurrencyException {
         // given
         ClassificationImpl classification = (ClassificationImpl) classificationService.newClassification("DOMAIN_A",
             "1", "A");

rest/taskana-rest-spring/src/test/java/pro/taskana/rest/resource/mapper/WorkbasketAccessItemMapperTest.java

@@ -11,6 +11,7 @@ import org.springframework.test.context.web.WebAppConfiguration;
 import pro.taskana.WorkbasketAccessItem;
 import pro.taskana.WorkbasketService;
 import pro.taskana.exceptions.NotAuthorizedException;
+import pro.taskana.exceptions.WorkbasketNotFoundException;
 import pro.taskana.rest.RestConfiguration;
 import pro.taskana.rest.resource.WorkbasketAccessItemResource;
 
@@ -28,7 +29,8 @@ public class WorkbasketAccessItemMapperTest {
     WorkbasketService workbasketService;
 
     @Test
-    public void workBasketAccessItemToResourcePropertiesEqual() throws NotAuthorizedException {
+    public void workBasketAccessItemToResourcePropertiesEqual()
+        throws NotAuthorizedException, WorkbasketNotFoundException {
         // given
         WorkbasketAccessItem accessItem = workbasketService.newWorkbasketAccessItem("1", "2");
         accessItem.setPermDistribute(false);

rest/taskana-rest-spring/src/test/java/pro/taskana/rest/resource/mapper/WorkbasketMapperTest.java

@@ -14,6 +14,7 @@ import pro.taskana.Workbasket;
 import pro.taskana.WorkbasketService;
 import pro.taskana.WorkbasketType;
 import pro.taskana.exceptions.NotAuthorizedException;
+import pro.taskana.exceptions.WorkbasketNotFoundException;
 import pro.taskana.impl.WorkbasketImpl;
 import pro.taskana.rest.RestConfiguration;
 import pro.taskana.rest.resource.WorkbasketResource;
@@ -32,7 +33,7 @@ public class WorkbasketMapperTest {
     WorkbasketMapper workbasketMapper;
 
     @Test
-    public void workbasketToResource() throws NotAuthorizedException {
+    public void workbasketToResource() throws NotAuthorizedException, WorkbasketNotFoundException {
         // given
         Workbasket workbasket = workbasketService.newWorkbasket("1", "DOMAIN_A");
         ((WorkbasketImpl) workbasket).setId("ID");

rest/taskana-rest-spring/src/test/java/pro/taskana/rest/resource/mapper/WorkbasketSummaryMapperTest.java

@@ -10,6 +10,8 @@ import org.springframework.test.context.web.WebAppConfiguration;
 
 import pro.taskana.WorkbasketService;
 import pro.taskana.WorkbasketType;
+import pro.taskana.exceptions.NotAuthorizedException;
+import pro.taskana.exceptions.WorkbasketNotFoundException;
 import pro.taskana.impl.WorkbasketSummaryImpl;
 import pro.taskana.rest.RestConfiguration;
 import pro.taskana.rest.resource.WorkbasketSummaryResource;
@@ -28,7 +30,7 @@ public class WorkbasketSummaryMapperTest {
     WorkbasketService workbasketService;
 
     @Test
-    public void workbasketSummaryToResource() {
+    public void workbasketSummaryToResource() throws WorkbasketNotFoundException, NotAuthorizedException {
         // given
         WorkbasketSummaryImpl workbasketSummary = (WorkbasketSummaryImpl) workbasketService.newWorkbasket("1",
             "DOMAIN_A").asSummary();