TSK-1178

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

@@ -74,8 +74,9 @@ public class TaskController extends AbstractPagingController {
   private static final String DUE_TO = "due-until";
   private static final String DUE_FROM = "due-from";
   private static final String PLANNED = "planned";
-  private static final String PLANNED_TO = "planned-until";
+  private static final String PLANNED_UNTIL = "planned-until";
   private static final String PLANNED_FROM = "planned-from";
+  private static final String EXTERNAL_ID = "external-id";
 
   private static final String SORT_BY = "sort-by";
   private static final String SORT_DIRECTION = "order";
@@ -157,10 +158,9 @@ public class TaskController extends AbstractPagingController {
 
   @DeleteMapping(path = Mapping.URL_TASKS_ID_CLAIM)
   @Transactional(rollbackFor = Exception.class)
-  public ResponseEntity<TaskResource> cancelClaimTask(
+  public ResponseEntity<TaskResource> cancelClaimTask(@PathVariable String taskId)
-      @PathVariable String taskId)
       throws TaskNotFoundException, InvalidStateException, InvalidOwnerException,
-                 NotAuthorizedException {
+          NotAuthorizedException {
 
     LOGGER.debug("Entry to cancelClaimTask(taskId= {}", taskId);
 
@@ -353,18 +353,18 @@ public class TaskController extends AbstractPagingController {
       updateTaskQueryWithPlannedOrDueTimeIntervals(taskQuery, params, DUE);
     }
 
-    if (params.containsKey(PLANNED_FROM) && params.containsKey(PLANNED_TO)) {
+    if (params.containsKey(PLANNED_FROM) && params.containsKey(PLANNED_UNTIL)) {
-      updateTaskQueryWithPlannedOrDueTimeInterval(taskQuery, params, PLANNED_FROM, PLANNED_TO);
+      updateTaskQueryWithPlannedOrDueTimeInterval(taskQuery, params, PLANNED_FROM, PLANNED_UNTIL);
 
-    } else if (params.containsKey(PLANNED_FROM) && !params.containsKey(PLANNED_TO)) {
+    } else if (params.containsKey(PLANNED_FROM) && !params.containsKey(PLANNED_UNTIL)) {
 
       TimeInterval timeInterval = createIndefiniteTimeIntervalFromParam(params, PLANNED_FROM);
       updateTaskQueryWithIndefiniteTimeInterval(taskQuery, params, PLANNED_FROM, timeInterval);
 
-    } else if (!params.containsKey(PLANNED_FROM) && params.containsKey(PLANNED_TO)) {
+    } else if (!params.containsKey(PLANNED_FROM) && params.containsKey(PLANNED_UNTIL)) {
 
-      TimeInterval timeInterval = createIndefiniteTimeIntervalFromParam(params, PLANNED_TO);
+      TimeInterval timeInterval = createIndefiniteTimeIntervalFromParam(params, PLANNED_UNTIL);
-      updateTaskQueryWithIndefiniteTimeInterval(taskQuery, params, PLANNED_TO, timeInterval);
+      updateTaskQueryWithIndefiniteTimeInterval(taskQuery, params, PLANNED_UNTIL, timeInterval);
     }
 
     if (params.containsKey(DUE_FROM) && params.containsKey(DUE_TO)) {
@@ -382,6 +382,12 @@ public class TaskController extends AbstractPagingController {
       updateTaskQueryWithIndefiniteTimeInterval(taskQuery, params, DUE_TO, timeInterval);
     }
 
+    if (params.containsKey(EXTERNAL_ID)) {
+      String[] externalIds = extractCommaSeparatedFields(params.get(EXTERNAL_ID));
+      taskQuery.externalIdIn(externalIds);
+      params.remove(EXTERNAL_ID);
+    }
+
     if (LOGGER.isDebugEnabled()) {
       LOGGER.debug("Exit from applyFilterParams(), returning {}", taskQuery);
     }
@@ -413,7 +419,7 @@ public class TaskController extends AbstractPagingController {
   private void checkForIllegalParamCombinations(MultiValueMap<String, String> params) {
 
     if (params.containsKey(PLANNED)
-        && (params.containsKey(PLANNED_FROM) || params.containsKey(PLANNED_TO))) {
+        && (params.containsKey(PLANNED_FROM) || params.containsKey(PLANNED_UNTIL))) {
 
       throw new IllegalArgumentException(
           "It is prohibited to use the param \""
@@ -421,7 +427,7 @@ public class TaskController extends AbstractPagingController {
               + "\" in combination with the params \""
               + PLANNED_FROM
               + "\" and / or \""
-              + PLANNED_TO
+              + PLANNED_UNTIL
               + "\"");
     }
 
@@ -433,7 +439,7 @@ public class TaskController extends AbstractPagingController {
               + "\" in combination with the params \""
               + PLANNED_FROM
               + "\" and / or \""
-              + PLANNED_TO
+              + PLANNED_UNTIL
               + "\"");
     }
   }
@@ -444,7 +450,7 @@ public class TaskController extends AbstractPagingController {
       String param,
       TimeInterval timeInterval) {
 
-    if (param.equals(PLANNED_FROM) || param.equals(PLANNED_TO)) {
+    if (param.equals(PLANNED_FROM) || param.equals(PLANNED_UNTIL)) {
       taskQuery.plannedWithin(timeInterval);
 
     } else {

rest/taskana-rest-spring/src/test/java/pro/taskana/rest/TaskControllerIntTest.java

@@ -289,6 +289,20 @@ class TaskControllerIntTest {
     assertThat(response.getBody().getContent()).hasSize(20);
   }
 
+  @Test
+  void testGetAllTasksByExternalId() {
+    ResponseEntity<TaskSummaryListResource> response =
+        template.exchange(
+            restHelper.toUrl(Mapping.URL_TASKS)
+                + "?external-id=ETI:000000000000000000000000000000000003,"
+                + "ETI:000000000000000000000000000000000004",
+            HttpMethod.GET,
+            restHelper.defaultRequest(),
+            ParameterizedTypeReference.forType(TaskSummaryListResource.class));
+    assertThat(response.getBody().getLink(Link.REL_SELF)).isNotNull();
+    assertThat(response.getBody().getContent()).hasSize(2);
+  }
+
   @Test
   void testExceptionIfKeyIsSetButDomainIsMissing() {
 

rest/taskana-rest-spring/src/test/resources/asciidoc/rest-api.adoc

@@ -121,7 +121,8 @@ include::{snippets}/GetAllTasksDocTest/response-fields.adoc[]
 The list generated in the response can be filtered using following parameters in the uri: +
 name | priority | state | classification.key | workbasket-id | {workbasket-key , domain} | +
 owner | por.company | por.system | por.instance | por.type | por.value +
-planned | planned-from | planned-until | due | due-from | due-until +
+planned | planned-from | planned-until | due | due-from | due-until | +
+external-id
 
 If it is sufficient to filter the list with a single time interval, use the parameters +
 planned-from/due-from and planned-until/due-until. +