Merged V3.1 to HEAD

13218: Partial fix for ETHREEOH-1259 - the null pointer exceptions are gone to be replaced by sensible error messages.
   13220: Merged V3.0 to V3.1
      13219: Build Fix for error in hand merge of r13141 from V2.2 to V3.0
   13226: Clearer debugging of exceptions during NodeService cleanup
   13228: ETHREEOH-1250
   13229: Fix for ETHREEOH-1184: Share webscript configuration does not support international chars as values
   13235: Add support to exclude admin and guest from person permission fix ups. Tidy up for ETHREEOH-1239
   13239: Build Fix
   13243: ETHREEOH-1308: Update AMPs to indicate unsupported status
   13247: Build fix - do not delete admin :-)
   13248: Fix build
   13254: Fix for ETHREEOH-1351: Schemas containing an enumeration with an empty string ...
   ___________________________________________________________________
   Modified: svn:mergeinfo
      Merged /alfresco/BRANCHES/V3.0:r13219
      Merged /alfresco/BRANCHES/V3.1:r13218-13220,13224,13226-13229,13231-13232,13234-13237,13239,13241,13243-13248,13250,13252-13254


git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@13612 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261

source/java/org/alfresco/repo/avm/AVMSyncServiceImpl.java

@@ -558,6 +558,7 @@ public class AVMSyncServiceImpl implements AVMSyncService
             fAVMService.removeNode(parentPath, name);
             return;
         }
+        mkdirs(parentPath, AVMNodeConverter.SplitBase(toLink.getPath())[0]);
         
         if (toLink.isLayeredDirectory() && !toLink.isPrimary())
         {

source/java/org/alfresco/repo/node/cleanup/AbstractNodeCleanupWorker.java

@@ -92,7 +92,7 @@ public abstract class AbstractNodeCleanupWorker implements NodeCleanupWorker
                     StackTraceUtil.buildStackTrace(
                             "Node cleanup failed: " +
                             "   Worker: " + this.getClass().getName() + "\n" +
-                            "   Error:  ",
+                            "   Error:  " + e.getMessage(),
                             e.getStackTrace(),
                             sb,
                             Integer.MAX_VALUE);
@@ -102,7 +102,7 @@ public abstract class AbstractNodeCleanupWorker implements NodeCleanupWorker
                 StackTraceUtil.buildStackTrace(
                     "Node cleanup failed: " +
                     "   Worker: " + this.getClass().getName() + "\n" +
-                    "   Error:  ",
+                    "   Error:  " + e.getMessage(),
                     e.getStackTrace(),
                     sb,
                     20);

source/java/org/alfresco/repo/node/cleanup/NodeCleanupRegistry.java

@@ -53,10 +53,10 @@ public class NodeCleanupRegistry implements NodeCleanupWorker
                 StackTraceUtil.buildStackTrace(
                     "Node cleanup failed: " +
                     "   Worker: " + cleanupWorker.getClass().getName() + "\n" +
-                    "   Error:  ",
+                    "   Error:  " + e.getMessage(),
                     e.getStackTrace(),
                     sb,
-                    20);
+                    0);
                 results.add(sb.toString());
             }
         }

source/java/org/alfresco/repo/security/person/CheckAndFixPersonPermissionsBootstrapBean.java

@@ -56,6 +56,8 @@ public class CheckAndFixPersonPermissionsBootstrapBean extends AbstractLifecycle
 
     private PermissionsManager permissionsManager;
 
+    private Set<String> excludedUsers;
+
     public void setNodeService(NodeService nodeService)
     {
         this.nodeService = nodeService;
@@ -75,6 +77,11 @@ public class CheckAndFixPersonPermissionsBootstrapBean extends AbstractLifecycle
     {
         this.permissionsManager = permissionsManager;
     }
+    
+    public void setExcludedUsers(Set<String> excludedUsers)
+    {
+        this.excludedUsers = excludedUsers;
+    }
 
     @Override
     protected void onBootstrap(ApplicationEvent event)
@@ -96,6 +103,10 @@ public class CheckAndFixPersonPermissionsBootstrapBean extends AbstractLifecycle
                 for (NodeRef person : people)
                 {
                     String uid = DefaultTypeConverter.INSTANCE.convert(String.class, nodeService.getProperty(person, ContentModel.PROP_USERNAME));
+                    if((excludedUsers != null) && excludedUsers.contains(uid))
+                    {
+                        continue;
+                    }
                     if(!permissionsManager.validatePermissions(person, uid, uid))
                     {
                         permissionsManager.setPermissions(person, uid, uid);

source/java/org/alfresco/repo/security/person/PermissionsManagerImpl.java

@@ -41,7 +41,7 @@ public class PermissionsManagerImpl implements PermissionsManager
     /**
      * Set if permissions are inherited when nodes are created.
      */
-    private Boolean inheritPermissions = false;
+    private Boolean inheritPermissions;
 
     /**
      * A set of permissions to set for the owner when a home folder is created
@@ -61,7 +61,7 @@ public class PermissionsManagerImpl implements PermissionsManager
     /**
      * Clear existing permissions on new home folders (useful of created from a template.
      */
-    private Boolean clearExistingPermissions = false;
+    private Boolean clearExistingPermissions;
 
     private OwnableService ownableService;
 

source/java/org/alfresco/repo/security/person/PersonTest.java

@@ -36,6 +36,7 @@ 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.cmr.security.AuthorityService;
 import org.alfresco.service.cmr.security.NoSuchPersonException;
 import org.alfresco.service.cmr.security.PermissionService;
 import org.alfresco.service.cmr.security.PersonService;
@@ -48,7 +49,7 @@ import org.alfresco.util.GUID;
 public class PersonTest extends BaseSpringTest
 {
     private TransactionService transactionService;
-    
+
     private PersonService personService;
 
     private NodeService nodeService;
@@ -57,6 +58,8 @@ public class PersonTest extends BaseSpringTest
 
     private PermissionService permissionService;
 
+    private AuthorityService authorityService;
+
     public PersonTest()
     {
         super();
@@ -69,13 +72,18 @@ public class PersonTest extends BaseSpringTest
         personService = (PersonService) applicationContext.getBean("personService");
         nodeService = (NodeService) applicationContext.getBean("nodeService");
         permissionService = (PermissionService) applicationContext.getBean("permissionService");
+        authorityService = (AuthorityService) applicationContext.getBean("authorityService");
 
         StoreRef storeRef = nodeService.createStore(StoreRef.PROTOCOL_WORKSPACE, "Test_" + System.currentTimeMillis());
         rootNodeRef = nodeService.getRootNode(storeRef);
 
         for (NodeRef nodeRef : personService.getAllPeople())
         {
-            nodeService.deleteNode(nodeRef);
+            String uid = DefaultTypeConverter.INSTANCE.convert(String.class, nodeService.getProperty(nodeRef, ContentModel.PROP_USERNAME));
+            if (!uid.equals("admin"))
+            {
+                nodeService.deleteNode(nodeRef);
+            }
         }
 
         personService.setCreateMissingPeople(true);
@@ -90,8 +98,7 @@ public class PersonTest extends BaseSpringTest
     {
         personService.setCreateMissingPeople(false);
 
-        personService
+        personService.createPerson(createDefaultProperties("derek", "Derek", "Hulley", "dh@dh", "alfresco", rootNodeRef));
-                .createPerson(createDefaultProperties("derek", "Derek", "Hulley", "dh@dh", "alfresco", rootNodeRef));
 
         long create = 0;
 
@@ -142,7 +149,7 @@ public class PersonTest extends BaseSpringTest
         endTransaction();
         startNewTransaction();
     }
-    
+
     public void testCreateAndThenDelete()
     {
         personService.setCreateMissingPeople(false);
@@ -174,7 +181,7 @@ public class PersonTest extends BaseSpringTest
 
         }
     }
-    
+
     public void testCreateMissingPeople1()
     {
         personService.setCreateMissingPeople(false);
@@ -198,7 +205,7 @@ public class PersonTest extends BaseSpringTest
     public void testCreateMissingPeople2()
     {
         System.out.print(personService.getAllPeople());
-        
+
         personService.setCreateMissingPeople(false);
         assertFalse(personService.createMissingPeople());
 
@@ -211,10 +218,10 @@ public class PersonTest extends BaseSpringTest
 
         nodeRef = personService.getPerson("andy");
         testProperties(nodeRef, "andy", "andy", "", "", "");
-        
+
         nodeRef = personService.getPerson("Andy");
         testProperties(nodeRef, "andy", "andy", "", "", "");
-        
+
         assertEquals(nodeRef, personService.getPerson("Andy"));
         nodeRef = personService.getPerson("Andy");
         assertNotNull(nodeRef);
@@ -230,8 +237,7 @@ public class PersonTest extends BaseSpringTest
         personService.setCreateMissingPeople(false);
         try
         {
-            personService.setPersonProperties("derek", createDefaultProperties("derek", "Derek", "Hulley", "dh@dh",
+            personService.setPersonProperties("derek", createDefaultProperties("derek", "Derek", "Hulley", "dh@dh", "alfresco", rootNodeRef));
-                    "alfresco", rootNodeRef));
             fail("Getting Derek should fail");
         }
         catch (PersonException pe)
@@ -253,13 +259,12 @@ public class PersonTest extends BaseSpringTest
         testProperties(nodeRef, "andy", "andy", "", "", "");
 
         personService.setCreateMissingPeople(true);
-        personService.setPersonProperties("derek", createDefaultProperties("derek", "Derek", "Hulley", "dh@dh",
+        personService.setPersonProperties("derek", createDefaultProperties("derek", "Derek", "Hulley", "dh@dh", "alfresco", rootNodeRef));
-                "alfresco", rootNodeRef));
         testProperties(personService.getPerson("derek"), "derek", "Derek", "Hulley", "dh@dh", "alfresco");
 
         testProperties(personService.getPerson("andy"), "andy", "andy", "", "", "");
 
-        assertEquals(2, personService.getAllPeople().size());
+        assertEquals(3, personService.getAllPeople().size());
         assertTrue(personService.getAllPeople().contains(personService.getPerson("andy")));
         assertTrue(personService.getAllPeople().contains(personService.getPerson("derek")));
 
@@ -293,21 +298,18 @@ public class PersonTest extends BaseSpringTest
     public void testPersonCRUD2()
     {
         personService.setCreateMissingPeople(false);
-        personService
+        personService.createPerson(createDefaultProperties("derek", "Derek", "Hulley", "dh@dh", "alfresco", rootNodeRef));
-                .createPerson(createDefaultProperties("derek", "Derek", "Hulley", "dh@dh", "alfresco", rootNodeRef));
         testProperties(personService.getPerson("derek"), "derek", "Derek", "Hulley", "dh@dh", "alfresco");
 
-        personService.setPersonProperties("derek", createDefaultProperties("derek", "Derek_", "Hulley_", "dh@dh_",
+        personService.setPersonProperties("derek", createDefaultProperties("derek", "Derek_", "Hulley_", "dh@dh_", "alfresco_", rootNodeRef));
-                "alfresco_", rootNodeRef));
 
         testProperties(personService.getPerson("derek"), "derek", "Derek_", "Hulley_", "dh@dh_", "alfresco_");
 
-        personService.setPersonProperties("derek", createDefaultProperties("derek", "Derek", "Hulley", "dh@dh",
+        personService.setPersonProperties("derek", createDefaultProperties("derek", "Derek", "Hulley", "dh@dh", "alfresco", rootNodeRef));
-                "alfresco", rootNodeRef));
 
         testProperties(personService.getPerson("derek"), "derek", "Derek", "Hulley", "dh@dh", "alfresco");
 
-        assertEquals(1, personService.getAllPeople().size());
+        assertEquals(2, personService.getAllPeople().size());
         assertTrue(personService.getAllPeople().contains(personService.getPerson("derek")));
         assertEquals(1, personService.getPeopleFilteredByProperty(ContentModel.PROP_USERNAME, "derek").size());
         assertEquals(1, personService.getPeopleFilteredByProperty(ContentModel.PROP_EMAIL, "dh@dh").size());
@@ -317,7 +319,7 @@ public class PersonTest extends BaseSpringTest
         assertEquals(0, personService.getPeopleFilteredByProperty(ContentModel.PROP_ORGID, "microsoft").size());
 
         personService.deletePerson("derek");
-        assertEquals(0, personService.getAllPeople().size());
+        assertEquals(1, personService.getAllPeople().size());
         try
         {
             personService.getPerson("derek");
@@ -332,21 +334,18 @@ public class PersonTest extends BaseSpringTest
     public void testPersonCRUD()
     {
         personService.setCreateMissingPeople(false);
-        personService
+        personService.createPerson(createDefaultProperties("Derek", "Derek", "Hulley", "dh@dh", "alfresco", rootNodeRef));
-                .createPerson(createDefaultProperties("Derek", "Derek", "Hulley", "dh@dh", "alfresco", rootNodeRef));
         testProperties(personService.getPerson("Derek"), "Derek", "Derek", "Hulley", "dh@dh", "alfresco");
 
-        personService.setPersonProperties("Derek", createDefaultProperties("derek", "Derek_", "Hulley_", "dh@dh_",
+        personService.setPersonProperties("Derek", createDefaultProperties("derek", "Derek_", "Hulley_", "dh@dh_", "alfresco_", rootNodeRef));
-                "alfresco_", rootNodeRef));
 
         testProperties(personService.getPerson("Derek"), "Derek", "Derek_", "Hulley_", "dh@dh_", "alfresco_");
 
-        personService.setPersonProperties("Derek", createDefaultProperties("derek", "Derek", "Hulley", "dh@dh",
+        personService.setPersonProperties("Derek", createDefaultProperties("derek", "Derek", "Hulley", "dh@dh", "alfresco", rootNodeRef));
-                "alfresco", rootNodeRef));
 
         testProperties(personService.getPerson("Derek"), "Derek", "Derek", "Hulley", "dh@dh", "alfresco");
 
-        assertEquals(1, personService.getAllPeople().size());
+        assertEquals(2, personService.getAllPeople().size());
         assertTrue(personService.getAllPeople().contains(personService.getPerson("Derek")));
         assertEquals(1, personService.getPeopleFilteredByProperty(ContentModel.PROP_USERNAME, "Derek").size());
         assertEquals(1, personService.getPeopleFilteredByProperty(ContentModel.PROP_EMAIL, "dh@dh").size());
@@ -359,29 +358,22 @@ public class PersonTest extends BaseSpringTest
         assertEquals(personService.personExists("DEREK"), EqualsHelper.nullSafeEquals(personService.getUserIdentifier("DEREK"), "Derek"));
 
         personService.deletePerson("Derek");
-        assertEquals(0, personService.getAllPeople().size());
+        assertEquals(1, personService.getAllPeople().size());
 
     }
 
-    private void testProperties(NodeRef nodeRef, String userName, String firstName, String lastName, String email,
+    private void testProperties(NodeRef nodeRef, String userName, String firstName, String lastName, String email, String orgId)
-            String orgId)
     {
         Map<QName, Serializable> props = nodeService.getProperties(nodeRef);
-        assertEquals(userName, DefaultTypeConverter.INSTANCE.convert(String.class, nodeService.getProperty(nodeRef,
+        assertEquals(userName, DefaultTypeConverter.INSTANCE.convert(String.class, nodeService.getProperty(nodeRef, ContentModel.PROP_USERNAME)));
-                ContentModel.PROP_USERNAME)));
         assertNotNull(nodeService.getProperty(nodeRef, ContentModel.PROP_HOMEFOLDER));
-        assertEquals(firstName, DefaultTypeConverter.INSTANCE.convert(String.class, nodeService.getProperty(nodeRef,
+        assertEquals(firstName, DefaultTypeConverter.INSTANCE.convert(String.class, nodeService.getProperty(nodeRef, ContentModel.PROP_FIRSTNAME)));
-                ContentModel.PROP_FIRSTNAME)));
+        assertEquals(lastName, DefaultTypeConverter.INSTANCE.convert(String.class, nodeService.getProperty(nodeRef, ContentModel.PROP_LASTNAME)));
-        assertEquals(lastName, DefaultTypeConverter.INSTANCE.convert(String.class, nodeService.getProperty(nodeRef,
+        assertEquals(email, DefaultTypeConverter.INSTANCE.convert(String.class, nodeService.getProperty(nodeRef, ContentModel.PROP_EMAIL)));
-                ContentModel.PROP_LASTNAME)));
+        assertEquals(orgId, DefaultTypeConverter.INSTANCE.convert(String.class, nodeService.getProperty(nodeRef, ContentModel.PROP_ORGID)));
-        assertEquals(email, DefaultTypeConverter.INSTANCE.convert(String.class, nodeService.getProperty(nodeRef,
-                ContentModel.PROP_EMAIL)));
-        assertEquals(orgId, DefaultTypeConverter.INSTANCE.convert(String.class, nodeService.getProperty(nodeRef,
-                ContentModel.PROP_ORGID)));
     }
 
-    private Map<QName, Serializable> createDefaultProperties(String userName, String firstName, String lastName,
+    private Map<QName, Serializable> createDefaultProperties(String userName, String firstName, String lastName, String email, String orgId, NodeRef home)
-            String email, String orgId, NodeRef home)
     {
         HashMap<QName, Serializable> properties = new HashMap<QName, Serializable>();
         properties.put(ContentModel.PROP_USERNAME, userName);
@@ -396,8 +388,7 @@ public class PersonTest extends BaseSpringTest
     public void testCaseSensitive()
     {
 
-        personService
+        personService.createPerson(createDefaultProperties("Derek", "Derek", "Hulley", "dh@dh", "alfresco", rootNodeRef));
-                .createPerson(createDefaultProperties("Derek", "Derek", "Hulley", "dh@dh", "alfresco", rootNodeRef));
 
         try
         {
@@ -450,16 +441,16 @@ public class PersonTest extends BaseSpringTest
         }
         personService.getPerson("Derek");
     }
-    
+
     public void testReadOnlyTransactionHandling() throws Exception
     {
         // Kill the annoying Spring-managed txn
         super.setComplete();
         super.endTransaction();
-        
+
         boolean createMissingPeople = personService.createMissingPeople();
         assertTrue("Default should be to create missing people", createMissingPeople);
-        
+
         final String username = "Derek";
         // Make sure that the person is missing
         RetryingTransactionCallback<Object> deletePersonWork = new RetryingTransactionCallback<Object>()
@@ -497,13 +488,13 @@ public class PersonTest extends BaseSpringTest
         // Kill the annoying Spring-managed txn
         super.setComplete();
         super.endTransaction();
-        
+
         boolean createMissingPeople = personService.createMissingPeople();
         assertTrue("Default should be to create missing people", createMissingPeople);
-        
+
         PersonServiceImpl personServiceImpl = (PersonServiceImpl) personService;
         personServiceImpl.setDuplicateMode("LEAVE");
-        
+
         // The user to duplicate
         final String duplicateUsername = GUID.generate();
         // Make sure that the person is missing
@@ -530,8 +521,14 @@ public class PersonTest extends BaseSpringTest
                     public NodeRef execute() throws Throwable
                     {
                         // Wait for the trigger to start
-                        try { startLatch.await(); } catch (InterruptedException e) {}
+                        try
-                        
+                        {
+                            startLatch.await();
+                        }
+                        catch (InterruptedException e)
+                        {
+                        }
+
                         // Trigger
                         NodeRef personNodeRef = personService.getPerson(duplicateUsername);
                         return personNodeRef;
@@ -562,11 +559,17 @@ public class PersonTest extends BaseSpringTest
             thread.start();
         }
         // Wait for the threads to have finished
-        try { endLatch.await(60, TimeUnit.SECONDS); } catch (InterruptedException e) {}
+        try
-        
+        {
+            endLatch.await(60, TimeUnit.SECONDS);
+        }
+        catch (InterruptedException e)
+        {
+        }
+
         // Now, get the user with full split person handling
         personServiceImpl.setDuplicateMode("DELETE");
-        
+
         RetryingTransactionCallback<NodeRef> getPersonWork = new RetryingTransactionCallback<NodeRef>()
         {
             public NodeRef execute() throws Throwable