@dhyasama/totem-models 12.3.0 → 12.4.0

package/lib/FinancialsAnalysis.js

@@ -15,7 +15,7 @@ module.exports = function(mongoose, config) {
   const moment = require('moment');
 
   const FinancialsAnalysis = new Schema({
-    
+
     organization: { type: Schema.ObjectId, ref: 'Organization', required: true, index: true },
 
     customer: { type: Schema.ObjectId, ref: 'Organization', required: true, index: true },
@@ -31,77 +31,88 @@ module.exports = function(mongoose, config) {
       category: { type: String, enum: ['highlight', 'lowlight', 'goal', 'ask'] },
       page: { type: Number, default: -1 }
     }]
-    
-  });
 
-  FinancialsAnalysis.statics.getByOrg = function getByOrg(customerId, orgId, cb) {
+  });
 
-    const self = this;
+  FinancialsAnalysis.statics.getByOrg = async function getByOrg(customerId, orgId, cb) {
 
-    var query = self.find({
-      'customer': customerId,
-      'organization': orgId
-    })
+    try {
+      var query = this.find({
+        'customer': customerId,
+        'organization': orgId
+      })
 
-    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);
+    }
 
   };
 
-  FinancialsAnalysis.statics.getByCustomer = function getByCustomer(customerId, cb) {
-
-    var self = this;
+  FinancialsAnalysis.statics.getByCustomer = async function getByCustomer(customerId, cb) {
 
-    var query = self.find({
-      'customer': customerId
-    });
+    try {
+      var query = this.find({
+        '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);
+    }
 
   };
 
-  FinancialsAnalysis.statics.getByFinancials = function getByFinancials(financials, cb) {
+  FinancialsAnalysis.statics.getByFinancials = async function getByFinancials(financials, cb) {
 
-    let self = this;
+    try {
+      let query = this.find({
+        'financials': financials
+      });
 
-    let query = self.find({
-      'financials': financials
-    });
-
-    query.exec().then(function(result) {
+      const result = await query;
       if (!result) {
         return cb(null, null);
       }
 
       return cb(null, result);
-
-    }).catch(function(err) { cb(err); });
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  FinancialsAnalysis.statics.getBySnapshotUUID = function getBySnapshotUUID(uuids, cb) {
-
-    let self = this;
+  FinancialsAnalysis.statics.getBySnapshotUUID = async function getBySnapshotUUID(uuids, cb) {
 
-    let query = self.find({
-      'snapshotUUID': uuids
-    });
+    try {
+      let query = this.find({
+        'snapshotUUID': uuids
+      });
 
-    query.exec().then(function(result) {
+      const result = await query;
       if (!result) {
         return cb(null, null);
       }
 
       return cb(null, result);
-
-    }).catch(function(err) { cb(err); });
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  FinancialsAnalysis.statics.upsert = function upsert(doc, cb) {
+  FinancialsAnalysis.statics.upsert = async function upsert(doc, cb) {
 
     if (!doc) { return cb(new Error('doc is required'), null); }
 
-    doc.save().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await doc.save();
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
@@ -114,4 +125,4 @@ module.exports = function(mongoose, config) {
 
   mongoose.model('FinancialsAnalysis', FinancialsAnalysis);
 
-};
+};

package/lib/Flag.js

@@ -21,7 +21,7 @@ module.exports = function(mongoose, config) {
 
   });
 
-  Flag.statics.createForModel = function(flag, Model, modelId, cb) {
+  Flag.statics.createForModel = async function(flag, Model, modelId, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!flag) { throw new Error('flag is required'); }
@@ -29,27 +29,22 @@ module.exports = function(mongoose, config) {
     if (!modelId) { throw new Error('modelId is required'); }
     if (!mongoose.Types.ObjectId.isValid(modelId)) { return cb(new Error('modelId is not a valid ObjectId'), null); }
 
-    const self = this;
-
-    var addToModel = function(err, createdFlag) {
-      if (err) return cb(err, null);
-      Model.findByIdAndUpdate(modelId, { $push: { flags: createdFlag }}, { new: true, upsert: false }).then(function(addedTo) {
-        return cb(null, {
-          flag: createdFlag,
-          addedTo: addedTo
-        });
-      }).catch(function(err) {
-        return cb(err);
-      });
-    };
-
     flag.createdOn = new Date();
 
-    self.create(flag).then(function(created) { addToModel(null, created); }).catch(function(err) { addToModel(err); });
+    try {
+      const createdFlag = await this.create(flag);
+      const addedTo = await Model.findByIdAndUpdate(modelId, { $push: { flags: createdFlag }}, { new: true, upsert: false });
+      return cb(null, {
+        flag: createdFlag,
+        addedTo: addedTo
+      });
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Flag.statics.delete = function(flagId, customerId, cb) {
+  Flag.statics.delete = async function(flagId, customerId, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!flagId) { throw new Error('flagId is required'); }
@@ -57,40 +52,44 @@ 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); }
 
-    const self = this;
-
     // Not strictly necessary but provides verification that the flag being deleted belongs to the customer doing the deleting
-    let query = self.findOne({
+    let query = this.findOne({
       '_id': flagId,
       'customer': customerId
     });
 
-    query.exec().then(function(flag) {
+    try {
+      const flag = await query;
       if (!flag) { return cb(null, null); }
 
-      flag.deleteOne().then(function() { cb(null, flag); }).catch(function(err) { cb(err); });
-
-    }).catch(function(err) { cb(err); });
+      await flag.deleteOne();
+      return cb(null, flag);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Flag.statics.getById = function(id, cb) {
+  Flag.statics.getById = async function(id, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!id) { throw new Error('id is required'); }
     if (!mongoose.Types.ObjectId.isValid(id)) { return cb(new Error('id is not a valid ObjectId'), null); }
 
-    const self = this;
-
-    let query = self.findById({
+    let query = this.findById({
       '_id': id
     });
 
-    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);
+    }
 
   };
 
-  Flag.statics.modifyById = function(id, update, cb) {
+  Flag.statics.modifyById = async function(id, update, cb) {
 
     // VERY IMPORTANT NOTE
     // findByIdAndUpdate and findOneAndUpdate do not trigger pre-save hook so that code will not run here
@@ -99,18 +98,26 @@ module.exports = function(mongoose, config) {
     if (!id) { return cb(new Error('id is required'), null); }
     if (!update) { return cb(new Error('update is required'), null); }
 
-    var self = this;
-
     // 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
 
-    self.findByIdAndUpdate(id, update, { upsert: false, new: true }).then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.findByIdAndUpdate(id, update, { upsert: false, new: true });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Flag.statics.upsert = function(flag, cb) {
-    flag.save().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+  Flag.statics.upsert = async function(flag, cb) {
+    try {
+      const result = await flag.save();
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
   };
 
   Flag.post('init', function(doc) {

package/lib/Folder.js

@@ -16,7 +16,7 @@ module.exports = function(mongoose, config) {
     documents: [{ type: Schema.ObjectId, ref: 'Document' }]
   });
 
-  Folder.statics.modifyById = function(id, update, cb) {
+  Folder.statics.modifyById = async function(id, update, cb) {
 
     // VERY IMPORTANT NOTE
     // findByIdAndUpdate and findOneAndUpdate do not trigger pre-save hook so that code will not run here
@@ -27,17 +27,20 @@ module.exports = function(mongoose, config) {
     if (!mongoose.Types.ObjectId.isValid(id)) { return cb(new Error('id is not a valid ObjectId'), null); }
     if (!update) { return cb(new Error('update is required'), null); }
 
-    var self = this;
-
     // 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
 
-    self.findByIdAndUpdate(id, update, { upsert: false, new: true }).then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.findByIdAndUpdate(id, update, { upsert: false, new: true });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Folder.statics.getByEntity = function getByEntity(entity, options, cb) {
+  Folder.statics.getByEntity = async function getByEntity(entity, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!entity) { return cb(new Error('entity is required'), null); }
@@ -48,30 +51,40 @@ 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); }
 
-    const self = this;
-
-    self.find({
-      'entity.id': entity.id,
-      'entity.model': entity.model,
-      customer: options.CUSTOMER_ID
-    })
-    .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.find({
+        'entity.id': entity.id,
+        'entity.model': entity.model,
+        customer: options.CUSTOMER_ID
+      });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Folder.statics.upsert = function (folder, cb) {
-    folder.save().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+  Folder.statics.upsert = async function (folder, cb) {
+    try {
+      const result = await folder.save();
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
   };
 
-  Folder.statics.delete = function (id, options, cb) {
-
-    const self = this;
+  Folder.statics.delete = async function (id, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!id) { return cb(new Error('id is required'), null); }
     if (!mongoose.Types.ObjectId.isValid(id)) { return cb(new Error('id is not a valid ObjectId'), null); }
 
-    self.findByIdAndDelete(id).then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.findByIdAndDelete(id);
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
   Folder.set('autoIndex', false);
@@ -79,4 +92,4 @@ module.exports = function(mongoose, config) {
 
   mongoose.model('Folder', Folder);
 
-};
+};

package/lib/Fund.js

@@ -66,44 +66,57 @@ module.exports = function(mongoose, config) {
 
   ///////////////////////////////////////
 
-  Fund.statics.findBySlugs = function findBySlugs(slugs, cb) {
-
-    const self = this;
+  Fund.statics.findBySlugs = async function findBySlugs(slugs, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!slugs) { return cb(new Error('slug must be provided'), null); }
 
-    self
-      .find({ 'slug': { $in : slugs }})
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.find({ 'slug': { $in : slugs }});
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Fund.statics.getById = function getById(id, cb) {
-    this
-      .findById(id)
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+  Fund.statics.getById = async function getById(id, cb) {
+    try {
+      const result = await this.findById(id);
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
   };
 
-  Fund.statics.getBySlug = function getBySlug(slug, cb) {
-    this
-      .find({slug: slug})
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+  Fund.statics.getBySlug = async function getBySlug(slug, cb) {
+    try {
+      const result = await this.find({slug: slug});
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
   };
 
-  Fund.statics.getCount = function getCount(cb) {
-    this
-      .countDocuments({})
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+  Fund.statics.getCount = async function getCount(cb) {
+    try {
+      const result = await this.countDocuments({});
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
   };
 
-  Fund.statics.list = function list(cb) {
-    this
-      .find()
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+  Fund.statics.list = async function list(cb) {
+    try {
+      const result = await this.find();
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
   };
 
-  Fund.statics.search = function search(query, options, cb) {
+  Fund.statics.search = async function search(query, options, cb) {
 
     if (!cb) throw new Error('cb is required');
     if (!query) return cb(null, []);
@@ -112,16 +125,16 @@ module.exports = function(mongoose, config) {
       'name': new RegExp(query, "i")
     };
 
-    this
-      .find(conditions)
-      .sort('name')
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.find(conditions).sort('name');
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Fund.statics.search2 = function search2(value, options, cb) {
-
-    const self = this;
+  Fund.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); }
@@ -138,46 +151,51 @@ module.exports = function(mongoose, config) {
     // combine provided and default options
     options = _.defaults(options || {}, defaultOptions);
 
-    self.aggregate([
-      {
-        "$search": {
-          index: 'default',
-          compound: {
-            should: [
-              {
-                text: {
-                  query: value,
-                  path: [
-                    'name',
-                    'stakeholders'
-                  ],
-                  fuzzy: {
-                    maxEdits: options.maxEdits,
-                    maxExpansions: options.maxExpansions
-                  },
-                  score: { boost: { value: 3 } }
+    try {
+      const result = await this.aggregate([
+        {
+          "$search": {
+            index: 'default',
+            compound: {
+              should: [
+                {
+                  text: {
+                    query: value,
+                    path: [
+                      'name',
+                      'stakeholders'
+                    ],
+                    fuzzy: {
+                      maxEdits: options.maxEdits,
+                      maxExpansions: options.maxExpansions
+                    },
+                    score: { boost: { value: 3 } }
+                  }
                 }
-              }
-            ],
-            minimumShouldMatch: 1
+              ],
+              minimumShouldMatch: 1
+            }
+          }
+        },
+        {
+          $limit: options.limit,
+        },
+        {
+          $project: {
+            name: 1,
+            abbreviation: 1,
+            score: { $meta: "searchScore" }
           }
         }
-      },
-      {
-        $limit: options.limit,
-      },
-      {
-        $project: {
-          name: 1,
-          abbreviation: 1,
-          score: { $meta: "searchScore" }
-        }
-      }
-    ]).exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+      ]);
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Fund.statics.upsert = function upsert(fund, username, cb) {
+  Fund.statics.upsert = async function upsert(fund, username, cb) {
 
     if (!fund) { return cb(new Error('Fund is required'), null); }
     if (!username) { return cb(new Error('Username is required'), null); }
@@ -185,11 +203,16 @@ module.exports = function(mongoose, config) {
     // Required for mixed types
     fund.markModified('customFields');
 
-    fund.save().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await fund.save();
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Fund.statics.modify = function(filter, update, cb) {
+  Fund.statics.modify = async function(filter, update, cb) {
 
     // VERY IMPORTANT NOTE
     // findByIdAndUpdate and findOneAndUpdate do not trigger pre-save hook so that code will not run here
@@ -199,17 +222,20 @@ module.exports = function(mongoose, config) {
     if (!filter) { return cb(new Error('filter is required'), null); }
     if (!update) { return cb(new Error('update is required'), null); }
 
-    var self = this;
-
     // 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
 
-    self.findOneAndUpdate(filter, update, { upsert: false, new: true }).then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.findOneAndUpdate(filter, update, { upsert: false, new: true });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Fund.statics.modifyById = function(id, update, cb) {
+  Fund.statics.modifyById = async function(id, update, cb) {
 
     // VERY IMPORTANT NOTE
     // findByIdAndUpdate and findOneAndUpdate do not trigger pre-save hook so that code will not run here
@@ -220,13 +246,16 @@ module.exports = function(mongoose, config) {
     if (!mongoose.Types.ObjectId.isValid(id)) { return cb(new Error('id is not a valid ObjectId'), null); }
     if (!update) { return cb(new Error('update is required'), null); }
 
-    var self = this;
-
     // 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
 
-    self.findByIdAndUpdate(id, update, { upsert: false, new: true }).then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.findByIdAndUpdate(id, update, { upsert: false, new: true });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
   Fund.set('autoIndex', false);
@@ -234,4 +263,4 @@ module.exports = function(mongoose, config) {
 
   mongoose.model('Fund', Fund);
 
-};
+};