@dhyasama/totem-models 7.58.0 → 8.0.1

package/lib/Organization.js

@@ -1,18 +1,16 @@
-"use strict";
+'use strict';
 
 module.exports = function(mongoose, config) {
 
-  var
+  let
 
     _ = require('underscore'),
     async = require('async'),
     utils = require('@dhyasama/ffvc-utilities'),
+    helpers = require('../helpers'),
     Schema = mongoose.Schema,
-    Deal = mongoose.model('Deal'),
     Flag = mongoose.model('Flag'),
     Note = mongoose.model('Note'),
-    customerFunds = [],
-    customerPortfolio = [],
 
     Organization = new Schema({
 
@@ -173,7 +171,13 @@ module.exports = function(mongoose, config) {
 
         totemUrl: { type: String, trim: true, unique: true, partialFilterExpression : { type :"string" } },
 
-        locale: { type: String, default: 'en-us', trim: true },
+        auth: {
+
+          google: { type: Boolean, default: false },
+
+          microsoft: { type: Boolean, default: false }
+
+        },
 
         beanstalk: {
           environmentName: { type: String, trim: true },
@@ -251,6 +255,12 @@ module.exports = function(mongoose, config) {
 
         },
 
+        lps: {
+
+          active: {type: Boolean, default: false},
+
+        },
+
         deals: {
 
           active: { type: Boolean, default: false },
@@ -430,163 +440,6 @@ module.exports = function(mongoose, config) {
 
 
 
-  ///////////////////////////////////////////////////////////////////////////////////////
-  // HELPERS
-  ///////////////////////////////////////////////////////////////////////////////////////
-
-  var getSources = function getSources(people) {
-
-    var result = _.compact(_.pluck(people, 'person'));
-    if (result.length == 0) return [];
-
-    result = _.compact(_.pluck(result, '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; });
-    result = _.sortBy(result, 'interactions.count');
-    result.reverse();
-    result = _.sortBy(result, 'name.full');
-
-    return result;
-
-  };
-
-  var prepForSave = function prepForSave(doc) {
-
-    var cleanContactInfo = function cleanContactInfo(obj) {
-
-      var thereCanOnlyBeOne = function thereCanOnlyBeOne(items) {
-
-        var primaryItems = _.filter(items, function(item) { return item.primary; });
-
-        if (primaryItems.length > 1) {
-
-          _.each(primaryItems, function(item, index) {
-            // skip the first one (leave it primary) and mark the rest as not primary
-            if (index >= 1) item.primary = false;
-          });
-
-        }
-
-        return items;
-
-      };
-
-      if (!obj || !obj.contact) return;
-
-      if (obj.contact.address) {
-
-        // must have something meaningful
-        obj.contact.address = _.map(obj.contact.address, function(address) {
-          if (!address.city && !address.state && !address.country) return null;
-          else return address;
-        });
-
-        // remove emptiness and dedupe
-        obj.contact.address = _.uniq(_.compact(obj.contact.address), function(item) { return item.city + item.state + item.country; });
-
-        // only one primary
-        obj.contact.address = thereCanOnlyBeOne(obj.contact.address);
-
-      }
-
-      if (obj.contact.email) {
-
-        // must have something meaningful
-        obj.contact.email = _.map(doc.contact.email, function(item) {
-          if (!item.email) return null;
-          else return item;
-        });
-
-        // remove emptiness and dedupe
-        obj.contact.email = _.uniq(_.compact(obj.contact.email), function(item) { return item.email; });
-
-        // only one primary
-        obj.contact.email = thereCanOnlyBeOne(obj.contact.email);
-
-      }
-
-      if (obj.contact.phone) {
-
-        // must have something meaningful
-        obj.contact.phone = _.map(doc.contact.phone, function(item) {
-          if (!item.number) return null;
-          else return item;
-        });
-
-        // remove emptiness and dedupe
-        obj.contact.phone = _.uniq(_.compact(obj.contact.phone), function(item) { return item.number; });
-
-        // only one primary
-        obj.contact.phone = thereCanOnlyBeOne(obj.contact.phone);
-
-      }
-
-    };
-
-    var cleanPeople = function cleanPeople(obj) {
-
-      if (!obj || !obj.people) return;
-
-      // remove junk
-      obj.people = _.reject(obj.people, function(p) { return p.person == null; });
-
-      // dedupe
-      obj.people = _.uniq(obj.people, function(p) { return p.person._id ? p.person._id.toString() : p.person.toString(); });
-
-    };
-
-    var cleanWebsites = function cleanWebsites(obj) {
-
-      if (!obj) return;
-
-      // Format website
-      if (obj.website) {
-        obj.website = String(obj.website);
-        obj.website = obj.website.replace('http://', '').replace('https://', '').replace(/\/+$/, '');
-        obj.website = utils.getDomain(obj.website);
-      }
-
-      // Format website aliases
-      if (obj.websiteAliases && obj.websiteAliases.length >= 1) {
-        obj.websiteAliases = _.map(obj.websiteAliases, function(alias) {
-          alias = String(alias);
-          alias = alias.replace('http://', '').replace('https://', '').replace(/\/+$/, '');
-          return utils.getDomain(alias);
-        });
-      }
-
-      // Add website to website aliases
-      // There are unique constraints on website and website aliases
-      // This enables us to enforce uniqueness across both and across documents
-      if (obj.website && obj.websiteAliases) obj.websiteAliases.push(obj.website);
-
-      if (obj.websiteAliases) {
-        obj.websiteAliases = _.uniq(obj.websiteAliases);
-        obj.websiteAliases = _.compact(obj.websiteAliases);
-      }
-
-    };
-
-    cleanContactInfo(doc);
-    cleanPeople(doc);
-    cleanWebsites(doc);
-
-  };
-
-
-
   ///////////////////////////////////////////////////////////////////////////////////////
   // VIRTUALS
   // Properties that are not persisted to the database
@@ -594,12 +447,12 @@ module.exports = function(mongoose, config) {
 
   Organization.virtual('acquired.amount').get(function () {
 
-    var self = this;
-    var publicData = self.operating.acquired.public || {};
-    var privateData = self.operating.acquired.private || [];
+    const self = this;
+    const publicData = self.operating.acquired.public || {};
+    const privateData = self.operating.acquired.private || [];
 
     if (publicData.amount) return publicData.amount;
-    else if (privateData.length == 1) {
+    else if (privateData.length >= 1) {
       if (privateData[0].amount) return privateData[0].amount;
       else return 0;
     }
@@ -609,12 +462,12 @@ module.exports = function(mongoose, config) {
 
   Organization.virtual('acquired.by').get(function () {
 
-    var self = this;
-    var publicData = self.operating.acquired.public || {};
-    var privateData = self.operating.acquired.private || [];
+    const self = this;
+    const publicData = self.operating.acquired.public || {};
+    const privateData = self.operating.acquired.private || [];
 
     if (publicData.by) return publicData.by;
-    else if (privateData.length == 1) {
+    else if (privateData.length >= 1) {
       if (privateData[0].by) return privateData[0].by;
       else return null;
     }
@@ -624,12 +477,12 @@ module.exports = function(mongoose, config) {
 
   Organization.virtual('acquired.on').get(function () {
 
-    var self = this;
-    var publicData = self.operating.acquired.public || {};
-    var privateData = self.operating.acquired.private || [];
+    const self = this;
+    const publicData = self.operating.acquired.public || {};
+    const privateData = self.operating.acquired.private || [];
 
     if (publicData.acquiredOn) return publicData.acquiredOn;
-    else if (privateData.length == 1) {
+    else if (privateData.length >= 1) {
       if (privateData[0].acquiredOn) return privateData[0].acquiredOn;
       else return null;
     }
@@ -1021,7 +874,7 @@ module.exports = function(mongoose, config) {
 
   Organization.virtual('status').get(function () {
 
-    var self = this;
+    const self = this;
 
     if (self.ipo.ticker) return 'IPO';
     else if (self.acquired.by || self.acquired.on) return 'Acquired';
@@ -1099,7 +952,7 @@ module.exports = function(mongoose, config) {
   };
 
   Organization.methods.merge = function(id) {
-    if (this.merged.indexOf(id) == -1) {
+    if (this.merged.indexOf(id) === -1) {
       this.merged = this.merged.concat([id]);
       return true;
     }
@@ -1114,7 +967,7 @@ module.exports = function(mongoose, config) {
 
     var match = _.find(self.related, function(org) {
       var orgId = utils.isValidObjectId(org) ? org : org.id;
-      return orgId.toString() == id.toString();
+      return orgId.toString() === id.toString();
     });
 
     if (!match) { self.related.push(id); }
@@ -1135,158 +988,34 @@ module.exports = function(mongoose, config) {
   // Statics query the entire collection
   //////////////////////////////////////////////////////
 
-  Organization.statics.addDeal = function(deal, user, cb) {
-
-    var self = this;
-
-    var checkForDuplicates = function checkForDuplicates(previous, callback) {
-
-      // get org and make sure not already a deal for current customer
-
-      self.getById(utils.getIdAsString(previous.deal, 'organization'), {}, function(err, org) {
-
-        if (err) return callback(err, null);
-        else if (!org) return callback(new Error('Org not found'), null);
-        else if (org.deleted) return callback(new Error('Org deleted'), null);
-
-        var match = _.find(org.deals, function(d) {
-          return utils.getIdAsString(d, 'customer') == deal.customer._id.toString();
-        });
-
-        if (match) return callback(new Error('This org already has a deal for this customer'), null);
-
-        previous.org = org;
-
-        return callback(null, previous);
-
-      });
-
-    };
-
-    var validateStage = function validateStage(previous, callback) {
-
-      // check allowable deal stages against the new deal
-
-      self.findById(deal.customer, function(err, org) {
-
-        if (err) return callback(err, null);
-        else if (!org) return callback(new Error('Customer not found'), null);
-
-        var statuses = org.customer.deals.activeStatuses;
-
-        var match = _.find(statuses, function(status) {
-          return status == previous.deal.stage;
-        });
-
-        if (!match) return callback(new Error('This stage is not valid for this customer'), null);
-
-        return callback(null, previous);
-
-      });
-
-    };
-
-    var createDeal = function createDeal(previous, callback) {
-
-      Deal.upsert(previous.deal, previous.user, function(err, result) {
-
-        if (err) return callback(err, null);
-
-        previous.deal = result;
-
-        return callback(null, previous);
-
-      });
-
-    };
-
-    var addDealToOrg = function addDealToOrg(previous, callback) {
-
-      previous.org.deals.push(previous.deal);
-
-      self.upsert(previous.org, previous.user.username, function(err, result) {
-
-        if (err) return callback(err, null);
-
-        previous.org = result;
-
-        return callback(null, previous);
-
-      });
-
-    };
-
-    var previous = {
-      deal: deal,
-      user: user,
-      org: null
-    };
-
-    async.waterfall([
-      checkForDuplicates.bind(null, previous),
-      validateStage,
-      createDeal,
-      addDealToOrg
-    ], function(err, results) {
-
-      if (err) return cb(err, null);
-
-      return cb(null, {
-        org: results.org,
-        deal: results.deal
-      });
-
-    });
-
-  };
-
-  Organization.statics.addFlag = function(organizationId, creatorPersonId, text, cb) {
+  Organization.statics.addFlag = function(orgId, creatorPersonId, text, customerId, cb) {
 
     Flag.createForModel({
       createdBy: creatorPersonId,
-      text: text
-    }, this, organizationId, cb);
+      text: text,
+      customer: customerId
+    }, this, orgId, cb);
 
   };
 
-  Organization.statics.addNote = function(organizationId, creatorPersonId, text, isPrivate, cb) {
+  Organization.statics.addNote = function(organizationId, creatorPersonId, text, isPrivate, customerId, cb) {
 
     Note.createForModel({
       createdBy: creatorPersonId,
       text: text,
-      isPrivate: isPrivate
+      isPrivate: isPrivate,
+      customer: customerId
     }, this, organizationId, cb);
 
   };
 
-  Organization.statics.deleteDeal = function(dealId, cb) {
-
-    // Delete the deal itself along with any references
-
-    var self = this;
-
-    var removeReferences = function removeReferences(callback) {
-      self.update({}, {
-        $pull: { 'deals' : [dealId] }
-      }, callback);
-    };
-
-    async.series([
-      Deal.delete.bind(Deal, dealId),
-      removeReferences
-    ], function(err, results) {
-      return cb(err, null);
-    });
-
-  };
-
   Organization.statics.deleteFlag = function(flagId, cb) {
 
     // Delete the flag itself along with reference
 
-    var self = this;
+    const self = this;
 
-    var removeReferences = function removeReferences(callback) {
+    let removeReferences = function removeReferences(callback) {
       self.update({}, {
         $pull: { 'flags' : [flagId] }
       }, callback);
@@ -1305,9 +1034,9 @@ module.exports = function(mongoose, config) {
 
     // Delete the note itself along with any references
 
-    var self = this;
+    const self = this;
 
-    var removeReferences = function removeReferences(callback) {
+    let removeReferences = function removeReferences(callback) {
       self.update({}, {
         $pull: { 'notes' : [noteId] }
       }, callback);
@@ -1322,21 +1051,15 @@ module.exports = function(mongoose, config) {
 
   };
 
-  Organization.statics.removeCustomerFilters = function(customerId, cb) {
+  Organization.statics.findByDomains = function findByDomains(domains, options, cb) {
 
-    var self = this;
+    const self = this;
 
-    self
-      .update(
-        { 'filters.customer': customerId },
-        { $pull : { 'filters': { 'customer': customerId } } },
-        { multi : true }
-      )
-      .exec(cb);
-      
-  };
-
-  Organization.statics.findByDomains = function findByDomains(domains, cb) {
+    if (!cb) { throw new Error('cb is required'); }
+    if (!domains) { return cb(new Error('domains is required'), null); }
+    if (!options) { return cb(new Error('options is required'), null); }
+    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); }
 
     // we haven't been able to avoid some domains having a protocol prefix in the database
     // until we can, use protocol as part of searching by domain
@@ -1353,7 +1076,7 @@ module.exports = function(mongoose, config) {
     });
 
     // add http and https alternatives for each domain
-    var alternativeDomains = [];
+    let alternativeDomains = [];
     _.each(domains, function(d) {
       alternativeDomains.push('http://' + d);
       alternativeDomains.push('https://' + d);
@@ -1361,32 +1084,67 @@ module.exports = function(mongoose, config) {
 
     domains = domains.concat(alternativeDomains);
 
-    var query = this.find({ $or: [ {'website': { $in : domains }}, {'websiteAliases': { $in : domains }} ], 'deleted': {$ne: true} });
-    query.exec(cb);
+    let query = self.find({ $or: [ {'website': { $in : domains }}, {'websiteAliases': { $in : domains }} ], 'deleted': {$ne: true} });
+
+    query.exec(function(err, orgs) {
+
+      if (err) { return cb(err, null); }
+      else if (!orgs) { return cb(null, []); }
+
+      orgs = _.map(orgs, function(org) {
+        return helpers.cleanOrg(org, options.CUSTOMER_ID);
+      });
+
+      return cb(null, orgs);
+
+    });
 
   };
 
   Organization.statics.findByFunds = function findByFunds(fundids, cb) {
-    var self = this;
+    const self = this;
     self
       .find({ 'funds': { $in : fundids }, 'deleted': {$ne: true} })
       .select('name logoUrl funds contact')
       .exec(cb);
   };
 
-  Organization.statics.findByIdsUnpopulated = function findByIdsUnpopulated(ids, cb) {
+  Organization.statics.findByIdsUnpopulated = function findByIdsUnpopulated(ids, options, cb) {
 
-    var self = this;
+    const self = this;
+
+    if (!cb) { throw new Error('cb is required'); }
+    if (!ids) { return cb(new Error('ids is required'), null); }
+    if (!options) { return cb(new Error('options is required'), null); }
+    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); }
 
     self
       .find({ '_id': { $in : ids }})
-      .exec(cb);
+      .exec(function(err, orgs) {
+
+        if (err) { return cb(err, null); }
+        else if (!orgs) { return cb(null, []); }
+
+        orgs = _.map(orgs, function(org) {
+          return helpers.cleanOrg(org, options.CUSTOMER_ID);
+        });
+
+        return cb(null, orgs);
+
+      });
 
   };
 
-  Organization.statics.findByIds = function findByIds(ids, cb) {
+  Organization.statics.findByIds = function findByIds(ids, options, cb) {
 
-    var self = this;
+    const self = this;
+
+    if (!cb) { throw new Error('cb is required'); }
+    if (!ids) { return cb(new Error('ids is required'), null); }
+    if (!options) { return cb(new Error('options is required'), null); }
+    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); }
 
     self
       .find({ '_id': { $in : ids }})
@@ -1408,18 +1166,28 @@ module.exports = function(mongoose, config) {
           'people.person.calendarEventSummaries.notes.createdBy': { select: 'name avatarUrl title doNotDisplay' }
         }
       })
-      .exec(cb);
+      .exec(function(err, orgs) {
+
+        if (err) { return cb(err, null); }
+        else if (!orgs) { return cb(null, []); }
+
+        orgs = _.map(orgs, function(org) {
+          return helpers.cleanOrg(org, options.CUSTOMER_ID);
+        });
+
+        return cb(null, orgs);
+
+      });
 
   };
 
   Organization.statics.findByLimitedPartner = function findByLimitedPartner(lpid, options, cb) {
 
-    var self = this;
+    const self = this;
 
-    options = options || {};
-    options.role = options.role || 'none';
+    options = helpers.getDefaultOptions(options);
 
-    if (options.role == 'none') return cb(new Error('Access denied'), null);
+    if (options.role === 'none') { return cb(new Error('Access denied'), null); }
 
     self
       .find({ 'lps': lpid, 'deleted': {$ne: true} })
@@ -1432,7 +1200,11 @@ module.exports = function(mongoose, config) {
 
     // Given a person id, get all organizations with that person
 
-    var self = this;
+    const self = this;
+
+    if (!cb) { throw new Error('cb is required'); }
+    if (!personId) { return cb(new Error('ids is required'), null); }
+    if (!mongoose.Types.ObjectId.isValid(personId)) { return cb(new Error('personId is not a valid ObjectId'), null); }
 
     self
       .find({ $or:
@@ -1443,28 +1215,11 @@ module.exports = function(mongoose, config) {
         ],
         'deleted': { $ne: true }
       })
+      .select('-sources -customer')
       .exec(cb);
 
   };
 
-  Organization.statics.findByPersonRaw = function findByPersonRaw(personId, cb) {
-
-    // Given a person id, get all organizations with that person
-    // directly from mongo driver to avoid mongoose middlewares
-
-    var self = this;
-
-    self.collection.find({ $or:
-      [
-        { 'people.person': personId },
-        { 'chairs.first': personId },
-        { 'chairs.second': personId }
-      ],
-      'deleted': { $ne: true }
-    }).toArray(cb);
-
-  };
-
   Organization.statics.findBySlug = function findBySlug(slug, cb) {
     this.findOne({ slug: slug, 'deleted': {$ne: true} }).exec(cb);
   };
@@ -1473,15 +1228,19 @@ module.exports = function(mongoose, config) {
     this.find({ 'slug': { $in : slugs } }).exec(cb);
   };
 
-  Organization.statics.findBySocial = function findBySocial(value, cb) {
+  Organization.statics.findBySocial = function findBySocial(value, options, cb) {
 
     // Extract stand-alone username and append it to our standardized domains
 
-    var self = this;
+    const self = this;
 
-    if (!value) { return cb(new Error('value must be provided'), null); }
+    if (!cb) { throw new Error('cb is required'); }
+    if (!value) { return cb(new Error('value is required'), null); }
+    if (!options) { return cb(new Error('options is required'), null); }
+    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); }
 
-    var username = utils.getUsernameFromUrl(value);
+    let username = utils.getUsernameFromUrl(value);
 
     if (!username) { return cb(null, []); }
 
@@ -1495,57 +1254,40 @@ module.exports = function(mongoose, config) {
           ],
         'deleted': { $ne: true }
       })
-      .exec(cb);
-
-  };
-
-  Organization.statics.findDupes = function findDupes(org, options, cb) {
+      .exec(function(err, orgs) {
 
-    if (!cb) throw new Error('cb is required');
-    if (!org || (!org.name && !org.website)) return cb(null, []);
+        if (err) { return cb(err, null); }
 
-    this.search({
-      name: org.name,
-      domain: utils.getDomain(org.website)
-    }, options, function(err, orgs) {
+        orgs = _.map(orgs, function(org) {
+          return helpers.cleanOrg(org, options.CUSTOMER_ID);
+        });
 
-      if (err) return cb(err, null);
-      if (!orgs) return cb(null, null);
+        return cb(null, orgs);
 
-      // exclude passed in org from results
-      orgs = _.reject(orgs, function(o) {
-        return o.id == org.id;
       });
 
-      return cb(null, orgs);
-
-    });
-
   };
 
-  Organization.statics.flag = function(orgId, resolved, text, username, cb) {
-
-    this.findById(orgId).exec(function(err, org) {
-
-      org.flagged.resolved = resolved;
-      org.flagged.text = text;
-      org.flagged.by = username;
-      org.flagged.on = Date.now();
+  Organization.statics.findByTotemUrl = function findBySlug(url, cb) {
+    this.findOne({ 'customer.totemUrl': url }).exec(cb);
+  };
 
-      org.save(cb);
+  Organization.statics.getAcquisitions = function getAcquisitions(orgid, options, cb) {
 
-    });
+    const self = this;
 
-  };
+    if (!cb) { throw new Error('cb is required'); }
+    if (!orgid) { return cb(new Error('orgid is required'), null); }
+    if (!mongoose.Types.ObjectId.isValid(orgid)) { return cb(new Error('orgid is not a valid ObjectId'), null); }
+    if (!options) { return cb(new Error('options is required'), null); }
+    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); }
 
-  Organization.statics.getAcquisitions = function getAcquisitions(orgid, cb) {
-    // todo - logic to check public and private
-    var self = this;
     self
       .find(
         { $or: [
-          {'operating.acquired.private.by': orgid, 'deleted': {$ne: true} },
-          {'operating.acquired.public.by': orgid, 'deleted': {$ne: true} },
+          { 'operating.acquired.private.by': orgid, 'operating.acquired.private.customer': options.CUSTOMER_ID, 'deleted': { $ne: true } },
+          { 'operating.acquired.public.by': orgid, 'deleted': { $ne: true } },
         ]}
       )
       .select('name logoUrl')
@@ -1582,18 +1324,24 @@ module.exports = function(mongoose, config) {
 
   Organization.statics.getById = function getById(id, options, cb) {
 
-    var self = this;
+    const self = this;
+
+    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); }
+    if (!options) { return cb(new Error('options is required'), null); }
+    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); }
 
-    options = options || {};
-    options.role = options.role || 'none';
+    options = helpers.getDefaultOptions(options);
 
-    var lpPopulateOptions = { path: 'lps' };
-    if (config.CUSTOMER_ID != 'GLOBAL_PROCESS') lpPopulateOptions.match = { customer: config.CUSTOMER_ID };
+    let lpPopulateOptions = { path: 'lps' };
+    if (!options.isWorkerProcess) { lpPopulateOptions.match = { customer: options.CUSTOMER_ID }; }
 
     var dealPopulateOptions = { path: 'deals' };
-    if (config.CUSTOMER_ID != 'GLOBAL_PROCESS') dealPopulateOptions.match = { customer: config.CUSTOMER_ID };
+    if (!options.isWorkerProcess) { dealPopulateOptions.match = { customer: options.CUSTOMER_ID }; }
 
-    var query = self.findById(id);
+    let query = self.findById(id);
 
     query.populate('people.person', 'name avatarUrl title contact doNotDisplay');
     query.populate('related', 'name logoUrl');
@@ -1604,7 +1352,7 @@ module.exports = function(mongoose, config) {
     query.populate('operating.acquired.private.by', 'name logoUrl');
     query.populate(dealPopulateOptions);
 
-    if (options.role != 'none') {
+    if (options.role !== 'none') {
       query.populate(lpPopulateOptions);
       query.deepPopulate([
         'deals.sources.person',
@@ -1625,84 +1373,27 @@ module.exports = function(mongoose, config) {
       ]);
     }
 
-    query.exec(cb);
+    query.exec(function(err, result) {
 
-  };
-
-  Organization.statics.getByIdAsGlobal = function getByIdAsGlobal(id, options, cb) {
-
-    var self = this;
-
-    // Save original id so we can put it back when we're done
-    var orginalCustomerId = config.CUSTOMER_ID;
-
-    // Switch to global
-    config.CUSTOMER_ID = "GLOBAL_PROCESS";
-    console.log('config.CUSTOMER_ID pre query', config.CUSTOMER_ID);
-
-    try {
-
-      self.findById(id, function(err, result) {
-
-        // Put original id back
-        config.CUSTOMER_ID = orginalCustomerId;
-        console.log('config.CUSTOMER_ID post query', config.CUSTOMER_ID);
-
-        if (err) { return cb(err, null); }
-
-        return cb(null, result);
-
-      });
-
-
-    }
-    catch(err) {
-
-      // Put original id back
-      config.CUSTOMER_ID = orginalCustomerId;
-      console.log('config.CUSTOMER_ID post query', config.CUSTOMER_ID);
-
-      console.log('ERROR WITH ORGANIZATION.GETBYIDGLOBAL');
-      console.log('config.CUSTOMER_ID', config.CUSTOMER_ID);
-      console.log(err);
-
-      return cb(err, null);
-
-    }
-
-  };
-
-  Organization.statics.getByIdRaw = function getByIdRaw(id, options, cb) {
-
-    // directly from mongo driver to avoid mongoose middlewares
-
-    var self = this;
-
-    //self.collection.findOne({ "_id": id }, cb);
+      if (err) { return cb(err, null); }
 
-    self.collection.findOne({ "_id": id }, function(err, result) {
-
-      if (err) return cb(err, null);
-      else if (!result) return cb(null, null);
-
-      // hydrate so we can use the populate method to get people
-      // note the hydrated version is not returned
-      var hydrated = self.hydrate(result);
-      hydrated.populate({
-        path: 'people.person',
-        select: 'name avatarUrl title contact doNotDisplay'
-      }, function (err, populated) {
-        result.people = populated.people;
-        return cb(null, result);
-      });
+      if (options.isWorkerProcess) { return cb(null, result); }
+      else { return cb(null, helpers.cleanOrg(result, options.CUSTOMER_ID)); }
 
     });
 
   };
 
-  Organization.statics.getChairsOfPerson = function getChairsOfPerson(personId, cb) {
+  Organization.statics.getChairsOfPerson = function getChairsOfPerson(personId, options, cb) {
 
-    var self = this;
+    const self = this;
+
+    if (!cb) { throw new Error('cb is required'); }
+    if (!personId) { return cb(new Error('personId is required'), null); }
+    if (!mongoose.Types.ObjectId.isValid(personId)) { return cb(new Error('personId is not a valid ObjectId'), null); }
+    if (!options) { return cb(new Error('options is required'), null); }
+    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); }
 
     self
       .find({ $or:
@@ -1712,57 +1403,63 @@ module.exports = function(mongoose, config) {
         ],
         'deleted': { $ne: true }
       })
-      .exec(cb);
+      .exec(function(err, orgs) {
+
+        if (err) { return cb(err, null); }
+
+        orgs = _.map(orgs, function(org) {
+          return helpers.cleanOrg(org, options.CUSTOMER_ID);
+        });
+
+        return cb(null, orgs);
+
+      });
 
   };
 
-  Organization.statics.getFlags = function getFlags(orgid, cb) {
+  Organization.statics.getFlags = function getFlags(orgid, options, cb) {
 
-    var self = this;
-    var query = self.findById(orgid)
+    const self = this;
+
+    if (!cb) { throw new Error('cb is required'); }
+    if (!orgid) { return cb(new Error('orgid is required'), null); }
+    if (!mongoose.Types.ObjectId.isValid(orgid)) { return cb(new Error('orgid is not a valid ObjectId'), null); }
+    if (!options) { return cb(new Error('options is required'), null); }
+    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); }
 
-    query.select('flags')
+    let query = self.findById(orgid);
+
+    query.select('flags');
     query.populate({
       path: 'flags',
-      match: { customer: config.CUSTOMER_ID }
-    })
+      match: { customer: options.CUSTOMER_ID }
+    });
     query.deepPopulate([
       'flags.createdBy'
     ], {
       populate: {
         'flags.createdBy': { select: 'name avatarUrl title' }
       }
-    })
-    query.sort({'createdOn':-1})
-    query.exec(cb);
+    });
+    query.sort({'createdOn':-1});
 
-  };
+    query.exec(function(err, org) {
 
-  Organization.statics.getInteractions = function getInteractions(orgid, cb) {
+      if (err) { return cb(err, null); }
+      else if (!org) { return cb(null, []); }
 
-    var self = this;
+      org = helpers.cleanOrg(org, options.CUSTOMER_ID);
 
-    self
-      .findById(orgid)
-      .populate('people.person', 'name avatarUrl title doNotDisplay calendarEventSummaries')
-      .deepPopulate([
-        'people.person.calendarEventSummaries.attendees.internal',
-        'people.person.calendarEventSummaries.attendees.external',
-        'people.person.calendarEventSummaries.notes.createdBy'
-      ], {
-        populate: {
-          'people.person.calendarEventSummaries.attendees.internal': { select: 'name avatarUrl title doNotDisplay' },
-          'people.person.calendarEventSummaries.attendees.external': { select: 'name avatarUrl title doNotDisplay' },
-          'people.person.calendarEventSummaries.notes.createdBy': { select: 'name avatarUrl title doNotDisplay' }
-        }
-      })
-      .exec(cb);
+      return cb(null, org);
+
+    });
 
   };
 
   Organization.statics.getList = function getList(cb) {
 
-    var self = this;
+    const self = this;
 
     self
       .find({'deleted': {$ne: true}})
@@ -1772,26 +1469,55 @@ module.exports = function(mongoose, config) {
 
   };
 
-  Organization.statics.getLpOrgs = function getLpOrgs(lpids, cb) {
-    var self = this;
-    self
-      .find({ 'lps': { $in : lpids }, 'deleted': {$ne: true} })
-      .select('name logoUrl lps')
-      .populate('lps', 'name customer')
-      .exec(cb);
+  Organization.statics.getLpOrgs = function getLpOrgs(lpids, options, cb) {
+
+    const self = this;
+
+    if (!cb) { throw new Error('cb is required'); }
+    if (!lpids) { return cb(new Error('lpids is required'), null); }
+    if (!options) { return cb(new Error('options is required'), null); }
+    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); }
+
+    let query = self.find({ 'lps': { $in : lpids }, 'deleted': {$ne: true} });
+
+    query.select('name logoUrl lps');
+    query.populate('lps', 'name customer');
+
+    query.exec(function(err, orgs) {
+
+        if (err) { return cb(err, null); }
+        else if (!orgs) { return cb(null, []); }
+
+        orgs = _.map(orgs, function(org) {
+          return helpers.cleanOrg(org, options.CUSTOMER_ID);
+        });
+
+        return cb(null, orgs);
+
+      });
+
   };
 
-  Organization.statics.getNotes = function getNotes(orgid, cb) {
+  Organization.statics.getNotes = function getNotes(orgid, options, cb) {
 
-    var self = this;
-    var query = self.findById(orgid)
+    const self = this;
 
-    query.select('notes people.person')
-    query.populate('people.person', 'name avatarUrl title calendarEventSummaries')
+    if (!cb) { throw new Error('cb is required'); }
+    if (!orgid) { return cb(new Error('orgid is required'), null); }
+    if (!mongoose.Types.ObjectId.isValid(orgid)) { return cb(new Error('orgid is not a valid ObjectId'), null); }
+    if (!options) { return cb(new Error('options is required'), null); }
+    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); }
+
+    let query = self.findById(orgid);
+
+    query.select('notes people.person');
+    query.populate('people.person', 'name avatarUrl title calendarEventSummaries');
     query.populate({
       path: 'notes',
-      match: { customer: config.CUSTOMER_ID }
-    })
+      match: { customer: options.CUSTOMER_ID }
+    });
     query.deepPopulate([
       'notes.createdBy',
       'people.person.calendarEventSummaries.notes.createdBy'
@@ -1800,47 +1526,69 @@ module.exports = function(mongoose, config) {
         'notes.createdBy': { select: 'name avatarUrl title' },
         'people.person.calendarEventSummaries.notes.createdBy': { select: 'name avatarUrl title' }
       }
-    })
-    query.sort({'createdOn':-1})
-    query.exec(cb);
+    });
+    query.sort({'createdOn':-1});
+
+    query.exec(function(err, org) {
+
+      if (err) { return cb(err, null); }
+      else if (!org) { return cb(null, []); }
+
+      org = helpers.cleanOrg(org, options.CUSTOMER_ID);
+
+      return cb(null, org);
+
+    });
 
   };
 
-  Organization.statics.getSources = function(id, cb) {
+  Organization.statics.getSources = function(id, options, cb) {
 
-    var self = this;
+    const self = this;
 
-    self
-      .findById(id)
-      .select('people')
-      .populate('people.person', 'name avatarUrl title doNotDisplay sources')
-      .deepPopulate([
-        'people.person.sources.person'
-      ], {
-        populate: {
-          'people.person.sources.person': { select: 'name avatarUrl title doNotDisplay' }
-        }
-      })
-      .exec(function(err, org) {
+    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); }
+    if (!options) { return cb(new Error('options is required'), null); }
+    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); }
+
+    let query = self.findById(id);
+    query.select('people');
+    query.populate('people.person', 'name avatarUrl title doNotDisplay sources');
+    query.deepPopulate([
+      'people.person.sources.person'
+    ], {
+      populate: {
+        'people.person.sources.person': { select: 'name avatarUrl title doNotDisplay' }
+      }
+    });
 
-        if (err) return cb(err, null);
-        if (!org) return cb(null, null);
+    // get the org requested
+    query.exec(function(err, org) {
+
+        if (err) { return cb(err, null); }
+        if (!org) { return cb(null, null); }
 
-        self.findById(config.CUSTOMER_ID, function(err, customer) {
+        // get the customer requesting org
+        self.findById(options.CUSTOMER_ID, function(err, customer) {
 
-          if (err) return cb(err, null);
-          if (!customer) return cb(null, null);
+          if (err) { return cb(err, null); }
+          if (!customer) { return cb(null, null); }
 
-          var current = [];
-          var past = [];
-          var all = [];
-          var orgSources = getSources(org.people);
+          let current = [];
+          let past = [];
+          let all = [];
 
+          // combined list of sources from each person at org
+          let orgSources = helpers.getPeopleSources(_.pluck(org.people, 'person'));
+
+          // loop through customer's people and categorize sources
           _.each(customer.people, function(p) {
 
             var source = _.find(orgSources, function(os) {
               if (!os || !os.person || !os.person._id) return false;
-              return os.person._id.toString() == p.person.toString();
+              return os.person._id.toString() === p.person.toString();
             });
 
             if (!source) return;
@@ -1851,10 +1599,11 @@ module.exports = function(mongoose, config) {
 
           });
 
+          // return categorized sources
           return cb(null, {
-            all: all,
-            current: current,
-            past: past
+            all: helpers.sortPeopleSources(all, options.CUSTOMER_ID),
+            current: helpers.sortPeopleSources(current, options.CUSTOMER_ID),
+            past: helpers.sortPeopleSources(past, options.CUSTOMER_ID)
           });
 
         });
@@ -1863,53 +1612,57 @@ module.exports = function(mongoose, config) {
 
   };
 
-  Organization.statics.listAllFlagged = function (cb) {
+  Organization.statics.modify = function(filter, update, cb) {
 
-    var query = this.find({'flagged.resolved': false, 'flagged.text': { $ne: '' }, 'deleted': {$ne: true}});
-    query.exec(function (err, orgs) {
+    // VERY IMPORTANT NOTE
+    // findByIdAndUpdate and findOneAndUpdate do not trigger pre-save hook so that code will not run here
+    // at this time, the only known and approved use of this method is for adding and removing roles in totem web
 
-      if (err) return cb(err, null);
+    if (!cb) throw new Error('cb is required');
+    if (!filter) { return cb(new Error('filter is required'), null); }
+    if (!update) { return cb(new Error('update is required'), null); }
 
-      orgs = _.sortBy(orgs, function(org){
-        var timestamp = new Date(org.flagged.on);
-        timestamp = timestamp.getTime();
-        return timestamp;
-      });
-      orgs = orgs.reverse();
+    var self = this;
 
-      return cb(null, orgs);
+    // 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 }, cb);
 
   };
 
-  Organization.statics.listCustomers = function listCustomers(cb) {
+  Organization.statics.modifyById = function(id, update, cb) {
 
-    var self = this;
+    // VERY IMPORTANT NOTE
+    // findByIdAndUpdate and findOneAndUpdate do not trigger pre-save hook so that code will not run here
+    // at this time, the only known and approved use of this method is for the org edit form in totem web
 
-    self
-      .find({$where:'this.customer && this.customer.totemUrl && this.customer.totemUrl.length >=1'})
-      .exec(cb);
+    if (!cb) throw new Error('cb is required');
+    if (!id) { return cb(new Error('id is required'), null); }
+    if (!update) { return cb(new Error('update is required'), null); }
 
-  };
+    var self = this;
 
-  Organization.statics.listPage = function (skip, cb) {
+    // 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
 
-    this
-      .find({'deleted': {$ne: true}})
-      .sort('name')
-      .skip(skip)
-      .limit(100)
-      .exec(cb)
+    self.findByIdAndUpdate(id, update, { upsert: false, new: true }, cb);
 
   };
 
-  Organization.statics.removeById = function(id, cb) {
+  Organization.statics.removeCustomerFilters = function(customerId, cb) {
 
-    if (!id) { return cb(new Error('id is required'), null); }
-    if (!cb) { throw new Error('cb is required'); }
+    var self = this;
 
-    this.remove({_id: id}, cb);
+    self
+      .update(
+        { 'filters.customer': customerId },
+        { $pull : { 'filters': { 'customer': customerId } } },
+        { multi : true }
+      )
+      .exec(cb);
 
   };
 
@@ -2070,22 +1823,6 @@ module.exports = function(mongoose, config) {
 
   };
 
-  Organization.statics.setCustomerFunds = function setCustomerFunds(fundids) {
-    var self = this;
-    self.customerFunds = fundids;
-    return self.customerFunds;
-  };
-
-  Organization.statics.setCustomerPortfolio = function setCustomerPortfolio(portfolio) {
-    var self = this;
-    self.customerPortfolio = portfolio;
-    return self.customerPortfolio;
-  };
-
-  Organization.statics.stats = function stats(cb) {
-    this.collection.stats(cb);
-  };
-
   Organization.statics.upsert = function(org, username, cb) {
 
     if (!org) { return cb(new Error('Organization is required'), null); }
@@ -2101,56 +1838,138 @@ module.exports = function(mongoose, config) {
 
   };
 
-  Organization.statics.modify = function(filter, update, cb) {
 
-    // VERY IMPORTANT NOTE
-    // findByIdAndUpdate and findOneAndUpdate do not trigger pre-save hook so that code will not run here
-    // at this time, the only known and approved use of this method is for adding and removing roles in totem web
 
-    if (!cb) throw new Error('cb is required');
-    if (!filter) { return cb(new Error('filter is required'), null); }
-    if (!update) { return cb(new Error('update is required'), null); }
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // HOOKS
+  // Pre-save: fired on every document before it is saved
+  // Post-init: fired on every document when it's returned from a query
+  ///////////////////////////////////////////////////////////////////////////////////////
 
-    var self = this;
+  Organization.pre('save', function(next) {
 
-    // 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
+    let prepForSave = function prepForSave(doc) {
 
-    self.findOneAndUpdate(filter, update, { upsert: false, new: true }, cb);
+      var cleanContactInfo = function cleanContactInfo(obj) {
 
-  };
+        var thereCanOnlyBeOne = function thereCanOnlyBeOne(items) {
 
-  Organization.statics.modifyById = function(id, update, cb) {
+          var primaryItems = _.filter(items, function(item) { return item.primary; });
 
-    // VERY IMPORTANT NOTE
-    // findByIdAndUpdate and findOneAndUpdate do not trigger pre-save hook so that code will not run here
-    // at this time, the only known and approved use of this method is for the org edit form in totem web
+          if (primaryItems.length > 1) {
 
-    if (!cb) throw new Error('cb is required');
-    if (!id) { return cb(new Error('id is required'), null); }
-    if (!update) { return cb(new Error('update is required'), null); }
+            _.each(primaryItems, function(item, index) {
+              // skip the first one (leave it primary) and mark the rest as not primary
+              if (index >= 1) item.primary = false;
+            });
 
-    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
+          return items;
 
-    self.findByIdAndUpdate(id, update, { upsert: false, new: true }, cb);
+        };
 
-  };
+        if (!obj || !obj.contact) return;
 
+        if (obj.contact.address) {
 
+          // must have something meaningful
+          obj.contact.address = _.map(obj.contact.address, function(address) {
+            if (!address.city && !address.state && !address.country) return null;
+            else return address;
+          });
 
-  ///////////////////////////////////////////////////////////////////////////////////////
-  // HOOKS
-  // Pre-save: fired on every document before it is saved
-  // Post-init: fired on every document when it's returned from a query
-  ///////////////////////////////////////////////////////////////////////////////////////
+          // remove emptiness and dedupe
+          obj.contact.address = _.uniq(_.compact(obj.contact.address), function(item) { return item.city + item.state + item.country; });
 
+          // only one primary
+          obj.contact.address = thereCanOnlyBeOne(obj.contact.address);
 
-  Organization.pre('save', function(next) {
+        }
+
+        if (obj.contact.email) {
+
+          // must have something meaningful
+          obj.contact.email = _.map(doc.contact.email, function(item) {
+            if (!item.email) return null;
+            else return item;
+          });
+
+          // remove emptiness and dedupe
+          obj.contact.email = _.uniq(_.compact(obj.contact.email), function(item) { return item.email; });
+
+          // only one primary
+          obj.contact.email = thereCanOnlyBeOne(obj.contact.email);
+
+        }
+
+        if (obj.contact.phone) {
+
+          // must have something meaningful
+          obj.contact.phone = _.map(doc.contact.phone, function(item) {
+            if (!item.number) return null;
+            else return item;
+          });
+
+          // remove emptiness and dedupe
+          obj.contact.phone = _.uniq(_.compact(obj.contact.phone), function(item) { return item.number; });
+
+          // only one primary
+          obj.contact.phone = thereCanOnlyBeOne(obj.contact.phone);
+
+        }
+
+      };
+
+      var cleanPeople = function cleanPeople(obj) {
+
+        if (!obj || !obj.people) return;
+
+        // remove junk
+        obj.people = _.reject(obj.people, function(p) { return p.person == null; });
+
+        // dedupe
+        obj.people = _.uniq(obj.people, function(p) { return p.person._id ? p.person._id.toString() : p.person.toString(); });
+
+      };
+
+      var cleanWebsites = function cleanWebsites(obj) {
+
+        if (!obj) return;
+
+        // Format website
+        if (obj.website) {
+          obj.website = String(obj.website);
+          obj.website = obj.website.replace('http://', '').replace('https://', '').replace(/\/+$/, '');
+          obj.website = utils.getDomain(obj.website);
+        }
+
+        // Format website aliases
+        if (obj.websiteAliases && obj.websiteAliases.length >= 1) {
+          obj.websiteAliases = _.map(obj.websiteAliases, function(alias) {
+            alias = String(alias);
+            alias = alias.replace('http://', '').replace('https://', '').replace(/\/+$/, '');
+            return utils.getDomain(alias);
+          });
+        }
+
+        // Add website to website aliases
+        // There are unique constraints on website and website aliases
+        // This enables us to enforce uniqueness across both and across documents
+        if (obj.website && obj.websiteAliases) obj.websiteAliases.push(obj.website);
+
+        if (obj.websiteAliases) {
+          obj.websiteAliases = _.uniq(obj.websiteAliases);
+          obj.websiteAliases = _.compact(obj.websiteAliases);
+        }
+
+      };
+
+      cleanContactInfo(doc);
+      cleanPeople(doc);
+      cleanWebsites(doc);
+
+    };
 
     prepForSave(this);
 
@@ -2163,27 +1982,40 @@ module.exports = function(mongoose, config) {
     // Protect private data
     // Merge public and private data
 
-    var CUSTOMER_ID = config.CUSTOMER_ID;
-
-    if (CUSTOMER_ID == 'GLOBAL_PROCESS' && next) return next();
+    // const CUSTOMER_ID = this[CUSTOMER_ID];
+    // let err;
+    //
+    // if (!CUSTOMER_ID) {
+    //   err = new Error('Missing CUSTOMER_ID');
+    //   if (next) { return next(err); }
+    //   else { throw err; }
+    // }
+    //
+    // else if (CUSTOMER_ID === 'GLOBAL_PROCESS' && next) { return next(); }
+    //
+    // else if (!mongoose.Types.ObjectId.isValid(CUSTOMER_ID)) {
+    //   err = new Error('CUSTOMER_ID is not a valid ObjectId');
+    //   if (next) { return next(err); }
+    //   else { throw err; }
+    // }
 
     // remove customer details if not viewing self
-    if (doc._id.toString() != CUSTOMER_ID) doc.customer = {};
+    //if (doc._id.toString() !== CUSTOMER_ID) { doc.customer = {}; }
 
     // Website is stored in aliases to facilitate enforcing uniqueness
     // Remove it here to make it easier for consumers to provide a good ux
     // It will get added back in during pre save hook
     if (doc.website && doc.websiteAliases && doc.websiteAliases.length >= 1) {
-      doc.websiteAliases = _.reject(doc.websiteAliases, function(alias) { return alias == doc.website; });
+      doc.websiteAliases = _.reject(doc.websiteAliases, function(alias) { return alias === doc.website; });
     }
 
-    doc.lps = _.reject(doc.lps, function(item) { return !item.customer || item.customer.toString() != CUSTOMER_ID; });
-    doc.filters = _.reject(doc.filters, function(item) { return !item.customer || item.customer.toString() != CUSTOMER_ID; });
-    doc.valuations = _.reject(doc.valuations, function(item) { return !item.customer || item.customer.toString() != CUSTOMER_ID; });
-    doc.iLevel = _.reject(doc.iLevel, function(item) { return !item.customer || item.customer.toString() != CUSTOMER_ID; });
-    doc.chairs = _.reject(doc.chairs, function(item) { return !item.customer || item.customer.toString() != CUSTOMER_ID; });
-    doc.operating.acquired.private = _.find(doc.operating.acquired.private, function(item) { return !item.customer || item.customer.toString() == CUSTOMER_ID; });
-    doc.operating.closed.private = _.find(doc.operating.closed.private, function(item) { return !item.customer || item.customer.toString() == CUSTOMER_ID; });
+    // doc.lps = _.reject(doc.lps, function(item) { return !item.customer || item.customer.toString() !== CUSTOMER_ID; });
+    // doc.filters = _.reject(doc.filters, function(item) { return !item.customer || item.customer.toString() !== CUSTOMER_ID; });
+    // doc.valuations = _.reject(doc.valuations, function(item) { return !item.customer || item.customer.toString() !== CUSTOMER_ID; });
+    // doc.iLevel = _.reject(doc.iLevel, function(item) { return !item.customer || item.customer.toString() !== CUSTOMER_ID; });
+    // doc.chairs = _.reject(doc.chairs, function(item) { return !item.customer || item.customer.toString() !== CUSTOMER_ID; });
+    // doc.operating.acquired.private = _.find(doc.operating.acquired.private, function(item) { return !item.customer || item.customer.toString() === CUSTOMER_ID; });
+    // doc.operating.closed.private = _.find(doc.operating.closed.private, function(item) { return !item.customer || item.customer.toString() === CUSTOMER_ID; });
 
     // people
     _.each(doc.people, function(person) {
@@ -2191,10 +2023,6 @@ module.exports = function(mongoose, config) {
       // always include if explicitly public
       if (person.public) return;
 
-      // if not public, keep it in if org is in the current customer's portfolio. otherwise remove it.
-      // todo
-      //console.log(customerPortfolio);
-
     });
 
     if (next) return next();
@@ -2207,9 +2035,7 @@ module.exports = function(mongoose, config) {
   ///////////////////////////////////////////////////////////////////////////////////////
 
   Organization.set('toJSON', { virtuals: true });
-  Organization.set('usePushEach', true);
   Organization.set('autoIndex', false);
-  Organization.set('usePushEach', true);
 
   Organization.index({ website: 1,  websiteAliases: 1 }, { unique: true, partialFilterExpression : { type :"string" } });
   Organization.on('index', function(err) { console.log('error building organization_new indexes: ' + err); });