@dhyasama/totem-models 7.58.0 → 8.0.1

package/.npmignore

@@ -0,0 +1,14 @@
+lib-cov
+*.seed
+*.log
+*.csv
+*.dat
+*.out
+*.pid
+*.gz
+
+npm-debug.log
+node_modules
+
+.DS_Store
+.idea

package/helpers.js

@@ -0,0 +1,89 @@
+'use strict';
+
+const _ = require('underscore');
+const mongoose = require('mongoose');
+
+const cleanOrg = module.exports.cleanOrg = function cleanOrg(doc, customerId) {
+
+  if (!doc) { return; }
+  if (!doc._id) { return; }
+  if (!customerId) { return; }
+  if (!mongoose.Types.ObjectId.isValid(customerId)) { return; }
+
+  // remove customer details if not viewing self
+  if (doc._id.toString() !== customerId.toString()) { doc.customer = {}; }
+
+  doc.lps = _.reject(doc.lps, function(item) { return !item.customer || item.customer.toString() !== customerId.toString(); });
+  doc.filters = _.reject(doc.filters, function(item) { return !item.customer || item.customer.toString() !== customerId.toString(); });
+  doc.valuations = _.reject(doc.valuations, function(item) { return !item.customer || item.customer.toString() !== customerId.toString(); });
+  doc.iLevel = _.reject(doc.iLevel, function(item) { return !item.customer || item.customer.toString() !== customerId.toString(); });
+  doc.chairs = _.reject(doc.chairs, function(item) { return !item.customer || item.customer.toString() !== customerId.toString(); });
+  doc.operating.acquired.private = _.find(doc.operating.acquired.private, function(item) { return !item.customer || item.customer.toString() === customerId.toString(); });
+  doc.operating.closed.private = _.find(doc.operating.closed.private, function(item) { return !item.customer || item.customer.toString() === customerId.toString(); });
+
+  return doc;
+
+};
+
+const cleanPerson = module.exports.cleanPerson = function cleanPerson(doc, customerId) {
+
+  if (!doc) { return; }
+  if (!doc._id) { return; }
+  if (!customerId) { return; }
+  if (!mongoose.Types.ObjectId.isValid(customerId)) { return; }
+
+  doc.sources = _.reject(doc.sources, function(source) {
+    let sourceCustomerId = mongoose.Types.ObjectId.isValid(source.customer) ? source.customer : source.customer._id;
+    return sourceCustomerId.toString() !== customerId.toString();
+  });
+
+  return doc;
+
+};
+
+const getDefaultOptions = module.exports.getDefaultOptions = function getDefaultOptions(options) {
+
+  const DEFAULT_OPTIONS = { isWorkerProcess: false, role: 'none' };
+
+  return _.defaults(options || {}, DEFAULT_OPTIONS);
+
+};
+
+const getPeopleSources = module.exports.getPeopleSources = function getPeopleSources(people) {
+
+  if (!people) { return []; }
+  if (!Array.isArray(people)) { return []; }
+
+  let result = _.compact(_.pluck(people, 'sources'));
+  if (result.length === 0) { return []; }
+
+  result = _.flatten(result);
+  result = _.compact(result);
+
+  if (result.length === 0) { return []; }
+  if (mongoose.Types.ObjectId.isValid(result[0].person)) { return []; } // not populated
+
+  result = _.uniq(result, function(item) {
+    if (!item || !item.person) { return ''; }
+    else return item.person._id ? item.person._id.toString() : '';
+  });
+  result = _.compact(result);
+  result = _.reject(result, function(item) { return !item.person; });
+
+  return result;
+
+};
+
+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/index.js

@@ -64,7 +64,6 @@ var bootstrap = function(mongoose, config) {
   require('./lib/Message.js')(mongoose, config);
   require('./lib/News.js')(mongoose, config);
   require('./lib/Snapshot.js')(mongoose, config);
-  require('./lib/Sync.js')(mongoose, config);
   require('./lib/Webhook.js')(mongoose, config);
 
 };

package/lib/Account.js

@@ -2,12 +2,13 @@
 
 module.exports = function(mongoose, config) {
 
-  var
+  let
 
     Schema = mongoose.Schema,
-    _ = require('underscore');
+    _ = require('underscore'),
+    helpers = require('../helpers');
 
-  var Account = new Schema({
+  let Account = new Schema({
 
     username: { type: String, required: true, unique: true },
     email: { type: String, required: true, unique: true },
@@ -72,66 +73,130 @@ module.exports = function(mongoose, config) {
 
   Account.statics.findByEmail = function(email, cb) {
 
-    var self = this;
+    let self = this;
+
+    if (!cb) { throw new Error('cb is required'); }
+    if (!email) { return cb(new Error('email is required'), null); }
 
     self
-      .findOne({ 'email': (email || '').toLowerCase()})
+      .findOne({ 'email': email.toLowerCase()})
       .populate('person')
-      .exec(cb);
-  };
+      .exec(function(err, account) {
+
+        if (err) { return cb(err); }
+        else if (!account) { return cb(null, null); }
+
+        if (account.populated('person')) {
+
+          if (account.org) { helpers.cleanPerson(account.person, account.org); }
+          else { account.person.sources = []; }
+
+        }
+
+        return cb(null, account);
 
-  Account.statics.findByUsername = function(username, cb) {
-    this
-      .findOne({ 'username': new RegExp(username, 'i') })
-      .populate('person')
-      .exec(function (err, account) {
-        cb(err, account);
       });
   };
 
   Account.statics.getById = function (id, cb) {
 
-    this
-      .findById(id)
-      .populate('person org')
-      .exec(function (err, account) {
-        if (err) {
-          return cb(err, null);
-        }
-        else if (account && account.person) {
-          account.deepPopulate('person.lps.lp', function (err, result) {
-            return cb(err, account);
-          });
-        }
-        else if (!account) {
-          return cb(new Error('No account with id ' + id.toString()), null);
-        }
-        else if (account && !account.person) {
-          return cb(new Error('Missing person reference on account with id ' + id.toString()), null);
-        }
-        else {
-          return cb(new Error('Unknown error'), null);
-        }
-      });
+    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); }
+
+    let query = self.findById(id);
+
+    query.populate('person');
+    query.populate('org');
+
+    query.exec(function (err, account) {
+
+      if (err) {
+        return cb(err, null);
+      }
+      else if (account && account.populated('person') && account.populated('org')) {
+
+        // Scrub customer info before returning
+
+        let customerId = account.populated('org');
+
+        if (account.populated('org')) { helpers.cleanOrg(account.org, customerId); }
+
+        if (account.populated('person')) { helpers.cleanPerson(account.person, customerId); }
+
+        return cb(null, account);
+
+      }
+      else if (!account) {
+        return cb(new Error('No account with id ' + id.toString()), null);
+      }
+      else if (account && !account.person) {
+        return cb(new Error('Missing person reference on account with id ' + id.toString()), null);
+      }
+      else if (account && !account.org) {
+        return cb(new Error('Missing org reference on account with id ' + id.toString()), null);
+      }
+      else {
+        return cb(new Error('Unknown error'), null);
+      }
+
+    });
 
-  Account.statics.getByPersonIds = function (ids, cb) {
-    this
-      .find({ 'person': { $in : ids } })
-      .populate('person', 'name')
-      .exec(cb);
   };
 
   Account.statics.getForCustomer = function (customerId, cb) {
-    this
+
+    // 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(cb);
+
+  };
+
+  Account.statics.listAllAccounts = 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(cb);
+
   };
 
-  Account.statics.listGoogleAccounts = function(cb) {
+  Account.statics.listGoogleAccounts = 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'); }
 
-    this
+    options = helpers.getDefaultOptions(options);
+
+    if (!options.isWorkerProcess) { return cb(null, []); }
+
+    self
       .find({
         'active': true,
         'calendar.active': true,
@@ -142,9 +207,20 @@ module.exports = function(mongoose, config) {
 
   };
 
-  Account.statics.listMicrosoftAccounts = function(cb) {
+  Account.statics.listMicrosoftAccounts = function(options, cb) {
+
+    // This is only for worker
+    // Since it's only worker, no need to scrub results
+
+    const self = this;
 
-    this
+    if (!cb) { throw new Error('cb is required'); }
+
+    options = helpers.getDefaultOptions(options);
+
+    if (!options.isWorkerProcess) { return cb(null, []); }
+
+    self
       .find({
         'active': true,
         'calendar.active': true,
@@ -155,49 +231,19 @@ module.exports = function(mongoose, config) {
 
   };
 
-  Account.statics.listAllAccounts = function (cb) {
-
-    // sort is done post retrieval because query sort is done pre-decryption
-
-    this
-      .find({'active': true})
-      .populate('person')
-      .exec(function (err, accounts) {
-        return cb(err, _.sortBy(accounts, function(account) {
-          if (account.person && account.person.name && account.person.name.last) {
-            return account.person.name.last;
-          }
-          else return '';
-        }));
-      });
-
-  };
+  Account.statics.upsert = function(account, cb) {
 
-  Account.statics.listAllAccountsSkinny = function (cb) {
+    // No population so no need to scrub
 
-    // sort is done post retrieval because query sort is done pre-decryption
-    this
-      .find({'active': true})
-      .exec(cb);
+    account.save(cb);
 
   };
 
-  Account.statics.upsert = function(account, cb) {
-    account.save(cb);
-  };
 
-  Account.post('remove', function(doc) {
-    // CalendarEvent.account
-    // Person.account
-  });
 
   Account.set('autoIndex', false);
-  Account.set('usePushEach', true);
   Account.on('index', function(err) { console.log('error building account indexes: ' + err); });
 
-  var deepPopulate = require('mongoose-deep-populate')(mongoose);
-  Account.plugin(deepPopulate);
-
   mongoose.model('Account', Account);
 
 };

package/lib/Activity.js

@@ -5,7 +5,6 @@ module.exports = function(mongoose, config) {
   var
 
     Schema = mongoose.Schema,
-    env = process.env.NODE_ENV || 'development',
     Geoip = require('@dhyasama/ffvc-geoip'),
     geoip = new Geoip(),
     async = require('async'),
@@ -131,7 +130,6 @@ module.exports = function(mongoose, config) {
   };
 
   Activity.set('autoIndex', false);
-  Activity.set('usePushEach', true);
   Activity.on('index', function(err) { console.log('error building activity indexes: ' + err); });
 
   mongoose.model('Activity', Activity);

package/lib/CalendarEvent.js

@@ -4,9 +4,7 @@ module.exports = function(mongoose, config) {
 
   var
 
-    Schema = mongoose.Schema,
-    env = process.env.NODE_ENV || 'development',
-    _ = require('underscore');
+    Schema = mongoose.Schema;
 
   var CalendarEvent = new Schema({
 
@@ -178,12 +176,8 @@ module.exports = function(mongoose, config) {
 
   };
 
-  CalendarEvent.post('remove', function(doc) {
-    // Person.calendarEventId
-  });
 
   CalendarEvent.set('autoIndex', false);
-  CalendarEvent.set('usePushEach', true);
   CalendarEvent.on('index', function(err) { console.log('error building calendar event indexes: ' + err); });
 
   mongoose.model('CalendarEvent', CalendarEvent);

package/lib/CapTable.js

@@ -419,7 +419,6 @@ module.exports = function(mongoose, config) {
   ///////////////////////////////////////////////////////////////////////////////////////
 
   CapTable.set('toJSON', { virtuals: true });
-  CapTable.set('usePushEach', true);
   CapTable.set('autoIndex', false);
 
   CapTable.index({ organization: 1,  customer: 1 }, { unique: true, partialFilterExpression : { type :"string" } });