@dhyasama/totem-models 12.3.0 → 12.4.0

package/lib/Interaction.js

@@ -31,11 +31,11 @@ module.exports = function(mongoose, config) {
         end: { type: Number }
       }],
       notes: [{
-        title: { type: String }, 
+        title: { type: String },
         list: [{ type: String }]
       }],
       actions: [{
-        title: { type: String }, 
+        title: { type: String },
         list: [{ type: String }]
       }],
       insights: [{
@@ -51,25 +51,26 @@ module.exports = function(mongoose, config) {
 
   ///////////////////////////////////////
 
-  Interaction.statics.delete = function(providerEventId, totemCustomerId, cb) {
+  Interaction.statics.delete = async function(providerEventId, totemCustomerId, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!providerEventId) { return cb(new Error('providerEventId is required'), null); }
     if (!totemCustomerId) { return cb(new Error('totemCustomerId is required'), null); }
     if (!mongoose.Types.ObjectId.isValid(totemCustomerId)) { return cb(new Error('totemCustomerId is not a valid ObjectId'), null); }
 
-    var self = this;
-
-    self.findOneAndDelete({
-      'providerEventId': providerEventId,
-      'totemCustomerId': totemCustomerId
-    }).then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.findOneAndDelete({
+        'providerEventId': providerEventId,
+        'totemCustomerId': totemCustomerId
+      });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Interaction.statics.getById = function getById(id, options, cb) {
-
-    const self = this;
+  Interaction.statics.getById = async function getById(id, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!id) { return cb(new Error('id is required'), null); }
@@ -83,80 +84,92 @@ module.exports = function(mongoose, config) {
       if (!mongoose.Types.ObjectId.isValid(options.CUSTOMER_ID)) { return cb(new Error('options.CUSTOMER_ID is not a valid ObjectId'), null); }
     }
 
-    let query = self.findById(id);
-
-    query.populate('attendees.internal');
-    query.populate('attendees.external');
+    try {
+      let query = this.findById(id);
 
-    query.exec().then(function(result) {if (options.isWorkerProcess) { return cb(null, result); }
-      else { return cb(null, result); }
+      query.populate('attendees.internal');
+      query.populate('attendees.external');
 
-    }).catch(function(err) { cb(err); });
+      const result = await query;
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
 
-  Interaction.statics.getByCalendarEventId = function getByCalendarEventId(calendarEventId, cb) {
+  Interaction.statics.getByCalendarEventId = async function getByCalendarEventId(calendarEventId, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!calendarEventId) { return cb(new Error('calendarEventId is required'), null); }
 
-    var self = this;
-    var query = self.find({ calendarEventId: calendarEventId });
+    try {
+      let query = this.find({ calendarEventId: calendarEventId });
 
-    query.populate('attendees.internal');
-    query.populate('attendees.external');
+      query.populate('attendees.internal');
+      query.populate('attendees.external');
 
-    query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+      const result = await query;
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Interaction.statics.getBySummaryAndStartTime = function getBySummaryAndStartTime(summary, startTime, cb) {
-    
+  Interaction.statics.getBySummaryAndStartTime = async function getBySummaryAndStartTime(summary, startTime, cb) {
+
     if (!cb) { throw new Error('cb is required'); }
     if (!summary) { return cb(new Error('summary is required'), null); }
     if (!startTime) { return cb(new Error('startTime is required'), null); }
 
-    const self = this;
+    try {
+      // Query to match summary directly
+      const query = this.find({
+          $and: [
+              { startTime: new Date(startTime) },
+              { summary: { $regex: summary, $options: 'i' } } // Simple case-insensitive regex match
+          ]
+      });
 
-    // Query to match summary directly
-    const query = self.find({
-        $and: [
-            { startTime: new Date(startTime) },
-            { summary: { $regex: summary, $options: 'i' } } // Simple case-insensitive regex match
-        ]
-    });
+      // Populate attendees
+      query.populate('attendees.internal');
+      query.populate('attendees.external');
 
-    // Populate attendees
-    query.populate('attendees.internal');
-    query.populate('attendees.external');
+      // Execute the query
+      const result = await query;
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
-    // Execute the query
-    query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
-  
   };
 
-  Interaction.statics.getByProviderEventId = function getByProviderEventId(providerEventId, cb) {
-    
+  Interaction.statics.getByProviderEventId = async function getByProviderEventId(providerEventId, cb) {
+
     if (!cb) { throw new Error('cb is required'); }
     if (!providerEventId) { return cb(new Error('providerEventId is required'), null); }
 
-    const self = this;
+    try {
+      const query = this.find({
+         providerEventId: providerEventId
+      });
 
-    const query = self.find({
-       providerEventId: providerEventId
-    });
+      // Populate attendees
+      query.populate('attendees.internal');
+      query.populate('attendees.external');
 
-    // Populate attendees
-    query.populate('attendees.internal');
-    query.populate('attendees.external');
+      // Execute the query
+      const result = await query;
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
-    // Execute the query
-    query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
-  
   };
 
-  Interaction.statics.getForCustomer = function getForCustomer(customerId, since, cb) {
+  Interaction.statics.getForCustomer = async function getForCustomer(customerId, since, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!customerId) { return cb(new Error('customerId is required'), null); }
@@ -166,14 +179,18 @@ module.exports = function(mongoose, config) {
     var sinceObjectId = utilities.convertTimestampToObjectId(since);
     if (!mongoose.Types.ObjectId.isValid(sinceObjectId)) { return cb(new Error('sinceObjectId is not a valid ObjectId'), null); }
 
-    var self = this;
-    var query = self.find({ totemCustomerId: customerId, _id: { $gt: sinceObjectId } });
-    query.populate('attendees.external');
-    query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      let query = this.find({ totemCustomerId: customerId, _id: { $gt: sinceObjectId } });
+      query.populate('attendees.external');
+      const result = await query;
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Interaction.statics.getForCustomerSkinny = function getForCustomer(customerId, since, cb) {
+  Interaction.statics.getForCustomerSkinny = async function getForCustomer(customerId, since, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!customerId) { return cb(new Error('customerId is required'), null); }
@@ -184,13 +201,17 @@ module.exports = function(mongoose, config) {
     var sinceObjectId = utilities.convertTimestampToObjectId(since);
     if (!mongoose.Types.ObjectId.isValid(sinceObjectId)) { return cb(new Error('sinceObjectId is not a valid ObjectId'), null); }
 
-    var self = this;
-    var query = self.find({ totemCustomerId: customerId, _id: { $gt: sinceObjectId } });
-    query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      let query = this.find({ totemCustomerId: customerId, _id: { $gt: sinceObjectId } });
+      const result = await query;
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Interaction.statics.getForPeople = function getForPeople(personIds, options, cb) {
+  Interaction.statics.getForPeople = async function getForPeople(personIds, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!personIds) { return cb(new Error('personIds is required'), null); }
@@ -200,8 +221,6 @@ module.exports = function(mongoose, config) {
 
     // NOTE: This is not for global process workers. Use getForPeopleLite instead.
 
-    let self = this;
-
     options.limit = options.limit || -1;
     options.skip = options.skip || -1;
 
@@ -212,31 +231,34 @@ module.exports = function(mongoose, config) {
     options.before = options.before || moment().toISOString();
     options.after = options.after || moment().subtract(20, 'year').toISOString();
 
-    let query = self.find({ totemCustomerId: options.CUSTOMER_ID });
+    try {
+      let query = this.find({ totemCustomerId: options.CUSTOMER_ID });
 
-    query.where({ $or: [ { 'attendees.external': { $in: personIds } }, { 'attendees.internal': { $in: personIds } } ] });
-    query.where({ startTime: { $gte: options.after }});
-    query.where({ startTime: { $lte: options.before }});
+      query.where({ $or: [ { 'attendees.external': { $in: personIds } }, { 'attendees.internal': { $in: personIds } } ] });
+      query.where({ startTime: { $gte: options.after }});
+      query.where({ startTime: { $lte: options.before }});
 
-    query.populate('attendees.internal', 'name title avatarUrl doNotDisplay');
-    query.populate('attendees.external', 'name title avatarUrl doNotDisplay');
+      query.populate('attendees.internal', 'name title avatarUrl doNotDisplay');
+      query.populate('attendees.external', 'name title avatarUrl doNotDisplay');
 
-    query.sort(options.sort);
+      query.sort(options.sort);
 
-    if (options.attendee) { query.where({'attendees.internal': options.attendee}); }
-    if (options.limit >= 0) query.limit(options.limit);
-    if (options.skip >= 0) query.skip(options.skip);
+      if (options.attendee) { query.where({'attendees.internal': options.attendee}); }
+      if (options.limit >= 0) query.limit(options.limit);
+      if (options.skip >= 0) query.skip(options.skip);
 
-    query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+      const result = await query;
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Interaction.statics.getForPeopleLite = function getForPeopleLite(personIds, options, cb) {
+  Interaction.statics.getForPeopleLite = async function getForPeopleLite(personIds, options, cb) {
 
     // This doesn't filter by customer so is only usable by admin tools
 
-    let self = this;
-
     if (!cb) { throw new Error('cb is required'); }
     if (!personIds) { return cb(new Error('personIds is required'), null); }
     if (!options) { return cb(new Error('options is required'), null); }
@@ -245,56 +267,64 @@ module.exports = function(mongoose, config) {
 
     if (!options.isWorkerProcess) { return cb(null, []); }
 
-    let query = self.find({'attendees.external': { $in : personIds }});
-
-    query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      let query = this.find({'attendees.external': { $in : personIds }});
+      const result = await query;
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Interaction.statics.getForTimeline = function getForTimeline(customerId, options, cb) {
+  Interaction.statics.getForTimeline = async function getForTimeline(customerId, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     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); }
 
-    const self = this;
     const startDate = options.startDate ? moment(options.startDate).toDate() : moment().subtract(20, 'years').startOf('day').toDate();
     const endDate = options.endDate ? moment(options.endDate).toDate() : new Date();
 
-    self.aggregate([
-      {
-        $match: {
-          totemCustomerId: new mongoose.Types.ObjectId(customerId),
-          startTime: {
-            $gte: startDate,
-            $lte: endDate
+    try {
+      const result = await this.aggregate([
+        {
+          $match: {
+            totemCustomerId: new mongoose.Types.ObjectId(customerId),
+            startTime: {
+              $gte: startDate,
+              $lte: endDate
+            }
+          }
+        },
+        {
+          $sort: {
+            startTime: -1
+          }
+        },
+        {
+          $group: {
+            _id: "$providerEventId", // Group by providerEventId to deduplicate
+            doc: { $first: "$$ROOT" } // Take the first (latest) document encountered for each providerEventId after sorting
+          }
+        },
+        {
+          $replaceRoot: { newRoot: "$doc" } // Replace the root to output the original document structure
+        },
+        {
+          $sort: {
+            startTime: -1 // Final sort by startTime in descending order to order the output
           }
         }
-      },
-      {
-        $sort: {
-          startTime: -1
-        }
-      },
-      {
-        $group: {
-          _id: "$providerEventId", // Group by providerEventId to deduplicate
-          doc: { $first: "$$ROOT" } // Take the first (latest) document encountered for each providerEventId after sorting
-        }
-      },
-      {
-        $replaceRoot: { newRoot: "$doc" } // Replace the root to output the original document structure
-      },
-      {
-        $sort: {
-          startTime: -1 // Final sort by startTime in descending order to order the output
-        }
-      }
-    ]).exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+      ]);
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Interaction.statics.getMostRecent = function getMostRecent(customerId, personIds, cb) {
+  Interaction.statics.getMostRecent = async function getMostRecent(customerId, personIds, cb) {
 
     // Gets the most recent interaction with a customer across a list of people
     // Typically used to get the last interaction the firm had with an org
@@ -307,13 +337,12 @@ module.exports = function(mongoose, config) {
 
     // Note - This filters by customer so is NOT usable by admin tools
 
-    const self = this;
+    try {
+      let query = this.find({ totemCustomerId: customerId });
 
-    let query = self.find({ totemCustomerId: customerId });
+      query.where({ 'attendees.external': { $in : personIds } });
 
-    query.where({ 'attendees.external': { $in : personIds } });
-
-    query.exec().then(function(interactions) {
+      let interactions = await query;
       if (!interactions) {
         return cb(null, null);
       }
@@ -327,14 +356,15 @@ module.exports = function(mongoose, config) {
       });
 
       var interaction = _.last(interactions);
-      
-      return cb(null, interaction);
 
-    }).catch(function(err) { cb(err); });
+      return cb(null, interaction);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Interaction.statics.getMostRecent2 = function getMostRecent2(customerId, personIds, timestamp, cb) {
+  Interaction.statics.getMostRecent2 = async function getMostRecent2(customerId, personIds, timestamp, cb) {
 
     // Gets the most recent interaction with a customer across a list of people
     // Typically used to get the last interaction the firm had with an org
@@ -348,28 +378,31 @@ module.exports = function(mongoose, config) {
 
     // Note - This filters by customer so is NOT usable by admin tools
 
-    const self = this;
-
-    // only for this customer
-    let query = self.findOne({ totemCustomerId: customerId });
+    try {
+      // only for this customer
+      let query = this.findOne({ totemCustomerId: customerId });
 
-    // with these outside attendees
-    query.where({ 'attendees.external': { $in : personIds } });
+      // with these outside attendees
+      query.where({ 'attendees.external': { $in : personIds } });
 
-    // only events that have already happened
-    query.where({'startTime': { $lte: new Date() }});
+      // only events that have already happened
+      query.where({'startTime': { $lte: new Date() }});
 
-    // Optionally limit to events newer than timestamp (useful for seeing if anything since a previous event)
-    if (timestamp) query.where({'startTime': { $gt: timestamp }});
+      // Optionally limit to events newer than timestamp (useful for seeing if anything since a previous event)
+      if (timestamp) query.where({'startTime': { $gt: timestamp }});
 
-    query.sort({ 'startTime': -1 });
-    query.limit(1);
+      query.sort({ 'startTime': -1 });
+      query.limit(1);
 
-    query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+      const result = await query;
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Interaction.statics.modifyById = function(id, update, cb) {
+  Interaction.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
@@ -379,21 +412,29 @@ module.exports = function(mongoose, config) {
     if (!mongoose.Types.ObjectId.isValid(id)) { return cb(new Error('id is not a valid ObjectId'), null); }
     if (!update) { return cb(new Error('update is required'), null); }
 
-    var 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);
+    }
 
   };
 
-  Interaction.statics.upsert = function upsert(interaction, cb) {
+  Interaction.statics.upsert = async function upsert(interaction, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!interaction) { return cb(new Error('Interaction is required'), null); }
 
-    interaction.save().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await interaction.save();
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
   Interaction.set('autoIndex', false);

package/lib/Investment.js

@@ -62,90 +62,99 @@ module.exports = function(mongoose, config) {
   // Statics operate on the entire collection
   //////////////////////////////////////////////////////
 
-  Investment.statics.getOrgIds = function(options, cb) {
+  Investment.statics.getOrgIds = async function(options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!options) { return cb(new Error('options is required'), null); }
-    
+
     if (!options.isWorkerProcess) {
       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); }
     }
 
-    var self = this;
-    var query = self.find({ customer: options.CUSTOMER_ID });
+    try {
+      let query = this.find({ customer: options.CUSTOMER_ID });
 
-    if (options.startDate) {
-      var startDate = options.startDate || moment().subtract(20, 'years').startOf('day').toISOString();
-      query.where('date').gte(startDate);
-    }
+      if (options.startDate) {
+        var startDate = options.startDate || moment().subtract(20, 'years').startOf('day').toISOString();
+        query.where('date').gte(startDate);
+      }
 
-    if (options.endDate) {
-      var endDate = options.endDate || moment().toISOString();
-      query.where('date').lte(endDate);
-    }
+      if (options.endDate) {
+        var endDate = options.endDate || moment().toISOString();
+        query.where('date').lte(endDate);
+      }
 
-    query.exec().then(function(investments) {Round.find({
-        'vehicles.investments': { $in: _.map(investments, function(inv) { return inv._id; }) }
-      })
-      .exec().then(function(rounds) {var organizationIds = _.compact(_.map(investments, function(inv) {
-          var organization = null;
+      const investments = await query;
 
-          var round = _.find(rounds, function(r) {
-            return _.some(r.vehicles, function(v) {
-              var investmentFound = _.some(v.investments, function(investmentId) {
-                return investmentId.toString() === inv._id.toString();
-              });
+      const rounds = await Round.find({
+        'vehicles.investments': { $in: _.map(investments, function(inv) { return inv._id; }) }
+      });
 
-              if (investmentFound) {
-                organization = r.organization;
-              }
+      var organizationIds = _.compact(_.map(investments, function(inv) {
+        var organization = null;
 
-              return investmentFound;
+        var round = _.find(rounds, function(r) {
+          return _.some(r.vehicles, function(v) {
+            var investmentFound = _.some(v.investments, function(investmentId) {
+              return investmentId.toString() === inv._id.toString();
             });
+
+            if (investmentFound) {
+              organization = r.organization;
+            }
+
+            return investmentFound;
           });
+        });
+
+        return organization;
 
-          return organization;
-        
-        }));
+      }));
+
+      return cb(null, organizationIds);
+    } catch(err) {
+      return cb(err);
+    }
 
-        cb(null, organizationIds);
-      
-      }).catch(function(err) { cb(err); });
-    
-    }).catch(function(err) { cb(err); });
-    
   };
 
-  Investment.statics.removeCustomerInvestments = function removeCustomerInvestments(customerId, cb) {
+  Investment.statics.removeCustomerInvestments = async function removeCustomerInvestments(customerId, cb) {
 
     // Note that rounds hold references to investments, so when an investment is deleted we need
     // to also remove any references to it. Investment has a post-deleteOne hook which does that, but
     // post-deleteOne hooks only fire on document.deleteOne not query.deleteMany, hence the loop below
     // to call deleteOne on each matching investment.
 
-    let self = this;
+    try {
+      const investments = await this
+        .find({ customer: customerId })
+        .select('_id');
 
-    self
-      .find({ customer: customerId })
-      .select('_id')
-      .exec().then(function(investments) {async.each(investments, function(investment, callback) {
-          investment.deleteOne().then(function() { callback(null, investment); }).catch(function(err) { callback(err); });
-        }, function(err) {
-          return cb(err, null);
-        });
+      for (const investment of investments) {
+        await investment.deleteOne();
+      }
 
-      }).catch(function(err) { cb(err); });
+      return cb(null, null);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Investment.statics.upsert = function upsert(investment, cb) {
+  Investment.statics.upsert = async function upsert(investment, cb) {
 
     // Required for mixed types
     investment.markModified('details');
 
     if (!investment) { return cb(new Error('investment is required'), null); }
-    investment.save().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+
+    try {
+      const result = await investment.save();
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
@@ -181,4 +190,4 @@ module.exports = function(mongoose, config) {
 
   mongoose.model('Investment', Investment);
 
-};
+};