Workflow REST API added sorting, tests and paging fix

git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@54789 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261

source/java/org/alfresco/rest/workflow/api/impl/ProcessesImpl.java

@@ -73,6 +73,7 @@ import org.alfresco.rest.framework.resource.content.FileBinaryResource;
 import org.alfresco.rest.framework.resource.parameters.CollectionWithPagingInfo;
 import org.alfresco.rest.framework.resource.parameters.Paging;
 import org.alfresco.rest.framework.resource.parameters.Parameters;
+import org.alfresco.rest.framework.resource.parameters.SortColumn;
 import org.alfresco.rest.framework.resource.parameters.where.QueryHelper;
 import org.alfresco.rest.workflow.api.Processes;
 import org.alfresco.rest.workflow.api.impl.MapBasedQueryWalker.QueryVariableHolder;
@@ -294,6 +295,17 @@ public class ProcessesImpl extends WorkflowRestImpl implements Processes
             throw new InvalidArgumentException("Invalid status parameter: " + status);
         }
         
+        List<SortColumn> sortList = parameters.getSorting();
+        SortColumn sortColumn = null;
+        if (sortList != null && sortList.size() > 0)
+        {
+            if (sortList.size() != 1)
+            {
+                throw new InvalidArgumentException("Only one order by parameter is supported");
+            }
+            sortColumn = sortList.get(0);
+        }
+        
         final HistoricProcessInstanceQuery query = activitiProcessEngine
                 .getHistoryService()
                 .createHistoricProcessInstanceQuery();
@@ -392,58 +404,48 @@ public class ProcessesImpl extends WorkflowRestImpl implements Processes
             query.involvedUser(AuthenticationUtil.getRunAsUser());
         }
         
-        String sortParam = parameters.getParameter("sort");
-        if (sortParam != null)
+        if (sortColumn != null)
         {
-            if (PROCESS_COLLECTION_SORT_PROPERTIES.contains(sortParam))
+            if (PROCESS_COLLECTION_SORT_PROPERTIES.contains(sortColumn.column))
             {
-                if ("processDefinitionId".equalsIgnoreCase(sortParam))
+                if ("processDefinitionId".equalsIgnoreCase(sortColumn.column))
                 {
                     query.orderByProcessDefinitionId();
                 }
-                else if ("id".equalsIgnoreCase(sortParam))
+                else if ("id".equalsIgnoreCase(sortColumn.column))
                 {
                     query.orderByProcessInstanceId();
                 }
-                else if ("businessKey".equalsIgnoreCase(sortParam))
+                else if ("businessKey".equalsIgnoreCase(sortColumn.column))
                 {
                     query.orderByProcessInstanceBusinessKey();
                 }
-                else if ("startedAt".equalsIgnoreCase(sortParam))
+                else if ("startedAt".equalsIgnoreCase(sortColumn.column))
                 {
                     query.orderByProcessInstanceStartTime();
                 }
-                else if ("endedAt".equalsIgnoreCase(sortParam))
+                else if ("endedAt".equalsIgnoreCase(sortColumn.column))
                 {
                     query.orderByProcessInstanceEndTime();
                 }
-                else if ("durationInMillis".equalsIgnoreCase(sortParam))
+                else if ("durationInMillis".equalsIgnoreCase(sortColumn.column))
                 {
                     query.orderByProcessInstanceDuration();
                 }
             }
             else
             {
-                throw new InvalidArgumentException("sort " + sortParam + 
+                throw new InvalidArgumentException("sort " + sortColumn.column + 
                         " is not supported, supported items are " + PROCESS_COLLECTION_SORT_PROPERTIES.toArray());
             }
             
-            String sortOrderParam = parameters.getParameter("sortOrder");
-            if (sortOrderParam != null)
-            {
-                if ("asc".equalsIgnoreCase(sortOrderParam))
+            if (sortColumn.asc)
             {
                 query.asc();
             }
-                else if ("desc".equalsIgnoreCase(sortOrderParam))
-                {
-                    query.desc();
-                }
             else
             {
-                    throw new InvalidArgumentException("sort order " + sortOrderParam + 
-                            " is not supported, supported items are asc and desc");
-                }
+                query.desc();
             }
         }
         else
@@ -452,6 +454,7 @@ public class ProcessesImpl extends WorkflowRestImpl implements Processes
         }
         
         List<HistoricProcessInstance> processInstances = query.listPage(paging.getSkipCount(), paging.getMaxItems());
+        int totalCount = (int) query.count();
 
         List<ProcessInfo> page = new ArrayList<ProcessInfo>(processInstances.size());
         for (HistoricProcessInstance processInstance: processInstances) 
@@ -459,7 +462,7 @@ public class ProcessesImpl extends WorkflowRestImpl implements Processes
             page.add(createProcessInfo(processInstance));
         }
         
-        return CollectionWithPagingInfo.asPaged(paging, page, false, page.size());
+        return CollectionWithPagingInfo.asPaged(paging, page, page.size() != totalCount, totalCount);
     }
 
     @Override

source/java/org/alfresco/rest/workflow/api/impl/TasksImpl.java

@@ -53,6 +53,7 @@ import org.alfresco.rest.framework.core.exceptions.UnsupportedResourceOperationE
 import org.alfresco.rest.framework.resource.parameters.CollectionWithPagingInfo;
 import org.alfresco.rest.framework.resource.parameters.Paging;
 import org.alfresco.rest.framework.resource.parameters.Parameters;
+import org.alfresco.rest.framework.resource.parameters.SortColumn;
 import org.alfresco.rest.framework.resource.parameters.where.QueryHelper;
 import org.alfresco.rest.workflow.api.Tasks;
 import org.alfresco.rest.workflow.api.impl.MapBasedQueryWalker.QueryVariableHolder;
@@ -183,7 +184,19 @@ public class TasksImpl extends WorkflowRestImpl implements Tasks
         Date dueAtGreaterThan = propertyWalker.getProperty("dueAt", WhereClauseParser.GREATERTHAN, Date.class);
         Date dueAtLessThan = propertyWalker.getProperty("dueAt", WhereClauseParser.LESSTHAN, Date.class);
 
+        List<SortColumn> sortList = parameters.getSorting();
+        SortColumn sortColumn = null;
+        if (sortList != null && sortList.size() > 0)
+        {
+            if (sortList.size() != 1)
+            {
+                throw new InvalidArgumentException("Only one order by parameter is supported");
+            }
+            sortColumn = sortList.get(0);
+        }
+        
         List<Task> page = null;
+        int totalCount = 0;
         if (status == null || STATUS_ACTIVE.equals(status))
         {
             TaskQuery query = activitiProcessEngine
@@ -296,9 +309,10 @@ public class TasksImpl extends WorkflowRestImpl implements Tasks
                 query.taskInvolvedUser(AuthenticationUtil.getRunAsUser());
             }
             
-            query.orderByDueDate().asc();
+            setSorting(query, sortColumn);
             
             List<org.activiti.engine.task.Task> tasks = query.listPage(paging.getSkipCount(), paging.getMaxItems());
+            totalCount = (int) query.count();
             
             page = new ArrayList<Task>(tasks.size());
             for (org.activiti.engine.task.Task taskInstance: tasks) 
@@ -411,9 +425,10 @@ public class TasksImpl extends WorkflowRestImpl implements Tasks
                 query.taskInvolvedUser(AuthenticationUtil.getRunAsUser());
             }
             
-            query.orderByTaskDueDate().asc();
+            setSorting(query, sortColumn);
             
             List<HistoricTaskInstance> tasks = query.listPage(paging.getSkipCount(), paging.getMaxItems());
+            totalCount = (int) query.count();
 
             page = new ArrayList<Task>(tasks.size());
             for (HistoricTaskInstance taskInstance: tasks) 
@@ -427,7 +442,7 @@ public class TasksImpl extends WorkflowRestImpl implements Tasks
             throw new InvalidArgumentException("Invalid status parameter: " + status);
         }
         
-        return CollectionWithPagingInfo.asPaged(paging, page, false, page.size());
+        return CollectionWithPagingInfo.asPaged(paging, page, page.size() != totalCount, totalCount);
     }
     
     @Override
@@ -436,9 +451,21 @@ public class TasksImpl extends WorkflowRestImpl implements Tasks
         Paging paging = parameters.getPaging();
         String status = parameters.getParameter("status");
         
+        List<SortColumn> sortList = parameters.getSorting();
+        SortColumn sortColumn = null;
+        if (sortList != null && sortList.size() > 0)
+        {
+            if (sortList.size() != 1)
+            {
+                throw new InvalidArgumentException("Only one order by parameter is supported");
+            }
+            sortColumn = sortList.get(0);
+        }
+        
         validateIfUserAllowedToWorkWithProcess(processId);
 
         List<Task> page = null;
+        int totalCount = 0;
         if (status == null || STATUS_ACTIVE.equals(status))
         {
             TaskQuery query = activitiProcessEngine
@@ -446,75 +473,10 @@ public class TasksImpl extends WorkflowRestImpl implements Tasks
                     .createTaskQuery();
             
             query.processInstanceId(processId);
-            
-            String sortParam = parameters.getParameter("sort");
-            if (sortParam != null)
-            {
-                if (TASK_COLLECTION_RUNNING_SORT_PROPERTIES.contains(sortParam))
-                {
-                    if ("id".equalsIgnoreCase(sortParam))
-                    {
-                        query.orderByTaskId();
-                    }
-                    else if ("name".equalsIgnoreCase(sortParam))
-                    {
-                        query.orderByTaskName();
-                    }
-                    else if ("description".equalsIgnoreCase(sortParam))
-                    {
-                        query.orderByTaskDescription();
-                    }
-                    else if ("priority".equalsIgnoreCase(sortParam))
-                    {
-                        query.orderByTaskPriority();
-                    }
-                    else if ("processId".equalsIgnoreCase(sortParam))
-                    {
-                        query.orderByProcessInstanceId();
-                    }
-                    else if ("assignee".equalsIgnoreCase(sortParam))
-                    {
-                        query.orderByTaskAssignee();
-                    }
-                    else if ("startedAt".equalsIgnoreCase(sortParam))
-                    {
-                        query.orderByTaskCreateTime();
-                    }
-                    else if ("dueAt".equalsIgnoreCase(sortParam))
-                    {
-                        query.orderByDueDate();
-                    }
-                }
-                else
-                {
-                    throw new InvalidArgumentException("sort " + sortParam + 
-                            " is not supported, supported items are " + TASK_COLLECTION_RUNNING_SORT_PROPERTIES.toArray());
-                }
-                
-                String sortOrderParam = parameters.getParameter("sortOrder");
-                if (sortOrderParam != null)
-                {
-                    if ("asc".equalsIgnoreCase(sortOrderParam))
-                    {
-                        query.asc();
-                    }
-                    else if ("desc".equalsIgnoreCase(sortOrderParam))
-                    {
-                        query.desc();
-                    }
-                    else
-                    {
-                        throw new InvalidArgumentException("sort order " + sortOrderParam + 
-                                " is not supported, supported items are asc and desc");
-                    }
-                }
-            }
-            else
-            {
-                query.orderByDueDate().asc();
-            }
+            setSorting(query, sortColumn);
             
             List<org.activiti.engine.task.Task> tasks = query.listPage(paging.getSkipCount(), paging.getMaxItems());
+            totalCount = (int) query.count();
 
             page = new ArrayList<Task>(tasks.size());
             for (org.activiti.engine.task.Task taskInstance: tasks) 
@@ -544,90 +506,10 @@ public class TasksImpl extends WorkflowRestImpl implements Tasks
                 query.taskInvolvedUser(AuthenticationUtil.getRunAsUser());
             }
             
-            String sortParam = parameters.getParameter("sort");
-            if (sortParam != null)
-            {
-                if (TASK_COLLECTION_HISTORY_SORT_PROPERTIES.contains(sortParam))
-                {
-                    if ("id".equalsIgnoreCase(sortParam))
-                    {
-                        query.orderByTaskId();
-                    }
-                    else if ("name".equalsIgnoreCase(sortParam))
-                    {
-                        query.orderByTaskName();
-                    }
-                    else if ("description".equalsIgnoreCase(sortParam))
-                    {
-                        query.orderByTaskDescription();
-                    }
-                    else if ("priority".equalsIgnoreCase(sortParam))
-                    {
-                        query.orderByTaskPriority();
-                    }
-                    else if ("processId".equalsIgnoreCase(sortParam))
-                    {
-                        query.orderByProcessInstanceId();
-                    }
-                    else if ("processDefinitionId".equalsIgnoreCase(sortParam))
-                    {
-                        query.orderByProcessDefinitionId();
-                    }
-                    else if ("assignee".equalsIgnoreCase(sortParam))
-                    {
-                        query.orderByTaskAssignee();
-                    }
-                    else if ("owner".equalsIgnoreCase(sortParam))
-                    {
-                        query.orderByTaskOwner();
-                    }
-                    else if ("startedAt".equalsIgnoreCase(sortParam))
-                    {
-                        query.orderByHistoricTaskInstanceStartTime();
-                    }
-                    else if ("endedAt".equalsIgnoreCase(sortParam))
-                    {
-                        query.orderByHistoricTaskInstanceEndTime();
-                    }
-                    else if ("durationInMs".equalsIgnoreCase(sortParam))
-                    {
-                        query.orderByHistoricTaskInstanceDuration();
-                    }
-                    else if ("dueAt".equalsIgnoreCase(sortParam))
-                    {
-                        query.orderByTaskDueDate();
-                    }
-                }
-                else
-                {
-                    throw new InvalidArgumentException("sort " + sortParam + 
-                            " is not supported, supported items are " + TASK_COLLECTION_HISTORY_SORT_PROPERTIES.toArray());
-                }
-                
-                String sortOrderParam = parameters.getParameter("sortOrder");
-                if (sortOrderParam != null)
-                {
-                    if ("asc".equalsIgnoreCase(sortOrderParam))
-                    {
-                        query.asc();
-                    }
-                    else if ("desc".equalsIgnoreCase(sortOrderParam))
-                    {
-                        query.desc();
-                    }
-                    else
-                    {
-                        throw new InvalidArgumentException("sort order " + sortOrderParam + 
-                                " is not supported, supported items are asc and desc");
-                    }
-                }
-            }
-            else
-            {
-                query.orderByTaskDueDate().asc();
-            }
+            setSorting(query, sortColumn);
             
             List<HistoricTaskInstance> tasks = query.listPage(paging.getSkipCount(), paging.getMaxItems());
+            totalCount = (int) query.count();
 
             page = new ArrayList<Task>(tasks.size());
             for (HistoricTaskInstance taskInstance: tasks) 
@@ -641,7 +523,7 @@ public class TasksImpl extends WorkflowRestImpl implements Tasks
             throw new InvalidArgumentException("Invalid status parameter: " + status);
         }
         
-        return CollectionWithPagingInfo.asPaged(paging, page, false, page.size());
+        return CollectionWithPagingInfo.asPaged(paging, page, page.size() != totalCount, totalCount);
     }
 
     @Override
@@ -1320,6 +1202,142 @@ public class TasksImpl extends WorkflowRestImpl implements Tasks
         return taskInstance;
     }
     
+    protected void setSorting(TaskQuery query, SortColumn sortColumn)
+    {
+        if (sortColumn != null)
+        {
+            if (TASK_COLLECTION_RUNNING_SORT_PROPERTIES.contains(sortColumn.column))
+            {
+                if ("id".equalsIgnoreCase(sortColumn.column))
+                {
+                    query.orderByTaskId();
+                }
+                else if ("name".equalsIgnoreCase(sortColumn.column))
+                {
+                    query.orderByTaskName();
+                }
+                else if ("description".equalsIgnoreCase(sortColumn.column))
+                {
+                    query.orderByTaskDescription();
+                }
+                else if ("priority".equalsIgnoreCase(sortColumn.column))
+                {
+                    query.orderByTaskPriority();
+                }
+                else if ("processId".equalsIgnoreCase(sortColumn.column))
+                {
+                    query.orderByProcessInstanceId();
+                }
+                else if ("assignee".equalsIgnoreCase(sortColumn.column))
+                {
+                    query.orderByTaskAssignee();
+                }
+                else if ("startedAt".equalsIgnoreCase(sortColumn.column))
+                {
+                    query.orderByTaskCreateTime();
+                }
+                else if ("dueAt".equalsIgnoreCase(sortColumn.column))
+                {
+                    query.orderByDueDate();
+                }
+            }
+            else
+            {
+                throw new InvalidArgumentException("sort " + sortColumn.column + 
+                        " is not supported, supported items are " + TASK_COLLECTION_RUNNING_SORT_PROPERTIES.toArray());
+            }
+            
+            if (sortColumn.asc)
+            {
+                query.asc();
+            }
+            else
+            {
+                query.desc();
+            }
+        }
+        else
+        {
+            query.orderByDueDate().asc();
+        }
+    }
+    
+    protected void setSorting(HistoricTaskInstanceQuery query, SortColumn sortColumn)
+    {
+        if (sortColumn != null)
+        {
+            if (TASK_COLLECTION_HISTORY_SORT_PROPERTIES.contains(sortColumn.column))
+            {
+                if ("id".equalsIgnoreCase(sortColumn.column))
+                {
+                    query.orderByTaskId();
+                }
+                else if ("name".equalsIgnoreCase(sortColumn.column))
+                {
+                    query.orderByTaskName();
+                }
+                else if ("description".equalsIgnoreCase(sortColumn.column))
+                {
+                    query.orderByTaskDescription();
+                }
+                else if ("priority".equalsIgnoreCase(sortColumn.column))
+                {
+                    query.orderByTaskPriority();
+                }
+                else if ("processId".equalsIgnoreCase(sortColumn.column))
+                {
+                    query.orderByProcessInstanceId();
+                }
+                else if ("processDefinitionId".equalsIgnoreCase(sortColumn.column))
+                {
+                    query.orderByProcessDefinitionId();
+                }
+                else if ("assignee".equalsIgnoreCase(sortColumn.column))
+                {
+                    query.orderByTaskAssignee();
+                }
+                else if ("owner".equalsIgnoreCase(sortColumn.column))
+                {
+                    query.orderByTaskOwner();
+                }
+                else if ("startedAt".equalsIgnoreCase(sortColumn.column))
+                {
+                    query.orderByHistoricTaskInstanceStartTime();
+                }
+                else if ("endedAt".equalsIgnoreCase(sortColumn.column))
+                {
+                    query.orderByHistoricTaskInstanceEndTime();
+                }
+                else if ("durationInMs".equalsIgnoreCase(sortColumn.column))
+                {
+                    query.orderByHistoricTaskInstanceDuration();
+                }
+                else if ("dueAt".equalsIgnoreCase(sortColumn.column))
+                {
+                    query.orderByTaskDueDate();
+                }
+            }
+            else
+            {
+                throw new InvalidArgumentException("sort " + sortColumn.column + 
+                        " is not supported, supported items are " + TASK_COLLECTION_HISTORY_SORT_PROPERTIES.toArray());
+            }
+            
+            if (sortColumn.asc)
+            {
+                query.asc();
+            }
+            else
+            {
+                query.desc();
+            }
+        }
+        else
+        {
+            query.orderByTaskDueDate().asc();
+        }
+    }
+    
     protected WorkflowQNameConverter getQNameConverter()
     {
         if (qNameConverter == null)

source/test-java/org/alfresco/rest/workflow/api/tests/ProcessWorkflowApiTest.java

@@ -609,6 +609,8 @@ public class ProcessWorkflowApiTest extends EnterpriseWorkflowTestApi
         final ProcessInfo process2 = startAdhocProcess(requestContext, null);
         final ProcessInfo process3 = startAdhocProcess(requestContext, null);
         
+        try
+        {
             ProcessesClient processesClient = publicApiClient.processesClient();
             Map<String, String> paramMap = new HashMap<String, String>();
             ListResponse<ProcessInfo> processList = processesClient.getProcesses(paramMap);
@@ -728,12 +730,89 @@ public class ProcessWorkflowApiTest extends EnterpriseWorkflowTestApi
             processList = processesClient.getProcesses(paramMap);
             assertNotNull(processList);
             assertEquals(1, processList.getList().size());
-        
+        } 
+        finally
+        {
             cleanupProcessInstance(process1.getId(), process2.getId(), process3.getId());
         }
+    }
     
-    // No sorting support yet
-    /*@Test
+    @Test
+    public void testGetProcessInstancesWithPaging() throws Exception
+    {
+        final RequestContext requestContext = initApiClientWithTestUser();
+        
+        final ProcessInfo process1 = startAdhocProcess(requestContext, null);
+        final ProcessInfo process2 = startAdhocProcess(requestContext, null);
+        final ProcessInfo process3 = startAdhocProcess(requestContext, null);
+        
+        try
+        {
+            ProcessesClient processesClient = publicApiClient.processesClient();
+            
+            // Test with existing processDefinitionId
+            Map<String, String> params = new HashMap<String, String>();
+            params.put("processDefinitionId", process1.getProcessDefinitionId());
+            JSONObject processListJSONObject = processesClient.getProcessesJSON(params);
+            assertNotNull(processListJSONObject);
+            JSONObject paginationJSON = (JSONObject) processListJSONObject.get("pagination");
+            assertEquals(3l, paginationJSON.get("count"));
+            assertEquals(3l, paginationJSON.get("totalItems"));
+            assertEquals(0l, paginationJSON.get("skipCount"));
+            assertEquals(false, paginationJSON.get("hasMoreItems"));
+            JSONArray jsonEntries = (JSONArray) processListJSONObject.get("entries");
+            assertEquals(3, jsonEntries.size());
+            
+            // Test with existing processDefinitionId and max items
+            params.clear();
+            params.put("maxItems", "2");
+            params.put("processDefinitionId",  process1.getProcessDefinitionId());
+            processListJSONObject = processesClient.getProcessesJSON(params);
+            assertNotNull(processListJSONObject);
+            paginationJSON = (JSONObject) processListJSONObject.get("pagination");
+            assertEquals(2l, paginationJSON.get("count"));
+            assertEquals(3l, paginationJSON.get("totalItems"));
+            assertEquals(0l, paginationJSON.get("skipCount"));
+            assertEquals(true, paginationJSON.get("hasMoreItems"));
+            jsonEntries = (JSONArray) processListJSONObject.get("entries");
+            assertEquals(2, jsonEntries.size());
+            
+            // Test with existing processDefinitionId and skip count
+            params.clear();
+            params.put("skipCount", "1");
+            params.put("processDefinitionId", process1.getProcessDefinitionId());
+            processListJSONObject = processesClient.getProcessesJSON(params);
+            assertNotNull(processListJSONObject);
+            paginationJSON = (JSONObject) processListJSONObject.get("pagination");
+            assertEquals(2l, paginationJSON.get("count"));
+            assertEquals(3l, paginationJSON.get("totalItems"));
+            assertEquals(1l, paginationJSON.get("skipCount"));
+            assertEquals(true, paginationJSON.get("hasMoreItems"));
+            jsonEntries = (JSONArray) processListJSONObject.get("entries");
+            assertEquals(2, jsonEntries.size());
+            
+            // Test with existing processDefinitionId and max items and skip count
+            params.clear();
+            params.put("maxItems", "3");
+            params.put("skipCount", "2");
+            params.put("processDefinitionId", process1.getProcessDefinitionId());
+            processListJSONObject = processesClient.getProcessesJSON(params);
+            assertNotNull(processListJSONObject);
+            paginationJSON = (JSONObject) processListJSONObject.get("pagination");
+            assertEquals(1l, paginationJSON.get("count"));
+            assertEquals(3l, paginationJSON.get("totalItems"));
+            assertEquals(2l, paginationJSON.get("skipCount"));
+            assertEquals(true, paginationJSON.get("hasMoreItems"));
+            jsonEntries = (JSONArray) processListJSONObject.get("entries");
+            assertEquals(1, jsonEntries.size());
+        } 
+        finally
+        {
+            cleanupProcessInstance(process1.getId(), process2.getId(), process3.getId());
+        }
+    }
+    
+    @Test
     public void testGetProcessInstancesWithSorting() throws Exception
     {
         final RequestContext requestContext = initApiClientWithTestUser();
@@ -747,8 +826,7 @@ public class ProcessWorkflowApiTest extends EnterpriseWorkflowTestApi
             // sort on business key ascending
             ProcessesClient processesClient = publicApiClient.processesClient();
             Map<String, String> paramMap = new HashMap<String, String>();
-            paramMap.put("sort", "businessKey");
-            paramMap.put("sortOrder", "asc");
+            paramMap.put("orderBy", "businessKey ASC");
             ListResponse<ProcessInfo> processList = processesClient.getProcesses(paramMap);
             assertNotNull(processList);
             assertEquals(3, processList.getList().size());
@@ -758,8 +836,7 @@ public class ProcessWorkflowApiTest extends EnterpriseWorkflowTestApi
             assertEquals(process2.getId(), processList.getList().get(2).getId());
             
             // sort on business key descending
-            paramMap.put("sort", "businessKey");
-            paramMap.put("sortOrder", "desc");
+            paramMap.put("orderBy", "businessKey DESC");
             processList = processesClient.getProcesses(paramMap);
             assertNotNull(processList);
             assertEquals(3, processList.getList().size());
@@ -769,7 +846,7 @@ public class ProcessWorkflowApiTest extends EnterpriseWorkflowTestApi
             assertEquals(process3.getId(), processList.getList().get(2).getId());
             
             // sort on non existing key
-            paramMap.put("sort", "businessKey2");
+            paramMap.put("orderBy", "businessKey2 ASC");
             try 
             {
                 processList = processesClient.getProcesses(paramMap);
@@ -780,24 +857,21 @@ public class ProcessWorkflowApiTest extends EnterpriseWorkflowTestApi
                 assertEquals(HttpStatus.BAD_REQUEST.value(), e.getHttpResponse().getStatusCode());
             }
             
-            // sort on non existing sort order
-            paramMap.put("sort", "businessKey");
-            paramMap.put("sortOrder", "asc2");
-            try 
-            {
+            // sort on non existing sort order (default ASC is taken)
+            paramMap.put("orderBy", "businessKey ASC2");
             processList = processesClient.getProcesses(paramMap);
-                fail();
-            }
-            catch (PublicApiException e)
-            {
-                assertEquals(HttpStatus.BAD_REQUEST.value(), e.getHttpResponse().getStatusCode());
-            }
+            assertNotNull(processList);
+            assertEquals(3, processList.getList().size());
+            
+            assertEquals(process3.getId(), processList.getList().get(0).getId());
+            assertEquals(process1.getId(), processList.getList().get(1).getId());
+            assertEquals(process2.getId(), processList.getList().get(2).getId());
         }
         finally
         {
             cleanupProcessInstance(process1.getId(), process2.getId(), process3.getId());
         }
-    }*/
+    }
     
     @Test
     public void testGetProcessTasks() throws Exception

source/test-java/org/alfresco/rest/workflow/api/tests/TaskWorkflowApiTest.java

@@ -1541,33 +1541,151 @@ public class TaskWorkflowApiTest extends EnterpriseWorkflowTestApi
             // Test with existing processDefinitionId
             Map<String, String> params = new HashMap<String, String>();
             params.put("processDefinitionId", processDefinitionId);
-            assertEquals(6, getResultSizeForTaskQuery(params, tasksClient));
+            JSONObject taskListJSONObject = tasksClient.findTasks(params);
+            assertNotNull(taskListJSONObject);
+            JSONObject paginationJSON = (JSONObject) taskListJSONObject.get("pagination");
+            assertEquals(6l, paginationJSON.get("count"));
+            assertEquals(6l, paginationJSON.get("totalItems"));
+            assertEquals(0l, paginationJSON.get("skipCount"));
+            assertEquals(false, paginationJSON.get("hasMoreItems"));
+            JSONArray jsonEntries = (JSONArray) taskListJSONObject.get("entries");
+            assertEquals(6, jsonEntries.size());
             
             // Test with existing processDefinitionId and max items
             params.clear();
             params.put("maxItems", "3");
             params.put("processDefinitionId", processDefinitionId);
-            assertEquals(3, getResultSizeForTaskQuery(params, tasksClient));
+            taskListJSONObject = tasksClient.findTasks(params);
+            assertNotNull(taskListJSONObject);
+            paginationJSON = (JSONObject) taskListJSONObject.get("pagination");
+            assertEquals(3l, paginationJSON.get("count"));
+            assertEquals(6l, paginationJSON.get("totalItems"));
+            assertEquals(0l, paginationJSON.get("skipCount"));
+            assertEquals(true, paginationJSON.get("hasMoreItems"));
+            jsonEntries = (JSONArray) taskListJSONObject.get("entries");
+            assertEquals(3, jsonEntries.size());
             
             // Test with existing processDefinitionId and skip count
             params.clear();
             params.put("skipCount", "2");
             params.put("processDefinitionId", processDefinitionId);
-            assertEquals(4, getResultSizeForTaskQuery(params, tasksClient));
+            taskListJSONObject = tasksClient.findTasks(params);
+            assertNotNull(taskListJSONObject);
+            paginationJSON = (JSONObject) taskListJSONObject.get("pagination");
+            assertEquals(4l, paginationJSON.get("count"));
+            assertEquals(6l, paginationJSON.get("totalItems"));
+            assertEquals(2l, paginationJSON.get("skipCount"));
+            assertEquals(true, paginationJSON.get("hasMoreItems"));
+            jsonEntries = (JSONArray) taskListJSONObject.get("entries");
+            assertEquals(4, jsonEntries.size());
             
             // Test with existing processDefinitionId and max items and skip count
             params.clear();
             params.put("maxItems", "3");
             params.put("skipCount", "2");
             params.put("processDefinitionId", processDefinitionId);
-            assertEquals(3, getResultSizeForTaskQuery(params, tasksClient));
+            taskListJSONObject = tasksClient.findTasks(params);
+            assertNotNull(taskListJSONObject);
+            paginationJSON = (JSONObject) taskListJSONObject.get("pagination");
+            assertEquals(3l, paginationJSON.get("count"));
+            assertEquals(6l, paginationJSON.get("totalItems"));
+            assertEquals(2l, paginationJSON.get("skipCount"));
+            assertEquals(true, paginationJSON.get("hasMoreItems"));
+            jsonEntries = (JSONArray) taskListJSONObject.get("entries");
+            assertEquals(3, jsonEntries.size());
             
             // Test with existing processDefinitionId and max items and skip count
             params.clear();
             params.put("maxItems", "3");
             params.put("skipCount", "4");
             params.put("processDefinitionId", processDefinitionId);
-            assertEquals(2, getResultSizeForTaskQuery(params, tasksClient));
+            taskListJSONObject = tasksClient.findTasks(params);
+            assertNotNull(taskListJSONObject);
+            paginationJSON = (JSONObject) taskListJSONObject.get("pagination");
+            assertEquals(2l, paginationJSON.get("count"));
+            assertEquals(6l, paginationJSON.get("totalItems"));
+            assertEquals(4l, paginationJSON.get("skipCount"));
+            assertEquals(true, paginationJSON.get("hasMoreItems"));
+            jsonEntries = (JSONArray) taskListJSONObject.get("entries");
+            assertEquals(2, jsonEntries.size());
+        }
+        finally
+        {
+            cleanupProcessInstance(startedProcesses.toArray(new ProcessInstance[] {}));
+        }
+    }
+    
+    @Test
+    public void testGetTasksWithSorting() throws Exception
+    {
+        RequestContext requestContext = initApiClientWithTestUser();
+        // Start 6 processes
+        List<ProcessInstance> startedProcesses = new ArrayList<ProcessInstance>();
+        try
+        {
+            int numberOfTasks = 6;
+            for (int i = 0; i < numberOfTasks; i++) 
+            {
+                startedProcesses.add(startAdhocProcess(requestContext.getRunAsUser(), requestContext.getNetworkId(), null));
+            }
+            
+            List<Task> taskList = new ArrayList<Task>();
+            for (int i = 0; i < numberOfTasks; i++) 
+            {
+                Task task = activitiProcessEngine.getTaskService().createTaskQuery().processInstanceId(startedProcesses.get(i).getProcessInstanceId()).singleResult();
+                activitiProcessEngine.getTaskService().setPriority(task.getId(), (i + 1) * 10);
+                taskList.add(task);
+            }
+            
+            // set last task priority to 1
+            activitiProcessEngine.getTaskService().setPriority(taskList.get(numberOfTasks - 1).getId(), 1);
+            
+            TasksClient tasksClient = publicApiClient.tasksClient();
+            
+            // Test with existing processDefinitionId
+            Map<String, String> params = new HashMap<String, String>();
+            params.put("where", "(processDefinitionId = '" + startedProcesses.get(0).getProcessDefinitionId() + "')");
+            params.put("orderBy", "priority ASC");
+            JSONObject tasksResponseJSON = tasksClient.findTasks(params);
+            
+            JSONObject paginationJSON = (JSONObject) tasksResponseJSON.get("pagination");
+            assertEquals(6l, paginationJSON.get("count"));
+            assertEquals(6l, paginationJSON.get("totalItems"));
+            JSONArray tasksListJSON = (JSONArray) tasksResponseJSON.get("entries");
+            assertEquals(6, tasksListJSON.size());
+            JSONObject taskJSON = (JSONObject) ((JSONObject) tasksListJSON.get(0)).get("entry");
+            assertEquals(taskList.get(numberOfTasks - 1).getId(), taskJSON.get("id"));
+            taskJSON = (JSONObject) ((JSONObject) tasksListJSON.get(1)).get("entry");
+            assertEquals(taskList.get(0).getId(), taskJSON.get("id"));
+            taskJSON = (JSONObject) ((JSONObject) tasksListJSON.get(2)).get("entry");
+            assertEquals(taskList.get(1).getId(), taskJSON.get("id"));
+            taskJSON = (JSONObject) ((JSONObject) tasksListJSON.get(3)).get("entry");
+            assertEquals(taskList.get(2).getId(), taskJSON.get("id"));
+            taskJSON = (JSONObject) ((JSONObject) tasksListJSON.get(4)).get("entry");
+            assertEquals(taskList.get(3).getId(), taskJSON.get("id"));
+            taskJSON = (JSONObject) ((JSONObject) tasksListJSON.get(5)).get("entry");
+            assertEquals(taskList.get(4).getId(), taskJSON.get("id"));
+            
+            params.put("orderBy", "priority DESC");
+            tasksResponseJSON = tasksClient.findTasks(params);
+            
+            paginationJSON = (JSONObject) tasksResponseJSON.get("pagination");
+            assertEquals(6l, paginationJSON.get("count"));
+            assertEquals(6l, paginationJSON.get("totalItems"));
+            tasksListJSON = (JSONArray) tasksResponseJSON.get("entries");
+            assertEquals(6, tasksListJSON.size());
+            taskJSON = (JSONObject) ((JSONObject) tasksListJSON.get(0)).get("entry");
+            assertEquals(taskList.get(4).getId(), taskJSON.get("id"));
+            taskJSON = (JSONObject) ((JSONObject) tasksListJSON.get(1)).get("entry");
+            assertEquals(taskList.get(3).getId(), taskJSON.get("id"));
+            taskJSON = (JSONObject) ((JSONObject) tasksListJSON.get(2)).get("entry");
+            assertEquals(taskList.get(2).getId(), taskJSON.get("id"));
+            taskJSON = (JSONObject) ((JSONObject) tasksListJSON.get(3)).get("entry");
+            assertEquals(taskList.get(1).getId(), taskJSON.get("id"));
+            taskJSON = (JSONObject) ((JSONObject) tasksListJSON.get(4)).get("entry");
+            assertEquals(taskList.get(0).getId(), taskJSON.get("id"));
+            taskJSON = (JSONObject) ((JSONObject) tasksListJSON.get(5)).get("entry");
+            assertEquals(taskList.get(numberOfTasks - 1).getId(), taskJSON.get("id"));
         }
         finally
         {

source/test-java/org/alfresco/rest/workflow/api/tests/WorkflowApiClient.java

@@ -137,6 +137,13 @@ public class WorkflowApiClient extends PublicApiClient
             return ProcessesParser.INSTANCE.parseList(response.getJsonResponse());
         }
         
+        public JSONObject getProcessesJSON(Map<String, String> params) throws PublicApiException
+        {
+            HttpResponse response = getAll("processes", null, null, null, params, "Failed to get process instances");
+            JSONObject list = (JSONObject) response.getJsonResponse().get("list");
+            return list;
+        }
+
         public ProcessInfo findProcessById(String processInstanceId) throws PublicApiException
         {
             HttpResponse response = getSingle("processes", processInstanceId, null, null, "Failed to find process instance by id");