@dhyasama/totem-models 12.3.0 → 12.4.0

package/lib/Deal.js

@@ -79,7 +79,7 @@ module.exports = function(mongoose, config) {
 
     const self = this;
     return _.find(self.documents, function(document) { return document.type == 'deck'; })
-    
+
   });
 
   Deal.virtual('added').get(function () {
@@ -113,9 +113,7 @@ module.exports = function(mongoose, config) {
   // Statics operate on the entire collection
   //////////////////////////////////////////////////////
 
-  Deal.statics.delete = function(id, options, cb) {
-
-    let self = this;
+  Deal.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); }
@@ -124,26 +122,27 @@ 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); }
 
-    // Not strictly necessary but provides verification that the document being deleted belongs to the customer doing the deleting
-    let query = self.findOne({
-      '_id': id,
-      'customer': options.CUSTOMER_ID
-    });
+    try {
+      // Not strictly necessary but provides verification that the document being deleted belongs to the customer doing the deleting
+      let query = this.findOne({
+        '_id': id,
+        'customer': options.CUSTOMER_ID
+      });
 
-    query.exec().then(function(deal) {
+      const deal = await query;
       if (!deal) return cb(null, null);
 
       // No population so no need to scrub
 
-      deal.deleteOne().then(function() { cb(null, deal); }).catch(function(err) { cb(err); });
-
-    }).catch(function(err) { cb(err); });
+      await deal.deleteOne();
+      return cb(null, deal);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Deal.statics.getById = function (id, options, cb) {
-
-    let self = this;
+  Deal.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); }
@@ -152,22 +151,25 @@ 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
-    });
+    try {
+      let query = this.findOne({
+        '_id': id,
+        'customer': options.CUSTOMER_ID
+      });
 
-    query.populate({ path: 'documents', match: { customer: options.CUSTOMER_ID } });
-    query.populate({ path: 'messages', match: { customer: options.CUSTOMER_ID } });
-    query.populate('organization', 'name aliases description logoUrl website websiteAliases chairs contact social crunchbase pitchbook foundedOn operating shutdown');
-    query.populate('referrer.person', 'name avatarUrl title');
-    query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+      query.populate({ path: 'documents', match: { customer: options.CUSTOMER_ID } });
+      query.populate({ path: 'messages', match: { customer: options.CUSTOMER_ID } });
+      query.populate('organization', 'name aliases description logoUrl website websiteAliases chairs contact social crunchbase pitchbook foundedOn operating shutdown');
+      query.populate('referrer.person', 'name avatarUrl title');
+      const result = await query;
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Deal.statics.getByIds = function (ids, options, cb) {
-
-    let self = this;
+  Deal.statics.getByIds = async function (ids, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!ids) { return cb(new Error('ids is required'), null); }
@@ -175,290 +177,295 @@ 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({
-      customer: options.CUSTOMER_ID,
-      '_id': { $in : ids }
-    });
+    try {
+      let query = this.find({
+        customer: options.CUSTOMER_ID,
+        '_id': { $in : ids }
+      });
 
-    query.populate({ path: 'documents', match: { customer: options.CUSTOMER_ID } });
-    query.populate({ path: 'messages', match: { customer: options.CUSTOMER_ID } });
-    query.populate('organization', 'name aliases description logoUrl website websiteAliases chairs contact');
-    query.populate('referrer.person', 'name avatarUrl title');
-    query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+      query.populate({ path: 'documents', match: { customer: options.CUSTOMER_ID } });
+      query.populate({ path: 'messages', match: { customer: options.CUSTOMER_ID } });
+      query.populate('organization', 'name aliases description logoUrl website websiteAliases chairs contact');
+      query.populate('referrer.person', 'name avatarUrl title');
+      const result = await query;
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
   // Get all deals belonging to a customer
-  Deal.statics.getForCustomer = function (customerId, options, cb) {
-
-    let self = this;
+  Deal.statics.getForCustomer = async function (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); }
 
-    options = options || {};
+    try {
+      options = options || {};
 
-    let terms = { 'customer': customerId };
-    if (options.stages) { terms['stage'] = { $in: options.stages }; }
-    if (options.added) {
-      if(options.added.lte && options.added.gte) terms['history.0.timestamp'] = { $lte: options.added.lte, $gte: options.added.gte };
-      else if(options.added.lte) terms['history.0.timestamp'] = { $lte: options.added.lte };
-      else if(options.added.gte) terms['history.0.timestamp'] = { $gte: options.added.gte };
-    }
-    if (options.updated) {
-      if(options.updated.lte && options.updated.gte) terms['history'] = { $elemMatch: { timestamp: { $lte: options.updated.lte, $gte: options.updated.gte } } };
-      else if(options.updated.lte) terms['history'] = { $elemMatch: { timestamp: { $lte: options.updated.lte } } };
-      else if(options.updated.gte) terms['history'] = { $elemMatch: { timestamp: { $gte: options.updated.gte } } };
-    };
+      let terms = { 'customer': customerId };
+      if (options.stages) { terms['stage'] = { $in: options.stages }; }
+      if (options.added) {
+        if(options.added.lte && options.added.gte) terms['history.0.timestamp'] = { $lte: options.added.lte, $gte: options.added.gte };
+        else if(options.added.lte) terms['history.0.timestamp'] = { $lte: options.added.lte };
+        else if(options.added.gte) terms['history.0.timestamp'] = { $gte: options.added.gte };
+      }
+      if (options.updated) {
+        if(options.updated.lte && options.updated.gte) terms['history'] = { $elemMatch: { timestamp: { $lte: options.updated.lte, $gte: options.updated.gte } } };
+        else if(options.updated.lte) terms['history'] = { $elemMatch: { timestamp: { $lte: options.updated.lte } } };
+        else if(options.updated.gte) terms['history'] = { $elemMatch: { timestamp: { $gte: options.updated.gte } } };
+      };
 
-    let query = self.find(terms);
+      let query = this.find(terms);
 
-    if (options.populate) {
-      query.populate({ path: 'documents', match: { customer: options.CUSTOMER_ID } });
-      query.populate({ path: 'messages', match: { customer: options.CUSTOMER_ID }, select: '-raw' });
-      query.populate('organization', 'name aliases description logoUrl website websiteAliases chairs contact people');
-      query.populate('referrer.person', 'name avatarUrl title');
-      query.populate('latestInteraction');
-      query.populate('latestMessage');
-    }
+      if (options.populate) {
+        query.populate({ path: 'documents', match: { customer: options.CUSTOMER_ID } });
+        query.populate({ path: 'messages', match: { customer: options.CUSTOMER_ID }, select: '-raw' });
+        query.populate('organization', 'name aliases description logoUrl website websiteAliases chairs contact people');
+        query.populate('referrer.person', 'name avatarUrl title');
+        query.populate('latestInteraction');
+        query.populate('latestMessage');
+      }
 
-    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);
+    }
 
   };
 
-  Deal.statics.getForCustomer2 = function (customerId, updatedSince, cb) {
-
-    const self = this;
+  Deal.statics.getForCustomer2 = async function (customerId, updatedSince, 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); }
 
-    let query = self.find({
-      customer: customerId,
-      lastUpdated: { $gte: updatedSince }
-    });
+    try {
+      let query = this.find({
+        customer: customerId,
+        lastUpdated: { $gte: updatedSince }
+      });
 
-    query.populate({ path: 'documents', match: { customer: customerId } });
-    query.populate({ path: 'messages', match: { customer: customerId }, select: '-raw' });
-    query.populate('organization', 'name aliases description logoUrl website websiteAliases chairs contact people');
-    query.populate('referrer.person', 'name avatarUrl title');
-    query.populate('latestInteraction');
-    query.populate('latestMessage');
+      query.populate({ path: 'documents', match: { customer: customerId } });
+      query.populate({ path: 'messages', match: { customer: customerId }, select: '-raw' });
+      query.populate('organization', 'name aliases description logoUrl website websiteAliases chairs contact people');
+      query.populate('referrer.person', 'name avatarUrl title');
+      query.populate('latestInteraction');
+      query.populate('latestMessage');
 
-    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);
+    }
 
   };
 
-  Deal.statics.getForCustomer3 = function (customerId, options, cb) {
-
-    let self = this;
+  Deal.statics.getForCustomer3 = async function (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); }
 
-    options = options || {};
-
-    //let terms = { 'customer': customerId };
-    //if (options.stages) { terms['stage'] = { $in: options.stages }; }
-    // if (options.added) {
-    //   if(options.added.lte && options.added.gte) terms['history.0.timestamp'] = { $lte: options.added.lte, $gte: options.added.gte };
-    //   else if(options.added.lte) terms['history.0.timestamp'] = { $lte: options.added.lte };
-    //   else if(options.added.gte) terms['history.0.timestamp'] = { $gte: options.added.gte };
-    // }
-    // if (options.updated) {
-    //   if(options.updated.lte && options.updated.gte) terms['history'] = { $elemMatch: { timestamp: { $lte: options.updated.lte, $gte: options.updated.gte } } };
-    //   else if(options.updated.lte) terms['history'] = { $elemMatch: { timestamp: { $lte: options.updated.lte } } };
-    //   else if(options.updated.gte) terms['history'] = { $elemMatch: { timestamp: { $gte: options.updated.gte } } };
-    // };
-
-    let matchTerms = { 'customer': new mongoose.Types.ObjectId(customerId) };
-    if (options.stages) { matchTerms['stage'] = { $in: options.stages }; }
-    if (options.added) {
-      if(options.added.lte && options.added.gte) matchTerms['lastUpdated'] = { $lte: new Date(options.added.lte), $gte: new Date(options.added.gte) };
-      else if(options.added.lte) matchTerms['lastUpdated'] = { $lte: new Date(options.added.lte) };
-      else if(options.added.gte) matchTerms['lastUpdated'] = { $gte: new Date(options.added.gte) };
-    }
-    if (options.updated) {
-      if(options.updated.lte && options.updated.gte) matchTerms['lastUpdated'] = { $lte: new Date(options.updated.lte), $gte: new Date(options.updated.gte) };
-      else if(options.updated.lte) matchTerms['lastUpdated'] = { $lte: new Date(options.updated.lte) };
-      else if(options.updated.gte) matchTerms['lastUpdated'] = { $gte: new Date(options.updated.gte) };
-    };
+    try {
+      options = options || {};
+
+      //let terms = { 'customer': customerId };
+      //if (options.stages) { terms['stage'] = { $in: options.stages }; }
+      // if (options.added) {
+      //   if(options.added.lte && options.added.gte) terms['history.0.timestamp'] = { $lte: options.added.lte, $gte: options.added.gte };
+      //   else if(options.added.lte) terms['history.0.timestamp'] = { $lte: options.added.lte };
+      //   else if(options.added.gte) terms['history.0.timestamp'] = { $gte: options.added.gte };
+      // }
+      // if (options.updated) {
+      //   if(options.updated.lte && options.updated.gte) terms['history'] = { $elemMatch: { timestamp: { $lte: options.updated.lte, $gte: options.updated.gte } } };
+      //   else if(options.updated.lte) terms['history'] = { $elemMatch: { timestamp: { $lte: options.updated.lte } } };
+      //   else if(options.updated.gte) terms['history'] = { $elemMatch: { timestamp: { $gte: options.updated.gte } } };
+      // };
+
+      let matchTerms = { 'customer': new mongoose.Types.ObjectId(customerId) };
+      if (options.stages) { matchTerms['stage'] = { $in: options.stages }; }
+      if (options.added) {
+        if(options.added.lte && options.added.gte) matchTerms['lastUpdated'] = { $lte: new Date(options.added.lte), $gte: new Date(options.added.gte) };
+        else if(options.added.lte) matchTerms['lastUpdated'] = { $lte: new Date(options.added.lte) };
+        else if(options.added.gte) matchTerms['lastUpdated'] = { $gte: new Date(options.added.gte) };
+      }
+      if (options.updated) {
+        if(options.updated.lte && options.updated.gte) matchTerms['lastUpdated'] = { $lte: new Date(options.updated.lte), $gte: new Date(options.updated.gte) };
+        else if(options.updated.lte) matchTerms['lastUpdated'] = { $lte: new Date(options.updated.lte) };
+        else if(options.updated.gte) matchTerms['lastUpdated'] = { $gte: new Date(options.updated.gte) };
+      };
 
-    let pipeline = [
+      let pipeline = [
 
-      // start by getting deals for the requested customer
-      {
-        $match: matchTerms
+        // start by getting deals for the requested customer
+        {
+          $match: matchTerms
+          // {
+          //   customer: mongoose.Types.ObjectId(customerId),
+          //   stage: {
+          //     $in: options.stages
+          //   },
+          //   lastUpdated: { $gte: new Date(options.updated.gte) }
+          //   //history: { $elemMatch: { timestamp: { $gte: ISODate('2023-02-14T00:00:00.000Z') } } }
+          // }
+        },
+
+        // get the orgs the deals are for
+        {
+          $lookup:
+            {
+              from: "organizations",
+              localField: "organization",
+              foreignField: "_id",
+              as: "organization"
+            }
+        },
         // {
-        //   customer: mongoose.Types.ObjectId(customerId),
-        //   stage: {
-        //     $in: options.stages
-        //   },
-        //   lastUpdated: { $gte: new Date(options.updated.gte) }
-        //   //history: { $elemMatch: { timestamp: { $gte: ISODate('2023-02-14T00:00:00.000Z') } } }
-        // }
-      },
-
-      // get the orgs the deals are for
-      {
-        $lookup:
-          {
-            from: "organizations",
-            localField: "organization",
-            foreignField: "_id",
-            as: "organization"
-          }
-      },
-      // {
-      //   $unwind: {
-      //     path: "$organization",
-      //     preserveNullAndEmptyArrays: true
-      //   }
-      // },
-
-      // get the referrer
-      {
-        $lookup:
-          {
-            from: "people",
-            let: { referrerPersonId: "$referrer.person" },
-            pipeline: [
-              {
-                $match: {
-                  $expr: {
-                    $eq: ["$_id", "$$referrerPersonId"]
+        //   $unwind: {
+        //     path: "$organization",
+        //     preserveNullAndEmptyArrays: true
+        //   }
+        // },
+
+        // get the referrer
+        {
+          $lookup:
+            {
+              from: "people",
+              let: { referrerPersonId: "$referrer.person" },
+              pipeline: [
+                {
+                  $match: {
+                    $expr: {
+                      $eq: ["$_id", "$$referrerPersonId"]
+                    }
+                  }
+                },
+                {
+                  $project: {
+                    name: 1,
+                    avatarUrl: 1,
+                    title: 1
                   }
                 }
-              },
-              {
-                $project: {
-                  name: 1,
-                  avatarUrl: 1,
-                  title: 1
-                }
-              }
-            ],
-            as: "referrerPerson"
-          }
-      },
+              ],
+              as: "referrerPerson"
+            }
+        },
 
-      // get documents
-      {
-        $lookup:
-          {
-            from: "documents",
-            let: { docIds: { $ifNull: ["$documents", []] } },
-            pipeline: [
-              {
-                $match: {
-                  $expr: {
-                    $in: ["$_id", "$$docIds"]
+        // get documents
+        {
+          $lookup:
+            {
+              from: "documents",
+              let: { docIds: { $ifNull: ["$documents", []] } },
+              pipeline: [
+                {
+                  $match: {
+                    $expr: {
+                      $in: ["$_id", "$$docIds"]
+                    }
+                  }
+                },
+                {
+                  $project: {
+                    name: 1,
+                    type: 1,
+                    contentType: 1,
+                    s3: 1,
+                    createdOn: 1,
+                    createdBy: 1,
+                    customer: 1
                   }
                 }
-              },
-              {
-                $project: {
-                  name: 1,
-                  type: 1,
-                  contentType: 1,
-                  s3: 1,
-                  createdOn: 1,
-                  createdBy: 1,
-                  customer: 1
-                }
-              }
-            ],
-            as: "documents"
-          }
-      },
+              ],
+              as: "documents"
+            }
+        },
 
-      // get messages
-      {
-        $lookup:
-          {
-            from: "messages",
-            let: { messageIds: { $ifNull: ["$messages", []] } },
-            pipeline: [
-              {
-                $match: {
-                  $expr: {
-                    $in: ["$_id", "$$messageIds"]
+        // get messages
+        {
+          $lookup:
+            {
+              from: "messages",
+              let: { messageIds: { $ifNull: ["$messages", []] } },
+              pipeline: [
+                {
+                  $match: {
+                    $expr: {
+                      $in: ["$_id", "$$messageIds"]
+                    }
                   }
                 }
-              }
-            ],
-            as: "messages"
-          }
-      },
+              ],
+              as: "messages"
+            }
+        },
 
-      // keep the lightweight latest-message payload for callers that use it
-      {
-        $lookup:
-          {
-            from: "messages",
-            let: { latestMessageId: "$latestMessage" },
-            pipeline: [
-              {
-                $match: {
-                  $expr: {
-                    $eq: ["$_id", "$$latestMessageId"]
+        // keep the lightweight latest-message payload for callers that use it
+        {
+          $lookup:
+            {
+              from: "messages",
+              let: { latestMessageId: "$latestMessage" },
+              pipeline: [
+                {
+                  $match: {
+                    $expr: {
+                      $eq: ["$_id", "$$latestMessageId"]
+                    }
+                  }
+                },
+                {
+                  $project: {
+                    subject: 1,
+                    originalMessageDate: 1,
+                    createdOn: 1,
+                    messageDate: 1
                   }
                 }
-              },
-              {
-                $project: {
-                  subject: 1,
-                  originalMessageDate: 1,
-                  createdOn: 1,
-                  messageDate: 1
-                }
-              }
-            ],
-            as: "latestMessage"
-          }
-      }
-
-    ];
-
-    mongoose.connection.db.collection('deals').aggregate(pipeline, { allowDiskUse: true }).toArray()
-      .then(function(results) {
+              ],
+              as: "latestMessage"
+            }
+        }
 
-        results = Array.isArray(results) ? results : [];
+      ];
 
-        _.each(results, function(result) {
+      let results = await mongoose.connection.db.collection('deals').aggregate(pipeline, { allowDiskUse: true }).toArray();
 
-          if (!result) { return; }
+      results = Array.isArray(results) ? results : [];
 
-          result.organization = Array.isArray(result.organization) && result.organization.length ? result.organization[0] : null;
-          result.documents = Array.isArray(result.documents) ? result.documents : [];
-          result.messages = Array.isArray(result.messages) ? result.messages : [];
-          result.latestMessage = Array.isArray(result.latestMessage) && result.latestMessage.length ? result.latestMessage[0] : null;
-          result.referrer = result.referrer || {};
-          result.referrer.person = Array.isArray(result.referrerPerson) && result.referrerPerson.length ? result.referrerPerson[0] : null;
+      _.each(results, function(result) {
 
-          if (result.referrer.person && result.referrer.person.name) {
-            result.referrer.person.name.full = ((result.referrer.person.name.first || '') + ' ' + (result.referrer.person.name.last || '')).trim();
-          }
+        if (!result) { return; }
 
-          delete result.referrerPerson;
+        result.organization = Array.isArray(result.organization) && result.organization.length ? result.organization[0] : null;
+        result.documents = Array.isArray(result.documents) ? result.documents : [];
+        result.messages = Array.isArray(result.messages) ? result.messages : [];
+        result.latestMessage = Array.isArray(result.latestMessage) && result.latestMessage.length ? result.latestMessage[0] : null;
+        result.referrer = result.referrer || {};
+        result.referrer.person = Array.isArray(result.referrerPerson) && result.referrerPerson.length ? result.referrerPerson[0] : null;
 
-        });
+        if (result.referrer.person && result.referrer.person.name) {
+          result.referrer.person.name.full = ((result.referrer.person.name.first || '') + ' ' + (result.referrer.person.name.last || '')).trim();
+        }
 
-        return cb(null, results);
+        delete result.referrerPerson;
 
-      })
-      .catch(function(err) {
-        return cb(err, null);
       });
 
-  }
+      return cb(null, results);
+    } catch(err) {
+      return cb(err, null);
+    }
 
-  Deal.statics.getByReferrer = function (personId, options, cb) {
+  }
 
-    let self = this;
+  Deal.statics.getByReferrer = async function (personId, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!personId) { return cb(new Error('personId is required'), null); }
@@ -467,21 +474,24 @@ 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({
-      'referrer.person': personId,
-      'customer': options.CUSTOMER_ID
-    });
+    try {
+      let query = this.find({
+        'referrer.person': personId,
+        'customer': options.CUSTOMER_ID
+      });
 
-    query.populate({ path: 'documents', match: { customer: options.CUSTOMER_ID } });
-    query.populate({ path: 'messages', match: { customer: options.CUSTOMER_ID } });
-    query.populate('organization', 'name aliases description logoUrl website websiteAliases');
-    query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+      query.populate({ path: 'documents', match: { customer: options.CUSTOMER_ID } });
+      query.populate({ path: 'messages', match: { customer: options.CUSTOMER_ID } });
+      query.populate('organization', 'name aliases description logoUrl website websiteAliases');
+      const result = await query;
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Deal.statics.getByApplication = function (application, options, cb) {
-
-    let self = this;
+  Deal.statics.getByApplication = async function (application, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!application) { return cb(new Error('application is required'), null); }
@@ -489,20 +499,23 @@ 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({
-      'applications.application': application,
-      'customer': options.CUSTOMER_ID
-    });
+    try {
+      let query = this.find({
+        'applications.application': application,
+        'customer': options.CUSTOMER_ID
+      });
 
-    query.populate('organization', 'name description');
-    query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+      query.populate('organization', 'name description');
+      const result = await query;
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
   // Get a deal for a org, belonging to current customer
-  Deal.statics.getForOrg = function (orgId, options, cb) {
-
-    const self = this;
+  Deal.statics.getForOrg = async function (orgId, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!orgId) { return cb(new Error('orgId is required'), null); }
@@ -511,42 +524,48 @@ 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({
-      'organization': orgId,
-      'customer': options.CUSTOMER_ID
-    });
+    try {
+      let query = this.findOne({
+        'organization': orgId,
+        'customer': options.CUSTOMER_ID
+      });
 
-    query.populate({ path: 'documents', match: { customer: options.CUSTOMER_ID } });
-    query.populate({ path: 'messages', match: { customer: options.CUSTOMER_ID } });
-    query.populate('organization', 'name aliases logoUrl website websiteAliases');
-    query.populate('referrer.person', 'name avatarUrl title');
-    query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+      query.populate({ path: 'documents', match: { customer: options.CUSTOMER_ID } });
+      query.populate({ path: 'messages', match: { customer: options.CUSTOMER_ID } });
+      query.populate('organization', 'name aliases logoUrl website websiteAliases');
+      query.populate('referrer.person', 'name avatarUrl title');
+      const result = await query;
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Deal.statics.getOrgsForCustomer = function (customerId, options, cb) {
-
-    let self = this;
+  Deal.statics.getOrgsForCustomer = async function (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); }
 
-    options = options || {};
+    try {
+      options = options || {};
 
-    let query = self.find({ 'customer': customerId });
-    query.select('organization');
-    query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+      let query = this.find({ 'customer': customerId });
+      query.select('organization');
+      const result = await query;
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Deal.statics.modifyById = function(id, update, options, cb) {
+  Deal.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
 
-    let self = this;
-
     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); }
@@ -555,15 +574,20 @@ 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); }
 
-    // https://mongoosejs.com/docs/api.html#model_Model.findOneAndUpdate
-    // options runValidators defaults false which is ok since we have upsert false
-    // new returns the updated document
+    try {
+      // https://mongoosejs.com/docs/api.html#model_Model.findOneAndUpdate
+      // 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
+      // No population so no need to scrub
 
-    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);
+    }
 
   };
 
@@ -575,30 +599,33 @@ module.exports = function(mongoose, config) {
 
     // The upsert piece is unusually complicated for an update query but it is necessary in order to have an atomic transaction
 
-    const self = this;
-
     // Remove this user's vote for this deal
-    const removePollItem = function(id, path, voterid, callback) {
+    const removePollItem = async function(id, path, voterid, callback) {
 
       // Dynamic custom field name requires building object this way, rather than { 'customField.' + key: value }
       let pull = {};
       pull[path] = { voter: voterid };
 
-      const query = self.updateOne(
-        {
-          '_id': id,
-          customer: customerId
-        },
-        { $pull: pull },
-        { upsert: false, new: true }
-      );
-
-      query.exec().then(function(result) { callback(null, result); }).catch(function(err) { callback(err); });
+      try {
+        const query = this.updateOne(
+          {
+            '_id': id,
+            customer: customerId
+          },
+          { $pull: pull },
+          { upsert: false, new: true }
+        );
+
+        const result = await query;
+        return callback(null, result);
+      } catch(err) {
+        return callback(err);
+      }
 
-    }
+    }.bind(this);
 
     // Add or update this user's vote for this deal
-    const upsertPollItem = function(id, path, voterid, vote, callback) {
+    const upsertPollItem = async function(id, path, voterid, vote, callback) {
 
       const pollItem = {
         voter: voterid,
@@ -650,21 +677,26 @@ module.exports = function(mongoose, config) {
         }
       };
 
-      const query =  self.updateOne(
-        {
-          '_id': id,
-          customer: customerId
-        },
-        [
-          { $addFields: addFields },
-          { $set: set }
-        ], // must be part of aggregation pipeline for conditions to work
-        { upsert: false, new: true }
-      );
-
-      query.exec().then(function(result) { callback(null, result); }).catch(function(err) { callback(err); });
+      try {
+        const query = this.updateOne(
+          {
+            '_id': id,
+            customer: customerId
+          },
+          [
+            { $addFields: addFields },
+            { $set: set }
+          ], // must be part of aggregation pipeline for conditions to work
+          { upsert: false, new: true }
+        );
+
+        const result = await query;
+        return callback(null, result);
+      } catch(err) {
+        return callback(err);
+      }
 
-    }
+    }.bind(this);
 
     // Save the action in the deal's history
     // todo - I can't figure a way to do it in a single transaction, so bonus points to anyone that can...
@@ -672,7 +704,7 @@ module.exports = function(mongoose, config) {
     //  update requires aggregation pipeline but doesn't recognize $push stage
     //  removing aggregation allows $push to work, but the $cond update doesn't
     //  commence spinning in circles...
-    const saveHistory = function(err, result) {
+    const saveHistory = async function(err, result) {
 
       if (err) return cb(err);
 
@@ -689,18 +721,23 @@ module.exports = function(mongoose, config) {
         description: 'The deal details were updated'
       };
 
-      const query = self.updateOne(
-        {
-          '_id': id,
-          customer: customerId
-        },
-        { $push: { history: historyItem } },
-        { upsert: false, new: true }
-      );
-
-      query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+      try {
+        const query = this.updateOne(
+          {
+            '_id': id,
+            customer: customerId
+          },
+          { $push: { history: historyItem } },
+          { upsert: false, new: true }
+        );
+
+        const result = await query;
+        return cb(null, result);
+      } catch(err) {
+        return cb(err);
+      }
 
-    }
+    }.bind(this);
 
     if (!cb) { throw new Error('cb is required'); }
     if (!id) { return cb(new Error('id is required'), null); }
@@ -719,9 +756,7 @@ module.exports = function(mongoose, config) {
 
   };
 
-  Deal.statics.modifyProperty = function modifyProperty(id, key, value, customerId, options, cb) {
-
-    const self = this;
+  Deal.statics.modifyProperty = async function modifyProperty(id, key, value, customerId, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!id) { return cb(new Error('id is required'), null); }
@@ -730,33 +765,38 @@ 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 keyValue = {};
-    keyValue[key] = value;
+    try {
+      let keyValue = {};
+      keyValue[key] = value;
 
-    const historyItem = {
-      timestamp: new Date(),
-      account: options.account,
-      stage: null,
-      description: 'The deal details were updated'
-    };
+      const historyItem = {
+        timestamp: new Date(),
+        account: options.account,
+        stage: null,
+        description: 'The deal details were updated'
+      };
 
-    const update = {
-      $set: keyValue,
-      $push: { history: historyItem }
-    };
+      const update = {
+        $set: keyValue,
+        $push: { history: historyItem }
+      };
 
-    const match = {
-      _id: id,
-      customer: customerId
-    };
+      const match = {
+        _id: id,
+        customer: customerId
+      };
 
-    const query = self.updateOne(match, update, { upsert: false, new: true });
+      const query = this.updateOne(match, update, { upsert: false, new: true });
 
-    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);
+    }
 
   };
 
-  Deal.statics.upsert = function upsert(deal, options, cb) {
+  Deal.statics.upsert = async function upsert(deal, options, cb) {
 
     // Deal is dumb and doesn't validate customer stages or duplicate deals. That responsibility is with the org.
 
@@ -831,11 +871,16 @@ module.exports = function(mongoose, config) {
 
     // Required for mixed types
     deal.markModified('customFields');
-    
-    deal.save().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+
+    try {
+      const result = await deal.save();
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
-  
+
   ///////////////////////////////////////////////////////////////////////////////////////
   // CONFIG
   ///////////////////////////////////////////////////////////////////////////////////////