@dhyasama/totem-models 8.48.0 → 8.50.0

package/lib/Fund.js

@@ -104,48 +104,6 @@ module.exports = function(mongoose, config) {
       .exec(cb);
   };
 
-  Fund.statics.getPerformance = function getPerformance(id, cb) {
-
-    var getLatestVehicle = function(rounds) {
-
-      var latestVehicles = [];
-
-      _.each(rounds, function (r) {
-        latestVehicles.push(_.max(r.vehicles, function (v) {
-          return v.valuationDate;
-        }));
-      });
-
-      latestVehicles = _.compact(latestVehicles);
-
-      return _.max(latestVehicles, function (v) { return v.valuationDate; });
-
-    };
-
-    Round.getByFund(id, function(err, rounds) {
-
-      if (err) return cb(err, null);
-      if (!rounds || rounds.length == 0) return cb(null, []);
-
-      // filter vehicles down to this fund
-      _.each(rounds, function (r) {
-        r.vehicles = _.filter(r.vehicles, function (v) {
-          return v.fund._id.toString() == id.toString();
-        });
-      });
-
-      var latestVehicle = getLatestVehicle(rounds);
-
-      return cb(null, {
-        cost: latestVehicle.cost,
-        fairValue: latestVehicle.fairValue,
-        multiple: latestVehicle.multiple
-      });
-
-    });
-
-  };
-
   Fund.statics.list = function list(cb) {
     this
       .find()
@@ -196,4 +154,4 @@ module.exports = function(mongoose, config) {
 
   mongoose.model('Fund', Fund);
 
-};
+};

package/lib/Investment.js

@@ -88,9 +88,8 @@ module.exports = function(mongoose, config) {
 
     if (!investment) { return cb(new Error('investment is required'), null); }
     investment.save(cb);
-  };
-
 
+  };
 
   ///////////////////////////////////////////////////////////////////////////////////////
   // HOOKS
@@ -103,8 +102,6 @@ module.exports = function(mongoose, config) {
 
     var self = this;
 
-    if (self.debtType) self.debt = true;
-
     return next();
 
   });
@@ -116,8 +113,6 @@ module.exports = function(mongoose, config) {
     });
   });
 
-
-
   ///////////////////////////////////////////////////////////////////////////////////////
   // CONFIG
   ///////////////////////////////////////////////////////////////////////////////////////

package/lib/Round.js

@@ -64,38 +64,37 @@ module.exports = function(mongoose, config) {
   // 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 investment of each vehicle
-      org.investment = _.reduce(rounds, function(memo, round) {
-        var sum = _.reduce(round.vehicles, function(memo, vehicle) { return memo + vehicle.investment; }, 0);
-        return memo + sum;
-      }, 0);
+  var calculatePerformance = function calculatePerformance(rounds) {
+
+    var totalInvestment = 0;
+    var totalUnrealized = 0;
+    var totalRealized = 0;
+
+    _.each(rounds, function(round) {
+      _.each(round.vehicles, function(vehicle) {
+        _.each(vehicle.investments, function(investment) {
+          totalInvestment += investment.investment || 0;
+          totalUnrealized += investment.unrealized || 0;
+          totalRealized += investment.realized || 0;
+        });
+      });
+    });
 
-      // sum the unrealized of each vehicle
-      org.unrealized = _.reduce(rounds, function(memo, round) {
-        var sum = _.reduce(round.vehicles, function(memo, vehicle) { return memo + vehicle.unrealized; }, 0);
-        return memo + sum;
-      }, 0);
+    // finally, calc the multiple
+    return {
+      investment: totalInvestment,
+      unrealized: totalUnrealized,
+      realized: totalRealized,
+      multiple: totalInvestment > 0 ? (totalUnrealized + totalRealized) / totalInvestment : 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.investment > 0 ? (org.unrealized + org.realized) / org.investment : 0;
+  var buildPortfolio = function buildPortfolio(rounds, fundIds) {
 
-      return org;
+    // Given a collection of rounds and funds, construct a portfolio of organizations
 
-    };
+    var portfolio = [];
 
     rounds = filterVehicles(rounds, fundIds);
 
@@ -141,7 +140,11 @@ module.exports = function(mongoose, config) {
         funds: funds
       };
 
-      org = calculateOrgPerformance(org, rounds);
+      var performance = calculatePerformance(rounds);
+      org.investment = performance.investment;
+      org.unrealized = performance.unrealized;
+      org.realized = performance.realized;
+      org.multiple = performance.multiple;
 
       portfolio.push(org);
 
@@ -508,7 +511,7 @@ module.exports = function(mongoose, config) {
 
   };
 
-  Round.statics.getFundPerformance = function getFundPerformance(fundId, cb) {
+  Round.statics.getFundPerformance = function getFundPerformance(fundId, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!fundId) { throw new Error('fundId is required'); }
@@ -518,38 +521,28 @@ module.exports = function(mongoose, config) {
 
     let query = self.find({ 'vehicles.fund': fundId });
 
+    query.select('organization vehicles');
+    query.populate('organization', 'name slug logoUrl description ');
+    query.populate('vehicles.fund');
+
+    if (options.isWorkerProcess) {
+      query.populate('vehicles.investments');
+    }
+    else {
+      query.populate({
+        path: 'vehicles.investments',
+        match: { customer: options.CUSTOMER_ID }
+      });
+    }
+
     query.exec(function(err, rounds) {
 
       if (err) return cb(err, null);
       else if (!rounds) return cb(null, null);
-      else if(rounds.length === 0) return cb(null, []);
+      else if (rounds.length === 0) return cb(null, []);
 
       rounds = filterVehicles(rounds, [fundId]);
-
-      // we now have all the rounds the fund has participated in with other fund information removed from each round
-
-      let totalInvestment = _.reduce(rounds, function(memo, round) {
-        let roundInvestment = _.reduce(round.vehicles, function(memo, vehicle) { return memo + vehicle.investment; }, 0);
-        return memo + roundInvestment;
-      }, 0);
-
-      let totalUnrealized = _.reduce(rounds, function(memo, round) {
-        let roundUnrealized = _.reduce(round.vehicles, function(memo, vehicle) { return memo + vehicle.unrealized; }, 0);
-        return memo + roundUnrealized;
-      }, 0);
-
-      let totalRealized = _.reduce(rounds, function(memo, round) {
-        let roundRealized = _.reduce(round.vehicles, function(memo, vehicle) { return memo + vehicle.realized; }, 0);
-        return memo + roundRealized;
-      }, 0);
-
-      return cb(null, {
-        investment: totalInvestment,
-        unrealized: totalUnrealized,
-        realized: totalRealized,
-        value: totalUnrealized + totalRealized,
-        multiple: totalInvestment > 0 ? (totalUnrealized + totalRealized) / totalInvestment : 0
-      });
+      return cb(null, calculatePerformance(rounds));
 
     });
 
@@ -710,11 +703,6 @@ module.exports = function(mongoose, config) {
     // 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.
-
     if (!cb) { throw new Error('cb is required'); }
     if (!investmentId) { throw new Error('investmentId is required'); }
     if (!mongoose.Types.ObjectId.isValid(investmentId)) { return cb(new Error('investmentId is not a valid ObjectId'), null); }
@@ -736,25 +724,9 @@ module.exports = function(mongoose, config) {
       query.exec(callback);
     };
 
-    let updateCost = function updateCost(previous, callback) {
-
-      let ids = _.pluck(previous, '_id');
-      let 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
+      updateRounds
     ], cb);
 
   };
@@ -790,45 +762,7 @@ module.exports = function(mongoose, config) {
   Round.statics.upsert = function(round, cb) {
 
     if (!round) { return cb(new Error('round is required'), null); }
-
-    const compute = function compute(doc) {
-
-      // compute for each vehicle
-
-      _.each(doc.vehicles, function(vehicle) {
-
-        var investments = vehicle.investments;
-
-        if (investments.length >= 1) {
-          vehicle.investment = _.reduce(investments, function(memo, investment) { return memo + investment.investment; }, 0);
-        }
-        else {
-          vehicle.investment = 0;
-        }
-
-      });
-
-    };
-
-    round.save(function(err, result) {
-
-      if (err) return cb(err, null);
-
-      result.populate({
-        path: 'vehicles.investments',
-        select: 'investment'
-      }, function(err, doc) {
-
-        if (err) return cb(err, null);
-        else if (!doc) return cb(null, null);
-
-        compute(doc);
-
-        round.save(cb);
-
-      });
-
-    });
+    round.save(cb);
 
   };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dhyasama/totem-models",
-  "version": "8.48.0",
+  "version": "8.50.0",
   "author": "Jason Reynolds",
   "license": "UNLICENSED",
   "description": "Models for Totem platform",