@dhyasama/totem-models 7.57.0 → 8.0.0

package/lib/Person.js

@@ -2,26 +2,21 @@
 
 module.exports = function(mongoose, config) {
 
-  var customerCompanyIds = [];
-
-  var
+  let
 
     Schema = mongoose.Schema,
     Organization = mongoose.model('Organization'),
-    Flag = mongoose.model('Flag'),
     Note = mongoose.model('Note'),
-    Crypto = require('@dhyasama/ffvc-crypto'),
-    crypto = new Crypto({'key': config.crypto.key}),
-    domain = config.domain,
+    Flag = mongoose.model('Flag'),
+    helpers = require('../helpers'),
     utils = require('@dhyasama/ffvc-utilities'),
     async = require('async'),
     _ = require('underscore'),
-    phoneFormatter = require('phone-formatter'),
     PhoneNumber = require( 'awesome-phonenumber'),
     validator = require('validator'),
     escapeStringRegexp = require('escape-string-regexp');
 
-  var Person = new Schema({
+  let Person = new Schema({
 
     name: {
       first: { type: String, default: '', index: true },
@@ -146,7 +141,7 @@ module.exports = function(mongoose, config) {
   });
 
   Person.virtual('avatar').get(function() {
-    return this.avatarUrl || domain + '/media/moustache.jpg';
+    return this.avatarUrl || '/media/moustache.jpg';
   });
 
   Person.virtual('email.primary').get(function () {
@@ -169,21 +164,42 @@ module.exports = function(mongoose, config) {
     return primary ? primary.number : '';
   });
 
-  Person.virtual('interactions.count').get(function () {
+  /////////////
+
+  Person.methods.addMerged = function(id) {
+    if (this.merged.indexOf(id) == -1) {
+     this.merged = this.merged.concat([id]);
+      return true;
+    }
+    else {
+      return false;
+    }
+  };
+
+  Person.methods.deletePerson = function() {
+    this.deleted = true;
+  };
+
+  Person.methods.interactionsCount = function(requestingCustomerId) {
+
+    const self = this;
+
+    if (!requestingCustomerId) { throw new Error('requestingCustomerId is required'); }
+    if (!mongoose.Types.ObjectId.isValid(requestingCustomerId)) { throw new Error('requestingCustomerId is not a valid ObjectId'); }
 
     // handle missing doc data
-    this.sources = this.sources || [];
+    self.sources = self.sources || [];
 
-    var calendarCount = 0;
-    var emailCount = 0;
+    let calendarCount = 0;
+    let emailCount = 0;
 
-    _.each(this.sources, function(source) {
+    _.each(self.sources, function(source) {
 
       // Only count interactions for the current customer
       // A universal interaction count isn't useful
-      var cid = mongoose.Types.ObjectId.isValid(source.customer) ? source.customer : source.customer._id;
+      let sourceCustomerId = mongoose.Types.ObjectId.isValid(source.customer) ? source.customer : source.customer._id;
 
-      if (cid.toString() == config.CUSTOMER_ID) {
+      if (sourceCustomerId.toString() === requestingCustomerId.toString()) {
         source.interactions = source.interactions || {};
         calendarCount += source.interactions.calendar || 0;
         emailCount += source.interactions.email || 0;
@@ -193,43 +209,6 @@ module.exports = function(mongoose, config) {
 
     return calendarCount + emailCount;
 
-  });
-
-  Person.virtual('allNotes').get(function () {
-
-    // todo - calendarEventNotes are now stored in the Interactions collection
-    // todo - should this be deprecated? research where it's used.
-
-    // combine direct person notes and notes from events this person attended
-    // sort reverse chronologically
-
-    var personNotes = this.notes || [];
-    personNotes = _.compact(personNotes);
-
-    // var eventNotes = _.pluck(this.calendarEventSummaries || [], 'notes');
-    // eventNotes = _.flatten(eventNotes);
-    // eventNotes = _.compact(eventNotes);
-
-    var result = _.sortBy(personNotes, 'createdOn');
-
-    return result.reverse();
-
-  });
-
-  /////////////
-
-  Person.methods.addMerged = function(id) {
-    if (this.merged.indexOf(id) == -1) {
-     this.merged = this.merged.concat([id]);
-      return true;
-    }
-    else {
-      return false;
-    }
-  };
-
-  Person.methods.deletePerson = function() {
-    this.deleted = true;
   };
 
   Person.methods.relatePerson = function(id) {
@@ -286,17 +265,315 @@ module.exports = function(mongoose, config) {
 
   };
 
-  /************* ACCESS **********************/
+////////////
+
+  Person.statics.addFlag = function(personId, creatorPersonId, text, customerId, cb) {
+
+    Flag.createForModel({
+      createdBy: creatorPersonId,
+      text: text,
+      customer: customerId
+    }, this, personId, cb);
 
-  Person.methods.funds = function() {
-    return getActiveFunds(this);
   };
 
-  Person.methods.isSubscriber = function() {
-    return this.subscriptions && this.subscriptions.length >= 1;
+  Person.statics.addNote = function(personId, creatorPersonId, text, isPrivate, customerId, cb) {
+
+    Note.createForModel({
+      createdBy: creatorPersonId,
+      text: text,
+      isPrivate: isPrivate,
+      customer: customerId
+    }, this, personId, cb);
+
   };
 
-////////////
+  Person.statics.deleteNote = function(noteId, cb) {
+
+    // Delete the note itself along with any references on people
+
+    const self = this;
+
+    let removePersonNoteReferences = function removePersonNoteReferences(callback) {
+      self.update({}, {
+        $pull: { 'notes' : [noteId] }
+      }, callback);
+    };
+
+    async.series([
+      Note.delete.bind(Note, noteId),
+      removePersonNoteReferences
+    ], function(err, results) {
+      return cb(err, null);
+    });
+
+  };
+
+  // Retrieve any person matching an email in the emails array parameter
+  Person.statics.findByEmails = function (emails, cb) {
+
+    this
+      .find({ 'contact.email.email': { $in : emails }, 'deleted': {$ne: true}})
+      .select('name avatarUrl title doNotDisplay')
+      .sort('name.full')
+      .exec(cb);
+
+  };
+
+  Person.statics.findBySocial = function findBySocial(value, cb) {
+
+    // Extract stand-alone username and append it to our standardized domains
+
+    const self = this;
+
+    if (!value) { return cb(new Error('value must be provided'), null); }
+
+    let username = utils.getUsernameFromUrl(value);
+
+    if (!username) { return cb(null, []); }
+
+    self
+      .find({ $or:
+          [
+            { 'social.facebook': new RegExp('facebook.com/' + username + '$/?', 'i') },
+            { 'social.linkedin': new RegExp('linkedin.com/in/' + username + '\/?$', 'i') },
+            { 'social.twitter': new RegExp('twitter.com/' + username + '/?$', 'i') }
+          ],
+        'deleted': { $ne: true }
+      })
+      .exec(cb);
+
+  };
+
+  Person.statics.getById = function (id, options, cb) {
+
+    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); }
+
+    self
+      .findById(id)
+      .select('-previous')
+      .populate('related')
+      .populate('sources.person', 'avatarUrl name title doNotDisplay')
+      .exec(function (err, person) {
+
+        if (err) return cb(err, null);
+        else if (!person) return cb(null, null);
+
+        person = helpers.cleanPerson(person, options.CUSTOMER_ID);
+
+        person.sources = _.sortBy(person.sources, function(source) {
+          return source.interactions.calendar + source.interactions.email;
+        }).reverse();
+
+        return cb(null, person);
+
+      });
+
+  };
+
+  Person.statics.getByIdNoPopulate = function (id, options, cb) {
+
+    // only for worker
+
+    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); }
+
+    options = helpers.getDefaultOptions(options);
+
+    if (!options.isWorkerProcess) { return cb(null, null); }
+
+    self.findById(id).exec(cb);
+
+  };
+
+  Person.statics.getByIds = function (ids, options, cb) {
+
+    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 }, 'deleted': {$ne: true} })
+      .exec(function(err, people) {
+
+        if (err) { return cb(err, null); }
+        else if (!people) { return cb(null, []); }
+
+        people = _.map(people, function(person) {
+          return helpers.cleanPerson(person, options.CUSTOMER_ID);
+        });
+
+        return cb(null, people);
+
+      });
+  };
+
+  Person.statics.getFlags = function getFlags(personId, options, cb) {
+
+    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); }
+
+    const self = this;
+    let query = self.findById(personId);
+
+    query.select('flags');
+    query.populate({
+      path: 'flags',
+      match: { customer: options.CUSTOMER_ID }
+    });
+    query.deepPopulate([
+      'flags.createdBy'
+    ], {
+      populate: {
+        'flags.createdBy': { select: 'name avatarUrl title' }
+      }
+    });
+    query.sort({'createdOn':-1});
+
+    query.exec(cb);
+
+  };
+
+  Person.statics.getList = function getList(cb) {
+
+    var self = this;
+
+    self
+      .find({'deleted': {$ne: true}})
+      .select('name contact.email')
+      .lean()
+      .exec(cb);
+
+  };
+
+  Person.statics.getNotes = function getNotes(personId, options, cb) {
+
+    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); }
+
+    const self = this;
+    let query = self.findById(personId);
+
+    query.select('notes');
+    query.populate({
+      path: 'notes',
+      match: { customer: options.CUSTOMER_ID }
+    });
+    query.deepPopulate([
+      'notes.createdBy'
+    ], {
+      populate: {
+        'notes.createdBy': { select: 'name avatarUrl title' }
+      }
+    });
+    query.sort({'createdOn':-1});
+
+    query.exec(cb);
+
+  };
+
+  Person.statics.getSources = 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); }
+    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); }
+
+    const self = this;
+
+    // get the person
+    let query = self.findById(id);
+
+    query.populate('sources.person');
+
+    query.exec(function(err, person) {
+
+      if (err) { return cb(err, null); }
+      if (!person) { return cb(err, null); }
+
+      // get the customer's org
+      Organization.collection.findById(options.CUSTOMER_ID, function(err, customer) {
+
+        if (err) { return cb(err, null); }
+        if (!customer) { return cb(null, null); }
+
+        let current = [];
+        let past = [];
+        let all = [];
+
+        // look at each person at customer
+        // if person is a source, add to list(s)
+        _.each(customer.people, function(p) {
+
+          let source = _.find(person.sources, function(ps) {
+            if (!ps || !ps.person || !ps.person._id) { return false; }
+            return ps.person._id.toString() === p.person.toString();
+          });
+
+          if (!source) { return; }
+
+          if (p.current) { current.push(source); }
+          if (!p.current) { past.push(source); }
+
+          all.push(source);
+
+        });
+
+        // return categorized sources
+        return cb(null, {
+          all: all,
+          current: current,
+          past: past
+        });
+
+      });
+
+    });
+  };
+
+  Person.statics.modifyById = function(id, update, cb) {
+
+    // VERY IMPORTANT NOTE
+    // findByIdAndUpdate and findOneAndUpdate do not trigger pre-save hook so that code will not run here
+
+    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); }
+
+    const 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
+
+    self.findByIdAndUpdate(id, update, { upsert: false, new: true }, cb);
+
+  };
 
   // search for people based on fields provided
   // Data format, everything is optional
@@ -642,491 +919,15 @@ module.exports = function(mongoose, config) {
 
     this
       .find({ 'contact.email.email': email, 'deleted': {$ne: true} })
+      .select('name avatarUrl')
       .exec(cb);
 
   };
 
-  Person.statics.findDupes = function(person, options, cb) {
+  Person.statics.upsert = function(currentPerson, username, cb) {
 
-    if (!cb) throw new Error('cb is required');
-    if (!person) return cb(null, []);
-
-    var emails = [];
-    if (person.contact && person.contact.email) {
-      // pluck emails
-      emails = _.map(person.contact.email, function(email) {
-        return email.email;
-      });
-    }
-
-    var phones = [];
-    if (person.contact && person.contact.phone) {
-      // pluck and normalize phone numbers
-      phones = _.map(person.contact.phone, function(phone) {
-        return phoneFormatter.normalize(phone.number);
-      });
-    }
-
-    // Sometimes clients pass in something like { name: 'Jason Reynolds' } rather than { name: { first: 'Jason', last: 'Reynolds' } }
-    // Parse it out as a courtesy
-    if (!person.name.first && !person.name.last) {
-      var fullName = person.name;
-      person = {
-        name: {
-          first: fullName.split(" ")[0],
-          last: fullName.split(" ")[1]
-        }
-      };
-    }
-
-    // Require names that are at least two characters long
-    if (person.name.first.length < 2) person.name.first = '';
-    if (person.name.last.length < 2) person.name.last = '';
-
-    this.search({
-      emails: emails,
-      phones: phones,
-      name: person.name
-    }, options, function(err, people) {
-
-      if (err) return cb(err, null);
-      if (!people) return cb(null, null);
-
-      // exclude passed in person from results
-      people = _.reject(people, function(p) {
-        return p.id == person.id;
-      });
-
-      return cb(null, people);
-
-    });
-
-  };
-
-  Person.statics.findBySocial = function findBySocial(value, cb) {
-
-    // Extract stand-alone username and append it to our standardized domains
-
-    var self = this;
-
-    if (!value) { return cb(new Error('value must be provided'), null); }
-
-    var username = utils.getUsernameFromUrl(value);
-
-    if (!username) { return cb(null, []); }
-
-    self
-      .find({ $or:
-          [
-            { 'social.facebook': new RegExp('facebook.com/' + username + '$/?', 'i') },
-            { 'social.linkedin': new RegExp('linkedin.com/in/' + username + '\/?$', 'i') },
-            { 'social.twitter': new RegExp('twitter.com/' + username + '/?$', 'i') }
-          ],
-        'deleted': { $ne: true }
-      })
-      .exec(cb);
-
-  };
-
-  Person.statics.stats = function (cb) {
-    this.collection.stats(cb);
-  };
-
-  Person.statics.getById = function (id, cb) {
-
-    this
-      .findById(id)
-      .select('-previous')
-      .populate('related')
-      .populate('sources.person', 'avatarUrl name title doNotDisplay')
-      .exec(function (err, person) {
-
-        if (err) return cb(err, null);
-        else if (!person) return cb(null, null);
-
-        person.sources = _.sortBy(person.sources, function(source) {
-          return source.interactions.calendar + source.interactions.email;
-        }).reverse();
-
-        return cb(null, person);
-
-      });
-
-  };
-
-  Person.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 PERSON.GETBYIDGLOBAL');
-      console.log('config.CUSTOMER_ID', config.CUSTOMER_ID);
-      console.log(err);
-
-      return cb(err, null);
-
-    }
-
-  };
-
-  Person.statics.getByIdRaw = function (id, cb) {
-
-    // directly from mongo driver to avoid mongoose middlewares
-
-    var self = this;
-
-    self.collection.findOne({ "_id": id }, cb);
-
-  };
-
-  Person.statics.getByIdNoPopulate = function (id, cb) {
-
-    this
-      .findById(id)
-      .exec(cb);
-
-  };
-
-  Person.statics.getByIds = function (ids, cb) {
-    this
-      .find({ '_id': { $in : ids }, 'deleted': {$ne: true} })
-      .exec(cb);
-  };
-
-  Person.statics.getList = function getList(cb) {
-
-    var self = this;
-
-    self
-      .find({'deleted': {$ne: true}})
-      .select('name contact.email')
-      .lean()
-      .exec(cb);
-
-  };
-
-  Person.statics.getFlags = function getFlags(personId, cb) {
-
-    var self = this;
-    var query = self.findById(personId)
-
-    query.select('flags')
-    query.populate({
-      path: 'flags',
-      match: { customer: config.CUSTOMER_ID }
-    })
-    query.deepPopulate([
-      'flags.createdBy'
-    ], {
-      populate: {
-        'flags.createdBy': { select: 'name avatarUrl title' }
-      }
-    })
-    query.sort({'createdOn':-1})
-    query.exec(cb);
-
-  };
-
-  Person.statics.getNotes = function getNotes(personId, cb) {
-
-    var self = this;
-    var query = self.findById(personId)
-
-    query.select('notes')
-    query.populate({
-      path: 'notes',
-      match: { customer: config.CUSTOMER_ID }
-    })
-    query.deepPopulate([
-      'notes.createdBy'
-    ], {
-      populate: {
-        'notes.createdBy': { select: 'name avatarUrl title' }
-      }
-    })
-    query.sort({'createdOn':-1})
-    query.exec(cb);
-
-  };
-
-  // Retrieve any person matching an email in the emails array parameter
-  Person.statics.findByEmails = function (emails, cb) {
-
-    // sort is done post retrieval because query sort is done pre-decryption
-
-    this
-      .find({ 'contact.email.email': { $in : emails }, 'deleted': {$ne: true}})
-      .select('name avatarUrl title doNotDisplay contact')
-      .exec(function (err, people) {
-        cb(err, _.sortBy(people, function(person) { return person.name.full; }));
-      });
-
-  };
-
-  // Retrieve any person matching an email in the emails array parameter
-  Person.statics.findByEmailsSkinny = function (emails, cb) {
-    this
-      .find({ 'contact.email.email': { $in : emails }, 'deleted': {$ne: true}})
-      .exec(cb);
-  };
-
-  Person.statics.findBySlug = function (slug, cb) {
-    this
-      .find({ slug: new RegExp(slug, 'i'), 'deleted': {$ne: true} })
-      .exec(cb);
-  };
-
-  Person.statics.findBySlugs = function (slugs, cb) {
-    this
-      .find({ 'slug': { $in : slugs } })
-      .exec(cb);
-  };
-
-  Person.statics.findByUniqueInfo = function (email, cb) {
-
-    // useful for not inserting dupes
-    // could expand this to check other fields
-    // but really should be replaced by search
-
-    this.findOne({
-      $or: [
-        { 'contact.email': { $elemMatch: {'email': crypto.encrypt(email)} }},
-        { 'contact.email': { $elemMatch: {'email': email} }}
-      ]})
-      .populate('account boards.company leadership.company chairs.first.company chairs.second.company')
-      .exec(cb);
-
-  };
-
-  Person.statics.getSources = function (id, cb) {
-    this
-      .findById(id)
-      .populate('sources.person')
-      .exec(function(err, person) {
-
-        if (err) return cb(err, null);
-        if (!person) return cb(err, null);
-
-        Organization.findById(config.CUSTOMER_ID, function(err, customer) {
-
-          if (err) return cb(err, null);
-          if (!customer) return cb(null, null);
-
-          var current = [];
-          var past = [];
-          var all = [];
-
-          _.each(customer.people, function(p) {
-
-            var source = _.find(person.sources, function(ps) {
-              if (!ps || !ps.person || !ps.person._id) return false;
-              return ps.person._id.toString() == p.person.toString();
-            });
-
-            if (!source) return;
-
-            if (p.current) current.push(source);
-            if (!p.current) past.push(source);
-            all.push(source);
-
-          });
-
-          return cb(null, {
-            all: all,
-            current: current,
-            past: past
-          });
-
-        });
-
-      });
-  };
-
-  Person.statics.listAllPeople = function (cb) {
-
-    // sort is done post retrieval because query sort is done pre-decryption
-
-    var query = this.find({'deleted': {$ne: true}});
-    query.populate('account chairs.first.company chairs.second.company');
-    query.exec(function (err, people) {
-      cb(err, _.sortBy(people, function(person) { return person.name.full; }));
-    });
-
-  };
-
-  Person.statics.listMostRecentPeople = function (cb) {
-
-    // sort is done post retrieval because query sort is done pre-decryption
-
-    this
-      .find({'deleted': {$ne: true}})
-      .sort({'_id': 1})
-      .limit(100)
-      .exec(function (err, people) {
-        cb(err, _.sortBy(people, function(person) { return person.name.full; }));
-      });
-
-  };
-
-  Person.statics.listPage = function (skip, cb) {
-
-    this
-      .find({'deleted': {$ne: true}})
-      .sort({'name.first':1, 'name.last':1})
-      .skip(skip)
-      .limit(100)
-      .exec(cb);
-
-  };
-
-  Person.statics.listAllPeopleNoPop = function (cb) {
-
-    // sort is done post retrieval because query sort is done pre-decryption
-
-    var query = this.find({'deleted': {$ne: true}});
-    query.exec(function (err, people) {
-      cb(err, _.sortBy(people, function(person) { return person.name.full; }));
-    });
-
-  };
-
-  Person.statics.listAllFlaggedPeople = function (cb) {
-
-    this
-      .find({'flagged.resolved': false, 'flagged.text': { $ne: '' }, 'deleted': {$ne: true}})
-      .exec(function (err, people) {
-        people = _.sortBy(people, function(person){
-          var timestamp = new Date(person.flagged.on);
-          timestamp = timestamp.getTime();
-          return timestamp;
-        });
-        people = people.reverse();
-
-        cb(err, people);
-      });
-
-  };
-
-  Person.statics.listAllPeopleWithoutAccounts = function (cb) {
-
-    // sort is done post retrieval because query sort is done pre-decryption
-
-    this
-      .find({account: {$exists: false}, 'deleted': {$ne: true}})
-      .exec(function (err, people) {
-        cb(err, _.sortBy(people, function(person) { return person.name.full; }));
-      });
-
-  };
-
-  Person.statics.listForSubscription = function (subscriptionId, cb) {
-
-    this
-      .find({ 'subscriptions.id': subscriptionId, 'deleted': {$ne: true}})
-      .exec(function(err, people) {
-        cb(err, people);
-      });
-
-  };
-
-  Person.statics.addChair = function(personId, chairPos, companyId, cb) {
-
-    this.findById(personId).exec(function(err, person) {
-
-      var chairObj = {
-        company: companyId,
-        start: ''
-      };
-
-      switch(chairPos) {
-        case 'first':
-          person.chairs.first.push(chairObj);
-          break;
-
-        case 'second':
-          person.chairs.second.push(chairObj);
-          break;
-      }
-
-      person.save(cb);
-
-    });
-
-  };
-
-  //same function for flag resolved and unresolved... all based on true|false resolved arg
-  Person.statics.flag = function(personId, resolved, text, username, cb) {
-
-    this.findById(personId).exec(function(err, person) {
-
-      if (!person) return cb(new Error('person not found'), null);
-
-      person.flagged.resolved = resolved;
-      person.flagged.text = text;
-      person.flagged.by = username;
-      person.flagged.on = Date.now();
-
-      person.save(cb);
-
-    });
-
-  };
-
-  Person.statics.setCustomerCompanyIds = function(ids) {
-    customerCompanyIds = ids;
-  };
-
-  Person.statics.modifyById = function(id, update, cb) {
-
-    // VERY IMPORTANT NOTE
-    // findByIdAndUpdate and findOneAndUpdate do not trigger pre-save hook so that code will not run here
-
-    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;
-
-    // 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.findByIdAndUpdate(id, update, { upsert: false, new: true }, cb);
-
-  };
-
-  Person.statics.upsert = function(currentPerson, username, cb) {
-
-    if (!currentPerson) { return cb(new Error('Current Person is required'), null); }
-    if (!username) { return cb(new Error('Username is required'), null); }
+    if (!currentPerson) { return cb(new Error('Current Person is required'), null); }
+    if (!username) { return cb(new Error('Username is required'), null); }
 
     currentPerson.entered = {
       by: username,
@@ -1137,96 +938,8 @@ module.exports = function(mongoose, config) {
 
   };
 
-  Person.statics.addFlag = function(personId, creatorPersonId, text, cb) {
-
-    Flag.createForModel({
-      createdBy: creatorPersonId,
-      text: text
-    }, this, personId, cb);
-
-  };
-
-  Person.statics.addNote = function(personId, creatorPersonId, text, isPrivate, cb) {
-
-    Note.createForModel({
-      createdBy: creatorPersonId,
-      text: text,
-      isPrivate: isPrivate
-    }, this, personId, cb);
-
-  };
-
-  Person.statics.deleteFlag = function(flagId, cb) {
-
-    // Delete the flag itself along with reference on person
-
-    var self = this;
-
-    var removeReference = function removeReference(callback) {
-      self.update({}, {
-        $pull: { 'flags' : [flagId] }
-      }, callback);
-    };
-
-    async.series([
-      Flag.delete.bind(Flag, flagId),
-      removeReference
-    ], function(err, results) {
-      return cb(err, null);
-    });
-
-  };
-
-  Person.statics.deleteNote = function(noteId, cb) {
-
-    // Delete the note itself along with any references on people
-
-    var self = this;
-
-    var removePersonNoteReferences = function removePersonNoteReferences(callback) {
-      self.update({}, {
-        $pull: { 'notes' : [noteId] }
-      }, callback);
-    };
-
-    // var removeEventNoteReferences = function removeEventNoteReferences(callback) {
-    //   self.update({
-    //     'calendarEventSummaries.notes': noteId
-    //   }, {
-    //     $pull: { 'calendarEventSummaries.$.notes' : [noteId] }
-    //   }, callback);
-    // };
-
-    async.series([
-      Note.delete.bind(Note, noteId),
-      removePersonNoteReferences,
-      //removeEventNoteReferences
-    ], function(err, results) {
-      return cb(err, null);
-    });
-
-  };
-
 ///////////////
 
-  Person.post('remove', function(doc) {
-    // Account.person
-    // Investor.people
-    // Investor.formerPeople
-    // LimitedPartner.person
-    // Organization.people.person
-    // Person.merged
-    // Person.related
-    // Person.calendarEventSummaries.attendees.internal
-    // Person.calendarEventSummaries.attendees.external
-    // PortfolioCompany.chairs.first
-    // PortfolioCompany.chairs.second
-    // PortfolioCompany.boards
-    // PortfolioCompany.leadership.person
-    // PortfolioCompany.people.person
-    // PortfolioCompany.formerPeople
-  });
-
   Person.pre('save', function(next) {
 
     var self = this;
@@ -1327,31 +1040,10 @@ module.exports = function(mongoose, config) {
 
   });
 
-  Person.post('init', function() {
-
-    var self = this;
-    var CUSTOMER_ID = config.CUSTOMER_ID;
-
-    var protectSources = function protectSources(person) {
-
-      if (CUSTOMER_ID == 'GLOBAL_PROCESS') return;
-
-      person.sources = _.reject(person.sources, function(source) {
-        var customerId = mongoose.Types.ObjectId.isValid(source.customer) ? source.customer : source.customer._id;
-        return customerId.toString() != CUSTOMER_ID.toString();
-      });
-
-    };
-
-    protectSources(self);
-
-  });
-
-  var deepPopulate = require('mongoose-deep-populate')(mongoose);
+  let deepPopulate = require('mongoose-deep-populate')(mongoose);
   Person.plugin(deepPopulate);
 
   Person.set('autoIndex', false);
-  Person.set('usePushEach', true);
   Person.on('index', function(err) { console.log('error building person indexes: ' + err); });
 
   Person.set('toJSON', { virtuals: true });