mirror of
https://github.com/Alfresco/alfresco-community-repo.git
synced 2025-06-30 18:15:39 +00:00
3e7141dc1a
git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@2005 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
570 lines
20 KiB
Java
570 lines
20 KiB
Java
/*
|
|
* 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.webservice;
|
|
|
|
import java.io.Serializable;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
import org.alfresco.repo.webservice.repository.UpdateResult;
|
|
import org.alfresco.repo.webservice.types.CML;
|
|
import org.alfresco.repo.webservice.types.CMLAddAspect;
|
|
import org.alfresco.repo.webservice.types.CMLAddChild;
|
|
import org.alfresco.repo.webservice.types.CMLCopy;
|
|
import org.alfresco.repo.webservice.types.CMLCreate;
|
|
import org.alfresco.repo.webservice.types.CMLCreateAssociation;
|
|
import org.alfresco.repo.webservice.types.CMLDelete;
|
|
import org.alfresco.repo.webservice.types.CMLMove;
|
|
import org.alfresco.repo.webservice.types.CMLRemoveAspect;
|
|
import org.alfresco.repo.webservice.types.CMLRemoveAssociation;
|
|
import org.alfresco.repo.webservice.types.CMLRemoveChild;
|
|
import org.alfresco.repo.webservice.types.CMLUpdate;
|
|
import org.alfresco.repo.webservice.types.NamedValue;
|
|
import org.alfresco.repo.webservice.types.ParentReference;
|
|
import org.alfresco.repo.webservice.types.Predicate;
|
|
import org.alfresco.repo.webservice.types.Reference;
|
|
import org.alfresco.service.cmr.repository.CopyService;
|
|
import org.alfresco.service.cmr.repository.NodeRef;
|
|
import org.alfresco.service.cmr.repository.NodeService;
|
|
import org.alfresco.service.cmr.search.SearchService;
|
|
import org.alfresco.service.namespace.NamespaceService;
|
|
import org.alfresco.service.namespace.QName;
|
|
import org.alfresco.util.PropertyMap;
|
|
|
|
/**
|
|
* @author Roy Wetherall
|
|
*/
|
|
public class CMLUtil
|
|
{
|
|
private static final String CREATE = "create";
|
|
private static final String ADD_ASPECT = "addAspect";
|
|
private static final String REMOVE_ASPECT = "removeAspect";
|
|
private static final String UPDATE = "update";
|
|
private static final String DELETE = "delete";
|
|
private static final String MOVE = "move";
|
|
private static final String COPY = "copy";
|
|
private static final String ADD_CHILD = "addChild";
|
|
private static final String REMOVE_CHILD = "removeChild";
|
|
private static final String CREATE_ASSOCIATION = "createAssociation";
|
|
private static final String REMOVE_ASSOCIATION = "removeAssociation";
|
|
|
|
private NodeService nodeService;
|
|
private SearchService searchService;
|
|
private NamespaceService namespaceService;
|
|
private CopyService copyService;
|
|
|
|
public void setNodeService(NodeService nodeService)
|
|
{
|
|
this.nodeService = nodeService;
|
|
}
|
|
|
|
public void setSearchService(SearchService searchService)
|
|
{
|
|
this.searchService = searchService;
|
|
}
|
|
|
|
public void setNamespaceService(NamespaceService namespaceService)
|
|
{
|
|
this.namespaceService = namespaceService;
|
|
}
|
|
|
|
public void setCopyService(CopyService copyService)
|
|
{
|
|
this.copyService = copyService;
|
|
}
|
|
|
|
/**
|
|
* Execute a cml update query.
|
|
*
|
|
* @param cml the cml objects
|
|
* @return the update result
|
|
*/
|
|
public UpdateResult[] executeCML(CML cml)
|
|
{
|
|
ExecutionContext context = new ExecutionContext();
|
|
List<UpdateResult> results = new ArrayList<UpdateResult>();
|
|
|
|
// Execute creates
|
|
CMLCreate[] creates = cml.getCreate();
|
|
if (creates != null)
|
|
{
|
|
for (CMLCreate create : creates)
|
|
{
|
|
executeCMLCreate(create, context, results);
|
|
}
|
|
}
|
|
|
|
// Exceute add aspect
|
|
CMLAddAspect[] addAspects = cml.getAddAspect();
|
|
if (addAspects != null)
|
|
{
|
|
for (CMLAddAspect addAspect : addAspects)
|
|
{
|
|
executeCMLAddAspect(addAspect, context, results);
|
|
}
|
|
}
|
|
|
|
// Execeute remove aspect
|
|
CMLRemoveAspect[] removeAspects = cml.getRemoveAspect();
|
|
if (removeAspects != null)
|
|
{
|
|
for (CMLRemoveAspect removeAspect : removeAspects)
|
|
{
|
|
executeCMLRemoveAspect(removeAspect, context, results);
|
|
}
|
|
}
|
|
|
|
// Execute update
|
|
CMLUpdate[] updates = cml.getUpdate();
|
|
if (updates != null)
|
|
{
|
|
for (CMLUpdate update : updates)
|
|
{
|
|
executeCMLUpdate(update, context, results);
|
|
}
|
|
}
|
|
|
|
// Execute delete
|
|
CMLDelete[] deletes = cml.getDelete();
|
|
if (deletes != null)
|
|
{
|
|
for (CMLDelete delete : deletes)
|
|
{
|
|
executeCMLDelete(delete, context, results);
|
|
}
|
|
}
|
|
|
|
// Execute move
|
|
CMLMove[] moves = cml.getMove();
|
|
if (moves != null)
|
|
{
|
|
for (CMLMove move : moves)
|
|
{
|
|
executeCMLMove(move, context, results);
|
|
}
|
|
}
|
|
|
|
// Execute copy
|
|
CMLCopy[] copies = cml.getCopy();
|
|
if (copies != null)
|
|
{
|
|
for (CMLCopy copy : copies)
|
|
{
|
|
executeCMLCopy(copy, context, results);
|
|
}
|
|
}
|
|
|
|
// Execute addChild
|
|
CMLAddChild[] addChildren = cml.getAddChild();
|
|
if (addChildren != null)
|
|
{
|
|
for (CMLAddChild addChild : addChildren)
|
|
{
|
|
executeCMLAddChild(addChild, context, results);
|
|
}
|
|
}
|
|
|
|
// Execute removeChild
|
|
CMLRemoveChild[] removeChildren = cml.getRemoveChild();
|
|
if (removeChildren != null)
|
|
{
|
|
for (CMLRemoveChild removeChild : removeChildren)
|
|
{
|
|
executeCMLRemoveChild(removeChild, context, results);
|
|
}
|
|
}
|
|
|
|
// Execute createAssociation
|
|
CMLCreateAssociation[] createAssocs = cml.getCreateAssociation();
|
|
if (createAssocs != null)
|
|
{
|
|
for (CMLCreateAssociation createAssoc : createAssocs)
|
|
{
|
|
executeCMLCreateAssociation(createAssoc, context, results);
|
|
}
|
|
}
|
|
|
|
// Execute removeAssociation
|
|
CMLRemoveAssociation[] removeAssocs = cml.getRemoveAssociation();
|
|
if (removeAssocs != null)
|
|
{
|
|
for (CMLRemoveAssociation removeAssoc : removeAssocs)
|
|
{
|
|
executeCMLRemoveAssociation(removeAssoc, context, results);
|
|
}
|
|
}
|
|
|
|
return results.toArray(new UpdateResult[results.size()]);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param create
|
|
* @param result
|
|
*/
|
|
private void executeCMLCreate(CMLCreate create, ExecutionContext context, List<UpdateResult> results)
|
|
{
|
|
// Get the detail of the parent
|
|
ParentReference parentReference = create.getParent();
|
|
NodeRef parentNodeRef = Utils.convertToNodeRef(
|
|
parentReference,
|
|
this.nodeService,
|
|
this.searchService,
|
|
this.namespaceService);
|
|
QName assocTypeQName = QName.createQName(parentReference.getAssociationType());
|
|
QName assocQName = QName.createQName(parentReference.getChildName());
|
|
|
|
// Get the type of the node to create
|
|
QName nodeTypeQName = QName.createQName(create.getType());
|
|
|
|
// Get the properties
|
|
PropertyMap properties = getPropertyMap(create.getProperty());
|
|
|
|
// Create the new node
|
|
NodeRef nodeRef = this.nodeService.createNode(parentNodeRef, assocTypeQName, assocQName, nodeTypeQName, properties).getChildRef();
|
|
|
|
// Store the node ref in the execution context (if appropraite)
|
|
String id = create.getId();
|
|
if (id != null && id.length() != 0)
|
|
{
|
|
context.addId(id, nodeRef);
|
|
}
|
|
|
|
results.add(createResult(CREATE, null, nodeRef));
|
|
}
|
|
|
|
private PropertyMap getPropertyMap(NamedValue[] namedValues)
|
|
{
|
|
PropertyMap properties = new PropertyMap();
|
|
if (namedValues != null)
|
|
{
|
|
for (NamedValue value : namedValues)
|
|
{
|
|
QName qname = QName.createQName(value.getName());
|
|
properties.put(qname, value.getValue());
|
|
}
|
|
}
|
|
return properties;
|
|
}
|
|
|
|
private UpdateResult createResult(String cmd, NodeRef sourceNodeRef, NodeRef destinationNodeRef)
|
|
{
|
|
UpdateResult result = new UpdateResult();
|
|
result.setStatement(cmd);
|
|
if (sourceNodeRef != null)
|
|
{
|
|
result.setSource(Utils.convertToReference(sourceNodeRef));
|
|
}
|
|
if (destinationNodeRef != null)
|
|
{
|
|
result.setDestination(Utils.convertToReference(destinationNodeRef));
|
|
}
|
|
// Sort out the count ???
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param addAspect
|
|
* @param result
|
|
*/
|
|
private void executeCMLAddAspect(CMLAddAspect addAspect, ExecutionContext context, List<UpdateResult> results)
|
|
{
|
|
// Get the node refs
|
|
List<NodeRef> nodeRefs = getNodeRefList(addAspect.getWhere_id(), addAspect.getWhere(), context);
|
|
|
|
// Get the aspect name and the properties
|
|
QName aspectQName = QName.createQName(addAspect.getAspect());
|
|
PropertyMap properties = getPropertyMap(addAspect.getProperty());
|
|
|
|
for (NodeRef nodeRef : nodeRefs)
|
|
{
|
|
// Add the aspect
|
|
this.nodeService.addAspect(nodeRef, aspectQName, properties);
|
|
|
|
// Create the result
|
|
results.add(createResult(ADD_ASPECT, nodeRef, nodeRef));
|
|
}
|
|
}
|
|
|
|
private void executeCMLRemoveAspect(CMLRemoveAspect removeAspect, ExecutionContext context, List<UpdateResult> results)
|
|
{
|
|
// Get the node refs
|
|
List<NodeRef> nodeRefs = getNodeRefList(removeAspect.getWhere_id(), removeAspect.getWhere(), context);
|
|
|
|
// Get the aspect name
|
|
QName aspectQName = QName.createQName(removeAspect.getAspect());
|
|
|
|
for (NodeRef nodeRef : nodeRefs)
|
|
{
|
|
// Add the aspect
|
|
this.nodeService.removeAspect(nodeRef, aspectQName);
|
|
|
|
// Create the result
|
|
results.add(createResult(REMOVE_ASPECT, nodeRef, nodeRef));
|
|
}
|
|
}
|
|
|
|
private List<NodeRef> getNodeRefList(String id, Predicate predicate, ExecutionContext context)
|
|
{
|
|
List<NodeRef> nodeRefs = new ArrayList<NodeRef>();
|
|
if (id != null && id.length() != 0)
|
|
{
|
|
NodeRef localNodeRef = context.getNodeRef(id);
|
|
if (localNodeRef != null)
|
|
{
|
|
nodeRefs.add(localNodeRef);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
nodeRefs = Utils.resolvePredicate(predicate, this.nodeService, this.searchService, this.namespaceService);
|
|
}
|
|
return nodeRefs;
|
|
}
|
|
|
|
private void executeCMLUpdate(CMLUpdate update, ExecutionContext context, List<UpdateResult> results)
|
|
{
|
|
// Get the nodes and properties
|
|
List<NodeRef> nodeRefs = getNodeRefList(update.getWhere_id(), update.getWhere(), context);
|
|
PropertyMap props = getPropertyMap(update.getProperty());
|
|
|
|
for (NodeRef nodeRef : nodeRefs)
|
|
{
|
|
// Update the property values
|
|
Map<QName, Serializable> currentProps = this.nodeService.getProperties(nodeRef);
|
|
currentProps.putAll(props);
|
|
this.nodeService.setProperties(nodeRef, currentProps);
|
|
|
|
// Get the result
|
|
results.add(createResult(UPDATE, nodeRef, nodeRef));
|
|
}
|
|
}
|
|
|
|
private void executeCMLDelete(CMLDelete delete, ExecutionContext context, List<UpdateResult> results)
|
|
{
|
|
List<NodeRef> nodeRefs = Utils.resolvePredicate(delete.getWhere(), this.nodeService, this.searchService, this.namespaceService);
|
|
for (NodeRef nodeRef : nodeRefs)
|
|
{
|
|
// Delete the node
|
|
this.nodeService.deleteNode(nodeRef);
|
|
|
|
// Create the result
|
|
results.add(createResult(DELETE, nodeRef, null));
|
|
}
|
|
}
|
|
|
|
private void executeCMLMove(CMLMove move, ExecutionContext context, List<UpdateResult> results)
|
|
{
|
|
NodeRef destinationNodeRef = getNodeRef(move.getTo_id(), move.getTo(), context);
|
|
if (destinationNodeRef != null)
|
|
{
|
|
QName assocType = null;
|
|
QName assocName = null;
|
|
if (move.getTo_id() != null)
|
|
{
|
|
assocType = QName.createQName(move.getAssociationType());
|
|
assocName = QName.createQName(move.getChildName());
|
|
}
|
|
else
|
|
{
|
|
assocType = QName.createQName(move.getTo().getAssociationType());
|
|
assocName = QName.createQName(move.getTo().getChildName());
|
|
}
|
|
|
|
List<NodeRef> nodesToMove = getNodeRefList(move.getWhere_id(), move.getWhere(), context);
|
|
for (NodeRef nodeToMove : nodesToMove)
|
|
{
|
|
NodeRef newNodeRef = this.nodeService.moveNode(nodeToMove, destinationNodeRef, assocType, assocName).getChildRef();
|
|
|
|
// Create the result
|
|
results.add(createResult(MOVE, nodeToMove, newNodeRef));
|
|
}
|
|
}
|
|
}
|
|
|
|
private NodeRef getNodeRef(String id, ParentReference parentReference, ExecutionContext context)
|
|
{
|
|
NodeRef nodeRef = null;
|
|
if (id != null && id.length() != 0)
|
|
{
|
|
nodeRef = context.getNodeRef(id);
|
|
}
|
|
else
|
|
{
|
|
nodeRef = Utils.convertToNodeRef(parentReference, this.nodeService, this.searchService, this.namespaceService);
|
|
}
|
|
|
|
return nodeRef;
|
|
}
|
|
|
|
private NodeRef getNodeRef(String id, Reference reference, ExecutionContext context)
|
|
{
|
|
NodeRef nodeRef = null;
|
|
if (id != null && id.length() != 0)
|
|
{
|
|
nodeRef = context.getNodeRef(id);
|
|
}
|
|
else
|
|
{
|
|
nodeRef = Utils.convertToNodeRef(reference, this.nodeService, this.searchService, this.namespaceService);
|
|
}
|
|
|
|
return nodeRef;
|
|
}
|
|
|
|
private void executeCMLCopy(CMLCopy copy, ExecutionContext context, List<UpdateResult> results)
|
|
{
|
|
NodeRef destinationNodeRef = getNodeRef(copy.getTo_id(), copy.getTo(), context);
|
|
if (destinationNodeRef != null)
|
|
{
|
|
QName assocType = null;
|
|
QName assocName = null;
|
|
if (copy.getTo_id() != null)
|
|
{
|
|
assocType = QName.createQName(copy.getAssociationType());
|
|
assocName = QName.createQName(copy.getChildName());
|
|
}
|
|
else
|
|
{
|
|
assocType = QName.createQName(copy.getTo().getAssociationType());
|
|
assocName = QName.createQName(copy.getTo().getChildName());
|
|
}
|
|
|
|
boolean copyChildren = false;
|
|
Boolean value = copy.getChildren();
|
|
if (value != null)
|
|
{
|
|
copyChildren = value.booleanValue();
|
|
}
|
|
|
|
List<NodeRef> nodesToCopy = getNodeRefList(copy.getWhere_id(), copy.getWhere(), context);
|
|
for (NodeRef nodeToCopy : nodesToCopy)
|
|
{
|
|
NodeRef newNodeRef = this.copyService.copy(nodeToCopy, destinationNodeRef, assocType, assocName, copyChildren);
|
|
|
|
// Create the result
|
|
results.add(createResult(COPY, nodeToCopy, newNodeRef));
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
private void executeCMLAddChild(CMLAddChild addChild, ExecutionContext context, List<UpdateResult> results)
|
|
{
|
|
NodeRef nodeRef = getNodeRef(addChild.getTo_id(), addChild.getTo(), context);
|
|
if (nodeRef != null)
|
|
{
|
|
QName assocType = null;
|
|
QName assocName = null;
|
|
if (addChild.getTo_id() != null)
|
|
{
|
|
assocType = QName.createQName(addChild.getAssociationType());
|
|
assocName = QName.createQName(addChild.getChildName());
|
|
}
|
|
else
|
|
{
|
|
assocType = QName.createQName(addChild.getTo().getAssociationType());
|
|
assocName = QName.createQName(addChild.getTo().getChildName());
|
|
}
|
|
|
|
List<NodeRef> whereNodeRefs = getNodeRefList(addChild.getWhere_id(), addChild.getWhere(), context);
|
|
for (NodeRef whereNodeRef : whereNodeRefs)
|
|
{
|
|
this.nodeService.addChild(nodeRef, whereNodeRef, assocType, assocName);
|
|
|
|
// Create the result
|
|
results.add(createResult(ADD_CHILD, nodeRef, whereNodeRef));
|
|
}
|
|
}
|
|
}
|
|
|
|
private void executeCMLRemoveChild(CMLRemoveChild removeChild, ExecutionContext context, List<UpdateResult> results)
|
|
{
|
|
NodeRef parentNodeRef = getNodeRef(removeChild.getFrom_id(), removeChild.getFrom(), context);
|
|
if (parentNodeRef != null)
|
|
{
|
|
List<NodeRef> childNodeRefs = getNodeRefList(removeChild.getWhere_id(), removeChild.getWhere(), context);
|
|
for (NodeRef childNodeRef : childNodeRefs)
|
|
{
|
|
this.nodeService.removeChild(parentNodeRef, childNodeRef);
|
|
|
|
// Create the result
|
|
results.add(createResult(REMOVE_CHILD, parentNodeRef, null));
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
private void executeCMLCreateAssociation(CMLCreateAssociation createAssoc, ExecutionContext context, List<UpdateResult> results)
|
|
{
|
|
QName assocType = QName.createQName(createAssoc.getAssociation());
|
|
if (assocType != null)
|
|
{
|
|
List<NodeRef> fromNodeRefs = getNodeRefList(createAssoc.getFrom_id(), createAssoc.getFrom(), context);
|
|
List<NodeRef> toNodeRefs = getNodeRefList(createAssoc.getTo_id(), createAssoc.getTo(), context);
|
|
for (NodeRef fromNodeRef : fromNodeRefs)
|
|
{
|
|
for (NodeRef toNodeRef : toNodeRefs)
|
|
{
|
|
this.nodeService.createAssociation(fromNodeRef, toNodeRef, assocType);
|
|
|
|
// Create the result
|
|
results.add(createResult(CREATE_ASSOCIATION, fromNodeRef, toNodeRef));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void executeCMLRemoveAssociation(CMLRemoveAssociation removeAssoc, ExecutionContext context, List<UpdateResult> results)
|
|
{
|
|
QName assocType = QName.createQName(removeAssoc.getAssociation());
|
|
if (assocType != null)
|
|
{
|
|
List<NodeRef> fromNodeRefs = getNodeRefList(removeAssoc.getFrom_id(), removeAssoc.getFrom(), context);
|
|
List<NodeRef> toNodeRefs = getNodeRefList(removeAssoc.getTo_id(), removeAssoc.getTo(), context);
|
|
for (NodeRef fromNodeRef : fromNodeRefs)
|
|
{
|
|
for (NodeRef toNodeRef : toNodeRefs)
|
|
{
|
|
this.nodeService.removeAssociation(fromNodeRef, toNodeRef, assocType);
|
|
|
|
// Create the result
|
|
results.add(createResult(REMOVE_ASSOCIATION, fromNodeRef, toNodeRef));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private class ExecutionContext
|
|
{
|
|
private Map<String, NodeRef> idMap = new HashMap<String, NodeRef>();
|
|
|
|
public void addId(String id, NodeRef nodeRef)
|
|
{
|
|
this.idMap.put(id, nodeRef);
|
|
}
|
|
|
|
public NodeRef getNodeRef(String id)
|
|
{
|
|
return this.idMap.get(id);
|
|
}
|
|
}
|
|
}
|