From a7fddef34baf715437f9ad82ffa755532409b7be Mon Sep 17 00:00:00 2001 From: Sara Aspery Date: Tue, 6 Jun 2017 16:21:49 +0100 Subject: [PATCH] RM-5175_Complete_record_with_missing_metadata --- .../action/impl/DeclareRecordAction.java | 22 + .../record/CompleteRecordTest.java | 671 ++++++++++++++---- .../test/util/CommonRMTestUtils.java | 37 + 3 files changed, 585 insertions(+), 145 deletions(-) diff --git a/rm-community/rm-community-repo/source/java/org/alfresco/module/org_alfresco_module_rm/action/impl/DeclareRecordAction.java b/rm-community/rm-community-repo/source/java/org/alfresco/module/org_alfresco_module_rm/action/impl/DeclareRecordAction.java index 40698f75e4..83329105a4 100644 --- a/rm-community/rm-community-repo/source/java/org/alfresco/module/org_alfresco_module_rm/action/impl/DeclareRecordAction.java +++ b/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 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; } diff --git a/rm-community/rm-community-repo/test/java/org/alfresco/module/org_alfresco_module_rm/test/integration/record/CompleteRecordTest.java b/rm-community/rm-community-repo/test/java/org/alfresco/module/org_alfresco_module_rm/test/integration/record/CompleteRecordTest.java index dc31c9ba14..0079cc3829 100644 --- a/rm-community/rm-community-repo/test/java/org/alfresco/module/org_alfresco_module_rm/test/integration/record/CompleteRecordTest.java +++ b/rm-community/rm-community-repo/test/java/org/alfresco/module/org_alfresco_module_rm/test/integration/record/CompleteRecordTest.java @@ -33,210 +33,591 @@ 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; /** * Complete record tests. - * + * * @author Roy Wetherall * @since 2.2.1 */ 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"); - - /** complete record action */ - private DeclareRecordAction action; - - /** - * @see org.alfresco.module.org_alfresco_module_rm.test.util.BaseRMTestCase#initServices() - */ - @Override - protected void initServices() - { - super.initServices(); - - // get the action - action = (DeclareRecordAction)applicationContext.getBean("declareRecord"); - } - - /** - * @see org.alfresco.module.org_alfresco_module_rm.test.util.BaseRMTestCase#tearDownImpl() - */ - @Override - protected void tearDownImpl() - { - super.tearDownImpl(); - - // ensure action is returned to original state - action.setCheckMandatoryPropertiesEnabled(true); - } - - /** - * Given the the application is configured to check for mandatory values before complete - * And a filed record is missing 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 - */ +{ + 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 + */ + private DeclareRecordAction action; + + /** + * @see org.alfresco.module.org_alfresco_module_rm.test.util.BaseRMTestCase#initServices() + */ + @Override + protected void initServices() + { + super.initServices(); + + // get the action + action = (DeclareRecordAction) applicationContext.getBean("declareRecord"); + } + + /** + * @see org.alfresco.module.org_alfresco_module_rm.test.util.BaseRMTestCase#tearDownImpl() + */ + @Override + protected void tearDownImpl() + { + super.tearDownImpl(); + + // ensure action is returned to original state + action.setCheckMandatoryPropertiesEnabled(true); + } + + /** + * Given the the application is configured to check for mandatory values before complete + * And a filed record is missing 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 testCheckForMandatoryValuesMissing() throws Exception { doBehaviourDrivenTest(new BehaviourDrivenTest() - { - private NodeRef record; - private RecordsManagementActionResult result; - + { + private NodeRef record; + private RecordsManagementActionResult result; + public void given() { - // enable mandatory parameter check - action.setCheckMandatoryPropertiesEnabled(true); - - // create a record - record = utils.createRecord(rmFolder, "record.txt", "title"); - - // add the record aspect (that has a mandatory property) - nodeService.addAspect(record, ASPECT_TEST, null); + // enable mandatory parameter check + action.setCheckMandatoryPropertiesEnabled(true); + + // create a record + record = utils.createRecord(rmFolder, "record.txt", "title"); + + // add the record aspect (that has a mandatory property) + nodeService.addAspect(record, ASPECT_TEST, null); } - + public void when() { - // complete record - result = rmActionService.executeRecordsManagementAction(record, "declareRecord"); + // complete record + result = rmActionService.executeRecordsManagementAction(record, "declareRecord"); } - - public void then() + + public void then() { - assertNotNull(result); - assertNotNull(result.getValue()); - assertFalse(nodeService.hasAspect(record, ASPECT_DECLARED_RECORD)); + assertNotNull(result); + assertNotNull(result.getValue()); + assertFalse(nodeService.hasAspect(record, ASPECT_DECLARED_RECORD)); } - }); + }); } - + /** - * Given the the application is configured to check for mandatory values before complete - * And a filed record has all mandatory values - * When I try to complete the record - * Then the record is completed - */ + * Given the the application is configured to check for mandatory values before complete + * And a filed record has all mandatory values + * When I try to complete the record + * Then the record is completed + */ public void testCheckForMandatoryValuePresent() throws Exception { doBehaviourDrivenTest(new BehaviourDrivenTest() - { - private NodeRef record; - private RecordsManagementActionResult result; - + { + private NodeRef record; + private RecordsManagementActionResult result; + public void given() { - // enable mandatory parameter check - action.setCheckMandatoryPropertiesEnabled(true); - - // create a record - record = utils.createRecord(rmFolder, "record.txt", "title"); - - // add the record aspect (that has a mandatory property) - Map properties = new HashMap(1); - properties.put(PROP_TEST, "something"); - nodeService.addAspect(record, ASPECT_TEST, properties); + // enable mandatory parameter check + action.setCheckMandatoryPropertiesEnabled(true); + + // create a record + record = utils.createRecord(rmFolder, "record.txt", "title"); + + // add the record aspect (that has a mandatory property) + Map properties = new HashMap<>(1); + properties.put(PROP_TEST, "something"); + nodeService.addAspect(record, ASPECT_TEST, properties); } - + public void when() { - // complete record - result = rmActionService.executeRecordsManagementAction(record, "declareRecord"); + // complete record + result = rmActionService.executeRecordsManagementAction(record, "declareRecord"); } - - public void then() + + public void then() { - assertNotNull(result); - assertNull(result.getValue()); - assertTrue(nodeService.hasAspect(record, ASPECT_DECLARED_RECORD)); + assertNotNull(result); + assertNull(result.getValue()); + assertTrue(nodeService.hasAspect(record, ASPECT_DECLARED_RECORD)); } - }); + }); } - + /** - * Given the the application is configured not to check for mandatory values before complete - * And a filed record is missing mandatory values - * When I try to complete the record - * Then the record is completed - */ + * 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 + * When I try to complete the record + * Then the record is completed + */ public void testDontCheckForMandatoryValuesMissing() throws Exception { doBehaviourDrivenTest(new BehaviourDrivenTest() - { - private NodeRef record; - private RecordsManagementActionResult result; - + { + private NodeRef record; + private RecordsManagementActionResult result; + public void given() { - // disable mandatory parameter check - action.setCheckMandatoryPropertiesEnabled(false); - - // create a record - record = utils.createRecord(rmFolder, "record.txt", "title"); - - // add the record aspect (that has a mandatory property) - nodeService.addAspect(record, ASPECT_TEST, null); + // disable mandatory parameter check + action.setCheckMandatoryPropertiesEnabled(false); + + // create a record + record = utils.createRecord(rmFolder, "record.txt", "title"); + + // add the record aspect (that has a mandatory property) + nodeService.addAspect(record, ASPECT_TEST, null); } - + public void when() { - // complete record - result = rmActionService.executeRecordsManagementAction(record, "declareRecord"); + // complete record + result = rmActionService.executeRecordsManagementAction(record, "declareRecord"); } - - public void then() + + public void then() { - assertNotNull(result); - assertNull(result.getValue()); - assertTrue(nodeService.hasAspect(record, ASPECT_DECLARED_RECORD)); + assertNotNull(result); + assertNull(result.getValue()); + assertTrue(nodeService.hasAspect(record, ASPECT_DECLARED_RECORD)); } - }); + }); } - + /** - * Given the the application is configured to not to check for mandatory values before complete - * And a filed record has all mandatory values - * When I try to complete the record - * Then the record is completed - */ + * Given the the application is configured to not to check for mandatory values before complete + * And a filed record has all mandatory values + * When I try to complete the record + * Then the record is completed + */ public void testDontCheckForMandatoryValuePresent() throws Exception { doBehaviourDrivenTest(new BehaviourDrivenTest() - { - private NodeRef record; - private RecordsManagementActionResult result; - + { + private NodeRef record; + private RecordsManagementActionResult result; + public void given() { - // enable mandatory parameter check - action.setCheckMandatoryPropertiesEnabled(false); - - // create a record - record = utils.createRecord(rmFolder, "record.txt", "title"); - - // add the record aspect (that has a mandatory property) - Map properties = new HashMap(1); - properties.put(PROP_TEST, "something"); - nodeService.addAspect(record, ASPECT_TEST, properties); + // enable mandatory parameter check + action.setCheckMandatoryPropertiesEnabled(false); + + // create a record + record = utils.createRecord(rmFolder, "record.txt", "title"); + + // add the record aspect (that has a mandatory property) + Map properties = new HashMap<>(1); + properties.put(PROP_TEST, "something"); + nodeService.addAspect(record, ASPECT_TEST, properties); } - + public void when() { - // complete record - result = rmActionService.executeRecordsManagementAction(record, "declareRecord"); + // complete record + result = rmActionService.executeRecordsManagementAction(record, "declareRecord"); } - - public void then() + + public void then() { - assertNotNull(result); - assertNull(result.getValue()); - assertTrue(nodeService.hasAspect(record, ASPECT_DECLARED_RECORD)); + assertNotNull(result); + assertNull(result.getValue()); + assertTrue(nodeService.hasAspect(record, ASPECT_DECLARED_RECORD)); } - }); + }); + } + + /** + * 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 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); } } diff --git a/rm-community/rm-community-repo/test/java/org/alfresco/module/org_alfresco_module_rm/test/util/CommonRMTestUtils.java b/rm-community/rm-community-repo/test/java/org/alfresco/module/org_alfresco_module_rm/test/util/CommonRMTestUtils.java index 20b8947d0a..f0b8e2829f 100644 --- a/rm-community/rm-community-repo/test/java/org/alfresco/module/org_alfresco_module_rm/test/util/CommonRMTestUtils.java +++ b/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 props = new HashMap(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 properties) + { + // Create the document + if (properties == null) + { + properties = new HashMap(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. */