Refactored marking definitions service

app/controllers/marking-definitions-controller.js

@@ -2,45 +2,50 @@
 
 const markingDefinitionsService = require('../services/marking-definitions-service');
 const logger = require('../lib/logger');
+const { BadlyFormattedParameterError, CannotUpdateStaticObjectError, InvalidQueryStringParameterError } = require('../exceptions');
 
 // NOTE: A marking definition does not support the modified or revoked properties!!
 
-exports.retrieveAll = function(req, res) {
+exports.retrieveAll = async function(req, res) {
     const options = {
         offset: req.query.offset || 0,
         limit: req.query.limit || 0,
         state: req.query.state,
         includeDeprecated: req.query.includeDeprecated,
         includePagination: req.query.includePagination
     }
-
-    markingDefinitionsService.retrieveAll(options, function(err, markingDefinitions) {
-        if (err) {
-            logger.error('Failed with error: ' + err);
-            return res.status(500).send('Unable to get marking definitions. Server error.');
+    try {
+        const markingDefinitions = await markingDefinitionsService.retrieveAll(options);
+        if (options.includePagination) {
+            logger.debug(`Success: Retrieved ${ markingDefinitions.data.length } of ${ markingDefinitions.pagination.total } total marking definition(s)`);
         }
         else {
-            if (options.includePagination) {
-                logger.debug(`Success: Retrieved ${ markingDefinitions.data.length } of ${ markingDefinitions.pagination.total } total marking definition(s)`);
-            }
-            else {
-                logger.debug(`Success: Retrieved ${ markingDefinitions.length } marking definition(s)`);
-            }
-            return res.status(200).send(markingDefinitions);
+            logger.debug(`Success: Retrieved ${ markingDefinitions.length } marking definition(s)`);
         }
-    });
+        return res.status(200).send(markingDefinitions);
+    } catch (err) {
+        logger.error('Failed with error: ' + err);
+        return res.status(500).send('Unable to get marking definitions. Server error.');
+    }
 };
 
-exports.retrieveById = function(req, res) {
+exports.retrieveById = async function(req, res) {
     const options = { };
-
-    markingDefinitionsService.retrieveById(req.params.stixId, options, function (err, markingDefinitions) {
-        if (err) {
-            if (err.message === markingDefinitionsService.errors.badlyFormattedParameter) {
+        try {
+            const markingDefinitions = await markingDefinitionsService.retrieveById(req.params.stixId, options);
+            if (markingDefinitions.length === 0) {
+                return res.status(404).send('Marking definitions not found.');
+            }
+            else {
+                logger.debug(`Success: Retrieved ${ markingDefinitions.length } marking definition with id ${ req.params.stixId }`);
+                return res.status(200).send(markingDefinitions);
+            }
+        } catch (err) {
+            if (err instanceof BadlyFormattedParameterError) {
                 logger.warn('Badly formatted stix id: ' + req.params.stixId);
                 return res.status(400).send('Stix id is badly formatted.');
             }
-            else if (err.message === markingDefinitionsService.errors.invalidQueryStringParameter) {
+            else if (err.message === InvalidQueryStringParameterError) {
                 logger.warn('Invalid query string: versions=' + req.query.versions);
                 return res.status(400).send('Query string parameter versions is invalid.');
             }
@@ -49,16 +54,6 @@ exports.retrieveById = function(req, res) {
                 return res.status(500).send('Unable to get marking definitions. Server error.');
             }
         }
-        else {
-            if (markingDefinitions.length === 0) {
-                return res.status(404).send('Marking definitions not found.');
-            }
-            else {
-                logger.debug(`Success: Retrieved ${ markingDefinitions.length } marking definition with id ${ req.params.stixId }`);
-                return res.status(200).send(markingDefinitions);
-            }
-        }
-    });
 };
 
 exports.create = async function(req, res) {
@@ -76,7 +71,7 @@ exports.create = async function(req, res) {
         return res.status(201).send(markingDefinition);
     }
     catch(err) {
-        if (err.message === markingDefinitionsService.errors.badlyFormattedParameter) {
+        if (err instanceof BadlyFormattedParameterError) {
             logger.warn('Unable to create marking definition: Stix id not allowed');
             return res.status(400).send('Stix id not allowed.');
         }
@@ -87,46 +82,42 @@ exports.create = async function(req, res) {
     }
 };
 
-exports.updateFull = function(req, res) {
+exports.updateFull = async function(req, res) {
     // Get the data from the request
     const markingDefinitionData = req.body;
 
     // Create the marking definition
-    markingDefinitionsService.updateFull(req.params.stixId, markingDefinitionData, function(err, markingDefinition) {
-        if (err) {
-            if (err.message === markingDefinitionsService.errors.cannotUpdateStaticObject) {
-                logger.warn('Unable to update marking definition, cannot update static object');
-                return res.status(400).send('Cannot update static object');
-            }
-            else {
-                logger.error("Failed with error: " + err);
-                return res.status(500).send("Unable to update marking definition. Server error.");
-            }
+    try {
+        const markingDefinition = await markingDefinitionsService.updateFull(req.params.stixId, markingDefinitionData);
+        if (!markingDefinition) {
+            return res.status(404).send('Marking definition not found.');
+        } else {
+            logger.debug("Success: Updated marking definition with id " + markingDefinition.stix.id);
+            return res.status(200).send(markingDefinition);
+        }
+    } catch (err) {
+        if (err instanceof CannotUpdateStaticObjectError) {
+            logger.warn('Unable to update marking definition, cannot update static object');
+            return res.status(400).send('Cannot update static object');
         }
         else {
-            if (!markingDefinition) {
-                return res.status(404).send('Marking definition not found.');
-            } else {
-                logger.debug("Success: Updated marking definition with id " + markingDefinition.stix.id);
-                return res.status(200).send(markingDefinition);
-            }
+            logger.error("Failed with error: " + err);
+            return res.status(500).send("Unable to update marking definition. Server error.");
         }
-    });
+    }
 };
 
-exports.delete = function(req, res) {
-    markingDefinitionsService.delete(req.params.stixId, function (err, markingDefinition) {
-        if (err) {
-            logger.error('Delete marking definition failed. ' + err);
-            return res.status(500).send('Unable to delete marking definition. Server error.');
-        }
-        else {
-            if (!markingDefinition) {
-                return res.status(404).send('Marking definition not found.');
-            } else {
-                logger.debug("Success: Deleted marking definition with id " + markingDefinition.stix.id);
-                return res.status(204).end();
-            }
+exports.delete = async function(req, res) {
+    try {
+        const markingDefinition = await markingDefinitionsService.delete(req.params.stixId);
+        if (!markingDefinition) {
+            return res.status(404).send('Marking definition not found.');
+        } else {
+            logger.debug("Success: Deleted marking definition with id " + markingDefinition.stix.id);
+            return res.status(204).end();
         }
-    });
+    } catch (err) {
+        logger.error('Delete marking definition failed. ' + err);
+        return res.status(500).send('Unable to delete marking definition. Server error.');
+    }
 };

app/exceptions/index.js

@@ -44,6 +44,12 @@ class InvalidQueryStringParameterError extends CustomError {
     }
 }
 
+class CannotUpdateStaticObjectError extends CustomError {
+    constructor(options) {
+        super('Cannot update static object', options);
+    }
+}
+
 class IdentityServiceError extends CustomError {
     constructor(options) {
         super('An error occurred in the identities service.', options);
@@ -96,6 +102,7 @@ module.exports = {
     MissingParameterError,
     BadlyFormattedParameterError,
     InvalidQueryStringParameterError,
+    CannotUpdateStaticObjectError,
 
     //** Database-related errors */
     DuplicateIdError,

app/repository/_base.repository.js

@@ -145,6 +145,25 @@ class BaseRepository extends AbstractRepository {
         }
     }
 
+    createNewDocument(data) {
+        return new this.model(data);
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    async saveDocument(document) {
+        try {
+            return await document.save();
+        }
+        catch(err) {
+            if (err.name === 'MongoServerError' && err.code === 11000) {
+                throw new DuplicateIdError({
+                    details: `Document with id '${ document.stix.id }' already exists.`
+                });
+            }
+            throw new DatabaseError(err);
+        }
+    }
+
     // eslint-disable-next-line class-methods-use-this
     async save(data) {
         try {

app/repository/marking-definitions-repository.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const BaseRepository = require('./_base.repository');
+const MarkingDefinition = require('../models/marking-definition-model');
+const { DatabaseError } = require('../exceptions');
+
+class MarkingDefinitionsRepository extends BaseRepository {
+
+    async deleteOneById(stixId) {
+        try {
+            return await this.model.findOneAndRemove({ 'stix.id': stixId }).exec();
+        }
+        catch (err) {
+            throw new DatabaseError(err);
+        }
+    }
+}
+
+module.exports = new MarkingDefinitionsRepository(MarkingDefinition);