Derek Hulley f0f74b86f1 Merged DEV/SWIFT to HEAD
27600: ALF-8522: MyBatis: Performance: ensure <association> elements are properly keyed
   27608: RINF 09 / RINF 10: DB-based paged query for get children (DocLib & CMIS) 
          - update FileFolder paging API
          - update GetChildren canned query sorting (to return sort props prior to batched pre-load)
   27614: RINF 09 / RINF 10: DB-based paged query for get children (DocLib & CMIS) 
          - add missing file (and fix my SmartSVN ignore unversioned list ;-)
          - follow-on to r27608
   27621: RINF 11: Extended generalized CannedQueryDAO to support common selects
          - MyBatis resultset termination included
          - RINF 11: Integrate existing CannedQueryDAO (ALF-8417)
          - RINF 11: Canned queries (ALF-7167)
   27623: RINF 09 / RINF 10: DB-based paged query for get children (DocLib & CMIS) 
          - if total count not requested then can cut-off permission checks (based on max items) and instead set "hasMore" flag (if applicable)
          - now used by Share DocLib folder tree listing (on LHS) - see ALF-6570
   27636: RINF 09 / RINF 10: DB-based getChildren
          - improvements to treenode (push down sort by name, get subfolders with max 1, remove redundant max check) - re: ALF-6570
          - add default child assoc sort (if no sort requested)
          - minor tweak to getChildren CQ trace logging
   27641: RINF 11: Extended generalized CannedQueryDAO
          - add temporary MyBatis workarounds for ResultHandler-based queries
            --> support unlimited queries for nested results maps (MyBatis #129)
            --> clear cache to return results on subsequent calls (MyBatis #58 ...)
   27642: RINF 16: Ordered associations: Added NodeService.setAssociations
          - All reordering, deleting and adding node by NodeService impl.
          - ALF-7405 (ALF-7404 RINF 16: Peer association enhancements)
   27643: ALF-8183 SVC 01: I18N List of values constraint.
          Added ListOfValuesConstraint.getDisplayLabel(constraintAllowableValue) method which uses the usual I18NUtil methods
             to retrieve a localised display-label for the LoV constraint values.
          These can be added to resource bundles in the usual way using a key as follows:
             listconstraint.test_list1.ABC=ABC display where "listconstraint." is a fixed prefix.
             "test_list1" is the shortform QName for the constraint with colon replaced by underscore.
             "ABC" is one of the allowed values for the named constraint.
          The test case changes & the associated model & property changes should make things clear.
   27644: Test cases for ChannelService.createChannel and ChannelService.getChannels
   27645: ALF-8183. I18N LIST constraint.
          This check-in ensures that requests for a LIST.value display label for:
             a non-existent value returns null
             an unlocalised value returns the allowableValue String from the model (backwards compatibility).
   27651: Fixing compile errors caused by moving NodeLocator classes.
   27652: RINF 09 / RINF 10: DB-based getChildren CQ
          - replace direct use of "sqlSessionTemplate" with "cannedQueryDAO"(RINF 11)
   27657: RINF 09: GetChildren CQ
          - temp fix for cm:modified (when qname does not exist) - TODO review
   27666: Support for ALF-8594: RSOLR 039: SOLR sorting
          - sorting for all single valued types
   27671: Ignore virtual tomcat build
   27673: Projects core, datamodel and solr now explicitly list their library dependencies and no longer include the 3rd party project
   27681: Added pub:channelInfo aspect tows:webasset and ws:section.
          Also ws:website now extends pub:DeliveryChannel.
		  Added new behaviours to section and website to ensure the channel info is populated.
   27682: Added example SOLR config dir and instructions on how to set up - simple dev set up only subject to lots of change
   27685: Cleanup: Removed non-javadoc; Removed unused methods; Added @override
   27689: Update SOLR test instance dependencies
   27692: ALF-8183 SVC 01: I18N Lost of values constraint.
          Added code to the FormService's PropertyFieldProcessor so that the allowedValues for a ListOfValuesConstraint
		  have both the allowed value and its localised display label, if there is one.
          Added English property values for the bpm:allowedStatus constraint and also for the LIST constraint in the FDK.
   27693: WCM-QS ML work - Have the webscript return more details on the node and its parents,
          and begin to use this in the UI to allow you to create as well as manage translations
   27695: Workaround/fix for ALF-5747. Incompatibilities with OpenOffice 3.3
          It looks like OOo 3.3.0 shipped with a missing component. The ConfigurationRegistry, which is used to remotely query the
		  OOo version, was not implemented in 3.3.0 and therefore gives an ugly (and unavoidable) exception on OOo startup.
          There's not much we can do here, beyond getting users to upgrade their OOo install.
          I've added a catch clause that detects this problem and emits a slightly friendlier warning to the log.
   27720: ALF-8532: WPUB: F148: Foundation API: Request that a node be published to the live environment
   27727: Removed duplicates
   27734: WCM-QS ML Updates to handle marking a node as an initial translation, and a start on creating translations
   27735: Fixed generics warning
   27736: Added PermissionService.getReaders(List<Long> aclIds)
          - Support for ALF-8335: RSOLR 013: DAOs and remote APIs for ACL changesets (ALF-7072)
          - Also cleaned up empty javadoc
   27739: Implemented NodeFilters and NodeFinders for AbstractChannelType and ChannelServiceImpl.
   27741: RINF 09: GetChildren CQ - fix sorting - with unit tests (for default Share DocLib fields)
          - partial ALF-8638
          - ALF-8584 (follow-on for r27657)
   27746: Start on linking the WCM-QS ML ui and the forms service for creating the translation
   27747: Added --INCLUDE: directive to SQL scripts to allow importing of DB-specific snippets
          - ALF-8498: SVC 06: Property holding comment count for a node
   27748: Web scripts for ACLs and ACL readers
          - Unit tests at all levels (Webscripts, Service and DAO)
          - Tweaks to the DB queries to support index-based sorting
          - Support for ALF-8335: RSOLR 013: DAOs and remote APIs for ACL changesets (ALF-7072)
   27753: Fixed enum naming
   27754: Undo changes to ChannelServiceImplIntegratedTest made in 27739 that broke the build
   27762: Part I: ALF-7992: RSOLR 024: Locale support for query: SOLR
          - restructure and split localisation from generic query parsing
          - Lucene impl migrated and tested
          - No SOLR impl yet
          - Fix CMIS QueyTest 
          - Fix references for LuceneQueryParser mostly to AbstractLuceneQueryParser
   27763: Initial implementation of ALF-8498. SVC 06: Property holding comment count for a node.
          This check-in adds a rollup property to hold the commentCount (fm:commentCount under fm:discussable).
          It adds registered behaviours for fm:post deletion/creation that will decrement/increment the commentCount for the discussable ancestor node.
          I've also added a new test class to test this rollup property. There was no existing test class at this level and indeed there is no
		  CommentService or DiscussionService. Instead the REST API of comment.put.desc.xml uses the ScriptNodeService to create the correct node structure.
		  Therefore the test code has had to do the same thing.
   27766: Slight reimpl of ALF-8498. Moved the rollup property onto its own aspect.
          So now we have fm:discussable, as before, for generic discussions and posts (including Explorer comments).
          And we have fm:commentsRollup which is only for rolling up Share comments.
   27777: WCM QS ML Forms config and related tweaks to support having newly created nodes made multilingual where required
   27781: Add repository project dependency for test context and debug
          - fixes model issue with SOLRAPIClientTest
   27782: SOLR - move back to dynamic catch all field which seems to be working
          -> simpler build and model management
   27810: ALF-8405 SiteAspect needs to handle child types of Site as well as Site itself
   27821: ALF-7070: Fixed SOLRSerializer to handle residual properties (not in dictionary)
   27828: RINF 11: Canned Queries (CQ)
          - update API post review .
          - add underlying pageRequest/pageResult for single page (or max items if skip is 0)
          - add hasMoreItems (ALF-8470) and update unit tests
          - return total count range - accurate count (if lower=upper), approximation (lower<upper) or more than (lower known, upper unknown)
          - update option to request total count with max (if cutoff/trimmed then returns unknown upper count)
   27829: RINF 09: GetChildren CQ - paging support for FileFolderService list
          - update impl wrt CQ API changes (follow-on to r27828)
          - add factory method to return CQ with common params & update FileFolderService
          - update CMIS getChildren (AlrescoCmisService)
          - update scripting layer (ScriptNode, ScriptPagingNodes)
          - update Share DocLib (including doclist & treenode)
          - ALF-8641 - add proto (UI subject to review) to demo Share DocLib requesting max total count (eg. "Showing items 1 - 50 of 1000++")
   27837: Moving the pdfbox, fontbox, jempbox libs from 1.3.1 to 1.5.0, which adds various bugfixes.
   27838: Web scripts for ACLs and ACL readers
           - Simplification of paging API for ACLs
           - Support for ALF-8335: RSOLR 013: DAOs and remote APIs for ACL changesets (ALF-7072)
   27839: SOLR ACL tracking client code and tests
           - Support for ALF-8335: RSOLR 013: ACL changesets client APIs (ALF-8463)
   27844: Build fix. Making SiteServiceImplTest more tolerant of preexisting sites.
   27845: Build fix. Making SiteServiceTest more tolerant of preexisting sites in databse.
   27846: Build fix relating to ALF-8183. An extra test constraint requires an increment to a assertion expectedValue in this test.
   27849: ALF-8532: WPUB: F148: Foundation API: Request that a node be published to the live environment
           - Added more necessary interfaces and framework code
   27850: RINF 09: GetChildren CQ - update sorting unit test + fixes
          - nulls sort 'low'
          - fix multi sort props
   27858: ALF-8532: WPUB: F148: Foundation API: Request that a node be published to the live environment
          - Initial cut of persisting publishing events (not tested yet) 
   27861: WCM QS ML webscript work - fix some issues, and start on webscript unit test
          Also updates a failing test with details of why it's failing (switch from JSON to XML some time ago)
   27864: Fix context minimal tests - web publishing context is already included from the high level context, and shouldn't be in the core one
   27867: ALF-8184: SVC 02: Encode and decode of forms itemId should be done in the REST layer and not in each individual form processor.
   27868: Sample Adobe Illustrator files from Linton, for use in testing future metadata/transformer support
   27869: Fixed ChannelServiceImplTest failures.
   27870: Created JBPM process definition to publish scheduled Publishing Events.
   27872: Sample Adobe Illustrator 3 file (PS not PDF based) from Linton, for use in testing future metadata/transformer support
   27874: OpenCMIS update
   27875: Change the Tika auto transformer to register aliases of mime types, as well as the canonical ones, for when Alfresco uses the alias
   27876: RINF 11: Permission checking in canned queries (ALF-8419)
   27877: RINF 39: Optimise GetChildren CQ for unsorted maxItems (ALF-8576)
   27878: RINF 09: Update FileFolderService - all list methods should use GetChildren CQ (ALF-8733)
   27882: ALF-8532: WPUB: F148: Foundation API: Request that a node be published to the live environment
          - Unit test for the publishing package serializer/deserializer 
   27885: Change order of publishing context so it comes after transfer service context. 
   27886: Fix for ALF-7992: RSOLR 024: Locale support for query: SOLR
          - d:mltext, d:text. d:content
          - phrase, term, prefix, wild, ranges, fuzzy etc
          - localised tokenisation
          - consistent tokenisation for cross language support ( phrase, term, prefix, wild, ranges, fuzzy etc)
          - CMIS related stuff to be tested later
   27897: Minor tweak to prevent repeated gets of the default locale when writing properties
   27900: WCM QS ML webscript tests
   27905: Fixed PostgreSQL HeartbeatTest: WorkflowDeployer was checking for read-only server too late
   27906: Remove unused imports
   27907: Used common SQL snippets for DB2 node inserts.

git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@28319 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
2011-06-09 21:14:18 +00:00

2013 lines
81 KiB
Java

/*
* Copyright (C) 2005-2010 Alfresco Software Limited.
*
* This file is part of Alfresco
*
* Alfresco is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Alfresco is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Alfresco. If not, see <http://www.gnu.org/licenses/>. */
package org.alfresco.repo.avm;
import java.io.IOException;
import java.io.OutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import org.alfresco.model.ContentModel;
import org.alfresco.model.WCMModel;
import org.alfresco.repo.avm.util.AVMUtil;
import org.alfresco.repo.domain.PropertyValue;
import org.alfresco.repo.node.AbstractNodeServiceImpl;
import org.alfresco.service.cmr.avm.AVMException;
import org.alfresco.service.cmr.avm.AVMExistsException;
import org.alfresco.service.cmr.avm.AVMNodeDescriptor;
import org.alfresco.service.cmr.avm.AVMNotFoundException;
import org.alfresco.service.cmr.avm.AVMService;
import org.alfresco.service.cmr.avm.AVMStoreDescriptor;
import org.alfresco.service.cmr.dictionary.AspectDefinition;
import org.alfresco.service.cmr.dictionary.ClassDefinition;
import org.alfresco.service.cmr.dictionary.DataTypeDefinition;
import org.alfresco.service.cmr.dictionary.DictionaryException;
import org.alfresco.service.cmr.dictionary.InvalidAspectException;
import org.alfresco.service.cmr.dictionary.InvalidTypeException;
import org.alfresco.service.cmr.dictionary.PropertyDefinition;
import org.alfresco.service.cmr.dictionary.TypeDefinition;
import org.alfresco.service.cmr.repository.AssociationExistsException;
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.CyclicChildRelationshipException;
import org.alfresco.service.cmr.repository.InvalidChildAssociationRefException;
import org.alfresco.service.cmr.repository.InvalidNodeRefException;
import org.alfresco.service.cmr.repository.InvalidStoreRefException;
import org.alfresco.service.cmr.repository.NodeRef;
import org.alfresco.service.cmr.repository.NodeService;
import org.alfresco.service.cmr.repository.Path;
import org.alfresco.service.cmr.repository.StoreExistsException;
import org.alfresco.service.cmr.repository.StoreRef;
import org.alfresco.service.cmr.repository.datatype.TypeConversionException;
import org.alfresco.service.namespace.NamespaceService;
import org.alfresco.service.namespace.QName;
import org.alfresco.service.namespace.QNamePattern;
import org.alfresco.util.Pair;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
* NodeService implementing facade over AVMService.
* @author britt
*/
public class AVMNodeService extends AbstractNodeServiceImpl implements NodeService
{
private static Log logger = LogFactory.getLog(AVMNodeService.class);
/**
* Flag for whether policy callbacks are made.
*/
private boolean fInvokePolicies = false;
/**
* Reference to AVMService.
*/
private AVMService fAVMService;
/**
* Set the AVMService. For Spring.
* @param service The AVMService instance.
*/
public void setAvmService(AVMService service)
{
fAVMService = service;
}
/**
* Default constructor.
*/
public AVMNodeService()
{
}
public void setInvokePolicies(boolean invoke)
{
fInvokePolicies = invoke;
}
/**
* Helper method to convert the <code>Serializable</code> value into a full,
* persistable {@link PropertyValue}.
* <p>
* Where the property definition is null, the value will take on the
* {@link DataTypeDefinition#ANY generic ANY} value.
* <p>
* Where the property definition specifies a multi-valued property but the
* value provided is not a collection, the value will be wrapped in a collection.
*
* @param propertyDef the property dictionary definition, may be null
* @param value the value, which will be converted according to the definition -
* may be null
* @return Returns the persistable property value
*/
protected PropertyValue makePropertyValue(PropertyDefinition propertyDef, Serializable value)
{
// get property attributes
QName propertyTypeQName = null;
if (propertyDef == null) // property not recognised
{
// allow it for now - persisting excess properties can be useful sometimes
propertyTypeQName = DataTypeDefinition.ANY;
}
else
{
propertyTypeQName = propertyDef.getDataType().getName();
// check that multi-valued properties are allowed
boolean isMultiValued = propertyDef.isMultiValued();
if (isMultiValued && !(value instanceof Collection<?>))
{
if (value != null)
{
// put the value into a collection
// the implementation gives back a Serializable list
value = (Serializable) Collections.singletonList(value);
}
}
else if (!isMultiValued && (value instanceof Collection<?>))
{
// we only allow this case if the property type is ANY
if (!propertyTypeQName.equals(DataTypeDefinition.ANY))
{
throw new DictionaryException(
"A single-valued property of this type may not be a collection: \n" +
" Property: " + propertyDef + "\n" +
" Type: " + propertyTypeQName + "\n" +
" Value: " + value);
}
}
}
try
{
PropertyValue propertyValue = new PropertyValue(propertyTypeQName, value);
// done
return propertyValue;
}
catch (TypeConversionException e)
{
throw new TypeConversionException(
"The property value is not compatible with the type defined for the property: \n" +
" property: " + (propertyDef == null ? "unknown" : propertyDef) + "\n" +
" value: " + value + "\n" +
" value type: " + value.getClass(),
e);
}
}
/**
* Extracts the externally-visible property from the {@link PropertyValue propertyValue}.
*
* @param propertyDef the model property definition - may be <tt>null</tt>
* @param propertyValue the persisted property
* @return Returns the value of the property in the format dictated by the property
* definition, or null if the property value is null
*/
protected Serializable makeSerializableValue(PropertyDefinition propertyDef, PropertyValue propertyValue)
{
if (propertyValue == null)
{
return null;
}
// get property attributes
QName propertyTypeQName = null;
if (propertyDef == null)
{
// allow this for now
propertyTypeQName = DataTypeDefinition.ANY;
}
else
{
propertyTypeQName = propertyDef.getDataType().getName();
}
try
{
Serializable value = propertyValue.getValue(propertyTypeQName);
// done
return value;
}
catch (TypeConversionException e)
{
throw new TypeConversionException(
"The property value is not compatible with the type defined for the property: \n" +
" property: " + (propertyDef == null ? "unknown" : propertyDef) + "\n" +
" property value: " + propertyValue,
e);
}
}
/**
* Gets a list of all available node store references
*
* @return Returns a list of store references
*/
public List<StoreRef> getStores()
{
// For AVM stores we fake up StoreRefs.
List<AVMStoreDescriptor> stores = fAVMService.getStores();
List<StoreRef> result = new ArrayList<StoreRef>();
for (AVMStoreDescriptor desc : stores)
{
String name = desc.getName();
result.add(new StoreRef(StoreRef.PROTOCOL_AVM, name));
}
return result;
}
/**
* Create a new AVM store.
* @param protocol the implementation protocol
* @param identifier the protocol-specific identifier
* @return Returns a reference to the store
* @throws StoreExistsException
*/
public StoreRef createStore(String protocol, String identifier) throws StoreExistsException
{
StoreRef result = new StoreRef(StoreRef.PROTOCOL_AVM, identifier);
// invokeBeforeCreateStore(ContentModel.TYPE_STOREROOT, result);
try
{
fAVMService.createStore(identifier);
NodeRef rootRef = getRootNode(result);
addAspect(rootRef, ContentModel.ASPECT_ROOT,
Collections.<QName, Serializable>emptyMap());
// invokeOnCreateStore(rootRef);
return result;
}
catch (AVMExistsException e)
{
throw new StoreExistsException(result, e);
}
}
/**
* @throws UnsupportedOperationException Always
*/
public void deleteStore(StoreRef storeRef) throws InvalidStoreRefException
{
throw new UnsupportedOperationException();
}
/**
* Does the indicated store exist?
* @param storeRef a reference to the store to look for
* @return Returns true if the store exists, otherwise false
*/
public boolean exists(StoreRef storeRef)
{
return fAVMService.getStore(storeRef.getIdentifier()) != null;
}
/**
* @param nodeRef a reference to the node to look for
* @return Returns true if the node exists, otherwise false
*/
public boolean exists(NodeRef nodeRef)
{
Pair<Integer, String> avmInfo = AVMNodeConverter.ToAVMVersionPath(nodeRef);
int version = avmInfo.getFirst();
String avmPath = avmInfo.getSecond();
return fAVMService.lookup(version, avmPath) != null;
}
/**
* Gets the ID of the last transaction that caused the node to change. This includes
* deletions, so it is possible that the node being referenced no longer exists.
* If the node never existed, then null is returned.
*
* @param nodeRef a reference to a current or previously existing node
* @return Returns the status of the node, or null if the node never existed
*/
public NodeRef.Status getNodeStatus(NodeRef nodeRef)
{
// TODO Need to find out if this is important and if so
// need to capture Transaction IDs.
return new NodeRef.Status(nodeRef, "Unknown", null, !exists(nodeRef));
}
/**
* @param storeRef a reference to an existing store
* @return Returns a reference to the root node of the store
* @throws InvalidStoreRefException if the store could not be found
*/
public NodeRef getRootNode(StoreRef storeRef) throws InvalidStoreRefException
{
String storeName = storeRef.getIdentifier();
if (fAVMService.getStore(storeName) != null)
{
return AVMNodeConverter.ToNodeRef(-1, storeName + ":/");
}
else
{
throw new InvalidStoreRefException(storeName +":/" + " not found.", storeRef);
}
}
/**
* @see #createNode(NodeRef, QName, QName, QName, Map)
*/
public ChildAssociationRef createNode(
NodeRef parentRef,
QName assocTypeQName,
QName assocQName,
QName nodeTypeQName)
throws InvalidNodeRefException, InvalidTypeException
{
return createNode(parentRef,
assocTypeQName,
assocQName,
nodeTypeQName,
new HashMap<QName, Serializable>());
}
/**
* Creates a new, non-abstract, real node as a primary child of the given parent node.
*
* @param parentRef the parent node
* @param assocTypeQName the type of the association to create. This is used
* for verification against the data dictionary.
* @param assocQName the qualified name of the association
* @param nodeTypeQName a reference to the node type
* @param properties optional map of properties to keyed by their qualified names
* @return Returns a reference to the newly created child association
* @throws InvalidNodeRefException if the parent reference is invalid
* @throws InvalidTypeException if the node type reference is not recognised
*
* @see org.alfresco.service.cmr.dictionary.DictionaryService
*/
public ChildAssociationRef createNode(
NodeRef parentRef,
QName assocTypeQName,
QName assocQName,
QName nodeTypeQName,
Map<QName, Serializable> properties)
throws InvalidNodeRefException, InvalidTypeException
{
// AVM stores only allow simple child associations.
if (!assocTypeQName.equals(ContentModel.ASSOC_CONTAINS))
{
throw new InvalidTypeException(assocTypeQName);
}
String nodeName = assocQName.getLocalName();
Pair<Integer, String> avmVersionPath = AVMNodeConverter.ToAVMVersionPath(parentRef);
int version = avmVersionPath.getFirst();
if (version >= 0)
{
throw new InvalidNodeRefException("Read only store.", parentRef);
}
String avmPath = avmVersionPath.getSecond();
// Invoke policy behavior.
// invokeBeforeUpdateNode(parentRef);
// invokeBeforeCreateNode(parentRef, assocTypeQName, assocQName, nodeTypeQName);
// Look up the type definition in the dictionary.
TypeDefinition nodeTypeDef = dictionaryService.getType(nodeTypeQName);
// Do the creates for supported types, or error out.
try
{
if (nodeTypeQName.equals(WCMModel.TYPE_AVM_PLAIN_FOLDER) ||
nodeTypeQName.equals(ContentModel.TYPE_FOLDER))
{
fAVMService.createDirectory(avmPath, nodeName);
}
else if (nodeTypeQName.equals(WCMModel.TYPE_AVM_PLAIN_CONTENT) ||
nodeTypeQName.equals(ContentModel.TYPE_CONTENT))
{
OutputStream os = fAVMService.createFile(avmPath, nodeName);
try
{
if (os != null) { os.close(); }
}
catch (IOException ioe)
{
logger.warn("Failed to close output stream when creating file '"+AVMUtil.extendAVMPath(avmPath, nodeName)+"'"+ioe.getMessage());
}
}
else if (nodeTypeQName.equals(WCMModel.TYPE_AVM_LAYERED_CONTENT))
{
NodeRef indirection = (NodeRef)properties.get(WCMModel.PROP_AVM_FILE_INDIRECTION);
if (indirection == null)
{
throw new InvalidTypeException("No Indirection Property", nodeTypeQName);
}
Pair<Integer, String> indVersionPath = AVMNodeConverter.ToAVMVersionPath(indirection);
fAVMService.createLayeredFile(indVersionPath.getSecond(), avmPath, nodeName);
}
else if (nodeTypeQName.equals(WCMModel.TYPE_AVM_LAYERED_FOLDER))
{
NodeRef indirection = (NodeRef)properties.get(WCMModel.PROP_AVM_DIR_INDIRECTION);
if (indirection == null)
{
throw new InvalidTypeException("No Indirection Property.", nodeTypeQName);
}
Pair<Integer, String> indVersionPath = AVMNodeConverter.ToAVMVersionPath(indirection);
fAVMService.createLayeredDirectory(indVersionPath.getSecond(), avmPath, nodeName);
}
else
{
throw new InvalidTypeException("Invalid node type for AVM.", nodeTypeQName);
}
properties.putAll(getDefaultProperties(nodeTypeDef));
addDefaultAspects(nodeTypeDef, avmPath, properties);
}
catch (AVMNotFoundException e)
{
throw new InvalidNodeRefException(avmPath + " not found.", parentRef);
}
catch (AVMExistsException e)
{
throw new InvalidNodeRefException("Child " + nodeName + " exists", parentRef);
}
String newAVMPath = AVMNodeConverter.ExtendAVMPath(avmPath, nodeName);
NodeRef childRef = AVMNodeConverter.ToNodeRef(-1, newAVMPath);
properties.putAll(getDefaultProperties(nodeTypeDef));
addDefaultAspects(nodeTypeDef, newAVMPath, properties);
Map<QName, PropertyValue> props = new HashMap<QName, PropertyValue>();
for (Map.Entry<QName, Serializable> entry : properties.entrySet())
{
QName propertyQName = entry.getKey();
if (isBuiltInProperty(propertyQName))
{
continue;
}
Serializable value = entry.getValue();
PropertyDefinition propertyDef = dictionaryService.getProperty(propertyQName);
PropertyValue propertyValue = makePropertyValue(propertyDef, value);
props.put(propertyQName, propertyValue);
}
fAVMService.setNodeProperties(newAVMPath, props);
ChildAssociationRef ref =
new ChildAssociationRef(assocTypeQName,
parentRef,
assocQName,
childRef,
true,
-1);
// invokeOnCreateNode(ref);
// invokeOnUpdateNode(parentRef);
// if (properties.size() != 0)
// {
// invokeOnUpdateProperties(childRef, new HashMap<QName, Serializable>(), properties);
// }
return ref;
}
/**
* Moves the primary location of the given node.
* <p>
* This involves changing the node's primary parent and possibly the name of the
* association referencing it.
* <p>
* If the new parent is in a different store from the original, then the entire
* node hierarchy is moved to the new store. Inter-store associations are not
* affected.
*
* @param nodeToMoveRef the node to move
* @param newParentRef the new parent of the moved node
* @param assocTypeQName the type of the association to create. This is used
* for verification against the data dictionary.
* @param assocQName the qualified name of the new child association
* @return Returns a reference to the newly created child association
* @throws InvalidNodeRefException if either the parent node or move node reference is invalid
* @throws CyclicChildRelationshipException if the child partakes in a cyclic relationship after the add
*
* @see #getPrimaryParent(NodeRef)
*/
public ChildAssociationRef moveNode(
NodeRef nodeToMoveRef,
NodeRef newParentRef,
QName assocTypeQName,
QName assocQName)
throws InvalidNodeRefException
{
// AVM stores only allow simple child associations.
if (!assocTypeQName.equals(ContentModel.ASSOC_CONTAINS))
{
throw new InvalidTypeException(assocTypeQName);
}
// Extract the parts from the source.
Pair<Integer, String> src = AVMNodeConverter.ToAVMVersionPath(nodeToMoveRef);
int srcVersion = src.getFirst();
if (srcVersion >= 0)
{
throw new InvalidNodeRefException("Read Only Store.", nodeToMoveRef);
}
String srcPath = src.getSecond();
String [] splitSrc = null;
try
{
splitSrc = AVMNodeConverter.SplitBase(srcPath);
}
catch (AVMException e)
{
throw new InvalidNodeRefException("Invalid src path.", nodeToMoveRef);
}
String srcParent = splitSrc[0];
if (srcParent == null)
{
throw new InvalidNodeRefException("Cannot rename root node.", nodeToMoveRef);
}
String srcName = splitSrc[1];
// Extract and setup the parts of the destination.
Pair<Integer, String> dst = AVMNodeConverter.ToAVMVersionPath(newParentRef);
if (dst.getFirst() >= 0)
{
throw new InvalidNodeRefException("Read Only Store.", newParentRef);
}
String dstParent = dst.getSecond();
String dstName = assocQName.getLocalName();
// TODO Invoke policy behavior. Not quite sure how to translate this.
// NodeRef oldParentRef = AVMNodeConverter.ToNodeRef(-1, srcParent);
// ChildAssociationRef oldAssocRef =
// new ChildAssociationRef(assocTypeQName,
// oldParentRef,
// QName.createQName(NamespaceService.CONTENT_MODEL_1_0_URI, srcName),
// nodeToMoveRef,
// true,
// -1);
// invokeBeforeDeleteChildAssociation(oldAssocRef);
String dstPath = AVMNodeConverter.ExtendAVMPath(dstParent, dstName);
NodeRef newChildRef = AVMNodeConverter.ToNodeRef(-1, dstPath);
// invokeBeforeUpdateNode(oldParentRef);
// invokeBeforeUpdateNode(newParentRef);
// Actually perform the rename and return a pseudo
// ChildAssociationRef.
try
{
fAVMService.rename(srcParent, srcName, dstParent, dstName);
ChildAssociationRef newAssocRef =
new ChildAssociationRef(assocTypeQName,
newParentRef,
assocQName,
newChildRef,
true,
-1);
// invokeOnCreateChildAssociation(newAssocRef);
// invokeOnDeleteChildAssociation(oldAssocRef);
// invokeOnUpdateNode(oldParentRef);
// invokeOnUpdateNode(newParentRef);
return newAssocRef;
}
catch (AVMNotFoundException e)
{
throw new InvalidNodeRefException("Non existent node.", nodeToMoveRef);
}
catch (AVMExistsException e)
{
throw new InvalidNodeRefException("Target already exists.", newParentRef);
}
catch (AVMException e)
{
throw new InvalidNodeRefException("Illegal move.", nodeToMoveRef);
}
}
/**
* Set the ordering index of the child association. This affects the ordering of
* of the return values of methods that return a set of children or child
* associations.
*
* @param childAssocRef the child association that must be moved in the order
* @param index an arbitrary index that will affect the return order
*
* @see #getChildAssocs(NodeRef)
* @see #getChildAssocs(NodeRef, QNamePattern, QNamePattern)
* @see ChildAssociationRef#getNthSibling()
*/
public void setChildAssociationIndex(
ChildAssociationRef childAssocRef,
int index)
throws InvalidChildAssociationRefException
{
// TODO We'll keep this a no-op unless there's a
// compelling reason to implement this capability
// for the AVM repository.
}
/**
* @param nodeRef
* @return Returns the type name
* @throws InvalidNodeRefException if the node could not be found
*
* @see org.alfresco.service.cmr.dictionary.DictionaryService
*/
public QName getType(NodeRef nodeRef) throws InvalidNodeRefException
{
Pair<Integer, String> avmVersionPath = AVMNodeConverter.ToAVMVersionPath(nodeRef);
AVMNodeDescriptor desc = fAVMService.lookup(avmVersionPath.getFirst(),
avmVersionPath.getSecond());
if (desc == null)
{
throw new InvalidNodeRefException(avmVersionPath.getSecond() + " not found.", nodeRef);
}
if (desc.isPlainDirectory())
{
return WCMModel.TYPE_AVM_PLAIN_FOLDER;
}
else if (desc.isPlainFile())
{
return WCMModel.TYPE_AVM_PLAIN_CONTENT;
}
else if (desc.isLayeredDirectory())
{
return WCMModel.TYPE_AVM_LAYERED_FOLDER;
}
else
{
return WCMModel.TYPE_AVM_LAYERED_CONTENT;
}
}
/**
* Re-sets the type of the node. Can be called in order specialise a node to a sub-type.
*
* This should be used with caution since calling it changes the type of the node and thus
* implies a different set of aspects, properties and associations. It is the calling codes
* responsibility to ensure that the node is in a approriate state after changing the type.
*
* @param nodeRef the node reference
* @param typeQName the type QName
*
* @since 1.1
*/
public void setType(NodeRef nodeRef, QName typeQName) throws InvalidNodeRefException
{
throw new UnsupportedOperationException("AVM Types are immutable.");
}
/**
* Applies an aspect to the given node. After this method has been called,
* the node with have all the aspect-related properties present
*
* @param nodeRef
* @param aspectTypeQName the aspect to apply to the node
* @param aspectProperties a minimum of the mandatory properties required for
* the aspect
* @throws InvalidNodeRefException
* @throws InvalidAspectException if the class reference is not to a valid aspect
*
* @see org.alfresco.service.cmr.dictionary.DictionaryService#getAspect(QName)
* @see org.alfresco.service.cmr.dictionary.ClassDefinition#getProperties()
*/
public void addAspect(
NodeRef nodeRef,
QName aspectTypeQName,
Map<QName, Serializable> aspectProperties)
throws InvalidNodeRefException, InvalidAspectException
{
// Check that the aspect exists.
AspectDefinition aspectDef = this.dictionaryService.getAspect(aspectTypeQName);
if (aspectDef == null)
{
throw new InvalidAspectException("The aspect is invalid: " + aspectTypeQName,
aspectTypeQName);
}
// Invoke policy behaviors.
// invokeBeforeUpdateNode(nodeRef);
// invokeBeforeAddAspect(nodeRef, aspectTypeQName);
// Crack the nodeRef.
Pair<Integer, String> avmVersionPath = AVMNodeConverter.ToAVMVersionPath(nodeRef);
int version = avmVersionPath.getFirst();
if (version >= 0)
{
throw new InvalidNodeRefException("Read Only node.", nodeRef);
}
String avmPath = avmVersionPath.getSecond();
// Accumulate properties.
Map<QName, Serializable> properties = new HashMap<QName, Serializable>();
// Add the supplied properties.
if (aspectProperties != null)
{
properties.putAll(aspectProperties);
}
// Now set any unspecified default properties for the aspect.
Map<QName, Serializable> defaultProperties = getDefaultProperties(aspectDef);
properties.putAll(defaultProperties);
// Now add any cascading aspects.
addDefaultAspects(aspectDef, avmPath, properties);
// Set the property values on the AVM Node.
if (properties.size() != 0)
{
Map<QName, PropertyValue> props = new HashMap<QName, PropertyValue>();
for (Map.Entry<QName, Serializable> entry : properties.entrySet())
{
QName propertyQName = entry.getKey();
if (isBuiltInProperty(propertyQName))
{
continue;
}
Serializable value = entry.getValue();
PropertyDefinition propertyDef = dictionaryService.getProperty(propertyQName);
PropertyValue propertyValue = makePropertyValue(propertyDef, value);
props.put(propertyQName, propertyValue);
}
if (props.size() != 0)
{
fAVMService.setNodeProperties(avmPath, props);
}
}
if (isBuiltinAspect(aspectTypeQName))
{
// No more work to do in this case.
return;
}
try
{
fAVMService.addAspect(avmPath, aspectTypeQName);
// Invoke policy behaviors.
// invokeOnUpdateNode(nodeRef);
// invokeOnAddAspect(nodeRef, aspectTypeQName);
}
catch (AVMNotFoundException e)
{
throw new InvalidNodeRefException(nodeRef);
}
}
/**
* Add any aspects that are mandatory for the ClassDefinition.
* @param classDef The ClassDefinition.
* @param path The path to the AVMNode.
* @param properties The in/out map of accumulated properties.
*/
private void addDefaultAspects(ClassDefinition classDef, String path,
Map<QName, Serializable> properties)
{
NodeRef nodeRef = AVMNodeConverter.ToNodeRef(-1, path);
// Get mandatory aspects.
List<AspectDefinition> defaultAspectDefs = classDef.getDefaultAspects();
// add all the aspects (and there dependent aspects recursively).
for (AspectDefinition def : defaultAspectDefs)
{
// invokeBeforeAddAspect(nodeRef, def.getName());
addAspect(nodeRef, def.getName(), Collections.<QName, Serializable>emptyMap());
properties.putAll(getDefaultProperties(def));
// invokeOnAddAspect(nodeRef, def.getName());
// recurse
addDefaultAspects(def, path, properties);
}
}
/**
* Remove an aspect and all related properties from a node
*
* @param nodeRef
* @param aspectTypeQName the type of aspect to remove
* @throws InvalidNodeRefException if the node could not be found
* @throws InvalidAspectException if the the aspect is unknown or if the
* aspect is mandatory for the <b>class</b> of the <b>node</b>
*/
public void removeAspect(NodeRef nodeRef, QName aspectTypeQName)
throws InvalidNodeRefException, InvalidAspectException
{
// Invoke policy behaviors.
// invokeBeforeUpdateNode(nodeRef);
// invokeBeforeRemoveAspect(nodeRef, aspectTypeQName);
AspectDefinition def = dictionaryService.getAspect(aspectTypeQName);
if (def == null)
{
throw new InvalidAspectException(aspectTypeQName);
}
if (isBuiltinAspect(aspectTypeQName))
{
// TODO shouldn't we be throwing some kind of exception here.
return;
}
Pair<Integer, String> avmVersionPath = AVMNodeConverter.ToAVMVersionPath(nodeRef);
int version = avmVersionPath.getFirst();
if (version >= 0)
{
throw new InvalidNodeRefException("Read Only Node.", nodeRef);
}
String path = avmVersionPath.getSecond();
try
{
if (fAVMService.hasAspect(-1, path, aspectTypeQName))
{
fAVMService.removeAspect(path, aspectTypeQName);
Map<QName, PropertyDefinition> propDefs = def.getProperties();
for (QName propertyName : propDefs.keySet())
{
fAVMService.deleteNodeProperty(path, propertyName);
}
}
// Invoke policy behaviors.
// invokeOnUpdateNode(nodeRef);
// invokeOnRemoveAspect(nodeRef, aspectTypeQName);
}
catch (AVMNotFoundException e)
{
throw new InvalidNodeRefException(nodeRef);
}
}
/**
* Determines if a given aspect is present on a node. Aspects may only be
* removed if they are <b>NOT</b> mandatory.
*
* @param nodeRef
* @param aspectTypeQName
* @return Returns true if the aspect has been applied to the given node,
* otherwise false
* @throws InvalidNodeRefException if the node could not be found
* @throws InvalidAspectException if the aspect reference is invalid
*/
public boolean hasAspect(NodeRef nodeRef, QName aspectTypeQName)
throws InvalidNodeRefException, InvalidAspectException
{
Pair<Integer, String> avmVersionPath = AVMNodeConverter.ToAVMVersionPath(nodeRef);
int version = avmVersionPath.getFirst();
String path = avmVersionPath.getSecond();
if (isBuiltinAspect(aspectTypeQName))
{
return true;
}
return fAVMService.hasAspect(version, path, aspectTypeQName);
}
private static QName [] fgBuiltinAspects = new QName[] { ContentModel.ASPECT_AUDITABLE,
ContentModel.ASPECT_REFERENCEABLE };
private boolean isBuiltinAspect(QName aspectQName)
{
for (QName builtin : fgBuiltinAspects)
{
if (builtin.equals(aspectQName))
{
return true;
}
}
return false;
}
/**
* @param nodeRef
* @return Returns a set of all aspects applied to the node, including mandatory
* aspects
* @throws InvalidNodeRefException if the node could not be found
*/
public Set<QName> getAspects(NodeRef nodeRef) throws InvalidNodeRefException
{
Pair<Integer, String> avmVersionPath = AVMNodeConverter.ToAVMVersionPath(nodeRef);
int version = avmVersionPath.getFirst();
String path = avmVersionPath.getSecond();
Set<QName> result = new HashSet<QName>();
// Add the builtin ones.
for (QName name : fgBuiltinAspects)
{
result.add(name);
}
try
{
for (QName name : fAVMService.getAspects(version, path))
{
result.add(name);
}
return result;
}
catch (AVMNotFoundException e)
{
throw new InvalidNodeRefException(nodeRef);
}
}
/**
* Deletes the given node.
* <p>
* All associations (both children and regular node associations)
* will be deleted, and where the given node is the primary parent,
* the children will also be cascade deleted.
*
* @param nodeRef reference to a node within a store
* @throws InvalidNodeRefException if the reference given is invalid
*/
public void deleteNode(NodeRef nodeRef) throws InvalidNodeRefException
{
// Invoke policy behaviors.
// invokeBeforeDeleteNode(nodeRef);
Pair<Integer, String> avmVersionPath = AVMNodeConverter.ToAVMVersionPath(nodeRef);
if (avmVersionPath.getFirst() != -1)
{
throw new InvalidNodeRefException("Read only store.", nodeRef);
}
String [] avmPathBase = AVMNodeConverter.SplitBase(avmVersionPath.getSecond());
if (avmPathBase[0] == null)
{
throw new InvalidNodeRefException("Cannot delete root node.", nodeRef);
}
try
{
// QName nodeTypeQName = getType(nodeRef);
// Set<QName> aspects = getAspects(nodeRef);
fAVMService.removeNode(avmPathBase[0], avmPathBase[1]);
// ChildAssociationRef childAssocRef =
// new ChildAssociationRef(ContentModel.ASSOC_CHILDREN,
// AVMNodeConverter.ToNodeRef(-1, avmPathBase[0]),
// QName.createQName(NamespaceService.CONTENT_MODEL_1_0_URI,
// avmPathBase[1]),
// nodeRef);
// invokeOnDeleteNode(childAssocRef, nodeTypeQName, aspects, false);
}
catch (AVMNotFoundException e)
{
throw new InvalidNodeRefException(avmVersionPath.getSecond() +" not found.", nodeRef);
}
}
/**
* Makes a parent-child association between the given nodes. Both nodes must belong to the same store.
* <p>
*
* @param parentRef
* @param childRef
* @param assocTypeQName the qualified name of the association type as defined in the datadictionary
* @param qname the qualified name of the association
* @return Returns a reference to the newly created child association
* @throws InvalidNodeRefException if the parent or child nodes could not be found
* @throws CyclicChildRelationshipException if the child partakes in a cyclic relationship after the add
*/
public ChildAssociationRef addChild(
NodeRef parentRef,
NodeRef childRef,
QName assocTypeQName,
QName qname) throws InvalidNodeRefException
{
return addChild(Collections.singletonList(parentRef), childRef, assocTypeQName, qname).get(0);
}
/**
* Associates a given child node with a given collection of parents. All nodes must belong to the same store.
* <p>
*
*
* @param parentRefs
* @param childRef
* @param assocTypeQName the qualified name of the association type as defined in the datadictionary
* @param qname the qualified name of the association
* @return Returns a reference to the newly created child association
* @throws InvalidNodeRefException if the parent or child nodes could not be found
* @throws CyclicChildRelationshipException if the child partakes in a cyclic relationship after the add
*/
public List<ChildAssociationRef> addChild(
Collection<NodeRef> parentRefs,
NodeRef childRef,
QName assocTypeQName,
QName qname) throws InvalidNodeRefException
{
Pair<Integer, String> childVersionPath = AVMNodeConverter.ToAVMVersionPath(childRef);
AVMNodeDescriptor child = fAVMService.lookup(childVersionPath.getFirst(),
childVersionPath.getSecond());
if (child == null)
{
throw new InvalidNodeRefException(childVersionPath.getSecond() + " not found.", childRef);
}
List<ChildAssociationRef> childAssociationRefs = new ArrayList<ChildAssociationRef>(parentRefs.size());
for (NodeRef parentRef : parentRefs)
{
Pair<Integer, String> parentVersionPath = AVMNodeConverter.ToAVMVersionPath(parentRef);
if (parentVersionPath.getFirst() >= 0)
{
throw new InvalidNodeRefException("Read Only.", parentRef);
}
try
{
fAVMService.link(parentVersionPath.getSecond(), qname.getLocalName(), child);
ChildAssociationRef newChild = new ChildAssociationRef(assocTypeQName, parentRef, qname,
AVMNodeConverter.ToNodeRef(-1, AVMNodeConverter.ExtendAVMPath(parentVersionPath.getSecond(),
qname.getLocalName())));
childAssociationRefs.add(newChild);
}
catch (AVMException e)
{
throw new InvalidNodeRefException("Could not link.", childRef);
}
}
return childAssociationRefs;
}
/**
* Severs all parent-child relationships between two nodes.
* <p>
* The child node will be cascade deleted if one of the associations was the
* primary association, i.e. the one with which the child node was created.
*
* @param parentRef the parent end of the association
* @param childRef the child end of the association
* @throws InvalidNodeRefException if the parent or child nodes could not be found
*/
public void removeChild(NodeRef parentRef, NodeRef childRef) throws InvalidNodeRefException
{
Pair<Integer, String> parentVersionPath = AVMNodeConverter.ToAVMVersionPath(parentRef);
if (parentVersionPath.getFirst() >= 0)
{
throw new InvalidNodeRefException("Read only store.", parentRef);
}
Pair<Integer, String> childVersionPath = AVMNodeConverter.ToAVMVersionPath(childRef);
if (childVersionPath.getFirst() >= 0)
{
throw new InvalidNodeRefException("Read only store.", childRef);
}
String parentPath = parentVersionPath.getSecond();
String childPath = childVersionPath.getSecond();
String [] childPathBase = AVMNodeConverter.SplitBase(childPath);
if (childPathBase[0] == null || !childPathBase[0].equals(parentPath))
{
throw new InvalidNodeRefException(childPath + " not a child of " + parentPath, childRef);
}
try
{
// ChildAssociationRef assocRef =
// new ChildAssociationRef(ContentModel.ASSOC_CHILDREN,
// AVMNodeConverter.ToNodeRef(-1, parentPath),
// QName.createQName(NamespaceService.CONTENT_MODEL_1_0_URI,
// childPathBase[1]),
// AVMNodeConverter.ToNodeRef(-1, childPath));
// invokeBeforeDeleteChildAssociation(assocRef);
fAVMService.removeNode(childPathBase[0], childPathBase[1]);
// invokeOnDeleteChildAssociation(assocRef);
// invokeOnUpdateNode(AVMNodeConverter.ToNodeRef(-1, parentPath));
}
catch (AVMNotFoundException e)
{
throw new InvalidNodeRefException(childPathBase[1] + " not found in " + childPathBase[0],
childRef);
}
}
/**
* TODO: Check implementation
*/
public boolean removeChildAssociation(ChildAssociationRef childAssocRef)
{
NodeRef parentRef = childAssocRef.getParentRef();
NodeRef childRef = childAssocRef.getChildRef();
Pair<Integer, String> parentVersionPath = AVMNodeConverter.ToAVMVersionPath(parentRef);
if (parentVersionPath.getFirst() >= 0)
{
throw new InvalidNodeRefException("Read only store.", parentRef);
}
Pair<Integer, String> childVersionPath = AVMNodeConverter.ToAVMVersionPath(childRef);
if (childVersionPath.getFirst() >= 0)
{
throw new InvalidNodeRefException("Read only store.", childRef);
}
String parentPath = parentVersionPath.getSecond();
String childPath = childVersionPath.getSecond();
String [] childPathBase = AVMNodeConverter.SplitBase(childPath);
if (childPathBase[0] == null || !childPathBase[0].equals(parentPath))
{
return false;
}
try
{
fAVMService.removeNode(childPathBase[0], childPathBase[1]);
return true;
}
catch (AVMNotFoundException e)
{
throw new InvalidNodeRefException("Not found.", childRef);
}
}
/**
* TODO: Implement
*/
public boolean removeSecondaryChildAssociation(ChildAssociationRef childAssocRef)
{
throw new UnsupportedOperationException();
}
/**
* @param nodeRef
* @return Returns all properties keyed by their qualified name
* @throws InvalidNodeRefException if the node could not be found
*/
public Map<QName, Serializable> getProperties(NodeRef nodeRef) throws InvalidNodeRefException
{
Pair<Integer, String> avmVersionPath = AVMNodeConverter.ToAVMVersionPath(nodeRef);
Map<QName, PropertyValue> props = null;
AVMNodeDescriptor desc = fAVMService.lookup(avmVersionPath.getFirst(),
avmVersionPath.getSecond());
try
{
props = fAVMService.getNodeProperties(avmVersionPath.getFirst(),
avmVersionPath.getSecond());
}
catch (AVMNotFoundException e)
{
throw new InvalidNodeRefException(avmVersionPath.getSecond() + " not found.", nodeRef);
}
Map<QName, Serializable> result = new HashMap<QName, Serializable>();
for (QName qName : props.keySet())
{
PropertyValue value = props.get(qName);
PropertyDefinition def = dictionaryService.getProperty(qName);
result.put(qName, makeSerializableValue(def, value));
}
// Now spoof properties that are built in.
result.put(ContentModel.PROP_CREATED, new Date(desc.getCreateDate()));
result.put(ContentModel.PROP_CREATOR, desc.getCreator());
result.put(ContentModel.PROP_MODIFIED, new Date(desc.getModDate()));
result.put(ContentModel.PROP_MODIFIER, desc.getLastModifier());
result.put(ContentModel.PROP_OWNER, desc.getOwner());
result.put(ContentModel.PROP_NAME, desc.getName());
result.put(ContentModel.PROP_NODE_UUID, "UNKNOWN");
result.put(ContentModel.PROP_NODE_DBID, new Long(desc.getId()));
result.put(ContentModel.PROP_STORE_PROTOCOL, "avm");
result.put(ContentModel.PROP_STORE_IDENTIFIER, nodeRef.getStoreRef().getIdentifier());
if (desc.isLayeredDirectory())
{
result.put(WCMModel.PROP_AVM_DIR_INDIRECTION,
AVMNodeConverter.ToNodeRef(-1, desc.getIndirection()));
}
if (desc.isLayeredFile())
{
result.put(WCMModel.PROP_AVM_FILE_INDIRECTION,
AVMNodeConverter.ToNodeRef(-1, desc.getIndirection()));
}
if (desc.isFile())
{
try
{
ContentData contentData = fAVMService.getContentDataForRead(avmVersionPath.getFirst(),
avmVersionPath.getSecond());
result.put(ContentModel.PROP_CONTENT, contentData);
}
catch (AVMException e)
{
// TODO For now ignore.
}
}
return result;
}
/**
* @param nodeRef
* @param qname the qualified name of the property
* @return Returns the value of the property, or null if not yet set
* @throws InvalidNodeRefException if the node could not be found
*/
public Serializable getProperty(NodeRef nodeRef, QName qname) throws InvalidNodeRefException
{
Pair<Integer, String> avmVersionPath = AVMNodeConverter.ToAVMVersionPath(nodeRef);
if (isBuiltInProperty(qname))
{
return getBuiltInProperty(avmVersionPath, qname, nodeRef);
}
try
{
PropertyValue value = fAVMService.getNodeProperty(avmVersionPath.getFirst(),
avmVersionPath.getSecond(),
qname);
if (value == null)
{
return null;
}
PropertyDefinition def = this.dictionaryService.getProperty(qname);
return makeSerializableValue(def, value);
}
catch (AVMNotFoundException e)
{
throw new InvalidNodeRefException(avmVersionPath.getSecond() + " not found.", nodeRef);
}
}
/**
* {@inheritDoc}
*/
public void removeProperty(NodeRef nodeRef, QName qname) throws InvalidNodeRefException
{
Pair<Integer, String> avmVersionPath = AVMNodeConverter.ToAVMVersionPath(nodeRef);
if (isBuiltInProperty(qname))
{
// Ignore
return;
}
try
{
fAVMService.deleteNodeProperty(avmVersionPath.getSecond(), qname);
}
catch (AVMNotFoundException e)
{
throw new InvalidNodeRefException(avmVersionPath.getSecond() + " not found.", nodeRef);
}
}
/**
* A Helper to spoof built in properties.
* @param avmVersionPath The broken out version and path from a NodeRef.
* @param qName The name of the property to retrieve.
* @param nodeRef The original NodeRef (for error reporting).
* @return The property value.
*/
private Serializable getBuiltInProperty(Pair<Integer, String> avmVersionPath,
QName qName,
NodeRef nodeRef)
{
if (qName.equals(ContentModel.PROP_CONTENT))
{
try
{
ContentData contentData =
fAVMService.getContentDataForRead(avmVersionPath.getFirst(),
avmVersionPath.getSecond());
return contentData;
}
catch (AVMException e)
{
// TODO This seems very wrong. Do something better
// sooner rather than later.
return null;
}
}
AVMNodeDescriptor desc = fAVMService.lookup(avmVersionPath.getFirst(),
avmVersionPath.getSecond());
if (desc == null)
{
throw new InvalidNodeRefException(avmVersionPath.getSecond() + " not found.", nodeRef);
}
if (qName.equals(ContentModel.PROP_CREATED))
{
return new Date(desc.getCreateDate());
}
else if (qName.equals(ContentModel.PROP_CREATOR))
{
return desc.getCreator();
}
else if (qName.equals(ContentModel.PROP_MODIFIED))
{
return new Date(desc.getModDate());
}
else if (qName.equals(ContentModel.PROP_MODIFIER))
{
return desc.getLastModifier();
}
else if (qName.equals(ContentModel.PROP_OWNER))
{
return desc.getOwner();
}
else if (qName.equals(ContentModel.PROP_NAME))
{
return desc.getName();
}
else if (qName.equals(ContentModel.PROP_NODE_UUID))
{
return "UNKNOWN";
}
else if (qName.equals(ContentModel.PROP_NODE_DBID))
{
return new Long(desc.getId());
}
else if (qName.equals(ContentModel.PROP_STORE_PROTOCOL))
{
return "avm";
}
else if (qName.equals(ContentModel.PROP_STORE_IDENTIFIER))
{
return nodeRef.getStoreRef().getIdentifier();
}
else if (qName.equals(WCMModel.PROP_AVM_DIR_INDIRECTION))
{
if (desc.isLayeredDirectory())
{
return AVMNodeConverter.ToNodeRef(-1, desc.getIndirection());
}
return null;
}
else if (qName.equals(WCMModel.PROP_AVM_FILE_INDIRECTION))
{
if (desc.isLayeredFile())
{
return AVMNodeConverter.ToNodeRef(-1, desc.getIndirection());
}
return null;
}
else
{
logger.error("Invalid Built In Property: " + qName);
return null;
}
}
/**
* Set the values of all properties to be an <code>Serializable</code> instances.
* The properties given must still fulfill the requirements of the class and
* aspects relevant to the node.
* <p>
* <b>NOTE:</b> Null values <u>are</u> allowed.
*
* @param nodeRef
* @param properties all the properties of the node keyed by their qualified names
* @throws InvalidNodeRefException if the node could not be found
*/
public void setProperties(NodeRef nodeRef, Map<QName, Serializable> properties) throws InvalidNodeRefException
{
Pair<Integer, String> avmVersionPath = AVMNodeConverter.ToAVMVersionPath(nodeRef);
if (avmVersionPath.getFirst() >= 0)
{
throw new InvalidNodeRefException("Read only store.", nodeRef);
}
// TODO Not sure this try block is necessary.
try
{
// Prepare fr policy invocation.
Map<QName, Serializable> propsBefore = null;
if (fInvokePolicies)
{
propsBefore = getProperties(nodeRef);
}
// Remove all properties
fAVMService.deleteNodeProperties(avmVersionPath.getSecond());
// Rebuild node properties
Map<QName, PropertyValue> values = new HashMap<QName, PropertyValue>();
for (Map.Entry<QName, Serializable> entry : properties.entrySet())
{
QName propertyQName = entry.getKey();
Serializable value = entry.getValue();
// For AVM nodes is in place.
if (isBuiltInProperty(propertyQName))
{
if (propertyQName.equals(ContentModel.PROP_CONTENT))
{
AVMNodeDescriptor desc = fAVMService.lookup(-1, avmVersionPath.getSecond());
if (desc == null)
{
throw new InvalidNodeRefException(avmVersionPath.getSecond() + " not found.", nodeRef);
}
if (desc.isPlainFile())
{
fAVMService.setContentData(avmVersionPath.getSecond(),
(ContentData)properties.get(propertyQName));
}
}
}
PropertyDefinition propertyDef = dictionaryService.getProperty(propertyQName);
PropertyValue propertyValue = makePropertyValue(propertyDef, value);
values.put(propertyQName, propertyValue);
}
// Finally set node properties
fAVMService.setNodeProperties(avmVersionPath.getSecond(), values);
// Invoke policies
if (fInvokePolicies)
{
Map<QName, Serializable> propsAfter = properties;
invokeOnUpdateProperties(nodeRef, propsBefore, propsAfter);
}
// Invoke policy behaviors.
// invokeOnUpdateNode(nodeRef);
// invokeOnUpdateProperties(nodeRef, oldProps, properties);
}
catch (AVMNotFoundException e)
{
throw new InvalidNodeRefException(avmVersionPath.getSecond() + " not found.", nodeRef);
}
}
public void addProperties(NodeRef nodeRef, Map<QName, Serializable> properties)
{
// Overwrite the current properties
Map<QName, Serializable> currentProperties = getProperties(nodeRef);
currentProperties.putAll(properties);
setProperties(nodeRef, currentProperties);
}
static QName [] fgBuiltinProperties = new QName []
{
ContentModel.PROP_CREATED,
ContentModel.PROP_CREATOR,
ContentModel.PROP_MODIFIED,
ContentModel.PROP_MODIFIER,
ContentModel.PROP_OWNER,
ContentModel.PROP_CONTENT,
ContentModel.PROP_NAME,
ContentModel.PROP_NODE_UUID,
ContentModel.PROP_NODE_DBID,
ContentModel.PROP_STORE_PROTOCOL,
ContentModel.PROP_STORE_IDENTIFIER,
WCMModel.PROP_AVM_FILE_INDIRECTION,
WCMModel.PROP_AVM_DIR_INDIRECTION
};
/**
* Helper to distinguish built-in from generic properties.
* @param qName The name of the property to check.
* @return Whether <code>qName</code> is a built-in propety.
*/
private boolean isBuiltInProperty(QName qName)
{
for (QName name : fgBuiltinProperties)
{
if (name.equals(qName))
{
return true;
}
}
return false;
}
/**
* Sets the value of a property to be any <code>Serializable</code> instance.
* To remove a property value, use {@link #getProperties(NodeRef)}, remove the
* value and call {@link #setProperties(NodeRef, Map)}.
* <p>
* <b>NOTE:</b> Null values <u>are</u> allowed.
*
* @param nodeRef
* @param qname the fully qualified name of the property
* @param propertyValue the value of the property - never null
* @throws InvalidNodeRefException if the node could not be found
*/
public void setProperty(NodeRef nodeRef, QName qname, Serializable value) throws InvalidNodeRefException
{
// Invoke policy behaviors.
// invokeBeforeUpdateNode(nodeRef);
Pair<Integer, String> avmVersionPath = AVMNodeConverter.ToAVMVersionPath(nodeRef);
if (avmVersionPath.getFirst() >= 0)
{
throw new InvalidNodeRefException("Read only store.", nodeRef);
}
Map<QName, Serializable> propsBefore = null;
if (fInvokePolicies)
{
propsBefore = getProperties(nodeRef);
}
if (isBuiltInProperty(qname))
{
if (qname.equals(ContentModel.PROP_CONTENT))
{
try
{
fAVMService.setContentData(avmVersionPath.getSecond(), (ContentData)value);
if (fInvokePolicies)
{
Map<QName, Serializable> propsAfter = new HashMap<QName, Serializable>(propsBefore);
propsAfter.put(ContentModel.PROP_CONTENT, value);
invokeOnUpdateProperties(nodeRef, propsBefore, propsAfter);
}
}
catch (ClassCastException e)
{
throw new AVMException("Invalid ContentData.", e);
}
}
return;
}
try
{
PropertyDefinition propertyDef = dictionaryService.getProperty(qname);
PropertyValue propertyValue = makePropertyValue(propertyDef, value);
fAVMService.setNodeProperty(avmVersionPath.getSecond(), qname, propertyValue);
if (fInvokePolicies)
{
Map<QName, Serializable> propsAfter = new HashMap<QName, Serializable>(propsBefore);
propsAfter.put(qname, value);
invokeOnUpdateProperties(nodeRef, propsBefore, propsAfter);
}
// Map<QName, Serializable> propsAfter = getProperties(nodeRef);
// Invoke policy behaviors.
// invokeOnUpdateNode(nodeRef);
// invokeOnUpdateProperties(nodeRef, propsBefore, propsAfter);
}
catch (AVMNotFoundException e)
{
throw new InvalidNodeRefException(avmVersionPath.getSecond() + " not found.", nodeRef);
}
}
/**
* @param nodeRef the child node
* @return Returns a list of all parent-child associations that exist where the given
* node is the child
* @throws InvalidNodeRefException if the node could not be found
*
* @see #getParentAssocs(NodeRef, QNamePattern, QNamePattern)
*/
public List<ChildAssociationRef> getParentAssocs(NodeRef nodeRef) throws InvalidNodeRefException
{
// TODO OK, for now we'll simply return the single parent that corresponds
// to the path stuffed in the NodeRef.
Pair<Integer, String> avmVersionPath = AVMNodeConverter.ToAVMVersionPath(nodeRef);
String path = avmVersionPath.getSecond();
List<ChildAssociationRef> result = new ArrayList<ChildAssociationRef>();
String [] splitPath = AVMNodeConverter.SplitBase(path);
if (splitPath[0] == null)
{
return result;
}
result.add(new ChildAssociationRef(ContentModel.ASSOC_CONTAINS,
AVMNodeConverter.ToNodeRef(avmVersionPath.getFirst(),
splitPath[0]),
QName.createQName(NamespaceService.CONTENT_MODEL_1_0_URI,
splitPath[1]),
nodeRef,
true,
-1));
return result;
}
/**
* Gets all parent associations where the pattern of the association qualified
* name is a match
* <p>
* The resultant list is ordered by (a) explicit index and (b) association creation time.
*
* @param nodeRef the child node
* @param typeQNamePattern the pattern that the type qualified name of the association must match
* @param qnamePattern the pattern that the qnames of the assocs must match
* @return Returns a list of all parent-child associations that exist where the given
* node is the child
* @throws InvalidNodeRefException if the node could not be found
*
* @see ChildAssociationRef#getNthSibling()
* @see #setChildAssociationIndex(ChildAssociationRef, int)
* @see QName
* @see org.alfresco.service.namespace.RegexQNamePattern#MATCH_ALL
*/
public List<ChildAssociationRef> getParentAssocs(NodeRef nodeRef, QNamePattern typeQNamePattern, QNamePattern qnamePattern)
throws InvalidNodeRefException
{
if (!typeQNamePattern.isMatch(ContentModel.ASSOC_CONTAINS))
{
return new ArrayList<ChildAssociationRef>();
}
List<ChildAssociationRef> result = getParentAssocs(nodeRef);
if (result.size() == 0)
{
return result;
}
if (qnamePattern.isMatch(result.get(0).getQName()))
{
return result;
}
return new ArrayList<ChildAssociationRef>();
}
/**
* Get all child associations of the given node.
* <p>
* The resultant list is ordered by (a) explicit index and (b) association creation time.
*
* @param nodeRef the parent node - usually a <b>container</b>
* @return Returns a collection of <code>ChildAssocRef</code> instances. If the
* node is not a <b>container</b> then the result will be empty.
* @throws InvalidNodeRefException if the node could not be found
*
* @see #getChildAssocs(NodeRef, QNamePattern, QNamePattern)
* @see #setChildAssociationIndex(ChildAssociationRef, int)
* @see ChildAssociationRef#getNthSibling()
*/
public List<ChildAssociationRef> getChildAssocs(NodeRef nodeRef) throws InvalidNodeRefException
{
Pair<Integer, String> avmVersionPath = AVMNodeConverter.ToAVMVersionPath(nodeRef);
int version = avmVersionPath.getFirst();
String path = avmVersionPath.getSecond();
List<ChildAssociationRef> result = new ArrayList<ChildAssociationRef>();
SortedMap<String, AVMNodeDescriptor> children = null;
try
{
children =
fAVMService.getDirectoryListing(version,
path);
}
catch (AVMNotFoundException e)
{
return result;
}
for (String name : children.keySet())
{
result.add(new ChildAssociationRef(ContentModel.ASSOC_CONTAINS,
nodeRef,
QName.createQName(NamespaceService.CONTENT_MODEL_1_0_URI,
name),
AVMNodeConverter.ToNodeRef(
version,
AVMNodeConverter.ExtendAVMPath(path, name)),
true,
-1));
}
return result;
}
/**
* Gets all child associations where the pattern of the association qualified
* name is a match.
*
* @param nodeRef the parent node - usually a <b>container</b>
* @param typeQNamePattern the pattern that the type qualified name of the association must match
* @param qnamePattern the pattern that the qnames of the assocs must match
* @return Returns a list of <code>ChildAssocRef</code> instances. If the
* node is not a <b>container</b> then the result will be empty.
* @throws InvalidNodeRefException if the node could not be found
*
* @see QName
* @see org.alfresco.service.namespace.RegexQNamePattern#MATCH_ALL
*/
public List<ChildAssociationRef> getChildAssocs(
NodeRef nodeRef,
QNamePattern typeQNamePattern,
QNamePattern qnamePattern)
throws InvalidNodeRefException
{
List<ChildAssociationRef> result = new ArrayList<ChildAssociationRef>();
if (!typeQNamePattern.isMatch(ContentModel.ASSOC_CONTAINS))
{
return result;
}
List<ChildAssociationRef> all = getChildAssocs(nodeRef);
for (ChildAssociationRef child : all)
{
if (!qnamePattern.isMatch(child.getQName()))
{
continue;
}
result.add(child);
}
return result;
}
public List<ChildAssociationRef> getChildAssocs(NodeRef nodeRef, QNamePattern typeQNamePattern,
QNamePattern qnamePattern, boolean preload) throws InvalidNodeRefException
{
return getChildAssocs(nodeRef, typeQNamePattern, qnamePattern);
}
public List<ChildAssociationRef> getChildAssocs(NodeRef nodeRef, Set<QName> childNodeTypes)
{
/*
* ETWOTWO-961 forced an implementation, but this is just a workaround.
* We do a listing and then keep files or folders looking specifically
* for cm:folder and cm:content types from childNodeTypes.
*/
Pair<Integer, String> avmVersionPath = AVMNodeConverter.ToAVMVersionPath(nodeRef);
int version = avmVersionPath.getFirst();
String path = avmVersionPath.getSecond();
List<ChildAssociationRef> result = new ArrayList<ChildAssociationRef>();
SortedMap<String, AVMNodeDescriptor> children = null;
try
{
children =
fAVMService.getDirectoryListing(version,
path);
}
catch (AVMNotFoundException e)
{
return result;
}
for (Map.Entry<String, AVMNodeDescriptor> entry : children.entrySet())
{
String name = entry.getKey();
AVMNodeDescriptor descriptor = entry.getValue();
if (descriptor.isFile())
{
if (!childNodeTypes.contains(ContentModel.TYPE_CONTENT))
{
continue;
}
}
else if (descriptor.isDirectory())
{
if (!childNodeTypes.contains(ContentModel.TYPE_FOLDER))
{
continue;
}
}
else
{
// Not a file or directory???
continue;
}
result.add(new ChildAssociationRef(ContentModel.ASSOC_CONTAINS,
nodeRef,
QName.createQName(
NamespaceService.CONTENT_MODEL_1_0_URI,
name),
AVMNodeConverter.ToNodeRef(
version,
AVMNodeConverter.ExtendAVMPath(path, name)),
true,
-1));
}
return result;
}
/**
* getChildrenByName
*/
public List<ChildAssociationRef> getChildrenByName(NodeRef nodeRef, QName assocTypeQName, Collection<String> childNames)
{
final List<ChildAssociationRef> results = new ArrayList<ChildAssociationRef>(100);
if (!assocTypeQName.equals(ContentModel.ASSOC_CONTAINS))
{
throw new UnsupportedOperationException("AVM getChildrenByName only supports ASSOCS_CONTAINS.");
}
Pair<Integer, String> avmVersionPath = AVMNodeConverter.ToAVMVersionPath(nodeRef);
try
{
for(String childName : childNames)
{
AVMNodeDescriptor child = fAVMService.lookup(avmVersionPath.getFirst(),
AVMUtil.extendAVMPath(avmVersionPath.getSecond(), childName));
if (child != null)
{
NodeRef childRef = AVMNodeConverter.ToNodeRef(avmVersionPath.getFirst(),
child.getPath());
QName childQName = QName.createQName(NamespaceService.CONTENT_MODEL_1_0_URI,
childName);
ChildAssociationRef ref = new ChildAssociationRef(assocTypeQName, nodeRef, childQName, childRef);
if(logger.isDebugEnabled())
{
logger.debug("got a child node :" + ref);
}
results.add(ref);
}
}
return results;
}
catch (AVMException e)
{
logger.debug("exception in getChildrenByName ", e);
return results;
}
}
/**
* Get a child NodeRef by name.
* @param nodeRef The parent node.
* @param assocTypeQName The type of the Child Association.
* @param childName The name of the child to get.
*/
public NodeRef getChildByName(NodeRef nodeRef, QName assocTypeQName, String childName)
{
if (!assocTypeQName.equals(ContentModel.ASSOC_CONTAINS))
{
return null;
}
Pair<Integer, String> avmVersionPath = AVMNodeConverter.ToAVMVersionPath(nodeRef);
try
{
AVMNodeDescriptor child = fAVMService.lookup(avmVersionPath.getFirst(),
AVMUtil.extendAVMPath(avmVersionPath.getSecond(), childName));
if (child == null)
{
return null;
}
return AVMNodeConverter.ToNodeRef(avmVersionPath.getFirst(),
child.getPath());
}
catch (AVMException e)
{
return null;
}
}
/**
* Fetches the primary parent-child relationship.
* <p>
* For a root node, the parent node reference will be null.
*
* @param nodeRef
* @return Returns the primary parent-child association of the node
* @throws InvalidNodeRefException if the node could not be found
*/
public ChildAssociationRef getPrimaryParent(NodeRef nodeRef) throws InvalidNodeRefException
{
List<ChildAssociationRef> parents = getParentAssocs(nodeRef);
if (parents.size() == 0)
{
return new ChildAssociationRef(null, null, null, nodeRef);
}
return parents.get(0);
}
/**
* @throws UnsupportedOperationException always
*/
@Override
public AssociationRef createAssociation(NodeRef sourceRef, NodeRef targetRef, QName assocTypeQName)
throws InvalidNodeRefException, AssociationExistsException
{
throw new UnsupportedOperationException("AVM does not support arbitrary associations.");
}
/**
* @throws UnsupportedOperationException always
*/
@Override
public void setAssociations(NodeRef sourceRef, QName assocTypeQName, List<NodeRef> targetRefs)
{
throw new UnsupportedOperationException("AVM does not support arbitrary associations.");
}
/**
*
* @param sourceRef the associaton source node
* @param targetRef the association target node
* @param assocTypeQName the qualified name of the association type
* @throws InvalidNodeRefException if either of the nodes could not be found
*/
public void removeAssociation(NodeRef sourceRef, NodeRef targetRef, QName assocTypeQName)
throws InvalidNodeRefException
{
throw new UnsupportedOperationException("AVM does not support arbitrary associations.");
}
/**
* Gets an association by ID.
*
* @param assocId
* the association id
* @return the association, or <code>null</code> if it does not exist
*/
public AssociationRef getAssoc(Long id)
{
return null;
}
/**
* Fetches all associations <i>from</i> the given source where the associations'
* qualified names match the pattern provided.
*
* @param sourceRef the association source
* @param qnamePattern the association qname pattern to match against
* @return Returns a list of <code>NodeAssocRef</code> instances for which the
* given node is a source
* @throws InvalidNodeRefException if the source node could not be found
*
* @see QName
* @see org.alfresco.service.namespace.RegexQNamePattern#MATCH_ALL
*/
public List<AssociationRef> getTargetAssocs(NodeRef sourceRef, QNamePattern qnamePattern)
throws InvalidNodeRefException
{
return new ArrayList<AssociationRef>();
}
/**
* Fetches all associations <i>to</i> the given target where the associations'
* qualified names match the pattern provided.
*
* @param targetRef the association target
* @param qnamePattern the association qname pattern to match against
* @return Returns a list of <code>NodeAssocRef</code> instances for which the
* given node is a target
* @throws InvalidNodeRefException
*
* @see QName
* @see org.alfresco.service.namespace.RegexQNamePattern#MATCH_ALL
*/
public List<AssociationRef> getSourceAssocs(NodeRef targetRef, QNamePattern qnamePattern)
throws InvalidNodeRefException
{
return new ArrayList<AssociationRef>();
}
/**
* The root node has an entry in the path(s) returned. For this reason, there
* will always be <b>at least one</b> path element in the returned path(s).
* The first element will have a null parent reference and qname.
*
* @param nodeRef
* @return Returns the path to the node along the primary node path
* @throws InvalidNodeRefException if the node could not be found
*
* @see #getPaths(NodeRef, boolean)
*/
public Path getPath(NodeRef nodeRef) throws InvalidNodeRefException
{
// TODO Review later. This may be wrong.
Path path = new Path();
Pair<Integer, String> avmVersionPath = AVMNodeConverter.ToAVMVersionPath(nodeRef);
int version = avmVersionPath.getFirst();
String currPath = avmVersionPath.getSecond();
while (!currPath.endsWith("/"))
{
String [] splitPath = AVMNodeConverter.SplitBase(currPath);
String parentPath = splitPath[0];
String name = splitPath[1];
ChildAssociationRef caRef =
new ChildAssociationRef(ContentModel.ASSOC_CONTAINS,
AVMNodeConverter.ToNodeRef(version, parentPath),
QName.createQName(NamespaceService.CONTENT_MODEL_1_0_URI,
name),
AVMNodeConverter.ToNodeRef(version, currPath),
true,
-1);
path.prepend(new Path.ChildAssocElement(caRef));
currPath = parentPath;
}
ChildAssociationRef caRef = new ChildAssociationRef(null, null, null,
AVMNodeConverter.ToNodeRef(version,
currPath));
path.prepend(new Path.ChildAssocElement(caRef));
return path;
}
/**
* The root node has an entry in the path(s) returned. For this reason, there
* will always be <b>at least one</b> path element in the returned path(s).
* The first element will have a null parent reference and qname.
*
* @param nodeRef
* @param primaryOnly true if only the primary path must be retrieved. If true, the
* result will have exactly one entry.
* @return Returns a List of all possible paths to the given node
* @throws InvalidNodeRefException if the node could not be found
*/
public List<Path> getPaths(NodeRef nodeRef, boolean primaryOnly) throws InvalidNodeRefException
{
List<Path> result = new ArrayList<Path>();
result.add(getPath(nodeRef));
return result;
}
/**
* Get the node where archived items will have gone when deleted from the given store.
*
* @param storeRef the store that items were deleted from
* @return Returns the archive node parent
*/
public NodeRef getStoreArchiveNode(StoreRef storeRef)
{
throw new UnsupportedOperationException("AVM does not support this operation.");
}
/**
* Restore an individual node (along with its sub-tree nodes) to the target location.
* The archived node must have the {@link org.alfresco.model.ContentModel#ASPECT_ARCHIVED archived aspect}
* set against it.
*
* @param archivedNodeRef the archived node
* @param destinationParentNodeRef the parent to move the node into
* or <tt>null</tt> to use the original
* @param assocTypeQName the primary association type name to use in the new location
* or <tt>null</tt> to use the original
* @param assocQName the primary association name to use in the new location
* or <tt>null</tt> to use the original
* @return Returns the reference to the newly created node
*/
public NodeRef restoreNode(
NodeRef archivedNodeRef,
NodeRef destinationParentNodeRef,
QName assocTypeQName,
QName assocQName)
{
throw new UnsupportedOperationException("AVM does not support this operation.");
}
/* (non-Javadoc)
* @see org.alfresco.service.cmr.repository.NodeService#getChildAssocsWithoutParentAssocsOfType(org.alfresco.service.cmr.repository.NodeRef, org.alfresco.service.namespace.QName)
*/
public Collection<ChildAssociationRef> getChildAssocsWithoutParentAssocsOfType(NodeRef parent, QName assocTypeQName)
{
throw new UnsupportedOperationException("AVM does not support this operation.");
}
public Long getNodeAclId(NodeRef nodeRef) throws InvalidNodeRefException
{
throw new UnsupportedOperationException("getNodeAclId is unsupported for AVMNodeService");
}
@Override
public List<ChildAssociationRef> getChildAssocsByPropertyValue(
NodeRef nodeRef, QName propertyQName, Serializable value)
{
throw new UnsupportedOperationException("AVM does not support this operation.");
}
}