@dhyasama/totem-models 12.3.0 → 12.5.0

package/helpers.js

@@ -134,16 +134,3 @@ const getPeopleSources = module.exports.getPeopleSources = function getPeopleSou
 
 };
 
-const sortPeopleSources = module.exports.sortPeopleSources = function sortPeopleSources(items, customerId) {
-
-  items = _.sortBy(items, function(item) {
-    return item.interactionsCount(customerId);
-  });
-
-  items.reverse();
-
-  items = _.sortBy(items, 'name.full');
-
-  return items;
-
-};

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 },
@@ -95,97 +95,87 @@ module.exports = function(mongoose, config) {
 
   Account.statics.findByEmail = function(email, options, cb) {
 
-    let self = this;
-
-    if (!cb) { throw new Error('cb is required'); }
-    if (!email) { return cb(new Error('email is required'), null); }
+    const run = async () => {
+      if (!email) { throw new Error('email is required'); }
 
-    options = helpers.getDefaultOptions(options);
+      options = helpers.getDefaultOptions(options);
 
-    let query = { email: email.toLowerCase() };
+      let query = { email: email.toLowerCase() };
 
-    if (options.current !== undefined || options.customerId !== undefined) {
+      if (options.current !== undefined || options.customerId !== undefined) {
 
-      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 (options.current !== undefined) { query.current = options.current; }
+        if (options.customerId !== undefined) { query.org = options.customerId; }
 
-          if (account.populated('person')) {
+        const account = await this.findOne(query).populate('person').lean({ virtuals: true });
+        if (!account) { return 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 account;
 
-    }
+      }
 
-    else {
+      else {
 
-      self
-        .find(query)
-        .populate({
+        const result = await this.find(query).populate({
           path: 'org',
           select: 'name'
-        })
-        .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+        }).lean({ virtuals: true });
+        return result;
 
-    }
+      }
+    };
+
+    if (typeof cb === 'function') { run().then(result => cb(null, result)).catch(cb); return; }
+    else { return run(); }
 
   };
 
   Account.statics.findByEmails = function(emails, cb) {
 
-    let self = this;
-
-    if (!cb) { throw new Error('cb is required'); }
-    if (!emails) { return cb(new Error('email is required'), null); }
+    const run = async () => {
+      if (!emails) { throw new Error('email is required'); }
 
-    self
-      .find({ 'email': { $in : emails }})
-      .populate('person')
-      .exec().then(function(accounts) {
-      if (!accounts) { return cb(null, null); }
+      const accounts = await this.find({ 'email': { $in : emails }}).populate('person').lean({ virtuals: true });
+      if (!accounts) { return null; }
 
-        _.each(accounts, function(account) {
+      _.each(accounts, function(account) {
 
-          if (account.populated('person')) {
+        if (account.populated('person')) {
 
-            if (account.org) { helpers.cleanPerson(account.person, account.org); }
-            else { account.person.sources = []; }
+          if (account.org) { helpers.cleanPerson(account.person, account.org); }
+          else { account.person.sources = []; }
 
-          }
+        }
 
-        });
+      });
 
-        return cb(null, accounts);
+      return accounts;
+    };
 
-      }).catch(function(err) { cb(err); });
+    if (typeof cb === 'function') { run().then(result => cb(null, result)).catch(cb); return; }
+    else { return run(); }
 
   };
 
   Account.statics.getById = function (id, cb) {
 
-    const self = this;
-
-    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 run = async () => {
+      if (!id) { throw new Error('id is required'); }
+      if (!mongoose.Types.ObjectId.isValid(id)) { throw new Error('id is not a valid ObjectId'); }
 
-    let query = self.findById(id);
+      let query = this.findById(id);
 
-    query.populate('person');
-    query.populate('org');
+      query.populate('person');
+      query.populate('org');
 
-    query.exec().then(function(account) {
+      const account = await query.lean({ virtuals: true });
       if (account && account.populated('person') && account.populated('org')) {
 
         // Scrub customer info before returning
@@ -196,23 +186,25 @@ module.exports = function(mongoose, config) {
 
         if (account.populated('person')) { helpers.cleanPerson(account.person, customerId); }
 
-        return cb(null, account);
+        return account;
 
       }
       else if (!account) {
-        return cb(new Error('No account with id ' + id.toString()), null);
+        throw new Error('No account with id ' + id.toString());
       }
       else if (account && !account.person) {
-        return cb(new Error('Missing person reference on account with id ' + id.toString()), null);
+        throw new Error('Missing person reference on account with id ' + id.toString());
       }
       else if (account && !account.org) {
-        return cb(new Error('Missing org reference on account with id ' + id.toString()), null);
+        throw new Error('Missing org reference on account with id ' + id.toString());
       }
       else {
-        return cb(new Error('Unknown error'), null);
+        throw new Error('Unknown error');
       }
+    };
 
-    }).catch(function(err) { cb(err); });
+    if (typeof cb === 'function') { run().then(result => cb(null, result)).catch(cb); return; }
+    else { return run(); }
 
   };
 
@@ -220,75 +212,79 @@ module.exports = function(mongoose, config) {
 
     // No population so no need to scrub
 
-    const self = this;
+    const run = async () => {
+      if (!customerId) { throw new Error('customerId is required'); }
+      if (!mongoose.Types.ObjectId.isValid(customerId)) { throw new Error('customerId is not a valid ObjectId'); }
 
-    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); }
+      const result = await this.find({ 'org': customerId }).lean({ virtuals: true });
+      return result;
+    };
 
-    self
-      .find({ 'org': customerId })
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    if (typeof cb === 'function') { run().then(result => cb(null, result)).catch(cb); return; }
+    else { return run(); }
 
   };
 
   Account.statics.updateCurrent = 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;
+    const run = async () => {
+      if (!email) { throw new Error('email is required'); }
+      if (!customerId) { throw new Error('customerId is required'); }
+      if (!mongoose.Types.ObjectId.isValid(customerId)) { throw new Error('customerId is not a valid ObjectId'); }
 
-    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); });
+      await this.updateMany({ email: email }, { $set: { current: false } });
+      const res = await this.updateOne({ email: email, org: customerId }, { $set: { current: true } });
+      return res;
+    };
 
-    }).catch(function(err) { cb(err); });
+    if (typeof cb === 'function') { run().then(result => cb(null, result)).catch(cb); return; }
+    else { return run(); }
 
   };
 
   Account.statics.updateOrg = 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 run = async () => {
+      if (!email) { throw new Error('email is required'); }
+      if (!customerId) { throw new Error('customerId is required'); }
+      if (!mongoose.Types.ObjectId.isValid(customerId)) { throw new Error('customerId is not a valid ObjectId'); }
 
-    const self = this;
-      
-    self.updateOne({ email: email }, { $set: { org: customerId } }).then(function(res) {cb(null, res);
-    
-    }).catch(function(err) { cb(err); });
+      const res = await this.updateOne({ email: email }, { $set: { org: customerId } });
+      return res;
+    };
+
+    if (typeof cb === 'function') { run().then(result => cb(null, result)).catch(cb); return; }
+    else { return run(); }
 
   };
 
   Account.statics.listAdminAccounts = function (options, cb) {
 
-    const self = this;
-
-    if (!cb) { throw new Error('cb is required'); }
+    const run = async () => {
+      const result = await this.find({ 'active': true, 'role': 'admin' }).lean({ virtuals: true });
+      return result;
+    };
 
-    self
-      .find({ 'active': true, 'role': 'admin' })
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    if (typeof cb === 'function') { run().then(result => cb(null, result)).catch(cb); return; }
+    else { return run(); }
 
   };
 
   Account.statics.listSummaryAccounts = function (options, cb) {
 
-    const self = this;
+    const run = async () => {
+      let queryObj = { 'active': true, 'summary.active': true };
 
-    if (!cb) { throw new Error('cb is required'); }
+      if (options.CUSTOMER_ID) {
+        queryObj['org'] = options.CUSTOMER_ID;
+      }
 
-    let queryObj = { 'active': true, 'summary.active': true };
+      const result = await this.find(queryObj).lean({ virtuals: true });
+      return result;
+    };
 
-    if (options.CUSTOMER_ID) {
-      queryObj['org'] = options.CUSTOMER_ID;
-    }
-
-    self.find(queryObj).exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    if (typeof cb === 'function') { run().then(result => cb(null, result)).catch(cb); return; }
+    else { return run(); }
 
   };
 
@@ -297,36 +293,33 @@ module.exports = function(mongoose, config) {
     // This is only for worker
     // Since it's only worker, no need to scrub results
 
-    const self = this;
+    const run = async () => {
+      options = helpers.getDefaultOptions(options);
 
-    if (!cb) { throw new Error('cb is required'); }
+      if (!options.isWorkerProcess) { return []; }
 
-    options = helpers.getDefaultOptions(options);
+      const result = await this.find({'active': true}).populate('person').sort({'person.name.last': 1}).lean({ virtuals: true });
+      return result;
+    };
 
-    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); });
+    if (typeof cb === 'function') { run().then(result => cb(null, result)).catch(cb); return; }
+    else { return run(); }
 
   };
 
   Account.statics.listAllAccountsSkinny = function (options, cb) {
 
-    const self = this;
-
-    if (!cb) { throw new Error('cb is required'); }
+    const run = async () => {
+      options = helpers.getDefaultOptions(options);
 
-    options = helpers.getDefaultOptions(options);
+      if (!options.isWorkerProcess) { return []; }
 
-    if (!options.isWorkerProcess) { return cb(null, []); }
+      const result = await this.find({'active': true}).select('active email auth').lean({ virtuals: true });
+      return result;
+    };
 
-    self
-      .find({'active': true})
-      .select('active email auth')
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    if (typeof cb === 'function') { run().then(result => cb(null, result)).catch(cb); return; }
+    else { return run(); }
 
   };
 
@@ -335,22 +328,22 @@ module.exports = function(mongoose, config) {
     // 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);
+    const run = async () => {
+      options = helpers.getDefaultOptions(options);
 
-    if (!options.isWorkerProcess) { return cb(null, []); }
+      if (!options.isWorkerProcess) { return []; }
 
-    self
-      .find({
+      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); });
+      }).lean({ virtuals: true });
+      return result;
+    };
+
+    if (typeof cb === 'function') { run().then(result => cb(null, result)).catch(cb); return; }
+    else { return run(); }
 
   };
 
@@ -359,34 +352,37 @@ module.exports = function(mongoose, config) {
     // 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'); }
+    const run = async () => {
+      options = helpers.getDefaultOptions(options);
 
-    options = helpers.getDefaultOptions(options);
+      if (!options.isWorkerProcess) { return []; }
 
-    if (!options.isWorkerProcess) { return cb(null, []); }
-
-    self
-      .find({
+      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); });
+      }).lean({ virtuals: true });
+      return result;
+    };
+
+    if (typeof cb === 'function') { run().then(result => cb(null, result)).catch(cb); return; }
+    else { return run(); }
 
   };
 
   Account.statics.delete = function (id, options, cb) {
 
-    const self = this;
+    const run = async () => {
+      if (!id) { throw new Error('id is required'); }
+      if (!mongoose.Types.ObjectId.isValid(id)) { throw new Error('id is not a valid ObjectId'); }
 
-    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); }
+      const result = await this.findByIdAndDelete(id);
+      return result;
+    };
 
-    self.findByIdAndDelete(id).then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    if (typeof cb === 'function') { run().then(result => cb(null, result)).catch(cb); return; }
+    else { return run(); }
 
   };
 
@@ -394,7 +390,13 @@ module.exports = function(mongoose, config) {
 
     // No population so no need to scrub
 
-    account.save().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    const run = async () => {
+      const result = await account.save();
+      return result;
+    };
+
+    if (typeof cb === 'function') { run().then(result => cb(null, result)).catch(cb); return; }
+    else { return run(); }
 
   };
   Account.set('autoIndex', false);

package/lib/Activity.js

@@ -42,15 +42,14 @@ module.exports = function(mongoose, config) {
 
   Activity.statics.add = function(username, type, remoteAddress, url, filename, callback) {
 
-    const self = this;
+    const run = async () => {
+      if (!username) throw new Error('username is required');
+      if (!type) throw new Error('type is required');
 
-    if (!username) throw new Error('username is required');
-    if (!type) throw new Error('type is required');
-    if (!callback) throw new Error('callback is required');
+      username = username.toLowerCase();
 
-    username = username.toLowerCase();
-
-    self.findOne({ 'username': username }).then(function(activity) {if (!activity) {
+      let activity = await this.findOne({ 'username': username });
+      if (!activity) {
         const A = mongoose.model('Activity');
         activity = new A();
         activity.username = username;
@@ -71,29 +70,44 @@ 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 item;
       }
       else {
-        return callback(null, null);
+        return null;
       }
+    };
 
-    }).catch(function(err) { callback(err); });
+    if (typeof callback === 'function') { run().then(result => callback(null, result)).catch(callback); }
+    else { return run(); }
 
   };
 
   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); });
+
+    const run = async () => {
+      const result = await this.find({ 'username': username.toLowerCase(), 'items.document.messageId': messageId }).lean({ virtuals: true });
+      return result;
+    };
+
+    if (typeof cb === 'function') { run().then(result => cb(null, result)).catch(cb); return; }
+    else { return run(); }
+
   };
 
   Activity.statics.list = function(username, maxItems, cb) {
 
-    var query = this.findOne({ 'username': username.toLowerCase() });
+    const run = async () => {
+      var query = this.findOne({ 'username': username.toLowerCase() });
+
+      if (maxItems && maxItems >= 1) { query = query.slice('items', maxItems); }
 
-    if (maxItems && maxItems >= 1) { query = query.slice('items', maxItems); }
+      const result = await query.lean({ virtuals: true });
+      return result;
+    };
 
-    query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    if (typeof cb === 'function') { run().then(result => cb(null, result)).catch(cb); return; }
+    else { return run(); }
 
   };
   Activity.set('autoIndex', false);

package/lib/ApiKey.js

@@ -20,44 +20,47 @@ module.exports = function(mongoose, config) {
 
   ApiKey.statics.getByTokenHash = function(hash, cb) {
 
-    var self = this;
+    const run = async () => {
+      if (!hash) { throw new Error('hash is required'); }
 
-    if (!cb) { throw new Error('cb is required'); }
-    if (!hash) { return cb(new Error('hash is required'), null); }
+      const result = await this.findOne({ tokenHash: hash }).lean({ virtuals: true });
+      return result;
+    };
 
-    self
-      .findOne({ tokenHash: hash })
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    if (typeof cb === 'function') { run().then(result => cb(null, result)).catch(cb); return; }
+    else { return run(); }
 
   };
 
   ApiKey.statics.getByAccount = function(accountId, customerId, cb) {
 
-    var self = this;
+    const run = async () => {
+      if (!accountId) { throw new Error('accountId is required'); }
+      if (!customerId) { throw new Error('customerId is required'); }
 
-    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); }
+      const result = await this.find({ account: accountId, customer: customerId, active: true }).sort({ createdOn: -1 }).select('scopes createdOn lastUsedOn').lean({ virtuals: true });
+      return result;
+    };
 
-    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); });
+    if (typeof cb === 'function') { run().then(result => cb(null, result)).catch(cb); return; }
+    else { return run(); }
 
   };
 
   ApiKey.statics.revoke = function(tokenId, accountId, customerId, cb) {
 
-    var self = this;
+    const run = async () => {
+      if (!tokenId) { throw new Error('tokenId is required'); }
 
-    if (!cb) { throw new Error('cb is required'); }
-    if (!tokenId) { return cb(new Error('tokenId is required'), null); }
+      const result = await this.findOneAndUpdate(
+        { _id: tokenId, account: accountId, customer: customerId },
+        { active: false },
+        { new: true });
+      return result;
+    };
 
-    self.findOneAndUpdate(
-      { _id: tokenId, account: accountId, customer: customerId },
-      { active: false },
-      { new: true }).then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    if (typeof cb === 'function') { run().then(result => cb(null, result)).catch(cb); return; }
+    else { return run(); }
 
   };
   ApiKey.set('autoIndex', false);