@dhyasama/totem-models 12.3.0 → 12.4.0

package/lib/CalendarEvent.js

@@ -52,103 +52,137 @@ module.exports = function(mongoose, config) {
     try { return JSON.parse(this.raw); } catch (e) { return null; }
   });
 
-  CalendarEvent.statics.delete = function(calendarEventId, cb) {
+  CalendarEvent.statics.delete = async function(calendarEventId, cb) {
 
-    var self = this;
-
-    self
-      .findByIdAndDelete(calendarEventId)
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.findByIdAndDelete(calendarEventId);
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  CalendarEvent.statics.findByAccountId = function (accountId, cb) {
-    this
-      .find({ account: accountId })
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+  CalendarEvent.statics.findByAccountId = async function (accountId, cb) {
+    try {
+      const result = await this.find({ account: accountId });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
   };
 
-  CalendarEvent.statics.findByCreatedRange = function (since, until, cb) {
-    this
-      .find({ createdOn: { $gt: since, $lt: until } })
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+  CalendarEvent.statics.findByCreatedRange = async function (since, until, cb) {
+    try {
+      const result = await this.find({ createdOn: { $gt: since, $lt: until } });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
   };
 
-  CalendarEvent.statics.findByCreatedSince = function (since, cb) {
-    this
-      .find({ createdOn: { $gt: since } })
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+  CalendarEvent.statics.findByCreatedSince = async function (since, cb) {
+    try {
+      const result = await this.find({ createdOn: { $gt: since } });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
   };
 
-  CalendarEvent.statics.findByEmail = function (email, cb) {
-    this
-      .find({ email: email })
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+  CalendarEvent.statics.findByEmail = async function (email, cb) {
+    try {
+      const result = await this.find({ email: email });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
   };
 
-  CalendarEvent.statics.findByEmailForRange = function (email, startsAfter, startsBefore, cb) {
+  CalendarEvent.statics.findByEmailForRange = async function (email, startsAfter, startsBefore, cb) {
 
-    var self = this;
-    var query = self.find({ email: email });
+    var query = this.find({ email: email });
     query.where({ start: { $gte: startsAfter, $lte: startsBefore }});
-    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);
+    }
 
   };
 
-  CalendarEvent.statics.findByEventId = function (eventId, cb) {
-    this
-      .findOne({ 'eventId': eventId })
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+  CalendarEvent.statics.findByEventId = async function (eventId, cb) {
+    try {
+      const result = await this.findOne({ 'eventId': eventId });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
   };
 
-  CalendarEvent.statics.findUnprocessedForAccount = function (id, cb) {
-    this
-      .find({ account: id, processed: false })
-      .populate('account', 'email customer')
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+  CalendarEvent.statics.findUnprocessedForAccount = async function (id, cb) {
+    try {
+      const result = await this.find({ account: id, processed: false }).populate('account', 'email customer');
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
   };
 
-  CalendarEvent.statics.findByUsername = function (username, cb) {
-    this
-      .find({ 'account.username': username })
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+  CalendarEvent.statics.findByUsername = async function (username, cb) {
+    try {
+      const result = await this.find({ 'account.username': username });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
   };
 
-  CalendarEvent.statics.getById = function (id, cb) {
-    this
-      .findOne({ '_id': id })
-      .populate('account', 'email customer')
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+  CalendarEvent.statics.getById = async function (id, cb) {
+    try {
+      const result = await this.findOne({ '_id': id }).populate('account', 'email customer');
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
   };
 
-  CalendarEvent.statics.getNewest = function (email, cb) {
-    this
-      .findOne({email: email})
-      .sort({createdOn: -1})
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+  CalendarEvent.statics.getNewest = async function (email, cb) {
+    try {
+      const result = await this.findOne({email: email}).sort({createdOn: -1});
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
   };
 
-  CalendarEvent.statics.getNewestProcessed = function (email, cb) {
-    this
-      .findOne({ email: email, processed: true })
-      .sort({ createdOn: -1 })
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+  CalendarEvent.statics.getNewestProcessed = async function (email, cb) {
+    try {
+      const result = await this.findOne({ email: email, processed: true }).sort({ createdOn: -1 });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
   };
 
-  CalendarEvent.statics.markAsProcessed = function markAsProcessed(id, cb) {
+  CalendarEvent.statics.markAsProcessed = async function markAsProcessed(id, cb) {
 
-    var self = this;
     var filter = { '_id': id };
     var update = { $set: { processed: true } };
     var options = { 'upsert': false, 'new': true };
 
-    self.findOneAndUpdate(filter, update, options).then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.findOneAndUpdate(filter, update, options);
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  CalendarEvent.statics.upsert = function(calendarEvent, cb) {
-
-    var self = this;
+  CalendarEvent.statics.upsert = async function(calendarEvent, cb) {
 
     // Prevent dupe events
 
@@ -172,7 +206,12 @@ module.exports = function(mongoose, config) {
       raw: calendarEvent.raw
     };
 
-    self.findOneAndUpdate(query, update, options).then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.findOneAndUpdate(query, update, options);
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
   CalendarEvent.set('autoIndex', false);

package/lib/CapTable.js

@@ -134,9 +134,7 @@ module.exports = function(mongoose, config) {
   // Statics operate on the entire collection
   //////////////////////////////////////////////////////
 
-  CapTable.statics.getForCustomer = function getForCustomer(customerid, options, cb) {
-
-    const self = this;
+  CapTable.statics.getForCustomer = async function getForCustomer(customerid, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!customerid) { return cb(new Error('customerid is required'), null); }
@@ -145,7 +143,7 @@ module.exports = function(mongoose, config) {
 
     let query;
 
-    query = self.find({
+    query = this.find({
       customer: customerid,
     });
 
@@ -165,26 +163,32 @@ module.exports = function(mongoose, config) {
     query.populate('stakeholders.person', 'name avatarUrl title');
     query.sort({ asOfDate: -1 });
 
-    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);
+    }
 
   };
 
-  CapTable.statics.deleteForCustomer = function deleteForCustomer(customerid, options, cb) {
-
-    const self = this;
+  CapTable.statics.deleteForCustomer = async function deleteForCustomer(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); }
     if (!options) { return cb(new Error('options is required'), null); }
 
-    self.deleteMany({ customer: customerid, 'entered.by': { $ne: 'carta-parser' } }).then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.deleteMany({ customer: customerid, 'entered.by': { $ne: 'carta-parser' } });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  CapTable.statics.getForOrg = function getForOrg(orgid, options, cb) {
-
-    var self = this;
+  CapTable.statics.getForOrg = async function getForOrg(orgid, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!orgid) { return cb(new Error('orgid is required'), null); }
@@ -194,7 +198,7 @@ module.exports = function(mongoose, config) {
     var query;
 
     if (options.isWorkerProcess) {
-      query = self.find({
+      query = this.find({
         organization: orgid
       });
     }
@@ -204,7 +208,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); }
 
-      query = self.find({
+      query = this.find({
         customer: options.CUSTOMER_ID,
         organization: orgid
       });
@@ -217,13 +221,16 @@ module.exports = function(mongoose, config) {
     query.populate('stakeholders.person', 'name avatarUrl title')
     query.sort({ asOfDate: -1 });
 
-    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);
+    }
 
   };
 
-  CapTable.statics.getByLP = function getByLP(lpid, options, cb) {
-
-    var self = this;
+  CapTable.statics.getByLP = async function getByLP(lpid, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!lpid) { return cb(new Error('lpid is required'), null); }
@@ -233,7 +240,7 @@ module.exports = function(mongoose, config) {
     var query;
 
     if (options.isWorkerProcess) {
-      query = self.find({
+      query = this.find({
         'stakeholders.lp': lpid
       });
     }
@@ -243,7 +250,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); }
 
-      query = self.find({
+      query = this.find({
         customer: options.CUSTOMER_ID,
         'stakeholders.lp': lpid
       });
@@ -251,13 +258,17 @@ module.exports = function(mongoose, config) {
     }
 
     query.populate('organization', 'name logoUrl')
-    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);
+    }
 
-  CapTable.statics.getByLPs = function getByLPs(lpids, options, cb) {
+  };
 
-    var self = this;
+  CapTable.statics.getByLPs = async function getByLPs(lpids, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!lpids) { return cb(new Error('lpids is required'), null); }
@@ -266,7 +277,7 @@ module.exports = function(mongoose, config) {
     var query;
 
     if (options.isWorkerProcess) {
-      query = self.find({
+      query = this.find({
         'stakeholders.lp': { $in : lpids }
       });
     }
@@ -276,7 +287,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); }
 
-      query = self.find({
+      query = this.find({
         customer: options.CUSTOMER_ID,
         'stakeholders.lp': { $in : lpids }
       });
@@ -284,13 +295,17 @@ module.exports = function(mongoose, config) {
     }
 
     query.populate('organization', 'name logoUrl')
-    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);
+    }
 
-  CapTable.statics.getByOrg = function getByOrg(orgid, options, cb) {
+  };
 
-    var self = this;
+  CapTable.statics.getByOrg = async function getByOrg(orgid, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!orgid) { return cb(new Error('orgid is required'), null); }
@@ -300,7 +315,7 @@ module.exports = function(mongoose, config) {
     var query;
 
     if (options.isWorkerProcess) {
-      query = self.find({
+      query = this.find({
         'stakeholders.org': orgid
       });
     }
@@ -310,7 +325,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); }
 
-      query = self.find({
+      query = this.find({
         customer: options.CUSTOMER_ID,
         'stakeholders.org': orgid
       });
@@ -318,13 +333,17 @@ module.exports = function(mongoose, config) {
     }
 
     query.populate('organization', 'name logoUrl')
-    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);
+    }
 
-  CapTable.statics.getByPerson = function getByPerson(personid, options, cb) {
+  };
 
-    var self = this;
+  CapTable.statics.getByPerson = async function getByPerson(personid, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!personid) { return cb(new Error('personid is required'), null); }
@@ -334,7 +353,7 @@ module.exports = function(mongoose, config) {
     var query;
 
     if (options.isWorkerProcess) {
-      query = self.find({
+      query = this.find({
         'stakeholders.person': personid
       });
     }
@@ -344,7 +363,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); }
 
-      query = self.find({
+      query = this.find({
         customer: options.CUSTOMER_ID,
         'stakeholders.person': personid
       });
@@ -352,13 +371,17 @@ module.exports = function(mongoose, config) {
     }
 
     query.populate('organization', 'name logoUrl')
-    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);
+    }
 
-  CapTable.statics.search = function search(terms, options, cb) {
+  };
 
-    const self = this;
+  CapTable.statics.search = async function search(terms, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!terms) { return cb(new Error('terms is required'), null); }
@@ -370,7 +393,7 @@ module.exports = function(mongoose, config) {
 
     let query;
 
-    query = self.find({
+    query = this.find({
       customer: options.CUSTOMER_ID,
       'stakeholders.name': new RegExp(terms, 'i'),
       'stakeholders.person': null
@@ -378,13 +401,17 @@ module.exports = function(mongoose, config) {
 
     query.populate('organization', 'name logoUrl');
     query.sort({ 'name': -1 });
-    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);
+    }
 
-  CapTable.statics.search2 = function search2(value, options, cb) {
+  };
 
-    const self = this;
+  CapTable.statics.search2 = async function search2(value, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!value) { return cb(new Error('value is required'), null); }
@@ -403,80 +430,94 @@ module.exports = function(mongoose, config) {
 
     const path = 'stakeholders.name';
 
-    self.aggregate([
-      {
-        "$search": {
-          index: 'default',
-          compound: {
-            should: [
-              {
-                autocomplete: {
-                  query: value,
-                  path: path
+    try {
+      const result = await this.aggregate([
+        {
+          "$search": {
+            index: 'default',
+            compound: {
+              should: [
+                {
+                  autocomplete: {
+                    query: value,
+                    path: path
+                  }
                 }
-              }
-            ],
-            must: [
-              {
-                equals: {
-                  path: 'customer',
-                  value: new mongoose.Types.ObjectId(options.CUSTOMER_ID)
+              ],
+              must: [
+                {
+                  equals: {
+                    path: 'customer',
+                    value: new mongoose.Types.ObjectId(options.CUSTOMER_ID)
+                  }
                 }
-              }
-            ],
-            minimumShouldMatch: 1
-          },
-          highlight: {
-            path: path
+              ],
+              minimumShouldMatch: 1
+            },
+            highlight: {
+              path: path
+            }
           }
-        }
-      },
-      {
-        $limit: options.limit,
-      },
-      {
-        $lookup:
-          {
-            from: "organizations",
-            localField: "organization",
-            foreignField: "_id",
-            as: "org"
+        },
+        {
+          $limit: options.limit,
+        },
+        {
+          $lookup:
+            {
+              from: "organizations",
+              localField: "organization",
+              foreignField: "_id",
+              as: "org"
+            }
+        },
+        {
+          $unwind: "$org"
+        },
+        {
+          $addFields: {
+            orgId: "$org._id",
+            name: "$org.name",
+            logoUrl: "$org.logoUrl"
+          }
+        },
+        {
+          $project: {
+            name: 1,
+            logoUrl: 1,
+            orgId: 1,
+            score: { $meta: "searchScore" },
+            highlights: { $meta: "searchHighlights" }
           }
-      },
-      {
-        $unwind: "$org"
-      },
-      {
-        $addFields: {
-          orgId: "$org._id",
-          name: "$org.name",
-          logoUrl: "$org.logoUrl"
-        }
-      },
-      {
-        $project: {
-          name: 1,
-          logoUrl: 1,
-          orgId: 1,
-          score: { $meta: "searchScore" },
-          highlights: { $meta: "searchHighlights" }
         }
-      }
-    ]).exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+      ]);
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  CapTable.statics.upsert = function upsert(capTable, cb) {
+  CapTable.statics.upsert = async function upsert(capTable, cb) {
 
     if (!capTable) { return cb(new Error('cap table is required'), null); }
 
-    capTable.save().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await capTable.save();
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  CapTable.statics.delete = function(id, cb) {
-    var self = this;
-    self.findByIdAndDelete(id).then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+  CapTable.statics.delete = async function(id, cb) {
+    try {
+      const result = await this.findByIdAndDelete(id);
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
   };
 
   ///////////////////////////////////////////////////////////////////////////////////////