@dhyasama/totem-models 12.4.0 → 12.6.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

@@ -93,66 +93,61 @@ module.exports = function(mongoose, config) {
     return self.totemLive && self.totemLive.sheetsUser;
   });
 
-  Account.statics.findByEmail = async function(email, options, cb) {
+  Account.statics.findByEmail = function(email, options, cb) {
 
-    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; }
+        if (options.current !== undefined) { query.current = options.current; }
+        if (options.customerId !== undefined) { query.org = options.customerId; }
 
-      try {
-        const account = await this.findOne(query).populate('person');
-        if (!account) { return cb(null, null); }
+        const account = await this.findOne(query).populate('person').lean({ virtuals: true });
+        if (!account) { return null; }
 
-        if (account.populated('person')) {
+        if (account.person && typeof account.person === 'object') {
 
           if (account.org) { helpers.cleanPerson(account.person, account.org); }
           else { account.person.sources = []; }
 
         }
 
-        return cb(null, account);
-      } catch(err) {
-        return cb(err);
-      }
+        return account;
 
-    }
+      }
 
-    else {
+      else {
 
-      try {
         const result = await this.find(query).populate({
           path: 'org',
           select: 'name'
-        });
-        return cb(null, result);
-      } catch(err) {
-        return 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 = async function(emails, cb) {
+  Account.statics.findByEmails = function(emails, cb) {
 
-    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'); }
 
-    try {
-      const accounts = await this.find({ 'email': { $in : emails }}).populate('person');
-      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) {
 
-        if (account.populated('person')) {
+        if (account.person && typeof account.person === 'object') {
 
           if (account.org) { helpers.cleanPerson(account.person, account.org); }
           else { account.person.sources = []; }
@@ -161,251 +156,247 @@ module.exports = function(mongoose, config) {
 
       });
 
-      return cb(null, accounts);
-    } catch(err) {
-      return cb(err);
-    }
+      return accounts;
+    };
+
+    if (typeof cb === 'function') { run().then(result => cb(null, result)).catch(cb); return; }
+    else { return run(); }
 
   };
 
-  Account.statics.getById = async function (id, cb) {
+  Account.statics.getById = 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 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 = this.findById(id);
+      let query = this.findById(id);
 
-    query.populate('person');
-    query.populate('org');
+      query.populate('person');
+      query.populate('org');
 
-    try {
-      const account = await query;
-      if (account && account.populated('person') && account.populated('org')) {
+      const account = await query.lean({ virtuals: true });
+      if (account && account.person && typeof account.person === 'object' && account.org && typeof account.org === 'object') {
 
         // Scrub customer info before returning
 
-        let customerId = account.populated('org');
+        let customerId = account.org._id;
 
-        if (account.populated('org')) { helpers.cleanOrg(account.org, customerId); }
+        if (account.org && typeof account.org === 'object') { helpers.cleanOrg(account.org, customerId); }
 
-        if (account.populated('person')) { helpers.cleanPerson(account.person, customerId); }
+        if (account.person && typeof account.person === 'object') { 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(err) {
-      return cb(err);
-    }
+    };
+
+    if (typeof cb === 'function') { run().then(result => cb(null, result)).catch(cb); return; }
+    else { return run(); }
 
   };
 
-  Account.statics.getForCustomer = async function (customerId, cb) {
+  Account.statics.getForCustomer = function (customerId, cb) {
 
     // No population so no need to scrub
 
-    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 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'); }
 
-    try {
-      const result = await this.find({ 'org': customerId });
-      return cb(null, result);
-    } catch(err) {
-      return cb(err);
-    }
+      const result = await this.find({ 'org': customerId }).lean({ virtuals: true });
+      return result;
+    };
+
+    if (typeof cb === 'function') { run().then(result => cb(null, result)).catch(cb); return; }
+    else { return run(); }
 
   };
 
-  Account.statics.updateCurrent = async function(email, customerId, cb) {
+  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 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'); }
 
-    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);
-    }
+      return res;
+    };
+
+    if (typeof cb === 'function') { run().then(result => cb(null, result)).catch(cb); return; }
+    else { return run(); }
 
   };
 
-  Account.statics.updateOrg = async function(email, customerId, cb) {
+  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'); }
 
-    try {
       const res = await this.updateOne({ email: email }, { $set: { org: customerId } });
-      return cb(null, res);
-    } catch(err) {
-      return cb(err);
-    }
+      return res;
+    };
+
+    if (typeof cb === 'function') { run().then(result => cb(null, result)).catch(cb); return; }
+    else { return run(); }
 
   };
 
-  Account.statics.listAdminAccounts = async function (options, cb) {
+  Account.statics.listAdminAccounts = function (options, cb) {
 
-    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;
+    };
 
-    try {
-      const result = await this.find({ 'active': true, 'role': 'admin' });
-      return cb(null, result);
-    } catch(err) {
-      return cb(err);
-    }
+    if (typeof cb === 'function') { run().then(result => cb(null, result)).catch(cb); return; }
+    else { return run(); }
 
   };
 
-  Account.statics.listSummaryAccounts = async function (options, cb) {
+  Account.statics.listSummaryAccounts = function (options, cb) {
 
-    if (!cb) { throw new Error('cb is required'); }
+    const run = async () => {
+      let queryObj = { 'active': true, 'summary.active': true };
 
-    let queryObj = { 'active': true, 'summary.active': true };
+      if (options.CUSTOMER_ID) {
+        queryObj['org'] = options.CUSTOMER_ID;
+      }
 
-    if (options.CUSTOMER_ID) {
-      queryObj['org'] = options.CUSTOMER_ID;
-    }
+      const result = await this.find(queryObj).lean({ virtuals: true });
+      return result;
+    };
 
-    try {
-      const result = await this.find(queryObj);
-      return cb(null, result);
-    } catch(err) {
-      return cb(err);
-    }
+    if (typeof cb === 'function') { run().then(result => cb(null, result)).catch(cb); return; }
+    else { return run(); }
 
   };
 
-  Account.statics.listAllAccounts = async function (options, cb) {
+  Account.statics.listAllAccounts = function (options, cb) {
 
     // This is only for worker
     // Since it's only worker, no need to scrub results
 
-    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}).populate('person').sort({'person.name.last': 1}).lean({ virtuals: true });
+      return result;
+    };
 
-    try {
-      const result = await this.find({'active': true}).populate('person').sort({'person.name.last': 1});
-      return cb(null, result);
-    } catch(err) {
-      return cb(err);
-    }
+    if (typeof cb === 'function') { run().then(result => cb(null, result)).catch(cb); return; }
+    else { return run(); }
 
   };
 
-  Account.statics.listAllAccountsSkinny = async function (options, cb) {
+  Account.statics.listAllAccountsSkinny = function (options, cb) {
 
-    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;
+    };
 
-    try {
-      const result = await this.find({'active': true}).select('active email auth');
-      return cb(null, result);
-    } catch(err) {
-      return cb(err);
-    }
+    if (typeof cb === 'function') { run().then(result => cb(null, result)).catch(cb); return; }
+    else { return run(); }
 
   };
 
-  Account.statics.listGoogleAccounts = async function(options, cb) {
+  Account.statics.listGoogleAccounts = function(options, cb) {
 
     // This is only for worker
     // Since it's only worker, no need to scrub results
 
-    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, []); }
-
-    try {
       const result = await this.find({
         'active': true,
         'calendar.active': true,
         'auth.strategy': 'google',
         'auth.google.refreshToken': { $ne: null }
-      });
-      return cb(null, result);
-    } catch(err) {
-      return 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.listMicrosoftAccounts = async function(options, cb) {
+  Account.statics.listMicrosoftAccounts = function(options, cb) {
 
     // This is only for worker
     // Since it's only worker, no need to scrub results
 
-    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, []); }
-
-    try {
       const result = await this.find({
         'active': true,
         'calendar.active': true,
         'auth.strategy': 'microsoft',
         'auth.microsoft.refreshToken': { $ne: null }
-      });
-      return cb(null, result);
-    } catch(err) {
-      return 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 = async function (id, options, cb) {
+  Account.statics.delete = 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); }
+    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'); }
 
-    try {
       const result = await this.findByIdAndDelete(id);
-      return cb(null, result);
-    } catch(err) {
-      return cb(err);
-    }
+      return result;
+    };
+
+    if (typeof cb === 'function') { run().then(result => cb(null, result)).catch(cb); return; }
+    else { return run(); }
 
   };
 
-  Account.statics.upsert = async function(account, cb) {
+  Account.statics.upsert = function(account, cb) {
 
     // No population so no need to scrub
 
-    try {
+    const run = async () => {
       const result = await account.save();
-      return cb(null, result);
-    } catch(err) {
-      return cb(err);
-    }
+      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

@@ -40,15 +40,14 @@ module.exports = function(mongoose, config) {
 
   });
 
-  Activity.statics.add = async function(username, type, remoteAddress, url, filename, callback) {
+  Activity.statics.add = function(username, type, remoteAddress, url, filename, callback) {
 
-    if (!username) throw new Error('username is required');
-    if (!type) throw new Error('type is required');
-    if (!callback) throw new Error('callback is required');
+    const run = async () => {
+      if (!username) throw new Error('username is required');
+      if (!type) throw new Error('type is required');
 
-    username = username.toLowerCase();
+      username = username.toLowerCase();
 
-    try {
       let activity = await this.findOne({ 'username': username });
       if (!activity) {
         const A = mongoose.model('Activity');
@@ -72,38 +71,43 @@ module.exports = function(mongoose, config) {
       if (activity) {
         activity.items.unshift(item);
         await activity.save();
-        return callback(null, item);
+        return item;
       }
       else {
-        return callback(null, null);
+        return null;
       }
-    } catch(err) {
-      return callback(err);
-    }
+    };
+
+    if (typeof callback === 'function') { run().then(result => callback(null, result)).catch(callback); }
+    else { return run(); }
 
   };
 
-  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.forMessage = function(username, messageId, cb) {
+
+    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 = async function(username, maxItems, cb) {
+  Activity.statics.list = function(username, maxItems, cb) {
+
+    const run = async () => {
+      var query = this.findOne({ 'username': username.toLowerCase() });
 
-    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;
+    };
 
-    try {
-      const result = await query;
-      return cb(null, result);
-    } catch(err) {
-      return 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

@@ -18,49 +18,49 @@ module.exports = function(mongoose, config) {
   ApiKey.index({ customer: 1, account: 1 });
   ApiKey.index({ tokenHash: 1 });
 
-  ApiKey.statics.getByTokenHash = async function(hash, cb) {
+  ApiKey.statics.getByTokenHash = function(hash, cb) {
 
-    if (!cb) { throw new Error('cb is required'); }
-    if (!hash) { return cb(new Error('hash is required'), null); }
+    const run = async () => {
+      if (!hash) { throw new Error('hash is required'); }
 
-    try {
-      const result = await this.findOne({ tokenHash: hash });
-      return cb(null, result);
-    } catch(err) {
-      return cb(err);
-    }
+      const result = await this.findOne({ tokenHash: hash }).lean({ virtuals: true });
+      return result;
+    };
+
+    if (typeof cb === 'function') { run().then(result => cb(null, result)).catch(cb); return; }
+    else { return run(); }
 
   };
 
-  ApiKey.statics.getByAccount = async function(accountId, customerId, cb) {
+  ApiKey.statics.getByAccount = function(accountId, customerId, cb) {
+
+    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;
+    };
 
-    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);
-    }
+    if (typeof cb === 'function') { run().then(result => cb(null, result)).catch(cb); return; }
+    else { return run(); }
 
   };
 
-  ApiKey.statics.revoke = async function(tokenId, accountId, customerId, cb) {
+  ApiKey.statics.revoke = function(tokenId, accountId, customerId, cb) {
 
-    if (!cb) { throw new Error('cb is required'); }
-    if (!tokenId) { return cb(new Error('tokenId is required'), null); }
+    const run = async () => {
+      if (!tokenId) { throw new Error('tokenId is required'); }
 
-    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);
-    }
+      return result;
+    };
+
+    if (typeof cb === 'function') { run().then(result => cb(null, result)).catch(cb); return; }
+    else { return run(); }
 
   };
   ApiKey.set('autoIndex', false);