@dhyasama/totem-models 12.3.0 → 12.4.0

package/lib/DiffbotArticle.js

@@ -23,9 +23,7 @@ module.exports = function(mongoose, config) {
 
     });
 
-  DiffbotArticle.statics.getByOrgId = function getByOrgId(id, options, cb) {
-
-    const self = this;
+  DiffbotArticle.statics.getByOrgId = async function getByOrgId(id, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!id) { return cb(new Error('ids is required'), null); }
@@ -33,16 +31,16 @@ module.exports = function(mongoose, config) {
 
     options = helpers.getDefaultOptions(options);
 
-    self
-      .find({ org: id })
-      .populate('org')
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.find({ org: id }).populate('org');
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  DiffbotArticle.statics.getByOrgIdSkinny = function getByOrgIdSkinny(id, options, cb) {
-
-    const self = this;
+  DiffbotArticle.statics.getByOrgIdSkinny = async function getByOrgIdSkinny(id, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!id) { return cb(new Error('ids is required'), null); }
@@ -50,16 +48,24 @@ module.exports = function(mongoose, config) {
 
     options = helpers.getDefaultOptions(options);
 
-    self
-      .find({ org: id })
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.find({ org: id });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  DiffbotArticle.statics.upsert = function (doc, cb) {
+  DiffbotArticle.statics.upsert = async function (doc, cb) {
     doc.updatedOn = new Date();
     doc.markModified('entity');
-    doc.save().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await doc.save();
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
   };
   DiffbotArticle.set('autoIndex', true);
   DiffbotArticle.on('index', function(err) { console.log('error building DiffbotArticle indexes: ' + err); });

package/lib/DiffbotOrganization.js

@@ -22,9 +22,7 @@ module.exports = function(mongoose, config) {
 
     });
 
-  DiffbotOrganization.statics.getByOrgId = function getByOrgId(id, options, cb) {
-
-    const self = this;
+  DiffbotOrganization.statics.getByOrgId = async function getByOrgId(id, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!id) { return cb(new Error('ids is required'), null); }
@@ -32,16 +30,16 @@ module.exports = function(mongoose, config) {
 
     options = helpers.getDefaultOptions(options);
 
-    self
-      .findOne({ org: id })
-      .populate('org')
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.findOne({ org: id }).populate('org');
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  DiffbotOrganization.statics.getByOrgIdSkinny = function getByOrgIdSkinny(id, options, cb) {
-
-    const self = this;
+  DiffbotOrganization.statics.getByOrgIdSkinny = async function getByOrgIdSkinny(id, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!id) { return cb(new Error('ids is required'), null); }
@@ -49,16 +47,24 @@ module.exports = function(mongoose, config) {
 
     options = helpers.getDefaultOptions(options);
 
-    self
-      .findOne({ org: id })
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.findOne({ org: id });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  DiffbotOrganization.statics.upsert = function (doc, cb) {
+  DiffbotOrganization.statics.upsert = async function (doc, cb) {
     doc.updatedOn = new Date();
     doc.markModified('entity');
-    doc.save().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await doc.save();
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
   };
   DiffbotOrganization.set('autoIndex', false);
   DiffbotOrganization.on('index', function(err) { console.log('error building DiffbotOrganization indexes: ' + err); });

package/lib/Document.js

@@ -111,31 +111,26 @@ module.exports = function(mongoose, config) {
   // Statics operate on the entire collection
   //////////////////////////////////////////////////////
 
-  Document.statics.createForModel = function(doc, Model, modelId, cb) {
+  Document.statics.createForModel = async function(doc, Model, modelId, cb) {
 
     // No population so no need to scrub
 
-    var addToModel = function(err, createdDoc) {
-      if (err) return cb(err, null);
-      Model.findByIdAndUpdate(modelId, { $push: { documents: createdDoc }}, { new: true, upsert: false }).then(function(addedTo) {
-        return cb(null, {
-          document: createdDoc,
-          addedTo: addedTo
-        });
-      }).catch(function(err) {
-        return cb(err);
-      });
-    };
-
     doc.createdOn = new Date();
 
-    this.create(doc).then(function(created) { addToModel(null, created); }).catch(function(err) { addToModel(err); });
+    try {
+      const createdDoc = await this.create(doc);
+      const addedTo = await Model.findByIdAndUpdate(modelId, { $push: { documents: createdDoc }}, { new: true, upsert: false });
+      return cb(null, {
+        document: createdDoc,
+        addedTo: addedTo
+      });
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Document.statics.delete = function(id, options, cb) {
-
-    let self = this;
+  Document.statics.delete = async function(id, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!id) { return cb(new Error('id is required'), null); }
@@ -146,25 +141,26 @@ module.exports = function(mongoose, config) {
 
     // Not strictly necessary but provides verification that the document being deleted belongs to the customer doing the deleting
 
-    let query = self.findOne({
+    let query = this.findOne({
       '_id': id,
       'customer': options.CUSTOMER_ID
     });
 
-    query.exec().then(function(doc) {
+    try {
+      const doc = await query;
       if (!doc) return cb(null, null);
 
       // No population so no need to scrub
 
-      doc.deleteOne().then(function() { cb(null, doc); }).catch(function(err) { cb(err); });
-
-    }).catch(function(err) { cb(err); });
+      await doc.deleteOne();
+      return cb(null, doc);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Document.statics.getById = function (id, options, cb) {
-
-    let self = this;
+  Document.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); }
@@ -177,36 +173,43 @@ module.exports = function(mongoose, config) {
     }
 
     let queryOptions = { '_id': id };
-    
+
     if (!options.isWorkerProcess) {
       queryOptions.customer = options.CUSTOMER_ID;
     }
 
     let query = this.findOne(queryOptions);
-    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);
+    }
 
-  Document.statics.findByS3Info = function (bucket, key, cb) {
+  };
 
-    let self = this;
+  Document.statics.findByS3Info = async function (bucket, key, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!bucket) { return cb(new Error('bucket is required'), null); }
     if (!key) { return cb(new Error('key is required'), null); }
 
-    let query = self.findOne({
+    let query = this.findOne({
       's3.bucket': bucket,
       's3.key': key
     });
 
-    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);
+    }
 
   };
 
-  Document.statics.modifyById2 = function(id, update, options, cb) {
-
-    let self = this;
+  Document.statics.modifyById2 = async function(id, update, options, cb) {
 
     // VERY IMPORTANT NOTE
     // findByIdAndUpdate and findOneAndUpdate do not trigger pre-save hook so that code will not run here
@@ -221,17 +224,20 @@ module.exports = function(mongoose, config) {
     // options runValidators defaults false which is ok since we have upsert false
     // new returns the updated document
 
-    let query = self.findOneAndUpdate({ _id: id }, update, { upsert: false, new: true });
+    let query = this.findOneAndUpdate({ _id: id }, update, { upsert: false, new: true });
 
     // No population so no need to scrub
 
-    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);
+    }
 
   };
 
-  Document.statics.modifyById = function(id, update, options, cb) {
-
-    let self = this;
+  Document.statics.modifyById = async function(id, update, options, cb) {
 
     // VERY IMPORTANT NOTE
     // findByIdAndUpdate and findOneAndUpdate do not trigger pre-save hook so that code will not run here
@@ -248,21 +254,31 @@ module.exports = function(mongoose, config) {
     // options runValidators defaults false which is ok since we have upsert false
     // new returns the updated document
 
-    let query = self.findOneAndUpdate({ _id: id, customer: options.CUSTOMER_ID }, update, { upsert: false, new: true });
+    let query = this.findOneAndUpdate({ _id: id, customer: options.CUSTOMER_ID }, update, { upsert: false, new: true });
 
     // No population so no need to scrub
 
-    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);
+    }
 
   };
 
-  Document.statics.upsert = function upsert(doc, cb) {
+  Document.statics.upsert = async function upsert(doc, cb) {
 
     if (!doc) { return cb(new Error('doc is required'), null); }
 
     // No population so no need to scrub
 
-    doc.save().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await doc.save();
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 

package/lib/Event.js

@@ -42,15 +42,18 @@ module.exports = function(mongoose, config) {
     foreignField: 'Event'
   });
 
-  Event.statics.delete = function (id, options, cb) {
-
-    const self = this;
+  Event.statics.delete = async function (id, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!id) { return cb(new Error('id is required'), null); }
     if (!mongoose.Types.ObjectId.isValid(id)) { return cb(new Error('id is not a valid ObjectId'), null); }
 
-    self.findByIdAndDelete(id).then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.findByIdAndDelete(id);
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
@@ -58,9 +61,7 @@ module.exports = function(mongoose, config) {
   // Double check customer id
   // Always populates attendees
   // Optionally populate customer
-  Event.statics.getById = function (id, customerId, options, cb) {
-
-    const self = this;
+  Event.statics.getById = async function (id, customerId, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!id) { return cb(new Error('id is required'), null); }
@@ -68,7 +69,7 @@ module.exports = function(mongoose, config) {
     if (!customerId) { return cb(new Error('customerId is required'), null); }
     if (!mongoose.Types.ObjectId.isValid(customerId)) { return cb(new Error('customerId is not a valid ObjectId'), null); }
 
-    let query = self.findOne({
+    let query = this.findOne({
       '_id': id,
       'customer': customerId
     });
@@ -77,7 +78,12 @@ module.exports = function(mongoose, config) {
 
     query.populate('Attendees');
 
-    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);
+    }
 
   };
 
@@ -85,16 +91,14 @@ module.exports = function(mongoose, config) {
   // Double check customer id
   // Always populates attendees
   // Optionally populate customer
-  Event.statics.getByProviderEventId = function (id, customerId, options, cb) {
-
-    const self = this;
+  Event.statics.getByProviderEventId = async function (id, customerId, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!id) { return cb(new Error('id is required'), null); }
     if (!customerId) { return cb(new Error('customerId is required'), null); }
     if (!mongoose.Types.ObjectId.isValid(customerId)) { return cb(new Error('customerId is not a valid ObjectId'), null); }
 
-    let query = self.findOne({
+    let query = this.findOne({
       'EventId': id,
       'customer': customerId
     });
@@ -103,40 +107,53 @@ module.exports = function(mongoose, config) {
 
     query.populate('Attendees');
 
-    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);
+    }
 
   };
 
   // Get all events a customer has held
   // Always populate attendees
   // Optionally populate customer
-  Event.statics.list = function(customerId, options, cb) {
-
-    const self = this;
+  Event.statics.list = async function(customerId, options, cb) {
 
     if (!cb) throw new Error('callback is required');
     if (!options) options = {};
     if (!customerId) throw new Error('customerId is required');
     if (!mongoose.Types.ObjectId.isValid(customerId)) { return cb(new Error('customerId is not a valid ObjectId'), null); }
 
-    let query = self.find({ customer: customerId });
+    let query = this.find({ customer: customerId });
 
     if (options.populate) { query.populate('customer'); }
 
     query.populate('Attendees');
 
-    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);
+    }
 
   };
 
   // Create or update an event
-  Event.statics.upsert = function(event, options, cb) {
+  Event.statics.upsert = async function(event, options, cb) {
 
     if (!cb) throw new Error('cb is required');
     if (!event) throw new Error('event is required');
     if (!options) { return cb(new Error('options is required'), null); }
 
-    event.save().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await event.save();
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
   Event.set('autoIndex', false);

package/lib/EventAttendee.js

@@ -37,16 +37,19 @@ module.exports = function(mongoose, config) {
   });
 
   // Delete an attendee of an event
-  EventAttendee.statics.delete = function (eventId, email, options, cb) {
-
-    const self = this;
+  EventAttendee.statics.delete = async function (eventId, email, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!eventId) { return cb(new Error('eventId is required'), null); }
     if (!mongoose.Types.ObjectId.isValid(eventId)) { return cb(new Error('eventId is not a valid ObjectId'), null); }
     if (!email) { return cb(new Error('email is required'), null); }
 
-    self.findOneAndDelete({ Event: eventId, Email: email }).then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.findOneAndDelete({ Event: eventId, Email: email });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
@@ -62,9 +65,7 @@ module.exports = function(mongoose, config) {
 
   // Get all the events an attendee attended (that belong to the specified customer)
   // Email can be a single email or an array of emails
-  EventAttendee.statics.listAllEventsForAttendee = function (email, customerId, options, cb) {
-
-    const self = this;
+  EventAttendee.statics.listAllEventsForAttendee = async function (email, customerId, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!email) { return cb(new Error('email is required'), null); }
@@ -76,7 +77,7 @@ module.exports = function(mongoose, config) {
     if (Array.isArray(email)) { params = { Email: { $in : email }}; }
     else { params = { Email: email }; }
 
-    let query = self.find(params);
+    let query = this.find(params);
 
     // Get customer id so we can filter by it
     query.populate({
@@ -84,21 +85,22 @@ module.exports = function(mongoose, config) {
       match: { customer: customerId },
     });
 
-    query.exec().then(function(result) {// Reject anything that didn't match on customer id
+    try {
+      let result = await query;
+      // Reject anything that didn't match on customer id
       result = _.reject(result, function(r) {
         return !r.Event || !r.Event.customer;
       });
 
       return cb(null, result);
-
-    }).catch(function(err) { cb(err); });
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
   // Update status for an attendee of an event
-  EventAttendee.statics.setGuestListStatus = function(eventId, email, status, options, cb) {
-
-    const self = this;
+  EventAttendee.statics.setGuestListStatus = async function(eventId, email, status, options, cb) {
 
     if (!cb) throw new Error('cb is required');
     if (!eventId) throw new Error('eventId is required');
@@ -117,17 +119,27 @@ module.exports = function(mongoose, config) {
       }
     };
 
-    self.findOneAndUpdate(conditions, update, { upsert: false, new: true }).then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.findOneAndUpdate(conditions, update, { upsert: false, new: true });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
   // Update an attendee of an event
-  EventAttendee.statics.upsert = function(eventAttendee, options, cb) {
+  EventAttendee.statics.upsert = async function(eventAttendee, options, cb) {
 
     if (!cb) throw new Error('cb is required');
     if (!eventAttendee) throw new Error('eventAttendee is required');
 
-    eventAttendee.save().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await eventAttendee.save();
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
   EventAttendee.set('autoIndex', false);