@dhyasama/totem-models 12.2.0 → 12.4.0

package/lib/Account.js

@@ -21,7 +21,7 @@ module.exports = function(mongoose, config) {
     permissions: { type: Array, default: [] },
 
     funds: [ { type: Schema.ObjectId, ref: 'Fund' } ],
-    
+
     totemLive: {
       excelUser: { type: Boolean, default: true },
       sheetsUser: { type: Boolean, default: true },
@@ -93,9 +93,7 @@ module.exports = function(mongoose, config) {
     return self.totemLive && self.totemLive.sheetsUser;
   });
 
-  Account.statics.findByEmail = function(email, options, cb) {
-
-    let self = this;
+  Account.statics.findByEmail = async function(email, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!email) { return cb(new Error('email is required'), null); }
@@ -108,84 +106,81 @@ module.exports = function(mongoose, config) {
 
       if (options.current !== undefined) { query.current = options.current; }
       if (options.customerId !== undefined) { query.org = options.customerId; }
-        
-      self
-        .findOne(query)
-        .populate('person')
-        .exec().then(function(account) {
-      if (!account) { return cb(null, null); }
 
-          if (account.populated('person')) {
+      try {
+        const account = await this.findOne(query).populate('person');
+        if (!account) { return cb(null, null); }
 
-            if (account.org) { helpers.cleanPerson(account.person, account.org); }
-            else { account.person.sources = []; }
+        if (account.populated('person')) {
 
-          }
+          if (account.org) { helpers.cleanPerson(account.person, account.org); }
+          else { account.person.sources = []; }
 
-          return cb(null, account);
+        }
 
-        }).catch(function(err) { cb(err); });
+        return cb(null, account);
+      } catch(err) {
+        return cb(err);
+      }
 
     }
 
     else {
 
-      self
-        .find(query)
-        .populate({
+      try {
+        const result = await this.find(query).populate({
           path: 'org',
           select: 'name'
-        })
-        .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+        });
+        return cb(null, result);
+      } catch(err) {
+        return cb(err);
+      }
 
     }
 
   };
 
-  Account.statics.findByEmails = function(emails, cb) {
-
-    let self = this;
+  Account.statics.findByEmails = async function(emails, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!emails) { return cb(new Error('email is required'), null); }
 
-    self
-      .find({ 'email': { $in : emails }})
-      .populate('person')
-      .exec().then(function(accounts) {
+    try {
+      const accounts = await this.find({ 'email': { $in : emails }}).populate('person');
       if (!accounts) { return cb(null, null); }
 
-        _.each(accounts, function(account) {
-
-          if (account.populated('person')) {
+      _.each(accounts, function(account) {
 
-            if (account.org) { helpers.cleanPerson(account.person, account.org); }
-            else { account.person.sources = []; }
+        if (account.populated('person')) {
 
-          }
+          if (account.org) { helpers.cleanPerson(account.person, account.org); }
+          else { account.person.sources = []; }
 
-        });
+        }
 
-        return cb(null, accounts);
+      });
 
-      }).catch(function(err) { cb(err); });
+      return cb(null, accounts);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Account.statics.getById = function (id, cb) {
-
-    const self = this;
+  Account.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); }
 
-    let query = self.findById(id);
+    let query = this.findById(id);
 
     query.populate('person');
     query.populate('org');
 
-    query.exec().then(function(account) {
+    try {
+      const account = await query;
       if (account && account.populated('person') && account.populated('org')) {
 
         // Scrub customer info before returning
@@ -211,74 +206,76 @@ module.exports = function(mongoose, config) {
       else {
         return cb(new Error('Unknown error'), null);
       }
-
-    }).catch(function(err) { cb(err); });
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Account.statics.getForCustomer = function (customerId, cb) {
+  Account.statics.getForCustomer = async function (customerId, cb) {
 
     // No population so no need to scrub
 
-    const self = this;
-
     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); }
 
-    self
-      .find({ 'org': customerId })
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.find({ 'org': customerId });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Account.statics.updateCurrent = function(email, customerId, cb) {
+  Account.statics.updateCurrent = async function(email, customerId, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!email) { return cb(new Error('email is required'), null); }
     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;
-
-    self.updateMany({ email: email }, { $set: { current: false } }).then(function(res) {self.updateOne({ email: email, org: customerId }, { $set: { current: true } }).then(function(res) {cb(null, res);
-      
-      }).catch(function(err) { cb(err); });
-
-    }).catch(function(err) { cb(err); });
+    try {
+      await this.updateMany({ email: email }, { $set: { current: false } });
+      const res = await this.updateOne({ email: email, org: customerId }, { $set: { current: true } });
+      return cb(null, res);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Account.statics.updateOrg = function(email, customerId, cb) {
+  Account.statics.updateOrg = async function(email, customerId, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!email) { return cb(new Error('email is required'), null); }
     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;
-      
-    self.updateOne({ email: email }, { $set: { org: customerId } }).then(function(res) {cb(null, res);
-    
-    }).catch(function(err) { cb(err); });
+    try {
+      const res = await this.updateOne({ email: email }, { $set: { org: customerId } });
+      return cb(null, res);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Account.statics.listAdminAccounts = function (options, cb) {
-
-    const self = this;
+  Account.statics.listAdminAccounts = async function (options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
 
-    self
-      .find({ 'active': true, 'role': 'admin' })
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.find({ 'active': true, 'role': 'admin' });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Account.statics.listSummaryAccounts = function (options, cb) {
-
-    const self = this;
+  Account.statics.listSummaryAccounts = async function (options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
 
@@ -288,34 +285,36 @@ module.exports = function(mongoose, config) {
       queryObj['org'] = options.CUSTOMER_ID;
     }
 
-    self.find(queryObj).exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.find(queryObj);
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Account.statics.listAllAccounts = function (options, cb) {
+  Account.statics.listAllAccounts = async function (options, cb) {
 
     // This is only for worker
     // Since it's only worker, no need to scrub results
 
-    const self = this;
-
     if (!cb) { throw new Error('cb is required'); }
 
     options = helpers.getDefaultOptions(options);
 
     if (!options.isWorkerProcess) { return cb(null, []); }
 
-    self
-      .find({'active': true})
-      .populate('person')
-      .sort({'person.name.last': 1})
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.find({'active': true}).populate('person').sort({'person.name.last': 1});
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Account.statics.listAllAccountsSkinny = function (options, cb) {
-
-    const self = this;
+  Account.statics.listAllAccountsSkinny = async function (options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
 
@@ -323,78 +322,90 @@ module.exports = function(mongoose, config) {
 
     if (!options.isWorkerProcess) { return cb(null, []); }
 
-    self
-      .find({'active': true})
-      .select('active email auth')
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.find({'active': true}).select('active email auth');
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Account.statics.listGoogleAccounts = function(options, cb) {
+  Account.statics.listGoogleAccounts = async function(options, cb) {
 
     // This is only for worker
     // Since it's only worker, no need to scrub results
 
-    const self = this;
-
     if (!cb) { throw new Error('cb is required'); }
 
     options = helpers.getDefaultOptions(options);
 
     if (!options.isWorkerProcess) { return cb(null, []); }
 
-    self
-      .find({
+    try {
+      const result = await this.find({
         'active': true,
         'calendar.active': true,
         'auth.strategy': 'google',
         'auth.google.refreshToken': { $ne: null }
-      })
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+      });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Account.statics.listMicrosoftAccounts = function(options, cb) {
+  Account.statics.listMicrosoftAccounts = async function(options, cb) {
 
     // This is only for worker
     // Since it's only worker, no need to scrub results
 
-    const self = this;
-
     if (!cb) { throw new Error('cb is required'); }
 
     options = helpers.getDefaultOptions(options);
 
     if (!options.isWorkerProcess) { return cb(null, []); }
 
-    self
-      .find({
+    try {
+      const result = await this.find({
         'active': true,
         'calendar.active': true,
         'auth.strategy': 'microsoft',
         'auth.microsoft.refreshToken': { $ne: null }
-      })
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+      });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Account.statics.delete = function (id, options, cb) {
-
-    const self = this;
+  Account.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);
+    }
 
   };
 
-  Account.statics.upsert = function(account, cb) {
+  Account.statics.upsert = async function(account, cb) {
 
     // No population so no need to scrub
 
-    account.save().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await account.save();
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
   Account.set('autoIndex', false);

package/lib/Activity.js

@@ -40,9 +40,7 @@ module.exports = function(mongoose, config) {
 
   });
 
-  Activity.statics.add = function(username, type, remoteAddress, url, filename, callback) {
-
-    const self = this;
+  Activity.statics.add = async function(username, type, remoteAddress, url, filename, callback) {
 
     if (!username) throw new Error('username is required');
     if (!type) throw new Error('type is required');
@@ -50,7 +48,9 @@ module.exports = function(mongoose, config) {
 
     username = username.toLowerCase();
 
-    self.findOne({ 'username': username }).then(function(activity) {if (!activity) {
+    try {
+      let activity = await this.findOne({ 'username': username });
+      if (!activity) {
         const A = mongoose.model('Activity');
         activity = new A();
         activity.username = username;
@@ -71,29 +71,39 @@ module.exports = function(mongoose, config) {
 
       if (activity) {
         activity.items.unshift(item);
-        activity.save().then(function(result) {
-          return callback(null, item);
-        }).catch(function(err) { callback(err); });
+        await activity.save();
+        return callback(null, item);
       }
       else {
         return callback(null, null);
       }
-
-    }).catch(function(err) { callback(err); });
+    } catch(err) {
+      return callback(err);
+    }
 
   };
 
-  Activity.statics.forMessage = function(username, messageId, cb) {
-    this.find({ 'username': username.toLowerCase(), 'items.document.messageId': messageId }).then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+  Activity.statics.forMessage = async function(username, messageId, cb) {
+    try {
+      const result = await this.find({ 'username': username.toLowerCase(), 'items.document.messageId': messageId });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
   };
 
-  Activity.statics.list = function(username, maxItems, cb) {
+  Activity.statics.list = async function(username, maxItems, cb) {
 
     var query = this.findOne({ 'username': username.toLowerCase() });
 
     if (maxItems && maxItems >= 1) { query = query.slice('items', maxItems); }
 
-    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);
+    }
 
   };
   Activity.set('autoIndex', false);

package/lib/ApiKey.js

@@ -18,46 +18,49 @@ module.exports = function(mongoose, config) {
   ApiKey.index({ customer: 1, account: 1 });
   ApiKey.index({ tokenHash: 1 });
 
-  ApiKey.statics.getByTokenHash = function(hash, cb) {
-
-    var self = this;
+  ApiKey.statics.getByTokenHash = async function(hash, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!hash) { return cb(new Error('hash is required'), null); }
 
-    self
-      .findOne({ tokenHash: hash })
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.findOne({ tokenHash: hash });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  ApiKey.statics.getByAccount = function(accountId, customerId, cb) {
-
-    var self = this;
+  ApiKey.statics.getByAccount = async function(accountId, customerId, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!accountId) { return cb(new Error('accountId is required'), null); }
     if (!customerId) { return cb(new Error('customerId is required'), null); }
 
-    self
-      .find({ account: accountId, customer: customerId, active: true })
-      .sort({ createdOn: -1 })
-      .select('scopes createdOn lastUsedOn')
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.find({ account: accountId, customer: customerId, active: true }).sort({ createdOn: -1 }).select('scopes createdOn lastUsedOn');
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  ApiKey.statics.revoke = function(tokenId, accountId, customerId, cb) {
-
-    var self = this;
+  ApiKey.statics.revoke = async function(tokenId, accountId, customerId, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!tokenId) { return cb(new Error('tokenId is required'), null); }
 
-    self.findOneAndUpdate(
-      { _id: tokenId, account: accountId, customer: customerId },
-      { active: false },
-      { new: true }).then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.findOneAndUpdate(
+        { _id: tokenId, account: accountId, customer: customerId },
+        { active: false },
+        { new: true });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
   ApiKey.set('autoIndex', false);