diff --git a/rest/src/main/java/pro/taskana/rest/ClassificationController.java b/rest/src/main/java/pro/taskana/rest/ClassificationController.java index b8b00203d..01099ea00 100644 --- a/rest/src/main/java/pro/taskana/rest/ClassificationController.java +++ b/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; @@ -20,59 +24,69 @@ import pro.taskana.ClassificationService; import pro.taskana.ClassificationSummary; @RestController -@RequestMapping(path = "/v1/classifications", produces = { MediaType.APPLICATION_JSON_VALUE }) +@RequestMapping(path = "/v1/classifications", produces = {MediaType.APPLICATION_JSON_VALUE}) public class ClassificationController { @Autowired private ClassificationService classificationService; - @RequestMapping(method = RequestMethod.GET) + @GetMapping + @Transactional(readOnly = true, rollbackFor = Exception.class) public ResponseEntity> getClassifications() { try { List 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 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 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 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 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(); } } diff --git a/rest/src/main/java/pro/taskana/rest/MonitorController.java b/rest/src/main/java/pro/taskana/rest/MonitorController.java index 35b03ebd6..7653bfc3a 100644 --- a/rest/src/main/java/pro/taskana/rest/MonitorController.java +++ b/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; @@ -12,17 +13,17 @@ import org.springframework.web.bind.annotation.RestController; import pro.taskana.impl.TaskState; @RestController -@RequestMapping(path = "/v1/monitor", produces = { MediaType.APPLICATION_JSON_VALUE }) +@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 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 states) { diff --git a/rest/src/main/java/pro/taskana/rest/TaskController.java b/rest/src/main/java/pro/taskana/rest/TaskController.java index 0af8cdc20..d73b6b875 100644 --- a/rest/src/main/java/pro/taskana/rest/TaskController.java +++ b/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> getTasks(@RequestParam MultiValueMap 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}") - public ResponseEntity getTask(@PathVariable(value = "taskId") String taskId) - throws ClassificationNotFoundException { + @GetMapping(path = "/{taskId}") + @Transactional(readOnly = true, rollbackFor = Exception.class) + public ResponseEntity 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}") - public ResponseEntity> getTasksByWorkbasketIdAndState( - @PathVariable(value = "workbasketId") String workbasketId, - @PathVariable(value = "taskState") TaskState taskState) { + @GetMapping(path = "/workbasket/{workbasketId}/state/{taskState}") + @Transactional(readOnly = true, rollbackFor = Exception.class) + public ResponseEntity> getTasksByWorkbasketIdAndState(@PathVariable String workbasketId, + @PathVariable TaskState taskState) { try { List 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") - public ResponseEntity claimTask(@PathVariable String taskId, @RequestBody String userName) - throws ClassificationNotFoundException { + @PostMapping(path = "/{taskId}/claim") + @Transactional(rollbackFor = Exception.class) + public ResponseEntity 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) { - logger.error("The given Task could not be claimed. Reason: {}", e); - return ResponseEntity.status(HttpStatus.CONFLICT).build(); - } catch (InvalidOwnerException e) { + } catch (InvalidStateException | 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 completeTask(@PathVariable String taskId) throws ClassificationNotFoundException { + @Transactional(rollbackFor = Exception.class) + public ResponseEntity 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 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 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) - public ResponseEntity> getTasksummariesByWorkbasketId( - @PathVariable(value = "workbasketId") String workbasketId) { + @GetMapping(path = "/workbasket/{workbasketId}") + @Transactional(readOnly = true, rollbackFor = Exception.class) + public ResponseEntity> getTasksummariesByWorkbasketId(@PathVariable String workbasketId) { List 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(); } } diff --git a/rest/src/main/java/pro/taskana/rest/WorkbasketController.java b/rest/src/main/java/pro/taskana/rest/WorkbasketController.java index b7e805324..5ed7075f4 100644 --- a/rest/src/main/java/pro/taskana/rest/WorkbasketController.java +++ b/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> getWorkbaskets( @RequestParam(value = "sortBy", defaultValue = "name", required = false) String sortBy, @RequestParam(value = "order", defaultValue = "asc", required = false) String order, @@ -76,65 +81,70 @@ public class WorkbasketController { ResponseEntity> result; List workbasketsSummary; WorkbasketQuery query = workbasketService.createWorkbasketQuery(); - try { - addSortingToQuery(query, sortBy, order); - addAttributeFilter(query, name, nameLike, key, keyLike, descLike, owner, ownerLike, type); - addAuthorizationFilter(query, requiredPermission); - workbasketsSummary = query.list(); - 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); - } + addSortingToQuery(query, sortBy, order); + addAttributeFilter(query, name, nameLike, key, keyLike, descLike, owner, ownerLike, type); + addAuthorizationFilter(query, requiredPermission); + workbasketsSummary = query.list(); + result = new ResponseEntity<>(workbasketsSummary.stream() + .map(workbasket -> workbasketSummaryMapper.toResource(workbasket)) + .collect(Collectors.toList()), HttpStatus.OK); return result; } - @RequestMapping(value = "/{workbasketId}", method = RequestMethod.GET) + @GetMapping(path = "/{workbasketId}") + @Transactional(readOnly = true, rollbackFor = Exception.class) public ResponseEntity getWorkbasket(@PathVariable(value = "workbasketId") String workbasketId) { ResponseEntity 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 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 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> getWorkbasketAuthorizations( @PathVariable(value = "workbasketId") String workbasketId) { List 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 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 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> getDistributionTargetsForWorkbasketId( @PathVariable(value = "workbasketId") String workbasketId) { - ResponseEntity> result = new ResponseEntity<>(HttpStatus.NO_CONTENT); - List distributionTargets = null; + ResponseEntity> result; + List 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 targetWorkbasketIds) { @@ -228,8 +247,7 @@ public class WorkbasketController { return result; } - private void addAuthorizationFilter(WorkbasketQuery query, String requiredPermission) - throws InvalidArgumentException { + private void addAuthorizationFilter(WorkbasketQuery query, String requiredPermission) { if (requiredPermission == null) { return; } @@ -295,24 +313,29 @@ public class WorkbasketController { } } - private void addSortingToQuery(WorkbasketQuery query, String sortBy, String order) - throws InvalidRequestException, InvalidArgumentException { + private void addSortingToQuery(WorkbasketQuery query, String sortBy, String order) { BaseQuery.SortDirection sortDirection = getSortDirection(order); - if (sortBy.equals(NAME)) { - query.orderByName(sortDirection); - } else if (sortBy.equals(KEY)) { - query.orderByKey(sortDirection); - } else if (sortBy.equals(DESCRIPTION)) { - query.orderByDescription(sortDirection); - } else if (sortBy.equals(OWNER)) { - query.orderByOwner(sortDirection); - } else if (sortBy.equals(TYPE)) { - query.orderByType(sortDirection); + switch (sortBy) { + case NAME: + query.orderByName(sortDirection); + break; + case KEY: + query.orderByKey(sortDirection); + break; + case DESCRIPTION: + query.orderByDescription(sortDirection); + break; + case OWNER: + query.orderByOwner(sortDirection); + 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) diff --git a/rest/src/main/java/pro/taskana/rest/WorkbasketDefinitionController.java b/rest/src/main/java/pro/taskana/rest/WorkbasketDefinitionController.java index b1547e05f..5fca4bc72 100644 --- a/rest/src/main/java/pro/taskana/rest/WorkbasketDefinitionController.java +++ b/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) {