@dhyasama/totem-models 12.3.0 → 12.4.0

package/lib/List.js

@@ -61,7 +61,7 @@ module.exports = function(mongoose, config) {
 
   });
 
-  List.statics.addItem = function(listId, itemId, collection, options, cb) {
+  List.statics.addItem = async function(listId, itemId, collection, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!listId) { return cb(new Error('listId is required'), null); }
@@ -73,23 +73,26 @@ module.exports = function(mongoose, config) {
     if (!options.CUSTOMER_ID) { return cb(new Error('options.CUSTOMER_ID is required'), null); }
     if (!mongoose.Types.ObjectId.isValid(options.CUSTOMER_ID)) { return cb(new Error('options.CUSTOMER_ID is not a valid ObjectId'), null); }
 
-    const self = this;
-    let query = self.findOne({
+    let query = this.findOne({
       '_id': listId,
       'customer': options.CUSTOMER_ID
     });
 
-    query.exec().then(function(result) {if (!result) { return cb(null, null); }
+    try {
+      const result = await query;
+      if (!result) { return cb(null, null); }
 
       result[collection].push(itemId);
 
-      result.save().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
-
-    }).catch(function(err) { cb(err); });
+      const saved = await result.save();
+      return cb(null, saved);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  List.statics.createList = function(name, items, creator, options, cb) {
+  List.statics.createList = async function(name, items, creator, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!name) { return cb(new Error('name is required'), null); }
@@ -99,9 +102,7 @@ module.exports = function(mongoose, config) {
     if (!options.CUSTOMER_ID) { return cb(new Error('options.CUSTOMER_ID is required'), null); }
     if (!mongoose.Types.ObjectId.isValid(options.CUSTOMER_ID)) { return cb(new Error('options.CUSTOMER_ID is not a valid ObjectId'), null); }
 
-    const self = this;
-
-    let list = new self();
+    let list = new this();
     list.customer = options.CUSTOMER_ID;
     list.name = name;
     list.createdOn = new Date();
@@ -113,11 +114,16 @@ module.exports = function(mongoose, config) {
     // enforce unique customer/name tuple
     list.key = list.customer + '-' + list.name.split(' ').join('-');
 
-    list.save().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await list.save();
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  List.statics.getById = function (id, options, cb) {
+  List.statics.getById = async function (id, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!id) { return cb(new Error('name is required'), null); }
@@ -126,9 +132,7 @@ module.exports = function(mongoose, config) {
     if (!options.CUSTOMER_ID) { return cb(new Error('options.CUSTOMER_ID is required'), null); }
     if (!mongoose.Types.ObjectId.isValid(options.CUSTOMER_ID)) { return cb(new Error('options.CUSTOMER_ID is not a valid ObjectId'), null); }
 
-    const self = this;
-
-    let query = self.findOne({
+    let query = this.findOne({
         '_id': id,
         'customer': options.CUSTOMER_ID
       });
@@ -138,30 +142,38 @@ module.exports = function(mongoose, config) {
     query.populate('organizations', 'name logoUrl contact');
     query.populate('people', 'name title avatarUrl contact');
 
-    query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await query;
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  List.statics.getLists = function(options, cb) {
+  List.statics.getLists = async function(options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!options) { return cb(new Error('options is required'), null); }
     if (!options.CUSTOMER_ID) { return cb(new Error('options.CUSTOMER_ID is required'), null); }
     if (!mongoose.Types.ObjectId.isValid(options.CUSTOMER_ID)) { return cb(new Error('options.CUSTOMER_ID is not a valid ObjectId'), null); }
 
-    const self = this;
-
-    let query = self.find({ 'customer': options.CUSTOMER_ID });
+    let query = this.find({ 'customer': options.CUSTOMER_ID });
 
     query.populate('limitedPartners', 'name logoUrl');
     query.populate('organizations', 'name logoUrl');
     query.populate('people', 'name title avatarUrl');
 
-    query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await query;
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  List.statics.modifyById = function(id, update, cb) {
+  List.statics.modifyById = async function(id, update, cb) {
 
     // VERY IMPORTANT NOTE
     // findByIdAndUpdate and findOneAndUpdate do not trigger pre-save hook so that code will not run here
@@ -170,16 +182,19 @@ module.exports = function(mongoose, config) {
     if (!id) { return cb(new Error('id is required'), null); }
     if (!update) { return cb(new Error('update is required'), null); }
 
-    let self = this;
-
     // options runValidators defaults false which is ok since we have upsert false
     // new returns the updated document
 
-    self.findByIdAndUpdate(id, update, { upsert: false, new: true }).then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.findByIdAndUpdate(id, update, { upsert: false, new: true });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  List.statics.remove = function(id, options, cb) {
+  List.statics.remove = async function(id, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!id) { return cb(new Error('name is required'), null); }
@@ -188,16 +203,19 @@ module.exports = function(mongoose, config) {
     if (!options.CUSTOMER_ID) { return cb(new Error('options.CUSTOMER_ID is required'), null); }
     if (!mongoose.Types.ObjectId.isValid(options.CUSTOMER_ID)) { return cb(new Error('options.CUSTOMER_ID is not a valid ObjectId'), null); }
 
-    const self = this;
-
-    self.findOneAndDelete({
-      '_id': id,
-      'customer': options.CUSTOMER_ID
-    }).then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.findOneAndDelete({
+        '_id': id,
+        'customer': options.CUSTOMER_ID
+      });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  List.statics.removeItem = function(listId, itemId, collection, options, cb) {
+  List.statics.removeItem = async function(listId, itemId, collection, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!listId) { return cb(new Error('listId is required'), null); }
@@ -209,20 +227,28 @@ module.exports = function(mongoose, config) {
     if (!options.CUSTOMER_ID) { return cb(new Error('options.CUSTOMER_ID is required'), null); }
     if (!mongoose.Types.ObjectId.isValid(options.CUSTOMER_ID)) { return cb(new Error('options.CUSTOMER_ID is not a valid ObjectId'), null); }
 
-    const self = this;
-
     let update = {};
     update[collection] = itemId;
 
-    self.findOneAndUpdate({
-      '_id': listId,
-      'customer': options.CUSTOMER_ID
-    }, { $pull: update }, { new: true }).then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.findOneAndUpdate({
+        '_id': listId,
+        'customer': options.CUSTOMER_ID
+      }, { $pull: update }, { new: true });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  List.statics.upsert = function (list, cb) {
-    list.save().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+  List.statics.upsert = async function (list, cb) {
+    try {
+      const result = await list.save();
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
   };
 
   List.pre('save', function(next) {

package/lib/Meeting.js

@@ -9,7 +9,7 @@ module.exports = function(mongoose, config) {
   let moment = require('moment');
 
   var Meeting = new Schema({
-    
+
     customer: { type: Schema.ObjectId, ref: 'Organization', index: true, required: true },
 
     provider: { type: String, index: false, required: true },
@@ -31,11 +31,11 @@ module.exports = function(mongoose, config) {
     updatedOn: { type: Date, index: false, required: true },
 
     raw: { type: String, index: false, required: true },
-    
+
     people: [{ type: Schema.ObjectId, ref: 'Person', index: true }],
 
     notes: { type: String, trim: true },
-    
+
     analysis: {
       summary: { type: String },
       sentences: [{
@@ -56,9 +56,7 @@ module.exports = function(mongoose, config) {
     try { return JSON.parse(this.raw); } catch (e) { return null; }
   });
 
-  Meeting.statics.getById = function (id, options, cb) {
-
-    const self = this;
+  Meeting.statics.getById = async function (id, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!id) { return cb(new Error('id is required'), null); }
@@ -67,15 +65,19 @@ module.exports = function(mongoose, config) {
     if (!options.CUSTOMER_ID) { return cb(new Error('options.CUSTOMER_ID is required'), null); }
     if (!mongoose.Types.ObjectId.isValid(options.CUSTOMER_ID)) { return cb(new Error('options.CUSTOMER_ID is not a valid ObjectId'), null); }
 
-    let query = self.findOne({ '_id': id, customer: options.CUSTOMER_ID });
+    let query = this.findOne({ '_id': id, customer: options.CUSTOMER_ID });
     if (options.populate === true) { query.populate({ path: 'people', select: 'name title avatarUrl doNotDisplay' }); }
-    query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
 
-  };
+    try {
+      const result = await query;
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
-  Meeting.statics.getByEventId = function (eventId, options, cb) {
+  };
 
-    const self = this;
+  Meeting.statics.getByEventId = async function (eventId, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!eventId) { return cb(new Error('eventId is required'), null); }
@@ -83,15 +85,19 @@ module.exports = function(mongoose, config) {
     if (!options.CUSTOMER_ID) { return cb(new Error('options.CUSTOMER_ID is required'), null); }
     if (!mongoose.Types.ObjectId.isValid(options.CUSTOMER_ID)) { return cb(new Error('options.CUSTOMER_ID is not a valid ObjectId'), null); }
 
-    let query = self.find({ 'eventId': eventId, customer: options.CUSTOMER_ID });
+    let query = this.find({ 'eventId': eventId, customer: options.CUSTOMER_ID });
     if (options.populate === true) { query.populate({ path: 'people', select: 'name title avatarUrl doNotDisplay' }); }
-    query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
 
-  };
+    try {
+      const result = await query;
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
-  Meeting.statics.getByUniqueId = function (uniqueId, options, cb) {
+  };
 
-    const self = this;
+  Meeting.statics.getByUniqueId = async function (uniqueId, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!uniqueId) { return cb(new Error('uniqueId is required'), null); }
@@ -99,15 +105,19 @@ module.exports = function(mongoose, config) {
     if (!options.CUSTOMER_ID) { return cb(new Error('options.CUSTOMER_ID is required'), null); }
     if (!mongoose.Types.ObjectId.isValid(options.CUSTOMER_ID)) { return cb(new Error('options.CUSTOMER_ID is not a valid ObjectId'), null); }
 
-    let query = self.findOne({ 'uniqueId': uniqueId, customer: options.CUSTOMER_ID });
+    let query = this.findOne({ 'uniqueId': uniqueId, customer: options.CUSTOMER_ID });
     if (options.populate === true) { query.populate({ path: 'people', select: 'name title avatarUrl doNotDisplay' }); }
-    query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
 
-  };
+    try {
+      const result = await query;
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
-  Meeting.statics.search = function (options, cb) {
+  };
 
-    const self = this;
+  Meeting.statics.search = async function (options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!options) { return cb(new Error('options is required'), null); }
@@ -119,7 +129,7 @@ module.exports = function(mongoose, config) {
     options.before = options.before || moment().toISOString();
     options.after = options.after || moment().subtract(20, 'year').toISOString();
 
-    let query = self.find({ customer: options.CUSTOMER_ID });
+    let query = this.find({ customer: options.CUSTOMER_ID });
 
     if (options && Array.isArray(options.personIds) && options.personIds.length > 0) {
       query.where({ 'people': { $in: options.personIds } });
@@ -132,13 +142,17 @@ module.exports = function(mongoose, config) {
     if (options.limit >= 0) { query.limit(options.limit); }
 
     if (options.populate === true) { query.populate({ path: 'people', select: 'name title avatarUrl doNotDisplay' }); }
-    query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
 
-  };
+    try {
+      const result = await query;
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
-  Meeting.statics.delete = function(meetingId, options, cb) {
+  };
 
-    const self = this;
+  Meeting.statics.delete = async function(meetingId, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!meetingId) { return cb(new Error('meetingId is required'), null); }
@@ -147,19 +161,28 @@ module.exports = function(mongoose, config) {
     if (!options.CUSTOMER_ID) { return cb(new Error('options.CUSTOMER_ID is required'), null); }
     if (!mongoose.Types.ObjectId.isValid(options.CUSTOMER_ID)) { return cb(new Error('options.CUSTOMER_ID is not a valid ObjectId'), null); }
 
-    let query = self.findOne({ _id: meetingId, customer: options.CUSTOMER_ID });
-    query.exec().then(function(meeting) {
+    try {
+      let query = this.findOne({ _id: meetingId, customer: options.CUSTOMER_ID });
+      const meeting = await query;
       if (!meeting) { return cb(null, null); }
-      meeting.deleteOne().then(function() { cb(null, meeting); }).catch(function(err) { cb(err); });
-    }).catch(function(err) { cb(err); });
+      await meeting.deleteOne();
+      return cb(null, meeting);
+    } catch(err) {
+      return cb(err);
+    }
   };
 
-  Meeting.statics.upsert = function(meeting, cb) {
+  Meeting.statics.upsert = async function(meeting, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!meeting) { return cb(new Error('Meeting is required'), null); }
 
-    meeting.save().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await meeting.save();
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
   Meeting.set('autoIndex', false);
@@ -171,4 +194,4 @@ module.exports = function(mongoose, config) {
 
   mongoose.model('Meeting', Meeting);
 
-};
+};