RM-5175_Complete_record_with_missing_metadata

rm-community/rm-community-repo/source/java/org/alfresco/module/org_alfresco_module_rm/action/impl/DeclareRecordAction.java

@@ -29,6 +29,7 @@ package org.alfresco.module.org_alfresco_module_rm.action.impl;
 
 import java.io.Serializable;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.List;
@@ -193,6 +194,27 @@ public class DeclareRecordAction extends RMActionExecuterAbstractBase
             }
         }
 
+        // check for missing mandatory metadata from custom aspect definitions
+        if (result)
+        {
+            Collection<QName> aspects = this.getDictionaryService().getAspects(RM_CUSTOM_MODEL);
+            for (QName aspect : aspects)
+            {
+                // TODO should not apply record custom metadata for non-electronic and vice versa
+                AspectDefinition aspectDef = this.getDictionaryService().getAspect(aspect);
+                for (PropertyDefinition propDef : aspectDef.getProperties().values())
+                {
+                    if (propDef.isMandatory() && nodeRefProps.get(propDef.getName()) == null)
+                    {
+                        logMissingProperty(propDef, missingProperties);
+
+                        result = false;
+                        break;
+                    }
+                }
+            }
+        }
+
         return result;
     }
 

rm-community/rm-community-repo/test/java/org/alfresco/module/org_alfresco_module_rm/test/integration/record/CompleteRecordTest.java

@@ -33,7 +33,9 @@ import java.util.Map;
 
 import org.alfresco.module.org_alfresco_module_rm.action.RecordsManagementActionResult;
 import org.alfresco.module.org_alfresco_module_rm.action.impl.DeclareRecordAction;
+import org.alfresco.module.org_alfresco_module_rm.model.RecordsManagementCustomModel;
 import org.alfresco.module.org_alfresco_module_rm.test.util.BaseRMTestCase;
+import org.alfresco.service.cmr.dictionary.DataTypeDefinition;
 import org.alfresco.service.cmr.repository.NodeRef;
 import org.alfresco.service.namespace.QName;
 
@@ -47,8 +49,14 @@ public class CompleteRecordTest extends BaseRMTestCase
 {
     private static final QName ASPECT_TEST = QName.createQName("http://www.alfresco.org/model/rmtest/1.0", "recordMetaDataWithProperty");
     private static final QName PROP_TEST = QName.createQName("http://www.alfresco.org/model/rmtest/1.0", "customMandatoryProperty");
+    private static final QName CUSTOM_ELECTRONIC_TEST = QName.createQName(RecordsManagementCustomModel.RM_CUSTOM_URI, "rmarecordCustomProperties");
+    private static final QName CUSTOM_NON_ELECTRONIC_TEST = QName.createQName(RecordsManagementCustomModel.RM_CUSTOM_URI, "rmanonElectronicDocumentCustomProperties");
+    private static final boolean MANDATORY_METADATA = true;
+    private static final boolean OPTIONAL_METADATA = false;
 
-	/** complete record action */
+    /**
+     * complete record action
+     */
     private DeclareRecordAction action;
 
     /**
@@ -138,7 +146,7 @@ public class CompleteRecordTest extends BaseRMTestCase
                 record = utils.createRecord(rmFolder, "record.txt", "title");
 
                 // add the record aspect (that has a mandatory property)
-            	Map<QName, Serializable> properties = new HashMap<QName, Serializable>(1);
+                Map<QName, Serializable> properties = new HashMap<>(1);
                 properties.put(PROP_TEST, "something");
                 nodeService.addAspect(record, ASPECT_TEST, properties);
             }
@@ -158,6 +166,339 @@ public class CompleteRecordTest extends BaseRMTestCase
         });
     }
 
+    /**
+     * Given the the application is configured to check for mandatory values before complete
+     * And a filed record is missing custom mandatory values
+     * When I try to complete the record
+     * Then the missing properties parameter of the action will be populated
+     * And the record will not be complete
+     */
+    public void testCheckForCustomMandatoryValuesMissing() throws Exception
+    {
+        doBehaviourDrivenTest(new BehaviourDrivenTest()
+        {
+            private NodeRef record;
+            private RecordsManagementActionResult result;
+
+            public void given() throws Exception
+            {
+                // enable mandatory parameter check
+                action.setCheckMandatoryPropertiesEnabled(true);
+
+                // create the custom metadata definition (that has a mandatory property) for electronic records
+                defineCustomMetadata(CUSTOM_ELECTRONIC_TEST, ASPECT_RECORD, MANDATORY_METADATA);
+
+                // create an electronic record
+                record = utils.createRecord(rmFolder, "electronicRecord.txt", "title");
+            }
+
+            public void when()
+            {
+                // complete record
+                result = rmActionService.executeRecordsManagementAction(record, "declareRecord");
+            }
+
+            public void then()
+            {
+                assertNotNull(result);
+                assertNotNull(result.getValue());
+                assertFalse(nodeService.hasAspect(record, ASPECT_DECLARED_RECORD));
+            }
+
+            public void after()
+            {
+                // remove the custom metadata definition
+                removeCustomMetadata(CUSTOM_ELECTRONIC_TEST);
+            }
+        });
+    }
+
+    /**
+     * Given the the application is configured to check for mandatory values before complete
+     * And a filed record has all custom mandatory values
+     * When I try to complete the record
+     * Then the record is completed
+     */
+    public void testCheckForCustomMandatoryValuePresent() throws Exception
+    {
+        doBehaviourDrivenTest(new BehaviourDrivenTest()
+        {
+            private NodeRef record;
+            private RecordsManagementActionResult result;
+
+            public void given() throws Exception
+            {
+                // enable mandatory parameter check
+                action.setCheckMandatoryPropertiesEnabled(true);
+
+                // define the custom metadata definition (that has a mandatory property)
+                defineCustomMetadata(CUSTOM_ELECTRONIC_TEST, ASPECT_RECORD, MANDATORY_METADATA);
+
+                // create a record
+                record = utils.createRecord(rmFolder, "customrecord.txt", "title");
+
+                // populate the custom metadata mandatory property for the record
+                populateCustomMetadata(record, CUSTOM_ELECTRONIC_TEST);
+            }
+
+            public void when()
+            {
+                // complete record
+                result = rmActionService.executeRecordsManagementAction(record, "declareRecord");
+            }
+
+            public void then()
+            {
+                assertNotNull(result);
+                assertNull(result.getValue());
+                assertTrue(nodeService.hasAspect(record, ASPECT_DECLARED_RECORD));
+            }
+
+            public void after()
+            {
+                // remove the custom metadata definition
+                removeCustomMetadata(CUSTOM_ELECTRONIC_TEST);
+            }
+        });
+    }
+
+    /**
+     * Given the the application is configured to check for mandatory values before complete
+     * And a non-electronic record is missing custom mandatory values
+     * When I try to complete the record
+     * Then the missing properties parameter of the action will be populated
+     * And the record will not be complete
+     */
+    public void testCheckForCustomMandatoryValuesMissingInNonElectronicRecord() throws Exception
+    {
+        doBehaviourDrivenTest(new BehaviourDrivenTest()
+        {
+            private NodeRef nonElectronicRecord;
+            private RecordsManagementActionResult result;
+
+            public void given() throws Exception
+            {
+                // enable mandatory parameter check
+                action.setCheckMandatoryPropertiesEnabled(true);
+
+                // create the custom metadata definition (that has a mandatory property) for non-electronic records
+                defineCustomMetadata(CUSTOM_NON_ELECTRONIC_TEST, TYPE_NON_ELECTRONIC_DOCUMENT, MANDATORY_METADATA);
+
+                // create a non-electronic record
+                nonElectronicRecord = utils.createRecord(rmFolder, "non-electronicRecord.txt", "title");
+            }
+
+            public void when()
+            {
+                // complete non-electronic record
+                result = rmActionService.executeRecordsManagementAction(nonElectronicRecord,
+                        "declareRecord");
+            }
+
+            public void then()
+            {
+                assertNotNull(result);
+                assertNotNull(result.getValue());
+                assertFalse(nodeService.hasAspect(nonElectronicRecord, ASPECT_DECLARED_RECORD));
+            }
+
+            public void after()
+            {
+                // remove the custom metadata definition
+                removeCustomMetadata(CUSTOM_NON_ELECTRONIC_TEST);
+            }
+        });
+    }
+
+    /**
+     * Given the the application is configured to check for mandatory values before complete
+     * And a non-electronic record has all custom mandatory values
+     * When I try to complete the record
+     * Then the record is completed
+     */
+    public void testCheckForCustomMandatoryValuePresentInNonElectronicRecord() throws Exception
+    {
+        doBehaviourDrivenTest(new BehaviourDrivenTest()
+        {
+            private NodeRef nonElectronicRecord;
+            private RecordsManagementActionResult result;
+
+            public void given() throws Exception
+            {
+                // enable mandatory parameter check
+                action.setCheckMandatoryPropertiesEnabled(true);
+
+                // create the custom metadata definition (that has a mandatory property)
+                defineCustomMetadata(CUSTOM_NON_ELECTRONIC_TEST, ASPECT_RECORD, MANDATORY_METADATA);
+
+                // create a non-electronic record
+                nonElectronicRecord = utils.createRecord(rmFolder, "non-electronicRecord.txt", "title");
+
+                // populate the custom metadata mandatory property for the record
+                populateCustomMetadata(nonElectronicRecord, CUSTOM_NON_ELECTRONIC_TEST);
+            }
+
+            public void when()
+            {
+                // complete record
+                result = rmActionService.executeRecordsManagementAction(nonElectronicRecord, "declareRecord");
+            }
+
+            public void then()
+            {
+                assertNotNull(result);
+                assertNull(result.getValue());
+                assertTrue(nodeService.hasAspect(nonElectronicRecord, ASPECT_DECLARED_RECORD));
+            }
+
+            public void after()
+            {
+                // remove the custom metadata definition
+                removeCustomMetadata(CUSTOM_NON_ELECTRONIC_TEST);
+            }
+        });
+    }
+
+    /**
+     * Given the the application is configured to check for mandatory values before complete
+     * And a filed record is missing custom non-mandatory values
+     * When I try to complete the record
+     * Then the record is completed
+     */
+    public void testCheckForCustomOptionalValuesMissing() throws Exception
+    {
+        doBehaviourDrivenTest(new BehaviourDrivenTest()
+        {
+            private NodeRef record;
+            private RecordsManagementActionResult result;
+
+            public void given() throws Exception
+            {
+                // enable mandatory parameter check
+                action.setCheckMandatoryPropertiesEnabled(true);
+
+                // create the custom metadata definition (that does not have a mandatory property)
+                defineCustomMetadata(CUSTOM_ELECTRONIC_TEST, ASPECT_RECORD, OPTIONAL_METADATA);
+
+                // create a record
+                record = utils.createRecord(rmFolder, "customrecord.txt", "title");
+            }
+
+            public void when()
+            {
+                // complete record
+                result = rmActionService.executeRecordsManagementAction(record, "declareRecord");
+            }
+
+            public void then()
+            {
+                assertNotNull(result);
+                assertNull(result.getValue());
+                assertTrue(nodeService.hasAspect(record, ASPECT_DECLARED_RECORD));
+            }
+
+            public void after()
+            {
+                // remove the custom metadata definition
+                removeCustomMetadata(CUSTOM_ELECTRONIC_TEST);
+            }
+        });
+    }
+
+    /**
+     * Given the the application is configured to check for mandatory values before complete
+     * And custom mandatory metadata is required for electronic records
+     * And a non-electronic record has no custom mandatory values
+     * When I try to complete the non-electronic record
+     * Then the record is completed
+     */
+    public void testElectronicRecordCustomMandatoryNotAppliedToNonElectronicRecord() throws Exception
+    {
+        doBehaviourDrivenTest(new BehaviourDrivenTest()
+        {
+            private NodeRef nonElectronicRecord;
+            private RecordsManagementActionResult result;
+
+            public void given() throws Exception
+            {
+                // enable mandatory parameter check
+                action.setCheckMandatoryPropertiesEnabled(true);
+
+                // create the custom metadata definition (that has a mandatory property)
+                defineCustomMetadata(CUSTOM_ELECTRONIC_TEST, ASPECT_RECORD, MANDATORY_METADATA);
+
+                // create a non-electronic record
+                nonElectronicRecord = utils.createRecord(rmFolder, "non-electronicRecord.txt", "title");
+            }
+
+            public void when()
+            {
+                // complete record
+                result = rmActionService.executeRecordsManagementAction(nonElectronicRecord, "declareRecord");
+            }
+
+            public void then()
+            {
+                assertNotNull(result);
+                assertNull(result.getValue());
+                assertTrue(nodeService.hasAspect(nonElectronicRecord, ASPECT_DECLARED_RECORD));
+            }
+
+            public void after()
+            {
+                // remove the custom metadata definition
+                removeCustomMetadata(CUSTOM_ELECTRONIC_TEST);
+            }
+        });
+    }
+
+    /**
+     * Given the the application is configured to check for mandatory values before complete
+     * And custom mandatory metadata is required for non-electronic records
+     * And an electronic record has no custom mandatory values
+     * When I try to complete the electronic record
+     * Then the record is completed
+     */
+    public void testNonElectronicRecordCustomMandatoryNotAppliedToElectronicRecord() throws Exception
+    {
+        doBehaviourDrivenTest(new BehaviourDrivenTest()
+        {
+            private NodeRef record;
+            private RecordsManagementActionResult result;
+
+            public void given() throws Exception
+            {
+                // enable mandatory parameter check
+                action.setCheckMandatoryPropertiesEnabled(true);
+
+                // create the custom metadata definition (that has a mandatory property)
+                defineCustomMetadata(CUSTOM_NON_ELECTRONIC_TEST, ASPECT_RECORD, MANDATORY_METADATA);
+
+                // create a electronic record
+                record = utils.createRecord(rmFolder, "electronicRecord.txt", "title");
+            }
+
+            public void when()
+            {
+                // complete record
+                result = rmActionService.executeRecordsManagementAction(record, "declareRecord");
+            }
+
+            public void then()
+            {
+                assertNotNull(result);
+                assertNull(result.getValue());
+                assertTrue(nodeService.hasAspect(record, ASPECT_DECLARED_RECORD));
+            }
+
+            public void after()
+            {
+                // remove the custom metadata definition
+                removeCustomMetadata(CUSTOM_NON_ELECTRONIC_TEST);
+            }
+        });
+    }
+
     /**
      * Given the the application is configured not to check for mandatory values before complete
      * And a filed record is missing mandatory values
@@ -220,7 +561,7 @@ public class CompleteRecordTest extends BaseRMTestCase
                 record = utils.createRecord(rmFolder, "record.txt", "title");
 
                 // add the record aspect (that has a mandatory property)
-            	Map<QName, Serializable> properties = new HashMap<QName, Serializable>(1);
+                Map<QName, Serializable> properties = new HashMap<>(1);
                 properties.put(PROP_TEST, "something");
                 nodeService.addAspect(record, ASPECT_TEST, properties);
             }
@@ -239,4 +580,44 @@ public class CompleteRecordTest extends BaseRMTestCase
             }
         });
     }
+
+    /**
+     * Helper method to create a Custom Metadata definition in the RM custom model
+     *
+     * @param mandatory specifies if metadata is mandatory
+     */
+    private void defineCustomMetadata(QName propId, QName typeName, boolean mandatory) throws Exception
+    {
+        rmAdminService.addCustomPropertyDefinition(
+                propId,
+                typeName,
+                "SomeCustomDefLabel",
+                DataTypeDefinition.TEXT,
+                null,
+                null,
+                null,
+                false,
+                mandatory,
+                false,
+                null
+                                                  );
+    }
+
+    /**
+     * Helper method to populate the Custom Metadata for the record
+     */
+    private void populateCustomMetadata(NodeRef record, QName propId)
+    {
+        Map<QName, Serializable> properties = new HashMap<>(1);
+        properties.put(propId, "SomeCustomValue");
+        nodeService.addAspect(record, propId, properties);
+    }
+
+    /**
+     * Helper method to remove the Custom Metadata definition in the RM custom model
+     */
+    private void removeCustomMetadata(QName propId)
+    {
+        rmAdminService.removeCustomPropertyDefinition(propId);
+    }
 }

rm-community/rm-community-repo/test/java/org/alfresco/module/org_alfresco_module_rm/test/util/CommonRMTestUtils.java

@@ -298,6 +298,43 @@ public class CommonRMTestUtils implements RecordsManagementModel
         return record;
     }
 
+    /**
+     * Helper method to create a non-electronic record in a record folder.
+     *
+     * @param recordFolder record folder
+     * @param name         name of the non-electronic record
+     * @param title        title of the non-electronic record
+     * @return {@link NodeRef}  non-electronic record node reference
+     */
+    public NodeRef createNonElectronicRecord(NodeRef recordFolder, String name, String title)
+    {
+        Map<QName, Serializable> props = new HashMap<QName, Serializable>(1);
+        props.put(ContentModel.PROP_TITLE, title);
+        return createNonElectronicRecordImpl(recordFolder, name, props);
+    }
+
+    /**
+     * Helper to consolidate creation of non-electronic record
+     */
+    private NodeRef createNonElectronicRecordImpl(NodeRef recordFolder, String name, Map<QName, Serializable> properties)
+    {
+        // Create the document
+        if (properties == null)
+        {
+            properties = new HashMap<QName, Serializable>(1);
+        }
+        if (!properties.containsKey(ContentModel.PROP_NAME))
+        {
+            properties.put(ContentModel.PROP_NAME, name);
+        }
+        NodeRef record = nodeService.createNode(recordFolder,
+                ContentModel.ASSOC_CONTAINS,
+                QName.createQName(NamespaceService.CONTENT_MODEL_1_0_URI, name),
+                RecordsManagementModel.TYPE_NON_ELECTRONIC_DOCUMENT,
+                properties).getChildRef();
+        return record;
+    }
+
     /**
      * Helper method to complete record.
      */