Added sys:incomplete aspect.

Extended <mandatory> definition in the DD.
The "mandatory" properties in our system have, until now, been optional, i.e. the integrity has not been enforced.
It is possible to have
   <mandatory enforced="true">true</mandatory>, which means "mandatory and enforced", but
   <mandatory enforced="false">true</mandatory>, which means "mandatory but not enforced".
Our system properties have been marked as "mandatory".
Dublin core has had the properties marked as "required".  Currently, if the Dublin Core is added, the node is tagged with sys:incomplete.


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

source/java/org/alfresco/repo/node/index/NodeIndexer.java

@@ -65,7 +65,7 @@ public class NodeIndexer
     /**
      * Registers the policy behaviour methods
      */
-    private void init()
+    public void init()
     {
         policyComponent.bindClassBehaviour(
                 QName.createQName(NamespaceService.ALFRESCO_URI, "beforeCreateStore"),

source/java/org/alfresco/repo/node/integrity/IncompleteNodeTagger.java

@@ -0,0 +1,336 @@
+/*
+ * Copyright (C) 2005 Alfresco, Inc.
+ *
+ * Licensed under the Mozilla Public License version 1.1 
+ * with a permitted attribution clause. You may obtain a
+ * copy of the License at
+ *
+ *   http://www.alfresco.org/legal/license.txt
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific
+ * language governing permissions and limitations under the
+ * License.
+ */
+package org.alfresco.repo.node.integrity;
+
+import java.io.Serializable;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import org.alfresco.error.AlfrescoRuntimeException;
+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.transaction.AlfrescoTransactionSupport;
+import org.alfresco.repo.transaction.TransactionListenerAdapter;
+import org.alfresco.service.cmr.dictionary.AspectDefinition;
+import org.alfresco.service.cmr.dictionary.DictionaryService;
+import org.alfresco.service.cmr.dictionary.PropertyDefinition;
+import org.alfresco.service.cmr.dictionary.TypeDefinition;
+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.namespace.NamespaceService;
+import org.alfresco.service.namespace.QName;
+import org.alfresco.util.PropertyCheck;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+/**
+ * Component that tags {@link org.alfresco.model.ContentModel#ASPECT_INCOMPLETE incomplete} nodes. 
+ * 
+ * @author Derek Hulley
+ */
+public class IncompleteNodeTagger
+        extends     TransactionListenerAdapter
+        implements  NodeServicePolicies.OnCreateNodePolicy,
+                    NodeServicePolicies.OnUpdatePropertiesPolicy,
+                    NodeServicePolicies.OnAddAspectPolicy,
+                    NodeServicePolicies.OnRemoveAspectPolicy
+{
+    private static Log logger = LogFactory.getLog(IncompleteNodeTagger.class);
+    
+    /** key against which the set of nodes to check is stored in the current transaction */
+    private static final String KEY_NODE_SET = "IncompleteNodeTagger.NodeSet";
+    
+    private PolicyComponent policyComponent;
+    private DictionaryService dictionaryService;
+    private NodeService nodeService;
+    
+    public IncompleteNodeTagger()
+    {
+    }
+
+    /**
+     * @param policyComponent the component to register behaviour with
+     */
+    public void setPolicyComponent(PolicyComponent policyComponent)
+    {
+        this.policyComponent = policyComponent;
+    }
+
+    /**
+     * @param dictionaryService the dictionary against which to confirm model details
+     */
+    public void setDictionaryService(DictionaryService dictionaryService)
+    {
+        this.dictionaryService = dictionaryService;
+    }
+
+    /**
+     * @param nodeService the node service to use for browsing node structures
+     */
+    public void setNodeService(NodeService nodeService)
+    {
+        this.nodeService = nodeService;
+    }
+
+    /**
+     * Registers the system-level policy behaviours
+     */
+    public void init()
+    {
+        // check that required properties have been set
+        PropertyCheck.mandatory("IncompleteNodeTagger", "dictionaryService", dictionaryService);
+        PropertyCheck.mandatory("IncompleteNodeTagger", "nodeService", nodeService);
+        PropertyCheck.mandatory("IncompleteNodeTagger", "policyComponent", policyComponent);
+
+        // register behaviour
+        policyComponent.bindClassBehaviour(
+                QName.createQName(NamespaceService.ALFRESCO_URI, "onCreateNode"),
+                this,
+                new JavaBehaviour(this, "onCreateNode"));   
+        policyComponent.bindClassBehaviour(
+                QName.createQName(NamespaceService.ALFRESCO_URI, "onUpdateProperties"),
+                this,
+                new JavaBehaviour(this, "onUpdateProperties"));   
+        policyComponent.bindClassBehaviour(
+                QName.createQName(NamespaceService.ALFRESCO_URI, "onAddAspect"),
+                this,
+                new JavaBehaviour(this, "onAddAspect"));   
+        policyComponent.bindClassBehaviour(
+                QName.createQName(NamespaceService.ALFRESCO_URI, "onRemoveAspect"),
+                this,
+                new JavaBehaviour(this, "onRemoveAspect"));   
+    }
+    
+    /**
+     * @return Returns the set of nodes to check, or null if none were registered
+     */
+    @SuppressWarnings("unchecked")
+    private Set<NodeRef> getNodeSet()
+    {
+        return (Set<NodeRef>) AlfrescoTransactionSupport.getResource(KEY_NODE_SET);
+    }
+    
+    /**
+     * Ensures that this service is registered with the transaction and saves the node
+     * reference for use later.
+     * 
+     * @param nodeRef
+     */
+    private void save(NodeRef nodeRef)
+    {
+        // register this service
+        AlfrescoTransactionSupport.bindListener(this);
+        
+        // get the event list
+        Set<NodeRef> nodeRefs = getNodeSet();
+        if (nodeRefs == null)
+        {
+            nodeRefs = new HashSet<NodeRef>(31, 0.75F);
+            AlfrescoTransactionSupport.bindResource(KEY_NODE_SET, nodeRefs);
+        }
+        // add node to the set
+        nodeRefs.add(nodeRef);
+        // done
+        if (logger.isDebugEnabled())
+        {
+            logger.debug("Added node reference to set: " + nodeRef);
+        }
+    }
+
+    public void onCreateNode(ChildAssociationRef childAssocRef)
+    {
+        NodeRef nodeRef = childAssocRef.getChildRef();
+        save(nodeRef);
+    }
+
+    public void onUpdateProperties(
+            NodeRef nodeRef,
+            Map<QName, Serializable> before,
+            Map<QName, Serializable> after)
+    {
+        save(nodeRef);
+    }
+
+    /**
+     * Save the node for checking of properties.
+     * The {@link org.alfresco.model.ContentModel#ASPECT_INCOMPLETE incomplete} aspect is
+     * not processed.
+     */
+    public void onAddAspect(NodeRef nodeRef, QName aspectTypeQName)
+    {
+        if (aspectTypeQName.equals(ContentModel.ASPECT_INCOMPLETE))
+        {
+            if (logger.isDebugEnabled())
+            {
+                logger.debug("Ignoring aspect addition: " + ContentModel.ASPECT_INCOMPLETE);
+            }
+        }
+        save(nodeRef);
+    }
+
+    /**
+     * Recheck the node as an aspect was removed.
+     */
+    public void onRemoveAspect(NodeRef nodeRef, QName aspectTypeQName)
+    {
+        if (aspectTypeQName.equals(ContentModel.ASPECT_INCOMPLETE))
+        {
+            if (logger.isDebugEnabled())
+            {
+                logger.debug("Ignoring aspect removal: " + ContentModel.ASPECT_INCOMPLETE);
+            }
+        }
+        save(nodeRef);
+    }
+    
+    /**
+     * Process all the nodes that require checking within the transaction.
+     */
+    @Override
+    public void beforeCommit(boolean readOnly)
+    {
+        Set<NodeRef> nodeRefs = getNodeSet();
+        // clear the set out of the transaction
+        // there may be processes that react to the addition/removal of the aspect,
+        //    and these will, in turn, lead to further events
+        AlfrescoTransactionSupport.unbindResource(KEY_NODE_SET);
+        // process each node
+        for (NodeRef nodeRef : nodeRefs)
+        {
+            processNode(nodeRef);
+        }
+    }
+
+    private void processNode(NodeRef nodeRef)
+    {
+        // ignore the node if the marker aspect is already present
+        boolean isTagged = nodeService.hasAspect(nodeRef, ContentModel.ASPECT_INCOMPLETE);
+        
+        // get the node properties
+        Map<QName, Serializable> nodeProperties = nodeService.getProperties(nodeRef);
+        // get the node type
+        QName nodeTypeQName = nodeService.getType(nodeRef);
+        // get property definitions for the node type
+        TypeDefinition typeDef = dictionaryService.getType(nodeTypeQName);
+        if (typeDef == null)
+        {
+            throw new AlfrescoRuntimeException("Node type is not recognised: " + nodeTypeQName);
+        }
+        Collection<PropertyDefinition> propertyDefs = typeDef.getProperties().values();
+        // check them
+        boolean classPropertiesOK = checkProperties(propertyDefs, nodeProperties);
+        
+        // were there outstanding properties to check?
+        if (!classPropertiesOK)
+        {
+            addOrRemoveTag(nodeRef, true, isTagged);
+            // no further checking required
+            return;
+        }
+        
+        // get the node aspects
+        Set<QName> aspectTypeQNames = nodeService.getAspects(nodeRef);
+        for (QName aspectTypeQName : aspectTypeQNames)
+        {
+            // get property definitions for the aspect
+            AspectDefinition aspectDef = dictionaryService.getAspect(aspectTypeQName);
+            propertyDefs = aspectDef.getProperties().values();
+            // check them
+            boolean aspectPropertiesOK = checkProperties(propertyDefs, nodeProperties);
+            // were there outstanding properties to check?
+            if (!aspectPropertiesOK)
+            {
+                addOrRemoveTag(nodeRef, true, isTagged);
+                // no further checking required
+                return;
+            }
+        }
+        // all properties passed (both class- and aspect-defined) - remove aspect
+        addOrRemoveTag(nodeRef, false, isTagged);
+    }
+    
+    /**
+     * @param propertyDefs the property definitions to check
+     * @param properties the properties
+     * @return Returns true if the property definitions were all satisified
+     */
+    private boolean checkProperties(
+            Collection<PropertyDefinition> propertyDefs,
+            Map<QName, Serializable> properties)
+    {
+        for (PropertyDefinition propertyDef : propertyDefs)
+        {
+            if (!propertyDef.isMandatory())
+            {
+                // The property isn't mandatory in any way
+                continue;
+            }
+            else if (propertyDef.isMandatoryEnforced())
+            {
+                // The mandatory nature of the property is fully enforced
+                // Leave these for integrity
+                continue;
+            }
+            // The mandatory nature of the property is 'soft' a.k.a. 'required'
+            // Check that the property value has been supplied
+            if (properties.get(propertyDef.getName()) == null)
+            {
+                // property NOT supplied
+                return false;
+            }
+        }
+        // all properties were present
+        return true;
+    }
+    
+    /**
+     * Adds or removes the {@link ContentModel#ASPECT_INCOMPLETE incomplete} marker aspect.
+     * This only performs the operation if the tag aspect is or is not present, depending
+     * on the operation required.
+     * 
+     * @param nodeRef the node to apply the change to
+     * @param addTag <tt>true</tt> to add the tag and <tt>false</tt> to remove the tag
+     * @param isTagged <tt>true</tt> if the node already has the tag aspect applied,
+     *      otherwise <tt>false</tt>
+     */
+    private void addOrRemoveTag(NodeRef nodeRef, boolean addTag, boolean isTagged)
+    {
+        if (addTag && !isTagged)
+        {
+            nodeService.addAspect(nodeRef, ContentModel.ASPECT_INCOMPLETE, null);
+            // done
+            if (logger.isDebugEnabled())
+            {
+                logger.debug("Tagged node as INCOMPLETE: " + nodeRef);
+            }
+        }
+        else if (!addTag && isTagged)
+        {
+            nodeService.removeAspect(nodeRef, ContentModel.ASPECT_INCOMPLETE);
+            // done
+            if (logger.isDebugEnabled())
+            {
+                logger.debug("Untagged node as INCOMPLETE: " + nodeRef);
+            }
+        }
+    }
+}

source/java/org/alfresco/repo/node/integrity/IncompleteNodeTaggerTest.java

@@ -0,0 +1,141 @@
+/*
+ * Copyright (C) 2005 Alfresco, Inc.
+ *
+ * Licensed under the Mozilla Public License version 1.1 
+ * with a permitted attribution clause. You may obtain a
+ * copy of the License at
+ *
+ *   http://www.alfresco.org/legal/license.txt
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific
+ * language governing permissions and limitations under the
+ * License.
+ */
+package org.alfresco.repo.node.integrity;
+
+import java.io.InputStream;
+
+import javax.transaction.UserTransaction;
+
+import junit.framework.TestCase;
+
+import org.alfresco.model.ContentModel;
+import org.alfresco.repo.dictionary.DictionaryDAO;
+import org.alfresco.repo.dictionary.M2Model;
+import org.alfresco.repo.node.BaseNodeServiceTest;
+import org.alfresco.repo.security.authentication.AuthenticationComponent;
+import org.alfresco.service.ServiceRegistry;
+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.namespace.QName;
+import org.alfresco.service.transaction.TransactionService;
+import org.alfresco.util.ApplicationContextHelper;
+import org.alfresco.util.PropertyMap;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.springframework.context.ApplicationContext;
+
+/**
+ * Checks that tagging of <i>incomplete</i> nodes is done properly.
+ * 
+ * @author Derek Hulley
+ */
+@SuppressWarnings("unused")
+public class IncompleteNodeTaggerTest extends TestCase
+{
+    private static Log logger = LogFactory.getLog(IncompleteNodeTaggerTest.class);
+
+    private static ApplicationContext ctx;
+    static
+    {
+        ctx = ApplicationContextHelper.getApplicationContext();
+    }
+    
+    private IncompleteNodeTagger tagger;
+    private ServiceRegistry serviceRegistry;
+    private NodeService nodeService;
+    private NodeRef rootNodeRef;
+    private PropertyMap properties;
+    private UserTransaction txn;
+    private AuthenticationComponent authenticationComponent;
+    
+    public void setUp() throws Exception
+    {
+        DictionaryDAO dictionaryDao = (DictionaryDAO) ctx.getBean("dictionaryDAO");
+        ClassLoader cl = BaseNodeServiceTest.class.getClassLoader();
+        // load the test model
+        InputStream modelStream = cl.getResourceAsStream("org/alfresco/repo/node/integrity/IntegrityTest_model.xml");
+        assertNotNull(modelStream);
+        M2Model model = M2Model.createModel(modelStream);
+        dictionaryDao.putModel(model);
+
+        tagger = (IncompleteNodeTagger) ctx.getBean("incompleteNodeTagger");
+
+        serviceRegistry = (ServiceRegistry) ctx.getBean(ServiceRegistry.SERVICE_REGISTRY);
+        nodeService = serviceRegistry.getNodeService();
+        this.authenticationComponent = (AuthenticationComponent)ctx.getBean("authenticationComponent");
+        
+        this.authenticationComponent.setSystemUserAsCurrentUser();
+        
+        // begin a transaction
+        TransactionService transactionService = serviceRegistry.getTransactionService();
+        txn = transactionService.getUserTransaction();
+        txn.begin();
+        StoreRef storeRef = new StoreRef(StoreRef.PROTOCOL_WORKSPACE, getName());
+        if (!nodeService.exists(storeRef))
+        {
+            nodeService.createStore(storeRef.getProtocol(), storeRef.getIdentifier());
+        }
+        rootNodeRef = nodeService.getRootNode(storeRef);
+        
+        properties = new PropertyMap();
+        properties.put(IntegrityTest.TEST_PROP_TEXT_C, "abc");
+    }
+    
+    public void tearDown() throws Exception
+    {
+        authenticationComponent.clearCurrentSecurityContext();
+        txn.rollback();
+    }
+
+    /**
+     * Create a node of the given type, and hanging off the root node
+     */
+    private NodeRef createNode(String name, QName type, PropertyMap properties)
+    {
+        return nodeService.createNode(
+                rootNodeRef,
+                ContentModel.ASSOC_CHILDREN,
+                QName.createQName(IntegrityTest.NAMESPACE, name),
+                type,
+                properties
+                ).getChildRef();
+    }
+    
+    public void testSetUp() throws Exception
+    {
+        assertNotNull("IncompleteNodeTagger not created", tagger);
+    }
+    
+    private void checkTagging(NodeRef nodeRef, boolean mustBeTagged)
+    {
+        tagger.beforeCommit(false);
+        assertEquals(nodeService.hasAspect(nodeRef, ContentModel.ASPECT_INCOMPLETE), mustBeTagged);
+    }
+    
+    public void testCreateWithoutProperties() throws Exception
+    {
+        NodeRef nodeRef = createNode("abc", IntegrityTest.TEST_TYPE_WITH_PROPERTIES, null);
+        checkTagging(nodeRef, true);
+    }
+    
+    public void testCreateWithProperties() throws Exception
+    {
+        NodeRef nodeRef = createNode("abc", IntegrityTest.TEST_TYPE_WITH_PROPERTIES, properties);
+        checkTagging(nodeRef, false);
+    }
+}

source/java/org/alfresco/repo/node/integrity/IntegrityChecker.java

@@ -23,7 +23,6 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
-import org.alfresco.error.AlfrescoRuntimeException;
 import org.alfresco.repo.node.NodeServicePolicies;
 import org.alfresco.repo.policy.JavaBehaviour;
 import org.alfresco.repo.policy.PolicyComponent;
@@ -39,12 +38,13 @@ import org.alfresco.service.cmr.repository.NodeRef;
 import org.alfresco.service.cmr.repository.NodeService;
 import org.alfresco.service.namespace.NamespaceService;
 import org.alfresco.service.namespace.QName;
+import org.alfresco.util.PropertyCheck;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 
 /**
- * Implementation of the {@link org.alfresco.repo.integrity.IntegrityService integrity service}
- * that uses the domain persistence mechanism to store and recall integrity events.
+ * Component that generates and processes integrity events, enforcing the dictionary
+ * model's node structure.
  * <p>
  * In order to fulfill the contract of the interface, this class registers to receive notifications
  * pertinent to changes in the node structure.  These are then store away in the persistent
@@ -172,12 +172,9 @@ public class IntegrityChecker
     public void init()
     {
         // check that required properties have been set
-        if (dictionaryService == null)
-            throw new AlfrescoRuntimeException("IntegrityChecker property not set: dictionaryService");
-        if (nodeService == null)
-            throw new AlfrescoRuntimeException("IntegrityChecker property not set: nodeService");
-        if (policyComponent == null)
-            throw new AlfrescoRuntimeException("IntegrityChecker property not set: policyComponent");
+        PropertyCheck.mandatory("IntegrityChecker", "dictionaryService", dictionaryService);
+        PropertyCheck.mandatory("IntegrityChecker", "nodeService", nodeService);
+        PropertyCheck.mandatory("IntegrityChecker", "policyComponent", policyComponent);
 
         if (enabled)  // only register behaviour if integrity checking is on
         {
@@ -276,6 +273,8 @@ public class IntegrityChecker
 
     /**
      * @see PropertiesIntegrityEvent
+     * @see AssocTargetRoleIntegrityEvent
+     * @see AssocTargetMultiplicityIntegrityEvent
      */
     public void onCreateNode(ChildAssociationRef childAssocRef)
     {
@@ -344,6 +343,7 @@ public class IntegrityChecker
 
     /**
      * @see PropertiesIntegrityEvent
+     * @see AssocTargetMultiplicityIntegrityEvent
      */
     public void onAddAspect(NodeRef nodeRef, QName aspectTypeQName)
     {
@@ -382,6 +382,13 @@ public class IntegrityChecker
     {
     }
 
+    /**
+     * @see AssocSourceTypeIntegrityEvent
+     * @see AssocTargetTypeIntegrityEvent
+     * @see AssocSourceMultiplicityIntegrityEvent
+     * @see AssocTargetMultiplicityIntegrityEvent
+     * @see AssocTargetRoleIntegrityEvent
+     */
     public void onCreateChildAssociation(ChildAssociationRef childAssocRef)
     {
         IntegrityEvent event = null;
@@ -426,7 +433,8 @@ public class IntegrityChecker
     }
 
     /**
-     * @see CreateChildAssocIntegrityEvent
+     * @see AssocSourceMultiplicityIntegrityEvent
+     * @see AssocTargetMultiplicityIntegrityEvent
      */
     public void onDeleteChildAssociation(ChildAssociationRef childAssocRef)
     {
@@ -450,7 +458,10 @@ public class IntegrityChecker
     }
 
     /**
-     * @see AbstractAssocIntegrityEvent
+     * @see AssocSourceTypeIntegrityEvent
+     * @see AssocTargetTypeIntegrityEvent
+     * @see AssocSourceMultiplicityIntegrityEvent
+     * @see AssocTargetMultiplicityIntegrityEvent
      */
     public void onCreateAssociation(AssociationRef nodeAssocRef)
     {
@@ -488,7 +499,8 @@ public class IntegrityChecker
     }
 
     /**
-     * @see AbstractAssocIntegrityEvent
+     * @see AssocSourceMultiplicityIntegrityEvent
+     * @see AssocTargetMultiplicityIntegrityEvent
      */
     public void onDeleteAssociation(AssociationRef nodeAssocRef)
     {
@@ -583,7 +595,7 @@ public class IntegrityChecker
     private List<IntegrityRecord> processAllEvents()
     {
         // the results
-        ArrayList<IntegrityRecord> allIntegrityResults = new ArrayList<IntegrityRecord>(0); // generally unused
+        ArrayList<IntegrityRecord> allIntegrityResults = new ArrayList<IntegrityRecord>(0); // generally empty
 
         // get all the events for the transaction (or unit of work)
         // duplicates have been elimiated

source/java/org/alfresco/repo/node/integrity/IntegrityTest.java

@@ -74,8 +74,10 @@ public class IntegrityTest extends TestCase
     
     public static final QName TEST_PROP_TEXT_A = QName.createQName(NAMESPACE, "prop-text-a");
     public static final QName TEST_PROP_TEXT_B = QName.createQName(NAMESPACE, "prop-text-b");
+    public static final QName TEST_PROP_TEXT_C = QName.createQName(NAMESPACE, "prop-text-c");
     public static final QName TEST_PROP_INT_A = QName.createQName(NAMESPACE, "prop-int-a");
     public static final QName TEST_PROP_INT_B = QName.createQName(NAMESPACE, "prop-int-b");
+    public static final QName TEST_PROP_INT_C = QName.createQName(NAMESPACE, "prop-int-c");
     
     private static ApplicationContext ctx;
     static

source/java/org/alfresco/repo/node/integrity/IntegrityTest_model.xml

@@ -27,11 +27,15 @@
          <properties>
             <property name="test:prop-text-a">
                <type>d:text</type>
-               <mandatory>true</mandatory>
+               <mandatory enforced="true">true</mandatory>
             </property>
             <property name="test:prop-text-b">
                <type>d:text</type>
             </property>
+            <property name="test:prop-text-c">
+               <type>d:text</type>
+               <mandatory enforced="false">true</mandatory>
+            </property>
          </properties>
       </type>
       <!-- Type with mandatory aspect -->
@@ -116,6 +120,10 @@
             <property name="test:prop-int-b">
                <type>d:int</type>
             </property>
+            <property name="test:prop-int-c">
+               <type>d:int</type>
+               <mandatory enforced="false">true</mandatory>
+            </property>
          </properties>
       </aspect>
       <!-- aspect with associations -->

source/java/org/alfresco/repo/node/integrity/PropertiesIntegrityEvent.java

@@ -126,8 +126,8 @@ public class PropertiesIntegrityEvent extends AbstractIntegrityEvent
         for (PropertyDefinition propertyDef : propertyDefs)
         {
             QName propertyQName = propertyDef.getName();
-            // check that mandatory properties are set
-            if (propertyDef.isMandatory() && !nodeProperties.containsKey(propertyQName))
+            // check that enforced, mandatoryproperties are set
+            if (propertyDef.isMandatory() && propertyDef.isMandatoryEnforced() && !nodeProperties.containsKey(propertyQName))
             {
                 IntegrityRecord result = new IntegrityRecord(
                         "Mandatory property not set: \n" +