@dhyasama/totem-models 1.0.0 → 1.6.0

package/lib/Organization.js

@@ -2,8 +2,6 @@
 
 module.exports = function(mongoose, config) {
 
-  var LPS_ENABLED = config.LPS_ENABLED || false;
-
   var
 
     _ = require('underscore'),
@@ -12,6 +10,8 @@ module.exports = function(mongoose, config) {
     Schema = mongoose.Schema,
     Note = mongoose.model('Note'),
 
+    customerPortfolio = [],
+
     Organization = new Schema({
 
       name: { type: String, required: true, index: true },
@@ -64,6 +64,7 @@ module.exports = function(mongoose, config) {
         title: { type: String, default: null, trim: true },
         current: { type: Boolean, default: false, index: true },
         leader: { type: Boolean, default: false, index: true },
+        public: { type: Boolean, default: true },
         board: { type: String, enum: ['chairman', 'director', 'observer', 'none'], default: 'none', index: true }
       }],
 
@@ -114,10 +115,6 @@ module.exports = function(mongoose, config) {
         url: { type: String, unique: true, sparse: true, trim: true }
       },
 
-      eshares: {
-        companyid: { type: String, unique: true, sparse: true, trim: true }
-      },
-
       related: [{ type: Schema.ObjectId, ref: 'Organization' }],
 
       // customer specific (customer id is stored on note)
@@ -172,219 +169,238 @@ module.exports = function(mongoose, config) {
       // Funds belonging to this organization (which is typically, but not necessarily, what we'd call an investor)
       // An example of a non-"investor" with funds would be Slack with it's Slack Fund
       // Another way to put it, these are funds from which this organization makes investments
-      funds: [{ type: Schema.ObjectId, ref: 'Fund' }],
+      funds: [{ type: Schema.ObjectId, ref: 'Fund' }]
 
-      // Private
-      capTable: [{
-
-        customer: { type: Schema.ObjectId, ref: 'Organization', required: true },
-        shares: { type: Number, default: 0 },
-        fullyDiluted: { type: Number, default: 0 },
-        asOfDate: { type: Date },
+    });
 
-        // todo - ???
-        optionsAndWarrants: {
-          unissued: { type: Number },
-          issuedToUnspecified: { type: Number }
-        }
 
-      }],
 
-      // Equity or debt this organization has taken from other organizations
-      rounds: [{
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // HELPERS
+  ///////////////////////////////////////////////////////////////////////////////////////
 
-        roundName: { type: String, trim: true, default: null },
+  var getSources = function getSources(people) {
 
-        // used when cap table round names are changed and need to be matched to investment data
-        oldRoundName: { type: String, trim: true, default: null },
+    var result = _.compact(_.pluck(people, 'person'));
+    if (result.length == 0) return [];
 
-        // these three values are public and will be used in the absence of overriding private data
-        preMoneyValuation: { type: Number, default: 0 },
-        amountRaised: { type: Number, default: 0 },
-        closingDate: { type: Date, default: null },
+    result = _.compact(_.pluck(result, 'sources'));
+    if (result.length == 0) return [];
 
-        // Funds that participated in this round
-        // Recall that a fund belongs to an organization
-        // This is a public list of funds/orgs that invested
-        funds: [{
+    result = _.flatten(result);
+    result = _.compact(result);
 
-          fund: { type: Schema.ObjectId, ref: 'Fund', required: true },
+    if (result.length == 0) return [];
+    if (mongoose.Types.ObjectId.isValid(result[0].person)) return []; // not populated
 
-          // the lead on this round from the fund/org
-          partner: { type: Schema.ObjectId, ref: 'Person', required: false },
+    result = _.uniq(result, function(item) { return item.person._id.toString(); });
+    result = _.sortBy(result, 'interactions.count');
+    result.reverse();
+    result = _.sortBy(result, 'name.full');
 
-          // not strictly necessary since we have fund
-          // include because it makes filtering investments data, which is private, much easier
-          customer: { type: Schema.ObjectId, ref: 'Organization', required: false },
+    return result;
 
-          // Investments in this round from this fund
-          // this is all private data
-          investments: [{
+  };
 
-            amount: { type: Number, default: 0 },
-            date: { type: Date, default: null },
-            lead: { type: Boolean, default: false },
-            participatingPreferred: { type: Boolean, default: false },
-            pricePerShare: { type: Number, default: 0 },
-            fairMarketValue: { type: Number, default: 0 },
-            notes: { type: String, trim: true, default: null },
 
-            // note these fields are duplicative at the round level
-            // this is private data and will override the round level numbers where appropriate
-            preMoneyValuation: { type: Number, default: 0 },
-            amountRaised: { type: Number, default: 0 },
-            closingDate: { type: Date, default: null },
 
-            convertibleNotes: [{
-              cap: { type: Number, default: 0 },
-              discount: { type: Number, default: 0 },
-              interestRate: { type: Number, default: 0 },
-              maturityDate: { type: Date, default: null },
-              fairMarketValue: { type: Number, default: 0 },
-              notes: { type: String, trim: true, default: null }
-            }]
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // VIRTUALS
+  // Properties that are not persisted to the database
+  ///////////////////////////////////////////////////////////////////////////////////////
 
-          }]
+  Organization.virtual('address.primary').get(function () {
+    var primary = _.find(this.contact.address, function(address) {
+      return address.primary;
+    });
+    return primary ? primary.address : null;
+  });
 
-        }],
+  Organization.virtual('board.all').get(function () {
 
-        // People that participated in this round
-        // This is a public list of people that invested
-        people: [{
-          person: {type: Schema.ObjectId, ref: 'Person'}
-        }]
+    var self = this;
+    var members = [];
 
-      }],
+    _.each(self.people, function(p) {
+      var boardRole = p.board;
+      if (boardRole && boardRole != 'none') members.push(p.person);
+    });
 
+    members = _.sortBy(members, function(member) {
+      if (!member || !member.name) return null;
+      return member.name.last + member.name.first;
     });
 
-  ///////////////////////////////
+    return members;
 
-  Organization.virtual('status').get(function () {
+  });
+
+  Organization.virtual('board.current').get(function () {
 
     var self = this;
+    var members = [];
 
-    // infer from data
+    _.each(self.people, function(p) {
+      var boardRole = p.board;
+      if (p.current && boardRole && boardRole != 'none') members.push(p.person);
+    });
 
-    if (self.closedOn) return 'Dead';
-    else if (self.ipo.year) return 'IPO';
-    else if (self.acquisition.year) return 'Acquired';
-    else return 'Active';
+    members = _.sortBy(members, function(member) {
+      if (!member || !member.name) return null;
+      return member.name.last + member.name.first;
+    });
+
+    return members;
 
   });
 
-  Organization.virtual('address.primary').get(function () {
-    var primary = _.find(this.contact.address, function(address) {
-      return address.primary;
+  Organization.virtual('board.past').get(function () {
+
+    var self = this;
+    var members = [];
+
+    _.each(self.people, function(p) {
+      var boardRole = p.board;
+      if (!p.current && boardRole && boardRole != 'none') members.push(p.person);
     });
-    return primary ? primary.address : null;
+
+    members = _.sortBy(members, function(member) {
+      if (!member || !member.name) return null;
+      return member.name.last + member.name.first;
+    });
+
+    return members;
+
   });
 
-  Organization.virtual('sources').get(function () {
+  Organization.virtual('employees.all').get(function () {
+
+    var self = this;
+    var result = [];
+
+    _.each(self.people, function(p) {
+      if (!p.leader && (!p.board || p.board == 'none')) result.push(p);
+    });
+
+    result = _.sortBy(result, function(item) {
+      if (!item.person || !item.person.name) return null;
+      return item.person.name.last + item.person.name.first;
+    });
+
+    return result;
+
+  });
 
-    // Aggregate sources from all people at org
-    // Sort by interactions descending, full name ascending
+  Organization.virtual('employees.current').get(function () {
 
     var self = this;
+    var result = [];
 
-    var result = _.compact(_.pluck(self.people, 'person'));
-    if (result.length == 0) return [];
+    _.each(self.people, function(p) {
+      if (p.current && !p.leader && (!p.board || p.board == 'none')) result.push(p);
+    });
 
-    result = _.compact(_.pluck(result, 'sources'));
-    if (result.length == 0) return [];
+    result = _.sortBy(result, function(item) {
+      if (!item.person || !item.person.name) return null;
+      return item.person.name.last + item.person.name.first;
+    });
 
-    result = _.flatten(result);
-    result = _.compact(result);
+    return result;
 
-    if (result.length == 0) return [];
-    if (mongoose.Types.ObjectId.isValid(result[0].person)) return []; // not populated
+  });
 
-    result = _.uniq(result, function(item) { return item.person._id.toString(); });
-    result = _.sortBy(result, 'interactions.count');
-    result.reverse();
-    result = _.sortBy(result, 'name.full');
+  Organization.virtual('employees.past').get(function () {
+
+    var self = this;
+    var result = [];
+
+    _.each(self.people, function(p) {
+      if (!p.current && !p.leader && (!p.board || p.board == 'none')) result.push(p);
+    });
+
+    result = _.sortBy(result, function(item) {
+      if (!item.person || !item.person.name) return null;
+      return item.person.name.last + item.person.name.first;
+    });
 
     return result;
 
   });
 
-  ///////////////////////////////
+  Organization.virtual('leaders.all').get(function () {
 
-  Organization.methods.merge = function(id) {
-    if (this.merged.indexOf(id) == -1) {
-      this.merged.push(id);
-      return true;
-    }
-    else {
-      return false;
-    }
-  };
+    var self = this;
+    var result = [];
 
-  Organization.methods.deleteOrg = function() {
-    // Soft delete
-    this.deleted = true;
-  };
+    _.each(self.people, function(p) {
+      if (p.leader) result.push(p);
+    });
 
-  Organization.methods.relateOrg = function(id) {
+    result = _.sortBy(result, function(item) {
+      if (!item.person || !item.person.name) return null;
+      return item.person.name.last + item.person.name.first;
+    });
+
+    return result;
+
+  });
+
+  Organization.virtual('leaders.current').get(function () {
 
     var self = this;
+    var result = [];
 
-    var match = _.find(self.related, function(org) {
-      var orgId = utils.isValidObjectId(org) ? org : org.id;
-      return orgId.toString() == id.toString();
+    _.each(self.people, function(p) {
+      if (p.leader && p.current) result.push(p);
     });
 
-    if (!match) { self.related.push(id); }
+    result = _.sortBy(result, function(item) {
+      if (!item.person || !item.person.name) return null;
+      return item.person.name.last + item.person.name.first;
+    });
 
-  };
+    return result;
 
-  // todo - what are "basic" fields and how are they used?
-  Organization.methods.newBasic = function(field, value) {
+  });
 
-    var compoundField = false;
-    if(field.split(".").length > 1) {
-      compoundField = true;
-    }
+  Organization.virtual('leaders.past').get(function () {
 
-    if(!compoundField) {
-      this[field] = value;
-    } else {
-      var parentField = field.split('.')[0];
-      var childField = field.split('.')[1];
+    var self = this;
+    var result = [];
 
-      this[parentField][childField] = value;
-    }
+    _.each(self.people, function(p) {
+      if (p.leader && !p.current) result.push(p);
+    });
 
-  };
+    result = _.sortBy(result, function(item) {
+      if (!item.person || !item.person.name) return null;
+      return item.person.name.last + item.person.name.first;
+    });
+
+    return result;
 
-  Organization.methods.updateBasic = function(field, value) {
+  });
 
-    var compoundField = false;
-    if(field.split(".").length > 1) {
-      compoundField = true;
-    }
+  Organization.virtual('status').get(function () {
 
-    if(!compoundField) {
-      var currentVal = this[field];
-      this[field] = value;
-    } else {
-      var parentField = field.split('.')[0];
-      var childField = field.split('.')[1];
+    var self = this;
 
-      var currentVal = this[parentField][childField];
-      this[parentField][childField] = value;
-    }
+    // infer from data
 
-  };
+    if (self.closedOn) return 'Dead';
+    else if (self.ipo && self.ipo.year) return 'IPO';
+    else if (self.acquisition && self.acquisition.year) return 'Acquired';
+    else return 'Active';
 
-  Organization.methods.updateContact = function(field, value) {
+  });
 
-    var parentField = field.split('.')[0];
-    var childField = field.split('.')[1];
 
-    this[parentField][childField] = value;
 
-  };
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // METHODS
+  // Methods operate on a single document that has already been returned
+  // Note that running a method on a document does not save it
+  ///////////////////////////////////////////////////////////////////////////////////////
 
   Organization.methods.addPerson = function(personToAdd) {
 
@@ -406,151 +422,375 @@ module.exports = function(mongoose, config) {
 
   };
 
-  Organization.methods.removePerson = function(personIdToRemove) {
-
-    this.people = _.reject(this.people, function(existingPerson) {
-      var id = utils.isValidObjectId(existingPerson.person) ? existingPerson.person : existingPerson.person._id;
-      return id.toString() == personIdToRemove.toString();
-    });
+  Organization.methods.deleteOrg = function() {
+    // Soft delete
+    this.deleted = true;
+  };
 
+  Organization.methods.merge = function(id) {
+    if (this.merged.indexOf(id) == -1) {
+      this.merged.push(id);
+      return true;
+    }
+    else {
+      return false;
+    }
   };
 
-  Organization.methods.updateFunds = function(funds) {
+  Organization.methods.relateOrg = function(id) {
 
     var self = this;
 
-    // todo - ??? - funds invested into this org or funds this org invests from?
+    var match = _.find(self.related, function(org) {
+      var orgId = utils.isValidObjectId(org) ? org : org.id;
+      return orgId.toString() == id.toString();
+    });
 
-    if (!self.portfolioCompany) return;
+    if (!match) { self.related.push(id); }
 
-    // wipe funds and start fresh
-    self.portfolioCompany.fundsInvested = funds;
+  };
 
-    // Checking if it's a valid object id is a shortcut
-    // TODO: The alternative is to get a list of funds and verify against that
-    // TODO: also would be good to check for dupes
-    // This is used internally, in admin, so let's punt for now
+  Organization.methods.removePerson = function(personIdToRemove) {
 
-    //_.each(fundIds, function(fundId) {
-    //  if (utilities.isValidObjectId(fundId.id)) {
-    //    self.fundsInvested.push(fundId);
-    //  };
-    //});
+    this.people = _.reject(this.people, function(existingPerson) {
+      var id = utils.isValidObjectId(existingPerson.person) ? existingPerson.person : existingPerson.person._id;
+      return id.toString() == personIdToRemove.toString();
+    });
 
   };
 
-  Organization.methods.updateChair = function(chairObj) {
-
-    var self = this;
 
-    if (!self.portfolioCompany) return;
 
-    // todo - needs customer id
+  //////////////////////////////////////////////////////
+  // STATICS
+  // Statics query the entire collection
+  //////////////////////////////////////////////////////
 
-    switch(chairObj.num) {
-      case 'chair1':
-        if(chairObj.val && chairObj.val != "") {
-          self.portfolioCompany.chairs.first = chairObj.val;
-        } else {
-          self.portfolioCompany.chairs.first = {};
-        }
-        break;
+  Organization.statics.addNote = function(organizationId, creatorPersonId, text, cb) {
 
-      case 'chair2':
-        if(chairObj.val && chairObj.val != "") {
-          self.portfolioCompany.chairs.second = chairObj.val;
-        } else {
-          self.portfolioCompany.chairs.second = {}
-        }
-        break;
-    }
+    Note.createForModel({
+      createdBy: creatorPersonId,
+      text: text
+    }, this, organizationId, cb);
 
   };
 
-  // todo - change this to exit (with acquisition or ipo)
-  Organization.methods.updateAcquisition = function(aObj) {
+  Organization.statics.deleteNote = function(noteId, cb) {
+
+    // Delete the note itself along with any references
 
     var self = this;
 
-    if (!self.portfolioCompany) return;
+    var removeReferences = function removeReferences(callback) {
+      self.update({}, {
+        $pull: { 'notes' : [noteId] }
+      }, callback);
+    };
 
-    self.portfolioCompany.acquisition = aObj;
+    async.series([
+      Note.delete.bind(Note, noteId),
+      removeReferences
+    ], function(err, results) {
+      return cb(err, null);
+    });
 
   };
 
-  Organization.methods.removeInvestmentsAndDebtsByCustomer = function(investor) {
+  Organization.statics.findByDomains = function findByDomains(domains, cb) {
+    var query = this.find({ $or: [ {'website': { $in : domains }}, {'websiteAliases': { $in : domains }} ], 'deleted': {$ne: true} });
+    query.exec(cb);
+  };
 
+  Organization.statics.findByFunds = function findByFunds(fundids, cb) {
     var self = this;
+    self
+      .find({ 'funds': { $in : fundids }, 'deleted': {$ne: true} })
+      .select('name logoUrl')
+      .exec(cb);
+  };
 
-    // todo - change to round.funds and capTable.customer
-
-    if (!self.portfolioCompany) return;
-
-    if(self.portfolioCompany.investments.length > 0) {
-      self.portfolioCompany.investments = _.reject(self.portfolioCompany.investments, function(i) {
-        return String(i.source) == String(investor._id);
-      });
-    }
+  Organization.statics.findByIds = function findByIds(ids, cb) {
 
-    if(self.portfolioCompany.debts.length > 0) {
-      self.portfolioCompany.debts = _.reject(self.portfolioCompany.debts, function(d) {
-        return String(d.source) == String(investor._id);
-      });
-    }
+    var self = this;
 
-    if(self.portfolioCompany.fundsInvested.length > 0) {
-      self.portfolioCompany.fundsInvested = _.reject(self.portfolioCompany.fundsInvested, function(f) {
-        return String(f.investor._id || f.investor) == String(investor._id);
-      });
-    }
+    self
+      .find({ '_id': { $in : ids }})
+      .populate('people.person', 'name avatarUrl title calendarEventSummaries sources')
+      .populate('related', 'name logoUrl')
+      .populate('notes')
+      .populate('chairs.first', 'name avatarUrl title')
+      .populate('chairs.second', 'name avatarUrl title')
+      .populate('funds', 'name hexColorCode')
+      .deepPopulate([
+        'people.person.sources.person',
+        'people.person.calendarEventSummaries.attendees.internal',
+        'people.person.calendarEventSummaries.attendees.external',
+        'people.person.calendarEventSummaries.notes.createdBy',
+        'notes.createdBy'
+      ], {
+        populate: {
+          'people.person.sources.person': { select: 'name avatarUrl title' },
+          'people.person.calendarEventSummaries.attendees.internal': { select: 'name avatarUrl title' },
+          'people.person.calendarEventSummaries.attendees.external': { select: 'name avatarUrl title' },
+          'people.person.calendarEventSummaries.notes.createdBy': { select: 'name avatarUrl title' },
+          'notes.createdBy': { select: 'name avatarUrl title' }
+        }
+      })
+      .exec(cb);
 
   };
 
-  Organization.methods.addCompanyToInvestor = function(idOfCompanyToAdd) {
+  Organization.statics.findByPerson = function findByPerson(personId, cb) {
+
+    // Given a person id, get all organizations with that person
 
     var self = this;
-    if (!self.investor) return;
 
-    var match = _.find(self.investor.companies, function(company) {
-      var companyId = utils.isValidObjectId(company) ? company : company.id;
-      return companyId.toString() == idOfCompanyToAdd.toString();
-    });
+    self
+      .find({ $or:
+        [
+          { 'people.person': personId },
+          { 'chairs.first': personId },
+          { 'chairs.second': personId }
+        ],
+        'deleted': { $ne: true }
+      })
+      .exec(cb);
 
-    if (!match) self.investor.companies.push(idOfCompanyToAdd);
+  };
 
+  Organization.statics.findBySlug = function findBySlug(slug, cb) {
+    this.findOne({ slug: slug, 'deleted': {$ne: true} }).exec(cb);
   };
 
-  Organization.methods.addFundToInvestor = function(idOfFundToAdd) {
+  Organization.statics.findBySlugs = function findBySlugs(slugs, cb) {
+    this.find({ 'slug': { $in : slugs }, 'deleted': {$ne: true} }).exec(cb);
+  };
 
-    var self = this;
-    if (!self.investor) return;
+  Organization.statics.findDupes = function findDupes(org, options, cb) {
 
-    var match = _.find(self.investor.funds, function(fund) {
-      var fundId = utils.isValidObjectId(fund) ? fund : fund.id;
-      return fundId.toString() == idOfFundToAdd.toString();
-    });
+    if (!cb) throw new Error('cb is required');
+    if (!org || (!org.name && !org.website)) return cb(null, []);
 
-    if (!match) self.investor.funds.push(idOfFundToAdd);
+    this.search({
+      name: org.name,
+      domain: utils.getDomain(org.website)
+    }, options, function(err, orgs) {
 
-  };
+      if (err) return cb(err, null);
+      if (!orgs) return cb(null, null);
 
-///////////////////////
-
-  // search for orgs based on fields provided
-  // data format, each field is optional
-  // {
-  //   domain: ''
-  //   name: ''
-  // }
-  // options:
-  //   fuzzy: searches within strings, e.g., searching for "venture" will match "ff Venture Capital"
-  //          non-fuzzy does a full-string match, e.g., "ffvc" will match "ffvc" but "ff" will not
-  //          both fuzzy and non are case-insensitive
-  //   queryFirstWord: tokenizes first word and searches for it
-  //   removeRelatedFromTopLevel: related people are removed from top-level results
-  Organization.statics.search = function search(data, options, cb) {
+      // exclude passed in org from results
+      orgs = _.reject(orgs, function(o) {
+        return o.id == org.id;
+      });
 
-    // validate input
+      return cb(null, orgs);
+
+    });
+
+  };
+
+  Organization.statics.flag = function(orgId, resolved, text, username, cb) {
+
+    this.findById(orgId).exec(function(err, org) {
+
+      org.flagged.resolved = resolved;
+      org.flagged.text = text;
+      org.flagged.by = username;
+      org.flagged.on = Date.now();
+
+      org.save(cb);
+
+    });
+
+  };
+
+  Organization.statics.getBoardsOfPerson = function getBoardsOfPerson(personId, cb) {
+
+    var self = this;
+
+    self
+      .find({
+        'deleted': { $ne: true },
+        'people': {
+          $elemMatch: {
+            'person': personId,
+            'board': { $in: ['chairman', 'director', 'observer'] }
+          }
+        }
+      })
+      .select('name avatarUrl')
+      .exec(cb);
+
+  };
+
+  Organization.statics.getByFund = function getByFund(id, cb) {
+    var self = this;
+    self
+      .findOne({ 'funds': id, 'deleted': {$ne: true} })
+      .select('name logoUrl')
+      .exec(cb);
+  };
+
+  Organization.statics.getById = function getById(id, cb) {
+
+    var self = this;
+
+    self
+      .findById(id)
+      .populate('people.person', 'name avatarUrl title calendarEventSummaries sources')
+      .populate('related', 'name logoUrl')
+      .populate('notes')
+      .populate('chairs.first', 'name avatarUrl title')
+      .populate('chairs.second', 'name avatarUrl title')
+      .populate('funds', 'name hexColorCode closeDate')
+      .deepPopulate([
+        'people.person.sources.person',
+        'people.person.calendarEventSummaries.attendees.internal',
+        'people.person.calendarEventSummaries.attendees.external',
+        'people.person.calendarEventSummaries.notes.createdBy',
+        'notes.createdBy'
+      ], {
+        populate: {
+          'people.person.sources.person': { select: 'name avatarUrl title' },
+          'people.person.calendarEventSummaries.attendees.internal': { select: 'name avatarUrl title' },
+          'people.person.calendarEventSummaries.attendees.external': { select: 'name avatarUrl title' },
+          'people.person.calendarEventSummaries.notes.createdBy': { select: 'name avatarUrl title' },
+          'notes.createdBy': { select: 'name avatarUrl title' }
+        }
+      })
+      .exec(cb);
+
+  };
+
+  Organization.statics.getChairsOfPerson = function getChairsOfPerson(personId, cb) {
+
+    var self = this;
+
+    self
+      .find({ $or:
+        [
+          { 'chairs.first': personId },
+          { 'chairs.second': personId }
+        ],
+        'deleted': { $ne: true }
+      })
+      .exec(cb);
+
+  };
+
+  Organization.statics.getSources = function(id, cb) {
+
+    var self = this;
+
+    self
+      .findById(id)
+      .populate('people.person', 'name avatarUrl title calendarEventSummaries sources')
+      .deepPopulate([
+        'people.person.sources.person'
+      ], {
+        populate: {
+          'people.person.sources.person': { select: 'name avatarUrl title' }
+        }
+      })
+      .exec(function(err, org) {
+
+        if (err) return cb(err, null);
+        if (!org) return cb(null, null);
+
+        self.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 = [];
+          var orgSources = getSources(org.people);
+
+          _.each(customer.people, function(p) {
+
+            var source = _.find(orgSources, function(os) {
+              return os.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
+          });
+
+        });
+
+      });
+
+  };
+
+  Organization.statics.listAllFlagged = function (cb) {
+
+    var query = this.find({'flagged.resolved': false, 'flagged.text': { $ne: '' }, 'deleted': {$ne: true}});
+    query.exec(function (err, orgs) {
+
+      if (err) return cb(err, null);
+
+      orgs = _.sortBy(orgs, function(org){
+        var timestamp = new Date(org.flagged.on);
+        timestamp = timestamp.getTime();
+        return timestamp;
+      });
+      orgs = orgs.reverse();
+
+      return cb(null, orgs);
+
+    });
+
+  };
+
+  Organization.statics.listPage = function (skip, cb) {
+
+    this
+      .find({'deleted': {$ne: true}})
+      .sort('name')
+      .skip(skip)
+      .limit(100)
+      .exec(cb)
+
+  };
+
+  Organization.statics.removeById = function(id, cb) {
+
+    if (!id) { return cb(new Error('id is required'), null); }
+    if (!cb) { throw new Error('cb is required'); }
+
+    this.remove({_id: id}, cb);
+
+  };
+
+  Organization.statics.search = function search(data, options, cb) {
+
+    // search for orgs based on fields provided
+    // data format, each field is optional
+    // {
+    //   domain: ''
+    //   name: ''
+    // }
+    // options:
+    //   fuzzy: searches within strings, e.g., searching for "venture" will match "ff Venture Capital"
+    //          non-fuzzy does a full-string match, e.g., "ffvc" will match "ffvc" but "ff" will not
+    //          both fuzzy and non are case-insensitive
+    //   queryFirstWord: tokenizes first word and searches for it
+    //   removeRelatedFromTopLevel: related people are removed from top-level results
+
+    // validate input
     if (!cb) throw new Error('cb is required');
     if (!data || (!data.name && !data.domain)) return cb(null, []);
 
@@ -686,162 +926,16 @@ module.exports = function(mongoose, config) {
 
   };
 
-  Organization.statics.findDupes = function findDupes(org, options, cb) {
-
-    if (!cb) throw new Error('cb is required');
-    if (!org || (!org.name && !org.website)) return cb(null, []);
-
-    this.search({
-      name: org.name,
-      domain: utils.getDomain(org.website)
-    }, options, function(err, orgs) {
-
-      if (err) return cb(err, null);
-      if (!orgs) return cb(null, null);
-
-      // exclude passed in org from results
-      orgs = _.reject(orgs, function(o) {
-        return o.id == org.id;
-      });
-
-      return cb(null, orgs);
-
-    });
-
+  Organization.statics.setCustomerPortfolio = function setCustomerPortfolio(portfolio) {
+    var self = this;
+    self.customerPortfolio = portfolio;
+    return self.customerPortfolio;
   };
 
   Organization.statics.stats = function stats(cb) {
     this.collection.stats(cb);
   };
 
-  Organization.statics.findByPerson = function findByPerson(personId, cb) {
-    this.find({ 'people.person': personId, 'deleted': {$ne: true} }).exec(cb);
-  };
-
-  Organization.statics.findBySlug = function findBySlug(slug, cb) {
-    this.find({ slug: slug, 'deleted': {$ne: true} }).exec(cb);
-  };
-
-  Organization.statics.findBySlugs = function findBySlugs(slugs, cb) {
-    this.find({ 'slug': { $in : slugs }, 'deleted': {$ne: true} }).exec(cb);
-  };
-
-  Organization.statics.findByDomains = function findByDomains(domains, cb) {
-    var query = this.find({ $or: [ {'website': { $in : domains }}, {'websiteAliases': { $in : domains }} ], 'deleted': {$ne: true} });
-    query.exec(cb);
-  };
-
-  Organization.statics.findByIds = function findByIds(ids, cb) {
-
-    var self = this;
-
-    self
-      .find({ '_id': { $in : ids }})
-      .populate('people.person', 'name avatarUrl title calendarEventSummaries sources')
-      .populate('related', 'name logoUrl')
-      .populate('notes')
-      .populate('chairs.first', 'name avatarUrl title')
-      .populate('chairs.second', 'name avatarUrl title')
-      .populate('funds', 'name hexColorCode')
-      .populate('rounds.funds.fund', 'name hexColorCode')
-      .populate('rounds.funds.partner', 'name avatarUrl title')
-      .populate('rounds.people.person', 'name avatarUrl title')
-      .deepPopulate([
-        'people.person.sources.person',
-        'people.person.calendarEventSummaries.attendees.internal',
-        'people.person.calendarEventSummaries.attendees.external',
-        'people.person.calendarEventSummaries.notes.createdBy',
-        'notes.createdBy'
-      ], {
-        populate: {
-          'people.person.sources.person': { select: 'name avatarUrl title' },
-          'people.person.calendarEventSummaries.attendees.internal': { select: 'name avatarUrl title' },
-          'people.person.calendarEventSummaries.attendees.external': { select: 'name avatarUrl title' },
-          'people.person.calendarEventSummaries.notes.createdBy': { select: 'name avatarUrl title' },
-          'notes.createdBy': { select: 'name avatarUrl title' }
-        }
-      })
-      .exec(cb);
-
-  };
-
-  Organization.statics.getById = function getById(id, cb) {
-
-    var self = this;
-
-    self
-      .findById(id)
-      .populate('people.person', 'name avatarUrl title calendarEventSummaries sources')
-      .populate('related', 'name logoUrl')
-      .populate('notes')
-      .populate('chairs.first', 'name avatarUrl title')
-      .populate('chairs.second', 'name avatarUrl title')
-      .populate('funds', 'name hexColorCode')
-      .populate('rounds.funds.fund', 'name hexColorCode')
-      .populate('rounds.funds.partner', 'name avatarUrl title')
-      .populate('rounds.people.person', 'name avatarUrl title')
-      .deepPopulate([
-        'people.person.sources.person',
-        'people.person.calendarEventSummaries.attendees.internal',
-        'people.person.calendarEventSummaries.attendees.external',
-        'people.person.calendarEventSummaries.notes.createdBy',
-        'notes.createdBy'
-      ], {
-        populate: {
-          'people.person.sources.person': { select: 'name avatarUrl title' },
-          'people.person.calendarEventSummaries.attendees.internal': { select: 'name avatarUrl title' },
-          'people.person.calendarEventSummaries.attendees.external': { select: 'name avatarUrl title' },
-          'people.person.calendarEventSummaries.notes.createdBy': { select: 'name avatarUrl title' },
-          'notes.createdBy': { select: 'name avatarUrl title' }
-        }
-      })
-      .exec(cb);
-
-  };
-
-  Organization.statics.getPortfolio = function getPortfolio(orgId, cb) {
-
-    var self = this;
-
-    self
-      .find({ 'rounds.funds.customer': orgId })
-      .select('name logoUrl description exit filters contact.addresses')
-      .sort('name')
-      .exec(cb);
-
-  };
-
-  Organization.statics.listPage = function (skip, cb) {
-
-    this
-      .find({'deleted': {$ne: true}})
-      .sort('name')
-      .skip(skip)
-      .limit(100)
-      .exec(cb)
-
-  };
-
-  Organization.statics.listAllFlagged = function (cb) {
-
-    var query = this.find({'flagged.resolved': false, 'flagged.text': { $ne: '' }, 'deleted': {$ne: true}});
-    query.exec(function (err, orgs) {
-
-        if (err) return cb(err, null);
-
-        orgs = _.sortBy(orgs, function(org){
-          var timestamp = new Date(org.flagged.on);
-          timestamp = timestamp.getTime();
-          return timestamp;
-        });
-        orgs = orgs.reverse();
-
-        return cb(null, orgs);
-
-      });
-
-  };
-
   Organization.statics.upsert = function(org, username, cb) {
 
     if (!org) { return cb(new Error('Organization is required'), null); }
@@ -854,61 +948,13 @@ module.exports = function(mongoose, config) {
 
   };
 
-  Organization.statics.removeById = function(id, cb) {
-
-    if (!id) { return cb(new Error('id is required'), null); }
-    if (!cb) { throw new Error('cb is required'); }
-
-    this.remove({_id: id}, cb);
-
-  };
-
-  Organization.statics.flag = function(orgId, resolved, text, username, cb) {
-
-    this.findById(orgId).exec(function(err, org) {
-
-      org.flagged.resolved = resolved;
-      org.flagged.text = text;
-      org.flagged.by = username;
-      org.flagged.on = Date.now();
-
-      org.save(cb);
 
-    });
 
-  };
-
-  Organization.statics.addNote = function(organizationId, creatorPersonId, text, cb) {
-
-    Note.createForModel({
-      createdBy: creatorPersonId,
-      text: text
-    }, this, organizationId, cb);
-
-  };
-
-  Organization.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);
-    });
-
-  };
-
-  ///////////////////////////////
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // HOOKS
+  // Pre-save: fired on every document before it is saved
+  // Post-init: fired on every document when it's returned from a query
+  ///////////////////////////////////////////////////////////////////////////////////////
 
   Organization.pre('save', function(next) {
 
@@ -928,74 +974,44 @@ module.exports = function(mongoose, config) {
 
   });
 
-  Organization.post('init', function() {
+  Organization.post('init', function(doc, next) {
 
-    // Protect private data and merge public and private data
+    // Protect private data
+    // Merge public and private data
 
-    var self = this;
     var CUSTOMER_ID = config.CUSTOMER_ID;
 
-    if (CUSTOMER_ID == 'GLOBAL_PROCESS') return;
-
-    var protectCustomerData = function protectCustomerData() {
-
-      // remove customer details if not viewing self
-      if (self._id.toString() != CUSTOMER_ID) self.customer = {};
+    if (CUSTOMER_ID == 'GLOBAL_PROCESS') return next();
 
-      self.filters = _.reject(self.filters, function(item) { return item.customer != CUSTOMER_ID; });
-      self.docs = _.reject(self.docs, function(item) { return item.customer != CUSTOMER_ID; });
-      self.iLevel = _.reject(self.iLevel, function(item) { return item.customer != CUSTOMER_ID; });
-      self.chairs = _.reject(self.chairs, function(item) { return item.customer != CUSTOMER_ID; });
-      self.capTable = _.reject(self.capTable, function(item) { return item.customer != CUSTOMER_ID; });
-
-      // investment data
-      _.each(self.rounds, function(round) {
-        _.each(round.funds, function(fund) {
-          if (fund.customer != CUSTOMER_ID) fund.investments = [];
-        });
-      });
-
-    };
+    // remove customer details if not viewing self
+    if (doc._id.toString() != CUSTOMER_ID) doc.customer = {};
 
-    var mergePublicAndPrivateData = function mergePublicAndPrivateData() {
+    doc.filters = _.reject(doc.filters, function(item) { return item.customer != CUSTOMER_ID; });
+    doc.docs = _.reject(doc.docs, function(item) { return item.customer != CUSTOMER_ID; });
+    doc.iLevel = _.reject(doc.iLevel, function(item) { return item.customer != CUSTOMER_ID; });
+    doc.chairs = _.reject(doc.chairs, function(item) { return item.customer != CUSTOMER_ID; });
 
-      // rounds are public
-      _.each(self.rounds, function(round) {
+    // people
+    _.each(doc.people, function(person) {
 
-        // note that public versions of the following data exist at this level:
-        // preMoneyValuation
-        // amountRaised
-        // closingDate
-        // this data will be overwritten if private data belonging to the current customer is present
+      // always include if explicitly public
+      if (person.public) return;
 
-        // participating funds are public
-        _.each(round.funds, function(fund) {
+      // if not public, keep it in if org is in the current customer's portfolio. otherwise remove it.
+      // todo
+      console.log(customerPortfolio);
 
-          if (fund.customer != CUSTOMER_ID) return;
-          if (!fund.investments || fund.investments.length == 0) return;
-
-          // there can be multiple investments in a single round from the same fund
-          // use the most recent
-          var mostRecentInvestment = _.max(fund.investments, function(investment) { return investment.date; });
-
-          // this fund belongs to the current customer
-          // if we have private data, use it rather than the public data
-          if (mostRecentInvestment) {
-            if (mostRecentInvestment.preMoneyValuation) round.preMoneyValuation = mostRecentInvestment.preMoneyValuation;
-            if (mostRecentInvestment.amountRaised) round.amountRaised = mostRecentInvestment.amountRaised;
-            if (mostRecentInvestment.closingDate) round.closingDate = mostRecentInvestment.closingDate;
-          }
+    });
 
-        });
+    return next();
 
-      });
+  });
 
-    };
 
-    protectCustomerData();
-    mergePublicAndPrivateData();
 
-  });
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // CONFIG
+  ///////////////////////////////////////////////////////////////////////////////////////
 
   Organization.set('toJSON', { virtuals: true });
   Organization.set('autoIndex', true);
@@ -1006,6 +1022,6 @@ module.exports = function(mongoose, config) {
   var deepPopulate = require('mongoose-deep-populate')(mongoose);
   Organization.plugin(deepPopulate);
 
-  mongoose.model('Organization', Organization, 'Organization_new');
+  mongoose.model('Organization', Organization, 'organization_new');
 
 };