@dhyasama/totem-models 1.0.0

package/lib/Organization.js

@@ -0,0 +1,1011 @@
+"use strict";
+
+module.exports = function(mongoose, config) {
+
+  var LPS_ENABLED = config.LPS_ENABLED || false;
+
+  var
+
+    _ = require('underscore'),
+    async = require('async'),
+    utils = require('@dhyasama/ffvc-utilities'),
+    Schema = mongoose.Schema,
+    Note = mongoose.model('Note'),
+
+    Organization = new Schema({
+
+      name: { type: String, required: true, index: true },
+
+      slug: { type: String, required: true, unique: true, sparse: false, trim: true, lowercase: true },
+
+      logoUrl: { type: String, trim: true },
+
+      description: { type: String, trim: true },
+
+      website: { type: String, unique: true, sparse: true, required: false, trim: true, lowercase: true },
+
+      websiteAliases: [ { type: String, unique: true, sparse: true, trim: true, lowercase: true } ],
+
+      social: {
+        twitter: { type: String, trim: true, unique: true, sparse: true },
+        facebook: { type: String, trim: true, unique: true, sparse: true },
+        linkedin: { type: String, trim: true, unique: true, sparse: true }
+      },
+
+      contact: {
+
+        phone: [{
+          type: { type: String, default: null, trim: true },
+          number: { type: String, default: null, trim: true },
+          primary: { type: Boolean, default: false }
+        }],
+
+        email: [{
+          type: { type: String, default: null, trim: true },
+          email: { type: String, default: null, trim: true, lowercase: true },
+          primary: { type: Boolean, default: false }
+        }],
+
+        address: [{
+          type: { type: String, default: '', trim: true },
+          street: { type: String, default: '', trim: true },
+          suite: { type: String, default: '', trim: true },
+          city: { type: String, default: '', trim: true },
+          state: { type: String, default: '', trim: true },
+          country: { type: String, default: '', trim: true },
+          postalCode: { type: String, default: '', trim: true },
+          primary: { type: Boolean, default: false }
+        }]
+
+      },
+
+      people: [{
+        person: { type: Schema.ObjectId, ref: 'Person', required: true, index: true },
+        title: { type: String, default: null, trim: true },
+        current: { type: Boolean, default: false, index: true },
+        leader: { type: Boolean, default: false, index: true },
+        board: { type: String, enum: ['chairman', 'director', 'observer', 'none'], default: 'none', index: true }
+      }],
+
+      entered: {
+        by: { type: String, default: '', trim: true },
+        on: { type: Date, default: Date.now }
+      },
+
+      flagged: {
+        by: { type: String, default: '', trim: true },
+        on: { type: Date, default: Date.now },
+        text: { type: String, default: '', trim: true },
+        resolved: { type: Boolean, default: false }
+      },
+
+      merged: [{ type: Schema.ObjectId, ref: 'Organization' }],
+
+      deleted: { type: Boolean, default: false },
+
+      aliases: [ { type: String, trim: true } ],
+
+      foundedOn: { type: Date, default: null },
+      closedOn: { type: Date, default: null },
+
+      exit: {
+
+        acquisition: {
+          by: { type: Schema.ObjectId, ref: 'Organization' },
+          year: { type: Date, default: null },
+          amount: { type: Number, default: 0 }
+        },
+
+        ipo: {
+          ticker: {type: String, default: null, trim: true},
+          year: {type: Date, default: null}
+        }
+
+      },
+
+      filters: [{
+        group: { type: String, trim: true },
+        items: [{ type: String, trim: true }],
+        customer: { type: Schema.ObjectId, ref: 'Organization' }
+      }],
+
+      crunchbase: {
+        uuid: { type: String, unique: true, sparse: true, trim: true },
+        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)
+      notes: [ { type: Schema.ObjectId, ref: 'Note' } ],
+
+      customer: {
+
+        active: { type: Boolean, default: false },
+
+        totemUrl: { type: String, trim: true, unique: true, sparse: true },
+
+        style: {
+          backgroundColor: { type: String, default: '#666666', trim: true },
+          textColor: { type: String, default: '#ffffff', trim: true }
+        },
+
+        investmentsSheet: {
+          sheet: { type: String, trim: true, unique: true, sparse: true },
+          googleSheetCreds: {
+            private_key_id: { type: String, trim: true, unique: true, sparse: true },
+            private_key: { type: String, trim: true, unique: true, sparse: true },
+            client_email: { type: String, trim: true, unique: true, sparse: true },
+            client_id: { type: String, trim: true, unique: true, sparse: true },
+            type: { type: String, trim: true }
+          }
+        },
+
+        eshares: {
+          firmid: { type: String, unique: true, sparse: true, trim: true }
+        }
+
+      },
+
+      docs: [{
+        customer: { type: Schema.ObjectId, ref: 'Organization' },
+        url: { type: String, trim: true, unique: true, sparse: true }
+      }],
+
+      // Link to deeper data on iLevel
+      // iLevelUser must be true at the account level
+      iLevel: [{
+        customer: { type: Schema.ObjectId, ref: 'Organization' },
+        url: { type: String, trim: true, unique: true, sparse: true }
+      }],
+
+      chairs: [{
+        customer: { type: Schema.ObjectId, ref: 'Organization' },
+        first: { type: Schema.ObjectId,  ref: 'Person' },
+        second: { type: Schema.ObjectId, ref: 'Person' }
+      }],
+
+      // 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' }],
+
+      // 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: [{
+
+        roundName: { type: String, trim: true, default: null },
+
+        // used when cap table round names are changed and need to be matched to investment data
+        oldRoundName: { type: String, trim: true, default: null },
+
+        // 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 },
+
+        // 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: [{
+
+          fund: { type: Schema.ObjectId, ref: 'Fund', required: true },
+
+          // the lead on this round from the fund/org
+          partner: { type: Schema.ObjectId, ref: 'Person', required: false },
+
+          // 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 },
+
+            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 }
+            }]
+
+          }]
+
+        }],
+
+        // People that participated in this round
+        // This is a public list of people that invested
+        people: [{
+          person: {type: Schema.ObjectId, ref: 'Person'}
+        }]
+
+      }],
+
+    });
+
+  ///////////////////////////////
+
+  Organization.virtual('status').get(function () {
+
+    var self = this;
+
+    // infer from data
+
+    if (self.closedOn) return 'Dead';
+    else if (self.ipo.year) return 'IPO';
+    else if (self.acquisition.year) return 'Acquired';
+    else return 'Active';
+
+  });
+
+  Organization.virtual('address.primary').get(function () {
+    var primary = _.find(this.contact.address, function(address) {
+      return address.primary;
+    });
+    return primary ? primary.address : null;
+  });
+
+  Organization.virtual('sources').get(function () {
+
+    // Aggregate sources from all people at org
+    // Sort by interactions descending, full name ascending
+
+    var self = this;
+
+    var result = _.compact(_.pluck(self.people, 'person'));
+    if (result.length == 0) return [];
+
+    result = _.compact(_.pluck(result, 'sources'));
+    if (result.length == 0) return [];
+
+    result = _.flatten(result);
+    result = _.compact(result);
+
+    if (result.length == 0) return [];
+    if (mongoose.Types.ObjectId.isValid(result[0].person)) return []; // not populated
+
+    result = _.uniq(result, function(item) { return item.person._id.toString(); });
+    result = _.sortBy(result, 'interactions.count');
+    result.reverse();
+    result = _.sortBy(result, 'name.full');
+
+    return result;
+
+  });
+
+  ///////////////////////////////
+
+  Organization.methods.merge = function(id) {
+    if (this.merged.indexOf(id) == -1) {
+      this.merged.push(id);
+      return true;
+    }
+    else {
+      return false;
+    }
+  };
+
+  Organization.methods.deleteOrg = function() {
+    // Soft delete
+    this.deleted = true;
+  };
+
+  Organization.methods.relateOrg = function(id) {
+
+    var self = this;
+
+    var match = _.find(self.related, function(org) {
+      var orgId = utils.isValidObjectId(org) ? org : org.id;
+      return orgId.toString() == id.toString();
+    });
+
+    if (!match) { self.related.push(id); }
+
+  };
+
+  // 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;
+    }
+
+    if(!compoundField) {
+      this[field] = value;
+    } else {
+      var parentField = field.split('.')[0];
+      var childField = field.split('.')[1];
+
+      this[parentField][childField] = value;
+    }
+
+  };
+
+  Organization.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;
+    }
+
+  };
+
+  Organization.methods.updateContact = function(field, value) {
+
+    var parentField = field.split('.')[0];
+    var childField = field.split('.')[1];
+
+    this[parentField][childField] = value;
+
+  };
+
+  Organization.methods.addPerson = function(personToAdd) {
+
+    var self = this;
+
+    // Some simple validation
+    if (!personToAdd) throw new Error('Must supply person to add');
+    if (!personToAdd.person) throw new Error('Person to add must have person reference');
+    if (!utils.isValidObjectId(personToAdd.person)) throw new Error('Person reference must be a valid objectid');
+
+    // Check if person is already added
+    var match = _.find(self.people, function(existingPerson) {
+      var id = utils.isValidObjectId(existingPerson.person) ? existingPerson.person : existingPerson.person.id;
+      return id.toString() == personToAdd.person.toString();
+    });
+
+    // If not, add it
+    if (!match) self.people.push(personToAdd);
+
+  };
+
+  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.updateFunds = function(funds) {
+
+    var self = this;
+
+    // todo - ??? - funds invested into this org or funds this org invests from?
+
+    if (!self.portfolioCompany) return;
+
+    // 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
+
+    //_.each(fundIds, function(fundId) {
+    //  if (utilities.isValidObjectId(fundId.id)) {
+    //    self.fundsInvested.push(fundId);
+    //  };
+    //});
+
+  };
+
+  Organization.methods.updateChair = function(chairObj) {
+
+    var self = this;
+
+    if (!self.portfolioCompany) return;
+
+    // todo - needs customer id
+
+    switch(chairObj.num) {
+      case 'chair1':
+        if(chairObj.val && chairObj.val != "") {
+          self.portfolioCompany.chairs.first = chairObj.val;
+        } else {
+          self.portfolioCompany.chairs.first = {};
+        }
+        break;
+
+      case 'chair2':
+        if(chairObj.val && chairObj.val != "") {
+          self.portfolioCompany.chairs.second = chairObj.val;
+        } else {
+          self.portfolioCompany.chairs.second = {}
+        }
+        break;
+    }
+
+  };
+
+  // todo - change this to exit (with acquisition or ipo)
+  Organization.methods.updateAcquisition = function(aObj) {
+
+    var self = this;
+
+    if (!self.portfolioCompany) return;
+
+    self.portfolioCompany.acquisition = aObj;
+
+  };
+
+  Organization.methods.removeInvestmentsAndDebtsByCustomer = function(investor) {
+
+    var self = this;
+
+    // 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);
+      });
+    }
+
+    if(self.portfolioCompany.debts.length > 0) {
+      self.portfolioCompany.debts = _.reject(self.portfolioCompany.debts, function(d) {
+        return String(d.source) == String(investor._id);
+      });
+    }
+
+    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);
+      });
+    }
+
+  };
+
+  Organization.methods.addCompanyToInvestor = function(idOfCompanyToAdd) {
+
+    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();
+    });
+
+    if (!match) self.investor.companies.push(idOfCompanyToAdd);
+
+  };
+
+  Organization.methods.addFundToInvestor = function(idOfFundToAdd) {
+
+    var self = this;
+    if (!self.investor) return;
+
+    var match = _.find(self.investor.funds, function(fund) {
+      var fundId = utils.isValidObjectId(fund) ? fund : fund.id;
+      return fundId.toString() == idOfFundToAdd.toString();
+    });
+
+    if (!match) self.investor.funds.push(idOfFundToAdd);
+
+  };
+
+///////////////////////
+
+  // 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) {
+
+    // 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);
+          }
+        });
+
+        return _.uniq(result);
+
+      };
+
+      var relatedIds = getRelatedIds(items);
+      items = _.reject(items, function(item) {
+        return relatedIds.indexOf(item.id) >= 0;
+      });
+
+      return items;
+
+    };
+
+    // 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) {
+
+      if (!name) throw new Error('name is required');
+      if (!query) throw new Error('query is required');
+
+      var parts = [];
+
+      try { parts = name.toString().split(' '); }
+      catch (err) { throw err; }
+
+      // fuzzy search first word if more than one word in phrase
+      if (parts.length >= 2) {
+        query['$or'].push({ 'name': new RegExp(parts[0], 'i') });
+      }
+
+    };
+
+    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
+
+      // conditionally include name
+      if (data.name) {
+
+        // 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);
+        }
+
+        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 {
+
+          // 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.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.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); }
+    if (!username) { return cb(new Error('Username is required'), null); }
+
+    org.entered.by = username;
+    org.entered.on = new Date();
+
+    org.save(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.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);
+    });
+
+  };
+
+  ///////////////////////////////
+
+  Organization.pre('save', function(next) {
+
+    var self = this;
+
+    // Format website
+    if (self.website) self.website = utils.getDomain(self.website);
+
+    // Format website aliases
+    if (self.websiteAliases && self.websiteAliases.length >= 1) {
+      self.websiteAliases = _.map(self.websiteAliases, function(alias) {
+        return utils.getDomain(alias);
+      });
+    }
+
+    return next();
+
+  });
+
+  Organization.post('init', function() {
+
+    // Protect private data and 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 = {};
+
+      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 = [];
+        });
+      });
+
+    };
+
+    var mergePublicAndPrivateData = function mergePublicAndPrivateData() {
+
+      // rounds are public
+      _.each(self.rounds, function(round) {
+
+        // 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
+
+        // 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;
+          }
+
+        });
+
+      });
+
+    };
+
+    protectCustomerData();
+    mergePublicAndPrivateData();
+
+  });
+
+  Organization.set('toJSON', { virtuals: true });
+  Organization.set('autoIndex', true);
+
+  Organization.index({ website: 1,  websiteAliases: 1 }, { unique: true, sparse: true });
+  Organization.on('index', function(err) { console.log('error building organization_new indexes: ' + err); });
+
+  var deepPopulate = require('mongoose-deep-populate')(mongoose);
+  Organization.plugin(deepPopulate);
+
+  mongoose.model('Organization', Organization, 'Organization_new');
+
+};