Merge release/V2.3 into RM-3386_ManauallySetDate.

rm-server/config/alfresco/module/org_alfresco_module_rm/rm-service-context.xml

@@ -39,12 +39,6 @@
 
     <bean id="RecordsManagementServiceRegistry" class="org.alfresco.module.org_alfresco_module_rm.RecordsManagementServiceRegistryImpl" />
 
-    <!-- Disposition selection strategy -->
-    <bean id="org_alfresco_module_rm_dispositionSelectionStrategy"
-          class="org.alfresco.module.org_alfresco_module_rm.disposition.DispositionSelectionStrategy" >
-        <property name="dispositionService" ref="dispositionService"/>
-    </bean>
-
     <!--  Vital Record Service -->
 
     <bean id="vitalRecordService" parent="baseService" class="org.alfresco.module.org_alfresco_module_rm.vital.VitalRecordServiceImpl">
@@ -96,9 +90,6 @@
         <property name="recordFolderService" ref="RecordFolderService"/>
         <property name="recordService" ref="RecordService"/>
         <property name="freezeService" ref="FreezeService"/>
-        <property name="dispositionSelectionStrategy">
-           <ref local="org_alfresco_module_rm_dispositionSelectionStrategy" />
-        </property>
     </bean>
 
     <bean id="DispositionService" class="org.springframework.aop.framework.ProxyFactoryBean">
@@ -139,6 +130,7 @@
                 org.alfresco.module.org_alfresco_module_rm.disposition.DispositionService.registerDispositionProperty=RM_ALLOW
                 org.alfresco.module.org_alfresco_module_rm.disposition.DispositionService.getDispositionProperties=RM_ALLOW
                 org.alfresco.module.org_alfresco_module_rm.disposition.DispositionService.getDispositionSchedule=RM.Read.0
+                org.alfresco.module.org_alfresco_module_rm.disposition.DispositionService.getOriginDispositionSchedule=RM.Read.0
                 org.alfresco.module.org_alfresco_module_rm.disposition.DispositionService.getAssociatedDispositionSchedule=RM.Read.0
                 org.alfresco.module.org_alfresco_module_rm.disposition.DispositionService.getAssociatedRecordsManagementContainer=RM_ALLOW
                 org.alfresco.module.org_alfresco_module_rm.disposition.DispositionService.hasDisposableItems=RM_ALLOW

rm-server/pom.xml

@@ -20,6 +20,12 @@
          <resource>
             <directory>config</directory>
             <filtering>true</filtering>
+             <includes>
+                <include>**/module.properties</include>
+             </includes>
+         </resource>
+         <resource>
+            <directory>config</directory>
          </resource>
       </resources>
       <testResources>

rm-server/source/java/org/alfresco/module/org_alfresco_module_rm/action/impl/EditDispositionActionAsOfDateAction.java

@@ -38,6 +38,9 @@ public class EditDispositionActionAsOfDateAction extends RMActionExecuterAbstrac
     private static final String MSG_VALID_DATE_DISP_ASOF = "rm.action.valid-date-disp-asof";
     private static final String MSG_DISP_ASOF_LIFECYCLE_APPLIED = "rm.action.disp-asof-lifecycle-applied";
 
+    /** Action name */
+    public static final String NAME = "editDispositionActionAsOfDate";
+    
     /** Action parameters */
     public static final String PARAM_AS_OF_DATE = "asOfDate";
 

rm-server/source/java/org/alfresco/module/org_alfresco_module_rm/disposition/DispositionSelectionStrategy.java

@@ -1,199 +0,0 @@
-/*
- * Copyright (C) 2005-2014 Alfresco Software Limited.
- *
- * This file is part of Alfresco
- *
- * Alfresco is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Alfresco is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
- */
-package org.alfresco.module.org_alfresco_module_rm.disposition;
-
-import java.util.Comparator;
-import java.util.Date;
-import java.util.List;
-import java.util.SortedSet;
-import java.util.TreeSet;
-
-import org.alfresco.module.org_alfresco_module_rm.model.RecordsManagementModel;
-import org.alfresco.repo.security.authentication.AuthenticationUtil;
-import org.alfresco.repo.security.authentication.AuthenticationUtil.RunAsWork;
-import org.alfresco.service.cmr.repository.NodeRef;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-
-/**
- * This class offers the default implementation of a strategy for selection of
- * disposition schedule for a record when there is more than one which is applicable.
- * An example of where this strategy might be used would be in the case of a record
- * which was multiply filed.
- *
- * @author neilm
- */
-public class DispositionSelectionStrategy implements RecordsManagementModel
-{
-    /** Logger */
-    private static Log logger = LogFactory.getLog(DispositionSelectionStrategy.class);
-
-    /** Disposition service */
-    private DispositionService dispositionService;
-
-    /**
-     * Set the disposition service
-     *
-     * @param dispositionService    disposition service
-     */
-    public void setDispositionService(DispositionService dispositionService)
-    {
-        this.dispositionService = dispositionService;
-    }
-
-    /**
-     * Select the disposition schedule to use given there is more than one
-     *
-     * @param recordFolders
-     * @return
-     */
-    public NodeRef selectDispositionScheduleFrom(List<NodeRef> recordFolders)
-    {
-        if (recordFolders == null || recordFolders.isEmpty())
-        {
-            return null;
-        }
-        else
-        {
-            //      46 CHAPTER 2
-            //      Records assigned more than 1 disposition must be retained and linked to the record folder (category) with the longest
-            //      retention period.
-
-            // Assumption: an event-based disposition action has a longer retention
-            // period than a time-based one - as we cannot know when an event will occur
-            // TODO Automatic events?
-
-        	NodeRef recordFolder = null;
-        	if (recordFolders.size() == 1)
-        	{
-        		recordFolder = recordFolders.get(0);
-        	}
-        	else
-        	{
-	            SortedSet<NodeRef> sortedFolders = new TreeSet<NodeRef>(new DispositionableNodeRefComparator());
-	            sortedFolders.addAll(recordFolders);
-	            recordFolder = sortedFolders.first();
-        	}
-
-            DispositionSchedule dispSchedule = dispositionService.getDispositionSchedule(recordFolder);
-
-            if (logger.isDebugEnabled())
-            {
-                logger.debug("Selected disposition schedule: " + dispSchedule);
-            }
-
-            NodeRef result = null;
-            if (dispSchedule != null)
-            {
-                result = dispSchedule.getNodeRef();
-            }
-            return result;
-        }
-    }
-
-    /**
-     * This class defines a natural comparison order between NodeRefs that have
-     * the dispositionLifecycle aspect applied.
-     * This order has the following meaning: NodeRefs with a 'lesser' value are considered
-     * to have a shorter retention period, although the actual retention period may
-     * not be straightforwardly determined in all cases.
-     */
-    class DispositionableNodeRefComparator implements Comparator<NodeRef>
-    {
-        public int compare(final NodeRef f1, final NodeRef f2)
-        {
-            // Run as admin user
-            return AuthenticationUtil.runAs(new RunAsWork<Integer>()
-            {
-                public Integer doWork()
-                {
-                    return compareImpl(f1, f2);
-                }
-            }, AuthenticationUtil.getAdminUserName());
-        }
-
-        private int compareImpl(NodeRef f1, NodeRef f2)
-        {
-            // quick check to see if the node references are the same
-            if (f1.equals(f2))
-            {
-                return 0;
-            }
-
-            // get the disposition schedules for the folders
-            DispositionSchedule ds1 = dispositionService.getDispositionSchedule(f1);
-            DispositionSchedule ds2 = dispositionService.getDispositionSchedule(f2);
-
-            // make sure each folder has a disposition schedule
-            if (ds1 == null && ds2 != null)
-            {
-                return 1;
-            }
-            else if (ds1 != null && ds2 == null)
-            {
-                return -1;
-            }
-            else if (ds1 == null && ds2 == null)
-            {
-                return 0;
-            }
-
-            // TODO this won't work correctly if we are trying to compare schedules that are record based!!
-            DispositionAction da1 = dispositionService.getNextDispositionAction(f1);
-            DispositionAction da2 = dispositionService.getNextDispositionAction(f2);
-
-            if (da1 != null && da2 != null)
-            {
-                Date asOfDate1 = da1.getAsOfDate();
-                Date asOfDate2 = da2.getAsOfDate();
-                // If both record(Folder)s have asOfDates, then use these to compare
-                if (asOfDate1 != null && asOfDate2 != null)
-                {
-                    return asOfDate1.compareTo(asOfDate2);
-                }
-                // If one has a date and the other doesn't, the one with the date is "less".
-                // (Defined date is 'shorter' than undefined date as an undefined date means it may be retained forever - theoretically)
-                else if (asOfDate1 != null || asOfDate2 != null)
-                {
-                    return asOfDate1 == null ? +1 : -1;
-                }
-                else
-                {
-                    // Neither has an asOfDate. (Somewhat arbitrarily) we'll use the number of events to compare now.
-                    DispositionActionDefinition dad1 = da1.getDispositionActionDefinition();
-                    DispositionActionDefinition dad2 = da2.getDispositionActionDefinition();
-                    int eventsCount1 = 0;
-                    int eventsCount2 = 0;
-
-                    if (dad1 != null)
-                    {
-                        eventsCount1 = dad1.getEvents().size();
-                    }
-                    if (dad2 != null)
-                    {
-                        eventsCount2 = dad2.getEvents().size();
-                    }
-                    return Integer.valueOf(eventsCount1).compareTo(eventsCount2);
-                }
-            }
-
-            return 0;
-        }
-    }
-}

rm-server/source/java/org/alfresco/module/org_alfresco_module_rm/disposition/DispositionService.java

@@ -234,6 +234,17 @@ public interface DispositionService
      */
     void refreshDispositionAction(NodeRef nodeRef);
     
+    /**
+     * Gets date of the disposition action for the given 
+     * disposition schedule with the given action name
+     * 
+     * @param record
+     * @param dispositionSchedule nodeRef
+     * @param dispositionActionName
+     * @return date
+     */
+    Date getDispositionActionDate(NodeRef record, NodeRef dispositionSchedule, String dispositionActionName);
+
     /**
      * Compute the "disposition as of" date (if necessary) for a disposition action and a node.
      *
@@ -244,4 +255,13 @@ public interface DispositionService
      */
     Date calculateAsOfDate(NodeRef nodeRef, DispositionActionDefinition dispositionActionDefinition,
                 boolean allowContextFromAsOf);
+    
+    /**
+     * Gets the origin disposition schedule for the record, not the calculated one
+     * in case of multiple dispositions applied to record
+     * 
+     * @param nodeRef record 
+     * @return the initial disposition
+     */
+    DispositionSchedule getOriginDispositionSchedule(NodeRef nodeRef);
 }

rm-server/source/java/org/alfresco/module/org_alfresco_module_rm/disposition/DispositionServiceImpl.java

@@ -27,6 +27,7 @@ import java.util.List;
 import java.util.Map;
 
 import org.alfresco.error.AlfrescoRuntimeException;
+import org.alfresco.model.ContentModel;
 import org.alfresco.module.org_alfresco_module_rm.RecordsManagementPolicies;
 import org.alfresco.module.org_alfresco_module_rm.RecordsManagementServiceRegistry;
 import org.alfresco.module.org_alfresco_module_rm.disposition.property.DispositionProperty;
@@ -38,6 +39,7 @@ import org.alfresco.module.org_alfresco_module_rm.model.RecordsManagementModel;
 import org.alfresco.module.org_alfresco_module_rm.record.RecordService;
 import org.alfresco.module.org_alfresco_module_rm.recordfolder.RecordFolderService;
 import org.alfresco.module.org_alfresco_module_rm.util.ServiceBaseImpl;
+import org.alfresco.repo.dictionary.types.period.Immediately;
 import org.alfresco.repo.policy.BehaviourFilter;
 import org.alfresco.repo.policy.annotation.Behaviour;
 import org.alfresco.repo.policy.annotation.BehaviourBean;
@@ -70,15 +72,26 @@ public class DispositionServiceImpl extends    ServiceBaseImpl
     /** Logger */
     private static final Logger LOGGER = LoggerFactory.getLogger(DispositionServiceImpl.class);
 
+    /** Transaction mode for setting next action */
+    public enum WriteMode
+    {
+        /** Do not update any data. */
+        READ_ONLY,
+        /** Only set the "disposition as of" date. */
+        DATE_ONLY,
+        /**
+         * Set the "disposition as of" date and the name of the next action. This only happens during the creation of a
+         * disposition schedule impl node under a record or folder.
+         */
+        DATE_AND_NAME
+    };
+
     /** Behaviour filter */
     private BehaviourFilter behaviourFilter;
 
     /** Records management service registry */
     private RecordsManagementServiceRegistry serviceRegistry;
 
-    /** Disposition selection strategy */
-    private DispositionSelectionStrategy dispositionSelectionStrategy;
-
     /** File plan service */
     private FilePlanService filePlanService;
 
@@ -168,16 +181,6 @@ public class DispositionServiceImpl extends    ServiceBaseImpl
         this.freezeService = freezeService;
     }
 
-    /**
-     * Set the dispositionSelectionStrategy bean.
-     *
-     * @param dispositionSelectionStrategy
-     */
-    public void setDispositionSelectionStrategy(DispositionSelectionStrategy dispositionSelectionStrategy)
-    {
-        this.dispositionSelectionStrategy = dispositionSelectionStrategy;
-    }
-
     /**
      * Behavior to initialize the disposition schedule of a newly filed record.
      *
@@ -267,31 +270,56 @@ public class DispositionServiceImpl extends    ServiceBaseImpl
      * @see org.alfresco.module.org_alfresco_module_rm.disposition.DispositionService#getDispositionSchedule(org.alfresco.service.cmr.repository.NodeRef)
      */
     @Override
-    public DispositionSchedule getDispositionSchedule(NodeRef nodeRef)
+    public DispositionSchedule getDispositionSchedule(final NodeRef nodeRef)
     {
-        DispositionSchedule di = null;
+        DispositionSchedule ds = null;
-        NodeRef diNodeRef = null;
+        NodeRef dsNodeRef = null;
         if (isRecord(nodeRef))
         {
-            // Get the record folders for the record
+            final NextActionFromDisposition dsNextAction = getDispositionActionByNameForRecord(nodeRef);
-            List<NodeRef> recordFolders = recordFolderService.getRecordFolders(nodeRef);
+
-            // At this point, we may have disposition instruction objects from 1..n folders.
+            if (dsNextAction != null)
-            diNodeRef = dispositionSelectionStrategy.selectDispositionScheduleFrom(recordFolders);
+            {
+                if (!dsNextAction.getWriteMode().equals(WriteMode.READ_ONLY))
+                {
+                    final NodeRef action = dsNextAction.getNextActionNodeRef();
+                    final String dispositionActionName = dsNextAction.getNextActionName();
+                    final Date dispositionActionDate = dsNextAction.getNextActionDateAsOf();
+
+                    AuthenticationUtil.runAsSystem(new RunAsWork<Void>()
+                    {
+                        @Override
+                        public Void doWork()
+                        {
+                            nodeService.setProperty(action, PROP_DISPOSITION_AS_OF, dispositionActionDate);
+                            if (dsNextAction.getWriteMode().equals(WriteMode.DATE_AND_NAME))
+                            {
+                                nodeService.setProperty(action, PROP_DISPOSITION_ACTION_NAME, dispositionActionName);
+                            }
+                            return null;
+                        }
+                    });
+                }
+                dsNodeRef = dsNextAction.getDispositionNodeRef();
+            }
         }
         else
         {
             // Get the disposition instructions for the node reference provided
-            diNodeRef = getDispositionScheduleImpl(nodeRef);
+            dsNodeRef = getDispositionScheduleImpl(nodeRef);
         }
 
-        if (diNodeRef != null)
+        if (dsNodeRef != null)
         {
-            di = new DispositionScheduleImpl(serviceRegistry, nodeService, diNodeRef);
+            ds = new DispositionScheduleImpl(serviceRegistry, nodeService, dsNodeRef);
         }
 
-        return di;
+        return ds;
     }
 
+
+
+
     /**
      * This method returns a NodeRef
      * Gets the disposition instructions
@@ -314,6 +342,28 @@ public class DispositionServiceImpl extends    ServiceBaseImpl
         return result;
     }
     
+    public DispositionSchedule getOriginDispositionSchedule(NodeRef nodeRef)
+    {
+        NodeRef parent = this.nodeService.getPrimaryParent(nodeRef).getParentRef();
+        if (parent != null)
+        {
+            if (filePlanService.isRecordCategory(parent)) 
+            {
+                NodeRef result = getAssociatedDispositionScheduleImpl(parent);
+                if (result == null)
+                {
+                    return null;
+                }
+                return new DispositionScheduleImpl(serviceRegistry, nodeService, result);
+            }
+            else
+            {
+                return getOriginDispositionSchedule(parent);
+            }
+        } 
+        return null;
+    }
+
     /**
      * @see org.alfresco.module.org_alfresco_module_rm.disposition.DispositionService#getAssociatedDispositionSchedule(org.alfresco.service.cmr.repository.NodeRef)
      */
@@ -620,8 +670,14 @@ public class DispositionServiceImpl extends    ServiceBaseImpl
      *  @param dispositionActionDefinition disposition action definition
      *  @param allowContextFromAsOf true if the context date is allowed to be obtained from the disposition "as of" property.
      */
-    private void initialiseDispositionAction(NodeRef nodeRef, DispositionActionDefinition dispositionActionDefinition, boolean allowContextFromAsOf)
+    private DispositionAction initialiseDispositionAction(NodeRef nodeRef, DispositionActionDefinition dispositionActionDefinition, boolean allowContextFromAsOf)
     {
+        List<ChildAssociationRef> childAssocs = nodeService.getChildAssocs(nodeRef, ASSOC_NEXT_DISPOSITION_ACTION, ASSOC_NEXT_DISPOSITION_ACTION, 1, true);
+        if (childAssocs != null && childAssocs.size() > 0)
+        {
+            return new DispositionActionImpl(serviceRegistry, childAssocs.get(0).getChildRef());
+        }
+
         // Create the properties
         Map<QName, Serializable> props = new HashMap<QName, Serializable>(10);
 
@@ -651,6 +707,7 @@ public class DispositionServiceImpl extends    ServiceBaseImpl
             // For every event create an entry on the action
             da.addEventCompletionDetails(event);
         }
+        return da;
     }
 
     /**
@@ -682,11 +739,18 @@ public class DispositionServiceImpl extends    ServiceBaseImpl
                 contextDate = (Date)this.nodeService.getProperty(nodeRef, periodProperty);
             }
             else
+            {
+                if (period.getPeriodType().equals(Immediately.PERIOD_TYPE))
+                {
+                    contextDate = (Date)nodeService.getProperty(nodeRef, ContentModel.PROP_CREATED);
+                }
+                else
                 {
                     // for now use 'NOW' as the default context date
                     // TODO set the default period property ... cut off date or last disposition date depending on context
                     contextDate = new Date();
                 }
+            }
 
             // Calculate the as of date
             if (contextDate != null)
@@ -897,6 +961,14 @@ public class DispositionServiceImpl extends    ServiceBaseImpl
                         String currentADId = (String) nodeService.getProperty(currentDispositionAction, PROP_DISPOSITION_ACTION_ID);
                         currentDispositionActionDefinition = di.getDispositionActionDefinition(currentADId);
 
+                        // When the record has multiple disposition schedules the current disposition action may not be found by id
+                        // In this case it will be searched by name
+                        if(currentDispositionActionDefinition == null)
+                        {
+                            String currentADName = (String) nodeService.getProperty(currentDispositionAction, PROP_DISPOSITION_ACTION);
+                            currentDispositionActionDefinition = di.getDispositionActionDefinitionByName(currentADName);
+                        }
+
                         // Get the next disposition action
                         int index = currentDispositionActionDefinition.getIndex();
                         index++;
@@ -983,6 +1055,24 @@ public class DispositionServiceImpl extends    ServiceBaseImpl
         }
     }
 
+    public Date getDispositionActionDate(NodeRef record, NodeRef dispositionSchedule, String dispositionActionName)
+    {
+        DispositionSchedule ds = new DispositionScheduleImpl(serviceRegistry, nodeService, dispositionSchedule);
+        List<ChildAssociationRef> assocs = nodeService.getChildAssocs(dispositionSchedule);
+        if (assocs != null && assocs.size() > 0)
+        {
+            for (ChildAssociationRef assoc : assocs)
+            {
+                if (assoc != null && assoc.getQName().getLocalName().contains(dispositionActionName))
+                {
+                    DispositionActionDefinition actionDefinition = ds.getDispositionActionDefinition(assoc.getChildRef().getId());
+                    return calculateAsOfDate(record, actionDefinition, true);
+                }
+            }
+        }
+        return null;
+    }
+
     /**
      * Helper method to determine if a node is frozen or has frozen children
      *
@@ -1030,4 +1120,162 @@ public class DispositionServiceImpl extends    ServiceBaseImpl
             }
         });
     }
+
+
+
+   /**
+    * Calculate next disposition action for a record
+    *
+    * @param record
+    * @return next disposition action (name, date) and the disposition associated
+    */
+
+    protected NextActionFromDisposition getDispositionActionByNameForRecord(NodeRef record)
+    {
+        List<NodeRef> recordFolders = recordFolderService.getRecordFolders(record);
+        DispositionAction nextDispositionAction = getNextDispositionAction(record);
+
+        if (nextDispositionAction == null)
+        {
+            return getFirstDispositionAction(record, recordFolders);
+        }
+        else
+        {
+            return getNextDispositionAction(record, recordFolders, nextDispositionAction);
+        }
+    }
+
+    /**
+     * Calculate next disposition action when the record already has one
+     * @param recordFolders
+     * @param nextDispositionAction
+     * @return next disposition action and the associated disposition schedule
+     */
+    private NextActionFromDisposition getNextDispositionAction(NodeRef record, List<NodeRef> recordFolders, DispositionAction nextDispositionAction)
+    {
+        String recordNextDispositionActionName = nextDispositionAction.getName();
+        Date recordNextDispositionActionDate = nextDispositionAction.getAsOfDate();
+        // We're looking for the latest date, so initially start with a very early one.
+        Date nextDispositionActionDate = new Date(Long.MIN_VALUE);
+        NodeRef dispositionNodeRef = null;
+
+        // Find the latest "disposition as of" date from all the schedules this record is subject to.
+        for (NodeRef folder : recordFolders)
+        {
+            NodeRef dsNodeRef = getDispositionScheduleImpl(folder);
+            if (dsNodeRef != null)
+            {
+                Date dispActionDate = getDispositionActionDate(record, dsNodeRef, recordNextDispositionActionName);
+                if (dispActionDate == null || (nextDispositionActionDate != null
+                                && nextDispositionActionDate.before(dispActionDate)))
+                {
+                    nextDispositionActionDate = dispActionDate;
+                    dispositionNodeRef = dsNodeRef;
+                    if (dispActionDate == null)
+                    {
+                        // Treat null as the latest date possible (so stop searching further).
+                        break;
+                    }
+                }
+            }
+        }
+        if (dispositionNodeRef == null)
+        {
+           return null;
+        }
+        WriteMode mode = determineWriteMode(recordNextDispositionActionDate, nextDispositionActionDate);
+
+        return new NextActionFromDisposition(dispositionNodeRef, nextDispositionAction.getNodeRef(),
+                recordNextDispositionActionName, nextDispositionActionDate, mode);
+    }
+
+    /**
+     * Determine what should be updated for an existing disposition schedule impl. We only update the date if the
+     * existing date is earlier than the calculated one.
+     *
+     * @param recordNextDispositionActionDate The next action date found on the record node (or folder node).
+     * @param nextDispositionActionDate The next action date calculated from the current disposition schedule(s)
+     *            affecting the node.
+     * @return READ_ONLY if nothing should be updated, or DATE_ONLY if the date needs updating.
+     */
+    private WriteMode determineWriteMode(Date recordNextDispositionActionDate, Date nextDispositionActionDate)
+    {
+        // Treat null dates as being the latest possible date.
+        Date maxDate = new Date(Long.MAX_VALUE);
+        Date recordDate = (recordNextDispositionActionDate != null ? recordNextDispositionActionDate : maxDate);
+        Date calculatedDate = (nextDispositionActionDate != null ? nextDispositionActionDate : maxDate);
+
+        // We only need to update the date if the current one is too early.
+        if (recordDate.before(calculatedDate))
+        {
+            return WriteMode.DATE_ONLY;
+        }
+        else
+        {
+            return WriteMode.READ_ONLY;
+        }
+    }
+
+    /**
+     * Calculate first disposition action when the record doesn't have one
+     * @param recordFolders
+     * @return next disposition action and the associated disposition schedule
+     */
+    private NextActionFromDisposition getFirstDispositionAction(NodeRef record, List<NodeRef> recordFolders)
+    {
+        NodeRef newAction = null;
+        String newDispositionActionName = null;
+        // We're looking for the latest date, so start with a very early one.
+        Date newDispositionActionDateAsOf = new Date(Long.MIN_VALUE);
+        NodeRef dispositionNodeRef = null;
+        for (NodeRef folder : recordFolders)
+        {
+            NodeRef folderDS = getDispositionScheduleImpl(folder);
+            if (folderDS != null)
+            {
+                DispositionSchedule ds = new DispositionScheduleImpl(serviceRegistry, nodeService, folderDS);
+                List<DispositionActionDefinition> dispositionActionDefinitions = ds.getDispositionActionDefinitions();
+
+                if (dispositionActionDefinitions != null && dispositionActionDefinitions.size() > 0)
+                {
+                    DispositionActionDefinition firstDispositionActionDef = dispositionActionDefinitions.get(0);
+                    dispositionNodeRef = folderDS;
+
+                    if (newAction == null)
+                    {
+                        NodeRef recordOrFolder = record;
+                        if (!ds.isRecordLevelDisposition()) 
+                        {
+                            recordOrFolder = folder;
+                        }
+                        DispositionAction firstDispositionAction = initialiseDispositionAction(recordOrFolder, firstDispositionActionDef, true);
+                        newAction = firstDispositionAction.getNodeRef();
+                        newDispositionActionName = (String)nodeService.getProperty(newAction, PROP_DISPOSITION_ACTION_NAME);
+                        newDispositionActionDateAsOf = firstDispositionAction.getAsOfDate();
+                    }
+                    else if (firstDispositionActionDef.getPeriod() != null)
+                    {
+                        Date firstActionDate = calculateAsOfDate(record, firstDispositionActionDef, true);
+                        if (firstActionDate == null || (newDispositionActionDateAsOf != null
+                                        && newDispositionActionDateAsOf.before(firstActionDate)))
+                        {
+                            newDispositionActionName = firstDispositionActionDef.getName();
+                            newDispositionActionDateAsOf = firstActionDate;
+                            if (firstActionDate == null)
+                            {
+                                // Treat null as the latest date possible, so there's no point searching further.
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if (newDispositionActionName == null || dispositionNodeRef == null || newAction == null)
+        {
+            return null;
+        }
+        return new NextActionFromDisposition(dispositionNodeRef, newAction,
+                newDispositionActionName, newDispositionActionDateAsOf, WriteMode.DATE_AND_NAME);
+    }
 }

rm-server/source/java/org/alfresco/module/org_alfresco_module_rm/disposition/NextActionFromDisposition.java

@@ -0,0 +1,80 @@
+package org.alfresco.module.org_alfresco_module_rm.disposition;
+
+import java.util.Date;
+
+import org.alfresco.module.org_alfresco_module_rm.disposition.DispositionServiceImpl.WriteMode;
+import org.alfresco.service.cmr.repository.NodeRef;
+
+public class NextActionFromDisposition
+{
+    public NextActionFromDisposition(NodeRef dispositionNodeRef, NodeRef nextActionNodeRef, String nextActionName, Date nextActionDateAsOf,
+            WriteMode writeMode)
+    {
+        super();
+        this.dispositionNodeRef = dispositionNodeRef;
+        this.nextActionNodeRef = nextActionNodeRef;
+        this.nextActionName = nextActionName;
+        this.nextActionDateAsOf = nextActionDateAsOf;
+        this.writeMode = writeMode;
+    }
+
+    private NodeRef dispositionNodeRef;
+
+    private NodeRef nextActionNodeRef;
+
+    private String nextActionName;
+
+    private Date nextActionDateAsOf;
+
+    private WriteMode writeMode;
+
+    public WriteMode getWriteMode()
+    {
+        return writeMode;
+    }
+
+    public void setWriteMode(WriteMode writeMode)
+    {
+        this.writeMode = writeMode;
+    }
+
+    public NodeRef getNextActionNodeRef()
+    {
+        return nextActionNodeRef;
+    }
+
+    public void setNextActionNodeRef(NodeRef nextActionNodeRef)
+    {
+        this.nextActionNodeRef = nextActionNodeRef;
+    }
+
+    public NodeRef getDispositionNodeRef()
+    {
+        return dispositionNodeRef;
+    }
+
+    public void setDispositionNodeRef(NodeRef dispositionNodeRef)
+    {
+        this.dispositionNodeRef = dispositionNodeRef;
+    }
+
+    public String getNextActionName()
+    {
+        return nextActionName;
+    }
+
+    public void setNextActionName(String nextActionName)
+    {
+        this.nextActionName = nextActionName;
+    }
+
+    public Date getNextActionDateAsOf()
+    {
+        return nextActionDateAsOf;
+    }
+
+    public void setNextActionDateAsOf(Date nextActionDateAsOf)
+    {
+        this.nextActionDateAsOf = nextActionDateAsOf;
+    }
+}

rm-server/source/java/org/alfresco/module/org_alfresco_module_rm/record/RecordServiceImpl.java

@@ -34,12 +34,14 @@ import java.util.Set;
 
 import org.alfresco.error.AlfrescoRuntimeException;
 import org.alfresco.model.ContentModel;
+import org.alfresco.module.org_alfresco_module_rm.RecordsManagementServiceRegistry;
 import org.alfresco.module.org_alfresco_module_rm.RecordsManagementPolicies.BeforeFileRecord;
 import org.alfresco.module.org_alfresco_module_rm.RecordsManagementPolicies.OnFileRecord;
 import org.alfresco.module.org_alfresco_module_rm.capability.Capability;
 import org.alfresco.module.org_alfresco_module_rm.capability.CapabilityService;
 import org.alfresco.module.org_alfresco_module_rm.capability.RMPermissionModel;
 import org.alfresco.module.org_alfresco_module_rm.disposition.DispositionSchedule;
+import org.alfresco.module.org_alfresco_module_rm.disposition.DispositionScheduleImpl;
 import org.alfresco.module.org_alfresco_module_rm.disposition.DispositionService;
 import org.alfresco.module.org_alfresco_module_rm.dod5015.DOD5015Model;
 import org.alfresco.module.org_alfresco_module_rm.fileplan.FilePlanService;
@@ -1732,7 +1734,10 @@ public class RecordServiceImpl extends BaseBehaviourBean
     private void validateLinkConditions(NodeRef record, NodeRef recordFolder)
     {
         // ensure that the linking record folders have compatible disposition schedules
-        DispositionSchedule recordDispositionSchedule = dispositionService.getDispositionSchedule(record);
+        
+        // get the origin disposition schedule for the record, not the calculated one
+        DispositionSchedule recordDispositionSchedule = dispositionService.getOriginDispositionSchedule(record);
+                
         if (recordDispositionSchedule != null)
         {
             DispositionSchedule recordFolderDispositionSchedule = dispositionService.getDispositionSchedule(recordFolder);

rm-server/test/java/org/alfresco/module/org_alfresco_module_rm/test/integration/disposition/DispositionTestSuite.java

@@ -32,7 +32,8 @@ import org.junit.runners.Suite.SuiteClasses;
 @SuiteClasses(
 {
     CutOffTest.class,
-    UpdateDispositionScheduleTest.class
+    UpdateDispositionScheduleTest.class,
+    UpdateNextDispositionActionTest.class
 })
 public class DispositionTestSuite
 {

rm-server/test/java/org/alfresco/module/org_alfresco_module_rm/test/integration/disposition/UpdateNextDispositionActionTest.java

@@ -0,0 +1,136 @@
+/*
+ * Copyright (C) 2005-2014 Alfresco Software Limited.
+ *
+ * This file is part of Alfresco
+ *
+ * Alfresco is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Alfresco is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.alfresco.module.org_alfresco_module_rm.test.integration.disposition;
+
+import static org.alfresco.module.org_alfresco_module_rm.test.util.CommonRMTestUtils.DEFAULT_DISPOSITION_DESCRIPTION;
+import static org.alfresco.module.org_alfresco_module_rm.test.util.CommonRMTestUtils.DEFAULT_DISPOSITION_INSTRUCTIONS;
+import static org.alfresco.module.org_alfresco_module_rm.test.util.CommonRMTestUtils.DEFAULT_EVENT_NAME;
+import static org.alfresco.module.org_alfresco_module_rm.test.util.CommonRMTestUtils.PERIOD_ONE_WEEK;
+import static org.alfresco.util.GUID.generate;
+
+import java.io.Serializable;
+import java.util.Collections;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.alfresco.module.org_alfresco_module_rm.action.impl.CutOffAction;
+import org.alfresco.module.org_alfresco_module_rm.action.impl.DestroyAction;
+import org.alfresco.module.org_alfresco_module_rm.action.impl.EditDispositionActionAsOfDateAction;
+import org.alfresco.module.org_alfresco_module_rm.action.impl.TransferAction;
+import org.alfresco.module.org_alfresco_module_rm.disposition.DispositionSchedule;
+import org.alfresco.module.org_alfresco_module_rm.test.util.BaseRMTestCase;
+import org.alfresco.module.org_alfresco_module_rm.test.util.CommonRMTestUtils;
+import org.alfresco.service.cmr.repository.NodeRef;
+import org.alfresco.service.namespace.QName;
+
+/**
+* Update next disposition step integration tests.
+*
+* @author Roxana Lucanu
+* @since 2.3.1
+*/
+public class UpdateNextDispositionActionTest extends BaseRMTestCase
+{
+    /**
+     * Given a record with multiple dispositions
+     * When updating the next step
+     * Then the action is available
+     * <p>
+     * relates to https://issues.alfresco.com/jira/browse/RM-3060
+     */
+    public void testUpdateNextDispositionAction_RM3060() throws Exception
+    {
+        doBehaviourDrivenTest(new BehaviourDrivenTest()
+        {
+            NodeRef record;
+            NodeRef folder2;
+
+            @Override
+            public void given()
+            {
+                // create category1
+                NodeRef category1 = filePlanService.createRecordCategory(filePlan, generate());
+
+                // create disposition schedule for category1
+                createDispositionSchedule(category1);
+
+                // create category2
+                NodeRef category2 = filePlanService.createRecordCategory(filePlan, generate());
+
+                // create disposition schedule for category2
+                createDispositionSchedule(category2);
+
+                // create folder2 inside category2
+                folder2 = recordFolderService.createRecordFolder(category2, generate());
+
+                // create folder1 inside category1
+                NodeRef folder1 = recordFolderService.createRecordFolder(category1, generate());
+
+                // create record inside folder1
+                record = utils.createRecord(folder1, generate(), generate());
+
+            }
+            @Override
+            public void when() throws Exception
+            {
+                // link the record to folder2
+                recordService.link(record, folder2);
+
+                // complete record
+                utils.completeRecord(record);
+
+                // cut off
+                rmActionService.executeRecordsManagementAction(record, CutOffAction.NAME, null); 
+            }
+
+            @Override
+            public void then() throws Exception
+            {
+                assertTrue("Record " + record + " doesn't have the cutOff aspect.", nodeService.hasAspect(record, ASPECT_CUT_OFF));
+            }
+        });
+    }
+
+    private void createDispositionSchedule(NodeRef category)
+    {
+        DispositionSchedule ds = utils.createDispositionSchedule(category, DEFAULT_DISPOSITION_INSTRUCTIONS, DEFAULT_DISPOSITION_DESCRIPTION, true, false, false);
+
+        // create the properties for CUTOFF action and add it to the disposition action definition
+        Map<QName, Serializable> cutOff = new HashMap<QName, Serializable>(3);
+        cutOff.put(PROP_DISPOSITION_ACTION_NAME, CutOffAction.NAME);
+        cutOff.put(PROP_DISPOSITION_DESCRIPTION, generate());
+        cutOff.put(PROP_DISPOSITION_PERIOD, CommonRMTestUtils.PERIOD_IMMEDIATELY);
+        dispositionService.addDispositionActionDefinition(ds, cutOff);
+
+        // create the properties for TRANSFER action and add it to the disposition action definition
+        Map<QName, Serializable> transfer = new HashMap<QName, Serializable>(3);
+        transfer.put(PROP_DISPOSITION_ACTION_NAME, TransferAction.NAME);
+        transfer.put(PROP_DISPOSITION_DESCRIPTION, generate());
+        transfer.put(PROP_DISPOSITION_EVENT, (Serializable)Collections.singletonList(DEFAULT_EVENT_NAME));
+        dispositionService.addDispositionActionDefinition(ds, transfer);
+
+        // create the properties for DESTROY action and add it to the disposition action definition
+        Map<QName, Serializable> destroy = new HashMap<QName, Serializable>(3);
+        destroy.put(PROP_DISPOSITION_ACTION_NAME, DestroyAction.NAME);
+        destroy.put(PROP_DISPOSITION_DESCRIPTION, generate());
+        destroy.put(PROP_DISPOSITION_PERIOD, PERIOD_ONE_WEEK);
+        dispositionService.addDispositionActionDefinition(ds, destroy);
+    }
+}

rm-server/test/java/org/alfresco/module/org_alfresco_module_rm/test/legacy/service/DispositionServiceImplTest.java

@@ -657,7 +657,7 @@ public class DispositionServiceImplTest extends BaseRMTestCase
                 checkDisposableItemChanged(mhRecordFolder42);
                 checkDisposableItemChanged(record43);
                 checkDisposableItemUnchanged(mhRecordFolder44);
-                checkDisposableItemUnchanged(record45);;
+                checkDisposableItemUnchanged(record45);
             }
         });
 

rm-server/test/java/org/alfresco/module/org_alfresco_module_rm/test/util/CommonRMTestUtils.java

@@ -76,6 +76,7 @@ public class CommonRMTestUtils implements RecordsManagementModel
     public static final String DEFAULT_EVENT_NAME = "case_closed";
     public static final String PERIOD_NONE = "none|0";
     public static final String PERIOD_IMMEDIATELY = "immediately|0";
+    public static final String PERIOD_ONE_WEEK = "week|1";
     public static final String PERIOD_ONE_YEAR = "year|1";
     public static final String PERIOD_THREE_YEARS = "year|3";
 

rm-server/unit-test/java/org/alfresco/module/org_alfresco_module_rm/record/RecordServiceImplUnitTest.java

@@ -263,7 +263,7 @@ public class RecordServiceImplUnitTest extends BaseUnitTest
         DispositionSchedule recordDispositionSchedule = mock(DispositionSchedule.class);
         when(recordDispositionSchedule.isRecordLevelDisposition())
             .thenReturn(true);
-        when(mockedDispositionService.getDispositionSchedule(record))
+        when(mockedDispositionService.getOriginDispositionSchedule(record))
             .thenReturn(recordDispositionSchedule);
         
         DispositionSchedule recordFolderDispositionSchedule = mock(DispositionSchedule.class);