@dhyasama/totem-models 1.0.1 → 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,171 +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 - ??? - clarify how to handle this
-        optionsAndWarrants: {
-          unissued: { type: Number },
-          issuedToUnspecified: { type: Number }
-        }
 
-      }],
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // HELPERS
+  ///////////////////////////////////////////////////////////////////////////////////////
 
-      // Equity or debt this organization has taken from other organizations
-      rounds: [{
+  var getSources = function getSources(people) {
 
-        roundName: { type: String, trim: true, default: null },
+    var result = _.compact(_.pluck(people, 'person'));
+    if (result.length == 0) return [];
 
-        // used when cap table round names are changed and need to be matched to investment data
-        oldRoundName: { type: String, trim: true, default: null },
+    result = _.compact(_.pluck(result, 'sources'));
+    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 = _.flatten(result);
+    result = _.compact(result);
 
-        // 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: [{
+    if (result.length == 0) return [];
+    if (mongoose.Types.ObjectId.isValid(result[0].person)) return []; // not populated
 
-          fund: { type: Schema.ObjectId, ref: 'Fund', required: true },
+    result = _.uniq(result, function(item) { return item.person._id.toString(); });
+    result = _.sortBy(result, 'interactions.count');
+    result.reverse();
+    result = _.sortBy(result, 'name.full');
 
-          // the lead on this round from the fund/org
-          partner: { type: Schema.ObjectId, ref: 'Person', required: false },
+    return result;
 
-          // 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 },
+  };
 
-          // 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 },
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // VIRTUALS
+  // Properties that are not persisted to the database
+  ///////////////////////////////////////////////////////////////////////////////////////
 
-            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 }
-            }]
+  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 () {
 
-        }],
+    var self = this;
+    var members = [];
 
-        // People that participated in this round
-        // This is a public list of people that invested
-        people: [{
-          person: {type: Schema.ObjectId, ref: 'Person'}
-        }]
+    _.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('board.current').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);
     });
 
-  ///////////////////////////////
+    members = _.sortBy(members, function(member) {
+      if (!member || !member.name) return null;
+      return member.name.last + member.name.first;
+    });
 
-  Organization.virtual('status').get(function () {
+    return members;
+
+  });
+
+  Organization.virtual('board.past').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('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);
     });
-    return primary ? primary.address : null;
+
+    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('sources').get(function () {
+  Organization.virtual('employees.current').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;
+
+  });
 
-    // Aggregate sources from all people at org
-    // Sort by interactions descending, full name ascending
+  Organization.virtual('employees.past').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('leaders.all').get(function () {
+
+    var self = this;
+    var result = [];
+
+    _.each(self.people, function(p) {
+      if (p.leader) 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.current').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 && p.current) 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.past').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;
+
+  });
+
+  Organization.virtual('status').get(function () {
+
+    var self = this;
+
+    // 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';
+
+  });
+
 
-  };
+
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // 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) {
 
@@ -358,165 +422,149 @@ 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;
   };
 
-///////////////////////
-
-  // 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) {
+  Organization.methods.merge = function(id) {
+    if (this.merged.indexOf(id) == -1) {
+      this.merged.push(id);
+      return true;
+    }
+    else {
+      return false;
+    }
+  };
 
-    // validate input
-    if (!cb) throw new Error('cb is required');
-    if (!data || (!data.name && !data.domain)) return cb(null, []);
+  Organization.methods.relateOrg = function(id) {
 
-    var defaultOptions = {
-      fuzzy: true,
-      queryFirstWord: false,
-      removeRelatedFromTopLevel: true
-    };
+    var self = this;
 
-    // combine provided and default options
-    options = utils.setDefaults(options, defaultOptions);
+    var match = _.find(self.related, function(org) {
+      var orgId = utils.isValidObjectId(org) ? org : org.id;
+      return orgId.toString() == id.toString();
+    });
 
-    // need to be admin or provide investor id
-    if (!options.admin && !options.investor) return cb(null, []);
+    if (!match) { self.related.push(id); }
 
-    data.name = data.name || '';
-    data.domain = data.domain || '';
+  };
 
-    var removeRelatedFromTopLevel = function(items) {
+  Organization.methods.removePerson = function(personIdToRemove) {
 
-      // All entities are searched initially, including entities that are listed as related to other entities
-      // Remove related entities from top-level results so they only come up as related
+    this.people = _.reject(this.people, function(existingPerson) {
+      var id = utils.isValidObjectId(existingPerson.person) ? existingPerson.person : existingPerson.person._id;
+      return id.toString() == personIdToRemove.toString();
+    });
 
-      var getRelatedIds = function getRelatedIds(items) {
+  };
 
-        var result = [];
 
-        _.each(items, function(item) {
-          if (item.related && item.related.length >= 1) {
-            var ids = _.pluck(item.related, 'id');
-            result = result.concat(ids);
-          }
-        });
 
-        return _.uniq(result);
+  //////////////////////////////////////////////////////
+  // STATICS
+  // Statics query the entire collection
+  //////////////////////////////////////////////////////
 
-      };
+  Organization.statics.addNote = function(organizationId, creatorPersonId, text, cb) {
 
-      var relatedIds = getRelatedIds(items);
-      items = _.reject(items, function(item) {
-        return relatedIds.indexOf(item.id) >= 0;
-      });
+    Note.createForModel({
+      createdBy: creatorPersonId,
+      text: text
+    }, this, organizationId, cb);
 
-      return items;
+  };
 
-    };
+  Organization.statics.deleteNote = function(noteId, cb) {
 
-    // use first word in org name to look for fuzzy matches which is a simple
-    // but effective technique as the first word is commonly the most important
-    var tokenizeName = function tokenizeName(name, query) {
+    // Delete the note itself along with any references
 
-      if (!name) throw new Error('name is required');
-      if (!query) throw new Error('query is required');
+    var self = this;
 
-      var parts = [];
+    var removeReferences = function removeReferences(callback) {
+      self.update({}, {
+        $pull: { 'notes' : [noteId] }
+      }, callback);
+    };
 
-      try { parts = name.toString().split(' '); }
-      catch (err) { throw err; }
+    async.series([
+      Note.delete.bind(Note, noteId),
+      removeReferences
+    ], function(err, results) {
+      return cb(err, null);
+    });
 
-      // fuzzy search first word if more than one word in phrase
-      if (parts.length >= 2) {
-        query['$or'].push({ 'name': new RegExp(parts[0], 'i') });
-      }
+  };
 
-    };
+  Organization.statics.findByDomains = function findByDomains(domains, cb) {
+    var query = this.find({ $or: [ {'website': { $in : domains }}, {'websiteAliases': { $in : domains }} ], 'deleted': {$ne: true} });
+    query.exec(cb);
+  };
 
-    var buildQuery = function buildQuery(data, options) {
+  Organization.statics.findByFunds = function findByFunds(fundids, cb) {
+    var self = this;
+    self
+      .find({ 'funds': { $in : fundids }, 'deleted': {$ne: true} })
+      .select('name logoUrl')
+      .exec(cb);
+  };
 
-      // prepare query
-      var query = {};
-      query['$or'] = [];  // these will be added dynamically from data parameter
-      query['$and'] = []; // these will be added dynamically from data parameter
-      query['deleted'] = { $ne: true }; // always include this
+  Organization.statics.findByIds = function findByIds(ids, cb) {
 
-      // conditionally include name
-      if (data.name) {
+    var self = this;
 
-        // an exact match is always a good thing
-        query['$or'].push({ 'name': new RegExp('^' + data.name + '$', 'i') });
-
-        if (options.fuzzy) {
-          // fuzzy search full phrase
-          query['$or'].push({'name': new RegExp(data.name, 'i')});
-        }
-
-        if (options.queryFirstWord) {
-          // fuzzy search first word
-          tokenizeName(data.name, query);
+    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);
 
-        var aliasRegExp = options.fuzzy ? new RegExp(data.name, 'i') : new RegExp('^' + data.name + '$', 'i');
-        query['$or'].push({ 'aliases': aliasRegExp });
-
-      }
-
-      // conditionally include domain
-      if (data.domain) {
-        var domainRegExp = options.fuzzy ? new RegExp(data.domain, 'i') : new RegExp('^' + data.domain + '$', 'i');
-        query['$or'].push({ 'website': domainRegExp });
-      }
-
-      // remove if unused
-      if (query['$or'].length == 0) delete query['$or'];
-      if (query['$and'].length == 0) delete query['$and'];
-
-      return query;
-
-    };
-
-    var query = buildQuery(data, options);
-
-    this
-      .find(query)
-      .populate('merged')
-      .select('logoUrl name description related')
-      .exec(function(err, orgs) {
+  };
 
-        if (err) return cb(err, null);
-        else if (!orgs) return cb(null, null);
-        else {
+  Organization.statics.findByPerson = function findByPerson(personId, cb) {
 
-          // remove related from top level
-          if (options.removeRelatedFromTopLevel) orgs = removeRelatedFromTopLevel(orgs);
+    // Given a person id, get all organizations with that person
 
-          // sort by name
-          orgs = _.sortBy(orgs, function(orgs) { return orgs.name; });
+    var self = this;
 
-          return cb(null, orgs);
+    self
+      .find({ $or:
+        [
+          { 'people.person': personId },
+          { 'chairs.first': personId },
+          { 'chairs.second': personId }
+        ],
+        'deleted': { $ne: true }
+      })
+      .exec(cb);
 
-        }
+  };
 
-      });
+  Organization.statics.findBySlug = function findBySlug(slug, cb) {
+    this.findOne({ 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.findDupes = function findDupes(org, options, cb) {
@@ -543,43 +591,60 @@ module.exports = function(mongoose, config) {
 
   };
 
-  Organization.statics.stats = function stats(cb) {
-    this.collection.stats(cb);
-  };
+  Organization.statics.flag = function(orgId, resolved, text, username, cb) {
 
-  Organization.statics.findByPerson = function findByPerson(personId, cb) {
-    // Given a person id, get all organizations with that person
-    this.find({ 'people.person': personId, 'deleted': {$ne: true} }).exec(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.findBySlug = function findBySlug(slug, cb) {
-    this.findOne({ 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.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.findByDomains = function findByDomains(domains, cb) {
-    var query = this.find({ $or: [ {'website': { $in : domains }}, {'websiteAliases': { $in : domains }} ], 'deleted': {$ne: true} });
-    query.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.findByIds = function findByIds(ids, cb) {
+  Organization.statics.getById = function getById(id, cb) {
 
     var self = this;
 
     self
-      .find({ '_id': { $in : ids }})
+      .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')
+      .populate('funds', 'name hexColorCode closeDate')
       .deepPopulate([
         'people.person.sources.person',
         'people.person.calendarEventSummaries.attendees.internal',
@@ -599,51 +664,94 @@ module.exports = function(mongoose, config) {
 
   };
 
-  Organization.statics.getById = function getById(id, 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')
-      .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'
+        'people.person.sources.person'
       ], {
         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' }
+          'people.person.sources.person': { select: 'name avatarUrl title' }
         }
       })
-      .exec(cb);
+      .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.getPortfolio = function getPortfolio(orgId, cb) {
+  Organization.statics.listAllFlagged = function (cb) {
 
-    // Get all organizations invested in by the given org id
+    var query = this.find({'flagged.resolved': false, 'flagged.text': { $ne: '' }, 'deleted': {$ne: true}});
+    query.exec(function (err, orgs) {
 
-    var self = this;
+      if (err) return cb(err, null);
 
-    self
-      .find({ 'rounds.funds.customer': orgId })
-      .select('name logoUrl description exit filters contact.addresses')
-      .sort('name')
-      .exec(cb);
+      orgs = _.sortBy(orgs, function(org){
+        var timestamp = new Date(org.flagged.on);
+        timestamp = timestamp.getTime();
+        return timestamp;
+      });
+      orgs = orgs.reverse();
+
+      return cb(null, orgs);
+
+    });
 
   };
 
@@ -658,93 +766,195 @@ module.exports = function(mongoose, config) {
 
   };
 
-  Organization.statics.listAllFlagged = function (cb) {
+  Organization.statics.removeById = function(id, cb) {
 
-    var query = this.find({'flagged.resolved': false, 'flagged.text': { $ne: '' }, 'deleted': {$ne: true}});
-    query.exec(function (err, orgs) {
+    if (!id) { return cb(new Error('id is required'), null); }
+    if (!cb) { throw new Error('cb is required'); }
 
-        if (err) return cb(err, null);
+    this.remove({_id: id}, cb);
+
+  };
 
-        orgs = _.sortBy(orgs, function(org){
-          var timestamp = new Date(org.flagged.on);
-          timestamp = timestamp.getTime();
-          return timestamp;
+  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, []);
+
+    var defaultOptions = {
+      fuzzy: true,
+      queryFirstWord: false,
+      removeRelatedFromTopLevel: true
+    };
+
+    // combine provided and default options
+    options = utils.setDefaults(options, defaultOptions);
+
+    // need to be admin or provide investor id
+    if (!options.admin && !options.investor) return cb(null, []);
+
+    data.name = data.name || '';
+    data.domain = data.domain || '';
+
+    var removeRelatedFromTopLevel = function(items) {
+
+      // All entities are searched initially, including entities that are listed as related to other entities
+      // Remove related entities from top-level results so they only come up as related
+
+      var getRelatedIds = function getRelatedIds(items) {
+
+        var result = [];
+
+        _.each(items, function(item) {
+          if (item.related && item.related.length >= 1) {
+            var ids = _.pluck(item.related, 'id');
+            result = result.concat(ids);
+          }
         });
-        orgs = orgs.reverse();
 
-        return cb(null, orgs);
+        return _.uniq(result);
+
+      };
 
+      var relatedIds = getRelatedIds(items);
+      items = _.reject(items, function(item) {
+        return relatedIds.indexOf(item.id) >= 0;
       });
 
-  };
+      return items;
 
-  Organization.statics.upsert = function(org, username, cb) {
+    };
 
-    if (!org) { return cb(new Error('Organization is required'), null); }
-    if (!username) { return cb(new Error('Username is required'), null); }
+    // use first word in org name to look for fuzzy matches which is a simple
+    // but effective technique as the first word is commonly the most important
+    var tokenizeName = function tokenizeName(name, query) {
 
-    org.entered.by = username;
-    org.entered.on = new Date();
+      if (!name) throw new Error('name is required');
+      if (!query) throw new Error('query is required');
 
-    org.save(cb);
+      var parts = [];
 
-  };
+      try { parts = name.toString().split(' '); }
+      catch (err) { throw err; }
 
-  Organization.statics.removeById = function(id, cb) {
+      // fuzzy search first word if more than one word in phrase
+      if (parts.length >= 2) {
+        query['$or'].push({ 'name': new RegExp(parts[0], 'i') });
+      }
 
-    if (!id) { return cb(new Error('id is required'), null); }
-    if (!cb) { throw new Error('cb is required'); }
+    };
 
-    this.remove({_id: id}, cb);
+    var buildQuery = function buildQuery(data, options) {
 
-  };
+      // prepare query
+      var query = {};
+      query['$or'] = [];  // these will be added dynamically from data parameter
+      query['$and'] = []; // these will be added dynamically from data parameter
+      query['deleted'] = { $ne: true }; // always include this
 
-  Organization.statics.flag = function(orgId, resolved, text, username, cb) {
+      // conditionally include name
+      if (data.name) {
 
-    this.findById(orgId).exec(function(err, org) {
+        // an exact match is always a good thing
+        query['$or'].push({ 'name': new RegExp('^' + data.name + '$', 'i') });
 
-      org.flagged.resolved = resolved;
-      org.flagged.text = text;
-      org.flagged.by = username;
-      org.flagged.on = Date.now();
+        if (options.fuzzy) {
+          // fuzzy search full phrase
+          query['$or'].push({'name': new RegExp(data.name, 'i')});
+        }
 
-      org.save(cb);
+        if (options.queryFirstWord) {
+          // fuzzy search first word
+          tokenizeName(data.name, query);
+        }
 
-    });
+        var aliasRegExp = options.fuzzy ? new RegExp(data.name, 'i') : new RegExp('^' + data.name + '$', 'i');
+        query['$or'].push({ 'aliases': aliasRegExp });
 
-  };
+      }
 
-  Organization.statics.addNote = function(organizationId, creatorPersonId, text, cb) {
+      // conditionally include domain
+      if (data.domain) {
+        var domainRegExp = options.fuzzy ? new RegExp(data.domain, 'i') : new RegExp('^' + data.domain + '$', 'i');
+        query['$or'].push({ 'website': domainRegExp });
+      }
 
-    Note.createForModel({
-      createdBy: creatorPersonId,
-      text: text
-    }, this, organizationId, cb);
+      // remove if unused
+      if (query['$or'].length == 0) delete query['$or'];
+      if (query['$and'].length == 0) delete query['$and'];
 
-  };
+      return query;
 
-  Organization.statics.deleteNote = function(noteId, cb) {
+    };
 
-    // Delete the note itself along with any references
+    var query = buildQuery(data, options);
+
+    this
+      .find(query)
+      .populate('merged')
+      .select('logoUrl name description related')
+      .exec(function(err, orgs) {
+
+        if (err) return cb(err, null);
+        else if (!orgs) return cb(null, null);
+        else {
+
+          // remove related from top level
+          if (options.removeRelatedFromTopLevel) orgs = removeRelatedFromTopLevel(orgs);
+
+          // sort by name
+          orgs = _.sortBy(orgs, function(orgs) { return orgs.name; });
+
+          return cb(null, orgs);
+
+        }
+
+      });
 
+  };
+
+  Organization.statics.setCustomerPortfolio = function setCustomerPortfolio(portfolio) {
     var self = this;
+    self.customerPortfolio = portfolio;
+    return self.customerPortfolio;
+  };
 
-    var removeReferences = function removeReferences(callback) {
-      self.update({}, {
-        $pull: { 'notes' : [noteId] }
-      }, callback);
-    };
+  Organization.statics.stats = function stats(cb) {
+    this.collection.stats(cb);
+  };
 
-    async.series([
-      Note.delete.bind(Note, noteId),
-      removeReferences
-    ], function(err, results) {
-      return cb(err, null);
-    });
+  Organization.statics.upsert = function(org, username, cb) {
+
+    if (!org) { return cb(new Error('Organization is required'), null); }
+    if (!username) { return cb(new Error('Username is required'), null); }
+
+    org.entered.by = username;
+    org.entered.on = new Date();
+
+    org.save(cb);
 
   };
 
-  ///////////////////////////////
+
+
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // 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) {
 
@@ -764,75 +974,44 @@ module.exports = function(mongoose, config) {
 
   });
 
-  Organization.post('init', function() {
+  Organization.post('init', function(doc, next) {
 
     // Protect private data
     // Merge public and private data
 
-    var self = this;
     var CUSTOMER_ID = config.CUSTOMER_ID;
 
-    if (CUSTOMER_ID == 'GLOBAL_PROCESS') return;
+    if (CUSTOMER_ID == 'GLOBAL_PROCESS') return next();
 
-    var protectCustomerData = function protectCustomerData() {
+    // remove customer details if not viewing self
+    if (doc._id.toString() != CUSTOMER_ID) doc.customer = {};
 
-      // remove customer details if not viewing self
-      if (self._id.toString() != CUSTOMER_ID) self.customer = {};
-
-      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 = [];
-        });
-      });
-
-    };
+    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; });
 
-    var mergePublicAndPrivateData = function mergePublicAndPrivateData() {
+    // people
+    _.each(doc.people, function(person) {
 
-      // rounds are public
-      _.each(self.rounds, function(round) {
+      // always include if explicitly public
+      if (person.public) return;
 
-        // 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
+      // if not public, keep it in if org is in the current customer's portfolio. otherwise remove it.
+      // todo
+      console.log(customerPortfolio);
 
-        // participating funds are public
-        _.each(round.funds, function(fund) {
-
-          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);
@@ -843,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');
 
 };