@dhyasama/totem-models 7.58.0 → 8.0.1

package/lib/LimitedPartner.js

@@ -1,33 +1,25 @@
-"use strict";
+'use strict';
 
 module.exports = function(mongoose, config) {
 
-  var
+  let
 
-    CUSTOMER_ID = config.CUSTOMER_ID,
-    LPS_ENABLED = config.LPS_ENABLED,
     Schema = mongoose.Schema,
     Flag = mongoose.model('Flag'),
-    Fund = mongoose.model('Fund'),
     Note = mongoose.model('Note'),
     Organization = mongoose.model('Organization'),
-    env = process.env.NODE_ENV || 'development',
-    Crypto = require('@dhyasama/ffvc-crypto'),
-    crypto = new Crypto({'key': config.crypto.key}),
     filter = require('mongoose-filter-denormalize').filter,
     _ = require('underscore'),
     async = require('async'),
-    utils = require('@dhyasama/ffvc-utilities');
+    helpers = require('../helpers');
 
-  var customerFunds = [];
-
-  var LimitedPartner = new Schema({
+  let LimitedPartner = new Schema({
 
     name: { type: String, index: true, required: true },
 
     shortName: { type: String, default: '' },
 
-    customer: { type: Schema.ObjectId, ref: 'Organization' },
+    customer: { type: Schema.ObjectId, ref: 'Organization', required: true },
 
     start: { type: String, default: '' },
 
@@ -45,11 +37,10 @@ module.exports = function(mongoose, config) {
       quarterlyAccountStatement: { type: String, default: '' }
     },
 
-    transactions: [{
+    fundsInvested: [{
       fund: {type: Schema.ObjectId, ref: 'Fund'},
-      type: { type: String, enum: ['commitment', 'contribution', 'distribution'] },
-      amount: { type: Number, default: 0 },
-      date: { type: Date, default: null },
+      committed: {type: Number, default: 0},
+      called: {type: Number, default: 0}
     }],
 
     contact: {
@@ -79,69 +70,6 @@ module.exports = function(mongoose, config) {
 
     },
 
-    distributions: {
-
-      typeOf: { type: String, required: false, enum: [null, '', 'ACH', 'Check'] },
-
-      ach: {
-
-        stripeRecipientId:  { type: String, default: ''},
-        legalName:          { type: String, default: ''},
-        accountType:        { type: String, required: false, enum: [null, '', 'Checking', 'Savings']},
-        taxId:              { type: String, default: ''},
-        verified:           { type: Boolean, default: false },
-
-        challengeDeposits: [{
-          id:      { type: String },
-          created: { type: Date },
-          amount:  { type: Number },
-          status:  { type: String }
-        }],
-
-        bankAccount: {
-          name:           { type: String, default: '' },
-          country:        { type: String, default: '' },
-          routingNumber:  { type: String, default: '' },
-          accountNumber:  { type: String, default: '' }
-        }
-
-      },
-
-      check: {
-        address: {
-          addressOne: { type: String, default: '' },
-          addressTwo: { type: String, default: '' },
-          city:       { type: String, default: '' },
-          state:      { type: String, default: '' },
-          country:    { type: String, default: '' },
-          postalCode: { type: String, default: '' }
-        }
-      }
-
-    },
-
-    k1: {
-      nameOfInvestor: { type: String, default: '' },
-      legalAddress: {
-        addressOne: { type: String, default: '' },
-        addressTwo: { type: String, default: '' },
-        city:       { type: String, default: '' },
-        state:      { type: String, default: '' },
-        country:    { type: String, default: '' },
-        postalCode: { type: String, default: '' }
-      },
-      EIN: { type: String, default: null },
-      entityType: { type: String, enum: [null, 'Individual', 'Trust', 'Partnership', 'Corporation', 'LLC-Partnership', 'LLC-Corporation'] },
-      taxExempt: { type: Boolean, default: false },
-      USBased: { type: Boolean, default: true },
-      fundOrFundOfFunds: { type: Boolean, default: false },
-      deliverTo: [{type: String }],
-      consented: { type: Boolean, default: false },
-      changedBy: { type: String, default: null },
-      changedOn: { type: Date, default: null },
-      complete: { type: Boolean, default: false }
-    },
-
     entered: {
       by: { type: String, default: '' },
       on: { type: Date, default: Date.now }
@@ -166,96 +94,22 @@ module.exports = function(mongoose, config) {
 
   });
 
-  var getSources = function getSources(people) {
-
-    var 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; });
-    result = _.sortBy(result, 'interactions.count');
-    result.reverse();
-    result = _.sortBy(result, 'name.full');
-
-    console.log(result);
-
-    return result;
-
-  };
-
 /////////////////////
 
-  LimitedPartner.virtual('totalCommitment').get(function () {
-    var self = this;
-    return _.reduce(self.transactions, function(memo, transaction) {
-      return memo + ((transaction.type == 'commitment' && transaction.amount > 0) ? transaction.amount : 0);
-    }, 0);
-  });
-
-  LimitedPartner.virtual('totalContribution').get(function () {
-    var self = this;
-    return _.reduce(self.transactions, function(memo, transaction) {
-      return memo + ((transaction.type == 'contribution' && transaction.amount > 0) ? transaction.amount : 0);
-    }, 0);
-  });
-
-  LimitedPartner.virtual('totalDistribution').get(function () {
-    var self = this;
-    return _.reduce(self.transactions, function(memo, transaction) {
-      return memo + ((transaction.type == 'distribution' && transaction.amount > 0) ? transaction.amount : 0);
-    }, 0);
-  });
-
-  LimitedPartner.virtual('fundsInvested').get(function () {
-    
-    var self = this;
-    var fundsInvested = [];
-    
-    _.each(self.transactions, function(transaction) {
-      
-      var fundMatch = _.find(fundsInvested, function(fund) { return fund._id == transaction.fund._id; });
-      
-      if(!fundMatch) {
-        fundsInvested.push({
-          _id: transaction.fund._id,
-          name: transaction.fund.name,
-          shortName: transaction.fund.shortName,
-          abbreviation: transaction.fund.abbreviation,
-          commitment: 0,
-          contribution: 0,
-          distribution: 0
-        });
-        fundMatch = _.last(fundsInvested);
-      }
-
-      // and increment the transaction type by the transaction amount
-      fundMatch[transaction.type] += transaction.amount;
-
-    });
-   
-    return fundsInvested;
-  
+  LimitedPartner.virtual('totalCommitted').get(function () {
+    const self = this;
+    return _.reduce(self.fundsInvested, function(memo, fund) { return memo + (fund.committed > 0 ? fund.committed : 0); }, 0);
   });
 
   LimitedPartner.virtual('email.primary').get(function () {
-    var primary = _.find(this.contact.email, function(email) {
+    let primary = _.find(this.contact.email, function(email) {
       return email.primary;
     });
     return primary ? primary.email : '';
   });
 
   LimitedPartner.virtual('phone.primary').get(function () {
-    var primary = _.find(this.contact.phone, function(phone) {
+    let primary = _.find(this.contact.phone, function(phone) {
       return phone.primary;
     });
     return primary ? primary.number : '';
@@ -263,7 +117,7 @@ module.exports = function(mongoose, config) {
 
   LimitedPartner.virtual('address.primary').get(function () {
 
-    var primary = _.find(this.contact.address, function(address) {
+    let primary = _.find(this.contact.address, function(address) {
       return address.primary;
     });
 
@@ -289,7 +143,7 @@ module.exports = function(mongoose, config) {
 
   LimitedPartner.methods.newBasic = function(field, value) {
 
-    var compoundField = false;
+    let compoundField = false;
     if(field.split(".").length > 1) {
       compoundField = true;
     }
@@ -297,8 +151,8 @@ module.exports = function(mongoose, config) {
     if(!compoundField) {
       this[field] = value;
     } else {
-      var parentField = field.split('.')[0];
-      var childField = field.split('.')[1];
+      let parentField = field.split('.')[0];
+      let childField = field.split('.')[1];
 
       this[parentField][childField] = value;
     }
@@ -307,21 +161,19 @@ module.exports = function(mongoose, config) {
 
   LimitedPartner.methods.updateBasic = function(field, value) {
 
-    var compoundField = false;
-    if(field.split(".").length > 1) {
-      compoundField = true;
-    }
+    const self = this;
 
-    if(!compoundField) {
-      var currentVal = this[field];
-      this[field] = value;
-    } else {
-      var parentField = field.split('.')[0];
-      var childField = field.split('.')[1];
+    let isCompoundField = field.split(".").length > 1;
+
+    if (isCompoundField) {
+
+      let parentField = field.split('.')[0];
+      let childField = field.split('.')[1];
+
+      self[parentField][childField] = value;
 
-      var currentVal = this[parentField][childField];
-      this[parentField][childField] = value;
     }
+    else { self[field] = value; }
 
   };
 
@@ -329,10 +181,12 @@ module.exports = function(mongoose, config) {
 
   LimitedPartner.methods.updateContact = function(field, value) {
 
-    var parentField = field.split('.')[0];
-    var childField = field.split('.')[1];
+    const self = this;
+
+    let parentField = field.split('.')[0];
+    let childField = field.split('.')[1];
 
-    this[parentField][childField] = value;
+    self[parentField][childField] = value;
 
   };
 
@@ -340,12 +194,14 @@ module.exports = function(mongoose, config) {
 
   LimitedPartner.methods.addPerson = function(idOfPersonToAdd) {
 
-    var match = _.find(this.people, function(person) {
-      var personId = utils.isValidObjectId(person) ? person : person.id;
-      return personId.toString() == idOfPersonToAdd.toString();
+    const self = this;
+
+    let match = _.find(self.people, function(person) {
+      let personId = mongoose.Types.ObjectId.isValid(person) ? person : person.id;
+      return personId.toString() === idOfPersonToAdd.toString();
     });
 
-    if (!match) this.people.push(idOfPersonToAdd);
+    if (!match) { self.people.push(idOfPersonToAdd); }
 
   };
 
@@ -356,381 +212,325 @@ module.exports = function(mongoose, config) {
     });
 
   };
-  
-  LimitedPartner.methods.docSlugs = function() {
-
-    var slugs = this.documentSlugs;
-    var fullName = this.name;
 
-    slugs.annualAudit = slugs.annualAudit || fullName;
-    slugs.capitalCall = slugs.capitalCall || fullName;
-    slugs.portfolioHolding = slugs.portfolioHolding || fullName;
-    slugs.k1 = slugs.k1 || fullName;
-    slugs.distribution = slugs.distribution || fullName;
-    slugs.quarterlyAccountStatement = slugs.quarterlyAccountStatement || fullName;
-
-    return slugs;
+////////////////////////
 
-  };
+  LimitedPartner.statics.addFlag = function(lpid, creatorPersonId, text, customerId, cb) {
 
-////////////////////////
+    Flag.createForModel({
+      createdBy: creatorPersonId,
+      text: text,
+      customer: customerId
+    }, this, lpid, cb);
 
-  LimitedPartner.statics.findByTransaction = function (id, role, cb) {
-    this
-      .find({ 'distributions.ach.challengeDeposits.id': id }, this.getReadFilterKeys(role))
-      .exec(cb);
   };
 
-  LimitedPartner.statics.getById = function(customerId, lpId, role, cb) {
-
-    var self = this;
-    var query;
-    var getLp = function() {
-      query.populate('transactions.fund');
-      query.populate('people');
-      query.populate('notes');
-      query.deepPopulate([
-        'people.sources.person',
-        'people.calendarEventSummaries.attendees.internal',
-        'people.calendarEventSummaries.attendees.external',
-        'notes.createdBy',
-        'people.calendarEventSummaries.notes.createdBy'
-      ], {
-        populate: {
-          'people.sources.person': { select: 'name avatarUrl title' },
-          'people.calendarEventSummaries.attendees.internal': { select: 'name avatarUrl title' },
-          'people.calendarEventSummaries.attendees.external': { select: 'name avatarUrl title' },
-          'notes.createdBy': { select: 'name avatarUrl' },
-          'people.calendarEventSummaries.notes.createdBy': {select: ' avatarUrl name' }
-        }
-      });
-      query.exec(cb);
-    };
+  LimitedPartner.statics.addNote = function(lpid, creatorPersonId, text, isPrivate, customerId, cb) {
 
-    if (CUSTOMER_ID == 'GLOBAL_PROCESS') {
-      query = self.findById(lpId, self.getReadFilterKeys(role))
-      getLp();
-    }
-    else {
-      query = self.findOne({ '_id': lpId, 'customer': customerId, 'transactions.fund': { $in : self.customerFunds }}, self.getReadFilterKeys(role));
-      getLp();
-    }
+    Note.createForModel({
+      createdBy: creatorPersonId,
+      text: text,
+      isPrivate: isPrivate,
+      customer: customerId
+    }, this, lpid, cb);
 
   };
 
-  LimitedPartner.statics.getByPersonId = function(personId, role, cb) {
+  LimitedPartner.statics.deleteFlag = function(flagId, cb) {
 
-    var self = this;
-    var query;
+    // Delete the flag itself along with any references
 
-    var getLps = function(q) {
-      q.populate('transactions.fund')
-      q.populate('people', 'name')
-      q.exec(function (err, lps) {
-        if (err) return cb(err, null);
-        lps = _.sortBy(lps, function(lp) { return lp.name ? lp.name.toLowerCase() : ''; });
-        return cb(null, lps);
-      });
+    const self = this;
+
+    let removeReferences = function removeReferences(callback) {
+      self.update({}, {
+        $pull: { 'flags' : [flagId] }
+      }, callback);
     };
 
-    if (CUSTOMER_ID == 'GLOBAL_PROCESS') {
-      query = self.find({'people': personId}, this.getReadFilterKeys(role))
-      getLps(query);
-    }
-    else {
-      query = self.find({'people': personId, 'transactions.fund': { $in : self.customerFunds }}, self.getReadFilterKeys(role));
-      getLps(query);
-    }
+    async.series([
+      Flag.delete.bind(Flag, flagId),
+      removeReferences
+    ], function(err, results) {
+      return cb(err, null);
+    });
 
   };
 
-  LimitedPartner.statics.getByName = function(customerId, lpName, role, cb) {
+  LimitedPartner.statics.deleteNote = function(noteId, customerId, cb) {
 
-    var self = this;
-    var query;
+    // Delete the note itself along with any references
 
-    var getLps = function() {
-      query.populate('transactions.fund');
-      query.exec(cb);
+    const self = this;
+
+    let removeReferences = function removeReferences(callback) {
+      self.update({}, {
+        $pull: { 'notes' : [noteId] }
+      }, callback);
     };
 
-    query = self.find({'customer': customerId, 'name': lpName}, self.getReadFilterKeys(role));
-    getLps();
+    async.series([
+      Note.delete.bind(Note, noteId, customerId),
+      removeReferences
+    ], function(err, results) {
+      return cb(err, null);
+    });
 
   };
 
-  LimitedPartner.statics.getFlags = function getFlags(lpid, cb) {
+  LimitedPartner.statics.getById = function(id, options, cb) {
 
-    var self = this;
-    var query = self.findById(lpid)
+    const self = this;
 
-    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);
+    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 = helpers.getDefaultOptions(options);
 
-  LimitedPartner.statics.getNotes = function getNotes(lpid, cb) {
+    let query;
 
-    var self = this;
-    var query = self.findById(lpid)
+    if (options.isWorkerProcess) {
+      query = self.findById(id, self.getReadFilterKeys(options.role))
+    }
+    else {
+      query = self.findOne({ '_id': id, customer: options.CUSTOMER_ID }, self.getReadFilterKeys(options.role));
+    }
 
-    query.select('notes people')
-    query.populate('people', 'name avatarUrl title calendarEventSummaries')
+    query.populate('fundsInvested.fund');
+    query.populate('people');
     query.populate({
       path: 'notes',
-      match: { customer: config.CUSTOMER_ID }
-    })
+      match: { customer: options.CUSTOMER_ID }
+    });
+
     query.deepPopulate([
-      'notes.createdBy',
-      'people.calendarEventSummaries.notes.createdBy'
+      'people.sources.person',
+      'notes.createdBy'
     ], {
       populate: {
-        'notes.createdBy': { select: 'name avatarUrl title' },
-        'people.calendarEventSummaries.notes.createdBy': { select: 'name avatarUrl title' }
+        'people.sources.person': { select: 'name avatarUrl title' },
+        'notes.createdBy': { select: 'name avatarUrl' }
       }
-    })
-    query.sort({'createdOn':-1})
-    query.exec(cb);
-
-  };
+    });
 
-  LimitedPartner.statics.getSources = function(lpid, cb) {
+    query.exec(function(err, lp) {
 
-    var self = this;
+      if (err) { return cb(err, null); }
+      else if (!lp) { return cb(null, null); }
 
-    self
-      .findById(lpid)
-      .populate('people', 'name avatarUrl title doNotDisplay sources')
-      .deepPopulate([
-        'people.sources.person'
-      ], {
-        populate: {
-          'people.sources.person': { select: 'name avatarUrl title doNotDisplay' }
-        }
-      })
-      .exec(function(err, lp) {
+      lp.people = _.map(lp.people, function(person) {
 
-        if (err) return cb(err, null);
-        if (!lp) return cb(null, null);
+        person.sources = _.filter(person.sources, function(s) {
+          return s.customer.toString() === options.CUSTOMER_ID;
+        });
 
-        Organization.findById(config.CUSTOMER_ID, function(err, customer) {
+        return person;
 
-          if (err) return cb(err, null);
-          if (!customer) return cb(null, null);
+      });
 
-          var current = [];
-          var past = [];
-          var all = [];
-          var lpSources = getSources(lp.people);
+      return cb(null, lp);
 
-          _.each(customer.people, function(p) {
+    });
 
-            var source = _.find(lpSources, function(ls) {
-              if (!ls || !ls.person || !ls.person._id) return false;
-              return ls.person._id.toString() == p.person.toString();
-            });
+  };
 
-            if (!source) return;
+  LimitedPartner.statics.getByName = function(lpName, options, cb) {
 
-            if (p.current) current.push(source);
-            if (!p.current) past.push(source);
-            all.push(source);
+    const self = this;
 
-          });
+    if (!cb) { throw new Error('cb is required'); }
+    if (!lpName) { return cb(new Error('lpName is required'), null); }
 
-          return cb(null, {
-            all: all,
-            current: current,
-            past: past
-          });
+    options = helpers.getDefaultOptions(options);
 
-        });
+    if (!options.isWorkerProcess) { return cb(null, []); }
 
-      });
+    let query = self.findOne({'name': lpName}, this.getReadFilterKeys(options.role));
+    query.populate('fundsInvested.fund');
+    query.exec(cb);
 
   };
 
-  LimitedPartner.statics.list = function (role, cb) {
+  LimitedPartner.statics.getByPersonId = function(personId, options, cb) {
 
-    // sorted by name ascending
-    // sort is done post retrieval because query sort is done pre-decryption
-    // filter by customer
+    const self = this;
 
-    var self = this;
-    var query;
+    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); }
 
-    var getLps = function(q) {
-      q.populate('transactions.fund')
-      q.exec(function (err, lps) {
-        if (err) return cb(err, null);
-        lps = _.sortBy(lps, function(lp) { return lp.name ? lp.name.toLowerCase() : ''; });
-        return cb(null, lps);
-      });
-    };
+    options = helpers.getDefaultOptions(options);
 
-    if (CUSTOMER_ID == 'GLOBAL_PROCESS') {
-      query = self.find({}, self.getReadFilterKeys(role));
-      getLps(query);
+    let query;
+
+    if (options.isWorkerProcess) {
+      query = self.find({'people': personId}, this.getReadFilterKeys(options.role));
     }
     else {
-      query = self.find({ 'transactions.fund': { $in : self.customerFunds }}, self.getReadFilterKeys(role));
-      getLps(query);
+      query = self.find({'people': personId, customer: options.CUSTOMER_ID }, self.getReadFilterKeys(options.role));
     }
 
-  };
-
-  LimitedPartner.statics.listForOrganization = function (orgid, role, cb) {
+    query.populate('fundsInvested.fund');
+    query.populate('people', 'name');
 
-    // sorted by name ascending
-    // sort is done post retrieval because query sort is done pre-decryption
+    query.exec(function (err, lps) {
+      if (err) { return cb(err, null); }
+      lps = _.sortBy(lps, function(lp) { return lp.name ? lp.name.toLowerCase() : ''; });
+      return cb(null, lps);
+    });
 
-    var self = this;
-    var query;
+  };
 
-    var getLps = function(q) {
-      q.populate('transactions.fund')
-      q.exec(function (err, lps) {
-        if (err) return cb(err, null);
-        lps = _.sortBy(lps, function(lp) { return lp.name ? lp.name.toLowerCase() : ''; });
-        return cb(null, lps);
-      });
-    };
+  LimitedPartner.statics.getFlags = function getFlags(lpid, options, cb) {
 
-    query = self.find({ 'transactions.fund': { $in : self.customerFunds }}, self.getReadFilterKeys(role));
-    getLps(query);
+    const self = this;
 
-  };
+    if (!cb) { throw new Error('cb is required'); }
+    if (!lpid) { return cb(new Error('lpid is required'), null); }
+    if (!mongoose.Types.ObjectId.isValid(lpid)) { return cb(new Error('lpid 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); }
 
-  LimitedPartner.statics.listAllUnverifiedLps = function (role, cb) {
+    let query = self.findOne({ '_id': lpid, customer: options.CUSTOMER_ID });
 
-    if (role != 'admin') return cb(new Error('Unauthorized'), []);
+    query.select('flags');
+    query.populate({
+      path: 'flags',
+      match: { customer: options.CUSTOMER_ID },
+      options: { sort: { createdOn: -1 } }
+    });
+    query.deepPopulate([
+      'flags.createdBy',
+    ], {
+      populate: {
+        'flags.createdBy': { select: 'name avatarUrl title' }
+      }
+    });
 
-    this
-      .find({'status.verified': false}, this.getReadFilterKeys(role))
-      .populate('transactions.fund')
-      .exec(function (err, lps) {
-        cb(err, _.sortBy(lps, function(lp) { return lp.name; }));
-      });
+    query.exec(cb);
 
   };
 
-  LimitedPartner.statics.listAllFlaggedLps = function (role, cb) {
+  LimitedPartner.statics.getNotes = function getNotes(lpid, options, cb) {
 
-    if (role != 'admin') return cb(new Error('Unauthorized'), []);
+    const self = this;
 
-    this
-      .find({'flagged.resolved': false, 'flagged.text': { $ne: '' }}, this.getReadFilterKeys(role))
-      .populate('transactions.fund')
-      .exec(function (err, lps) {
-        cb(err, _.sortBy(lps, function(lp) { return lp.name; }));
-      });
+    if (!cb) { throw new Error('cb is required'); }
+    if (!lpid) { return cb(new Error('lpid is required'), null); }
+    if (!mongoose.Types.ObjectId.isValid(lpid)) { return cb(new Error('lpid 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.findOne({ '_id': lpid, customer: options.CUSTOMER_ID });
 
-  LimitedPartner.statics.listByFund = function (fundId, role, cb) {
-
-    // all lps in a fund, sorted by name ascending
-    // sort is done post retrieval because query sort is done pre-decryption
-
-    var self = this;
+    query.select('notes people');
+    query.populate({
+      path: 'notes',
+      match: { customer: options.CUSTOMER_ID },
+      options: { sort: { createdOn: -1 } }
+    });
+    query.deepPopulate([
+      'notes.createdBy'
+    ], {
+      populate: {
+        'notes.createdBy': { select: 'name avatarUrl title' }
+      }
+    });
 
-    self
-      .find({ 'transactions.fund': fundId }, self.getReadFilterKeys(role))
-      .populate('transactions.fund')
-      .exec(function(err, lps) {
+    query.exec(cb);
 
-        if (err) return cb(err, null);
+  };
 
-        lps = _.sortBy(lps, function(lp) {
-          return lp.name ? lp.name.toLowerCase() : '';
-        });
+  LimitedPartner.statics.getSources = function(lpid, options, cb) {
 
-        return cb(null, lps);
+    const self = this;
+    
+    if (!cb) { throw new Error('cb is required'); }
+    if (!lpid) { return cb(new Error('lpid is required'), null); }
+    if (!mongoose.Types.ObjectId.isValid(lpid)) { return cb(new Error('lpid 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(lpid);
 
-  };
+    query.populate('people', 'name avatarUrl title doNotDisplay sources');
+    query.deepPopulate([
+      'people.sources.person'
+    ], {
+      populate: {
+        'people.sources.person': { select: 'name avatarUrl title doNotDisplay' }
+      }
+    });
 
-  LimitedPartner.statics.listPeople = function(lpid, role, cb) {
+    query.exec(function(err, lp) {
 
-    var self = this;
+        if (err) { return cb(err, null); }
+        if (!lp) { return cb(null, null); }
 
-    self.getById(lpid, role, function(err, lp) {
+        Organization.collection.findById(options.CUSTOMER_ID, function(err, customer) {
 
-      if (err) return cb(err, null);
+          if (err) { return cb(err, null); }
+          if (!customer) { return cb(null, null); }
 
-      var people = _.map(lp.people, function(person) {
-        return {
-          _id: person._id,
-          name: person.name
-        }
-      });
+          let current = [];
+          let past = [];
+          let all = [];
+          let lpSources = helpers.getPeopleSources(lp.people);
 
-      return cb(null, people);
+          _.each(customer.people, function(p) {
 
-    });
+            let source = _.find(lpSources, function(ls) {
+              if (!ls || !ls.person || !ls.person._id) return false;
+              return ls.person._id.toString() === p.person.toString();
+            });
 
-  };
+            if (!source) { return; }
 
-  LimitedPartner.statics.search = function (terms, role, cb) {
+            if (p.current) { current.push(source); }
+            if (!p.current) { past.push(source); }
+            all.push(source);
 
-    var self = this;
-    var query;
-    var getLps = function() {
-      query.populate('transactions.fund');
-      query.exec(function (err, lps) {
+          });
 
-        if (err) return cb(err, null);
+          return cb(null, {
+            all: helpers.sortPeopleSources(all, options.CUSTOMER_ID),
+            current: helpers.sortPeopleSources(current, options.CUSTOMER_ID),
+            past: helpers.sortPeopleSources(past, options.CUSTOMER_ID)
+          });
 
-        lps = _.sortBy(lps, function(lp) {
-          return lp.name.toLowerCase();
         });
 
-        return cb(null, lps);
       });
-    };
-
-    if (role == 'none') return cb(null, []);
 
-    if (CUSTOMER_ID == 'GLOBAL_PROCESS') {
-      query = self.find({'name': new RegExp(terms, "i")}, self.getReadFilterKeys(role));
-      getLps();
-    }
-    else {
-      query = self.find({ 'name': new RegExp(terms, "i"), 'transactions.fund': { $in : self.customerFunds }}, self.getReadFilterKeys(role));
+  };
 
-      getLps();
-    }
+  LimitedPartner.statics.listByFund = function (fundId, options, cb) {
 
-  };
+    const self = this;
 
-  LimitedPartner.statics.setCustomerFunds = function setCustomerFunds(fundids) {
-    var self = this;
-    self.customerFunds = fundids;
-    return self.customerFunds;
-  };
+    if (!cb) { throw new Error('cb is required'); }
+    if (!fundId) { return cb(new Error('fundId is required'), null); }
+    if (!mongoose.Types.ObjectId.isValid(fundId)) { return cb(new Error('fundId 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); }
 
-  LimitedPartner.statics.removeCustomerTransactions = function removeCustomerTransactions(customerId, cb) {
+    options = helpers.getDefaultOptions(options);
 
-    var self = this;
+    let query = self.find({ 'fundsInvested.fund': fundId, customer: options.CUSTOMER_ID }, self.getReadFilterKeys(options.role));
 
-    var query = self.update(
-      { 'customer': customerId },
-      { $set: { transactions: [] } },
-      { multi : true }
-    );
+    query.populate('fundsInvested.fund');
+    query.sort({ 'name': -1 });
     query.exec(cb);
 
   };
@@ -740,11 +540,12 @@ module.exports = function(mongoose, config) {
     // 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 (!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); }
+    if (!mongoose.Types.ObjectId.isValid(id)) { return cb(new Error('id is not a valid ObjectId'), null); }
+    if (!update) { return cb(new Error('options is required'), null); }
 
-    var self = this;
+    const self = this;
 
     // https://mongoosejs.com/docs/api.html#model_Model.findOneAndUpdate
     // options runValidators defaults false which is ok since we have upsert false
@@ -754,217 +555,85 @@ module.exports = function(mongoose, config) {
 
   };
 
-  LimitedPartner.statics.upsert = function(lp, username, role, cb) {
-
-    if (!lp) { return cb(new Error('lp is required'), null); }
-    if (!username) { return cb(new Error('username is required'), null); }
-
-    lp.entered.by = username;
-    lp.entered.on = new Date();
-
-    lp.extendWithWriteFilter(lp, role);
-    lp.save(function(err, result) {
-      if (err) return cb(err, null);
-      result.applyReadFilter(role);
-      return cb(null, result);
-    });
-
-  };
-
-  // Deprecated
-  LimitedPartner.statics.flag = function(lpId, resolved, text, username, role, cb) {
+  LimitedPartner.statics.search = function (terms, options, cb) {
 
-    var context = this;
+    const self = this;
 
-    context
-      .findById(lpId, this.getReadFilterKeys(role))
-      .exec(function(err, lp) {
+    if (!cb) { throw new Error('cb is required'); }
+    if (!terms) { return cb(new Error('terms 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); }
 
-        lp.flagged.resolved = resolved;
-        lp.flagged.text = text;
-        lp.flagged.by = username;
-        lp.flagged.on = Date.now();
+    options = helpers.getDefaultOptions(options);
 
-        if(!resolved) {
-          lp.status.verified = false;
-        }
+    let query;
 
-        return context.upsert(lp, username, role, cb);
+    if (options.role === 'none') { return cb(null, []); }
 
-      });
-
-  };
-
-  LimitedPartner.statics.addFlag = function(lpid, creatorPersonId, text, cb) {
-
-    Flag.createForModel({
-      createdBy: creatorPersonId,
-      text: text
-    }, this, lpid, cb);
-
-  };
-
-  LimitedPartner.statics.addNote = function(lpid, creatorPersonId, text, isPrivate, cb) {
-
-    Note.createForModel({
-      createdBy: creatorPersonId,
-      text: text,
-      isPrivate: isPrivate
-    }, this, lpid, cb);
-
-  };
-
-  LimitedPartner.statics.deleteFlag = function(flagId, cb) {
-
-    // Delete the flag itself along with any references
-
-    var self = this;
-
-    var removeReferences = function removeReferences(callback) {
-      self.update({}, {
-        $pull: { 'flags' : [flagId] }
-      }, callback);
-    };
+    if (options.isWorkerProcess) {
+      query = self.find({'name': new RegExp(terms, 'i')}, self.getReadFilterKeys(options.role));
+    }
+    else {
+      query = self.find({ 'name': new RegExp(terms, 'i'), customer: options.CUSTOMER_ID }, self.getReadFilterKeys(options.role));
+    }
 
-    async.series([
-      Flag.delete.bind(Flag, flagId),
-      removeReferences
-    ], function(err, results) {
-      return cb(err, null);
-    });
+    query.populate('fundsInvested.fund');
+    query.sort({ 'name': -1 });
+    query.exec(cb);
 
   };
 
-  LimitedPartner.statics.deleteNote = function(noteId, cb) {
+  LimitedPartner.statics.upsert = function(lp, username, options, cb) {
 
-    // Delete the note itself along with any references
-
-    var self = this;
+    if (!cb) { throw new Error('cb is required'); }
+    if (!lp) { return cb(new Error('lp is required'), null); }
+    if (!username) { return cb(new Error('username is required'), null); }
+    if (!options) { return cb(new Error('options is required'), null); }
+    if (!options.role) { return cb(new Error('options.role is required'), null); }
 
-    var removeReferences = function removeReferences(callback) {
-      self.update({}, {
-        $pull: { 'notes' : [noteId] }
-      }, callback);
-    };
+    lp.entered.by = username;
+    lp.entered.on = new Date();
 
-    async.series([
-      Note.delete.bind(Note, noteId),
-      removeReferences
-    ], function(err, results) {
-      return cb(err, null);
+    lp.extendWithWriteFilter(lp, options.role);
+    lp.save(function(err, result) {
+      if (err) return cb(err, null);
+      result.applyReadFilter(options.role);
+      return cb(null, result);
     });
 
   };
 
-//////////////////////////////
-
-  LimitedPartner.pre('save', function(next) {
-
-    var self = this;
-
-    var encryptSensitiveData = function(cb) {
-
-      if (self.distributions.ach.accountType) { self.distributions.ach.accountType = crypto.encrypt(self.distributions.ach.accountType); }
-      if (self.distributions.ach.stripeRecipientId) { self.distributions.ach.stripeRecipientId = crypto.encrypt(self.distributions.ach.stripeRecipientId); }
-      if (self.distributions.ach.legalName) { self.distributions.ach.legalName = crypto.encrypt(self.distributions.ach.legalName); }
-      if (self.distributions.ach.taxId) { self.distributions.ach.taxId = crypto.encrypt(self.distributions.ach.taxId); }
-      if (self.distributions.ach.bankAccount.name) { self.distributions.ach.bankAccount.name = crypto.encrypt(self.distributions.ach.bankAccount.name); }
-      if (self.distributions.ach.bankAccount.country) { self.distributions.ach.bankAccount.country = crypto.encrypt(self.distributions.ach.bankAccount.country); }
-      if (self.distributions.ach.bankAccount.routingNumber) { self.distributions.ach.bankAccount.routingNumber = crypto.encrypt(self.distributions.ach.bankAccount.routingNumber); }
-      if (self.distributions.ach.bankAccount.accountNumber) { self.distributions.ach.bankAccount.accountNumber = crypto.encrypt(self.distributions.ach.bankAccount.accountNumber); }
-      if (self.k1.EIN) { self.k1.EIN = crypto.encrypt(self.k1.EIN); }
-
-      return cb();
-
-    };
-
-    encryptSensitiveData(function() {
-      return next();
-    });
-
-  });
-
-  LimitedPartner.pre('init', function(next) {
-    if (CUSTOMER_ID != 'GLOBAL_PROCESS' && !LPS_ENABLED) throw new Error('LPS_ENABLED is false');
-    else next();
-  });
-
-  LimitedPartner.post('init', function(doc, next) {
-
-    if (CUSTOMER_ID != 'GLOBAL_PROCESS' && !LPS_ENABLED) {
-
-      // Don't return doc if lps aren't enabled or lp doesn't belong to current customer
-      if (!LPS_ENABLED || doc.customer != CUSTOMER_ID) {
-        doc = null;
-        return next();
-      }
-
-    }
-
-    // Decrypt sensitive data
-    if (this.distributions && this.distributions.ach) {
-      if (this.distributions.ach.accountType) {
-        this.distributions.ach.accountType = crypto.decrypt(this.distributions.ach.accountType);
-      }
-      if (this.distributions.ach.stripeRecipientId) {
-        this.distributions.ach.stripeRecipientId = crypto.decrypt(this.distributions.ach.stripeRecipientId);
-      }
-      if (this.distributions.ach.legalName) {
-        this.distributions.ach.legalName = crypto.decrypt(this.distributions.ach.legalName);
-      }
-      if (this.distributions.ach.taxId) {
-        this.distributions.ach.taxId = crypto.decrypt(this.distributions.ach.taxId);
-      }
-      if (this.distributions.ach.bankAccount.name) {
-        this.distributions.ach.bankAccount.name = crypto.decrypt(this.distributions.ach.bankAccount.name);
-      }
-      if (this.distributions.ach.bankAccount.country) {
-        this.distributions.ach.bankAccount.country = crypto.decrypt(this.distributions.ach.bankAccount.country);
-      }
-      if (this.distributions.ach.bankAccount.routingNumber) {
-        this.distributions.ach.bankAccount.routingNumber = crypto.decrypt(this.distributions.ach.bankAccount.routingNumber);
-      }
-      if (this.distributions.ach.bankAccount.accountNumber) {
-        this.distributions.ach.bankAccount.accountNumber = crypto.decrypt(this.distributions.ach.bankAccount.accountNumber);
-      }
-    }
-    if (this.k1 && this.k1.EIN) { this.k1.EIN = crypto.decrypt(this.k1.EIN); }
-
-    next();
-
-  });
-
 //////////////////////////////
 
   LimitedPartner.plugin(filter, {
-    "readFilter": {
-      "admin": ["name", "shortName", "start", "people", "documentSlugs", "transactions", "contact", "distributions", "k1", "entered", "status", "flagged", "flags", "notes"],
-      "lp-full": ["name", "shortName", "start", "people", "documentSlugs", "transactions", "contact", "distributions", "k1", "entered", "status", "flagged", "flags", "notes"],
-      "lp-names": ["name", "shortName", "flagged", "flags"],
-      "none": []
+    'readFilter': {
+      'admin': ['name', 'shortName', 'customer', 'start', 'people', 'documentSlugs', 'fundsInvested', 'contact', 'entered', 'status', 'flagged', 'flags', 'notes'],
+      'lp-full': ['name', 'shortName', 'customer', 'start', 'people', 'documentSlugs', 'fundsInvested', 'contact', 'entered', 'status', 'flagged', 'flags', 'notes'],
+      'lp-names': ['name', 'shortName', 'flagged', 'flags', 'customer'],
+      'none': []
     },
-    "writeFilter": {
-      "admin": ["name", "shortName", "start", "people", "documentSlugs", "transactions", "contact", "distributions", "k1", "entered", "status", "flagged", "flags", "notes"],
-      "lp-full": ["name", "shortName", "start", "people", "documentSlugs", "transactions", "contact", "distributions", "k1", "entered", "status", "flagged", "flags", "notes"],
-      "lp-names": ["flagged", "flags"],
-      "none": []
+    'writeFilter': {
+      'admin': ['name', 'shortName', 'customer', 'start', 'people', 'documentSlugs', 'fundsInvested', 'contact', 'entered', 'status', 'flagged', 'flags', 'notes'],
+      'lp-full': ['name', 'shortName', 'customer', 'start', 'people', 'documentSlugs', 'fundsInvested', 'contact', 'entered', 'status', 'flagged', 'flags', 'notes'],
+      'lp-names': ['flagged', 'flags', 'customer'],
+      'none': []
     },
-    "defaultFilterRole": "none",
-    "sanitize": false,
-    "compat": false
+    'defaultFilterRole': 'none',
+    'sanitize': false,
+    'compat': false
   });
 
 //////////////////////////////
 
   LimitedPartner.set('autoIndex', false);
-  LimitedPartner.set('usePushEach', true);
   LimitedPartner.on('index', function(err) { console.log('error building limited partner indexes: ' + err); });
 
   LimitedPartner.set('toJSON', { virtuals: true });
 
-  var deepPopulate = require('mongoose-deep-populate')(mongoose);
+  let deepPopulate = require('mongoose-deep-populate')(mongoose);
   LimitedPartner.plugin(deepPopulate);
 
   mongoose.model('LimitedPartner', LimitedPartner);
 
-};
+};