TSK-347 enabled transaction management for all rest interfaces

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

@@ -9,10 +9,14 @@ import org.springframework.beans.factory.annotation.Autowired;
 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.PathVariable;
+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.RestController;
 
 import pro.taskana.Classification;
@@ -26,53 +30,63 @@ public class ClassificationController {
     @Autowired
     private ClassificationService classificationService;
 
-    @RequestMapping(method = RequestMethod.GET)
+    @GetMapping
+    @Transactional(readOnly = true, rollbackFor = Exception.class)
     public ResponseEntity<List<ClassificationSummary>> getClassifications() {
         try {
             List<ClassificationSummary> classificationTree = classificationService.createClassificationQuery().list();
             return ResponseEntity.status(HttpStatus.OK).body(classificationTree);
         } catch (Exception e) {
+            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
             return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
         }
     }
 
-    @RequestMapping(value = "/{classificationKey}", method = RequestMethod.GET)
+    @GetMapping(path = "/{classificationKey}")
+    @Transactional(readOnly = true, rollbackFor = Exception.class)
     public ResponseEntity<Classification> getClassification(@PathVariable String classificationKey) {
         try {
             Classification classification = classificationService.getClassification(classificationKey, "");
             return ResponseEntity.status(HttpStatus.OK).body(classification);
         } catch (Exception e) {
+            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
             return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
         }
     }
 
-    @RequestMapping(value = "/{classificationKey}/{domain}", method = RequestMethod.GET)
+    @GetMapping(path = "/{classificationKey}/{domain}")
+    @Transactional(readOnly = true, rollbackFor = Exception.class)
     public ResponseEntity<Classification> getClassification(@PathVariable String classificationKey,
         @PathVariable String domain) {
         try {
             Classification classification = classificationService.getClassification(classificationKey, domain);
             return ResponseEntity.status(HttpStatus.OK).body(classification);
         } catch (Exception e) {
+            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
             return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
         }
     }
 
-    @RequestMapping(method = RequestMethod.POST)
+    @PostMapping
+    @Transactional(rollbackFor = Exception.class)
     public ResponseEntity<Classification> createClassification(@RequestBody Classification classification) {
         try {
             classificationService.createClassification(classification);
             return ResponseEntity.status(HttpStatus.CREATED).body(classification);
         } catch (Exception e) {
+            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
             return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
         }
     }
 
-    @RequestMapping(method = RequestMethod.PUT)
+    @PutMapping
+    @Transactional(rollbackFor = Exception.class)
     public ResponseEntity<Classification> updateClassification(@RequestBody Classification classification) {
         try {
             classificationService.updateClassification(classification);
             return ResponseEntity.status(HttpStatus.CREATED).body(classification);
         } catch (Exception e) {
+            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
             return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
         }
     }

rest/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.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
@@ -15,14 +16,14 @@ import pro.taskana.impl.TaskState;
 @RequestMapping(path = "/v1/monitor", produces = {MediaType.APPLICATION_JSON_VALUE})
 public class MonitorController {
 
-    @RequestMapping(value = "/countByState")
+    @GetMapping(path = "/countByState")
     public ResponseEntity<?> getTaskcountForState(
         @RequestParam(value = "states") List<TaskState> taskStates) {
         String taskCount = "[{\"state\": \"READY\", \"counter\": 7},{\"state\": \"CLAIMED\",\"counter\": 4},{\"state\": \"COMPLETED\",\"counter\": 4 }]";
         return ResponseEntity.status(HttpStatus.OK).body(taskCount);
     }
 
-    @RequestMapping(value = "/taskcountByWorkbasketDaysAndState")
+    @GetMapping(path = "/taskcountByWorkbasketDaysAndState")
     public ResponseEntity<?> getTaskCountByWorkbasketAndDaysInPastAndState(
         @RequestParam(value = "daysInPast") Long daysInPast,
         @RequestParam(value = "states") List<TaskState> states) {

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

@@ -3,16 +3,18 @@ package pro.taskana.rest;
 import java.util.Collections;
 import java.util.List;
 
-import javax.security.auth.login.LoginException;
-
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 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;
+import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
@@ -22,7 +24,6 @@ import org.springframework.web.bind.annotation.RestController;
 import pro.taskana.Task;
 import pro.taskana.TaskService;
 import pro.taskana.TaskSummary;
-import pro.taskana.exceptions.ClassificationNotFoundException;
 import pro.taskana.exceptions.InvalidArgumentException;
 import pro.taskana.exceptions.InvalidOwnerException;
 import pro.taskana.exceptions.InvalidStateException;
@@ -44,9 +45,10 @@ public class TaskController {
     @Autowired
     private TaskFilter taskLogic;
 
-    @RequestMapping
+    @GetMapping
+    @Transactional(readOnly = true, rollbackFor = Exception.class)
     public ResponseEntity<List<TaskSummary>> getTasks(@RequestParam MultiValueMap<String, String> params)
-        throws LoginException, InvalidArgumentException {
+        throws InvalidArgumentException {
         try {
             if (params.keySet().size() == 0) {
                 // get all
@@ -54,27 +56,29 @@ public class TaskController {
             }
             return ResponseEntity.status(HttpStatus.OK).body(taskLogic.inspectPrams(params));
         } catch (NotAuthorizedException e) {
-            logger.error("Somthing went wrong whith the Authorisation, while getting all Tasks.", e);
+            logger.error("Something went wrong with the Authorisation, while getting all Tasks.", e);
+            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
             return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
         }
     }
 
-    @RequestMapping(value = "/{taskId}")
+    @GetMapping(path = "/{taskId}")
-    public ResponseEntity<Task> getTask(@PathVariable(value = "taskId") String taskId)
+    @Transactional(readOnly = true, rollbackFor = Exception.class)
-        throws ClassificationNotFoundException {
+    public ResponseEntity<Task> getTask(@PathVariable String taskId) {
         try {
             Task task = taskService.getTask(taskId);
             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();
         }
     }
 
-    @RequestMapping(value = "/workbasket/{workbasketId}/state/{taskState}")
+    @GetMapping(path = "/workbasket/{workbasketId}/state/{taskState}")
-    public ResponseEntity<List<TaskSummary>> getTasksByWorkbasketIdAndState(
+    @Transactional(readOnly = true, rollbackFor = Exception.class)
-        @PathVariable(value = "workbasketId") String workbasketId,
+    public ResponseEntity<List<TaskSummary>> getTasksByWorkbasketIdAndState(@PathVariable String workbasketId,
-        @PathVariable(value = "taskState") TaskState taskState) {
+        @PathVariable TaskState taskState) {
         try {
             List<TaskSummary> taskList = taskService.createTaskQuery()
                 .workbasketIdIn(workbasketId)
@@ -82,15 +86,17 @@ public class TaskController {
                 .list();
             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();
         }
     }
 
-    @RequestMapping(method = RequestMethod.POST, value = "/{taskId}/claim")
+    @PostMapping(path = "/{taskId}/claim")
-    public ResponseEntity<Task> claimTask(@PathVariable String taskId, @RequestBody String userName)
+    @Transactional(rollbackFor = Exception.class)
-        throws ClassificationNotFoundException {
+    public ResponseEntity<Task> claimTask(@PathVariable String taskId, @RequestBody String userName) {
         // TODO verify user
         try {
             taskService.claim(taskId);
@@ -98,64 +104,72 @@ public class TaskController {
             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 e) {
+        } catch (InvalidStateException | InvalidOwnerException e) {
-            logger.error("The given Task could not be claimed. Reason: {}", e);
-            return ResponseEntity.status(HttpStatus.CONFLICT).build();
-        } catch (InvalidOwnerException e) {
             logger.error("The given Task could not be claimed. Reason: {}", e);
+            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
             return ResponseEntity.status(HttpStatus.CONFLICT).build();
         }
     }
 
     @RequestMapping(method = RequestMethod.POST, value = "/{taskId}/complete")
-    public ResponseEntity<Task> completeTask(@PathVariable String taskId) throws ClassificationNotFoundException {
+    @Transactional(rollbackFor = Exception.class)
+    public ResponseEntity<Task> completeTask(@PathVariable String taskId) {
         try {
             taskService.completeTask(taskId, true);
             Task updatedTask = taskService.getTask(taskId);
             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();
         }
     }
 
     @RequestMapping(method = RequestMethod.POST)
+    @Transactional(rollbackFor = Exception.class)
     public ResponseEntity<Task> createTask(@RequestBody Task task) {
         try {
             Task createdTask = taskService.createTask(task);
             return ResponseEntity.status(HttpStatus.CREATED).body(createdTask);
         } catch (Exception e) {
             logger.error("Something went wrong: ", e);
+            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
             return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
         }
     }
 
-    @RequestMapping(method = RequestMethod.POST, value = "/{taskId}/transfer/{workbasketKey}")
+    @RequestMapping(path = "/{taskId}/transfer/{workbasketKey}")
+    @Transactional(rollbackFor = Exception.class)
     public ResponseEntity<Task> transferTask(@PathVariable String taskId, @PathVariable String workbasketKey) {
         try {
             Task updatedTask = taskService.transfer(taskId, workbasketKey);
             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();
         }
     }
 
-    @RequestMapping(value = "/workbasket/{workbasketId}", method = RequestMethod.GET)
+    @GetMapping(path = "/workbasket/{workbasketId}")
-    public ResponseEntity<List<TaskSummary>> getTasksummariesByWorkbasketId(
+    @Transactional(readOnly = true, rollbackFor = Exception.class)
-        @PathVariable(value = "workbasketId") String workbasketId) {
+    public ResponseEntity<List<TaskSummary>> getTasksummariesByWorkbasketId(@PathVariable String workbasketId) {
         List<TaskSummary> taskSummaries = null;
         try {
             taskSummaries = taskService.createTaskQuery().workbasketIdIn(workbasketId).list();
             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/src/main/java/pro/taskana/rest/WorkbasketController.java

@@ -8,10 +8,15 @@ import org.springframework.beans.factory.annotation.Autowired;
 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;
+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;
 
@@ -22,7 +27,6 @@ import pro.taskana.WorkbasketQuery;
 import pro.taskana.WorkbasketService;
 import pro.taskana.WorkbasketSummary;
 import pro.taskana.exceptions.InvalidArgumentException;
-import pro.taskana.exceptions.InvalidRequestException;
 import pro.taskana.exceptions.InvalidWorkbasketException;
 import pro.taskana.exceptions.NotAuthorizedException;
 import pro.taskana.exceptions.WorkbasketInUseException;
@@ -60,7 +64,8 @@ public class WorkbasketController {
     @Autowired
     private WorkbasketAccessItemMapper workbasketAccessItemMapper;
 
-    @RequestMapping(method = RequestMethod.GET)
+    @GetMapping
+    @Transactional(readOnly = true, rollbackFor = Exception.class)
     public ResponseEntity<List<WorkbasketSummaryResource>> getWorkbaskets(
         @RequestParam(value = "sortBy", defaultValue = "name", required = false) String sortBy,
         @RequestParam(value = "order", defaultValue = "asc", required = false) String order,
@@ -76,7 +81,6 @@ public class WorkbasketController {
         ResponseEntity<List<WorkbasketSummaryResource>> result;
         List<WorkbasketSummary> workbasketsSummary;
         WorkbasketQuery query = workbasketService.createWorkbasketQuery();
-        try {
         addSortingToQuery(query, sortBy, order);
         addAttributeFilter(query, name, nameLike, key, keyLike, descLike, owner, ownerLike, type);
         addAuthorizationFilter(query, requiredPermission);
@@ -84,57 +88,63 @@ public class WorkbasketController {
         result = new ResponseEntity<>(workbasketsSummary.stream()
             .map(workbasket -> workbasketSummaryMapper.toResource(workbasket))
             .collect(Collectors.toList()), HttpStatus.OK);
-        } catch (InvalidArgumentException e) {
-            result = new ResponseEntity<>(HttpStatus.PRECONDITION_FAILED);
-        } catch (InvalidRequestException e) {
-            result = new ResponseEntity<>(HttpStatus.BAD_REQUEST);
-        }
         return result;
     }
 
-    @RequestMapping(value = "/{workbasketId}", method = RequestMethod.GET)
+    @GetMapping(path = "/{workbasketId}")
+    @Transactional(readOnly = true, rollbackFor = Exception.class)
     public ResponseEntity<WorkbasketResource> getWorkbasket(@PathVariable(value = "workbasketId") String workbasketId) {
         ResponseEntity<WorkbasketResource> result;
         try {
             Workbasket workbasket = workbasketService.getWorkbasket(workbasketId);
             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;
     }
 
-    @RequestMapping(value = "/{workbasketId}", method = RequestMethod.DELETE)
+    @DeleteMapping(path = "/{workbasketId}")
+    @Transactional(rollbackFor = Exception.class)
     public ResponseEntity<?> deleteWorkbasket(@PathVariable(value = "workbasketId") String workbasketId) {
         ResponseEntity<?> result = ResponseEntity.status(HttpStatus.NO_CONTENT).build();
         try {
             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.PRECONDITION_FAILED).build();
         }
         return result;
     }
 
-    @RequestMapping(method = RequestMethod.POST)
+    @PostMapping
+    @Transactional(rollbackFor = Exception.class)
     public ResponseEntity<WorkbasketResource> createWorkbasket(@RequestBody WorkbasketResource workbasketResource) {
         try {
             Workbasket workbasket = workbasketMapper.toModel(workbasketResource);
             workbasket = workbasketService.createWorkbasket(workbasket);
             return new ResponseEntity<>(workbasketMapper.toResource(workbasket), HttpStatus.CREATED);
         } catch (InvalidWorkbasketException e) {
-            return new ResponseEntity<>(HttpStatus.PRECONDITION_FAILED);
+            TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
+            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
         }
     }
 
-    @RequestMapping(value = "/{workbasketId}", method = RequestMethod.PUT)
+    @PutMapping(path = "/{workbasketId}")
+    @Transactional(rollbackFor = Exception.class)
     public ResponseEntity<WorkbasketResource> updateWorkbasket(
         @PathVariable(value = "workbasketId") String workbasketId,
         @RequestBody WorkbasketResource workbasketResource) {
@@ -151,17 +161,21 @@ public class WorkbasketController {
                         + workbasketResource.getId() + "')");
             }
         } catch (InvalidWorkbasketException e) {
-            result = new ResponseEntity<>(HttpStatus.PRECONDITION_FAILED);
+            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;
     }
 
-    @RequestMapping(value = "/{workbasketId}/authorizations", method = RequestMethod.GET)
+    @GetMapping(path = "/{workbasketId}/authorizations")
+    @Transactional(readOnly = true, rollbackFor = Exception.class)
     public ResponseEntity<List<WorkbasketAccessItemResource>> getWorkbasketAuthorizations(
         @PathVariable(value = "workbasketId") String workbasketId) {
         List<WorkbasketAccessItem> wbAuthorizations = workbasketService.getWorkbasketAuthorizations(workbasketId);
@@ -170,7 +184,8 @@ public class WorkbasketController {
             .collect(Collectors.toList()), HttpStatus.OK);
     }
 
-    @RequestMapping(value = "/authorizations", method = RequestMethod.POST)
+    @PostMapping(path = "/authorizations")
+    @Transactional(rollbackFor = Exception.class)
     public ResponseEntity<WorkbasketAccessItemResource> createWorkbasketAuthorization(
         @RequestBody WorkbasketAccessItemResource workbasketAccessItemResource) {
         WorkbasketAccessItem workbasketAccessItem = workbasketAccessItemMapper.toModel(workbasketAccessItemResource);
@@ -178,7 +193,8 @@ public class WorkbasketController {
         return new ResponseEntity<>(workbasketAccessItemMapper.toResource(workbasketAccessItem), HttpStatus.OK);
     }
 
-    @RequestMapping(value = "/authorizations/{authId}", method = RequestMethod.PUT)
+    @PutMapping(path = "/authorizations/{authId}")
+    @Transactional(rollbackFor = Exception.class)
     public ResponseEntity<WorkbasketAccessItemResource> updateWorkbasketAuthorization(
         @PathVariable(value = "authId") String authId,
         @RequestBody WorkbasketAccessItemResource workbasketAccessItemResource) throws InvalidArgumentException {
@@ -187,18 +203,20 @@ public class WorkbasketController {
         return new ResponseEntity<>(workbasketAccessItemMapper.toResource(workbasketAccessItem), HttpStatus.OK);
     }
 
-    @RequestMapping(value = "/authorizations/{authId}", method = RequestMethod.DELETE)
+    @DeleteMapping(path = "/authorizations/{authId}")
+    @Transactional(rollbackFor = Exception.class)
     public ResponseEntity<?> deleteWorkbasketAuthorization(@PathVariable(value = "authId") String authId) {
         workbasketService.deleteWorkbasketAuthorization(authId);
         return ResponseEntity.status(HttpStatus.NO_CONTENT).build();
     }
 
-    @RequestMapping(value = "/{workbasketId}/distributiontargets", method = RequestMethod.GET)
+    @GetMapping(path = "/{workbasketId}/distributiontargets")
+    @Transactional(readOnly = true, rollbackFor = Exception.class)
     public ResponseEntity<List<WorkbasketSummaryResource>> getDistributionTargetsForWorkbasketId(
         @PathVariable(value = "workbasketId") String workbasketId) {
 
-        ResponseEntity<List<WorkbasketSummaryResource>> result = new ResponseEntity<>(HttpStatus.NO_CONTENT);
+        ResponseEntity<List<WorkbasketSummaryResource>> result;
-        List<WorkbasketSummary> distributionTargets = null;
+        List<WorkbasketSummary> distributionTargets;
         try {
             distributionTargets = workbasketService.getDistributionTargets(workbasketId);
             result = new ResponseEntity<>(distributionTargets.stream()
@@ -212,7 +230,8 @@ public class WorkbasketController {
         return result;
     }
 
-    @RequestMapping(value = "/{workbasketId}/distributiontargets", method = RequestMethod.PUT)
+    @PutMapping(path = "/{workbasketId}/distributiontargets")
+    @Transactional(rollbackFor = Exception.class)
     public ResponseEntity<?> setDistributionTargets(
         @PathVariable(value = "workbasketId") String sourceWorkbasketId,
         @RequestBody List<String> targetWorkbasketIds) {
@@ -228,8 +247,7 @@ public class WorkbasketController {
         return result;
     }
 
-    private void addAuthorizationFilter(WorkbasketQuery query, String requiredPermission)
+    private void addAuthorizationFilter(WorkbasketQuery query, String requiredPermission) {
-        throws InvalidArgumentException {
         if (requiredPermission == null) {
             return;
         }
@@ -295,24 +313,29 @@ public class WorkbasketController {
         }
     }
 
-    private void addSortingToQuery(WorkbasketQuery query, String sortBy, String order)
+    private void addSortingToQuery(WorkbasketQuery query, String sortBy, String order) {
-        throws InvalidRequestException, InvalidArgumentException {
         BaseQuery.SortDirection sortDirection = getSortDirection(order);
 
-        if (sortBy.equals(NAME)) {
+        switch (sortBy) {
+            case NAME:
                 query.orderByName(sortDirection);
-        } else if (sortBy.equals(KEY)) {
+                break;
+            case KEY:
                 query.orderByKey(sortDirection);
-        } else if (sortBy.equals(DESCRIPTION)) {
+                break;
+            case DESCRIPTION:
                 query.orderByDescription(sortDirection);
-        } else if (sortBy.equals(OWNER)) {
+                break;
+            case OWNER:
                 query.orderByOwner(sortDirection);
-        } else if (sortBy.equals(TYPE)) {
+                break;
+            case TYPE:
                 query.orderByType(sortDirection);
+                break;
         }
     }
 
-    private BaseQuery.SortDirection getSortDirection(String order) throws InvalidRequestException {
+    private BaseQuery.SortDirection getSortDirection(String order) {
         if (order.equals(DESC)) {
             return BaseQuery.SortDirection.DESCENDING;
         }
@@ -323,7 +346,7 @@ public class WorkbasketController {
         String name, String nameLike,
         String key, String keyLike,
         String descLike, String owner,
-        String ownerLike, String type) throws InvalidArgumentException {
+        String ownerLike, String type) {
         if (name != null)
             query.nameIn(name);
         if (nameLike != null)

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

@@ -79,7 +79,10 @@ public class WorkbasketDefinitionController {
      * Otherwise a new workbasket will be created.
      *
      * @param definitions the list of workbasket definitions which will be imported to the current system.
-     * @return TODO: what should we return?
+     * @return Return answer is determined by the status code:
+     * 200 - all good
+     * 400 - list state error (referring to non existing id's)
+     * 401 - not authorized
      */
     @PostMapping(path = "/import")
     @Transactional(rollbackFor = Exception.class)
@@ -146,7 +149,6 @@ public class WorkbasketDefinitionController {
             TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
             return new ResponseEntity<>(HttpStatus.NOT_FOUND);
         } catch (InvalidWorkbasketException e) {
-            // TODO: which status code?
             TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
             return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
         } catch (NotAuthorizedException e) {