@dhyasama/totem-models 1.0.0

package/lib/LimitedPartner.js

@@ -0,0 +1,780 @@
+"use strict";
+
+module.exports = function(mongoose, config) {
+
+  var
+
+    CUSTOMER_ID = config.CUSTOMER_ID,
+    LPS_ENABLED = config.LPS_ENABLED,
+    Schema = mongoose.Schema,
+    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');
+
+  var getFundIdsForCustomer = function(cb) {
+    Organization.getById(CUSTOMER_ID, function(err, org) {
+      if (err) return cb(err, null);
+      else if (!org) return cb(null, null);
+      var fundIds = _.map(org.funds, function(fund) {
+        return mongoose.Types.ObjectId.isValid(fund) || fund._id;
+      });
+      return cb(null, fundIds);
+    });
+  };
+
+  var LimitedPartner = new Schema({
+
+    name: { type: String, index: true, required: true },
+
+    shortName: { type: String, default: '' },
+
+    start: { type: String, default: '' },
+
+    people: [{
+      type: Schema.ObjectId,
+      ref: 'Person'
+    }],
+
+    documentSlugs: {
+      annualAudit: { type: String, default: '' },
+      capitalCall: { type: String, default: '' },
+      portfolioHolding: { type: String, default: '' },
+      k1: { type: String, default: '' },
+      distribution: { type: String, default: '' },
+      quarterlyAccountStatement: { type: String, default: '' }
+    },
+
+    fundsInvested: [{
+      fund: {type: Schema.ObjectId, ref: 'Fund'},
+      committed: {type: Number, default: 0},
+      called: {type: Number, default: 0}
+    }],
+
+    contact: {
+
+      phone: [{
+        type: { type: String, enum: ['home', 'work', 'assistant', 'mobile', 'other'] },
+        number: { type: String, default: '' },
+        primary: { type: Boolean, default: false }
+      }],
+
+      email: [{
+        type: { type: String, enum: ['personal', 'work', 'assistant', 'other'] },
+        email: { type: String, default: '' },
+        primary: { type: Boolean, default: false }
+      }],
+
+      address: [{
+        type: { type: String, default: '' },
+        street: { type: String, default: '' },
+        suite: { type: String, default: '' },
+        city: { type: String, default: '' },
+        state: { type: String, default: '' },
+        country: { type: String, default: '' },
+        postalCode: { type: String, default: '' },
+        primary: { type: Boolean, default: false }
+      }]
+
+    },
+
+    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 }
+    },
+
+    status: {
+      verified: { type: Boolean, default: false },
+      verifiedBy: { type: String, default: '' },
+      verifiedOn: { type: Date, default: Date.now }
+    },
+
+    flagged: {
+      by: { type: String, default: '' },
+      on: { type: Date, default: Date.now },
+      text: { type: String, default: '' },
+      resolved: { type: Boolean, default: false }
+    },
+
+    notes: [ { type: Schema.ObjectId, ref: 'Note' } ]
+
+  });
+
+/////////////////////
+
+  LimitedPartner.virtual('email.primary').get(function () {
+    var 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) {
+      return phone.primary;
+    });
+    return primary ? primary.number : '';
+  });
+
+  LimitedPartner.virtual('address.primary').get(function () {
+
+    var primary = _.find(this.contact.address, function(address) {
+      return address.primary;
+    });
+
+    if (!primary) {
+      primary = {
+        street: '',
+        suite: '',
+        city: '',
+        state: '',
+        country: '',
+        postalCode: '',
+        primary: true
+      };
+    }
+
+    return primary;
+
+  });
+
+  LimitedPartner.virtual('sources').get(function () {
+
+    // Aggregate sources from all people
+    // Sort by interactions descending, full name ascending
+
+    var self = this;
+    var result = self.people || [];
+
+    if (result.length == 0) return [];
+    if (mongoose.Types.ObjectId.isValid(result[0])) return []; // not populated
+
+    result = _.pluck(result, 'sources');
+    result = _.flatten(result);
+    result = _.compact(result);
+    result = _.uniq(result, function(item) {
+      if (!item.person) return null;
+      var personId = utils.isValidObjectId(item.person) ? item.person : item.person._id;
+      return personId.toString();
+    });
+    result = _.compact(result);
+    result = _.sortBy(result, 'interactions.count');
+    result.reverse();
+    result = _.sortBy(result, 'name.full');
+
+    return result;
+
+  });
+
+/////////////////////
+
+  /************* BASIC FIELDS **********************/
+
+  LimitedPartner.methods.newBasic = function(field, value) {
+
+    var compoundField = false;
+    if(field.split(".").length > 1) {
+      compoundField = true;
+    }
+
+    if(!compoundField) {
+      this[field] = value;
+    } else {
+      var parentField = field.split('.')[0];
+      var childField = field.split('.')[1];
+
+      this[parentField][childField] = value;
+    }
+
+  };
+
+  LimitedPartner.methods.updateBasic = function(field, value) {
+
+    var compoundField = false;
+    if(field.split(".").length > 1) {
+      compoundField = true;
+    }
+
+    if(!compoundField) {
+      var currentVal = this[field];
+      this[field] = value;
+    } else {
+      var parentField = field.split('.')[0];
+      var childField = field.split('.')[1];
+
+      var currentVal = this[parentField][childField];
+      this[parentField][childField] = value;
+    }
+
+  };
+
+  /************* CONTACT FIELDS **********************/
+
+  LimitedPartner.methods.updateContact = function(field, value) {
+
+    var parentField = field.split('.')[0];
+    var childField = field.split('.')[1];
+
+    this[parentField][childField] = value;
+
+  };
+
+  /********** PERSON RELATIONSHIPS ********************/
+
+  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();
+    });
+
+    if (!match) this.people.push(idOfPersonToAdd);
+
+  };
+
+  LimitedPartner.methods.removePerson = function(id) {
+
+    this.people = _.filter(this.people, function(person) {
+      return person.id != id;
+    });
+
+  };
+
+  LimitedPartner.methods.fundPercentCalled = function(fundId) {
+
+    if (!fundId) return 0;
+
+    var match = _.find(this.fundsInvested, function(inv) {
+      return inv.fund == fundId || inv.fund.id == fundId;
+    });
+
+    if (!match) return 0;
+
+    return (match.called / match.committed) * 100;
+
+  };
+
+  LimitedPartner.methods.listActiveFunds = function(cb) {
+
+    var lp = this;
+    var funds = [];
+
+    lp.populate('fundsInvested.fund', function(err) {
+
+      if (err) return cb(err, null);
+
+      _.each(lp.fundsInvested, function(investment) {
+        if (investment.committed > 0) { funds.push(investment); }
+      });
+
+      return cb(null, funds);
+
+    });
+
+  };
+
+  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.findByTransaction = function (id, role, cb) {
+    this
+      .find({ 'distributions.ach.challengeDeposits.id': id }, this.getReadFilterKeys(role))
+      .exec(cb);
+  };
+
+  LimitedPartner.statics.getById = function(id, role, cb) {
+
+    var self = this;
+    var query;
+    var getLp = function() {
+      query.populate('fundsInvested.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);
+    };
+
+    if (CUSTOMER_ID == 'GLOBAL_PROCESS') {
+      query = self.findById(id, self.getReadFilterKeys(role))
+      getLp();
+    }
+    else {
+      getFundIdsForCustomer(function(err, fundIds) {
+        if (err) return cb(err, null);
+        query = self.findOne({ '_id': id, 'fundsInvested.fund': { $in : fundIds }}, self.getReadFilterKeys(role));
+        getLp();
+      });
+    }
+
+  };
+
+  LimitedPartner.statics.getByPersonId = function(personId, role, cb) {
+
+    var self = this;
+
+    self
+      .find({'people': personId}, this.getReadFilterKeys(role))
+      .populate('fundsInvested.fund')
+      .populate('people', 'name')
+      .exec(cb);
+
+  };
+
+  LimitedPartner.statics.list = function (role, cb) {
+
+    // sorted by name ascending
+    // sort is done post retrieval because query sort is done pre-decryption
+    // filter by customer
+
+    var self = this;
+    var query;
+    var getLps = function() {
+      query.populate('fundsInvested.fund')
+      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);
+      });
+    };
+
+    if (CUSTOMER_ID == 'GLOBAL_PROCESS') {
+      query = self.find({}, self.getReadFilterKeys(role));
+      getLps();
+    }
+    else {
+      getFundIdsForCustomer(function(err, fundIds) {
+        if (err) return cb(err, null);
+        query = self.find({ 'fundsInvested.fund': { $in : fundIds }}, self.getReadFilterKeys(role));
+        getLps();
+      });
+    }
+
+  };
+
+  LimitedPartner.statics.listAllUnverifiedLps = function (role, cb) {
+
+    if (role != 'admin') return cb(new Error('Unauthorized'), []);
+
+    this
+      .find({'status.verified': false}, this.getReadFilterKeys(role))
+      .populate('fundsInvested.fund')
+      .exec(function (err, lps) {
+        cb(err, _.sortBy(lps, function(lp) { return lp.name; }));
+      });
+
+  };
+
+  LimitedPartner.statics.listAllFlaggedLps = function (role, cb) {
+
+    if (role != 'admin') return cb(new Error('Unauthorized'), []);
+
+    this
+      .find({'flagged.resolved': false, 'flagged.text': { $ne: '' }}, this.getReadFilterKeys(role))
+      .populate('fundsInvested.fund')
+      .exec(function (err, lps) {
+        cb(err, _.sortBy(lps, function(lp) { return lp.name; }));
+      });
+
+  };
+
+  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;
+
+    self
+      .find({ 'fundsInvested.fund': fundId }, self.getReadFilterKeys(role))
+      .populate('fundsInvested.fund')
+      .exec(function(err, lps) {
+
+        if (err) return cb(err, null);
+
+        lps = _.filter(lps, function(lp) {
+          if (CUSTOMER_ID == 'GLOBAL_PROCESS') { return lp; }
+          else {
+            var match = _.find(lp.fundsInvested, function(fund) {
+              return fund.fund.investor.toString() == CUSTOMER_ID.toString();
+            });
+            return typeof match != 'undefined';
+          }
+        });
+
+        lps = _.sortBy(lps, function(lp) {
+          return lp.name ? lp.name.toLowerCase() : '';
+        });
+
+        return cb(null, lps);
+
+      });
+
+  };
+
+  LimitedPartner.statics.listPeople = function(lpid, role, cb) {
+
+    var self = this;
+
+    self.getById(lpid, role, function(err, lp) {
+
+      if (err) return cb(err, null);
+
+      var people = _.map(lp.people, function(person) {
+        return {
+          _id: person._id,
+          name: person.name
+        }
+      });
+
+      return cb(null, people);
+
+    });
+
+  };
+
+  LimitedPartner.statics.search = function (terms, role, cb) {
+
+    var self = this;
+    var query;
+    var getLps = function() {
+      //query.select('name');
+      query.exec(function (err, lps) {
+
+        if (err) return cb(err, null);
+
+        lps = _.sortBy(lps, function(lp) {
+          return lp.name.toLowerCase();
+        });
+
+        return cb(null, lps);
+      });
+    };
+
+    if (CUSTOMER_ID == 'GLOBAL_PROCESS') {
+      query = self.find({'name': new RegExp(terms, "i")}, self.getReadFilterKeys(role));
+      getLps();
+    }
+    else {
+      getFundIdsForCustomer(function(err, fundIds) {
+        if (err) return cb(err, null);
+        query = self.find({ 'name': new RegExp(terms, "i"), 'fundsInvested.fund': { $in : fundIds }}, self.getReadFilterKeys(role));
+        getLps();
+      });
+    }
+
+  };
+
+  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);
+    });
+
+  };
+
+  //TODO: this is same as Person & Portfolio Company Function
+  //Helper function that multiple models can use...
+  LimitedPartner.statics.verify = function(lpId, verified, username, role, cb) {
+
+    this
+      .findById(lpId, this.getReadFilterKeys(role))
+      .exec(function(err, lp) {
+
+      lp.status.verified = verified;
+      lp.status.verifiedBy = username;
+      lp.status.verifiedOn = Date.now();
+
+      if(verified) {
+        lp.flagged.resolved = true;
+      }
+
+      return this.upsert(lp, username, role, cb);
+
+    });
+
+  };
+
+  LimitedPartner.statics.flag = function(lpId, resolved, text, username, role, cb) {
+
+    var context = this;
+
+    context
+      .findById(lpId, this.getReadFilterKeys(role))
+      .exec(function(err, lp) {
+
+        lp.flagged.resolved = resolved;
+        lp.flagged.text = text;
+        lp.flagged.by = username;
+        lp.flagged.on = Date.now();
+
+        if(!resolved) {
+          lp.status.verified = false;
+        }
+
+        return context.upsert(lp, username, role, cb);
+
+      });
+
+  };
+
+  LimitedPartner.statics.addNote = function(lpid, creatorPersonId, text, cb) {
+
+    Note.createForModel({
+      createdBy: creatorPersonId,
+      text: text
+    }, this, lpid, cb);
+
+  };
+
+  LimitedPartner.statics.deleteNote = function(noteId, cb) {
+
+    // Delete the note itself along with any references
+
+    var self = this;
+
+    var removeReferences = function removeReferences(callback) {
+      self.update({}, {
+        $pull: { 'notes' : [noteId] }
+      }, callback);
+    };
+
+    async.series([
+      Note.delete.bind(Note, noteId),
+      removeReferences
+    ], function(err, results) {
+      return cb(err, null);
+    });
+
+  };
+
+//////////////////////////////
+
+  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();
+    });
+
+    // var takeSnapshot = function(cb) {
+    //
+    //   var LimitedPartnerHistory = mongoose.model('LimitedPartnerHistory');
+    //   var snapshot = new LimitedPartnerHistory();
+    //   snapshot.create(self, 'jason', function(err, result) {
+    //     if (err) {} // todo: alert admin to fix; ok to proceed;
+    //     return cb();
+    //   });
+    //
+    // };
+    //
+    // encryptSensitiveData(function() {
+    //   takeSnapshot(function() {
+    //     return next();
+    //   })
+    // });
+
+
+  });
+
+  LimitedPartner.pre('init', function(next) {
+    if (!LPS_ENABLED) throw new Error('LPS_ENABLED is false');
+    else next();
+  });
+
+  LimitedPartner.post('init', function() {
+
+    // 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); }
+
+  });
+
+//////////////////////////////
+
+  LimitedPartner.plugin(filter, {
+    readFilter: {
+      'admin': ['name', 'shortName', 'start', 'people', 'documentSlugs', 'fundsInvested', 'contact', 'distributions', 'k1', 'entered', 'status', 'flagged', 'notes'],
+      'lp-full': ['name', 'shortName', 'start', 'people', 'documentSlugs', 'fundsInvested', 'contact', 'distributions', 'k1', 'entered', 'status', 'flagged', 'notes'],
+      'lp-names': ['name', 'shortName', 'flagged'],
+      'none': []
+    },
+    writeFilter: {
+      'admin': ['name', 'shortName', 'start', 'people', 'documentSlugs', 'fundsInvested', 'contact', 'distributions', 'k1', 'entered', 'status', 'flagged', 'notes'],
+      'lp-full': ['name', 'shortName', 'start', 'people', 'documentSlugs', 'fundsInvested', 'contact', 'distributions', 'k1', 'entered', 'status', 'flagged', 'notes'],
+      'lp-names': ['flagged'],
+      'none': []
+    },
+    defaultFilterRole: 'none', // default to no read or write
+    sanitize: false, // Escape HTML in strings
+    compat: false // Enable compatibility for Mongoose versions prior to 3.6
+  });
+
+//////////////////////////////
+
+  LimitedPartner.set('autoIndex', 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);
+  LimitedPartner.plugin(deepPopulate);
+
+  mongoose.model('LimitedPartner', LimitedPartner);
+
+};