mirror of
https://github.com/Alfresco/alfresco-community-repo.git
synced 2025-07-24 17:32:48 +00:00
Moving to root below branch label
git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@2005 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
This commit is contained in:
Derek Hulley
757
source/java/org/alfresco/repo/copy/CopyServiceImpl.java
Normal file
757
source/java/org/alfresco/repo/copy/CopyServiceImpl.java
Normal file
@@ -0,0 +1,757 @@
|
||||
/*
|
||||
* Copyright (C) 2005 Alfresco, Inc.
|
||||
*
|
||||
* Licensed under the Mozilla Public License version 1.1
|
||||
* with a permitted attribution clause. You may obtain a
|
||||
* copy of the License at
|
||||
*
|
||||
* http://www.alfresco.org/legal/license.txt
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing,
|
||||
* software distributed under the License is distributed on an
|
||||
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
|
||||
* either express or implied. See the License for the specific
|
||||
* language governing permissions and limitations under the
|
||||
* License.
|
||||
*/
|
||||
package org.alfresco.repo.copy;
|
||||
|
||||
import java.io.Serializable;
|
||||
import java.util.Collection;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
|
||||
import org.alfresco.model.ContentModel;
|
||||
import org.alfresco.repo.policy.ClassPolicyDelegate;
|
||||
import org.alfresco.repo.policy.JavaBehaviour;
|
||||
import org.alfresco.repo.policy.PolicyComponent;
|
||||
import org.alfresco.repo.policy.PolicyScope;
|
||||
import org.alfresco.service.cmr.dictionary.AspectDefinition;
|
||||
import org.alfresco.service.cmr.dictionary.AssociationDefinition;
|
||||
import org.alfresco.service.cmr.dictionary.ClassDefinition;
|
||||
import org.alfresco.service.cmr.dictionary.DictionaryService;
|
||||
import org.alfresco.service.cmr.dictionary.InvalidTypeException;
|
||||
import org.alfresco.service.cmr.dictionary.PropertyDefinition;
|
||||
import org.alfresco.service.cmr.dictionary.DataTypeDefinition;
|
||||
import org.alfresco.service.cmr.dictionary.TypeDefinition;
|
||||
import org.alfresco.service.cmr.repository.AssociationRef;
|
||||
import org.alfresco.service.cmr.repository.ChildAssociationRef;
|
||||
import org.alfresco.service.cmr.repository.CopyService;
|
||||
import org.alfresco.service.cmr.repository.CopyServiceException;
|
||||
import org.alfresco.service.cmr.repository.NodeRef;
|
||||
import org.alfresco.service.cmr.repository.NodeService;
|
||||
import org.alfresco.service.cmr.repository.StoreRef;
|
||||
import org.alfresco.service.cmr.rule.RuleService;
|
||||
import org.alfresco.service.namespace.NamespaceService;
|
||||
import org.alfresco.service.namespace.QName;
|
||||
import org.alfresco.service.namespace.RegexQNamePattern;
|
||||
import org.alfresco.util.ParameterCheck;
|
||||
|
||||
/**
|
||||
* Node operations service implmentation.
|
||||
*
|
||||
* @author Roy Wetherall
|
||||
*/
|
||||
public class CopyServiceImpl implements CopyService
|
||||
{
|
||||
/**
|
||||
* The node service
|
||||
*/
|
||||
private NodeService nodeService;
|
||||
|
||||
/**
|
||||
* The dictionary service
|
||||
*/
|
||||
private DictionaryService dictionaryService;
|
||||
|
||||
/**
|
||||
* Policy component
|
||||
*/
|
||||
private PolicyComponent policyComponent;
|
||||
|
||||
/**
|
||||
* Rule service
|
||||
*/
|
||||
private RuleService ruleService;
|
||||
|
||||
/**
|
||||
* Policy delegates
|
||||
*/
|
||||
private ClassPolicyDelegate<CopyServicePolicies.OnCopyNodePolicy> onCopyNodeDelegate;
|
||||
private ClassPolicyDelegate<CopyServicePolicies.OnCopyCompletePolicy> onCopyCompleteDelegate;
|
||||
|
||||
/**
|
||||
* Set the node service
|
||||
*
|
||||
* @param nodeService the node service
|
||||
*/
|
||||
public void setNodeService(NodeService nodeService)
|
||||
{
|
||||
this.nodeService = nodeService;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the dictionary service
|
||||
*
|
||||
* @param dictionaryService the dictionary service
|
||||
*/
|
||||
public void setDictionaryService(DictionaryService dictionaryService)
|
||||
{
|
||||
this.dictionaryService = dictionaryService;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the policy component
|
||||
*
|
||||
* @param policyComponent the policy component
|
||||
*/
|
||||
public void setPolicyComponent(PolicyComponent policyComponent)
|
||||
{
|
||||
this.policyComponent = policyComponent;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the rule service
|
||||
*
|
||||
* @param ruleService the rule service
|
||||
*/
|
||||
public void setRuleService(RuleService ruleService)
|
||||
{
|
||||
this.ruleService = ruleService;
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialise method
|
||||
*/
|
||||
public void init()
|
||||
{
|
||||
// Register the policies
|
||||
this.onCopyNodeDelegate = this.policyComponent.registerClassPolicy(CopyServicePolicies.OnCopyNodePolicy.class);
|
||||
this.onCopyCompleteDelegate = this.policyComponent.registerClassPolicy(CopyServicePolicies.OnCopyCompletePolicy.class);
|
||||
|
||||
// Register policy behaviours
|
||||
this.policyComponent.bindClassBehaviour(
|
||||
QName.createQName(NamespaceService.ALFRESCO_URI, "onCopyNode"),
|
||||
ContentModel.ASPECT_COPIEDFROM,
|
||||
new JavaBehaviour(this, "copyAspectOnCopy"));
|
||||
this.policyComponent.bindClassBehaviour(
|
||||
QName.createQName(NamespaceService.ALFRESCO_URI, "onCopyComplete"),
|
||||
ContentModel.ASPECT_COPIEDFROM,
|
||||
new JavaBehaviour(this, "onCopyComplete"));
|
||||
}
|
||||
|
||||
/**
|
||||
* @see com.activiti.repo.node.copy.NodeCopyService#copy(com.activiti.repo.ref.NodeRef, com.activiti.repo.ref.NodeRef, com.activiti.repo.ref.QName, QName, boolean)
|
||||
*/
|
||||
public NodeRef copy(
|
||||
NodeRef sourceNodeRef,
|
||||
NodeRef destinationParent,
|
||||
QName destinationAssocTypeQName,
|
||||
QName destinationQName,
|
||||
boolean copyChildren)
|
||||
{
|
||||
// Check that all the passed values are not null
|
||||
ParameterCheck.mandatory("Source Node", sourceNodeRef);
|
||||
ParameterCheck.mandatory("Destination Parent", destinationParent);
|
||||
ParameterCheck.mandatory("Destination Association Name", destinationQName);
|
||||
|
||||
if (sourceNodeRef.getStoreRef().equals(destinationParent.getStoreRef()) == false)
|
||||
{
|
||||
// TODO We need to create a new node in the other store with the same id as the source
|
||||
|
||||
// Error - since at the moment we do not support cross store copying
|
||||
throw new UnsupportedOperationException("Copying nodes across stores is not currently supported.");
|
||||
}
|
||||
|
||||
// Recursively copy node
|
||||
Map<NodeRef, NodeRef> copiedChildren = new HashMap<NodeRef, NodeRef>();
|
||||
NodeRef copy = recursiveCopy(sourceNodeRef, destinationParent, destinationAssocTypeQName, destinationQName, copyChildren, copiedChildren);
|
||||
|
||||
// Foreach of the newly created copies call the copy complete policy
|
||||
for (Map.Entry<NodeRef, NodeRef> entry : copiedChildren.entrySet())
|
||||
{
|
||||
invokeCopyComplete(entry.getKey(), entry.getValue(), copiedChildren);
|
||||
}
|
||||
|
||||
return copy;
|
||||
}
|
||||
|
||||
/**
|
||||
* Invokes the copy complete policy for the node reference provided
|
||||
*
|
||||
* @param sourceNodeRef the source node reference
|
||||
* @param destinationNodeRef the destination node reference
|
||||
* @param copiedNodeRefs the map of copied node references
|
||||
*/
|
||||
private void invokeCopyComplete(
|
||||
NodeRef sourceNodeRef,
|
||||
NodeRef destinationNodeRef,
|
||||
Map<NodeRef, NodeRef> copiedNodeRefs)
|
||||
{
|
||||
QName sourceClassRef = this.nodeService.getType(sourceNodeRef);
|
||||
invokeCopyComplete(sourceClassRef, sourceNodeRef, destinationNodeRef, copiedNodeRefs);
|
||||
|
||||
// Get the source aspects
|
||||
Set<QName> sourceAspects = this.nodeService.getAspects(sourceNodeRef);
|
||||
for (QName sourceAspect : sourceAspects)
|
||||
{
|
||||
invokeCopyComplete(sourceAspect, sourceNodeRef, destinationNodeRef, copiedNodeRefs);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* @param typeQName
|
||||
* @param sourceNodeRef
|
||||
* @param destinationNodeRef
|
||||
* @param copiedNodeRefs
|
||||
*/
|
||||
private void invokeCopyComplete(
|
||||
QName typeQName,
|
||||
NodeRef sourceNodeRef,
|
||||
NodeRef destinationNodeRef,
|
||||
Map<NodeRef, NodeRef> copiedNodeRefs)
|
||||
{
|
||||
Collection<CopyServicePolicies.OnCopyCompletePolicy> policies = this.onCopyCompleteDelegate.getList(typeQName);
|
||||
if (policies.isEmpty() == true)
|
||||
{
|
||||
defaultOnCopyComplete(typeQName, sourceNodeRef, destinationNodeRef, copiedNodeRefs);
|
||||
}
|
||||
else
|
||||
{
|
||||
for (CopyServicePolicies.OnCopyCompletePolicy policy : policies)
|
||||
{
|
||||
policy.onCopyComplete(typeQName, sourceNodeRef, destinationNodeRef, copiedNodeRefs);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* @param typeQName
|
||||
* @param sourceNodeRef
|
||||
* @param destinationNodeRef
|
||||
* @param copiedNodeRefs
|
||||
*/
|
||||
private void defaultOnCopyComplete(
|
||||
QName typeQName,
|
||||
NodeRef sourceNodeRef,
|
||||
NodeRef destinationNodeRef,
|
||||
Map<NodeRef, NodeRef> copiedNodeRefs)
|
||||
{
|
||||
ClassDefinition classDefinition = this.dictionaryService.getClass(typeQName);
|
||||
if (classDefinition != null)
|
||||
{
|
||||
// Check the properties
|
||||
Map<QName,PropertyDefinition> propertyDefinitions = classDefinition.getProperties();
|
||||
for (Map.Entry<QName,PropertyDefinition> entry : propertyDefinitions.entrySet())
|
||||
{
|
||||
QName propertyTypeDefinition = entry.getValue().getDataType().getName();
|
||||
if (DataTypeDefinition.NODE_REF.equals(propertyTypeDefinition) == true ||
|
||||
DataTypeDefinition.ANY.equals(propertyTypeDefinition) == true)
|
||||
{
|
||||
// Re-set the node ref so that it is still relative (if appropriate)
|
||||
Serializable value = this.nodeService.getProperty(destinationNodeRef, entry.getKey());
|
||||
if (value != null && value instanceof NodeRef)
|
||||
{
|
||||
NodeRef nodeRef = (NodeRef)value;
|
||||
if (copiedNodeRefs.containsKey(nodeRef) == true)
|
||||
{
|
||||
NodeRef copiedNodeRef = copiedNodeRefs.get(nodeRef);
|
||||
this.nodeService.setProperty(destinationNodeRef, entry.getKey(), copiedNodeRef);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Copy the associations (child and target)
|
||||
Map<QName, AssociationDefinition> assocDefs = classDefinition.getAssociations();
|
||||
|
||||
// TODO: Need way of getting child assocs of a given type
|
||||
List<ChildAssociationRef> childAssocRefs = this.nodeService.getChildAssocs(destinationNodeRef);
|
||||
for (ChildAssociationRef childAssocRef : childAssocRefs)
|
||||
{
|
||||
if (assocDefs.containsKey(childAssocRef.getTypeQName()) &&
|
||||
childAssocRef.isPrimary() == false &&
|
||||
copiedNodeRefs.containsKey(childAssocRef.getChildRef()) == true)
|
||||
{
|
||||
// Remove the assoc and re-point to the new node
|
||||
this.nodeService.removeChild(destinationNodeRef, childAssocRef.getChildRef());
|
||||
this.nodeService.addChild(
|
||||
destinationNodeRef,
|
||||
copiedNodeRefs.get(childAssocRef.getChildRef()) ,
|
||||
childAssocRef.getTypeQName(),
|
||||
childAssocRef.getQName());
|
||||
}
|
||||
}
|
||||
|
||||
// TODO: Need way of getting assocs of a given type
|
||||
List<AssociationRef> nodeAssocRefs = this.nodeService.getTargetAssocs(destinationNodeRef, RegexQNamePattern.MATCH_ALL);
|
||||
for (AssociationRef nodeAssocRef : nodeAssocRefs)
|
||||
{
|
||||
if (assocDefs.containsKey(nodeAssocRef.getTypeQName()) &&
|
||||
copiedNodeRefs.containsKey(nodeAssocRef.getTargetRef()) == true)
|
||||
{
|
||||
// Remove the assoc and re-point to the new node
|
||||
this.nodeService.removeAssociation(
|
||||
destinationNodeRef,
|
||||
nodeAssocRef.getTargetRef(),
|
||||
nodeAssocRef.getTypeQName());
|
||||
this.nodeService.createAssociation(
|
||||
destinationNodeRef,
|
||||
copiedNodeRefs.get(nodeAssocRef.getTargetRef()),
|
||||
nodeAssocRef.getTypeQName());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Recursive copy algorithm
|
||||
*
|
||||
* @param sourceNodeRef
|
||||
* @param destinationParent
|
||||
* @param destinationAssocTypeQName
|
||||
* @param destinationQName
|
||||
* @param copyChildren
|
||||
* @param copiedChildren
|
||||
* @return
|
||||
*/
|
||||
private NodeRef recursiveCopy(
|
||||
NodeRef sourceNodeRef,
|
||||
NodeRef destinationParent,
|
||||
QName destinationAssocTypeQName,
|
||||
QName destinationQName,
|
||||
boolean copyChildren,
|
||||
Map<NodeRef, NodeRef> copiedChildren)
|
||||
{
|
||||
// Extract Type Definition
|
||||
QName sourceTypeRef = this.nodeService.getType(sourceNodeRef);
|
||||
TypeDefinition typeDef = dictionaryService.getType(sourceTypeRef);
|
||||
if (typeDef == null)
|
||||
{
|
||||
throw new InvalidTypeException(sourceTypeRef);
|
||||
}
|
||||
|
||||
// Establish the scope of the copy
|
||||
PolicyScope copyDetails = getCopyDetails(sourceNodeRef, destinationParent.getStoreRef(), true);
|
||||
|
||||
// Create collection of properties for type and mandatory aspects
|
||||
Map<QName, Serializable> typeProps = copyDetails.getProperties();
|
||||
Map<QName, Serializable> properties = new HashMap<QName, Serializable>();
|
||||
if (typeProps != null)
|
||||
{
|
||||
properties.putAll(typeProps);
|
||||
}
|
||||
for (AspectDefinition aspectDef : typeDef.getDefaultAspects())
|
||||
{
|
||||
Map<QName, Serializable> aspectProps = copyDetails.getProperties(aspectDef.getName());
|
||||
if (aspectProps != null)
|
||||
{
|
||||
properties.putAll(aspectProps);
|
||||
}
|
||||
}
|
||||
|
||||
// Create the new node
|
||||
ChildAssociationRef destinationChildAssocRef = this.nodeService.createNode(
|
||||
destinationParent,
|
||||
destinationAssocTypeQName,
|
||||
destinationQName,
|
||||
sourceTypeRef,
|
||||
properties);
|
||||
NodeRef destinationNodeRef = destinationChildAssocRef.getChildRef();
|
||||
copiedChildren.put(sourceNodeRef, destinationNodeRef);
|
||||
|
||||
// Prevent any rules being fired on the new destination node
|
||||
this.ruleService.disableRules(destinationNodeRef);
|
||||
try
|
||||
{
|
||||
// Apply the copy aspect to the new node
|
||||
Map<QName, Serializable> copyProperties = new HashMap<QName, Serializable>();
|
||||
copyProperties.put(ContentModel.PROP_COPY_REFERENCE, sourceNodeRef);
|
||||
this.nodeService.addAspect(destinationNodeRef, ContentModel.ASPECT_COPIEDFROM, copyProperties);
|
||||
|
||||
// Copy the aspects
|
||||
copyAspects(destinationNodeRef, copyDetails);
|
||||
|
||||
// Copy the associations
|
||||
copyAssociations(destinationNodeRef, copyDetails, copyChildren, copiedChildren);
|
||||
}
|
||||
finally
|
||||
{
|
||||
this.ruleService.enableRules(destinationNodeRef);
|
||||
}
|
||||
|
||||
return destinationNodeRef;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the copy details. This calls the appropriate policies that have been registered
|
||||
* against the node and aspect types in order to pick-up any type specific copy behaviour.
|
||||
* <p>
|
||||
* If no policies for a type are registered then the default copy takes place which will
|
||||
* copy all properties and associations in the ususal manner.
|
||||
*
|
||||
* @param sourceNodeRef the source node reference
|
||||
* @return the copy details
|
||||
*/
|
||||
private PolicyScope getCopyDetails(NodeRef sourceNodeRef, StoreRef destinationStoreRef, boolean copyToNewNode)
|
||||
{
|
||||
QName sourceClassRef = this.nodeService.getType(sourceNodeRef);
|
||||
PolicyScope copyDetails = new PolicyScope(sourceClassRef);
|
||||
|
||||
// Invoke the onCopy behaviour
|
||||
invokeOnCopy(sourceClassRef, sourceNodeRef, destinationStoreRef, copyToNewNode, copyDetails);
|
||||
|
||||
// TODO What do we do aboout props and assocs that are on the node node but not part of the type definition?
|
||||
|
||||
// Get the source aspects
|
||||
Set<QName> sourceAspects = this.nodeService.getAspects(sourceNodeRef);
|
||||
for (QName sourceAspect : sourceAspects)
|
||||
{
|
||||
// Invoke the onCopy behaviour
|
||||
invokeOnCopy(sourceAspect, sourceNodeRef, destinationStoreRef, copyToNewNode, copyDetails);
|
||||
}
|
||||
|
||||
return copyDetails;
|
||||
}
|
||||
|
||||
/**
|
||||
* Invoke the correct onCopy behaviour
|
||||
*
|
||||
* @param sourceClassRef source class reference
|
||||
* @param sourceNodeRef source node reference
|
||||
* @param copyDetails the copy details
|
||||
*/
|
||||
private void invokeOnCopy(
|
||||
QName sourceClassRef,
|
||||
NodeRef sourceNodeRef,
|
||||
StoreRef destinationStoreRef,
|
||||
boolean copyToNewNode,
|
||||
PolicyScope copyDetails)
|
||||
{
|
||||
Collection<CopyServicePolicies.OnCopyNodePolicy> policies = this.onCopyNodeDelegate.getList(sourceClassRef);
|
||||
if (policies.isEmpty() == true)
|
||||
{
|
||||
defaultOnCopy(sourceClassRef, sourceNodeRef, copyDetails);
|
||||
}
|
||||
else
|
||||
{
|
||||
for (CopyServicePolicies.OnCopyNodePolicy policy : policies)
|
||||
{
|
||||
policy.onCopyNode(sourceClassRef, sourceNodeRef, destinationStoreRef, copyToNewNode, copyDetails);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Default implementation of on copy, used when there is no policy specified for a class.
|
||||
*
|
||||
* @param classRef the class reference of the node being copied
|
||||
* @param sourceNodeRef the source node reference
|
||||
* @param copyDetails details of the state being copied
|
||||
*/
|
||||
private void defaultOnCopy(QName classRef, NodeRef sourceNodeRef, PolicyScope copyDetails)
|
||||
{
|
||||
ClassDefinition classDefinition = this.dictionaryService.getClass(classRef);
|
||||
if (classDefinition != null)
|
||||
{
|
||||
// Copy the properties
|
||||
Map<QName,PropertyDefinition> propertyDefinitions = classDefinition.getProperties();
|
||||
for (QName propertyName : propertyDefinitions.keySet())
|
||||
{
|
||||
Serializable propValue = this.nodeService.getProperty(sourceNodeRef, propertyName);
|
||||
copyDetails.addProperty(classDefinition.getName(), propertyName, propValue);
|
||||
}
|
||||
|
||||
// Copy the associations (child and target)
|
||||
Map<QName, AssociationDefinition> assocDefs = classDefinition.getAssociations();
|
||||
|
||||
// TODO: Need way of getting child assocs of a given type
|
||||
if (classDefinition.isContainer())
|
||||
{
|
||||
List<ChildAssociationRef> childAssocRefs = this.nodeService.getChildAssocs(sourceNodeRef);
|
||||
for (ChildAssociationRef childAssocRef : childAssocRefs)
|
||||
{
|
||||
if (assocDefs.containsKey(childAssocRef.getTypeQName()))
|
||||
{
|
||||
copyDetails.addChildAssociation(classDefinition.getName(), childAssocRef);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TODO: Need way of getting assocs of a given type
|
||||
List<AssociationRef> nodeAssocRefs = this.nodeService.getTargetAssocs(sourceNodeRef, RegexQNamePattern.MATCH_ALL);
|
||||
for (AssociationRef nodeAssocRef : nodeAssocRefs)
|
||||
{
|
||||
if (assocDefs.containsKey(nodeAssocRef.getTypeQName()))
|
||||
{
|
||||
copyDetails.addAssociation(classDefinition.getName(), nodeAssocRef);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Copies the properties for the node type onto the destination node.
|
||||
*
|
||||
* @param destinationNodeRef the destintaion node reference
|
||||
* @param copyDetails the copy details
|
||||
*/
|
||||
private void copyProperties(NodeRef destinationNodeRef, PolicyScope copyDetails)
|
||||
{
|
||||
Map<QName, Serializable> props = copyDetails.getProperties();
|
||||
if (props != null)
|
||||
{
|
||||
for (QName propName : props.keySet())
|
||||
{
|
||||
this.nodeService.setProperty(destinationNodeRef, propName, props.get(propName));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Applies the aspects (thus copying the associated properties) onto the destination node
|
||||
*
|
||||
* @param destinationNodeRef the destination node reference
|
||||
* @param copyDetails the copy details
|
||||
*/
|
||||
private void copyAspects(NodeRef destinationNodeRef, PolicyScope copyDetails)
|
||||
{
|
||||
Set<QName> apects = copyDetails.getAspects();
|
||||
for (QName aspect : apects)
|
||||
{
|
||||
if (this.nodeService.hasAspect(destinationNodeRef, aspect) == false)
|
||||
{
|
||||
// Add the aspect to the node
|
||||
this.nodeService.addAspect(
|
||||
destinationNodeRef,
|
||||
aspect,
|
||||
copyDetails.getProperties(aspect));
|
||||
}
|
||||
else
|
||||
{
|
||||
// Set each property on the destination node since the aspect has already been applied
|
||||
Map<QName, Serializable> aspectProps = copyDetails.getProperties(aspect);
|
||||
if (aspectProps != null)
|
||||
{
|
||||
for (Map.Entry<QName, Serializable> entry : aspectProps.entrySet())
|
||||
{
|
||||
this.nodeService.setProperty(destinationNodeRef, entry.getKey(), entry.getValue());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Copies the associations (child and target) for the node type and aspects onto the
|
||||
* destination node.
|
||||
* <p>
|
||||
* If copyChildren is true then all child nodes of primary child associations are copied
|
||||
* before they are associatied with the destination node.
|
||||
*
|
||||
* @param destinationNodeRef the destination node reference
|
||||
* @param copyDetails the copy details
|
||||
* @param copyChildren indicates whether the primary children are copied or not
|
||||
* @param copiedChildren set of children already copied
|
||||
*/
|
||||
private void copyAssociations(
|
||||
NodeRef destinationNodeRef,
|
||||
PolicyScope copyDetails,
|
||||
boolean copyChildren,
|
||||
Map<NodeRef, NodeRef> copiedChildren)
|
||||
{
|
||||
QName classRef = this.nodeService.getType(destinationNodeRef);
|
||||
copyChildAssociations(classRef, destinationNodeRef, copyDetails, copyChildren, copiedChildren);
|
||||
copyTargetAssociations(classRef, destinationNodeRef, copyDetails);
|
||||
|
||||
Set<QName> apects = copyDetails.getAspects();
|
||||
for (QName aspect : apects)
|
||||
{
|
||||
if (this.nodeService.hasAspect(destinationNodeRef, aspect) == false)
|
||||
{
|
||||
// Error since the aspect has not been added to the destination node (should never happen)
|
||||
throw new CopyServiceException("The aspect has not been added to the destination node.");
|
||||
}
|
||||
|
||||
copyChildAssociations(aspect, destinationNodeRef, copyDetails, copyChildren, copiedChildren);
|
||||
copyTargetAssociations(aspect, destinationNodeRef, copyDetails);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Copies the target associations onto the destination node reference.
|
||||
*
|
||||
* @param classRef the class reference
|
||||
* @param destinationNodeRef the destination node reference
|
||||
* @param copyDetails the copy details
|
||||
*/
|
||||
private void copyTargetAssociations(QName classRef, NodeRef destinationNodeRef, PolicyScope copyDetails)
|
||||
{
|
||||
List<AssociationRef> nodeAssocRefs = copyDetails.getAssociations(classRef);
|
||||
if (nodeAssocRefs != null)
|
||||
{
|
||||
for (AssociationRef assocRef : nodeAssocRefs)
|
||||
{
|
||||
// Add the association
|
||||
NodeRef targetRef = assocRef.getTargetRef();
|
||||
this.nodeService.createAssociation(destinationNodeRef, targetRef, assocRef.getTypeQName());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Copies the child associations onto the destiantion node reference.
|
||||
* <p>
|
||||
* If copyChildren is true then the nodes at the end of a primary assoc will be copied before they
|
||||
* are associated.
|
||||
*
|
||||
* @param classRef the class reference
|
||||
* @param destinationNodeRef the destination node reference
|
||||
* @param copyDetails the copy details
|
||||
* @param copyChildren indicates whether to copy the primary children
|
||||
*/
|
||||
private void copyChildAssociations(
|
||||
QName classRef,
|
||||
NodeRef destinationNodeRef,
|
||||
PolicyScope copyDetails,
|
||||
boolean copyChildren,
|
||||
Map<NodeRef, NodeRef> copiedChildren)
|
||||
{
|
||||
List<ChildAssociationRef> childAssocs = copyDetails.getChildAssociations(classRef);
|
||||
if (childAssocs != null)
|
||||
{
|
||||
for (ChildAssociationRef childAssoc : childAssocs)
|
||||
{
|
||||
if (copyChildren == true)
|
||||
{
|
||||
if (childAssoc.isPrimary() == true)
|
||||
{
|
||||
// Do not recurse further, if we've already copied this node
|
||||
if (copiedChildren.containsKey(childAssoc.getChildRef()) == false &&
|
||||
copiedChildren.containsValue(childAssoc.getChildRef()) == false)
|
||||
{
|
||||
// Copy the child
|
||||
recursiveCopy(
|
||||
childAssoc.getChildRef(),
|
||||
destinationNodeRef,
|
||||
childAssoc.getTypeQName(),
|
||||
childAssoc.getQName(),
|
||||
copyChildren,
|
||||
copiedChildren);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// Add the child
|
||||
NodeRef childRef = childAssoc.getChildRef();
|
||||
this.nodeService.addChild(destinationNodeRef, childRef, childAssoc.getTypeQName(), childAssoc.getQName());
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
NodeRef childRef = childAssoc.getChildRef();
|
||||
QName childType = this.nodeService.getType(childRef);
|
||||
|
||||
// TODO will need to remove this reference to the configurations association
|
||||
if (this.dictionaryService.isSubClass(childType, ContentModel.TYPE_CONFIGURATIONS) == true ||
|
||||
copyDetails.isChildAssociationRefAlwaysTraversed(classRef, childAssoc) == true)
|
||||
{
|
||||
if (copiedChildren.containsKey(childRef) == false)
|
||||
{
|
||||
// Always recursivly copy configuration folders
|
||||
recursiveCopy(
|
||||
childRef,
|
||||
destinationNodeRef,
|
||||
childAssoc.getTypeQName(),
|
||||
childAssoc.getQName(),
|
||||
true,
|
||||
copiedChildren);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// Add the child (will not be primary reguardless of its origional state)
|
||||
this.nodeService.addChild(destinationNodeRef, childRef, childAssoc.getTypeQName(), childAssoc.getQName());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Defer to the standard implementation with copyChildren set to false
|
||||
*
|
||||
* @see com.activiti.repo.node.copy.NodeCopyService#copy(com.activiti.repo.ref.NodeRef, com.activiti.repo.ref.NodeRef, com.activiti.repo.ref.QName)
|
||||
*/
|
||||
public NodeRef copy(
|
||||
NodeRef sourceNodeRef,
|
||||
NodeRef destinationParent,
|
||||
QName destinationAssocTypeQName,
|
||||
QName destinationQName)
|
||||
{
|
||||
return copy(
|
||||
sourceNodeRef,
|
||||
destinationParent,
|
||||
destinationAssocTypeQName,
|
||||
destinationQName,
|
||||
false);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see com.activiti.repo.node.copy.NodeCopyService#copy(com.activiti.repo.ref.NodeRef, com.activiti.repo.ref.NodeRef)
|
||||
*/
|
||||
public void copy(
|
||||
NodeRef sourceNodeRef,
|
||||
NodeRef destinationNodeRef)
|
||||
{
|
||||
// Check that the source and destination node are the same type
|
||||
if (this.nodeService.getType(sourceNodeRef).equals(this.nodeService.getType(destinationNodeRef)) == false)
|
||||
{
|
||||
// Error - can not copy objects that are of different types
|
||||
throw new CopyServiceException("The source and destination node must be the same type.");
|
||||
}
|
||||
|
||||
// Get the copy details
|
||||
PolicyScope copyDetails = getCopyDetails(sourceNodeRef, destinationNodeRef.getStoreRef(), false);
|
||||
|
||||
// Copy over the top of the destination node
|
||||
copyProperties(destinationNodeRef, copyDetails);
|
||||
copyAspects(destinationNodeRef, copyDetails);
|
||||
copyAssociations(destinationNodeRef, copyDetails, false, new HashMap<NodeRef, NodeRef>());
|
||||
}
|
||||
|
||||
/**
|
||||
* OnCopy behaviour registered for the copy aspect.
|
||||
* <p>
|
||||
* Doing nothing in this behaviour ensures that the copy aspect found on the source node does not get
|
||||
* copied onto the destination node.
|
||||
*
|
||||
* @param sourceClassRef the source class reference
|
||||
* @param sourceNodeRef the source node reference
|
||||
* @param copyDetails the copy details
|
||||
*/
|
||||
public void copyAspectOnCopy(
|
||||
QName classRef,
|
||||
NodeRef sourceNodeRef,
|
||||
StoreRef destinationStoreRef,
|
||||
boolean copyToNewNode,
|
||||
PolicyScope copyDetails)
|
||||
{
|
||||
// Do nothing. This will ensure that copy aspect on the source node does not get copied onto
|
||||
// the destination node.
|
||||
}
|
||||
|
||||
public void onCopyComplete(
|
||||
QName classRef,
|
||||
NodeRef sourceNodeRef,
|
||||
NodeRef destinationRef,
|
||||
Map<NodeRef, NodeRef> copyMap)
|
||||
{
|
||||
// Do nothing since we do not want the copy from aspect to be relative to the copied nodes
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user