JAWS-172 - add VersionService.deleteVersion(...)

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

source/java/org/alfresco/repo/version/Version2ServiceImpl.java

@@ -41,7 +41,6 @@ import org.alfresco.repo.version.common.VersionHistoryImpl;
 import org.alfresco.repo.version.common.VersionImpl;
 import org.alfresco.repo.version.common.VersionUtil;
 import org.alfresco.service.cmr.repository.AspectMissingException;
-import org.alfresco.service.cmr.repository.AssociationRef;
 import org.alfresco.service.cmr.repository.ChildAssociationRef;
 import org.alfresco.service.cmr.repository.NodeRef;
 import org.alfresco.service.cmr.repository.StoreRef;
@@ -1036,22 +1035,35 @@ public class Version2ServiceImpl extends VersionServiceImpl implements VersionSe
         if (versionHistoryNodeRef != null)
         {
         	List<ChildAssociationRef> versionsAssoc = this.dbNodeService.getChildAssocs(versionHistoryNodeRef, Version2Model.CHILD_QNAME_VERSIONS, RegexQNamePattern.MATCH_ALL);
+        	
+        	ChildAssociationRef headVersionAssoc = null;
+        	int headVersionNumber = -1;
         	for (ChildAssociationRef versionAssoc : versionsAssoc)
             {
-                NodeRef versionNodeRef = versionAssoc.getChildRef();
-                List<AssociationRef> successors = this.dbNodeService.getTargetAssocs(versionNodeRef, Version2Model.ASSOC_SUCCESSOR);
-                if (successors.size() == 0)
+        	    String localName = versionAssoc.getQName().getLocalName();
+                if (localName.indexOf(Version2Model.CHILD_VERSIONS+"-") != -1) // TODO - could remove this belts-and-braces, should match correctly above !
                 {
-                    NodeRef versionedNodeRef = (NodeRef)this.dbNodeService.getProperty(
-                            versionNodeRef,
-                            QName.createQName(Version2Model.NAMESPACE_URI, Version2Model.PROP_FROZEN_NODE_REF));             
-                    StoreRef versionStoreRef = versionedNodeRef.getStoreRef();
-                    if (storeRef.equals(versionStoreRef) == true)
+                    int versionNumber = Integer.parseInt(localName.substring((Version2Model.CHILD_VERSIONS+"-").length()));
+                    if (versionNumber > headVersionNumber)
                     {
-                        version = getVersion(versionNodeRef);
+                        headVersionNumber = versionNumber;
+                        headVersionAssoc = versionAssoc;
                     }
                 }
             }
+        	
+        	if (headVersionAssoc != null)
+        	{
+        	    NodeRef versionNodeRef = headVersionAssoc.getChildRef();
+                NodeRef versionedNodeRef = (NodeRef)this.dbNodeService.getProperty(
+                            versionNodeRef,
+                            QName.createQName(Version2Model.NAMESPACE_URI, Version2Model.PROP_FROZEN_NODE_REF));             
+                StoreRef versionStoreRef = versionedNodeRef.getStoreRef();
+                if (storeRef.equals(versionStoreRef) == true)
+                {
+                    version = getVersion(versionNodeRef);
+                }
+        	}
         }
 
         return version;
@@ -1085,4 +1097,40 @@ public class Version2ServiceImpl extends VersionServiceImpl implements VersionSe
             }
         }
     }
+    
+    /* (non-Javadoc)
+     * @see org.alfresco.service.cmr.version.VersionService#deleteVersion(org.alfresco.service.cmr.repository.NodeRef, org.alfresco.service.cmr.version.Version)
+     */
+    public void deleteVersion(NodeRef nodeRef, Version version)
+    {
+        if (useDeprecatedV1)
+        {
+            super.deleteVersion(nodeRef, version); // throws UnsupportedOperationException
+        }
+        else
+        {
+            // Check the mandatory parameters
+            ParameterCheck.mandatory("nodeRef", nodeRef);
+            ParameterCheck.mandatory("version", version);
+            
+            Version currentVersion = getCurrentVersion(nodeRef);
+            
+            // Delete the version node
+            this.dbNodeService.deleteNode(VersionUtil.convertNodeRef(version.getFrozenStateNodeRef()));
+            
+            if (currentVersion.getVersionLabel().equals(version.getVersionLabel()))
+            {
+                Version headVersion = getHeadVersion(nodeRef);
+                if (headVersion != null)
+                {
+                    // Reset the version label property on the versionable node to new head version
+                    this.nodeService.setProperty(nodeRef, ContentModel.PROP_VERSION_LABEL, headVersion.getVersionLabel());
+                }
+                else
+                {
+                    deleteVersionHistory(nodeRef);
+                }
+            }
+        }
+    }
 }

source/java/org/alfresco/repo/version/VersionServiceImpl.java

@@ -1215,6 +1215,12 @@ public class VersionServiceImpl extends AbstractVersionServiceImpl implements Ve
         }
     }
     
+    public void deleteVersion(NodeRef nodeRef, Version version)
+    {
+        // This operation is not supported for a version1 store
+        throw new UnsupportedOperationException("Delete version is unsupported by the old (deprecated) version store implementation");
+    }
+    
     @Override
     protected void defaultOnCreateVersion(
             QName classRef,

source/java/org/alfresco/repo/version/VersionServiceImplTest.java

@@ -25,8 +25,10 @@
 package org.alfresco.repo.version;
 
 import java.io.Serializable;
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -216,6 +218,28 @@ public class VersionServiceImplTest extends BaseVersionStoreTest
         }
     }
     
+    private void CheckVersionHistory(VersionHistory vh, List<Version> expectedVersions)
+    {
+        if (vh == null)
+        {
+            assertNull(expectedVersions);
+        }
+        else
+        {
+            Iterator<Version> itr = expectedVersions.iterator();
+            
+            for (Version version : vh.getAllVersions())
+            {
+                Version expectedVersion = itr.next();
+                
+                assertEquals(version.getVersionLabel(), expectedVersion.getVersionLabel());
+                assertEquals(version.getFrozenStateNodeRef(), expectedVersion.getFrozenStateNodeRef());
+            }
+            
+            assertFalse(itr.hasNext());
+        }
+    }
+    
     /**
      * Tests the version history
      */
@@ -512,6 +536,141 @@ public class VersionServiceImplTest extends BaseVersionStoreTest
     	
     }
     
+    /**
+     * Test deleteVersion
+     */
+    public void testDeleteVersion()
+    {
+        // Create a versionable node
+        NodeRef versionableNode = createNewVersionableNode();
+        
+        // Check that there is no version history
+        VersionHistory versionHistory = this.versionService.getVersionHistory(versionableNode);
+        CheckVersionHistory(versionHistory, null);
+        
+        // Check that the current version property on the versionable node is not set
+        String versionLabel = (String)this.dbNodeService.getProperty(versionableNode, ContentModel.PROP_VERSION_LABEL);
+        assertNull(versionLabel);
+        
+        // Check that there is no current version
+        Version version = this.versionService.getCurrentVersion(versionableNode);
+        assertNull(version);
+        
+        // Create a couple of versions
+        Version version0 = createVersion(versionableNode);
+        Version version1 = createVersion(versionableNode);
+        
+        // Check that the version label is correct on the versionable node
+        String versionLabel1 = (String)this.dbNodeService.getProperty(versionableNode, ContentModel.PROP_VERSION_LABEL);
+        assertEquals("1.1", versionLabel1);
+        assertEquals(version1.getVersionLabel(), versionLabel1);
+        
+        // Check the version history
+        List<Version> expectedVersions = new ArrayList<Version>(2);
+        expectedVersions.add(version1);
+        expectedVersions.add(version0);
+        versionHistory = this.versionService.getVersionHistory(versionableNode);
+        assertEquals(2, versionHistory.getAllVersions().size());
+        CheckVersionHistory(versionHistory, expectedVersions);
+        
+        // Check current version
+        Version currentVersion = this.versionService.getCurrentVersion(versionableNode);
+        assertEquals(currentVersion.getVersionLabel(), version1.getVersionLabel());
+        assertEquals(currentVersion.getFrozenStateNodeRef(), version1.getFrozenStateNodeRef());
+        
+        // Create a couple more versions
+        Version version2 = createVersion(versionableNode);
+        Version version3 = createVersion(versionableNode);
+        
+        // Check that the version label is correct on the versionable node
+        String versionLabel3 = (String)this.dbNodeService.getProperty(versionableNode, ContentModel.PROP_VERSION_LABEL);
+        assertEquals("1.3", versionLabel3);
+        assertEquals(version3.getVersionLabel(), versionLabel3);
+        
+        // Check the version history
+        expectedVersions = new ArrayList<Version>(4);
+        expectedVersions.add(version3);
+        expectedVersions.add(version2);
+        expectedVersions.add(version1);
+        expectedVersions.add(version0);
+        versionHistory = this.versionService.getVersionHistory(versionableNode);
+        assertEquals(4, versionHistory.getAllVersions().size());
+        CheckVersionHistory(versionHistory, expectedVersions);
+        
+        // Check current version
+        currentVersion = this.versionService.getCurrentVersion(versionableNode);
+        assertEquals(currentVersion.getVersionLabel(), version3.getVersionLabel());
+        assertEquals(currentVersion.getFrozenStateNodeRef(), version3.getFrozenStateNodeRef());
+
+        // Delete version 2
+        this.versionService.deleteVersion(versionableNode, version2);
+        
+        // Delete version 0
+        this.versionService.deleteVersion(versionableNode, version0);
+        
+        // Check the version history
+        expectedVersions = new ArrayList<Version>(2);
+        expectedVersions.add(version3);
+        expectedVersions.add(version1);
+        versionHistory = this.versionService.getVersionHistory(versionableNode);
+        assertEquals(2, versionHistory.getAllVersions().size());
+        CheckVersionHistory(versionHistory, expectedVersions);
+        
+        // Check current version is unchanged
+        currentVersion = this.versionService.getCurrentVersion(versionableNode);
+        assertEquals(currentVersion.getVersionLabel(), version3.getVersionLabel());
+        assertEquals(currentVersion.getFrozenStateNodeRef(), version3.getFrozenStateNodeRef());
+        
+        // Delete version 3
+        this.versionService.deleteVersion(versionableNode, version3);
+        
+        // Check the version history size
+        expectedVersions = new ArrayList<Version>(1);
+        expectedVersions.add(version1);
+        versionHistory = this.versionService.getVersionHistory(versionableNode);
+        assertEquals(1, versionHistory.getAllVersions().size());
+        CheckVersionHistory(versionHistory, expectedVersions);
+        
+        // Check current version has changed to version 1
+        currentVersion = this.versionService.getCurrentVersion(versionableNode);
+        assertEquals(currentVersion.getVersionLabel(), version1.getVersionLabel());
+        assertEquals(currentVersion.getFrozenStateNodeRef(), version1.getFrozenStateNodeRef());
+        
+        // Create version 4
+        Version version4 = createVersion(versionableNode);
+        
+        // Check the version history size
+        expectedVersions = new ArrayList<Version>(2);
+        expectedVersions.add(version4);
+        expectedVersions.add(version1);
+        versionHistory = this.versionService.getVersionHistory(versionableNode);
+        assertEquals(2, versionHistory.getAllVersions().size());
+        CheckVersionHistory(versionHistory, expectedVersions);
+        
+        // Check current version has changed to version 4
+        currentVersion = this.versionService.getCurrentVersion(versionableNode);
+        assertEquals(currentVersion.getVersionLabel(), version4.getVersionLabel());
+        assertEquals(currentVersion.getFrozenStateNodeRef(), version4.getFrozenStateNodeRef());
+        
+        // Delete version 1
+        this.versionService.deleteVersion(versionableNode, version1);
+        
+        // Delete version 4
+        this.versionService.deleteVersion(versionableNode, version4);
+        
+        // Check the version history is empty
+        versionHistory = this.versionService.getVersionHistory(versionableNode);
+        CheckVersionHistory(versionHistory, null);
+        
+        // Check that the current version property on the versionable node is no longer set
+        versionLabel = (String)this.dbNodeService.getProperty(versionableNode, ContentModel.PROP_VERSION_LABEL);
+        assertNull(versionLabel);
+        
+        // Check that there is no current version
+        version = this.versionService.getCurrentVersion(versionableNode);
+        assertNull(version);
+    }
+    
     public void testAutoVersionOnInitialVersionOn()
     {
         // Create a versionable node

source/java/org/alfresco/service/cmr/version/VersionService.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2005-2007 Alfresco Software Limited.
+ * Copyright (C) 2005-2008 Alfresco Software Limited.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -38,7 +38,7 @@ import org.alfresco.service.namespace.QName;
 /**
  * Interface for public and internal version operations.
  * 
- * @author Roy Wetherall
+ * @author Roy Wetherall, janv
  */
 @PublicService
 public interface VersionService
@@ -282,4 +282,19 @@ public interface VersionService
     @Auditable(key = Auditable.Key.ARG_0, parameters = {"nodeRef"})
 	public void deleteVersionHistory(NodeRef nodeRef)
 		throws AspectMissingException;
+    
+    /**
+     * Delete a specific version associated with a node reference.
+     * <p>
+     * This operation is permanent, the specific version in the version history is
+     * deleted and cannot be retrieved.
+     * <p> 
+     * If this is the last version, then the current version label for the node reference is 
+     * reset and any subsequent versions of the node will result in a new version history being created.
+     *  
+     * @param nodeRef   the node reference
+     * @param version   the version to delete
+     */
+    @Auditable(key = Auditable.Key.ARG_0, parameters = {"nodeRef", "version"})
+    public void deleteVersion(NodeRef nodeRef, Version version);
 }