@dhyasama/totem-models 8.47.1 → 8.49.0

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

@@ -54,14 +54,9 @@ module.exports = function(mongoose, config) {
       // These references are removed by the Investment post-remove hook calling Round.removeInvestment
       investments: [{ type: Schema.ObjectId, ref: 'Investment', required: false }],
 
-      // computed from investments
-      investment: { type: Number, default: 0 },
-      unrealized: { type: Number, default: 0 },
-      realized: { type: Number, default: 0 },
-
       _id: false
 
-    }]
+    }],
 
   });
 
@@ -69,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 calculatePerformance = function calculatePerformance(rounds) {
 
-    var calculateOrgPerformance = function calculateOrgPerformance(org, rounds) {
+    var totalInvestment = 0;
+    var totalUnrealized = 0;
+    var totalRealized = 0;
 
-      // 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);
+    _.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);
 
@@ -146,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);
 
@@ -202,19 +200,6 @@ module.exports = function(mongoose, config) {
 
   };
 
-  ///////////////////////////////////////////////////////////////////////////////////////
-  // VIRTUALS
-  // Properties that are not persisted to the database
-  ///////////////////////////////////////////////////////////////////////////////////////
-
-  Round.virtual('value').get(function () {
-    // sums the value (realized and unrealized) of all vehicles in the round
-    var self = this;
-    return _.reduce(self.vehicles, function(memo, vehicle) {
-      return memo + vehicle.unrealized + vehicle.realized;
-    }, 0);
-  });
-
   ///////////////////////////////////////////////////////////////////////////////////////
   // METHODS
   //
@@ -227,7 +212,7 @@ module.exports = function(mongoose, config) {
   // will add a bunch of things and then just get saved once.
   ///////////////////////////////////////////////////////////////////////////////////////
 
-  Round.methods.addInvestment = function addInvestment(investment, fund, data) {
+  Round.methods.addInvestment = function addInvestment(investment, fund) {
 
     // Add an investment reference
     // Investment data is private
@@ -252,7 +237,7 @@ module.exports = function(mongoose, config) {
     }
 
     // Create or update
-    var vehicle = self.addVehicle(fund, data);
+    var vehicle = self.addVehicle(fund);
     var fid = mongoose.Types.ObjectId.isValid(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.
@@ -304,7 +289,7 @@ module.exports = function(mongoose, config) {
 
   };
 
-  Round.methods.addVehicle = function addVehicle(fund, data) {
+  Round.methods.addVehicle = function addVehicle(fund) {
 
     // Add a vehicle, which is a fund
     // This data is public
@@ -322,10 +307,6 @@ module.exports = function(mongoose, config) {
       if (!mongoose.Types.ObjectId.isValid(fund)) throw new Error('Need a valid fund objectid!');
     }
 
-    data = data || {};
-    data.unrealized = data.unrealized || 0;
-    data.realized = data.realized || 0;
-
     // Check if vehicle is already added
     let vehicle = _.find(self.vehicles, function(v) {
       let fundid = mongoose.Types.ObjectId.isValid(v.fund) ? v.fund : v.fund._id;
@@ -333,17 +314,10 @@ module.exports = function(mongoose, config) {
     });
 
     // update data on existing vehicle
-    if (vehicle) {
-      vehicle.unrealized = data.unrealized;
-      vehicle.realized = data.realized;
-    }
-    // create vehicle
-    else {
+    if (!vehicle) {
       vehicle = {
         fund: fund,
-        investments: [],
-        unrealized: data.unrealized,
-        realized: data.realized
+        investments: []
       };
       self.vehicles.push(vehicle);
     }
@@ -537,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'); }
@@ -547,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 + roundCost;
-      }, 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));
 
     });
 
@@ -739,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); }
@@ -765,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);
 
   };
@@ -819,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);
 
   };
 
@@ -872,15 +777,6 @@ module.exports = function(mongoose, config) {
 
     if (!doc || !doc.vehicles) { return next(); }
 
-    // note participating people are public as there is no investment, i.e., private, data attached to them
-
-    // participating vehicles are public
-    // merge private data that was matched for customer
-
-    doc.vehicles = _.filter(doc.vehicles, function(vehicle) {
-      return vehicle.investments.length > 0;
-    });
-
     next();
 
   });

package/package.json

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