@dhyasama/totem-models 12.3.0 → 12.4.0

package/lib/Financials.js

@@ -330,59 +330,55 @@ module.exports = function(mongoose, config) {
   // Statics operate on the entire collection
   //////////////////////////////////////////////////////
 
-  Financials.statics.addMetrics = function updateProperty(snapshotUUID, metrics, cb) {
+  Financials.statics.addMetrics = async function updateProperty(snapshotUUID, metrics, cb) {
 
-    const self = this;
-    const filter = { 'snapshots.uuid': snapshotUUID };
-    const update = { '$push': { 'snapshots.$.metrics': { $each: metrics } } };
-    const options = { 'upsert': false, 'new': true };
+    try {
+      const filter = { 'snapshots.uuid': snapshotUUID };
+      const update = { '$push': { 'snapshots.$.metrics': { $each: metrics } } };
+      const options = { 'upsert': false, 'new': true };
 
-    self.updateOne(filter, update, options).then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+      const result = await this.updateOne(filter, update, options);
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Financials.statics.addNewMetrics = function addNewMetrics(financialsId, snapshotUUID, metricsToAdd, cb) {
+  Financials.statics.addNewMetrics = async function addNewMetrics(financialsId, snapshotUUID, metricsToAdd, cb) {
 
-    const self = this;
-
-    self.findOne({ _id: financialsId, 'snapshots.uuid': snapshotUUID })
-      .then(financials => {
+    try {
+      const financials = await this.findOne({ _id: financialsId, 'snapshots.uuid': snapshotUUID });
 
-        if (!financials) { throw new Error('financials not found'); }
+      if (!financials) { throw new Error('financials not found'); }
 
-        const snapshot = financials.snapshots.find(snap => snap.uuid === snapshotUUID);
-        if (!snapshot) { throw new Error('Snapshot not found'); }
+      const snapshot = financials.snapshots.find(snap => snap.uuid === snapshotUUID);
+      if (!snapshot) { throw new Error('Snapshot not found'); }
 
-        const existingMetricNames = new Set(snapshot.metrics.map(metric => metric.name));
-        const newMetrics = metricsToAdd.filter(metric => !existingMetricNames.has(metric.name));
+      const existingMetricNames = new Set(snapshot.metrics.map(metric => metric.name));
+      const newMetrics = metricsToAdd.filter(metric => !existingMetricNames.has(metric.name));
 
-        if (newMetrics.length === 0) {
-          console.log('No new metrics to add');
-          return;
-        }
-
-        return self.findOneAndUpdate(
-          { _id: financialsId, 'snapshots.uuid': snapshotUUID },
-          { $push: { 'snapshots.$.metrics': { $each: newMetrics } } },
-          { new: true }
-        );
-
-      })
-      .then(result => {
-        if (result) { console.log('Metrics added successfully'); }
+      if (newMetrics.length === 0) {
+        console.log('No new metrics to add');
         return cb();
-      })
-      .catch(error => {
-        console.error('Error adding metrics:', error);
-        return cb(error);
-      });
+      }
 
-  }
+      const result = await this.findOneAndUpdate(
+        { _id: financialsId, 'snapshots.uuid': snapshotUUID },
+        { $push: { 'snapshots.$.metrics': { $each: newMetrics } } },
+        { new: true }
+      );
+
+      if (result) { console.log('Metrics added successfully'); }
+      return cb();
+    } catch(error) {
+      console.error('Error adding metrics:', error);
+      return cb(error);
+    }
 
-  Financials.statics.upsertMetrics = function upsertMetrics(financialsId, snapshotUUID, metricsToUpdate, cb) {
+  }
 
-    const self = this;
-    const session = mongoose.startSession();
+  Financials.statics.upsertMetrics = async function upsertMetrics(financialsId, snapshotUUID, metricsToUpdate, cb) {
 
     const metricWasAdded = (updatedDocument, snapshotUUID, metric) => {
 
@@ -412,7 +408,9 @@ module.exports = function(mongoose, config) {
     console.log('Upserting metrics for snapshot', snapshotUUID)
     console.log('Metrics to upsert:', metricsToUpdate)
 
-    session.then(async _session => {
+    const _session = await mongoose.startSession();
+
+    try {
 
       _session.startTransaction();
 
@@ -421,13 +419,13 @@ module.exports = function(mongoose, config) {
       // Fetch the current document to read existing metric values before overwriting
       let currentDoc = null;
       try {
-        currentDoc = await self.findOne({ _id: financialsId, 'snapshots.uuid': snapshotUUID }, null, { session: _session });
+        currentDoc = await this.findOne({ _id: financialsId, 'snapshots.uuid': snapshotUUID }, null, { session: _session });
       } catch (e) {
         console.log('Could not fetch current metrics for previous state:', e);
       }
       const currentSnapshot = currentDoc ? currentDoc.snapshots.find(s => s.uuid === snapshotUUID) : null;
 
-      const promises = metricsToUpdate.map(metric => {
+      const promises = metricsToUpdate.map(async metric => {
 
         console.log('Upserting metric:', metric);
         console.log('Upserting metric name:', metric.name);
@@ -463,7 +461,7 @@ module.exports = function(mongoose, config) {
           $set['snapshots.$.metrics.$[metric].previous'] = previousState;
         }
 
-        return self.findOneAndUpdate(
+        const result = await this.findOneAndUpdate(
           {
             _id: financialsId,
             snapshots: {
@@ -492,179 +490,172 @@ module.exports = function(mongoose, config) {
             new: true,
             session: _session
           }
-        ).then(result => {
-
-          //console.log('Upsert result:', result)
-
-          if (!metricWasAdded(result, snapshotUUID, metric)) {
-            console.log('Metric not added')
-            // If the metric doesn't exist, push it to the array
-            return self.findOneAndUpdate(
-              { _id: financialsId, 'snapshots.uuid': snapshotUUID },
-              { $push: { 'snapshots.$.metrics': metric } },
-              { new: true, session: _session }
-            ).then(result => {
-              console.log('Result of second findOneAndUpdate:', result);
-              return result;
-            });
-          }
+        );
 
-          return result;
+        //console.log('Upsert result:', result)
+
+        if (!metricWasAdded(result, snapshotUUID, metric)) {
+          console.log('Metric not added')
+          // If the metric doesn't exist, push it to the array
+          const pushResult = await this.findOneAndUpdate(
+            { _id: financialsId, 'snapshots.uuid': snapshotUUID },
+            { $push: { 'snapshots.$.metrics': metric } },
+            { new: true, session: _session }
+          );
+          console.log('Result of second findOneAndUpdate:', pushResult);
+          return pushResult;
+        }
+
+        return result;
 
-        });
       });
 
-      Promise.all(promises)
-        .then(() => {
-          return _session.commitTransaction();
-        })
-        .then(() => {
-          _session.endSession();
-          console.log('Upsert complete.');
-          return cb();
-        })
-        .catch(error => {
-          _session.abortTransaction().then(() => {
-            _session.endSession();
-            console.error(error);
-            return cb(error);
-          });
-        });
-    });
+      await Promise.all(promises);
+      await _session.commitTransaction();
+      _session.endSession();
+      console.log('Upsert complete.');
+      return cb();
+
+    } catch(error) {
+      await _session.abortTransaction();
+      _session.endSession();
+      console.error(error);
+      return cb(error);
+    }
 
   }
 
-  Financials.statics.undoMetrics = function undoMetrics(financialsId, snapshotUUID, metricsToUndo, cb) {
+  Financials.statics.undoMetrics = async function undoMetrics(financialsId, snapshotUUID, metricsToUndo, cb) {
 
-    const self = this;
-    const session = mongoose.startSession();
+    const _session = await mongoose.startSession();
 
-    session.then(async _session => {
+    _session.startTransaction();
 
-      _session.startTransaction();
+    try {
 
-      try {
+      const currentDoc = await this.findOne({ _id: financialsId, 'snapshots.uuid': snapshotUUID }, null, { session: _session });
+      if (!currentDoc) { throw new Error('Financials not found'); }
 
-        const currentDoc = await self.findOne({ _id: financialsId, 'snapshots.uuid': snapshotUUID }, null, { session: _session });
-        if (!currentDoc) { throw new Error('Financials not found'); }
+      const snapshot = currentDoc.snapshots.find(s => s.uuid === snapshotUUID);
+      if (!snapshot) { throw new Error('Snapshot not found'); }
 
-        const snapshot = currentDoc.snapshots.find(s => s.uuid === snapshotUUID);
-        if (!snapshot) { throw new Error('Snapshot not found'); }
+      const promises = metricsToUndo.map(metricId => {
 
-        const promises = metricsToUndo.map(metricId => {
+        const currentMetric = snapshot.metrics.find(m => m.name === metricId.name && m.scenario === metricId.scenario);
+        if (!currentMetric || !currentMetric.previous) {
+          console.log('No previous state for metric:', metricId.name, metricId.scenario);
+          return Promise.resolve();
+        }
 
-          const currentMetric = snapshot.metrics.find(m => m.name === metricId.name && m.scenario === metricId.scenario);
-          if (!currentMetric || !currentMetric.previous) {
-            console.log('No previous state for metric:', metricId.name, metricId.scenario);
-            return Promise.resolve();
-          }
+        const prev = currentMetric.previous;
+        const prefix = 'snapshots.$.metrics.$[metric]';
 
-          const prev = currentMetric.previous;
-          const prefix = 'snapshots.$.metrics.$[metric]';
+        // Restore fields that had values; unset fields that were null (didn't exist before)
+        const $set = {};
+        const $unset = { [prefix + '.previous']: 1 };
 
-          // Restore fields that had values; unset fields that were null (didn't exist before)
-          const $set = {};
-          const $unset = { [prefix + '.previous']: 1 };
+        const fields = ['value', 'breakdown', 'calculation', 'sources', 'verified'];
+        fields.forEach(field => {
+          if (prev[field] != null) {
+            $set[prefix + '.' + field] = prev[field];
+          } else {
+            $unset[prefix + '.' + field] = 1;
+          }
+        });
 
-          const fields = ['value', 'breakdown', 'calculation', 'sources', 'verified'];
-          fields.forEach(field => {
-            if (prev[field] != null) {
-              $set[prefix + '.' + field] = prev[field];
-            } else {
-              $unset[prefix + '.' + field] = 1;
-            }
-          });
+        // History is always restored (empty array if it was empty)
+        $set[prefix + '.history'] = prev.history || [];
 
-          // History is always restored (empty array if it was empty)
-          $set[prefix + '.history'] = prev.history || [];
-
-          return self.findOneAndUpdate(
-            {
-              _id: financialsId,
-              snapshots: {
-                $elemMatch: {
-                  uuid: snapshotUUID,
-                  metrics: {
-                    $elemMatch: {
-                      name: metricId.name,
-                      scenario: metricId.scenario
-                    }
+        return this.findOneAndUpdate(
+          {
+            _id: financialsId,
+            snapshots: {
+              $elemMatch: {
+                uuid: snapshotUUID,
+                metrics: {
+                  $elemMatch: {
+                    name: metricId.name,
+                    scenario: metricId.scenario
                   }
                 }
               }
-            },
-            {
-              $set: $set,
-              $unset: $unset
-            },
-            {
-              arrayFilters: [{ 'metric.name': metricId.name, 'metric.scenario': metricId.scenario }],
-              new: true,
-              session: _session
             }
-          );
-
-        });
-
-        await Promise.all(promises);
-        await _session.commitTransaction();
-        _session.endSession();
-        console.log('Undo complete.');
-        return cb();
+          },
+          {
+            $set: $set,
+            $unset: $unset
+          },
+          {
+            arrayFilters: [{ 'metric.name': metricId.name, 'metric.scenario': metricId.scenario }],
+            new: true,
+            session: _session
+          }
+        );
 
-      } catch (error) {
-        await _session.abortTransaction();
-        _session.endSession();
-        console.error(error);
-        return cb(error);
-      }
+      });
 
-    });
+      await Promise.all(promises);
+      await _session.commitTransaction();
+      _session.endSession();
+      console.log('Undo complete.');
+      return cb();
+
+    } catch (error) {
+      await _session.abortTransaction();
+      _session.endSession();
+      console.error(error);
+      return cb(error);
+    }
 
   }
 
-  Financials.statics.getAll = function getAll(options, cb) {
-
-    const self = this;
+  Financials.statics.getAll = async function getAll(options, cb) {
 
-    let query = self.find({});
+    try {
+      let query = this.find({});
 
-    query.populate('organization', 'name logoUrl');
-    query.populate('customer', 'name logoUrl customer');
+      query.populate('organization', 'name logoUrl');
+      query.populate('customer', 'name logoUrl customer');
 
-    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);
+    }
 
   };
 
-  Financials.statics.getByOrg = function getByOrg(customerId, orgId, cb) {
+  Financials.statics.getByOrg = async function getByOrg(customerId, orgId, cb) {
 
-    var self = this;
-
-    var query = self.findOne({
-      'customer': customerId,
-      'organization': orgId
-    }).populate({
-      path: 'snapshots.documents.document',
-      match: { customer: customerId }
-    });
+    try {
+      var query = this.findOne({
+        'customer': customerId,
+        'organization': orgId
+      }).populate({
+        path: 'snapshots.documents.document',
+        match: { customer: customerId }
+      });
 
-    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);
+    }
 
   };
 
-  Financials.statics.getByUUID = function getByUUID(uuid, cb) {
-
-    let self = this;
+  Financials.statics.getByUUID = async function getByUUID(uuid, cb) {
 
-    let query = self.findOne({
-      'snapshots.uuid': uuid
-    });
+    try {
+      let query = this.findOne({
+        'snapshots.uuid': uuid
+      });
 
-    query.populate('organization', 'name logoUrl website');
-    query.populate('customer');
-    query.populate('snapshots.documents.document');
+      query.populate('organization', 'name logoUrl website');
+      query.populate('customer');
+      query.populate('snapshots.documents.document');
 
-    query.exec().then(function(result) {
+      const result = await query;
       if (!result) {
         return cb(null, null);
       }
@@ -681,32 +672,34 @@ module.exports = function(mongoose, config) {
       });
 
       return cb(null, result);
-
-    }).catch(function(err) { cb(err); });
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Financials.statics.getByPostmarkMessageId = function getByPostmarkMessageId(postmarkMessageId, cb) {
-
-    var self = this;
-
-    var query = self.findOne({
-      $or: [
-        { 'snapshots.notifications.company.initial.postmarkMessageId': postmarkMessageId },
-        { 'snapshots.notifications.company.reminders.postmarkMessageId': postmarkMessageId },
-        { 'snapshots.notifications.company.rejections.postmarkMessageId': postmarkMessageId },
-        { 'snapshots.notifications.stakeholders.initial.postmarkMessageId': postmarkMessageId },
-        { 'snapshots.notifications.stakeholders.reminders.postmarkMessageId': postmarkMessageId }
-      ]
-    });
+  Financials.statics.getByPostmarkMessageId = async function getByPostmarkMessageId(postmarkMessageId, cb) {
+
+    try {
+      var query = this.findOne({
+        $or: [
+          { 'snapshots.notifications.company.initial.postmarkMessageId': postmarkMessageId },
+          { 'snapshots.notifications.company.reminders.postmarkMessageId': postmarkMessageId },
+          { 'snapshots.notifications.company.rejections.postmarkMessageId': postmarkMessageId },
+          { 'snapshots.notifications.stakeholders.initial.postmarkMessageId': postmarkMessageId },
+          { 'snapshots.notifications.stakeholders.reminders.postmarkMessageId': postmarkMessageId }
+        ]
+      });
 
-    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);
+    }
 
   };
 
-  Financials.statics.getByPostmarkMessageId2 = function getByPostmarkMessageId2(notificationType, postmarkMessageId, cb) {
-
-    const self = this;
+  Financials.statics.getByPostmarkMessageId2 = async function getByPostmarkMessageId2(notificationType, postmarkMessageId, cb) {
 
     const notificationTypes = [
       'company.initial',
@@ -720,70 +713,78 @@ module.exports = function(mongoose, config) {
     if (!postmarkMessageId) { throw new Error('postmarkMessageId is required'); }
     if (!notificationTypes.includes(notificationType)) { throw new Error('notificationType is required'); }
 
-    const key = 'snapshots.notifications.' + notificationType + '.postmarkMessageId';
+    try {
+      const key = 'snapshots.notifications.' + notificationType + '.postmarkMessageId';
 
-    const query = self.findOne({
-      key: postmarkMessageId
-    });
+      const query = this.findOne({
+        key: postmarkMessageId
+      });
 
-    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);
+    }
 
   };
 
-  Financials.statics.getDocument = function getDocument(documentId, cb) {
+  Financials.statics.getDocument = async function getDocument(documentId, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!documentId) { return cb(new Error('documentId is required'), null); }
     if (!mongoose.Types.ObjectId.isValid(documentId)) { return cb(new Error('documentId is not a valid ObjectId'), null); }
 
-    const self = this;
-
-    self.aggregate([
-      { $unwind: '$snapshots' },
-      { $unwind: '$snapshots.documents' },
-      { $match: { 'snapshots.documents.document': new mongoose.Types.ObjectId(documentId) } },
-      {
-        $project: {
-          _id: 1,
-          snapshot: '$snapshots',
-          document: '$snapshots.documents',
-          organization: '$organization',
-          customer: '$customer'
+    try {
+      const result = await this.aggregate([
+        { $unwind: '$snapshots' },
+        { $unwind: '$snapshots.documents' },
+        { $match: { 'snapshots.documents.document': new mongoose.Types.ObjectId(documentId) } },
+        {
+          $project: {
+            _id: 1,
+            snapshot: '$snapshots',
+            document: '$snapshots.documents',
+            organization: '$organization',
+            customer: '$customer'
+          }
         }
-      }
-    ]).exec().then(function(result) {
+      ]);
+
       if (!result || result.length === 0) return cb(null, null);
       else return cb(null, result[0]);
-    }).catch(function(err) { cb(err); });
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Financials.statics.getSnapshot = function getSnapshot(snapshotUUID, cb) {
+  Financials.statics.getSnapshot = async function getSnapshot(snapshotUUID, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!snapshotUUID) { return cb(new Error('snapshotUUID is required'), null); }
 
-    const self = this;
-
-    self.aggregate([
-      { $unwind: '$snapshots' },
-      { $match: { 'snapshots.uuid': snapshotUUID } },
-      {
-        $project: {
-          _id: 1,
-          snapshot: '$snapshots'
+    try {
+      const result = await this.aggregate([
+        { $unwind: '$snapshots' },
+        { $match: { 'snapshots.uuid': snapshotUUID } },
+        {
+          $project: {
+            _id: 1,
+            snapshot: '$snapshots'
+          }
         }
-      }
-    ]).exec().then(function(result) {
+      ]);
+
       if (!result || result.length === 0) return cb(null, null);
       else return cb(null, result[0]);
-    }).catch(function(err) { cb(err); });
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Financials.statics.getRecurringToSend = function getRecurringToSend(options, cb) {
+  Financials.statics.getRecurringToSend = async function getRecurringToSend(options, cb) {
 
-    const self = this;
     const now = new Date();
 
     if (!cb) { throw new Error('cb is required'); }
@@ -791,34 +792,38 @@ module.exports = function(mongoose, config) {
     if (!options.startTime) { return cb(new Error('options.startTime is required'), null); }
     if (!options.endTime) { return cb(new Error('options.endTime is required'), null); }
 
-    let query = self.find({
-      'recurring.send.sendOn': { $lte: now },
-      'recurring.adminReminders.sent': false
-    });
-
-    query.exec().then(function(result) {return cb(null, result);
+    try {
+      let query = this.find({
+        'recurring.send.sendOn': { $lte: now },
+        'recurring.adminReminders.sent': false
+      });
 
-    }).catch(function(err) { cb(err); });
+      const result = await query;
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Financials.statics.getCompanyInitialToSend = function getCompanyInitialToSend(cb) {
+  Financials.statics.getCompanyInitialToSend = async function getCompanyInitialToSend(cb) {
 
-    var self = this;
     var now = new Date();
 
-    var query = self.find({
-      'snapshots': {
-        $elemMatch: {
-          'notifications.company.initial.sendTo': { $gt: [] },
-          'notifications.company.initial.sendOn': { $lte: now },
-          'notifications.company.initial.sentOn': null,
-          'status': { $nin: ['Pending', 'Completed', 'Archived'] }
+    try {
+      var query = this.find({
+        'snapshots': {
+          $elemMatch: {
+            'notifications.company.initial.sendTo': { $gt: [] },
+            'notifications.company.initial.sendOn': { $lte: now },
+            'notifications.company.initial.sentOn': null,
+            'status': { $nin: ['Pending', 'Completed', 'Archived'] }
+          }
         }
-      }
-    });
+      });
 
-    query.exec().then(function(result) {var results = [];
+      const result = await query;
+      var results = [];
 
       _.each(result, function(financial) {
 
@@ -849,28 +854,30 @@ module.exports = function(mongoose, config) {
       });
 
       return cb(null, results);
-
-    }).catch(function(err) { cb(err); });
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Financials.statics.getCompanyReminderToSend = function getCompanyReminderToSend(cb) {
+  Financials.statics.getCompanyReminderToSend = async function getCompanyReminderToSend(cb) {
 
-    var self = this;
     var now = new Date();
 
-    var query = self.find({
-      'snapshots': {
-        $elemMatch: {
-          'notifications.company.reminders.sendTo': { $gt: [] },
-          'notifications.company.reminders.sendOn': { $lte: now },
-          'notifications.company.reminders.sentOn': null,
-          'status': { $nin: ['Pending', 'Completed', 'Archived'] }
+    try {
+      var query = this.find({
+        'snapshots': {
+          $elemMatch: {
+            'notifications.company.reminders.sendTo': { $gt: [] },
+            'notifications.company.reminders.sendOn': { $lte: now },
+            'notifications.company.reminders.sentOn': null,
+            'status': { $nin: ['Pending', 'Completed', 'Archived'] }
+          }
         }
-      }
-    });
+      });
 
-    query.exec().then(function(result) {var results = [];
+      const result = await query;
+      var results = [];
 
       _.each(result, function(financial) {
 
@@ -905,28 +912,30 @@ module.exports = function(mongoose, config) {
       });
 
       return cb(null, results);
-
-    }).catch(function(err) { cb(err); });
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Financials.statics.getCompanyRejectionToSend = function getCompanyRejectionToSend(cb) {
+  Financials.statics.getCompanyRejectionToSend = async function getCompanyRejectionToSend(cb) {
 
-    var self = this;
     var now = new Date();
 
-    var query = self.find({
-      'snapshots': {
-        $elemMatch: {
-          'notifications.company.rejections.sendTo': { $gt: [] },
-          'notifications.company.rejections.sendOn': { $lte: now },
-          'notifications.company.rejections.sentOn': null,
-          'status': { $nin: ['Pending', 'Completed', 'Archived'] }
+    try {
+      var query = this.find({
+        'snapshots': {
+          $elemMatch: {
+            'notifications.company.rejections.sendTo': { $gt: [] },
+            'notifications.company.rejections.sendOn': { $lte: now },
+            'notifications.company.rejections.sentOn': null,
+            'status': { $nin: ['Pending', 'Completed', 'Archived'] }
+          }
         }
-      }
-    });
+      });
 
-    query.exec().then(function(result) {var results = [];
+      const result = await query;
+      var results = [];
 
       _.each(result, function(financial) {
 
@@ -937,7 +946,7 @@ module.exports = function(mongoose, config) {
             var hasSendTo = rejection.sendTo && rejection.sendTo.length > 0;
             var hasSendOnLessThanNow = rejection.sendOn && rejection.sendOn < now;
             var hasSentOn = rejection.sentOn;
-            
+
             var conditions = hasSendTo && hasSendOnLessThanNow && !hasSentOn;
 
             if(conditions) {
@@ -961,29 +970,31 @@ module.exports = function(mongoose, config) {
       });
 
       return cb(null, results);
-
-    }).catch(function(err) { cb(err); });
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Financials.statics.getStakeholderInitialToSend = function getStakeholderInitialToSend(cb) {
+  Financials.statics.getStakeholderInitialToSend = async function getStakeholderInitialToSend(cb) {
 
-    const self = this;
     const now = new Date();
 
-    // This will get each financial doc with a snapshot that matches the query
-    // Note that all snapshots in that doc will be returned, even ones that don't match the query
-    const query = self.find({
-      'snapshots': {
-        $elemMatch: {
-          'notifications.stakeholders.sendTo.email': { $ne: null },
-          'notifications.stakeholders.initial.sendOn': { $lte: now },
-          'notifications.stakeholders.initial.sentOn': null
+    try {
+      // This will get each financial doc with a snapshot that matches the query
+      // Note that all snapshots in that doc will be returned, even ones that don't match the query
+      const query = this.find({
+        'snapshots': {
+          $elemMatch: {
+            'notifications.stakeholders.sendTo.email': { $ne: null },
+            'notifications.stakeholders.initial.sendOn': { $lte: now },
+            'notifications.stakeholders.initial.sentOn': null
+          }
         }
-      }
-    });
+      });
 
-    query.exec().then(function(financials) {financials = financials || [];
+      let financials = await query;
+      financials = financials || [];
 
       let results = [];
 
@@ -1023,28 +1034,30 @@ module.exports = function(mongoose, config) {
       });
 
       return cb(null, results);
-
-    }).catch(function(err) { cb(err); });
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Financials.statics.getStakeholderReminderToSend = function getStakeholderReminderToSend(cb) {
+  Financials.statics.getStakeholderReminderToSend = async function getStakeholderReminderToSend(cb) {
 
-    var self = this;
     var now = new Date();
 
-    var query = self.find({
-      'snapshots': {
-        $elemMatch: {
-          'notifications.stakeholders.sendTo.email': { $ne: null },
-          'notifications.stakeholders.sendTo.organization': { $ne: null },
-          'notifications.stakeholders.reminders.sendOn': { $lte: now },
-          'notifications.stakeholders.reminders.sentOn': null
+    try {
+      var query = this.find({
+        'snapshots': {
+          $elemMatch: {
+            'notifications.stakeholders.sendTo.email': { $ne: null },
+            'notifications.stakeholders.sendTo.organization': { $ne: null },
+            'notifications.stakeholders.reminders.sendOn': { $lte: now },
+            'notifications.stakeholders.reminders.sentOn': null
+          }
         }
-      }
-    });
+      });
 
-    query.exec().then(function(result) {var results = [];
+      const result = await query;
+      var results = [];
 
       _.each(result, function(financial) {
 
@@ -1078,105 +1091,125 @@ module.exports = function(mongoose, config) {
       });
 
       return cb(null, results);
-
-    }).catch(function(err) { cb(err); });
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Financials.statics.getForCustomer = function getForCustomer(customerId, options, cb) {
-    
-    var self = this;
+  Financials.statics.getForCustomer = async function getForCustomer(customerId, options, cb) {
 
-    var query = self.find({
-      'customer': customerId
-    });
+    try {
+      var query = this.find({
+        'customer': customerId
+      });
 
-    var dateRangeQuery = {};
-    if (options.startDate) {
-      var startDate = new Date(options.startDate);
-      dateRangeQuery['$gte'] = startDate;
-    }
+      var dateRangeQuery = {};
+      if (options.startDate) {
+        var startDate = new Date(options.startDate);
+        dateRangeQuery['$gte'] = startDate;
+      }
 
-    if (options.endDate) {
-      var endDate = new Date(options.endDate);
-      dateRangeQuery['$lte'] = endDate;
-    }
+      if (options.endDate) {
+        var endDate = new Date(options.endDate);
+        dateRangeQuery['$lte'] = endDate;
+      }
 
-    if (options.startDate || options.endDate) {
-      query.where('snapshots').elemMatch({ 
-        submittedOn: dateRangeQuery 
-      });
-    }
+      if (options.startDate || options.endDate) {
+        query.where('snapshots').elemMatch({
+          submittedOn: dateRangeQuery
+        });
+      }
 
-    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);
+    }
 
   };
 
-  Financials.statics.getToSend = function getToSend(uuid, cb) {
+  Financials.statics.getToSend = async function getToSend(uuid, cb) {
 
-    var self = this;
-
-    var query = self.findOne({
-      'snapshots.uuid': uuid
-    });
+    try {
+      var query = this.findOne({
+        'snapshots.uuid': uuid
+      });
 
-    query.populate('organization', 'name logoUrl');
-    query.populate('customer', 'name logoUrl customer');
-    query.populate('snapshots.notifications.stakeholders.sendTo.organization', 'name logoUrl customer');
+      query.populate('organization', 'name logoUrl');
+      query.populate('customer', 'name logoUrl customer');
+      query.populate('snapshots.notifications.stakeholders.sendTo.organization', 'name logoUrl customer');
 
-    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);
+    }
 
   };
 
-  Financials.statics.getOverdue = function getOverdue(cb) {
+  Financials.statics.getOverdue = async function getOverdue(cb) {
 
-    const self = this;
-
-    const query = self.find({
-      'snapshots': {
-        $elemMatch: {
-          'status': { $nin: ['Completed', 'Archived', 'Overdue'] },
-          'dueOn': { $lte: new Date() }
+    try {
+      const query = this.find({
+        'snapshots': {
+          $elemMatch: {
+            'status': { $nin: ['Completed', 'Archived', 'Overdue'] },
+            'dueOn': { $lte: new Date() }
+          }
         }
-      }
-    });
+      });
 
-    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);
+    }
 
   };
 
-  Financials.statics.updateProperty = function updateProperty(id, key, value, cb) {
+  Financials.statics.updateProperty = async function updateProperty(id, key, value, cb) {
 
-    const self = this;
-    const filter = { '_id': id };
-    const update = { $set: { key: value } };
-    const options = { 'upsert': false, 'new': true };
+    try {
+      const filter = { '_id': id };
+      const update = { $set: { key: value } };
+      const options = { 'upsert': false, 'new': true };
 
-    self.findOneAndUpdate(filter, update, options).then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+      const result = await this.findOneAndUpdate(filter, update, options);
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Financials.statics.removeSheetFinancials = function removeSheetFinancials(customerId, cb) {
+  Financials.statics.removeSheetFinancials = async function removeSheetFinancials(customerId, cb) {
 
     // this is only used to wipe out financials created by the google sheet import process
     // we do NOT want to delete any financials submitted via forms generated directly from the app
 
-    var self = this;
-
-    self
-      .updateMany(
+    try {
+      const result = await this.updateMany(
         { customer: customerId },
-        { $pull : { snapshots: { submittedBy: 'Totem Sheet' } } },
-        { multi : true }
-      ).exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+        { $pull : { snapshots: { submittedBy: 'Totem Sheet' } } }
+      );
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Financials.statics.upsert = function upsert(financials, cb) {
+  Financials.statics.upsert = async function upsert(financials, cb) {
 
     if (!financials) { return cb(new Error('financials is required'), null); }
 
-    financials.save().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await financials.save();
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };