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

TSK-382 add errorhandling to controllers

This commit is contained in:
BerndBreier 2018-03-14 12:27:19 +01:00 committed by Holger Hagen
parent aef0e987e9
commit 5de0cd5e09
24 changed files with 430 additions and 403 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

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

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

@ -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("%")

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

@ -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("%")

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

@ -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,
InvalidRequestException {
throws SQLException, NotAuthorizedException, InvalidArgumentException, SystemException {
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,
InvalidRequestException {
throws SQLException, NotAuthorizedException, InvalidArgumentException, SystemException {
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,
InvalidRequestException {
throws SQLException, NotAuthorizedException, InvalidArgumentException, SystemException {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results = workbasketService.createWorkbasketQuery()
.accessIdsHavePermission(WorkbasketPermission.DISTRIBUTE, "user_1_1", "group_1")

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

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

67
rest/taskana-rest-spring/src/main/java/pro/taskana/rest/ClassificationController.java
View File

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

68
rest/taskana-rest-spring/src/main/java/pro/taskana/rest/ClassificationDefinitionController.java
View File

@ -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) {
try {
ClassificationQuery query = classificationService.createClassificationQuery();
List<ClassificationSummary> summaries = domain != null ? query.domainIn(domain).list() : query.list();
List<ClassificationResource> export = new ArrayList<>();
@RequestParam(required = false) String domain) throws ClassificationNotFoundException, NotAuthorizedException,
ClassificationAlreadyExistException, ConcurrencyException {
ClassificationQuery query = classificationService.createClassificationQuery();
List<ClassificationSummary> summaries = domain != null ? query.domainIn(domain).list() : query.list();
List<ClassificationResource> export = new ArrayList<>();
for (ClassificationSummary summary : summaries) {
Classification classification = classificationService.getClassification(summary.getKey(),
summary.getDomain());
export.add(classificationMapper.toResource(classification));
}
return new ResponseEntity<>(export, HttpStatus.OK);
} catch (ClassificationNotFoundException e) {
TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
return new ResponseEntity<>(HttpStatus.NOT_FOUND);
for (ClassificationSummary summary : summaries) {
Classification classification = classificationService.getClassification(summary.getKey(),
summary.getDomain());
export.add(classificationMapper.toResource(classification));
}
return new ResponseEntity<>(export, HttpStatus.OK);
}
@PostMapping(path = "/import")
@Transactional(rollbackFor = Exception.class)
public ResponseEntity<String> importClassifications(
@RequestBody List<ClassificationResource> classificationResources) {
try {
Map<String, String> systemIds = classificationService.createClassificationQuery()
.list()
.stream()
.collect(Collectors.toMap(i -> i.getKey() + "|||" + i.getDomain(), ClassificationSummary::getId));
@RequestBody List<ClassificationResource> classificationResources) throws NotAuthorizedException,
ClassificationNotFoundException, ConcurrencyException, ClassificationAlreadyExistException {
Map<String, String> systemIds = classificationService.createClassificationQuery()
.list()
.stream()
.collect(Collectors.toMap(i -> i.getKey() + "|||" + i.getDomain(), ClassificationSummary::getId));
for (ClassificationResource classificationResource : classificationResources) {
Classification classification = classificationMapper.toModel(classificationResource);
if (systemIds.containsKey(classificationResource.key + "|||" + classificationResource.domain)) {
classificationService.updateClassification(classification);
for (ClassificationResource classificationResource : classificationResources) {
Classification classification = classificationMapper.toModel(classificationResource);
if (systemIds.containsKey(classificationResource.key + "|||" + classificationResource.domain)) {
classificationService.updateClassification(classification);
} else {
classificationService.createClassification(classification);
}
} else {
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);
}
}

3
rest/taskana-rest-spring/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.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) {

149
rest/taskana-rest-spring/src/main/java/pro/taskana/rest/TaskController.java
View File

@ -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) {
try {
if (params.keySet().size() == 0) {
// get all
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();
public ResponseEntity<List<TaskSummary>> getTasks(@RequestParam MultiValueMap<String, String> params)
throws NotAuthorizedException, InvalidArgumentException {
if (params.keySet().size() == 0) {
// get all
return ResponseEntity.status(HttpStatus.OK).body(taskLogic.getAll());
}
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) {
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();
} 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();
}
public ResponseEntity<Task> getTask(@PathVariable String taskId)
throws TaskNotFoundException, NotAuthorizedException {
Task task = taskService.getTask(taskId);
return ResponseEntity.status(HttpStatus.OK).body(task);
}
@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)
.stateIn(taskState)
.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();
}
List<TaskSummary> taskList = taskService.createTaskQuery()
.workbasketIdIn(workbasketId)
.stateIn(taskState)
.list();
return ResponseEntity.status(HttpStatus.OK).body(taskList);
}
@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);
Task updatedTask = taskService.getTask(taskId);
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();
}
taskService.claim(taskId);
Task updatedTask = taskService.getTask(taskId);
return ResponseEntity.status(HttpStatus.OK).body(updatedTask);
}
@RequestMapping(method = RequestMethod.POST, value = "/{taskId}/complete")
@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();
} 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();
}
public ResponseEntity<Task> completeTask(@PathVariable String taskId)
throws TaskNotFoundException, InvalidOwnerException, InvalidStateException, NotAuthorizedException {
taskService.completeTask(taskId, true);
Task updatedTask = taskService.getTask(taskId);
return ResponseEntity.status(HttpStatus.OK).body(updatedTask);
}
@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();
}
public ResponseEntity<Task> createTask(@RequestBody Task task)
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
TaskAlreadyExistException, InvalidWorkbasketException, InvalidArgumentException {
Task createdTask = taskService.createTask(task);
return ResponseEntity.status(HttpStatus.CREATED).body(createdTask);
}
@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();
}
public ResponseEntity<Task> transferTask(@PathVariable String taskId, @PathVariable String workbasketKey)
throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException, InvalidWorkbasketException {
Task updatedTask = taskService.transfer(taskId, workbasketKey);
return ResponseEntity.status(HttpStatus.CREATED).body(updatedTask);
}
@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();
}
taskSummaries = taskService.createTaskQuery().workbasketIdIn(workbasketId).list();
return ResponseEntity.status(HttpStatus.OK).body(taskSummaries);
}
}

77
rest/taskana-rest-spring/src/main/java/pro/taskana/rest/TaskanaErrorData.java Normal file
View File

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

114
rest/taskana-rest-spring/src/main/java/pro/taskana/rest/TaskanaRestExceptionHandler.java Normal file
View File

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

202
rest/taskana-rest-spring/src/main/java/pro/taskana/rest/WorkbasketController.java
View File

@ -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) {
try {
WorkbasketQuery query = workbasketService.createWorkbasketQuery();
addSortingToQuery(query, sortBy, order);
addAttributeFilter(query, name, nameLike, key, keyLike, descLike, owner, ownerLike, type);
addAuthorizationFilter(query, requiredPermission);
List<WorkbasketSummary> workbasketSummaries = query.list();
Resources<WorkbasketSummaryResource> workbasketListResource = workbasketListMapper
.toResource(workbasketSummaries);
return new ResponseEntity<>(workbasketListResource, HttpStatus.OK);
} catch (InvalidArgumentException ex) {
TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
}
@RequestParam(value = "requiredPermission", required = false) String requiredPermission)
throws WorkbasketNotFoundException, NotAuthorizedException, InvalidArgumentException {
WorkbasketQuery query = workbasketService.createWorkbasketQuery();
addSortingToQuery(query, sortBy, order);
addAttributeFilter(query, name, nameLike, key, keyLike, descLike, owner, ownerLike, type);
addAuthorizationFilter(query, requiredPermission);
List<WorkbasketSummary> workbasketSummaries = query.list();
Resources<WorkbasketSummaryResource> workbasketListResource = workbasketListMapper
.toResource(workbasketSummaries);
return new ResponseEntity<>(workbasketListResource, HttpStatus.OK);
}
@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);
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);
}
Workbasket workbasket = workbasketService.getWorkbasket(workbasketId);
result = new ResponseEntity<>(workbasketMapper.toResource(workbasket), HttpStatus.OK);
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);
} 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();
}
workbasketService.deleteWorkbasket(workbasketId);
return result;
}
@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) {
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);
}
public ResponseEntity<WorkbasketResource> createWorkbasket(@RequestBody WorkbasketResource workbasketResource)
throws InvalidWorkbasketException, NotAuthorizedException, WorkbasketAlreadyExistException,
WorkbasketNotFoundException {
Workbasket workbasket = workbasketMapper.toModel(workbasketResource);
workbasket = workbasketService.createWorkbasket(workbasket);
return new ResponseEntity<>(workbasketMapper.toResource(workbasket), HttpStatus.CREATED);
}
@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)) {
Workbasket workbasket = workbasketMapper.toModel(workbasketResource);
workbasket = workbasketService.updateWorkbasket(workbasket);
result = ResponseEntity.ok(workbasketMapper.toResource(workbasket));
} else {
throw new InvalidWorkbasketException(
"Target-WB-ID('" + workbasketId
+ "') is not identical with the WB-ID of to object which should be updated. ID=('"
+ 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);
if (workbasketId.equals(workbasketResource.workbasketId)) {
Workbasket workbasket = workbasketMapper.toModel(workbasketResource);
workbasket = workbasketService.updateWorkbasket(workbasket);
result = ResponseEntity.ok(workbasketMapper.toResource(workbasket));
} else {
throw new InvalidWorkbasketException(
"Target-WB-ID('" + workbasketId
+ "') is not identical with the WB-ID of to object which should be updated. ID=('"
+ workbasketResource.getId() + "')");
}
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);
Resources<WorkbasketAccessItemResource> accessItemListResource = accessItemListMapper
.toResource(workbasketId, accessItems);
result = new ResponseEntity<>(accessItemListResource, HttpStatus.OK);
} catch (NotAuthorizedException e) {
result = new ResponseEntity<>(HttpStatus.UNAUTHORIZED);
}
List<WorkbasketAccessItem> accessItems = workbasketService.getWorkbasketAccessItems(workbasketId);
Resources<WorkbasketAccessItemResource> accessItemListResource = accessItemListMapper
.toResource(workbasketId, accessItems);
result = new ResponseEntity<>(accessItemListResource, HttpStatus.OK);
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) {
try {
if (workbasketAccessResourceItems == null) {
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);
@RequestBody List<WorkbasketAccessItemResource> workbasketAccessResourceItems)
throws NotAuthorizedException, InvalidArgumentException, WorkbasketNotFoundException {
if (workbasketAccessResourceItems == null) {
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);
}
@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);
Resources<DistributionTargetResource> distributionTargetListResource = distributionTargetListMapper
.toResource(workbasketId, distributionTargets);
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);
}
List<WorkbasketSummary> distributionTargets = workbasketService.getDistributionTargets(workbasketId);
Resources<DistributionTargetResource> distributionTargetListResource = distributionTargetListMapper
.toResource(workbasketId, distributionTargets);
result = new ResponseEntity<>(distributionTargetListResource, HttpStatus.OK);
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) {
try {
workbasketService.setDistributionTargets(sourceWorkbasketId, targetWorkbasketIds);
@RequestBody List<String> targetWorkbasketIds) throws WorkbasketNotFoundException, NotAuthorizedException {
workbasketService.setDistributionTargets(sourceWorkbasketId, targetWorkbasketIds);
List<WorkbasketSummary> distributionTargets = workbasketService.getDistributionTargets(sourceWorkbasketId);
Resources<DistributionTargetResource> distributionTargetListResource = distributionTargetListMapper
.toResource(sourceWorkbasketId, distributionTargets);
List<WorkbasketSummary> distributionTargets = workbasketService.getDistributionTargets(sourceWorkbasketId);
Resources<DistributionTargetResource> distributionTargetListResource = distributionTargetListMapper
.toResource(sourceWorkbasketId, distributionTargets);
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);
}
return new ResponseEntity<>(distributionTargetListResource, HttpStatus.OK);
}
private void addAuthorizationFilter(WorkbasketQuery query, String requiredPermission)

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

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

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

@ -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) {
List<DistributionTargetResource> resourceList = distributionTargets.stream()
.map(workbasket -> distributionTargetMapper.toResource(workbasket))
.collect(Collectors.toList());
Collection<WorkbasketSummary> distributionTargets) throws WorkbasketNotFoundException, NotAuthorizedException {
List<DistributionTargetResource> resourceList = new ArrayList<>();
for (WorkbasketSummary wb : distributionTargets) {
resourceList.add(distributionTargetMapper.toResource(wb));
}
Resources<DistributionTargetResource> distributionTargetListResource = new Resources<>(resourceList);
distributionTargetListResource

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

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

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

@ -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) {
List<WorkbasketAccessItemResource> resourceList = accessItems.stream()
.map(accessItem -> {
try {
return workbasketAccessItemMapper.toResource(accessItem);
} catch (NotAuthorizedException e) {
return null;
}
})
.collect(Collectors.toList());
Collection<WorkbasketAccessItem> accessItems) throws NotAuthorizedException, WorkbasketNotFoundException {
List<WorkbasketAccessItemResource> resourceList = new ArrayList<>();
for (WorkbasketAccessItem accessItem : accessItems) {
resourceList.add(workbasketAccessItemMapper.toResource(accessItem));
}
Resources<WorkbasketAccessItemResource> accessItemListResource = new Resources<>(resourceList);
accessItemListResource

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

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

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

@ -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) {
List<WorkbasketSummaryResource> resourceList = workbasketSummaries.stream()
.map(workbasket -> workbasketSummaryMapper.toResource(workbasket))
.collect(Collectors.toList());
public Resources<WorkbasketSummaryResource> toResource(Collection<WorkbasketSummary> workbasketSummaries)
throws WorkbasketNotFoundException, NotAuthorizedException {
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());

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

@ -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"));

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

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

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

@ -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");

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

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

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

@ -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");

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

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