inteligr8/alfresco-community-repo
1
0
Fork 0
mirror of https://github.com/Alfresco/alfresco-community-repo.git synced 2025-08-07 17:49:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merged DEV to HEAD

Browse Source 
- ALF-8806 RINF 41: Lucene Removal: Fix CopyService
     - ALF-9028: RINF 41: Fix Aspect cm:copiedFrom
   - ALF-9029 RINF 49: Lucene Removal: CheckOutCheckInService API
     - ALF-9032: RINF 49: fixes to cm:workingcopy aspect

   28996: Dev branch for De-Lucene work pending patches
   29004: Evaluator runs in read-only txn
   29006: Additional PermissionCheckedCollection.create method
          - Use an existing collection's permission check data (cut-off, etc) to wrap a new collection
   29007:
          CopyService and CheckOutCheckInService refactors to remove Lucene
          
          CopyService:
          
          Removed cm:source property from cm:copiedfrom aspect and replaced with a cm:original association.
          Added CQ-based APIs to query for copies
          Added APIs to support bi-directional walking of copy association
          Fixed sundry uses of cm:copiedfrom esp. all uses related to cm:workingcopy
          
          CheckOutCheckInService:
          
          Check-out now creates a source aspect cm:checkedOut with 1:1 relationship to cm:workingcopy via cm:workingcopylink
          Removed explicit use of cm:workingcopy aspect and replaced it with calls to COCI API
          
   29083: Audit tests fail when indexing is turned off.
          Also removed a getReader() call during rule evaluation, leading to a 'sub-action' read being recorded.
   29113: NodeDAO.getNodesWithAspects supports paging
   29135: Removed unused patch queries
   29139: Basic patch (still terminates with error) to upgrade cm:copiedfrom and cm:workingcopy
   29157: Tested patch for cm:copiedfrom and cm:workingcopy aspects


git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@29159 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
This commit is contained in:
Derek Hulley
2011-07-19 03:22:11 +00:00
parent 8a561b38ca
commit 6ec3f44c29
58 changed files with 2277 additions and 1845 deletions
Download Patch File Download Diff File Expand all files Collapse all files

564
source/java/org/alfresco/repo/coci/CheckOutCheckInServiceImpl.java
View File

@@ -48,6 +48,7 @@ import org.alfresco.service.cmr.model.FileExistsException;
import org.alfresco.service.cmr.model.FileFolderService;
import org.alfresco.service.cmr.model.FileNotFoundException;
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.ContentData;
import org.alfresco.service.cmr.repository.CopyService;
@@ -55,12 +56,12 @@ import org.alfresco.service.cmr.repository.NodeRef;
import org.alfresco.service.cmr.repository.NodeService;
import org.alfresco.service.cmr.rule.RuleService;
import org.alfresco.service.cmr.rule.RuleType;
import org.alfresco.service.cmr.search.ResultSet;
import org.alfresco.service.cmr.search.SearchService;
import org.alfresco.service.cmr.security.AuthenticationService;
import org.alfresco.service.cmr.security.OwnableService;
import org.alfresco.service.cmr.version.VersionService;
import org.alfresco.service.namespace.QName;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.extensions.surf.util.I18NUtil;
/**
@@ -95,48 +96,16 @@ public class CheckOutCheckInServiceImpl implements CheckOutCheckInService
*/
private static final String EXTENSION_CHARACTER = ".";
/**
* The node service
*/
private static Log logger = LogFactory.getLog(CheckOutCheckInServiceImpl.class);
private NodeService nodeService;
/**
* The version service
*/
private VersionService versionService;
/**
* The lock service
*/
private LockService lockService;
/**
* The copy service
*/
private CopyService copyService;
/**
* The file folder service
*/
private FileFolderService fileFolderService;
/** Ownable service */
private OwnableService ownableService;
/**
* The search service
*/
private SearchService searchService;
/** Policy component */
private PolicyComponent policyComponent;
/**
* The authentication service
*/
private AuthenticationService authenticationService;
/** Rule service */
private RuleService ruleService;
/**
@@ -157,8 +126,6 @@ public class CheckOutCheckInServiceImpl implements CheckOutCheckInService
/**
* Set the node service
*
* @param nodeService the node service
*/
public void setNodeService(NodeService nodeService)
{
@@ -167,8 +134,6 @@ public class CheckOutCheckInServiceImpl implements CheckOutCheckInService
/**
* Set the version service
*
* @param versionService the version service
*/
public void setVersionService(VersionService versionService)
{
@@ -177,7 +142,6 @@ public class CheckOutCheckInServiceImpl implements CheckOutCheckInService
/**
* Set the ownable service
* @param ownableService ownable service
*/
public void setOwnableService(OwnableService ownableService)
{
@@ -186,8 +150,6 @@ public class CheckOutCheckInServiceImpl implements CheckOutCheckInService
/**
* Sets the lock service
*
* @param lockService the lock service
*/
public void setLockService(LockService lockService)
{
@@ -196,8 +158,6 @@ public class CheckOutCheckInServiceImpl implements CheckOutCheckInService
/**
* Sets the copy service
*
* @param copyService the copy service
*/
public void setCopyService(CopyService copyService)
{
@@ -206,28 +166,14 @@ public class CheckOutCheckInServiceImpl implements CheckOutCheckInService
/**
* Sets the authentication service
*
* @param authenticationService the authentication service
*/
public void setAuthenticationService(AuthenticationService authenticationService)
{
this.authenticationService = authenticationService;
}
/**
* Set the search service
*
* @param searchService the search service
*/
public void setSearchService(SearchService searchService)
{
this.searchService = searchService;
}
/**
* Set the file folder service
*
* @param fileFolderService the file folder service
*/
public void setFileFolderService(FileFolderService fileFolderService)
{
@@ -236,8 +182,6 @@ public class CheckOutCheckInServiceImpl implements CheckOutCheckInService
/**
* Sets the versionable aspect behaviour implementation
*
* @param versionableAspect the versionable aspect behaviour implementation
*/
public void setVersionableAspect(VersionableAspect versionableAspect)
{
@@ -295,10 +239,10 @@ public class CheckOutCheckInServiceImpl implements CheckOutCheckInService
/**
* Invoke the before check out policy
*
* @param nodeRef
* @param destinationParentNodeRef
* @param destinationAssocTypeQName
* @param destinationAssocQName
* @param nodeRef the node to be checked out
* @param destinationParentNodeRef the parent of the working copy
* @param destinationAssocTypeQName the working copy's primary association type
* @param destinationAssocQName the working copy's primary association name
*/
private void invokeBeforeCheckOut(
NodeRef nodeRef,
@@ -314,14 +258,13 @@ public class CheckOutCheckInServiceImpl implements CheckOutCheckInService
{
policy.beforeCheckOut(nodeRef, destinationParentNodeRef, destinationAssocTypeQName, destinationAssocQName);
}
}
}
/**
* Invoke on the on check out policy
*
* @param workingCopy
* @param workingCopy the new working copy
*/
private void invokeOnCheckOut(NodeRef workingCopy)
{
@@ -333,15 +276,14 @@ public class CheckOutCheckInServiceImpl implements CheckOutCheckInService
{
policy.onCheckOut(workingCopy);
}
}
}
/**
* Invoke before check in policy
*
* @param workingCopyNodeRef
* @param versionProperties
* @param workingCopyNodeRef the current working copy to check in
* @param versionProperties
* @param contentUrl
* @param keepCheckedOut
*/
@@ -359,14 +301,13 @@ public class CheckOutCheckInServiceImpl implements CheckOutCheckInService
{
policy.beforeCheckIn(workingCopyNodeRef, versionProperties, contentUrl, keepCheckedOut);
}
}
}
/**
* Invoke on check in policy
*
* @param nodeRef
* @param nodeRef the node being checked in
*/
private void invokeOnCheckIn(NodeRef nodeRef)
{
@@ -378,14 +319,13 @@ public class CheckOutCheckInServiceImpl implements CheckOutCheckInService
{
policy.onCheckIn(nodeRef);
}
}
}
/**
* Invoke before cancel check out
*
* @param workingCopy
* @param workingCopy the working copy that will be destroyed
*/
private void invokeBeforeCancelCheckOut(NodeRef workingCopy)
{
@@ -404,7 +344,7 @@ public class CheckOutCheckInServiceImpl implements CheckOutCheckInService
/**
* Invoke on cancel check out
*
* @param nodeRef
* @param nodeRef the working copy that will be destroyed
*/
private void invokeOnCancelCheckOut(NodeRef nodeRef)
{
@@ -416,34 +356,41 @@ public class CheckOutCheckInServiceImpl implements CheckOutCheckInService
{
policy.onCancelCheckOut(nodeRef);
}
}
}
/**
* @see org.alfresco.service.cmr.coci.CheckOutCheckInService#checkout(org.alfresco.service.cmr.repository.NodeRef, org.alfresco.service.cmr.repository.NodeRef, org.alfresco.service.namespace.QName, org.alfresco.service.namespace.QName)
*/
@Override
public NodeRef checkout(NodeRef nodeRef)
{
// Find the primary parent in order to determine where to put the copy
ChildAssociationRef childAssocRef = nodeService.getPrimaryParent(nodeRef);
// Checkout the working copy to the same destination
return checkout(nodeRef, childAssocRef.getParentRef(), childAssocRef.getTypeQName(), childAssocRef.getQName());
}
@Override
public NodeRef checkout(
final NodeRef nodeRef,
final NodeRef destinationParentNodeRef,
final QName destinationAssocTypeQName,
QName destinationAssocQName)
{
LockType lockType = this.lockService.getLockType(nodeRef);
if (LockType.READ_ONLY_LOCK.equals(lockType) == true || getWorkingCopy(nodeRef) != null)
if (nodeService.hasAspect(nodeRef, ContentModel.ASPECT_CHECKED_OUT))
{
throw new CheckOutCheckInServiceException(MSG_ALREADY_CHECKEDOUT);
}
// Make sure we are no checking out a working copy node
if (this.nodeService.hasAspect(nodeRef, ContentModel.ASPECT_WORKING_COPY) == true)
if (nodeService.hasAspect(nodeRef, ContentModel.ASPECT_WORKING_COPY))
{
throw new CheckOutCheckInServiceException(MSG_ERR_ALREADY_WORKING_COPY);
}
behaviourFilter.disableBehaviour(nodeRef, ContentModel.ASPECT_AUDITABLE);
behaviourFilter.disableBehaviour(destinationParentNodeRef, ContentModel.ASPECT_AUDITABLE);
try {
try
{
return doCheckout(nodeRef, destinationParentNodeRef, destinationAssocTypeQName, destinationAssocQName);
}
finally
@@ -453,27 +400,23 @@ public class CheckOutCheckInServiceImpl implements CheckOutCheckInService
}
}
/**
* @param nodeRef
* @param destinationParentNodeRef
* @param destinationAssocTypeQName
* @param destinationAssocQName
* @return
*/
private NodeRef doCheckout(final NodeRef nodeRef, final NodeRef destinationParentNodeRef,
final QName destinationAssocTypeQName, QName destinationAssocQName)
private NodeRef doCheckout(
final NodeRef nodeRef,
final NodeRef destinationParentNodeRef,
final QName destinationAssocTypeQName,
QName destinationAssocQName)
{
// Apply the lock aspect if required
if (this.nodeService.hasAspect(nodeRef, ContentModel.ASPECT_LOCKABLE) == false)
if (nodeService.hasAspect(nodeRef, ContentModel.ASPECT_LOCKABLE) == false)
{
this.nodeService.addAspect(nodeRef, ContentModel.ASPECT_LOCKABLE, null);
nodeService.addAspect(nodeRef, ContentModel.ASPECT_LOCKABLE, null);
}
// Invoke before check out policy
invokeBeforeCheckOut(nodeRef, destinationParentNodeRef, destinationAssocTypeQName, destinationAssocQName);
// Rename the working copy
String copyName = (String)this.nodeService.getProperty(nodeRef, ContentModel.PROP_NAME);
String copyName = (String)nodeService.getProperty(nodeRef, ContentModel.PROP_NAME);
copyName = createWorkingCopyName(copyName);
// Get the user
@@ -487,7 +430,7 @@ public class CheckOutCheckInServiceImpl implements CheckOutCheckInService
final QName copyQName = QName.createQName(destinationAssocQName.getNamespaceURI(), QName.createValidLocalName(copyName));
// Find the primary parent
ChildAssociationRef childAssocRef = this.nodeService.getPrimaryParent(nodeRef);
ChildAssociationRef childAssocRef = nodeService.getPrimaryParent(nodeRef);
// If destination parent for working copy is the same as the parent of the source node
// then working copy should be created even if the user has no permissions to create children in
@@ -521,12 +464,14 @@ public class CheckOutCheckInServiceImpl implements CheckOutCheckInService
// Update the working copy name
this.nodeService.setProperty(workingCopy, ContentModel.PROP_NAME, copyName);
nodeService.setProperty(workingCopy, ContentModel.PROP_NAME, copyName);
// Apply the working copy aspect to the working copy
Map<QName, Serializable> workingCopyProperties = new HashMap<QName, Serializable>(1);
workingCopyProperties.put(ContentModel.PROP_WORKING_COPY_OWNER, userName);
this.nodeService.addAspect(workingCopy, ContentModel.ASPECT_WORKING_COPY, workingCopyProperties);
nodeService.addAspect(workingCopy, ContentModel.ASPECT_WORKING_COPY, workingCopyProperties);
nodeService.addAspect(nodeRef, ContentModel.ASPECT_CHECKED_OUT, null);
nodeService.createAssociation(nodeRef, workingCopy, ContentModel.ASSOC_WORKING_COPY_LINK);
}
finally
{
@@ -534,7 +479,7 @@ public class CheckOutCheckInServiceImpl implements CheckOutCheckInService
}
// Lock the original node
this.lockService.lock(nodeRef, LockType.READ_ONLY_LOCK);
lockService.lock(nodeRef, LockType.READ_ONLY_LOCK);
// Invoke on check out policy
invokeOnCheckOut(workingCopy);
@@ -559,160 +504,15 @@ public class CheckOutCheckInServiceImpl implements CheckOutCheckInService
}
}
/**
* @see org.alfresco.service.cmr.coci.CheckOutCheckInService#checkout(org.alfresco.service.cmr.repository.NodeRef)
*/
public NodeRef checkout(NodeRef nodeRef)
{
// Find the primary parent in order to determine where to put the copy
ChildAssociationRef childAssocRef = this.nodeService.getPrimaryParent(nodeRef);
// Checkout the working copy to the same destination
return checkout(nodeRef, childAssocRef.getParentRef(), childAssocRef.getTypeQName(), childAssocRef.getQName());
}
/**
* @see org.alfresco.repo.version.operations.VersionOperationsService#checkin(org.alfresco.repo.ref.NodeRef, Map<String,Serializable>, java.lang.String, boolean)
*/
@Override
public NodeRef checkin(
NodeRef workingCopyNodeRef,
Map<String,Serializable> versionProperties,
String contentUrl,
boolean keepCheckedOut)
Map<String, Serializable> versionProperties)
{
NodeRef nodeRef = null;
// Check that we have been handed a working copy
if (this.nodeService.hasAspect(workingCopyNodeRef, ContentModel.ASPECT_WORKING_COPY) == false)
{
// Error since we have not been passed a working copy
throw new AspectMissingException(ContentModel.ASPECT_WORKING_COPY, workingCopyNodeRef);
}
// Check that the working node still has the copy aspect applied
if (this.nodeService.hasAspect(workingCopyNodeRef, ContentModel.ASPECT_COPIEDFROM) == true)
{
// Invoke policy
invokeBeforeCheckIn(workingCopyNodeRef, versionProperties, contentUrl, keepCheckedOut);
Map<QName, Serializable> workingCopyProperties = nodeService.getProperties(workingCopyNodeRef);
// Try and get the original node reference
nodeRef = (NodeRef) workingCopyProperties.get(ContentModel.PROP_COPY_REFERENCE);
if(nodeRef == null)
{
// Error since the original node can not be found
throw new CheckOutCheckInServiceException(MSG_ERR_BAD_COPY);
}
try
{
// Release the lock
this.lockService.unlock(nodeRef);
}
catch (UnableToReleaseLockException exception)
{
throw new CheckOutCheckInServiceException(MSG_ERR_NOT_OWNER, exception);
}
if (contentUrl != null)
{
ContentData contentData = (ContentData) workingCopyProperties.get(ContentModel.PROP_CONTENT);
if (contentData == null)
{
throw new AlfrescoRuntimeException(MSG_ERR_WORKINGCOPY_HAS_NO_MIMETYPE, new Object[]{workingCopyNodeRef});
}
else
{
contentData = new ContentData(
contentUrl,
contentData.getMimetype(),
contentData.getSize(),
contentData.getEncoding());
}
// Set the content url value onto the working copy
this.nodeService.setProperty(
workingCopyNodeRef,
ContentModel.PROP_CONTENT,
contentData);
}
// Copy the contents of the working copy onto the original
this.copyService.copy(workingCopyNodeRef, nodeRef);
// Handle name change on working copy (only for folders/files)
if (fileFolderService.getFileInfo(workingCopyNodeRef) != null)
{
String origName = (String)this.nodeService.getProperty(nodeRef, ContentModel.PROP_NAME);
String name = (String)this.nodeService.getProperty(workingCopyNodeRef, ContentModel.PROP_NAME);
if (hasWorkingCopyNameChanged(name, origName))
{
// ensure working copy has working copy label in its name to avoid name clash
if (!name.contains(" " + getWorkingCopyLabel()))
{
try
{
fileFolderService.rename(workingCopyNodeRef, createWorkingCopyName(name));
}
catch (FileExistsException e)
{
throw new CheckOutCheckInServiceException(e, MSG_ERR_CANNOT_RENAME, name, createWorkingCopyName(name));
}
catch (FileNotFoundException e)
{
throw new CheckOutCheckInServiceException(e, MSG_ERR_CANNOT_RENAME, name, createWorkingCopyName(name));
}
}
try
{
// rename original to changed working name
fileFolderService.rename(nodeRef, getNameFromWorkingCopyName(name));
}
catch (FileExistsException e)
{
throw new CheckOutCheckInServiceException(e, MSG_ERR_CANNOT_RENAME, origName, getNameFromWorkingCopyName(name));
}
catch (FileNotFoundException e)
{
throw new CheckOutCheckInServiceException(e, MSG_ERR_CANNOT_RENAME, name, getNameFromWorkingCopyName(name));
}
}
}
if (versionProperties != null && this.nodeService.hasAspect(nodeRef, ContentModel.ASPECT_VERSIONABLE) == true)
{
// Create the new version
this.versionService.createVersion(nodeRef, versionProperties);
}
if (keepCheckedOut == false)
{
// Delete the working copy
this.nodeService.deleteNode(workingCopyNodeRef);
// Remove the lock aspect (copied from working copy)
this.nodeService.removeAspect(nodeRef, ContentModel.ASPECT_LOCKABLE);
}
else
{
// Re-lock the original node
this.lockService.lock(nodeRef, LockType.READ_ONLY_LOCK);
}
// Invoke policy
invokeOnCheckIn(nodeRef);
}
else
{
// Error since the copy aspect is missing
throw new AspectMissingException(ContentModel.ASPECT_COPIEDFROM, workingCopyNodeRef);
}
return nodeRef;
return checkin(workingCopyNodeRef, versionProperties, null, false);
}
/**
* @see org.alfresco.service.cmr.coci.CheckOutCheckInService#checkin(org.alfresco.service.cmr.repository.NodeRef, Map, java.lang.String)
*/
@Override
public NodeRef checkin(
NodeRef workingCopyNodeRef,
Map<String, Serializable> versionProperties,
@@ -721,110 +521,252 @@ public class CheckOutCheckInServiceImpl implements CheckOutCheckInService
return checkin(workingCopyNodeRef, versionProperties, contentUrl, false);
}
/**
* @see org.alfresco.service.cmr.coci.CheckOutCheckInService#checkin(org.alfresco.service.cmr.repository.NodeRef, Map)
*/
@Override
public NodeRef checkin(
NodeRef workingCopyNodeRef,
Map<String, Serializable> versionProperties)
Map<String,Serializable> versionProperties,
String contentUrl,
boolean keepCheckedOut)
{
return checkin(workingCopyNodeRef, versionProperties, null, false);
}
/**
* @see org.alfresco.service.cmr.coci.CheckOutCheckInService#cancelCheckout(org.alfresco.service.cmr.repository.NodeRef)
*/
public NodeRef cancelCheckout(NodeRef workingCopyNodeRef)
{
NodeRef nodeRef = null;
// Check that we have been handed a working copy
if (this.nodeService.hasAspect(workingCopyNodeRef, ContentModel.ASPECT_WORKING_COPY) == false)
if (!nodeService.hasAspect(workingCopyNodeRef, ContentModel.ASPECT_WORKING_COPY))
{
// Error since we have not been passed a working copy
throw new AspectMissingException(ContentModel.ASPECT_WORKING_COPY, workingCopyNodeRef);
}
// Ensure that the node has the copy aspect
if (this.nodeService.hasAspect(workingCopyNodeRef, ContentModel.ASPECT_COPIEDFROM) == true)
// Get the checked out node
NodeRef nodeRef = getCheckedOut(workingCopyNodeRef);
if (nodeRef == null)
{
// Invoke policy
invokeBeforeCancelCheckOut(workingCopyNodeRef);
// Error since the original node can not be found
throw new CheckOutCheckInServiceException(MSG_ERR_BAD_COPY);
}
// Invoke policy
invokeBeforeCheckIn(workingCopyNodeRef, versionProperties, contentUrl, keepCheckedOut);
try
{
// Release the lock
lockService.unlock(nodeRef);
}
catch (UnableToReleaseLockException exception)
{
throw new CheckOutCheckInServiceException(MSG_ERR_NOT_OWNER, exception);
}
// Get the original node
nodeRef = (NodeRef)this.nodeService.getProperty(workingCopyNodeRef, ContentModel.PROP_COPY_REFERENCE);
if (nodeRef == null)
if (contentUrl != null)
{
ContentData contentData = (ContentData) nodeService.getProperty(workingCopyNodeRef, ContentModel.PROP_CONTENT);
if (contentData == null)
{
// Error since the original node can not be found
throw new CheckOutCheckInServiceException(MSG_ERR_BAD_COPY);
}
behaviourFilter.disableBehaviour(nodeRef, ContentModel.ASPECT_AUDITABLE);
try{
throw new AlfrescoRuntimeException(MSG_ERR_WORKINGCOPY_HAS_NO_MIMETYPE, new Object[]{workingCopyNodeRef});
}
else
{
contentData = new ContentData(
contentUrl,
contentData.getMimetype(),
contentData.getSize(),
contentData.getEncoding());
}
// Set the content url value onto the working copy
nodeService.setProperty(
workingCopyNodeRef,
ContentModel.PROP_CONTENT,
contentData);
}
// Copy the contents of the working copy onto the original
this.copyService.copy(workingCopyNodeRef, nodeRef);
// Handle name change on working copy (only for folders/files)
if (fileFolderService.getFileInfo(workingCopyNodeRef) != null)
{
String origName = (String)nodeService.getProperty(nodeRef, ContentModel.PROP_NAME);
String name = (String)nodeService.getProperty(workingCopyNodeRef, ContentModel.PROP_NAME);
if (hasWorkingCopyNameChanged(name, origName))
{
// ensure working copy has working copy label in its name to avoid name clash
if (!name.contains(" " + getWorkingCopyLabel()))
{
try
{
fileFolderService.rename(workingCopyNodeRef, createWorkingCopyName(name));
}
catch (FileExistsException e)
{
throw new CheckOutCheckInServiceException(e, MSG_ERR_CANNOT_RENAME, name, createWorkingCopyName(name));
}
catch (FileNotFoundException e)
{
throw new CheckOutCheckInServiceException(e, MSG_ERR_CANNOT_RENAME, name, createWorkingCopyName(name));
}
}
try
{
// rename original to changed working name
fileFolderService.rename(nodeRef, getNameFromWorkingCopyName(name));
}
catch (FileExistsException e)
{
throw new CheckOutCheckInServiceException(e, MSG_ERR_CANNOT_RENAME, origName, getNameFromWorkingCopyName(name));
}
catch (FileNotFoundException e)
{
throw new CheckOutCheckInServiceException(e, MSG_ERR_CANNOT_RENAME, name, getNameFromWorkingCopyName(name));
}
}
}
if (versionProperties != null && nodeService.hasAspect(nodeRef, ContentModel.ASPECT_VERSIONABLE))
{
// Create the new version
this.versionService.createVersion(nodeRef, versionProperties);
}
if (keepCheckedOut == false)
{
// Delete the working copy
behaviourFilter.disableBehaviour(workingCopyNodeRef, ContentModel.ASPECT_WORKING_COPY);
try
{
// Clean up original node
// Note: Lock has already been removed. So no lockService.unlock(nodeRef);
nodeService.removeAspect(nodeRef, ContentModel.ASPECT_CHECKED_OUT);
// Release the lock on the original node
this.lockService.unlock(nodeRef);
// Delete the working copy
this.nodeService.deleteNode(workingCopyNodeRef);
// Invoke policy
invokeOnCancelCheckOut(nodeRef);
nodeService.deleteNode(workingCopyNodeRef);
}
finally
{
behaviourFilter.enableBehaviour(nodeRef, ContentModel.ASPECT_AUDITABLE);
// Just for symmetry; the node is gone
behaviourFilter.enableBehaviour(workingCopyNodeRef, ContentModel.ASPECT_WORKING_COPY);
}
}
else
{
// Error since the copy aspect is missing
throw new AspectMissingException(ContentModel.ASPECT_COPIEDFROM, workingCopyNodeRef);
// Re-lock the original node
lockService.lock(nodeRef, LockType.READ_ONLY_LOCK);
}
// Invoke policy
invokeOnCheckIn(nodeRef);
return nodeRef;
}
@Override
public NodeRef cancelCheckout(NodeRef workingCopyNodeRef)
{
// Check that we have been handed a working copy
if (!nodeService.hasAspect(workingCopyNodeRef, ContentModel.ASPECT_WORKING_COPY))
{
// Error since we have not been passed a working copy
throw new AspectMissingException(ContentModel.ASPECT_WORKING_COPY, workingCopyNodeRef);
}
// Get the checked out node
NodeRef nodeRef = getCheckedOut(workingCopyNodeRef);
if (nodeRef == null)
{
// Error since the original node can not be found
throw new CheckOutCheckInServiceException(MSG_ERR_BAD_COPY);
}
// Invoke policy
invokeBeforeCancelCheckOut(workingCopyNodeRef);
behaviourFilter.disableBehaviour(nodeRef, ContentModel.ASPECT_AUDITABLE);
behaviourFilter.disableBehaviour(workingCopyNodeRef, ContentModel.ASPECT_WORKING_COPY);
try
{
// Release the lock on the original node
lockService.unlock(nodeRef);
nodeService.removeAspect(nodeRef, ContentModel.ASPECT_CHECKED_OUT);
// Delete the working copy
nodeService.deleteNode(workingCopyNodeRef);
// Invoke policy
invokeOnCancelCheckOut(nodeRef);
}
catch (UnableToReleaseLockException exception)
{
throw new CheckOutCheckInServiceException(MSG_ERR_NOT_OWNER, exception);
}
finally
{
behaviourFilter.enableBehaviour(nodeRef, ContentModel.ASPECT_AUDITABLE);
}
return nodeRef;
}
/**
* @see org.alfresco.service.cmr.coci.CheckOutCheckInService#getWorkingCopy(org.alfresco.service.cmr.repository.NodeRef)
*/
@Override
public NodeRef getWorkingCopy(NodeRef nodeRef)
{
NodeRef workingCopy = null;
// Do a search to find the working copy document
ResultSet resultSet = null;
try
if (nodeService.hasAspect(nodeRef, ContentModel.ASPECT_CHECKED_OUT))
{
resultSet = this.searchService.query(
nodeRef.getStoreRef(),
SearchService.LANGUAGE_LUCENE,
"+ASPECT:\"" + ContentModel.ASPECT_WORKING_COPY.toString() + "\" +@\\{http\\://www.alfresco.org/model/content/1.0\\}" + ContentModel.PROP_COPY_REFERENCE.getLocalName() + ":\"" + nodeRef.toString() + "\"");
if (resultSet.getNodeRefs().size() != 0)
List<AssociationRef> assocs = nodeService.getTargetAssocs(nodeRef, ContentModel.ASSOC_WORKING_COPY_LINK);
// It is a 1:1 relationship
if (assocs.size() > 0)
{
workingCopy = resultSet.getNodeRef(0);
}
}
finally
{
if (resultSet != null)
{
resultSet.close();
if (assocs.size() > 1)
{
logger.warn("Found multiple " + ContentModel.ASSOC_WORKING_COPY_LINK + " association from node: " + nodeRef);
}
workingCopy = assocs.get(0).getTargetRef();
}
}
return workingCopy;
}
@Override
public NodeRef getCheckedOut(NodeRef nodeRef)
{
NodeRef original = null;
if (nodeService.hasAspect(nodeRef, ContentModel.ASPECT_WORKING_COPY))
{
List<AssociationRef> assocs = nodeService.getSourceAssocs(nodeRef, ContentModel.ASSOC_WORKING_COPY_LINK);
// It is a 1:1 relationship
if (assocs.size() > 0)
{
if (assocs.size() > 1)
{
logger.warn("Found multiple " + ContentModel.ASSOC_WORKING_COPY_LINK + " associations to node: " + nodeRef);
}
original = assocs.get(0).getSourceRef();
}
}
return original;
}
@Override
public boolean isWorkingCopy(NodeRef nodeRef)
{
return nodeService.hasAspect(nodeRef, ContentModel.ASPECT_WORKING_COPY);
}
@Override
public boolean isCheckedOut(NodeRef nodeRef)
{
return nodeService.hasAspect(nodeRef, ContentModel.ASPECT_CHECKED_OUT);
}
/**
* Create working copy name
*
* @param name name
* @return working copy name
*/
public String createWorkingCopyName(String name)
public static String createWorkingCopyName(String name)
{
if (this.getWorkingCopyLabel() != null && this.getWorkingCopyLabel().length() != 0)
if (getWorkingCopyLabel() != null && getWorkingCopyLabel().length() != 0)
{
if (name != null && name.length() != 0)
{
@@ -851,7 +793,6 @@ public class CheckOutCheckInServiceImpl implements CheckOutCheckInService
/**
* Get original name from working copy name
*
* @param workingCopyName
* @return original name
*/
private String getNameFromWorkingCopyName(String workingCopyName)
@@ -887,9 +828,8 @@ public class CheckOutCheckInServiceImpl implements CheckOutCheckInService
*
* @return the working copy label
*/
public String getWorkingCopyLabel()
public static String getWorkingCopyLabel()
{
return I18NUtil.getMessage(MSG_WORKING_COPY_LABEL);
}
}

220
source/java/org/alfresco/repo/coci/CheckOutCheckInServiceImplTest.java
View File

@@ -19,7 +19,9 @@
package org.alfresco.repo.coci;
import java.io.Serializable;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.alfresco.model.ContentModel;
@@ -30,6 +32,7 @@ import org.alfresco.repo.transaction.RetryingTransactionHelper.RetryingTransacti
import org.alfresco.repo.version.VersionModel;
import org.alfresco.service.cmr.coci.CheckOutCheckInService;
import org.alfresco.service.cmr.lock.LockService;
import org.alfresco.service.cmr.repository.AssociationRef;
import org.alfresco.service.cmr.repository.ChildAssociationRef;
import org.alfresco.service.cmr.repository.ContentData;
import org.alfresco.service.cmr.repository.ContentReader;
@@ -78,6 +81,8 @@ public class CheckOutCheckInServiceImplTest extends BaseSpringTest
private NodeRef rootNodeRef;
private NodeRef nodeRef;
private String userNodeRef;
private NodeRef folderNodeRef;
private NodeRef fileNodeRef;
/**
* Types and properties used by the tests
@@ -106,7 +111,7 @@ public class CheckOutCheckInServiceImplTest extends BaseSpringTest
{
// Set the services
this.nodeService = (NodeService)this.applicationContext.getBean("nodeService");
this.cociService = (CheckOutCheckInService)this.applicationContext.getBean("checkOutCheckInService");
this.cociService = (CheckOutCheckInService)this.applicationContext.getBean("CheckoutCheckinService");
this.contentService = (ContentService)this.applicationContext.getBean("contentService");
this.versionService = (VersionService)this.applicationContext.getBean("versionService");
this.authenticationService = (MutableAuthenticationService)this.applicationContext.getBean("authenticationService");
@@ -120,19 +125,19 @@ public class CheckOutCheckInServiceImplTest extends BaseSpringTest
authenticationComponent.setSystemUserAsCurrentUser();
// Create the store and get the root node reference
this.storeRef = this.nodeService.createStore(StoreRef.PROTOCOL_WORKSPACE, "Test_" + System.currentTimeMillis());
this.rootNodeRef = this.nodeService.getRootNode(storeRef);
this.storeRef = nodeService.createStore(StoreRef.PROTOCOL_WORKSPACE, "Test_" + System.currentTimeMillis());
this.rootNodeRef = nodeService.getRootNode(storeRef);
// Create the node used for tests
ChildAssociationRef childAssocRef = this.nodeService.createNode(
ChildAssociationRef childAssocRef = nodeService.createNode(
rootNodeRef,
ContentModel.ASSOC_CHILDREN,
QName.createQName("test"),
ContentModel.TYPE_CONTENT);
this.nodeRef = childAssocRef.getChildRef();
this.nodeService.addAspect(this.nodeRef, ContentModel.ASPECT_TITLED, null);
this.nodeService.setProperty(this.nodeRef, ContentModel.PROP_NAME, TEST_VALUE_NAME);
this.nodeService.setProperty(this.nodeRef, PROP2_QNAME, TEST_VALUE_2);
nodeService.addAspect(this.nodeRef, ContentModel.ASPECT_TITLED, null);
nodeService.setProperty(this.nodeRef, ContentModel.PROP_NAME, TEST_VALUE_NAME);
nodeService.setProperty(this.nodeRef, PROP2_QNAME, TEST_VALUE_2);
// Add the initial content to the node
ContentWriter contentWriter = this.contentService.getWriter(this.nodeRef, ContentModel.PROP_CONTENT, true);
@@ -141,8 +146,8 @@ public class CheckOutCheckInServiceImplTest extends BaseSpringTest
contentWriter.putContent(CONTENT_1);
// Add the lock and version aspects to the created node
this.nodeService.addAspect(this.nodeRef, ContentModel.ASPECT_VERSIONABLE, null);
this.nodeService.addAspect(this.nodeRef, ContentModel.ASPECT_LOCKABLE, null);
nodeService.addAspect(this.nodeRef, ContentModel.ASPECT_VERSIONABLE, null);
nodeService.addAspect(this.nodeRef, ContentModel.ASPECT_LOCKABLE, null);
// Create and authenticate the user
this.userName = "cociTest" + GUID.generate();
@@ -152,6 +157,23 @@ public class CheckOutCheckInServiceImplTest extends BaseSpringTest
permissionService.setPermission(this.rootNodeRef, this.userName, PermissionService.ALL_PERMISSIONS, true);
permissionService.setPermission(this.nodeRef, this.userName, PermissionService.ALL_PERMISSIONS, true);
folderNodeRef = nodeService.createNode(
rootNodeRef,
ContentModel.ASSOC_CHILDREN,
QName.createQName("test"),
ContentModel.TYPE_FOLDER,
Collections.<QName, Serializable>singletonMap(ContentModel.PROP_NAME, "folder")).getChildRef();
fileNodeRef = nodeService.createNode(
folderNodeRef,
ContentModel.ASSOC_CONTAINS,
QName.createQName("test"),
ContentModel.TYPE_CONTENT,
Collections.<QName, Serializable>singletonMap(ContentModel.PROP_NAME, "file")).getChildRef();
contentWriter = this.contentService.getWriter(fileNodeRef, ContentModel.PROP_CONTENT, true);
contentWriter.setMimetype("text/plain");
contentWriter.setEncoding("UTF-8");
contentWriter.putContent(CONTENT_1);
}
/**
@@ -181,7 +203,7 @@ public class CheckOutCheckInServiceImplTest extends BaseSpringTest
private NodeRef checkout()
{
// Check out the node
NodeRef workingCopy = this.cociService.checkout(
NodeRef workingCopy = cociService.checkout(
this.nodeRef,
this.rootNodeRef,
ContentModel.ASSOC_CHILDREN,
@@ -191,16 +213,16 @@ public class CheckOutCheckInServiceImplTest extends BaseSpringTest
//System.out.println(NodeStoreInspector.dumpNodeStore(this.nodeService, this.storeRef));
// Ensure that the working copy and copy aspect has been applied
assertTrue(this.nodeService.hasAspect(workingCopy, ContentModel.ASPECT_WORKING_COPY));
assertTrue(this.nodeService.hasAspect(workingCopy, ContentModel.ASPECT_COPIEDFROM));
assertTrue(nodeService.hasAspect(workingCopy, ContentModel.ASPECT_WORKING_COPY));
assertTrue(nodeService.hasAspect(workingCopy, ContentModel.ASPECT_COPIEDFROM));
// Check that the working copy owner has been set correctly
assertEquals(this.userNodeRef, this.nodeService.getProperty(workingCopy, ContentModel.PROP_WORKING_COPY_OWNER));
assertEquals(this.userNodeRef, nodeService.getProperty(workingCopy, ContentModel.PROP_WORKING_COPY_OWNER));
// Check that the working copy name has been set correctly
String name = (String)this.nodeService.getProperty(this.nodeRef, PROP_NAME_QNAME);
String workingCopyLabel = ((CheckOutCheckInServiceImpl)this.cociService).createWorkingCopyName(name);
String workingCopyName = (String)this.nodeService.getProperty(workingCopy, PROP_NAME_QNAME);
String name = (String)nodeService.getProperty(this.nodeRef, PROP_NAME_QNAME);
String workingCopyLabel = CheckOutCheckInServiceImpl.createWorkingCopyName(name);
String workingCopyName = (String)nodeService.getProperty(workingCopy, PROP_NAME_QNAME);
assertEquals(workingCopyLabel, workingCopyName);
// Ensure that the content has been copied correctly
@@ -226,13 +248,13 @@ public class CheckOutCheckInServiceImplTest extends BaseSpringTest
// Test standard check-in
Map<String, Serializable> versionProperties = new HashMap<String, Serializable>();
versionProperties.put(Version.PROP_DESCRIPTION, "This is a test version");
this.cociService.checkin(workingCopy, versionProperties);
cociService.checkin(workingCopy, versionProperties);
// Test check-in with content
NodeRef workingCopy3 = checkout();
this.nodeService.setProperty(workingCopy3, PROP_NAME_QNAME, TEST_VALUE_2);
this.nodeService.setProperty(workingCopy3, PROP2_QNAME, TEST_VALUE_3);
nodeService.setProperty(workingCopy3, PROP_NAME_QNAME, TEST_VALUE_2);
nodeService.setProperty(workingCopy3, PROP2_QNAME, TEST_VALUE_3);
ContentWriter tempWriter = this.contentService.getWriter(workingCopy3, ContentModel.PROP_CONTENT, false);
assertNotNull(tempWriter);
tempWriter.putContent(CONTENT_2);
@@ -240,7 +262,7 @@ public class CheckOutCheckInServiceImplTest extends BaseSpringTest
Map<String, Serializable> versionProperties3 = new HashMap<String, Serializable>();
versionProperties3.put(Version.PROP_DESCRIPTION, "description");
versionProperties3.put(VersionModel.PROP_VERSION_TYPE, VersionType.MAJOR);
NodeRef origNodeRef = this.cociService.checkin(workingCopy3, versionProperties3, contentUrl, true);
NodeRef origNodeRef = cociService.checkin(workingCopy3, versionProperties3, contentUrl, true);
assertNotNull(origNodeRef);
// Check the checked in content
@@ -262,38 +284,53 @@ public class CheckOutCheckInServiceImplTest extends BaseSpringTest
assertEquals(CONTENT_2, versionContentReader.getContentString());
// Check that the name is not updated during the check-in
assertEquals(TEST_VALUE_2, this.nodeService.getProperty(versionNodeRef, PROP_NAME_QNAME));
assertEquals(TEST_VALUE_2, this.nodeService.getProperty(origNodeRef, PROP_NAME_QNAME));
assertEquals(TEST_VALUE_2, nodeService.getProperty(versionNodeRef, PROP_NAME_QNAME));
assertEquals(TEST_VALUE_2, nodeService.getProperty(origNodeRef, PROP_NAME_QNAME));
// Check that the other properties are updated during the check-in
assertEquals(TEST_VALUE_3, this.nodeService.getProperty(versionNodeRef, PROP2_QNAME));
assertEquals(TEST_VALUE_3, this.nodeService.getProperty(origNodeRef, PROP2_QNAME));
assertEquals(TEST_VALUE_3, nodeService.getProperty(versionNodeRef, PROP2_QNAME));
assertEquals(TEST_VALUE_3, nodeService.getProperty(origNodeRef, PROP2_QNAME));
// Cancel the check out after is has been left checked out
this.cociService.cancelCheckout(workingCopy3);
cociService.cancelCheckout(workingCopy3);
// Test keep checked out flag
NodeRef workingCopy2 = checkout();
Map<String, Serializable> versionProperties2 = new HashMap<String, Serializable>();
versionProperties2.put(Version.PROP_DESCRIPTION, "Another version test");
this.cociService.checkin(workingCopy2, versionProperties2, null, true);
this.cociService.checkin(workingCopy2, new HashMap<String, Serializable>(), null, true);
cociService.checkin(workingCopy2, versionProperties2, null, true);
cociService.checkin(workingCopy2, new HashMap<String, Serializable>(), null, true);
}
public void testCheckInWithNameChange()
{
// Check out the file
NodeRef fileWorkingCopyNodeRef = cociService.checkout(fileNodeRef);
// Make sure we can get the checked out node
NodeRef fileWorkingCopyNodeRefCheck = cociService.getWorkingCopy(fileNodeRef);
assertEquals("Working copy not found ", fileWorkingCopyNodeRef, fileWorkingCopyNodeRefCheck);
// Rename the working copy
nodeService.setProperty(fileWorkingCopyNodeRef, ContentModel.PROP_NAME, "renamed");
// Check in
cociService.checkin(fileWorkingCopyNodeRef, null);
}
public void testCheckOutCheckInWithTranslatableAspect()
{
// Create a node to be used as the translation
NodeRef translationNodeRef = this.nodeService.createNode(
NodeRef translationNodeRef = nodeService.createNode(
rootNodeRef,
ContentModel.ASSOC_CHILDREN,
QName.createQName("translation"),
ContentModel.TYPE_CONTENT).getChildRef();
this.nodeService.addAspect(this.nodeRef, QName.createQName(NamespaceService.CONTENT_MODEL_1_0_URI, "translatable"), null);
this.nodeService.createAssociation(this.nodeRef, translationNodeRef, QName.createQName(NamespaceService.CONTENT_MODEL_1_0_URI, "translations"));
nodeService.addAspect(this.nodeRef, QName.createQName(NamespaceService.CONTENT_MODEL_1_0_URI, "translatable"), null);
nodeService.createAssociation(this.nodeRef, translationNodeRef, QName.createQName(NamespaceService.CONTENT_MODEL_1_0_URI, "translations"));
// Check it out
NodeRef workingCopy = this.cociService.checkout(
NodeRef workingCopy = cociService.checkout(
this.nodeRef,
this.rootNodeRef,
ContentModel.ASSOC_CHILDREN,
@@ -303,7 +340,7 @@ public class CheckOutCheckInServiceImplTest extends BaseSpringTest
// Check it back in again
Map<String, Serializable> versionProperties = new HashMap<String, Serializable>();
versionProperties.put(Version.PROP_DESCRIPTION, "This is a test version");
this.cociService.checkin(workingCopy, versionProperties);
cociService.checkin(workingCopy, versionProperties);
}
/**
@@ -316,7 +353,7 @@ public class CheckOutCheckInServiceImplTest extends BaseSpringTest
bagOfProps.put(ContentModel.PROP_CONTENT, new ContentData(null, MimetypeMap.MIMETYPE_TEXT_PLAIN, 0L, "UTF-8"));
// Create a new node
ChildAssociationRef childAssocRef = this.nodeService.createNode(
ChildAssociationRef childAssocRef = nodeService.createNode(
rootNodeRef,
ContentModel.ASSOC_CHILDREN,
QName.createQName("test"),
@@ -325,8 +362,8 @@ public class CheckOutCheckInServiceImplTest extends BaseSpringTest
NodeRef noVersionNodeRef = childAssocRef.getChildRef();
// Check out and check in
NodeRef workingCopy = this.cociService.checkout(noVersionNodeRef);
this.cociService.checkin(workingCopy, new HashMap<String, Serializable>());
NodeRef workingCopy = cociService.checkout(noVersionNodeRef);
cociService.checkin(workingCopy, new HashMap<String, Serializable>());
// Check that the origional node has no version history dispite sending verion props
assertNull(this.versionService.getVersionHistory(noVersionNodeRef));
@@ -350,7 +387,7 @@ public class CheckOutCheckInServiceImplTest extends BaseSpringTest
// Good the origional is locked
}
NodeRef origNodeRef = this.cociService.cancelCheckout(workingCopy);
NodeRef origNodeRef = cociService.cancelCheckout(workingCopy);
assertEquals(this.nodeRef, origNodeRef);
// The origional should no longer be locked
@@ -358,7 +395,7 @@ public class CheckOutCheckInServiceImplTest extends BaseSpringTest
}
/**
* Test the deleting a wokring copy node removed the lock on the origional node
* Test the deleting a wokring copy node removed the lock on the original node
*/
public void testAutoCancelCheckOut()
{
@@ -368,38 +405,44 @@ public class CheckOutCheckInServiceImplTest extends BaseSpringTest
try
{
this.lockService.checkForLock(this.nodeRef);
fail("The origional should be locked now.");
fail("The original should be locked now.");
}
catch (Throwable exception)
{
// Good the origional is locked
// Good the original is locked
}
// Delete the working copy
this.nodeService.deleteNode(workingCopy);
nodeService.deleteNode(workingCopy);
// The origional should no longer be locked
// The original should no longer be locked
this.lockService.checkForLock(this.nodeRef);
}
/**
* Test the getWorkingCopy method
* @see CheckOutCheckInService#getWorkingCopy(NodeRef)
* @see CheckOutCheckInService#getCheckedOut(NodeRef)
*/
public void testGetWorkingCopy()
public void testBidirectionalReferences()
{
NodeRef origNodeRef = this.nodeService.createNode(
final NodeRef origNodeRef = nodeService.createNode(
this.rootNodeRef,
ContentModel.ASSOC_CHILDREN,
QName.createQName("test2"),
ContentModel.TYPE_CONTENT).getChildRef();
NodeRef wk1 = this.cociService.getWorkingCopy(origNodeRef);
NodeRef wk1 = cociService.getWorkingCopy(origNodeRef);
assertNull(wk1);
// Check the document out
final NodeRef workingCopy = this.cociService.checkout(origNodeRef);
final NodeRef workingCopy = cociService.checkout(origNodeRef);
assertTrue("Expect cm:workingcopy aspect", nodeService.hasAspect(workingCopy, ContentModel.ASPECT_WORKING_COPY));
assertTrue("Expect cm:checkedOut aspect", nodeService.hasAspect(origNodeRef, ContentModel.ASPECT_CHECKED_OUT));
List<AssociationRef> targetAssocs = nodeService.getTargetAssocs(origNodeRef, ContentModel.ASSOC_WORKING_COPY_LINK);
assertEquals("Expect a 1:1 relationship", 1, targetAssocs.size());
List<AssociationRef> sourceAssocs = nodeService.getSourceAssocs(workingCopy, ContentModel.ASSOC_WORKING_COPY_LINK);
assertEquals("Expect a 1:1 relationship", 1, sourceAssocs.size());
// Need to commit the transaction in order to get the indexer to run
setComplete();
@@ -412,25 +455,27 @@ public class CheckOutCheckInServiceImplTest extends BaseSpringTest
{
public Object execute()
{
NodeRef wk2 = CheckOutCheckInServiceImplTest.this.cociService.getWorkingCopy(finalNodeRef);
NodeRef wk2 = cociService.getWorkingCopy(finalNodeRef);
assertNotNull(wk2);
assertEquals(workingCopy, wk2);
NodeRef orig2 = cociService.getCheckedOut(wk2);
assertNotNull(orig2);
assertEquals(origNodeRef, orig2);
CheckOutCheckInServiceImplTest.this.cociService.cancelCheckout(workingCopy);
cociService.cancelCheckout(workingCopy);
return null;
}
});
NodeRef wk3 = this.cociService.getWorkingCopy(this.nodeRef);
assertNull(wk3);
NodeRef wk3 = cociService.getWorkingCopy(this.nodeRef);
assertNull(wk3);
}
/**
* Test the getWorkingCopy method
*/
public void testETWOTWO_733()
{
NodeRef origNodeRef = this.nodeService.createNode(
NodeRef origNodeRef = nodeService.createNode(
this.rootNodeRef,
ContentModel.ASSOC_CHILDREN,
QName.createQName("test2"),
@@ -444,11 +489,11 @@ public class CheckOutCheckInServiceImplTest extends BaseSpringTest
QName.createQName("test6"),
false);
NodeRef wk1 = this.cociService.getWorkingCopy(origNodeRef);
NodeRef wk1 = cociService.getWorkingCopy(origNodeRef);
assertNull(wk1);
// Check the document out
final NodeRef workingCopy = this.cociService.checkout(origNodeRef);
final NodeRef workingCopy = cociService.checkout(origNodeRef);
// Need to commit the transaction in order to get the indexer to run
setComplete();
@@ -461,23 +506,23 @@ public class CheckOutCheckInServiceImplTest extends BaseSpringTest
{
public Object execute()
{
NodeRef wk2 = CheckOutCheckInServiceImplTest.this.cociService.getWorkingCopy(finalNodeRef);
NodeRef wk2 = cociService.getWorkingCopy(finalNodeRef);
assertNotNull(wk2);
assertEquals(workingCopy, wk2);
CheckOutCheckInServiceImplTest.this.cociService.cancelCheckout(workingCopy);
cociService.cancelCheckout(workingCopy);
return null;
}
});
NodeRef wk3 = this.cociService.getWorkingCopy(this.nodeRef);
NodeRef wk3 = cociService.getWorkingCopy(this.nodeRef);
assertNull(wk3);
}
public void testAR1056()
{
// Check out the node
NodeRef workingCopy = this.cociService.checkout(
NodeRef workingCopy = cociService.checkout(
this.nodeRef,
this.rootNodeRef,
ContentModel.ASSOC_CHILDREN,
@@ -487,7 +532,7 @@ public class CheckOutCheckInServiceImplTest extends BaseSpringTest
// Try and check the same node out again
try
{
this.cociService.checkout(
cociService.checkout(
this.nodeRef,
this.rootNodeRef,
ContentModel.ASSOC_CHILDREN,
@@ -496,9 +541,8 @@ public class CheckOutCheckInServiceImplTest extends BaseSpringTest
}
catch (Exception exception)
{
// Good because we shouldnt be able to checkout a document twice
// Good because we shouldn't be able to checkout a document twice
}
}
public void testMultipleCheckoutsCheckInsWithPropChange()
@@ -506,7 +550,7 @@ public class CheckOutCheckInServiceImplTest extends BaseSpringTest
// Note: this test assumes cm:autoVersionProps=true by default (refer to cm:versionableAspect in contentModel.xml)
// Create a new node
ChildAssociationRef childAssocRef = this.nodeService.createNode(
ChildAssociationRef childAssocRef = nodeService.createNode(
rootNodeRef,
ContentModel.ASSOC_CHILDREN,
QName.createQName("test"),
@@ -515,7 +559,7 @@ public class CheckOutCheckInServiceImplTest extends BaseSpringTest
final NodeRef testNodeRef = childAssocRef.getChildRef();
// Add the version aspect to the created node
this.nodeService.addAspect(testNodeRef, ContentModel.ASPECT_VERSIONABLE, null);
nodeService.addAspect(testNodeRef, ContentModel.ASPECT_VERSIONABLE, null);
setComplete();
endTransaction();
@@ -598,9 +642,9 @@ public class CheckOutCheckInServiceImplTest extends BaseSpringTest
String adminUser = AuthenticationUtil.getAdminUserName();
AuthenticationUtil.setFullyAuthenticatedUser(adminUser);
Serializable initModifieer = nodeService.getProperty(nodeRef, ContentModel.PROP_MODIFIER);
Serializable initModifieed = nodeService.getProperty(nodeRef, ContentModel.PROP_MODIFIED);
assertFalse("The initial modifier should not be Admin!", adminUser.equals(initModifieer));
Serializable initModifier = nodeService.getProperty(nodeRef, ContentModel.PROP_MODIFIER);
Serializable initModified = nodeService.getProperty(nodeRef, ContentModel.PROP_MODIFIED);
assertFalse("The initial modifier should not be Admin!", adminUser.equals(initModifier));
NodeRef copy = cociService.checkout(
nodeRef,
@@ -608,16 +652,16 @@ public class CheckOutCheckInServiceImplTest extends BaseSpringTest
ContentModel.ASSOC_CHILDREN,
QName.createQName("workingCopy"));
Serializable modifieer = nodeService.getProperty(nodeRef, ContentModel.PROP_MODIFIER);
assertEquals("Checkout should not cause the modifier to change!", initModifieer, modifieer);
Serializable modifieed = nodeService.getProperty(nodeRef, ContentModel.PROP_MODIFIED);
assertEquals("Checkout should not cause the modified date to change!", initModifieed, modifieed);
Serializable modifier = nodeService.getProperty(nodeRef, ContentModel.PROP_MODIFIER);
assertEquals("Checkout should not cause the modifier to change!", initModifier, modifier);
Serializable modified = nodeService.getProperty(nodeRef, ContentModel.PROP_MODIFIED);
assertEquals("Checkout should not cause the modified date to change!", initModified, modified);
cociService.cancelCheckout(copy);
modifieer = nodeService.getProperty(nodeRef, ContentModel.PROP_MODIFIER);
assertEquals("Checkout should not cause the modifier to change!", initModifieer, modifieer);
modifieed = nodeService.getProperty(nodeRef, ContentModel.PROP_MODIFIED);
assertEquals("Checkout should not cause the modified date to change!", initModifieed, modifieed);
modifier = nodeService.getProperty(nodeRef, ContentModel.PROP_MODIFIER);
assertEquals("Cancel checkout should not cause the modifier to change!", initModifier, modifier);
modified = nodeService.getProperty(nodeRef, ContentModel.PROP_MODIFIED);
assertEquals("Cancel checkout should not cause the modified date to change!", initModified, modified);
copy = cociService.checkout(
nodeRef,
@@ -628,8 +672,8 @@ public class CheckOutCheckInServiceImplTest extends BaseSpringTest
versionProperties.put(Version.PROP_DESCRIPTION, "This is a test version");
cociService.checkin(copy, versionProperties);
modifieer = nodeService.getProperty(nodeRef, ContentModel.PROP_MODIFIER);
assertEquals("The modifier should change to Admin after checkin!", adminUser, modifieer);
modifier = nodeService.getProperty(nodeRef, ContentModel.PROP_MODIFIER);
assertEquals("The modifier should change to Admin after checkin!", adminUser, modifier);
}
public void testCheckOutPermissions_ALF7680_ALF535()
@@ -645,7 +689,7 @@ public class CheckOutCheckInServiceImplTest extends BaseSpringTest
NodeRef node = createNodeWithPermission(folder1, userName, PermissionService.EDITOR);
// Check out the node
NodeRef workingCopy = this.cociService.checkout(
NodeRef workingCopy = cociService.checkout(
node,
folder1,
ContentModel.ASSOC_CHILDREN,
@@ -653,10 +697,10 @@ public class CheckOutCheckInServiceImplTest extends BaseSpringTest
// Ensure that the working copy was created and current user was set as owner
assertNotNull(workingCopy);
assertTrue(this.nodeService.hasAspect(workingCopy, ContentModel.ASPECT_WORKING_COPY));
assertEquals(this.userNodeRef, this.nodeService.getProperty(workingCopy, ContentModel.PROP_WORKING_COPY_OWNER));
assertTrue(nodeService.hasAspect(workingCopy, ContentModel.ASPECT_WORKING_COPY));
assertEquals(this.userNodeRef, nodeService.getProperty(workingCopy, ContentModel.PROP_WORKING_COPY_OWNER));
this.cociService.cancelCheckout(workingCopy);
cociService.cancelCheckout(workingCopy);
/*
* Testing working copy creation in a different folder.
@@ -668,7 +712,7 @@ public class CheckOutCheckInServiceImplTest extends BaseSpringTest
NodeRef folder2 = createFolderWithPermission(rootNodeRef, userName, PermissionService.ALL_PERMISSIONS);
// Check out the node
workingCopy = this.cociService.checkout(
workingCopy = cociService.checkout(
node,
folder2,
ContentModel.ASSOC_CHILDREN,
@@ -676,10 +720,10 @@ public class CheckOutCheckInServiceImplTest extends BaseSpringTest
// Ensure that the working copy was created and current user was set as owner
assertNotNull(workingCopy);
assertTrue(this.nodeService.hasAspect(workingCopy, ContentModel.ASPECT_WORKING_COPY));
assertEquals(this.userNodeRef, this.nodeService.getProperty(workingCopy, ContentModel.PROP_WORKING_COPY_OWNER));
assertTrue(nodeService.hasAspect(workingCopy, ContentModel.ASPECT_WORKING_COPY));
assertEquals(this.userNodeRef, nodeService.getProperty(workingCopy, ContentModel.PROP_WORKING_COPY_OWNER));
this.cociService.cancelCheckout(workingCopy);
cociService.cancelCheckout(workingCopy);
/*
* Testing working copy creation in a different folder.
@@ -692,7 +736,7 @@ public class CheckOutCheckInServiceImplTest extends BaseSpringTest
try
{
// Check out the node
workingCopy = this.cociService.checkout(
workingCopy = cociService.checkout(
node,
folder3,
ContentModel.ASSOC_CHILDREN,
@@ -717,7 +761,7 @@ public class CheckOutCheckInServiceImplTest extends BaseSpringTest
try
{
// Check out the node
workingCopy = this.cociService.checkout(
workingCopy = cociService.checkout(
node2,
folder3,
ContentModel.ASSOC_CHILDREN,
@@ -739,7 +783,7 @@ public class CheckOutCheckInServiceImplTest extends BaseSpringTest
authenticationComponent.setSystemUserAsCurrentUser();
// Create the folder
NodeRef folder = this.nodeService.createNode(
NodeRef folder = nodeService.createNode(
parent,
ContentModel.ASSOC_CHILDREN,
QName.createQName("TestFolder" + GUID.generate()),

86
source/java/org/alfresco/repo/coci/WorkingCopyAspect.java
View File

@@ -28,42 +28,30 @@ import org.alfresco.repo.copy.CopyBehaviourCallback;
import org.alfresco.repo.copy.CopyDetails;
import org.alfresco.repo.copy.CopyServicePolicies;
import org.alfresco.repo.copy.DefaultCopyBehaviourCallback;
import org.alfresco.repo.node.NodeServicePolicies;
import org.alfresco.repo.policy.JavaBehaviour;
import org.alfresco.repo.policy.PolicyComponent;
import org.alfresco.service.cmr.coci.CheckOutCheckInService;
import org.alfresco.service.cmr.lock.LockService;
import org.alfresco.service.cmr.lock.LockStatus;
import org.alfresco.service.cmr.repository.NodeRef;
import org.alfresco.service.cmr.repository.NodeService;
import org.alfresco.service.namespace.NamespaceService;
import org.alfresco.service.namespace.QName;
import org.alfresco.util.GUID;
public class WorkingCopyAspect implements CopyServicePolicies.OnCopyNodePolicy
{
/**
* Policy component
*/
private PolicyComponent policyComponent;
/**
* The node service
*/
private NodeService nodeService;
/**
* The lock service
*/
private LockService lockService;
private CheckOutCheckInService checkOutCheckInService;
/**
* The working copy aspect copy behaviour callback.
* */
*/
private WorkingCopyAspectCopyBehaviourCallback workingCopyAspectCopyBehaviourCallback = new WorkingCopyAspectCopyBehaviourCallback();
/**
* Sets the policy component
*
* @param policyComponent the policy component
*/
public void setPolicyComponent(PolicyComponent policyComponent)
{
@@ -72,8 +60,6 @@ public class WorkingCopyAspect implements CopyServicePolicies.OnCopyNodePolicy
/**
* Set the node service
*
* @param nodeService the node service
*/
public void setNodeService(NodeService nodeService)
{
@@ -82,14 +68,20 @@ public class WorkingCopyAspect implements CopyServicePolicies.OnCopyNodePolicy
/**
* Set the lock service
*
* @param lockService the lock service
*/
public void setLockService(LockService lockService)
{
this.lockService = lockService;
}
/**
* @param checkOutCheckInService the service dealing with working copies
*/
public void setCheckOutCheckInService(CheckOutCheckInService checkOutCheckInService)
{
this.checkOutCheckInService = checkOutCheckInService;
}
/**
* Initialise method
*/
@@ -97,19 +89,24 @@ public class WorkingCopyAspect implements CopyServicePolicies.OnCopyNodePolicy
{
// Register copy behaviour for the working copy aspect
this.policyComponent.bindClassBehaviour(
QName.createQName(NamespaceService.ALFRESCO_URI, "getCopyCallback"),
CopyServicePolicies.OnCopyNodePolicy.QNAME,
ContentModel.TYPE_CMOBJECT,
new JavaBehaviour(this, "getCopyCallback"));
this.policyComponent.bindClassBehaviour(
QName.createQName(NamespaceService.ALFRESCO_URI, "getCopyCallback"),
CopyServicePolicies.OnCopyNodePolicy.QNAME,
ContentModel.ASPECT_WORKING_COPY,
new JavaBehaviour(this, "getCopyCallback"));
this.policyComponent.bindClassBehaviour(
CopyServicePolicies.OnCopyNodePolicy.QNAME,
ContentModel.ASPECT_CHECKED_OUT,
new JavaBehaviour(this, "getCopyCallback"));
// register onBeforeDelete class behaviour for the working copy aspect
this.policyComponent.bindClassBehaviour(
QName.createQName(NamespaceService.ALFRESCO_URI, "beforeDeleteNode"),
NodeServicePolicies.BeforeDeleteNodePolicy.QNAME,
ContentModel.ASPECT_WORKING_COPY,
new JavaBehaviour(this, "beforeDeleteNode"));
new JavaBehaviour(this, "beforeDeleteWorkingCopy"));
// register onBeforeDelete class behaviour for the checked-out aspect
}
/**
@@ -117,23 +114,13 @@ public class WorkingCopyAspect implements CopyServicePolicies.OnCopyNodePolicy
*
* @param nodeRef the node reference about to be deleted
*/
public void beforeDeleteNode(NodeRef nodeRef)
public void beforeDeleteWorkingCopy(NodeRef nodeRef)
{
// Prior to deleting a working copy the lock on the origional node should be released
// Note: we do not call cancelCheckOut since this will also attempt to delete the node is question
if (this.nodeService.hasAspect(nodeRef, ContentModel.ASPECT_WORKING_COPY) == true &&
this.nodeService.hasAspect(nodeRef, ContentModel.ASPECT_COPIEDFROM) == true)
NodeRef checkedOutNodeRef = checkOutCheckInService.getCheckedOut(nodeRef);
if (checkedOutNodeRef != null)
{
// Get the origional node
NodeRef origNodeRef = (NodeRef)this.nodeService.getProperty(nodeRef, ContentModel.PROP_COPY_REFERENCE);
if (origNodeRef != null)
{
if (this.lockService.getLockStatus(origNodeRef).equals(LockStatus.NO_LOCK) == false)
{
// Release the lock on the origional node
this.lockService.unlock(origNodeRef);
}
}
lockService.unlock(checkedOutNodeRef);
nodeService.removeAspect(checkedOutNodeRef, ContentModel.ASPECT_CHECKED_OUT);
}
}
@@ -175,7 +162,9 @@ public class WorkingCopyAspect implements CopyServicePolicies.OnCopyNodePolicy
* Prevents copying off the {@link ContentModel#PROP_NAME <b>cm:name</b>} property.
*/
@Override
public Map<QName, Serializable> getCopyProperties(QName classQName, CopyDetails copyDetails,
public Map<QName, Serializable> getCopyProperties(
QName classQName,
CopyDetails copyDetails,
Map<QName, Serializable> properties)
{
if (classQName.equals(ContentModel.ASPECT_WORKING_COPY))
@@ -187,13 +176,12 @@ public class WorkingCopyAspect implements CopyServicePolicies.OnCopyNodePolicy
// Generate a new name for a new copy of a working copy
String newName = null;
// This is a copy of a working copy to a new node (not a check in). Try to derive a new name from the
// node it is checked out from
if (copyDetails.isTargetNodeIsNew() && copyDetails.getSourceNodeAspectQNames().contains(ContentModel.ASPECT_COPIEDFROM))
if (copyDetails.isTargetNodeIsNew())
{
NodeRef checkedOutFrom = (NodeRef) copyDetails.getSourceNodeProperties().get(
ContentModel.PROP_COPY_REFERENCE);
if (nodeService.exists(checkedOutFrom))
// This is a copy of a working copy to a new node (not a check in). Try to derive a new name from the
// node it is checked out from
NodeRef checkedOutFrom = checkOutCheckInService.getCheckedOut(copyDetails.getSourceNodeRef());
if (checkedOutFrom != null)
{
String oldName = (String) nodeService.getProperty(checkedOutFrom, ContentModel.PROP_NAME);
int extIndex = oldName.lastIndexOf('.');
@@ -201,6 +189,10 @@ public class WorkingCopyAspect implements CopyServicePolicies.OnCopyNodePolicy
+ "_" + GUID.generate() + oldName.substring(extIndex);
}
}
else
{
// This is a check-in i.e. a copy to an existing node, so keep a null cm:name
}
if (newName == null)
{