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

TSK-347 enabled transaction management for all rest interfaces

This commit is contained in:
Mustapha Zorgati 2018-02-23 17:32:38 +01:00 committed by Holger Hagen
parent 26c13514eb
commit 7b605a712f
5 changed files with 137 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
rest/src/main/java/pro/taskana/rest/ClassificationController.java
View File

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

7
rest/src/main/java/pro/taskana/rest/MonitorController.java
View File

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

64
rest/src/main/java/pro/taskana/rest/TaskController.java
View File

@ -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}")
public ResponseEntity<Task> getTask(@PathVariable(value = "taskId") String taskId)
throws ClassificationNotFoundException {
@GetMapping(path = "/{taskId}")
@Transactional(readOnly = true, rollbackFor = Exception.class)
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}")
public ResponseEntity<List<TaskSummary>> 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<List<TaskSummary>> getTasksByWorkbasketIdAndState(@PathVariable String workbasketId,
@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")
public ResponseEntity<Task> claimTask(@PathVariable String taskId, @RequestBody String userName)
throws ClassificationNotFoundException {
@PostMapping(path = "/{taskId}/claim")
@Transactional(rollbackFor = Exception.class)
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) {
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<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)
public ResponseEntity<List<TaskSummary>> getTasksummariesByWorkbasketId(
@PathVariable(value = "workbasketId") String workbasketId) {
@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();
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();
}
}

115
rest/src/main/java/pro/taskana/rest/WorkbasketController.java
View File

@ -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,65 +81,70 @@ 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);
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<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);
List<WorkbasketSummary> distributionTargets = null;
ResponseEntity<List<WorkbasketSummaryResource>> result;
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)
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)

6
rest/src/main/java/pro/taskana/rest/WorkbasketDefinitionController.java
View File

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