RM-4431 CompleteRecordActionRestAPI

rm-automation/rm-automation-community-rest-api/src/main/java/org/alfresco/rest/rm/community/requests/gscore/api/RecordsAPI.java

@@ -139,6 +139,32 @@ public class RecordsAPI extends RMModelRequest
         ));
     }
 
+    /**
+     * Complete the record recordId
+     *
+     * @param recordId The id of the record to complete
+     * @return The {@link Record} with the given properties
+     * @throws Exception for the following cases:
+     *                   <ul>
+     *                   <li>Invalid parameter: {@code recordBodyFile} is not a valid format,{@code recordId} is not a record</li>
+     *                   <li>authentication fails</li>
+     *                   <li>current user does not have permission to file to {@code fileplanComponentId}</li>
+     *                   <li>{@code recordId} does not exist</li>
+     *                   <li>model integrity exception: the record is already complete</li>
+     *                   <li>model integrity exception: the record has missing meta-data</li>
+     *                   </ul>
+     */
+    public Record completeRecord(String recordId, String parameters) throws Exception
+    {
+        mandatoryString("recordId", recordId);
+
+        return getRmRestWrapper().processModel(Record.class, simpleRequest(
+            POST,
+            "/records/{recordId}/complete?{parameters}",
+            recordId,
+            parameters
+        ));
+    }
     /**
      * Deletes a record.
      *

rm-automation/rm-automation-community-rest-api/src/test/java/org/alfresco/rest/rm/community/records/CompleteRecordTests.java

@@ -0,0 +1,338 @@
+/*
+ * #%L
+ * Alfresco Records Management Module
+ * %%
+ * Copyright (C) 2005 - 2017 Alfresco Software Limited
+ * %%
+ * This file is part of the Alfresco software.
+ * -
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail.  Otherwise, the software is
+ * provided under the following open source license terms:
+ * -
+ * Alfresco is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * -
+ * Alfresco is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * -
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ * #L%
+ */
+package org.alfresco.rest.rm.community.records;
+
+import static org.alfresco.rest.rm.community.utils.FilePlanComponentsUtil.IMAGE_FILE;
+import static org.alfresco.rest.rm.community.utils.FilePlanComponentsUtil.createElectronicRecordModel;
+import static org.alfresco.rest.rm.community.utils.FilePlanComponentsUtil.createNonElectronicRecordModel;
+import static org.alfresco.rest.rm.community.utils.FilePlanComponentsUtil.getFile;
+import static org.springframework.http.HttpStatus.BAD_REQUEST;
+import static org.springframework.http.HttpStatus.CREATED;
+import static org.springframework.http.HttpStatus.UNPROCESSABLE_ENTITY;
+import static org.testng.Assert.assertEquals;
+
+import javax.xml.namespace.QName;
+import java.io.Serializable;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.alfresco.rest.rm.community.base.BaseRMRestTest;
+import org.alfresco.rest.rm.community.model.record.Record;
+import org.alfresco.rest.rm.community.requests.gscore.api.RecordFolderAPI;
+import org.alfresco.rest.rm.community.requests.gscore.api.RecordsAPI;
+import org.alfresco.test.AlfrescoTest;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+/**
+ * This class contains the tests for
+ * Complete Record Action REST API
+ *
+ * @author Sara Aspery
+ * @since 2.6
+ */
+public class CompleteRecordTests extends BaseRMRestTest
+{
+    private static final Boolean COMPLETE = true;
+    private static final Boolean INCOMPLETE = false;
+    private static final String parameters = "include=isCompleted";
+
+    /**
+     * Incomplete records with mandatory meta-data present
+     */
+    @DataProvider (name = "IncompleteRecordsMandatoryMetadataPresent")
+    public Object[][] getIncompleteRecordsMandatoryMetadataPresent() throws Exception
+    {
+        createRMSiteIfNotExists();
+        createMandatoryMetadata();
+
+        // create record folder
+        String recordFolderId = createCategoryFolderInFilePlan().getId();
+        RecordFolderAPI recordFolderAPI = getRestAPIFactory().getRecordFolderAPI();
+
+        //create electronic record in record folder
+        Record electronicRecord = recordFolderAPI.createRecord(createElectronicRecordModel(), recordFolderId,
+            getFile(IMAGE_FILE));
+        assertStatusCode(CREATED);
+        setMandatoryMetadata(electronicRecord);
+        // TODO verfiy mandatory metadata is present
+
+        //create non-electronic record in record folder
+        Record nonElectronicRecord = recordFolderAPI.createRecord(createNonElectronicRecordModel(), recordFolderId);
+        assertStatusCode(CREATED);
+        setMandatoryMetadata(nonElectronicRecord);
+
+        return new String[][]
+            {
+                // an arbitrary record folder
+                { electronicRecord.getId(), nonElectronicRecord.getId() },
+            };
+    }
+
+    /**
+     * Incomplete records with mandatory meta-data missing
+     */
+    @DataProvider (name = "IncompleteRecordsMandatoryMetadataMissing")
+    public Object[][] getIncompleteRecordsMandatoryMetadataMissing() throws Exception
+    {
+        createRMSiteIfNotExists();
+        createMandatoryMetadata();
+
+        String recordFolderId = createCategoryFolderInFilePlan().getId();
+        RecordFolderAPI recordFolderAPI = getRestAPIFactory().getRecordFolderAPI();
+
+        //create electronic record in record folder
+        Record electronicRecord = recordFolderAPI.createRecord(createElectronicRecordModel(), recordFolderId,
+            getFile(IMAGE_FILE));
+        assertStatusCode(CREATED);
+
+        //create non-electronic record in record folder
+        Record nonElectronicRecord = recordFolderAPI.createRecord(createNonElectronicRecordModel(), recordFolderId);
+        assertStatusCode(CREATED);
+
+        return new String[][]
+            {
+                // an arbitrary record folder
+                { electronicRecord.getId(), nonElectronicRecord.getId() },
+            };
+    }
+
+    // TODO repeat previous 2 providers but with config set to not chk for mandatory data
+
+    /**
+     * Document to be completed is not a record
+     */
+    @DataProvider (name = "Supplied node is not a record")
+    // TODO include is a document but not a record
+
+    public Object[][] getNodesWhichAreNotRecords() throws Exception
+    {
+        //create record folder
+        String recordFolderId = createCategoryFolderInFilePlan().getId();
+        RecordFolderAPI recordFolderAPI = getRestAPIFactory().getRecordFolderAPI();
+        Record electronicRecord = recordFolderAPI.createRecord(createElectronicRecordModel(), recordFolderId,
+            getFile(IMAGE_FILE));
+        assertStatusCode(CREATED);
+
+        //create non-electronic record in record folder
+        Record nonElectronicRecord = recordFolderAPI.createRecord(createNonElectronicRecordModel(), recordFolderId);
+        assertStatusCode(CREATED);
+
+        return new String[][]
+            {
+                { createCategoryFolderInFilePlan().getId() },
+
+            };
+    }
+
+    /**
+     * Incomplete records with mandatory meta-data missing
+     */
+    @DataProvider (name = "FrozenRecords")
+    public Object[][] getFrozenRecords() throws Exception
+    {
+        // TODO consider adding method to BaseRMRestTest eg. createRMSiteIfNotExists(DOD5015);
+        createRMSiteIfNotExists();
+
+        // TODO add custom metadata to record model, and do not populate it
+        //create electronic record in record folder
+        String recordFolderId = createCategoryFolderInFilePlan().getId();
+        RecordFolderAPI recordFolderAPI = getRestAPIFactory().getRecordFolderAPI();
+        Record electronicRecord = recordFolderAPI.createRecord(createElectronicRecordModel(), recordFolderId,
+            getFile(IMAGE_FILE));
+        assertStatusCode(CREATED);
+
+        //create non-electronic record in record folder
+        Record nonElectronicRecord = recordFolderAPI.createRecord(createNonElectronicRecordModel(), recordFolderId);
+        assertStatusCode(CREATED);
+
+        return new String[][]
+            {
+                // an arbitrary record folder
+                { electronicRecord.getId(), nonElectronicRecord.getId() },
+            };
+    }
+
+    // TODO Add test for authentication fails (see yaml file)
+    // TODO Add test for user does not have permission to complete record
+
+    /**
+     * <pre>
+     * Given the repository is configured to check mandatory data before completing a record
+     * And an incomplete record with all mandatory meta-data present
+     * When I complete the record
+     * Then the record is successfully completed
+     * </pre>
+     */
+    @Test
+        (
+            dataProvider = "IncompleteRecordsMandatoryMetadataPresent",
+            description = "Can complete electronic and non-electronic records with mandatory metadata present"
+        )
+    @AlfrescoTest (jira = "RM-4431")
+    public void completeRecordWithMandatoryMetadataPresent(String electronicRecordId, String nonElectronicRecordId)
+        throws Exception
+    {
+        // Get the recordsAPI
+        RecordsAPI recordsAPI = getRestAPIFactory().getRecordsAPI();
+        Record electronicRecord = recordsAPI.getRecord(electronicRecordId);
+        Record nonElectronicRecord = recordsAPI.getRecord(nonElectronicRecordId);
+
+        for (Record record : Arrays.asList(electronicRecord, nonElectronicRecord))
+        {
+            Record recordModel;
+            // Verify the record is incomplete
+            recordModel = recordsAPI.getRecord(record.getId(), parameters);
+            assertEquals(recordModel.getIsCompleted(), INCOMPLETE);
+
+            // Complete record
+            recordModel = recordsAPI.completeRecord(record.getId(), parameters);
+            assertStatusCode(CREATED);
+
+            // Verify the record has been completed
+            assertEquals(recordModel.getIsCompleted(), COMPLETE);
+        }
+    }
+
+    /**
+     * <pre>
+     * Given the repository is configured to check mandatory data before completing a record
+     * And an incomplete record with missing mandatory meta-data
+     * When I complete the record
+     * Then I receive an error indicating that I can't complete the operation,
+     * because some of the mandatory meta-data of the record is missing
+     * </pre>
+     */
+    @Test
+        (
+            dataProvider = "IncompleteRecordsMandatoryMetadataMissing",
+            description = "Cannot complete electronic and non-electronic records with mandatory metadata missing"
+        )
+    @AlfrescoTest (jira = "RM-4431")
+    public void completeRecordWithMandatoryMetadataMissing(String electronicRecordId, String nonElectronicRecordId)
+        throws Exception
+    {
+        // Get the recordsAPI
+        RecordsAPI recordsAPI = getRestAPIFactory().getRecordsAPI();
+        Record electronicRecord = recordsAPI.getRecord(electronicRecordId);
+        Record nonElectronicRecord = recordsAPI.getRecord(nonElectronicRecordId);
+
+        for (Record record : Arrays.asList(nonElectronicRecord))
+        {
+            Record recordModel;
+            // Verify the record is incomplete
+            recordModel = recordsAPI.getRecord(record.getId(), parameters);
+            assertEquals(recordModel.getIsCompleted(), INCOMPLETE);
+
+            //Verify the record has missing mandatory metadata
+            // TODO change next line to get custom metadata and check not populated
+            //assertEquals(recordModel.  .getProperties()  .getTitle(), INCOMPLETE);
+
+            // Complete record
+            recordModel = recordsAPI.completeRecord(record.getId(), parameters);
+            assertStatusCode(UNPROCESSABLE_ENTITY);
+
+            // Verify the record has not been completed
+            assertEquals(recordModel.getIsCompleted(), INCOMPLETE);
+        }
+    }
+
+    /**
+     * <pre>
+     * Given a document that is not a record or any non-document node
+     * When I complete the item
+     * Then I receive an unsupported operation error
+     * </pre>
+     */
+    @Test
+        (
+            dataProvider = "Supplied node is not a record",
+            description = "Cannot complete a document that is not a record"
+        )
+    @AlfrescoTest (jira = "RM-4431")
+    public void completeNonRecord(String nonRecordId)
+        throws Exception
+    {
+        // Get the recordsAPI
+        RecordsAPI recordsAPI = getRestAPIFactory().getRecordsAPI();
+        Record recordModel;
+        recordModel = recordsAPI.completeRecord(nonRecordId, parameters);
+        assertStatusCode(BAD_REQUEST);
+    }
+
+    /**
+     * <pre>
+     * Given a record that is already completed
+     * When I complete the record
+     * Then I receive an error indicating that I can't complete the operation, because the record is already complete
+     * </pre>
+     */
+    @Test
+        (
+            dataProvider = "IncompleteRecordsMandatoryMetadataPresent",
+            description = "Cannot complete a record that is already completed"
+        )
+    @AlfrescoTest (jira = "RM-4431")
+    public void completeAlreadyCompletedRecord(String electronicRecordId, String nonElectronicRecordId)
+        throws Exception
+    {
+        // Get the recordsAPI
+        RecordsAPI recordsAPI = getRestAPIFactory().getRecordsAPI();
+        Record electronicRecord = recordsAPI.getRecord(electronicRecordId);
+        Record nonElectronicRecord = recordsAPI.getRecord(nonElectronicRecordId);
+
+        for (Record record : Arrays.asList(nonElectronicRecord))
+        {
+            Record recordModel;
+            // If the record is incomplete, complete it
+            recordModel = recordsAPI.getRecord(record.getId(), parameters);
+            if (recordModel.getIsCompleted().equals(INCOMPLETE))
+            {
+                recordModel = recordsAPI.completeRecord(record.getId(), parameters);
+            }
+
+            // Verify the record is already completed
+            assertEquals(recordModel.getIsCompleted(), COMPLETE);
+
+            // Complete record
+            recordModel = recordsAPI.completeRecord(record.getId(), parameters);
+            assertStatusCode(UNPROCESSABLE_ENTITY);
+        }
+    }
+
+
+    private void createMandatoryMetadata()
+    {
+    }
+
+    private void setMandatoryMetadata(Record record)
+    {
+    }
+}

rm-community/rm-community-repo/source/java/org/alfresco/module/org_alfresco_module_rm/record/RecordService.java

@@ -213,6 +213,21 @@ public interface RecordService
     */
    void file(NodeRef record);
 
+    /**
+     * Indicates whether all the mandatory metadata for the record is populated or not
+     *
+     * @param record    record for which to check if all mandatory metadata is populated
+     * @return boolean  true if all mandatory metadata is populated, false otherwise
+     */
+    boolean isMandatoryPropertiesPopulated(NodeRef record);
+
+    /**
+     * Completes a record.
+     *
+     * @param record    record to be completed
+     */
+    void complete(NodeRef record);
+
    /**
     * Rejects a record with the provided reason
     *

rm-community/rm-community-repo/source/java/org/alfresco/module/org_alfresco_module_rm/record/RecordServiceImpl.java

@@ -78,6 +78,7 @@ import org.alfresco.module.org_alfresco_module_rm.version.RecordableVersionModel
 import org.alfresco.module.org_alfresco_module_rm.version.RecordableVersionService;
 import org.alfresco.repo.content.ContentServicePolicies;
 import org.alfresco.repo.node.NodeServicePolicies;
+import org.alfresco.repo.node.integrity.IntegrityException;
 import org.alfresco.repo.policy.ClassPolicyDelegate;
 import org.alfresco.repo.policy.PolicyComponent;
 import org.alfresco.repo.policy.Behaviour.NotificationFrequency;
@@ -91,6 +92,7 @@ import org.alfresco.repo.security.permissions.impl.ExtendedPermissionService;
 import org.alfresco.service.cmr.dictionary.AspectDefinition;
 import org.alfresco.service.cmr.dictionary.ClassDefinition;
 import org.alfresco.service.cmr.dictionary.PropertyDefinition;
+import org.alfresco.service.cmr.dictionary.TypeDefinition;
 import org.alfresco.service.cmr.model.FileFolderService;
 import org.alfresco.service.cmr.model.FileInfo;
 import org.alfresco.service.cmr.model.FileNotFoundException;
@@ -1302,6 +1304,94 @@ public class RecordServiceImpl extends BaseBehaviourBean
         }
     }
 
+    /**
+     * Helper method to 'complete' a record.
+     *
+     * @param record node reference to record
+     */
+    public void complete(NodeRef record)
+    {
+        ParameterCheck.mandatory("item", record);
+
+        // TODO get this from config
+        boolean checkMandatoryPropertiesEnabled = true;
+
+        if (!checkMandatoryPropertiesEnabled || (isMandatoryPropertiesPopulated(record)))
+        {
+            disablePropertyEditableCheck();
+            // Add the declared aspect
+            Map<QName, Serializable> declaredProps = new HashMap<>(2);
+            declaredProps.put(RecordsManagementModel.PROP_DECLARED_AT, new Date());
+            declaredProps.put(RecordsManagementModel.PROP_DECLARED_BY, AuthenticationUtil.getRunAsUser());
+            nodeService.addAspect(record, RecordsManagementModel.ASPECT_DECLARED_RECORD, declaredProps);
+            enablePropertyEditableCheck();
+        }
+    }
+
+    /**
+     * Helper method to determine whether a record's mandatory properties are set.
+     *
+     * @param nodeRef  node reference to record
+     * @return boolean true if all mandatory metadata properties are set, false otherwise
+     */
+    public boolean isMandatoryPropertiesPopulated(NodeRef nodeRef)
+    {
+        boolean result = true;
+
+        // check for missing mandatory metadata from type definitions
+        Map<QName, Serializable> nodeRefProps = nodeService.getProperties(nodeRef);
+        QName nodeRefType = nodeService.getType(nodeRef);
+
+        TypeDefinition typeDef = dictionaryService.getType(nodeRefType);
+        for (PropertyDefinition propDef : typeDef.getProperties().values())
+        {
+            if (propDef.isMandatory() && nodeRefProps.get(propDef.getName()) == null)
+            {
+                result = false;
+                break;
+            }
+        }
+
+        // check for missing mandatory metadata from aspect definitions
+        if (result)
+        {
+            // TODO change to aspects = getAspects(nodeRef) ?
+            Set<QName> aspects = nodeService.getAspects(nodeRef);
+            for (QName aspect : aspects)
+            {
+                AspectDefinition aspectDef = dictionaryService.getAspect(aspect);
+                for (PropertyDefinition propDef : aspectDef.getProperties().values())
+                {
+                    if (propDef.isMandatory() && nodeRefProps.get(propDef.getName()) == null)
+                    {
+                        result = false;
+                        break;
+                    }
+                }
+            }
+        }
+
+        // check for missing mandatory metadata from custom aspect definitions
+        if (result)
+        {
+            Collection<QName> aspects = dictionaryService.getAspects(RM_CUSTOM_MODEL);
+            for (QName aspect : aspects)
+            {
+                AspectDefinition aspectDef = dictionaryService.getAspect(aspect);
+                for (PropertyDefinition propDef : aspectDef.getProperties().values())
+                {
+                    if (propDef.isMandatory() && nodeRefProps.get(propDef.getName()) == null)
+                    {
+                        result = false;
+                        break;
+                    }
+                }
+            }
+        }
+
+        return result;
+    }
+
     /**
      * @see org.alfresco.module.org_alfresco_module_rm.record.RecordService#rejectRecord(org.alfresco.service.cmr.repository.NodeRef, java.lang.String)
      */

rm-community/rm-community-repo/source/java/org/alfresco/rm/rest/api/records/RecordsEntityResource.java

@@ -27,20 +27,26 @@
 
 package org.alfresco.rm.rest.api.records;
 
+import static org.alfresco.module.org_alfresco_module_rm.model.RecordsManagementCustomModel.RM_CUSTOM_MODEL;
 import static org.alfresco.module.org_alfresco_module_rm.util.RMParameterCheck.checkNotBlank;
 import static org.alfresco.util.ParameterCheck.mandatory;
 
 import java.io.Serializable;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
+
+import com.sun.xml.bind.v2.TODO;
 
 import org.alfresco.module.org_alfresco_module_rm.model.RecordsManagementModel;
 import org.alfresco.module.org_alfresco_module_rm.record.RecordService;
 import org.alfresco.repo.activities.ActivityType;
 import org.alfresco.repo.node.integrity.IntegrityException;
+import org.alfresco.repo.security.authentication.AuthenticationUtil;
 import org.alfresco.repo.transaction.RetryingTransactionHelper.RetryingTransactionCallback;
 import org.alfresco.rest.framework.BinaryProperties;
 import org.alfresco.rest.framework.Operation;
@@ -58,6 +64,10 @@ import org.alfresco.rm.rest.api.impl.FilePlanComponentsApiUtils;
 import org.alfresco.rm.rest.api.model.Record;
 import org.alfresco.rm.rest.api.model.TargetContainer;
 import org.alfresco.service.cmr.activities.ActivityPoster;
+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.model.FileExistsException;
 import org.alfresco.service.cmr.model.FileFolderService;
 import org.alfresco.service.cmr.model.FileInfo;
@@ -67,8 +77,10 @@ import org.alfresco.service.cmr.repository.NodeService;
 import org.alfresco.service.namespace.QName;
 import org.alfresco.service.transaction.TransactionService;
 import org.alfresco.util.ParameterCheck;
+import org.opensaml.ws.security.provider.MandatoryAuthenticatedMessageRule;
 import org.springframework.beans.factory.InitializingBean;
 import org.springframework.dao.ConcurrencyFailureException;
+import sun.util.resources.cldr.naq.CalendarData_naq_NA;
 
 /**
  * An implementation of an Entity Resource for a record
@@ -91,6 +103,7 @@ public class RecordsEntityResource implements BinaryResourceAction.Read,
     private RecordService recordService;
     private NodeService nodeService;
     private TransactionService transactionService;
+    private DictionaryService dictionaryService;
 
     public void setNodesModelFactory(ApiNodesModelFactory nodesModelFactory)
     {
@@ -122,6 +135,11 @@ public class RecordsEntityResource implements BinaryResourceAction.Read,
         this.transactionService = transactionService;
     }
 
+    public void setDictionaryService(DictionaryService dictionaryService)
+    {
+        this.dictionaryService = dictionaryService;
+    }
+
     /**
      * Download content
      *
@@ -240,7 +258,7 @@ public class RecordsEntityResource implements BinaryResourceAction.Read,
 
     @Operation ("complete")
     @WebApiDescription (title = "Complete record", description = "Complete a record.")
-    public Record completeRecord(String recordId, Void body, Parameters parameters)
+    public Record completeRecord(String recordId, Void body, Parameters parameters, WithResponse withResponse)
     {
         checkNotBlank("recordId", recordId);
         mandatory("parameters", parameters);
@@ -249,67 +267,30 @@ public class RecordsEntityResource implements BinaryResourceAction.Read,
         NodeRef record = apiUtils.validateRecord(recordId);
 
         // Complete the record
-        //TODO this should probably be something like recordService.complete(record);
+        if (!recordService.isDeclared(record))
-        completeRecord(record);
+        {
+            //TODO: move this to appropriate place when resolved
+            boolean checkMandatoryPropertiesEnabled = true; // TODO
+            if (checkMandatoryPropertiesEnabled && (!recordService.isMandatoryPropertiesPopulated(record)))
+            {
+                throw new IntegrityException("Model integrity exception: the record has missing mandatory meta-data.",
+                        null);
+            }
+            else
+            {
+                recordService.complete(record);
+            }
+        }
+        else
+        {
+            throw new IntegrityException("Model integrity exception: the record is already completed.", null);
+        }
 
         // return record state
         FileInfo info = fileFolderService.getFileInfo(record);
         return nodesModelFactory.createRecord(info, parameters, null, false);
     }
 
-    /* Temporary helper method just to do the complete record action.
-       Should probably live elsewhere, maybe RecordsImpl
-     */
-    private void completeRecord(NodeRef record) {
-        boolean checkMandatoryPropertiesEnabled = true;
-
-        if (! recordService.isDeclared(record))
-        {
-            List<String> missingProperties = new ArrayList<>(5);
-            if (checkMandatoryPropertiesEnabled && mandatoryPropertiesSet(record, missingProperties))
-            {
-                //TODO error here;
-            }
-            else
-            {
-                recordService.disablePropertyEditableCheck();
-                //try
-                //{
-                    // Add the declared aspect
-                    Map<QName, Serializable> declaredProps = new HashMap<>(2);
-                    declaredProps.put(RecordsManagementModel.PROP_DECLARED_AT, new Date());
-                    //TODO declaredProps.put(RecordsManagementModel.PROP_DECLARED_BY, AuthenticationUtil.getRunAsUser());
-                    nodeService.addAspect(record, RecordsManagementModel.ASPECT_DECLARED_RECORD, declaredProps);
-
-                    /* TODO
-                    AuthenticationUtil.runAsSystem(new RunAsWork<Void>()
-                    {
-                        @Override
-                        public Void doWork()
-                        {
-                            // remove all owner related rights
-                            getOwnableService().setOwner(record, OwnableService.NO_OWNER);
-                            return null;
-                        }
-                    });
-                    */
-                //} finally
-                //{
-                //    recordService.enablePropertyEditableCheck();
-                //}
-            }
-        }
-    }
-
-    /* TODO
-     * this is temporary partly because there is an error in the original code
-     */
-    private boolean mandatoryPropertiesSet(NodeRef nodeRef, List<String> missingProperties) {
-
-        return true;
-    }
-
-
     @Override
     @WebApiDescription(title = "Delete record", description="Deletes a record with id 'recordId'")
     public void delete(String recordId, Parameters parameters)

rm-community/rm-community-rest-api-explorer/src/main/webapp/definitions/gs-core-api.yaml

@@ -1801,7 +1801,7 @@ paths:
           schema:
             $ref: '#/definitions/Error'
   '/records/{recordId}/complete':
-    put:
+    post:
       tags:
         - records
       summary: Complete a record
@@ -1834,9 +1834,9 @@ paths:
         '404':
           description: |
             **recordIdParam** does not exist
-        '409':
+        '422':
           description: |
-            **recordIdParam** is already completed
+            Model integrity exception: the record is already completed
         default:
           description: Unexpected error
           schema: