Merge remote-tracking branch 'remotes/origin/hotfix-2.5/MNT-18793_EligibleActionsNotExecuted' into merge-2.5/MNT-18793_to_2.5.x

rm-community/rm-community-repo/source/java/org/alfresco/module/org_alfresco_module_rm/job/DispositionLifecycleJobExecuter.java

@@ -42,6 +42,7 @@ import org.alfresco.service.cmr.repository.NodeRef;
 import org.alfresco.service.cmr.repository.NodeService;
 import org.alfresco.service.cmr.repository.StoreRef;
 import org.alfresco.service.cmr.search.ResultSet;
+import org.alfresco.service.cmr.search.SearchParameters;
 import org.alfresco.service.cmr.search.SearchService;
 import org.alfresco.service.cmr.security.PersonService;
 import org.apache.commons.logging.Log;
@@ -164,68 +165,32 @@ public class DispositionLifecycleJobExecuter extends RecordsManagementJobExecute
 
             if (dispositionActions != null && !dispositionActions.isEmpty())
             {
-                // execute search
+                boolean hasMore = true;
-                ResultSet results = searchService.query(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE,
+                int skipCount = 0;
-                            SearchService.LANGUAGE_FTS_ALFRESCO, getQuery());
+                while(hasMore)
-                List<NodeRef> resultNodes = results.getNodeRefs();
-                results.close();
-
-                if (logger.isDebugEnabled())
                 {
-                    logger.debug("Processing " + resultNodes.size() + " nodes");
+                    SearchParameters params = new SearchParameters();
-                }
+                    params.addStore(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE);
+                    params.setLanguage(SearchService.LANGUAGE_FTS_ALFRESCO);
+                    params.setQuery(getQuery());
+                    params.setSkipCount(skipCount);
 
-                // process search results
+                    // execute search
-                for (NodeRef node : resultNodes)
+                    ResultSet results = searchService.query(params);
-                {
+                    List<NodeRef> resultNodes = results.getNodeRefs();
-                    final NodeRef currentNode = node;
+                    hasMore = results.hasMore();
+                    skipCount += results.length();
+                    results.close();
 
-                    RetryingTransactionCallback<Boolean> processTranCB = new RetryingTransactionCallback<Boolean>()
+                    if (logger.isDebugEnabled())
                     {
-                        public Boolean execute()
+                        logger.debug("Processing " + resultNodes.size() + " nodes");
-                        {
+                    }
-                            final String dispAction = (String) nodeService.getProperty(currentNode,
-                                        RecordsManagementModel.PROP_DISPOSITION_ACTION);
 
-                            // Run disposition action
+                    // process search results
-                            if (dispAction != null && dispositionActions.contains(dispAction))
+                    for (NodeRef node : resultNodes)
-                            {
-                                ChildAssociationRef parent = nodeService.getPrimaryParent(currentNode);
-                                if (parent.getTypeQName().equals(RecordsManagementModel.ASSOC_NEXT_DISPOSITION_ACTION))
-                                {
-                                    Map<String, Serializable> props = new HashMap<String, Serializable>(1);
-                                    props.put(RMDispositionActionExecuterAbstractBase.PARAM_NO_ERROR_CHECK,
-                                                Boolean.FALSE);
-
-                                    try
-                                    {
-                                        // execute disposition action
-                                        recordsManagementActionService.executeRecordsManagementAction(
-                                                    parent.getParentRef(), dispAction, props);
-
-                                        if (logger.isDebugEnabled())
-                                        {
-                                            logger.debug("Processed action: " + dispAction + "on" + parent);
-                                        }
-                                    }
-                                    catch (AlfrescoRuntimeException exception)
-                                    {
-                                        if (logger.isDebugEnabled())
-                                        {
-                                            logger.debug(exception);
-                                        }
-                                    }
-                                }
-                            }
-
-                            return Boolean.TRUE;
-                        }
-                    };
-
-                    // if exists
-                    if (nodeService.exists(currentNode))
                     {
-                        retryingTransactionHelper.doInTransaction(processTranCB);
+                        executeAction(node);
                     }
                 }
             }
@@ -241,6 +206,62 @@ public class DispositionLifecycleJobExecuter extends RecordsManagementJobExecute
         }
     }
 
+    /**
+     * Helper method that executes a disposition action
+     *
+     * @param actionNode - the disposition action to execute
+     */
+    private void executeAction(final NodeRef actionNode)
+    {
+        RetryingTransactionCallback<Boolean> processTranCB = new RetryingTransactionCallback<Boolean>()
+        {
+            public Boolean execute()
+            {
+                final String dispAction = (String) nodeService.getProperty(actionNode,
+                            RecordsManagementModel.PROP_DISPOSITION_ACTION);
+
+                // Run disposition action
+                if (dispAction != null && dispositionActions.contains(dispAction))
+                {
+                    ChildAssociationRef parent = nodeService.getPrimaryParent(actionNode);
+                    if (parent.getTypeQName().equals(RecordsManagementModel.ASSOC_NEXT_DISPOSITION_ACTION))
+                    {
+                        Map<String, Serializable> props = new HashMap<String, Serializable>(1);
+                        props.put(RMDispositionActionExecuterAbstractBase.PARAM_NO_ERROR_CHECK,
+                                    Boolean.FALSE);
+
+                        try
+                        {
+                            // execute disposition action
+                            recordsManagementActionService.executeRecordsManagementAction(
+                                        parent.getParentRef(), dispAction, props);
+
+                            if (logger.isDebugEnabled())
+                            {
+                                logger.debug("Processed action: " + dispAction + "on" + parent);
+                            }
+                        }
+                        catch (AlfrescoRuntimeException exception)
+                        {
+                            if (logger.isDebugEnabled())
+                            {
+                                logger.debug(exception);
+                            }
+                        }
+                    }
+                }
+
+                return Boolean.TRUE;
+            }
+        };
+
+        // if exists
+        if (nodeService.exists(actionNode))
+        {
+            retryingTransactionHelper.doInTransaction(processTranCB);
+        }
+    }
+
     public PersonService getPersonService()
     {
         return personService;

rm-community/rm-community-repo/unit-test/java/org/alfresco/module/org_alfresco_module_rm/job/DispositionLifecycleJobExecuterUnitTest.java

@@ -29,6 +29,7 @@ package org.alfresco.module.org_alfresco_module_rm.job;
 
 import static org.alfresco.module.org_alfresco_module_rm.test.util.AlfMock.generateQName;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 import static org.mockito.Matchers.any;
 import static org.mockito.Matchers.anyMap;
 import static org.mockito.Matchers.anyString;
@@ -39,6 +40,7 @@ import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.when;
 
 import java.util.Collections;
 import java.util.List;
@@ -50,9 +52,11 @@ import org.alfresco.service.cmr.repository.ChildAssociationRef;
 import org.alfresco.service.cmr.repository.NodeRef;
 import org.alfresco.service.cmr.repository.StoreRef;
 import org.alfresco.service.cmr.search.ResultSet;
+import org.alfresco.service.cmr.search.SearchParameters;
 import org.alfresco.service.cmr.search.SearchService;
 import org.junit.Before;
 import org.junit.Test;
+import org.mockito.ArgumentCaptor;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 
@@ -92,7 +96,8 @@ public class DispositionLifecycleJobExecuterUnitTest extends BaseUnitTest
         executer.setDispositionActions(dispositionActions);
 
         // setup interactions
-        doReturn(mockedResultSet).when(mockedSearchService).query(eq(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE), eq(SearchService.LANGUAGE_FTS_ALFRESCO), anyString());
+        doReturn(mockedResultSet).when(mockedSearchService).query(any(SearchParameters.class));
+        when(mockedResultSet.hasMore()).thenReturn(false);
     }
 
     /**
@@ -100,7 +105,9 @@ public class DispositionLifecycleJobExecuterUnitTest extends BaseUnitTest
      */
     private void verifyQuery()
     {
-        verify(mockedSearchService, times(1)).query(eq(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE), eq(SearchService.LANGUAGE_FTS_ALFRESCO), contains(QUERY));
+        ArgumentCaptor<SearchParameters> paramsCaptor = ArgumentCaptor.forClass(SearchParameters.class);
+        verify(mockedSearchService, times(1)).query(paramsCaptor.capture());
+        assertTrue(paramsCaptor.getValue().getQuery().contains(QUERY));
         verify(mockedResultSet, times(1)).getNodeRefs();
         verify(mockedResultSet, times(1)).close();
     }