@dhyasama/totem-models 8.46.0 → 8.47.0

package/lib/Investment.js

@@ -25,40 +25,14 @@ module.exports = function(mongoose, config) {
     // Used by Round to selectively populate
     customer: { type: Schema.ObjectId, ref: 'Organization', required: true, index: true },
 
-    investmentDate: { type: Date, required: true },
-    cost: { type: Number, default: 0 },
-    costPlusInterest: { type: Number, default: 0 },
-    pricePerShare: { type: Number, default: 0 },
-
-    debt: { type: Boolean, default: false },
-    debtType: {
-      type: String,
-      enum: [ 'Convertible Note', 'Convertible Promissory Note', 'Demand Note', 'Demand Promissory Note', 'SAFE', 'SAFT', 'SAFTE', 'KISS', null ],
-      default: null,
-      required: false,
-      validate: {
-        validator: function(v) {
-          var self = this;
-          if (v && v.length && self.debt == false) return false;
-          else return true;
-        },
-        message: 'There is a debt type ({VALUE}) but debt is set to false! Either set debt to true or remove the debt type.'
-      }
-    },
-
-    converted: { type: Boolean, default: false },
-    convertedInto: {
-      type: String,
-      trim: true,
-      validate: {
-        validator: function(v) {
-          var self = this;
-          if (self.converted && (!v || v.length == 0)) return false;
-          else return true;
-        },
-        message: 'The investments is marked as converted but a converted into value was not provided! Either set converted to false or provide a value for converted into.'
-      }
-    },
+    date: { type: Date, required: true },
+    investment: { type: Number, default: 0 },
+    unrealized: { type: Number, default: 0 },
+    realized: { type: Number, default: 0 },
+    raised: { type: Number, required: false },
+    premoney: { type: Number, required: false },
+    postmoney: { type: Number, required: false },
+    pricePerShare: { type: Number, required: false },
 
     // Catch-all for customer specific key-value pairs from sheet that aren't supported by our schema
     details: [{
@@ -66,38 +40,15 @@ module.exports = function(mongoose, config) {
       value: { type: Schema.Types.Mixed, required: true },
       format: { type: String, enum: [null, 'number', 'decimal', 'money', 'percentage', 'date']},
       _id: false
-    }],
-
-    // 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 },
-    postMoneyValuation: { type: Number, default: 0 },
-    dollarsRaised: { type: Number, default: 0 },
-    closingDate: { type: Date, default: null }
+    }]
 
   });
 
-
-
   ///////////////////////////////////////////////////////////////////////////////////////
   // VIRTUALS
   // Properties that are not persisted to the database
   ///////////////////////////////////////////////////////////////////////////////////////
 
-  Investment.virtual('month').get(function () {
-    var self = this;
-    var monthNames = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
-    if (!self.investmentDate) return 'Unknown';
-    else return monthNames[self.investmentDate.getMonth()];
-  });
-
-  Investment.virtual('year').get(function () {
-    var self = this;
-    if (!self.investmentDate) return 'Unknown';
-    else return self.investmentDate.getFullYear();
-  });
-
-
 
   //////////////////////////////////////////////////////
   // STATICS
@@ -179,6 +130,4 @@ module.exports = function(mongoose, config) {
 
   mongoose.model('Investment', Investment);
 
-};
-
-
+};

package/lib/Round.js

@@ -29,16 +29,6 @@ module.exports = function(mongoose, config) {
 
     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 },
-    postMoneyValuation: { 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
@@ -65,11 +55,7 @@ module.exports = function(mongoose, config) {
       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 },
+      investment: { type: Number, default: 0 },
       unrealized: { type: Number, default: 0 },
       realized: { type: Number, default: 0 },
 
@@ -79,8 +65,6 @@ module.exports = function(mongoose, config) {
 
   });
 
-
-
   ///////////////////////////////////////////////////////////////////////////////////////
   // HELPERS
   ///////////////////////////////////////////////////////////////////////////////////////
@@ -93,15 +77,15 @@ module.exports = function(mongoose, config) {
 
     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);
+      // 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);
 
-      // sum the fair value of each vehicle, i.e., the unrealized value
+      // sum the unrealized of each vehicle
       org.unrealized = _.reduce(rounds, function(memo, round) {
-        var sum = _.reduce(round.vehicles, function(memo, vehicle) { return memo + vehicle.fairValue; }, 0);
+        var sum = _.reduce(round.vehicles, function(memo, vehicle) { return memo + vehicle.unrealized; }, 0);
         return memo + sum;
       }, 0);
 
@@ -112,7 +96,7 @@ module.exports = function(mongoose, config) {
       }, 0);
 
       // finally, calc the multiple
-      org.multiple = org.cost > 0 ? (org.unrealized + org.realized) / org.cost : 0;
+      org.multiple = org.investment > 0 ? (org.unrealized + org.realized) / org.investment : 0;
 
       return org;
 
@@ -158,8 +142,6 @@ module.exports = function(mongoose, config) {
         contact: rounds[0].organization.contact,
         filters: rounds[0].organization.filters,
         status: rounds[0].organization.status,
-        preMoneyValuation: rounds[0].preMoneyValuation,
-        postMoneyValuation: rounds[0].postMoneyValuation,
         chairs: rounds[0].organization.chairs,
         funds: funds
       };
@@ -220,43 +202,19 @@ module.exports = function(mongoose, config) {
 
   };
 
-
-
   ///////////////////////////////////////////////////////////////////////////////////////
   // 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
+    // sums the value (realized and unrealized) 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;
+      return memo + vehicle.unrealized + vehicle.realized;
     }, 0);
   });
 
-  Round.virtual('year').get(function () {
-    var self = this;
-    if (!self.closingDate) return 'Unknown';
-    else return self.closingDate.getFullYear();
-  });
-
-
-
   ///////////////////////////////////////////////////////////////////////////////////////
   // METHODS
   //
@@ -315,7 +273,6 @@ module.exports = function(mongoose, config) {
 
     // 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
 
   };
 
@@ -366,9 +323,8 @@ module.exports = function(mongoose, config) {
     }
 
     data = data || {};
-    data.fairValue = data.fairValue || 0;
+    data.unrealized = data.unrealized || 0;
     data.realized = data.realized || 0;
-    data.valuationDate = data.valuationDate || null;
 
     // Check if vehicle is already added
     let vehicle = _.find(self.vehicles, function(v) {
@@ -378,18 +334,16 @@ module.exports = function(mongoose, config) {
 
     // update data on existing vehicle
     if (vehicle) {
-      vehicle.fairValue = data.fairValue;
+      vehicle.unrealized = data.unrealized;
       vehicle.realized = data.realized;
-      vehicle.valuationDate = data.valuationDate;
     }
     // create vehicle
     else {
       vehicle = {
         fund: fund,
         investments: [],
-        fairValue: data.fairValue,
-        realized: data.realized,
-        valuationDate: data.valuationDate
+        unrealized: data.unrealized,
+        realized: data.realized
       };
       self.vehicles.push(vehicle);
     }
@@ -398,8 +352,6 @@ module.exports = function(mongoose, config) {
 
   };
 
-
-
   //////////////////////////////////////////////////////
   // STATICS
   // Statics operate on the entire collection
@@ -453,11 +405,9 @@ module.exports = function(mongoose, config) {
       // reverse chronological
       rounds = _.sortBy(rounds, function(r) {
 
-        let 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;
+          date = r.vehicles[0].investments[0].date;
         }
 
         return date;
@@ -515,11 +465,9 @@ module.exports = function(mongoose, config) {
       // reverse chronological
       rounds = _.sortBy(rounds, function(r) {
 
-        let 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;
+          date = r.vehicles[0].investments[0].date;
         }
 
         return date;
@@ -607,27 +555,27 @@ module.exports = function(mongoose, config) {
 
       // we now have all the rounds the fund has participated in with other fund information removed from each round
 
-      let totalFundCost = _.reduce(rounds, function(memo, round) {
-        let roundCost = _.reduce(round.vehicles, function(memo, vehicle) { return memo + vehicle.cost; }, 0);
+      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 roundValue = _.reduce(round.vehicles, function(memo, vehicle) { return memo + vehicle.fairValue; }, 0);
-        return memo + roundValue;
+        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 roundValue = _.reduce(round.vehicles, function(memo, vehicle) { return memo + vehicle.realized; }, 0);
-        return memo + roundValue;
+        let roundRealized = _.reduce(round.vehicles, function(memo, vehicle) { return memo + vehicle.realized; }, 0);
+        return memo + roundRealized;
       }, 0);
 
       return cb(null, {
-        cost: totalFundCost,
+        investment: totalInvestment,
         unrealized: totalUnrealized,
         realized: totalRealized,
         value: totalUnrealized + totalRealized,
-        multiple: totalFundCost > 0 ? (totalUnrealized + totalRealized) / totalFundCost : 0
+        multiple: totalInvestment > 0 ? (totalUnrealized + totalRealized) / totalInvestment : 0
       });
 
     });
@@ -652,7 +600,7 @@ module.exports = function(mongoose, config) {
 
     let query = self.find({ 'vehicles.fund': fundId });
 
-    query.select('organization vehicles preMoneyValuation postMoneyValuation');
+    query.select('organization vehicles');
     query.populate('organization', 'name slug logoUrl description contact filters status ipo closed acquired operating website websiteAliases');
     query.populate('vehicles.fund');
 
@@ -706,7 +654,7 @@ module.exports = function(mongoose, config) {
 
     let query = self.find({ 'vehicles.fund': { $in: fundIds } });
 
-    query.select('organization vehicles preMoneyValuation postMoneyValuation');
+    query.select('organization vehicles');
     query.populate('organization', 'name slug logoUrl description contact chairs filters status ipo closed acquired operating website websiteAliases');
     query.deepPopulate([
       'organization.chairs.first',
@@ -879,26 +827,10 @@ module.exports = function(mongoose, config) {
         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);
+          vehicle.investment = _.reduce(investments, function(memo, investment) { return memo + investment.investment; }, 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;
+          vehicle.investment = 0;
         }
 
       });
@@ -911,7 +843,7 @@ module.exports = function(mongoose, config) {
 
       result.populate({
         path: 'vehicles.investments',
-        select: 'cost'
+        select: 'investment'
       }, function(err, doc) {
 
         if (err) return cb(err, null);
@@ -940,13 +872,6 @@ module.exports = function(mongoose, config) {
 
     // 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
-    // postMoneyValuation
-    // 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
 
@@ -954,17 +879,6 @@ module.exports = function(mongoose, config) {
       return vehicle.investments.length > 0;
     });
 
-    let allInvestments = _.flatten(_.pluck(doc.vehicles, 'investments'));
-    let mostRecentInvestment = _.max(allInvestments, 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.postMoneyValuation) { doc.postMoneyValuation = mostRecentInvestment.postMoneyValuation; }
-      if (mostRecentInvestment.dollarsRaised) { doc.dollarsRaised = mostRecentInvestment.dollarsRaised; }
-      if (mostRecentInvestment.closingDate) { doc.closingDate = mostRecentInvestment.closingDate; }
-    }
-
     next();
 
   });
@@ -985,6 +899,4 @@ module.exports = function(mongoose, config) {
 
   mongoose.model('Round', Round);
 
-};
-
-
+};

package/package.json

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