Add additional unimplemented functions.

Remove redundant code.
Modify attack objects repository so that the base service can be used for the retrieveAll() function.
Avoid using the AttackObject model in the service.

app/repository/attack-objects-repository.js

@@ -2,8 +2,6 @@
 
 const BaseRepository = require('./_base.repository');
 const AttackObject = require('../models/attack-object-model');
-const util = require('util');
-const { BadlyFormattedParameterError, MissingParameterError } = require('../exceptions');
 const { lastUpdatedByQueryHelper } = require('../lib/request-parameter-helper');
 
 const regexValidator = require('../lib/regex');
@@ -19,8 +17,6 @@ class AttackObjectsRepository extends BaseRepository {
         duplicateCollection: 'Duplicate collection'
     };
 
-    relationshipPrefix = 'relationship';
-
     identitiesService;
 
     async retrieveAll(options) {
@@ -84,7 +80,7 @@ class AttackObjectsRepository extends BaseRepository {
         }
 
         // Retrieve the documents
-        let documents = await AttackObject.aggregate(aggregation);
+        let documents = await this.model.aggregate(aggregation);
 
         // Add relationships from separate collection
         if (!options.attackId && !options.search) {
@@ -113,69 +109,12 @@ class AttackObjectsRepository extends BaseRepository {
             paginatedDocuments = documents.slice(offset);
         }
 
-        // Add identities
-        if (!this.identitiesService) {
-            this.identitiesService = require('../services/identities-service');
-        }
-        await this.identitiesService.addCreatedByAndModifiedByIdentitiesToAll(paginatedDocuments);
-
-        // Prepare the return value
-        if (options.includePagination) {
-            const returnValue = {
-                pagination: {
-                    total: documents.length,
-                    offset: options.offset,
-                    limit: options.limit
-                },
-                data: paginatedDocuments
-            };
-            return returnValue;
-        }
-        else {
-            return paginatedDocuments;
-        }
+        // Mimic the format that the base repository uses to return documents
+        return [{
+            documents: paginatedDocuments,
+            totalCount: [ { totalCount: documents.length } ]
+        }];
     }
-
-    async retrieveVersionById(stixId, modified) {
-        // Retrieve the version of the attack object with the matching stixId and modified date
-
-        // require here to avoid circular dependency
-        const relationshipsService = require('../services/relationships-service');
-        const retrieveRelationshipsVersionById = util.promisify(relationshipsService.retrieveVersionById);
-
-        if (!stixId) {
-            throw new MissingParameterError('stixId');
-        }
-
-        if (!modified) {
-            throw new MissingParameterError('modified');
-        }
-
-        let attackObject;
-        if (stixId.startsWith(this.relationshipPrefix)) {
-            attackObject = await retrieveRelationshipsVersionById(stixId, modified);
-        }
-        else {
-            try {
-                attackObject = await AttackObject.findOne({ 'stix.id': stixId, 'stix.modified': modified });
-            }
-            catch(err) {
-                if (err.name === 'CastError') {
-                    throw new BadlyFormattedParameterError('stixId');
-                } else {
-                    throw err;
-                }
-            }
-        }
-
-        // Note: attackObject is null if not found
-        if (!this.identitiesService) {
-            this.identitiesService = require('../services/identities-service');
-        }
-        await this.identitiesService.addCreatedByAndModifiedByIdentities(attackObject);
-        return attackObject;
-    }
-
- }
+}
 
 module.exports = new AttackObjectsRepository(AttackObject);

app/services/attack-objects-service.js

@@ -1,28 +1,16 @@
 'use strict';
 
-const { NotImplementedError} = require('../exceptions');
-const AttackObject = require('../models/attack-object-model');
+const { NotImplementedError } = require('../exceptions');
 const Relationship = require('../models/relationship-model');
-const AttackObjectsRepository = require('../repository/attack-objects-repository');
+const attackObjectsRepository = require('../repository/attack-objects-repository');
 const BaseService = require('./_base.service');
 
 class AttackObjectsService extends BaseService {
 
     systemConfigurationService = require('./system-configuration-service');
 
-    errors = {
-        missingParameter: 'Missing required parameter',
-        badlyFormattedParameter: 'Badly formatted parameter',
-        duplicateId: 'Duplicate id',
-        notFound: 'Document not found',
-        invalidQueryStringParameter: 'Invalid query string parameter',
-        duplicateCollection: 'Duplicate collection'
-    };
-
     relationshipPrefix = 'relationship';
 
-    identitiesService;
-
     retrieveById(stixId, options, callback) {
         throw new NotImplementedError(this.constructor.name, 'retrieveById');
     }
@@ -31,24 +19,27 @@ class AttackObjectsService extends BaseService {
         throw new NotImplementedError(this.constructor.name, 'create');
     }
 
-    async retrieveAll(options) {
-        const res = await this.repository.retrieveAll(options);
-        return res;
+    updateFull(stixId, stixModified, data, callback) {
+        throw new NotImplementedError(this.constructor.name, 'updateFull');
     }
 
-    async retrieveVersionById(stixId, modified) {
-        const res = await this.repository.retrieveVersionById(stixId, modified);
-        return res;
+    deleteVersionById(stixId, stixModified, callback) {
+        throw new NotImplementedError(this.constructor.name, 'deleteVersionById');
+    }
+
+    deleteById(stixId, callback) {
+        throw new NotImplementedError(this.constructor.name, 'deleteById');
     }
 
     // Record that this object is part of a collection
     async insertCollection(stixId, modified, collectionId, collectionModified) {
         let attackObject;
         if (stixId.startsWith(this.relationshipPrefix)) {
+            // TBD: Use relationships service when that is converted to async
             attackObject = await Relationship.findOne({ 'stix.id': stixId, 'stix.modified': modified });
         }
         else {
-            attackObject = await AttackObject.findOne({ 'stix.id': stixId, 'stix.modified': modified });
+            attackObject = await this.repository.retrieveOneByVersion(stixId, modified);
         }
 
         if (attackObject) {
@@ -91,4 +82,5 @@ class AttackObjectsService extends BaseService {
         }
     }
 }
-module.exports = new AttackObjectsService(null, AttackObjectsRepository);
+
+module.exports = new AttackObjectsService(null, attackObjectsRepository);