@dhyasama/totem-models 1.0.1 → 1.6.1

package/lib/Round.js

@@ -0,0 +1,805 @@
+"use strict";
+
+///////////////////////////////////////////////////////////////////////////////////////
+// ROUNDS
+//
+// This is public data
+//
+// These are not referenced in orgs. If you need the rounds for an org, query this
+// collection separately and stitch together as necessary
+//
+// Each round has zero to many investments which are private. They are conditionally
+// populated based on the current customer.
+//
+// Rounds are rarely deleted. Compare that to cap tables and investments which are
+// wiped on each sheet pull.
+//
+///////////////////////////////////////////////////////////////////////////////////////
+
+
+
+module.exports = function(mongoose, config) {
+
+  var Schema = mongoose.Schema;
+  var Organization = mongoose.model('Organization');
+  var utils = require('@dhyasama/ffvc-utilities');
+  var async = require('async');
+  var _ = require('underscore');
+
+  var Round = new Schema({
+
+    organization: { type: Schema.ObjectId, ref: 'Organization', required: true, index: true },
+
+    roundName: { type: String, trim: true, required: true },
+
+    // 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
+    // if private data exists (in the form of investments), the most recent investment data will be used
+    preMoneyValuation: { type: Number, default: 0 },
+    dollarsRaised: { type: Number, default: 0 },
+    closingDate: { type: Date, default: null },
+
+    // People that participated in this round
+    // This is a public list of people that invested
+    // Use the addPerson method and removePerson static
+    people: [{
+      person: { type: Schema.ObjectId, ref: 'Person', index: true },
+      _id: false
+    }],
+
+    // Investment vehicles that participated in this round
+    // Currently only funds. May expand to SPVs.
+    // Recall that a fund belongs to an organization
+    // This is a public list of funds, i.e., orgs that invested
+    // Use the addVehicle method and removeVehicle static
+    vehicles: [{
+
+      // this is how an investor is referenced, indirectly through the investor's fund
+      // note we can have a fund here without a corresponding investment which is how we can show round participants that aren't customers
+      fund: { type: Schema.ObjectId, ref: 'Fund', required: true, index: true },
+
+      // Investments in this round, from this vehicle, which is all private data
+      // This data is conditionally populated for the current customer
+      // Use the addInvestment method
+      // These references are removed by the Investment post-remove hook calling Round.removeInvestment
+      investments: [{ type: Schema.ObjectId, ref: 'Investment', required: false }],
+
+      // computed from investments
+      cost: { type: Number, default: 0 },
+
+      // set at the vehicle level during investment pull
+      fairValue: { type: Number, default: 0 },
+      valuationDate: { type: Date, default: null },
+      unrealized: { type: Number, default: 0 },
+      realized: { type: Number, default: 0 },
+
+      _id: false
+
+    }]
+
+  });
+
+
+
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // HELPERS
+  ///////////////////////////////////////////////////////////////////////////////////////
+
+  var buildPortfolio = function buildPortfolio(rounds, fundIds) {
+
+    // Given a collection of rounds and funds, construct a portfolio of organizations
+
+    var portfolio = [];
+
+    var calculateOrgPerformance = function calculateOrgPerformance(org, rounds) {
+
+      // sum the cost of each vehicle
+      org.cost = _.reduce(rounds, function(memo, round) {
+        var sum = _.reduce(round.vehicles, function(memo, vehicle) { return memo + vehicle.cost; }, 0);
+        return memo + sum;
+      }, 0);
+
+      // sum the fair value of each vehicle, i.e., the unrealized value
+      org.unrealized = _.reduce(rounds, function(memo, round) {
+        var sum = _.reduce(round.vehicles, function(memo, vehicle) { return memo + vehicle.fairValue; }, 0);
+        return memo + sum;
+      }, 0);
+
+      // sum the realized value (typically from proceeds)
+      org.realized = _.reduce(rounds, function(memo, round) {
+        var sum = _.reduce(round.vehicles, function(memo, vehicle) { return memo + vehicle.realized; }, 0);
+        return memo + sum;
+      }, 0);
+
+      // finally, calc the multiple
+      org.multiple = org.cost > 0 ? (org.unrealized + org.realized) / org.cost : 0;
+
+      return org;
+
+    };
+
+    rounds = filterVehicles(rounds, fundIds);
+
+    // we now have all the rounds the funds have participated in with other fund information removed from each round
+
+    // Group rounds by org, for two reasons:
+    // 1. We're ultimately returning a collection of orgs
+    // 2. Each orgs collection of rounds is used to calculate performance
+    var grouped = _.groupBy(rounds, function(r) { return r.organization._id; });
+
+    _.each(grouped, function(rounds) {
+
+      // construct the org
+      var org = {
+        _id: rounds[0].organization._id,
+        name: rounds[0].organization.name,
+        logoUrl: rounds[0].organization.logoUrl,
+        description: rounds[0].organization.description,
+        status: rounds[0].organization.status,
+        preMoneyValuation: rounds[0].preMoneyValuation
+      };
+
+      org = calculateOrgPerformance(org, rounds);
+
+      portfolio.push(org);
+
+    });
+
+    // sort by org name, ascending
+    portfolio = _.sortBy(portfolio, function(p) { return p.name.toLowerCase(); });
+
+    return portfolio;
+
+  };
+
+  var checkForUnpopulatedData = function checkForUnpopulatedData(rounds, fnName, cb) {
+
+    // If one of these things isn't populated, that means we have bad data
+    // Fuck shit up so it gets taken care of
+
+    var vehicles = _.compact(_.flatten(_.pluck(rounds, 'vehicles')));
+    var people = _.compact(_.flatten(_.pluck(rounds, 'people')));
+    var badData = null;
+
+    badData = _.find(rounds, function(item) { return !item.organization; });
+    if (badData) return new Error(fnName + ' has one or more orgs that is not populated which means there is bad data');
+
+    badData = _.find(people, function(p) { return !p.person; });
+    if (badData) return new Error(fnName + ' has one or more people that is not populated which means there is bad data');
+
+    badData = _.find(vehicles, function(item) { return !item.fund; });
+    if (badData) return new Error(fnName + ' has one or more funds that is not populated which means there is bad data');
+
+    badData = _.find(vehicles, function(item) { return _.find(item.investments, function(i) { return !i; } ); });
+    if (badData) return new Error(fnName + ' has one or more investments that is not populated which means there is bad data');
+
+    return null;
+
+  };
+
+  var filterVehicles = function filterVehicles(rounds, fundIds) {
+
+    // Given a collection of rounds, each with a collection of vehicles,
+    // remove all vehicles that aren't for the given fund ids
+
+    fundIds = _.map(fundIds, function(id) { return id.toString(); });
+
+    _.each(rounds, function(r) {
+      r.vehicles = _.filter(r.vehicles, function(v) {
+        var fundid = utils.isValidObjectId(v.fund) ? v.fund : v.fund._id;
+        return fundIds.indexOf(fundid.toString()) >= 0;
+      });
+    });
+
+    return rounds;
+
+  };
+
+
+
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // VIRTUALS
+  // Properties that are not persisted to the database
+  ///////////////////////////////////////////////////////////////////////////////////////
+
+  Round.virtual('cost').get(function () {
+    // sums the cost of all vehicles in the round
+    var self = this;
+    return _.reduce(self.vehicles, function(memo, vehicle) { return memo + vehicle.cost; }, 0);
+  });
+
+  Round.virtual('month').get(function () {
+    var self = this;
+    var monthNames = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
+    if (!self.closingDate) return 'Unknown';
+    else return monthNames[self.closingDate.getMonth()];
+  });
+
+  Round.virtual('value').get(function () {
+    // sums the value (fair or realized) of all vehicles in the round
+    var self = this;
+    return _.reduce(self.vehicles, function(memo, vehicle) {
+      if (self.roundName == 'Proceeds') return memo + vehicle.realized; // proceeds are realized and do not have a fair value
+      else return memo + vehicle.fairValue;
+    }, 0);
+  });
+
+  Round.virtual('year').get(function () {
+    var self = this;
+    if (!self.closingDate) return 'Unknown';
+    else return self.closingDate.getFullYear();
+  });
+
+
+
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // METHODS
+  //
+  // Methods operate on a single document that has already been returned
+  //
+  // Note that running a method on a document does not save it
+  //
+  // I considered making these statics which would be good for one off additions, from
+  // admin for example, but the predominant use case is adding via sheet pulls which
+  // will add a bunch of things and then just get saved once.
+  ///////////////////////////////////////////////////////////////////////////////////////
+
+  Round.methods.addInvestment = function addInvestment(investment, fund, data) {
+
+    // Add an investment reference
+    // Investment data is private
+    // The vehicle off which the investment hangs will be created if it doesn't already exist
+    // Note data will overwrite values for an existing vehicle.
+
+    var self = this;
+
+    if (!investment) throw new Error('Must supply investment to add');
+    if (!fund) throw new Error('Must supply fund to add');
+
+    // Do our best to accept an object or an objectid
+    if (!utils.isValidObjectId(investment)) {
+      investment = investment._id;
+      if (!utils.isValidObjectId(investment)) throw new Error('Need a valid investment objectid!');
+    }
+
+    // Do our best to accept an object or an objectid
+    if (!utils.isValidObjectId(fund)) {
+      fund = fund._id;
+      if (!utils.isValidObjectId(fund)) throw new Error('Need a valid fund objectid!');
+    }
+
+    // Create or update
+    var vehicle = self.addVehicle(fund, data);
+    var fid = utils.isValidObjectId(vehicle.fund) ? vehicle.fund : vehicle.fund._id;
+
+    // The vehicle returned by addVehicle, appears to be a copy not a reference which is odd to me.
+    // We need a reference to add the investment, so go get it.
+    vehicle = _.find(self.vehicles, function(v) {
+      var fundid = utils.isValidObjectId(v.fund) ? v.fund : v.fund._id;
+      return fundid.toString() == fid.toString();
+    });
+
+    // bail if not found
+    if (!vehicle) throw new Error('Vehicle does not exist and unable to create it');
+
+    // Check if investment is already added
+    var match = _.find(vehicle.investments, function(i) {
+      var id = utils.isValidObjectId(i) ? i : i._id;
+      return id.toString() == investment.toString();
+    });
+
+    // If not, add it
+    if (!match) vehicle.investments.push(investment);
+    // note there is no need to compute vehicle cost as it is done during upsert
+
+  };
+
+  Round.methods.addPerson = function addPerson(person) {
+
+    // Add a reference to a person that participated in this round
+
+    var self = this;
+
+    if (!person) throw new Error('Must supply person to add');
+
+    // Do our best to accept an object or an objectid
+    if (!utils.isValidObjectId(person)) {
+      person = person._id;
+      if (!utils.isValidObjectId(person)) throw new Error('Need a valid objectid!');
+    }
+
+    // Check if person is already added
+    var match = _.find(self.people, function(existingPerson) {
+      var p = existingPerson.person || existingPerson;
+      var id = utils.isValidObjectId(p) ? p : p._id;
+      return id.toString() == person.toString();
+    });
+
+    // If not, add it
+    if (!match) self.people.push({
+      person: person
+    });
+
+  };
+
+  Round.methods.addVehicle = function addVehicle(fund, data) {
+
+    // Add a vehicle, which is a fund
+    // This data is public
+    // Private investment data will hang off it
+    // Note investment data is not added here
+    // Note data will overwrite values for an existing vehicle.
+
+    var self = this;
+
+    if (!fund) throw new Error('Must supply fund to add');
+
+    // Do our best to accept an object or an objectid
+    if (!utils.isValidObjectId(fund)) {
+      fund = fund._id;
+      if (!utils.isValidObjectId(fund)) throw new Error('Need a valid fund objectid!');
+    }
+
+    data = data || {};
+    data.fairValue = data.fairValue || 0;
+    data.realized = data.realized || 0;
+    data.valuationDate = data.valuationDate || null;
+
+    // Check if vehicle is already added
+    var vehicle = _.find(self.vehicles, function(v) {
+      var fundid = utils.isValidObjectId(v.fund) ? v.fund : v.fund._id;
+      return fundid.toString() == fund;
+    });
+
+    // update data on existing vehicle
+    if (vehicle) {
+      vehicle.fairValue = data.fairValue;
+      vehicle.realized = data.realized;
+      vehicle.valuationDate = data.valuationDate;
+    }
+    // create vehicle
+    else {
+      vehicle = {
+        fund: fund,
+        investments: [],
+        fairValue: data.fairValue,
+        realized: data.realized,
+        valuationDate: data.valuationDate
+      };
+      self.vehicles.push(vehicle);
+    }
+
+    return vehicle;
+
+  };
+
+
+
+  //////////////////////////////////////////////////////
+  // STATICS
+  // Statics operate on the entire collection
+  //////////////////////////////////////////////////////
+
+  Round.statics.getByFund = function getByFund(fundId, cb) {
+
+    var self = this;
+
+    self
+      .find({ 'vehicles.fund': fundId })
+      .exec(cb);
+
+  };
+
+  Round.statics.getByOrg = function getByOrg(orgId, cb) {
+
+    // Gets all the rounds an org has raised
+
+    var self = this;
+
+    self
+      .find({
+        'deleted': { $ne: true },
+        'organization': orgId
+      })
+      .populate('organization', 'name logoUrl')
+      .populate('people.person', 'name avatarUrl title')
+      .populate('vehicles.fund', 'name shortName')
+      .populate({
+        path: 'vehicles.investments',
+        match: { customer: config.CUSTOMER_ID }
+      })
+      .exec(function(err, rounds) {
+
+        if (err) return cb(err, null);
+        if (!rounds || rounds.length == 0) return cb(null, []);
+
+        var error = checkForUnpopulatedData(rounds, 'Round.getByOrg');
+        if (error) return cb(error, null);
+
+        // reverse chronological
+        rounds = _.sortBy(rounds, function(r) {
+
+          var date = r.closingDate;
+
+          // use investment date in absence of closing date
+          if (!date && r.vehicles.length && r.vehicles[0].investments.length) {
+            date = r.vehicles[0].investments[0].investmentDate;
+          }
+
+          return date;
+
+        }).reverse();
+
+        return cb(null, rounds);
+
+      });
+
+  };
+
+  Round.statics.getByOrgs = function getByOrg(orgIds, cb) {
+
+    var self = this;
+
+    self
+      .find({
+        'deleted': { $ne: true },
+        'organization': { $in: orgIds }
+      })
+      .populate('organization', 'name logoUrl')
+      .populate('people.person', 'name avatarUrl')
+      .populate('vehicles.fund')
+      .exec(function(err, rounds) {
+
+        if (err) return cb(err, null);
+        if (!rounds || rounds.length == 0) return cb(null, []);
+
+        var error = checkForUnpopulatedData(rounds, 'Round.getByOrgs');
+        if (error) return cb(error, null);
+
+        // reverse chronological
+        rounds = _.sortBy(rounds, function(r) {
+
+          var date = r.closingDate;
+
+          // use investment date in absence of closing date
+          if (!date && r.vehicles.length && r.vehicles[0].investments.length) {
+            date = r.vehicles[0].investments[0].investmentDate;
+          }
+
+          return date;
+
+        }).reverse();
+
+        return cb(null, rounds);
+
+      });
+
+  };
+
+  Round.statics.getFundPerformance = function getFundPerformance(fundId, cb) {
+
+    var self = this;
+
+    self
+      .find({ 'vehicles.fund': fundId })
+      .exec(function(err, rounds) {
+
+        if (err) return cb(err, null);
+        if (!rounds || rounds.length == 0) return cb(null, null);
+
+        rounds = filterVehicles(rounds, [fundId]);
+
+        // we now have all the rounds the fund has participated in with other fund information removed from each round
+
+        var totalFundCost = _.reduce(rounds, function(memo, round) {
+          var roundCost = _.reduce(round.vehicles, function(memo, vehicle) { return memo + vehicle.cost; }, 0);
+          return memo + roundCost;
+        }, 0);
+
+        var totalUnrealized = _.reduce(rounds, function(memo, round) {
+          var roundValue = _.reduce(round.vehicles, function(memo, vehicle) { return memo + vehicle.fairValue; }, 0);
+          return memo + roundValue;
+        }, 0);
+
+        var totalRealized = _.reduce(rounds, function(memo, round) {
+          var roundValue = _.reduce(round.vehicles, function(memo, vehicle) { return memo + vehicle.realized; }, 0);
+          return memo + roundValue;
+        }, 0);
+
+        return cb(null, {
+          cost: totalFundCost,
+          unrealized: totalUnrealized,
+          realized: totalRealized,
+          value: totalUnrealized + totalRealized,
+          multiple: totalFundCost > 0 ? (totalUnrealized + totalRealized) / totalFundCost : 0
+        });
+
+      });
+
+  };
+
+  Round.statics.getPortfolioByFund = function getPortfolioByFund(fundId, cb) {
+
+    var self = this;
+
+    self
+      .find({ 'vehicles.fund': fundId })
+      .select('organization vehicles preMoneyValuation')
+      .populate('organization', 'name logoUrl description')
+      .populate('vehicles.fund')
+      .populate('vehicles.investments')
+      .exec(function(err, rounds) {
+
+        if (err) return cb(err, null);
+        if (!rounds || rounds.length == 0) return cb(null, []);
+
+        var error = checkForUnpopulatedData(rounds, 'Round.getPortfolioByFund');
+        if (error) return cb(error, null);
+
+        return cb(null, buildPortfolio(rounds, [fundId]));
+
+      });
+
+  };
+
+  Round.statics.getPortfolioByFunds = function getPortfolioByFunds(fundIds, cb) {
+
+    // Returns a list of orgs that have rounds participated in by the given fund ids
+    // Note retrieving multiple funds does not calculate fund stats. Use getPortfolioByFund for that.
+
+    var self = this;
+
+    self
+      .find({ 'vehicles.fund': { $in: fundIds } })
+      .select('organization vehicles preMoneyValuation')
+      .populate('organization', 'name logoUrl description')
+      .populate('vehicles.fund')
+      .populate('vehicles.investments')
+      .exec(function(err, rounds) {
+
+        if (err) return cb(err, null);
+        if (!rounds || rounds.length == 0) return cb(null, []);
+
+        var error = checkForUnpopulatedData(rounds, 'Round.getPortfolioByFunds');
+        if (error) return cb(error, null);
+
+        return cb(null, buildPortfolio(rounds, fundIds));
+
+      });
+
+  };
+
+  Round.statics.getPortfolioByPerson = function getPortfolioByPerson(personId, cb) {
+
+    // Returns a list of orgs that have rounds participated in by the given person id
+
+    var self = this;
+
+    self
+      .find({ 'people.person': personId })
+      .select('organization')
+      .populate('organization', 'name logoUrl description')
+      .exec(function(err, rounds) {
+
+        if (err) return cb(err, null);
+        if (!rounds || rounds.length == 0) return cb(null, []);
+
+        var error = checkForUnpopulatedData(rounds, 'Round.getPortfolioByPerson');
+        if (error) return cb(error, null);
+
+        // Return a list of orgs, not a list of rounds
+        var portfolio = _.pluck(rounds, 'organization');
+        portfolio = _.uniq(portfolio, function(org) { return org.name; });
+        portfolio = _.sortBy(portfolio, 'name');
+
+        return cb(null, portfolio);
+
+      });
+
+  };
+
+  Round.statics.removeInvestment = function(investmentId, cb) {
+
+    // Do not call this directly. It will leave an orphaned investment document.
+    // The preferred way to delete an investment is to delete it directly and this
+    // reference will be cleaned up by the investment post-remove hook.
+
+    // Note that hooks don't work on updates so that makes this more complicated because our pre-save hook to compute
+    // cost won't work on a straight update. The workaround is to pull a list of round ids that will have the investment
+    // removed, call update to remove the investments from rounds, retrieve the updated rounds and save them which will
+    // trigger the pre-save hook and update the cost.
+
+    var self = this;
+
+    var getRounds = function getRounds(callback) {
+      var query = self.find({ 'vehicles.investments': investmentId });
+      query.select('_id');
+      query.exec(callback);
+    };
+
+    var updateRounds = function updateRounds(previous, callback) {
+      var query = self.update(
+        { 'vehicles.investments': investmentId },
+        { $pull : { 'vehicles.$.investments': investmentId } },
+        { multi : true }
+      );
+      query.exec(callback);
+    };
+
+    var updateCost = function updateCost(previous, callback) {
+
+      var ids = _.pluck(previous, '_id');
+      var query = self.find({_id: { $in: ids }});
+
+      query.exec(function (err, docs) {
+        async.map(docs, function (doc, saveCallback) {
+          doc.save(function (err) {
+            saveCallback(err, doc);
+          });
+        }, callback);
+      });
+
+    };
+
+    async.waterfall([
+      getRounds,
+      updateRounds,
+      updateCost
+    ], cb);
+
+  };
+
+  Round.statics.removePerson = function(roundId, personId, cb) {
+
+    var self = this;
+
+    self
+      .findOneAndUpdate(
+        { '_id': roundId },
+        { $pull : { 'people': { 'person': personId } } },
+        { multi : false }
+      )
+      .exec(cb);
+
+  };
+
+  Round.statics.removeVehicle = function(roundId, fundId, cb) {
+
+    var self = this;
+
+    self
+      .findOneAndUpdate(
+        { '_id': roundId },
+        { $pull : { 'vehicles': { 'fund': fundId } } },
+        { multi : false }
+      )
+      .exec(cb);
+
+  };
+
+  Round.statics.upsert = function(round, cb) {
+
+    if (!round) { return cb(new Error('round is required'), null); }
+
+    var compute = function compute(doc) {
+
+      // compute for each vehicle
+
+      _.each(doc.vehicles, function(vehicle) {
+
+        var investments = vehicle.investments;
+
+        if (investments.length >= 1) {
+          // sum cost of each investment
+          vehicle.cost = _.reduce(investments, function(memo, investment){ return memo + investment.cost; }, 0);
+        }
+        else {
+          // no investments = no cost
+          vehicle.cost = 0;
+        }
+
+        // proceeds are special in that the cost is actually a realized gain
+        if (doc.roundName == 'Proceeds') {
+          vehicle.realized = vehicle.cost;
+          vehicle.cost = 0;
+          vehicle.unrealized = 0;
+          vehicle.fairValue = 0;
+        }
+
+        // escrow is also special, except the gains are unrealized
+        else if (doc.roundName == 'Escrow') {
+          vehicle.unrealized = vehicle.fairValue - vehicle.cost;
+          vehicle.realized = 0;
+        }
+
+      });
+
+    };
+
+    round.save(function(err, result) {
+
+      if (err) return cb(err, null);
+
+      result.populate({
+        path: 'vehicles.investments',
+        select: 'cost'
+      }, function(err, doc) {
+
+        if (err) return cb(err, null);
+        else if (!doc) return cb(null, null);
+
+        compute(doc);
+
+        round.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
+  // Post-remove: fired on every document after it's deleted
+  ///////////////////////////////////////////////////////////////////////////////////////
+
+  Round.post('init', function(doc, next) {
+
+    var CUSTOMER_ID = config.CUSTOMER_ID;
+
+    if (CUSTOMER_ID == 'GLOBAL_PROCESS') return next();
+
+    // note participating people are public as there is no investment, i.e., private, data attached to them
+
+    // 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 vehicles are public
+    // merge private data that was matched for customer
+    _.each(doc.vehicles, function(vehicle) {
+
+      if (!vehicle.investments || vehicle.investments.length == 0) return;
+
+      // there can be multiple investments in a single round from the same fund
+      // use the most recent
+      var mostRecentInvestment = _.max(vehicle.investments, function(investment) { return investment.investmentDate; });
+
+      // if we have private data, use it rather than the public data
+      if (mostRecentInvestment) {
+        if (mostRecentInvestment.preMoneyValuation) doc.preMoneyValuation = mostRecentInvestment.preMoneyValuation;
+        if (mostRecentInvestment.dollarsRaised) doc.dollarsRaised = mostRecentInvestment.dollarsRaised;
+        if (mostRecentInvestment.closingDate) doc.closingDate = mostRecentInvestment.closingDate;
+      }
+
+    });
+
+    return next();
+
+  });
+
+
+
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // CONFIG
+  ///////////////////////////////////////////////////////////////////////////////////////
+
+  Round.set('toJSON', { virtuals: true });
+  Round.set('autoIndex', true);
+
+  Round.index({ organization: 1,  roundName: 1 }, { unique: true, sparse: true });
+  Round.on('index', function(err) { console.log('error building Round indexes: ' + err); });
+
+  mongoose.model('Round', Round);
+
+};
+
+