bundle (set of section entries) api

index.js

@@ -7,6 +7,7 @@ var match = require('./lib/match');
 var section = require('./lib/section');
 var entry = require('./lib/entry');
 var allsections = require('./lib/allsections');
+var bundle = require('./lib/bundle');
 var modelutil = require('./lib/modelutil');
 
 var account_history = require('./lib/history');
@@ -167,6 +168,24 @@ exports.patientKeyToId = function (secName, ptKey, callback) {
     entry.patientKeyToId(dbinfo, secName, ptKey, callback);
 };
 
+// bundle
+
+exports.saveBundle = function (secName, ptKey, bundleElements, bundleData, sourceId, callback) {
+    bundle.save(dbinfo, ptKey, bundleElements, bundleData, sourceId, callback);
+};
+
+exports.replaceBundle = function (secName, ptKey, id, bundleElements, bundleData, sourceId, callback) {
+    bundle.update(dbinfo, secName, ptKey, id, bundleElements, bundleData, sourceId, callback);
+};
+
+exports.removeBundle = function (secName, ptKey, id, callback) {
+    bundle.remove(dbinfo, secName, ptKey, id, callback);
+};
+
+exports.getMultiBundle = function (secName, queryObject, callback) {
+    bundle.getMulti(dbinfo, secName, queryObject, callback);
+};
+
 // utility
 
 exports.cleanSection = function (input) {

lib/bundle.js

@@ -0,0 +1,95 @@
+'use strict';
+
+var mongoose = require('mongoose');
+var _ = require('lodash');
+
+exports.save = function (dbinfo, secName, ptKey, bundleElements, bundleData, sourceId, callback) {
+    bundleElements = _.cloneDeep(bundleElements);
+    bundleData = _.cloneDeep(bundleData);
+    var model = dbinfo.bundleModels[secName]({
+        pat_key: ptKey,
+        entry_type: secName,
+        elements: bundleElements,
+        data: bundleData,
+        archieved: false
+    });
+    model.save(function (err, result) {
+        if (err) {
+            callback(err);
+        } else {
+            callback(null, result._id.toString());
+        }
+    });
+};
+
+exports.replace = function (dbinfo, secName, ptKey, id, bundleElements, bundleData, sourceId, callback) {
+    if (typeof id === 'string') {
+        id = mongoose.Types.ObjectId(id);
+    }
+    bundleElements = _.cloneDeep(bundleElements);
+    bundleData = _.cloneDeep(bundleData);
+
+    var model = dbinfo.bundleModels[secName];
+    var queryObject = {
+        '_id': id,
+        pat_key: ptKey
+    };
+    var query = model.findOne(queryObject);
+    query.where('archived').in([null, false]);
+    query.exec(function (err, bundle) {
+        if (err || !bundle) {
+            err ? callback(err) : callback(new Error('no bundle found.'));
+        } else {
+            if (bundleElements) {
+                bundle.elements = bundleElements;
+            }
+            if (bundleData) {
+                bundle.data = bundleData;
+            }
+            bundle.save(callback);
+        }
+    });
+};
+
+exports.remove = function (dbinfo, secName, ptKey, id, callback) {
+    if (typeof id === 'string') {
+        id = mongoose.Types.ObjectId(id);
+    }
+    var model = dbinfo.bundleModels[secName];
+    var query = model.update({
+        _id: id
+    }, {
+        archived: true
+    });
+    query.exec(callback);
+};
+
+exports.getMulti = function (dbinfo, secName, queryObject, callback) {
+    var model = dbinfo.bundleModels[secName];
+    queryObject = queryObject || {};
+
+    if (queryObject._id && (typeof queryObject._id === 'string')) {
+        queryObject._id = mongoose.Types.ObjectId(queryObject._id);
+    }
+
+    var query = model.find(queryObject);
+    query.where('archived').in([null, false]);
+
+    query.exec(function (err, results) {
+        if (err) {
+            callback(err);
+        } else {
+            var cleanedResults = results.map(function (result) {
+                var r = {
+                    _id: result._id.toString(),
+                    elements: result.elements.map(function(e) {
+                        return e.toString();
+                    }),
+                    data: result.data
+                }
+                 return r;
+            });
+            callback(null, cleanedResults);
+        }
+    });
+};

lib/db.js

@@ -73,6 +73,9 @@ exports.connect = function connectDatabase(server, inputOptions, callback) {
 
                 callback(null, dbinfo);
             }
+            if (options.bundle_sections) {
+                dbinfo.bundleModels = models.bundleModels(c, options.bundle_sections);
+            }
         }
     });
 };

lib/models.js

@@ -59,6 +59,23 @@ exports.notesModel = function (connection) {
 
 };
 
+exports.bundleModels = function (connection, sectionsBundles) {
+    var result = {};
+    sectionsBundles.forEach(function (secName) {
+        var bundleSchema = new Schema({
+            pat_key: String,
+            entry_type: String,
+            elements: [ObjectId],
+            data: {},
+            archived: Boolean
+        });
+
+        var name = secName + 'Bundle';
+        result[secName] = connection.model(name, bundleSchema);
+    });
+    return result;
+};
+
 exports.models = function (connection, supportedSections) {
     var result = {
         merge: {},

test/unit/test-fhir-support.js

@@ -6,25 +6,30 @@ var async = require('async');
 var refmodel = require('./refmodel');
 var section = require('../../lib/section');
 var entry = require('../../lib/entry');
+var bundle = require('../../lib/bundle');
 
 var expect = chai.expect;
 chai.config.includeStack = true;
 
 describe('fhir support', function () {
     var context = {}; // populated by refmodel common methods
 
-    refmodel.prepareConnection('fhirsupport', context)();
+    refmodel.prepareConnection({
+        dbName: 'fhirsupport',
+        bundle_sections: ['testprocedures']
+
+    }, context)();
 
     it('add sources', function (done) {
-        refmodel.addSourcesPerPatient(context, [1, 1], done);
+        refmodel.addSourcesPerPatient(context, [2, 1], done);
     });
 
     it('save sections for patient 0', function (done) {
-        refmodel.saveAllSections('pat0', '0.0', [4, 4], context, done);
+        refmodel.saveAllSections('pat0', '0.0', [4, 6], context, done);
     });
 
     it('save sections for patient 1', function (done) {
-        refmodel.saveAllSections('pat1', '1.0', [4, 4], context, done);
+        refmodel.saveAllSections('pat1', '1.0', [4, 6], context, done);
     });
 
     var patientIds = [null, null];
@@ -63,6 +68,24 @@ describe('fhir support', function () {
         });
     });
 
+    var procedures = {};
+
+    it('section.getMulti testprocedures', function (done) {
+        var expectedPat0 = refmodel.createTestSection('testprocedures', '0.0', 6);
+        var expectedPat1 = refmodel.createTestSection('testprocedures', '1.0', 6);
+        var expected = expectedPat0.concat(expectedPat1);
+        section.getMulti(context.dbinfo, 'testprocedures', {}, function (err, result) {
+            result.forEach(function (entry) {
+                var id = entry._id.toString();
+                procedures[id] = entry;
+                delete entry._id;
+            });
+            expect(expected).to.deep.include.members(result);
+            expect(result).to.deep.include.members(expected);
+            done();
+        });
+    });
+
     it('entry.idToPatientKey (pat0)', function (done) {
         entry.idToPatientKey(context.dbinfo, 'testdemographics', patientIds[0], function (err, ptKey) {
             if (err) {
@@ -107,6 +130,131 @@ describe('fhir support', function () {
         });
     });
 
+    var bundles;
+
+    it('create bundle data', function() {
+        bundles = Object.keys(procedures).reduce(function(r, id) {
+            expect(typeof id).to.equal('string');
+            var name = procedures[id].name;
+            if (name.substring(0, 8) === 'name_0.0') {
+                var index = parseInt(name.charAt(9), 10);
+                var bundleIndex = index % 2;
+                r[bundleIndex].push(id);
+            }
+            return r;
+        }, [[], []]);
+
+        expect(bundles[0]).to.have.length(3);
+        expect(bundles[1]).to.have.length(3)
+    });
+
+    var bundleExpected = {};
+    var bundleIds = [];
+
+    it('bundle.save (bundle 0)', function(done) {
+        var bundleData = {
+            name: 'name_0.0.0'
+        };
+        bundle.save(context.dbinfo, 'testprocedures', 'pat0', bundles[0], bundleData, null, function(err, id) {
+            if (err) {
+                done(err);
+            } else {
+                id = id.toString();
+                bundleExpected[id] = {
+                    _id: id,
+                    elements: bundles[0],
+                    data: bundleData
+                };
+                bundleIds.push(id);
+                done();
+            }
+        });
+    });
+
+    it('bundle.save (bundle 1)', function(done) {
+        var bundleData = {
+            name: 'name_1.0.0'
+        };
+        bundle.save(context.dbinfo, 'testprocedures', 'pat1', bundles[1], bundleData, null, function(err, id) {
+            if (err) {
+                done(err);
+            } else {
+                id = id.toString();
+                bundleExpected[id] = {
+                    _id: id,
+                    elements: bundles[1],
+                    data: bundleData
+                };
+                bundleIds.push(id);
+                done();
+            }
+        });
+    });
+
+    it('bundle.getMulti', function(done) {
+        bundle.getMulti(context.dbinfo, 'testprocedures', {}, function(err, result) {
+            if (err) {
+                done(err);
+            } else {
+                result.forEach(function(bundle) {
+                    var id = bundle._id;
+                    var expected = bundleExpected[id];
+                    expect(bundle).to.deep.equal(expected);
+                });
+                done();
+            }
+        });
+    });
+
+    it('bundle.replace', function(done) {
+        var bundleData = {
+            name: 'name_replaced'
+        };
+        bundles[0].splice(2, 1);
+        bundle.replace(context.dbinfo, 'testprocedures', 'pat0', bundleIds[0], bundles[0], bundleData, null, function(err) {
+            if (err) {
+                done(err);
+            } else {
+                bundleExpected[bundleIds[0]].data = bundleData;
+                done()
+            }
+        });
+    });
+
+    it('bundle.getMulti (after replace)', function(done) {
+        bundle.getMulti(context.dbinfo, 'testprocedures', {}, function(err, result) {
+            if (err) {
+                done(err);
+            } else {
+                result.forEach(function(bundle) {
+                    var id = bundle._id;
+                    var expected = bundleExpected[id];
+                    expect(bundle).to.deep.equal(expected);
+                });
+                done();
+            }
+        });
+    });
+
+    it('bundle.remove', function(done) {
+        bundle.remove(context.dbinfo, 'testprocedures', 'pat0', bundleIds[1], function(err) {
+            done(err);
+        });
+    });
+
+    it('bundle.getMulti (after remove)', function(done) {
+        bundle.getMulti(context.dbinfo, 'testprocedures', {}, function(err, result) {
+            if (err) {
+                done(err);
+            } else {
+                expect(result).to.have.length(1);
+                var expected = bundleExpected[bundleIds[0]];
+                expect(result[0]).to.deep.equal(expected);
+                done();
+            }
+        });
+    });
+
     after(function (done) {
         context.dbinfo.db.dropDatabase(function (err) {
             if (err) {