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

Merged V3.4-BUG-FIX to HEAD

Browse Source 
29057: ALF-9491: Bitrock 7.2.2
   29063: ALF-8766 Concatenated strings in EN webclient file
   29066: Merge DEV/DEV/BELARUS/V3.4-BUG-FIX-2011_07_13 to DEV/V3.4-BUG-FIX
      29010: ALF-7396: Japanese- Untranslated
   29072: HomeFolderProvider work - Changes as a result of Dave Ward's comments
     (HomeFolderManager not fully done as there is a spring issue with using NodeService, FileFolderService, fileFolderService, SearchService or searchService) 
   29074: ALF-7637 - Share displays incorrect folder contents after copy-on-outbound rule against working copy
   29075: ALF-8406 - Configuring the datalist display for sub-types does not work
   29082: ALF-6847 translation: "Collega" should be reverted to English: "Link" as per term list.
   29087: ALF-5717 property names for wcm quickstart website-model had an invalid format or did not end in .description or .title
   29093: Merge V3.3 to DEV/V3.4-BUG-FIX (28596)
      28596: Remove dependency between subsystems and all the object factories in the parent context!
         - Do not allow eager initialization when looking up parent post processors
         - Removes circular dependencies from sysAdmin subsystem
   29094: Merge HEAD to DEV/V3.4-BUG-FIX ()
      28892: Broke circular references between NodeService beans, NodeIndexer, Lucene and back to NodeService.
         - NodeIndexer is now bootstrapped to pull out reference to the Lucene beans
   29100: Revert Merge V3.3 to DEV/V3.4-BUG-FIX (28596) Caused RepositoryStartupTest to fail 
      28596: Remove dependency between subsystems and all the object factories in the parent context!
         - Do not allow eager initialization when looking up parent post processors
         - Removes circular dependencies from sysAdmin subsystem
   29102: ALF-9048: Make apply_amps.bat work from its installed location
   29103: ALF-8746: Restored Japanese choice format translations
   29104: Merged V3.3 to V3.4-BUG-FIX (Reinstated this revision as it is required)
      28596: Remove dependency between subsystems and all the object factories in the parent context!
         - Do not allow eager initialization when looking up parent post processors
         - Removes circular dependencies from sysAdmin subsystem
   29105: Use org.springframework.aop.target.LazyInitTargetSource in the NodeService public proxy to break a circular dependency
   29106: Make PersonService interact with HomeFolderManager via a lazy proxy to prevent another circular dependency
   - Simple HomeFolderManager interface created
   - Implementation class renamed to PortableHomeFolderManager
   - Removed TODOs from authentication-services-context.xml
   29107: Forgot to remove the serviceRegistry dependency from homeFolderManager
   29108: ALF-9529: Installer memory consumption and startup time improvements
   - Bitrock discover the for loop!
   29109: ALF-9530: Postgres installed as Windows service should run as a postgres user, not System
   - Fix from Bitrock
   29118: Fix for ALF-6737 - It's impossible to view any version of the wiki page if it was renamed with native characters
   29119: Fix for ALF-5787 - strings extracted for L10N in Web form creation help text
   29124: ALF-9530: Follow up fix from Bitrock
   29126: Fix for ALF-8344 - Incorrect message is displayed while recover deleted file
   29127: Fix for ALF-9445 - French - Share, translation on Transfer Target configuration
   29129: ALF-9476: Make FTPS work on IBM JDK
   29133: Fix failing DictionaryRestApiTest
   29136: Fix build issues from 29104:
   - run as system when creating home folders (PortableHomeFolderManager)
   - re-factored onCreateNode out of PortableHomeFolderManager into PersonServiceImpl
   - re-factored property PortableHomeFolderManager.enableHomeFolderCreationAsPeopleAreCreated to PersonServiceImpl.homeFolderCreationEager 
   29137: Fix for ALF-8831 - Internal error occurs in My Tasks Webscripts component
   29138: Fix for ALF-8765 - Layout is displaced if translated string occupies more than 1 line
   29140: Fix for ALF-8668 - Deleting author account causes Failed to load the forum posts
   29142: - PortableHomeFolderManager: Moved code to run as System into PersonServiceImpl so that one must have a valid authority to call the publick makeHomeFolder method. The authority should already be valid if called via PersonServiceImpl.
   - Removed unused policyBehaviourFilter property from PersonServiceImpl
   29146: ALF-8701: partially translated string in html-upload.get_fr
   29147: ALF-8727: DE - changes to Root Category
   29149: ALF-8731: DE - Wiki changes (space before full stop)
   29152: ALF-9503: Add space after colon in strings in file wdr-messages.properties
   29153: Fixed ALF-7899: association.ftl does not render when showTargetLink=true in workflow
   29165: ALF-8749: on submit action properties in wcn-workflow-messages.properties
   29166: Fix for ALF-6220 - Language pack - .ftl localization
   29167: ALF-9550 - Typos in new section of webclient.properties
   29169: Fix for ALF-7844 - W3C: Impossible to activate 'Choose from popular tags in this site' link by Enter/Space keys
   29170: Merge V3.4-TEAM to V3.4-BUG-FIX (3.4.4)
      27471: Fix for ALF-8150 - check for visibility before applying focus to element for IE.
   29171: Fixes: ALF-8922, removes date formatting from API (now returns ISO8601) and instead formats it on the client, using L10N strings.
   29172: Fix for ALF-2023 - Repository Action - Copy item to specific space doesn not include content. The option to 'deep copy' is now exposed in the UI for Run Action and Rules in Explorer.
   29173: Fix for ALF-1446 - Sorting of inline descendants is not observed
   29175: ALF-241 - The item is not coppied via 'Paste All' in Shelf when 'Details' page is opened
   29177: Fix for ALF-9520 - confusing sample config. Reordered sample config file as suggested.
   29178: Fixed ALF-6400: GERMAN: Explorer mouse over hints for TinyMCE are not localized
   Fixed ALF-5766: ALL translations errors in Explorer - Calendars are not localizable for content based on webforms
   29202: Merge DEV/BELARUS/V3.4-BUG-FIX-2011_04_12 to V3.4-BUG-FIX (3.4.4)
      27836: ALF-8524: CLONE - Sharepoint doesn't work with HTTPS
         Changes in url links required for HTTPS support.
   29203: Restored removal of postgresCreateSymLinksLinuxBuildingFromWindows tag (32 bit Linux) from revision 26582
   29211: Fix for ALF-1051 - It is impossible to find link by tag from link details page
   29212: Fix for ALF-5301 - TinyMCE is replacing carriage return with white spaces
   29250: Latest L10N update for all languages (DE, ES, FR, IT, JA) from Gloria (based on r29172)
   29253: L10N Update from Gloria
   29270: Fixed ALF-516: Unable to add content/delete tables in webform content when using FireFox
   29271: Update from Gloria
   29272: Merged BRANCHES/DEV/BELARUS/V3.4-BUG-FIX-2011_07_13 to BRANCHES/DEV/V3.4-BUG-FIX: (with minor modification)
      29223: ALF-7619: When document A has an association with a document B editing A's properties fails if user has no permission to edit B
   29274: ALF-9517 Incorrect behaviour of versions on Copy action. Version is 0.1 rather than 1.0
   29283: Resolve ALF-8273: Valid datetime value cannot be parsed by CMIS AtomPub interface
   29284: Update from Gloria
   29286: ALF-9596: Merged PATCHES/V3.4.1 to V3.4-BUG-FIX
      28150: ALF-8607: Detailed debug logging when out of sync transaction detected by index checker / tracker
      28177: ALF-8607: Corrections to debug logging in AbstractReindexComponent
      28213: ALF-8607: Further corrections to debug logging in AbstractReindexComponent
      - Log attributes from indexes, rather than nodeService properties
      28341: ALF-8607: Stop index checker from 'lying'
      - isTxnPresentInIndex() call must be made in a new transaction in order to get a database view in sync with the current indexes
      28352: ALF-8607: Revisit transaction delineation. Nested transaction only required in checkTxnsImpl()
      28403: ALF-8607: Merged PATCHES/V3.3.4 to PATCHES/V3.4.1
         27823: ALF-7237: Index tracker needs to perform a cascade reindex on updated nodes in order to cope with node moves
      28406: ALF-8607: Improvement to FTS fix. Prevent FTS from restoring documents that have been deleted!
      28412: ALF-8607: Invalidate properties and aspects as well as parent assocs when stale cache entry dected during transaction tracking
      28427: ALF-8607: Prevent NPE with bad NodeRef in ADMLuceneIndexerImpl.createDocumentsImpl()
      28705: ALF-8607: Validate transaction IDs when fetching parent associations
      - Compare the cached child node transaction ID against one fetched from the DB
      - Stops us from pairing up the cached node for an older or newer transaction with the wrong parent associations
      28707: ALF-8607: Merged PATCHES/V3.3.4 to PATCHES/V3.4.1
         28588: ALF-7237: Prevent FTS from ever wiping out a document that still exists and ignore duplicates
      28708: ALF-8607: Make FTS capable of recovering from cache concurrency issues by using a RetryingTransactionHelper and better exception handling.
      - Also avoids skipping the entire batch when the reindexing of a particular document fails.
      28710: ALF-8607: Corrected transaction delineation
      28753: ALF-8607: Prevent errors caused by AbstractReindexComponent diagnostics trying to parse FTSREF document IDs as NodeRefs (which they aren't!)
      28755: ALF-8607: When 'failing over' during FTS indexing, don't bother adding a FTS status document so we don't get stuck in a loop with a problematic document
      28815: ALF-8607: Do two way validation of cached / fetched nodes and their parent associations to avoid skew
      - Should resolve problem of tracking moves to the archive store and moves in general
      28862: ALF-8607: Lucene indexers now support 'read through' behaviour for FTS and Index tracking batches
      - Small discrete read only transactions used to read each reindexed node from the database / cache
      - Avoids cache 'drift' and 'skew' after long running indexing transactions
      28863: ALF-8607: Missing file
      28869: ALF-8607: isTxnPresentInIndex() needs to 'read through' so index tracker and checker don't pollute the cache
      28872: ALF-8607: Optimization to prevent constant writing to AVM indexes whilst 'ticking over'.
      28950: ALF-8607: Improved logic in AbstractReindexComponent.isTxnPresentInIndex() so that we can reliably cope with multi-store transactions (e.g. archive store + spaces store)
      - Due to FTS, the txn ID may have 'drifted in' to one store but not the other so we must validate all stores in the txn
      29098: ALF-8607: Use getNodeRefStatus as a cache validation point for reindexing 'read through' transactions
      - Guarantees that FTS reindexed node will see correct state (well if we had consistent read behaviour it would!)
      - Removes stale nodeRef -> ID mappings (e.g. when original node moved to archive store and substituted with deleted node)
      - Inexplicably seems to produce a ~30x speedup in performance tests on MySQL! Appears to remove a contention point. More investigation required to find out what!
   29287: ALF-9598: Merged PATCHES/V3.4.1 to V3.4-BUG-FIX
      28653: ALF-9189: More efficient usage of IndexReaders to avoid huge memory churn with large indexes
      - A single reading thread could block out all other reading threads because a write lock is obtained whilst constructing a set of FilterIndexReaderByStringId readers and all deletions across all indexes have to be evaluated. We now cache a FilterIndexReaderByStringId for each 'layer' of the index so that we get some reuse. We also defer evaluation of deletions to AFTER the write lock is returned and in some cases never have to evaluate the deletions at all.
      - When merging deletions we now make use of a cached index reader for locating the documents, and only resort to a new reader if deletions have to be performed. Hopefully this will mean that the reader for the largest indexes, containing the least recently used stuff, will get left alone most of the time. 
      28690: ALF-9189: Corrections to previous fix
      - Forgot to remove non-lazy reader initialization
      - Fixed NPE
      - Reinstated correct looping behaviour - each processed delta must be considered as one of the indexes to search for the next processed delta
      29099: ALF-9189: Avoid having to allocate a byte array full of number ones for all occurrences of a term to 'fake' norms.
      - Severe Lucene memory hog during FTS
      29262: ALF-9189: Fixed memory leak during index tracking / reindexing and further memory leak regression
      - Fixed up Lucene refcounting again - remember to propagate through decrefs on ReferenceCounting readers
      - Refined ALF-9189 fix to guarantee mainreader clean up
      - Remember to flush the delta during reindexing / tracking
      - Some extra trace diagnostics to help
   29288: ALF-9600: Merged PATCHES/V3.4.1 to V3.4-BUG_FIX
      28876: ALF-9041: Merged HEAD to PATCHES/V3.4.1
         28850: Latest SpringSurf libs
            - Fix to SSO connector passing empty username
   29289: ALF-8241: assemble-tomcat populates endorsed directory with xalan.jar and serializer.jar and Bitrock installer installs these too
   29291: Merged DEV/SWIFT to V3.4-BUG-FIX (3.4.4) - already merged to HEAD as part of a larger merge
      26104: RM: Remove incomplete and unnecessary unit test     
   29302: Fix for ALF-8885 - Unable to paste item due to system error:null


git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@29325 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
This commit is contained in:
Dave Ward
2011-07-25 19:32:17 +00:00
parent 4be0baaeb3
commit a7b885a1c6
92 changed files with 5905 additions and 1675 deletions
Download Patch File Download Diff File Expand all files Collapse all files

475
source/java/org/alfresco/repo/security/person/HomeFolderManager.java
View File

@@ -18,480 +18,19 @@
*/
package org.alfresco.repo.security.person;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import org.alfresco.model.ContentModel;
import org.alfresco.repo.node.NodeServicePolicies;
import org.alfresco.repo.policy.JavaBehaviour;
import org.alfresco.repo.policy.PolicyComponent;
import org.alfresco.repo.security.authentication.AuthenticationUtil;
import org.alfresco.repo.tenant.TenantService;
import org.alfresco.service.ServiceRegistry;
import org.alfresco.service.cmr.model.FileFolderService;
import org.alfresco.service.cmr.model.FileFolderUtil;
import org.alfresco.service.cmr.model.FileInfo;
import org.alfresco.service.cmr.model.FileNotFoundException;
import org.alfresco.service.cmr.repository.ChildAssociationRef;
import org.alfresco.service.cmr.repository.NodeRef;
import org.alfresco.service.cmr.repository.NodeService;
import org.alfresco.service.cmr.repository.StoreRef;
import org.alfresco.service.cmr.repository.datatype.DefaultTypeConverter;
import org.alfresco.service.namespace.NamespaceService;
import org.alfresco.service.namespace.QName;
/**
* Manage home folder creation by binding to events from the cm:person type.
*
* @author Andy Hind,
* Alan Davis (support v1 and v2 HomeFolderProviders - code from
* v1 HomeFolderProviders moved into HomeFolderManager).
* An object responsible for creating / validating the home folder for a given person node child association reference.
*/
public class HomeFolderManager implements NodeServicePolicies.OnCreateNodePolicy
public interface HomeFolderManager
{
private PolicyComponent policyComponent;
private NodeService nodeService;
private boolean enableHomeFolderCreationAsPeopleAreCreated = false;
private ServiceRegistry serviceRegistry;
private TenantService tenantService;
/**
* A default provider
*/
private HomeFolderProvider2 defaultProvider;
/**
* Original Providers (now depreciated) that have registered and are looked up by bean name.
*/
@SuppressWarnings("deprecation")
private Map<String, HomeFolderProvider> v1Providers = new HashMap<String, HomeFolderProvider>();
/**
* Providers that have registered and are looked up by bean name.
*/
private Map<String, HomeFolderProvider2> v2Providers = new HashMap<String, HomeFolderProvider2>();
/**
* Cache the result of the path look up.
*/
private Map<String, Map<String, NodeRef>> rootPathNodeRefMaps =
new ConcurrentHashMap<String, Map<String, NodeRef>>();
/**
* Bind the class behaviour to this implementation
*/
public void init() throws Exception
{
if (enableHomeFolderCreationAsPeopleAreCreated)
{
policyComponent.bindClassBehaviour(QName.createQName(NamespaceService.ALFRESCO_URI, "onCreateNode"), ContentModel.TYPE_PERSON, new JavaBehaviour(this, "onCreateNode"));
}
}
public void setEnableHomeFolderCreationAsPeopleAreCreated(boolean enableHomeFolderCreationAsPeopleAreCreated)
{
this.enableHomeFolderCreationAsPeopleAreCreated = enableHomeFolderCreationAsPeopleAreCreated;
}
/**
* Set the policy component.
* Create / move the home folder if required.
*
* @param policyComponent
* @param childAssocRef
* the primary child association pointing to the person node.
*/
public void setPolicyComponent(PolicyComponent policyComponent)
{
this.policyComponent = policyComponent;
}
public void makeHomeFolder(ChildAssociationRef childAssocRef);
/**
* Set the node service.
* @param nodeService
*/
public void setNodeService(NodeService nodeService)
{
this.nodeService = nodeService;
}
/**
* Set the service registry.
*/
public void setServiceRegistry(ServiceRegistry serviceRegistry)
{
this.serviceRegistry = serviceRegistry;
}
/**
* Set the tenant service
*/
public void setTenantService(TenantService tenantService)
{
this.tenantService = tenantService;
}
/**
* Register a home folder provider.
*
* @param provider
*/
@SuppressWarnings("deprecation")
public void addProvider(HomeFolderProvider provider)
{
v1Providers.put(provider.getName(), provider);
}
/**
* Register a home folder provider.
*
* @param provider
*/
public void addProvider(HomeFolderProvider2 provider)
{
v2Providers.put(provider.getName(), provider);
}
/**
* Returns the version 1 HomeFolderProvider with the given name.
*/
@SuppressWarnings("deprecation")
public HomeFolderProvider getHomeFolderProvider1(String providerName)
{
return v1Providers.get(providerName);
}
/**
* Returns the version 2 HomeFolderProvider2 with the given name.
*/
public HomeFolderProvider2 getHomeFolderProvider2(String providerName)
{
return v2Providers.get(providerName);
}
/**
* Set the default home folder provider (user which none is specified or when one is not found)
* @param defaultProvider
*/
public void setDefaultProvider(HomeFolderProvider2 defaultProvider)
{
this.defaultProvider = defaultProvider;
}
/**
* Find the provider and call if eager home folder creation is enabled.
*/
public void onCreateNode(ChildAssociationRef childAssocRef)
{
if (enableHomeFolderCreationAsPeopleAreCreated)
{
makeHomeFolder(childAssocRef);
}
}
/**
* Find the provider and call.
*/
@SuppressWarnings("deprecation")
public void makeHomeFolder(ChildAssociationRef childAssocRef)
{
HomeFolderProvider2 v2Provider = defaultProvider;
HomeFolderProvider v1Provider = null;
String providerName = DefaultTypeConverter.INSTANCE.convert(
String.class, nodeService.getProperty(childAssocRef
.getChildRef(), ContentModel.PROP_HOME_FOLDER_PROVIDER));
if (providerName != null)
{
v2Provider = getHomeFolderProvider2(providerName);
if (v2Provider == null)
{
v1Provider = getHomeFolderProvider1(providerName);
if (v1Provider == null)
{
v2Provider = defaultProvider;
}
}
}
else
{
providerName = defaultProvider.getName();
nodeService.setProperty(childAssocRef.getChildRef(),
ContentModel.PROP_HOME_FOLDER_PROVIDER, providerName);
}
if (v2Provider != null)
{
// If a V2Adaptor we still must call onCreateNode just like a
// v1 HomeFolderProvider in case it has been overridden
if (v2Provider instanceof AbstractHomeFolderProvider.V2Adaptor)
{
((AbstractHomeFolderProvider.V2Adaptor)v2Provider).onCreateNode(childAssocRef);
}
else
{
homeFolderCreateAndSetPermissions(v2Provider, childAssocRef.getChildRef());
}
}
else if (v1Provider != null)
{
v1Provider.onCreateNode(childAssocRef);
}
}
void homeFolderCreateAndSetPermissions(HomeFolderProvider2 provider, NodeRef personNodeRef)
{
AuthenticationUtil.RunAsWork<NodeRef> action =
new RunAsCreateAndSetPermissions(provider, personNodeRef);
AuthenticationUtil.runAs(action, AuthenticationUtil.getSystemUserName());
}
/**
* Helper class to encapsulate the creation and setting permissions etc
*/
private class RunAsCreateAndSetPermissions implements AuthenticationUtil.RunAsWork<NodeRef>
{
NodeRef personNodeRef;
HomeFolderProvider2 provider;
RunAsCreateAndSetPermissions(HomeFolderProvider2 provider, NodeRef personNodeRef)
{
this.personNodeRef = personNodeRef;
this.provider = provider;
}
public NodeRef doWork() throws Exception
{
// Get home folder
HomeSpaceNodeRef homeFolder = provider.getHomeFolder(personNodeRef);
// If it exists
if (homeFolder.getNodeRef() != null)
{
// Get uid and keep
String uid = DefaultTypeConverter.INSTANCE.convert(String.class,
serviceRegistry.getNodeService().getProperty(
personNodeRef, ContentModel.PROP_USERNAME));
// If created or found then set (other wise it was already set correctly)
if (homeFolder.getStatus() != HomeSpaceNodeRef.Status.VALID)
{
serviceRegistry.getNodeService().setProperty(
personNodeRef, ContentModel.PROP_HOMEFOLDER, homeFolder.getNodeRef());
}
final String providerSuppliedOwner = provider.getOwner();
String owner = (providerSuppliedOwner == null) ? uid : providerSuppliedOwner;
// If created..
if (homeFolder.getStatus() == HomeSpaceNodeRef.Status.CREATED)
{
PermissionsManager onCreatePermissionsManager =
provider.getOnCreatePermissionsManager();
if (onCreatePermissionsManager != null)
{
onCreatePermissionsManager.setPermissions(
homeFolder.getNodeRef(), owner, uid);
}
}
else
{
PermissionsManager onReferencePermissionsManager =
provider.getOnReferencePermissionsManager();
if (onReferencePermissionsManager != null)
{
onReferencePermissionsManager.setPermissions(
homeFolder.getNodeRef(), owner, uid);
}
}
}
return homeFolder.getNodeRef();
}
}
private StoreRef getStoreRef(HomeFolderProvider2 provider)
{
// Could check to see if provider is a V2Adaptor to avoid
// object creation, but there is little point.
return new StoreRef(provider.getStoreUrl());
}
/**
* Helper method for {@link HomeFolderProvider2.getHomeFolder} (so that it
* does not need its own NodeService) that returns a person property value.
*/
public String getPersonProperty(NodeRef person, QName name)
{
String value = DefaultTypeConverter.INSTANCE.convert(String.class, nodeService.getProperty(person, name));
if(value == null || value.length() == 0)
{
throw new PersonException("Can not create a home folder when the "+name+" property is null or empty");
}
return value;
}
void clearCaches(HomeFolderProvider2 provider)
{
getRootPathNodeRefMap(provider).clear();
}
NodeRef getRootPathNodeRef(HomeFolderProvider2 provider)
{
String rootPath = provider.getRootPath();
String tenantDomain = (tenantService != null ? tenantService.getCurrentUserDomain() : TenantService.DEFAULT_DOMAIN);
Map<String, NodeRef> rootPathNodeRefMap = getRootPathNodeRefMap(provider);
NodeRef rootPathNodeRef = rootPathNodeRefMap.get(tenantDomain);
if (rootPathNodeRef == null)
{
// ok with race condition for initial construction
rootPathNodeRef = resolvePath(provider, rootPath);
rootPathNodeRefMap.put(tenantDomain, rootPathNodeRef);
}
return rootPathNodeRef;
}
private Map<String, NodeRef> getRootPathNodeRefMap(HomeFolderProvider2 provider)
{
String name = provider.getName();
Map<String, NodeRef> rootPathNodeRefMap = rootPathNodeRefMaps.get(name);
if (rootPathNodeRefMap == null)
{
// ok with race condition for initial construction
rootPathNodeRefMap = new ConcurrentHashMap<String, NodeRef>();
rootPathNodeRefMaps.put(name, rootPathNodeRefMap);
}
return rootPathNodeRefMap;
}
/**
* Utility method to resolve paths to nodes.
*/
NodeRef resolvePath(HomeFolderProvider2 provider, String pathToResolve)
{
List<NodeRef> refs = serviceRegistry.getSearchService().selectNodes(
serviceRegistry.getNodeService().getRootNode(getStoreRef(provider)),
pathToResolve, null,
serviceRegistry.getNamespaceService(), false);
if (refs.size() != 1)
{
throw new IllegalStateException("Non-unique path: found : " +
pathToResolve + " " + refs.size());
}
return refs.get(0);
}
/**
* Helper method for {@link HomeFolderProvider2.getHomeFolder(NodeRef)}
* implementations to return a {@link HomeSpaceNodeRef}
* @param referenceRootNode indicates that a reference to the root node
* should be returned if the home folder property on the person
* has not yet been set.
*/
public HomeSpaceNodeRef getHomeFolder(HomeFolderProvider2 provider, NodeRef person, boolean referenceRootNode)
{
HomeSpaceNodeRef homeSpaceNodeRef = null;
NodeRef existingHomeFolder = DefaultTypeConverter.INSTANCE.convert(
NodeRef.class, serviceRegistry.getNodeService().getProperty(
person, ContentModel.PROP_HOMEFOLDER));
if (existingHomeFolder != null)
{
homeSpaceNodeRef = new HomeSpaceNodeRef(existingHomeFolder,
HomeSpaceNodeRef.Status.VALID);
}
else if (referenceRootNode)
{
homeSpaceNodeRef = new HomeSpaceNodeRef(getRootPathNodeRef(provider),
HomeSpaceNodeRef.Status.REFERENCED);
}
else
{
FileFolderService fileFolderService = serviceRegistry.getFileFolderService();
List<String> homeFolderPath = provider.getHomeFolderPath(person);
FileInfo fileInfo;
// Test if it already exists
NodeRef existing = getExisting(provider, fileFolderService, homeFolderPath);
if (existing != null)
{
fileInfo = fileFolderService.getFileInfo(existing);
}
else
{
fileInfo = createTree(provider, getRootPathNodeRef(provider), homeFolderPath,
provider.getTemplateNodeRef(), fileFolderService);
}
NodeRef homeFolderNodeRef = fileInfo.getNodeRef();
return new HomeSpaceNodeRef(homeFolderNodeRef, HomeSpaceNodeRef.Status.CREATED);
}
return homeSpaceNodeRef;
}
private NodeRef getExisting(HomeFolderProvider2 provider, FileFolderService fileFolderService,
List<String> homeFolderPath)
{
NodeRef existing;
try
{
FileInfo existingFileInfo = fileFolderService.resolveNamePath(getRootPathNodeRef(provider), homeFolderPath);
existing = existingFileInfo.getNodeRef();
}
catch (FileNotFoundException fnfe)
{
existing = null;// home folder noderef doesn't exist yet
}
return existing;
}
/**
* creates a tree of folder nodes based on the path elements provided.
*/
private FileInfo createTree(HomeFolderProvider2 provider, NodeRef root,
List<String> homeFolderPath, NodeRef templateNodeRef,
FileFolderService fileFolderService)
{
NodeRef newParent = createNewParentIfRequired(root, homeFolderPath, fileFolderService);
String homeFolderName = homeFolderPath.get(homeFolderPath.size()-1);
FileInfo fileInfo;
if (templateNodeRef == null)
{
fileInfo = fileFolderService.create(
newParent,
homeFolderName,
ContentModel.TYPE_FOLDER);
}
else
{
try
{
fileInfo = fileFolderService.copy(
templateNodeRef,
newParent,
homeFolderName);
}
catch (FileNotFoundException e)
{
throw new PersonException("Invalid template to create home space");
}
}
return fileInfo;
}
private NodeRef createNewParentIfRequired(NodeRef root,
List<String> homeFolderPath, FileFolderService fileFolderService)
{
if (homeFolderPath.size() > 1)
{
List<String> parentPath = new ArrayList<String>(homeFolderPath);
parentPath.remove(parentPath.size()-1);
return FileFolderUtil.makeFolders(fileFolderService, root,
parentPath, ContentModel.TYPE_FOLDER).getNodeRef();
}
else
{
return root;
}
}
}
}