@dhyasama/totem-models 1.0.1 → 1.6.1

package/index.js

@@ -17,12 +17,7 @@ var bootstrap = function(mongoose, config) {
   var configHas_CUSTOMER_ID = typeof config['CUSTOMER_ID'] != 'undefined';
   if (!configHas_CUSTOMER_ID) throw new Error('Config is missing CUSTOMER_ID setting');
 
-  require('./lib/Account.js')(mongoose, config);
-  require('./lib/Activity.js')(mongoose, config);
-  require('./lib/CalendarEvent.js')(mongoose, config);
-  require('./lib/Fund.js')(mongoose, config);
-  require('./lib/List.js')(mongoose, config);
-  require('./lib/News.js')(mongoose, config);
+  // todo - find a solution to load without worrying about order
 
   // note must be loaded before limited partner
   // note must be loaded before organization
@@ -30,11 +25,28 @@ var bootstrap = function(mongoose, config) {
   require('./lib/Note.js')(mongoose, config);
 
   // organization must be loaded before limited partner
+  // organization must be loaded before round
+  // organization must be loaded before cap table
   require('./lib/Organization.js')(mongoose, config);
 
+  // round must be loaded before investment
+  // round must be loaded before fund
+  require('./lib/Round.js')(mongoose, config);
+
+  // fund must be loaded before limited partner
+  require('./lib/Fund.js')(mongoose, config);
+
   // limited partner must be loaded before person
   require('./lib/LimitedPartner.js')(mongoose, config);
 
+  // none of these need to be loaded before anything
+  require('./lib/Account.js')(mongoose, config);
+  require('./lib/Activity.js')(mongoose, config);
+  require('./lib/CalendarEvent.js')(mongoose, config);
+  require('./lib/CapTable.js')(mongoose, config);
+  require('./lib/Investment.js')(mongoose, config);
+  require('./lib/List.js')(mongoose, config);
+  require('./lib/News.js')(mongoose, config);
   require('./lib/Person.js')(mongoose, config);
 
 };

package/lib/Account.js

@@ -16,36 +16,35 @@ module.exports = function(mongoose, config) {
     username: { type: String, required: true, unique: true },
     password: { type: String, default: '' },
     email: { type: String, required: true, unique: true },
-    avatar: { type: String, default: '/media/abstract-cubes.png' },
     reset: {
-      token: { type: String, default: '' },
+      token: { type: String },
       expiresOn: { type: Date }
     },
     setup: {
-      token: { type: String, default: '' },
+      token: { type: String },
       expiresOn: { type: Date },
-      complete: { type: Boolean, default: false },
+      complete: { type: Boolean},
       terms: {
         raw: { type: String },
         hash: { type: String }
       }
     },
     twoFactorAuth: {
-      enabled: { type: Boolean, default: true },
-      phone: { type: String, default: '' },
+      enabled: { type: Boolean },
+      phone: { type: String },
       country: {
-        callingCode: { type: String, default: '' },
-        abbreviation:  { type: String, default: '' }
+        callingCode: { type: String },
+        abbreviation:  { type: String }
       },
-      verified: { type: Boolean, default: false }
+      verified: { type: Boolean }
     },
-    admin: { type: Boolean, default: false },
-    active: { type: Boolean, default: false },
-    subscriber: { type: Boolean, default: false },
-    role: { type: String, enum: ['admin', 'lp-full', 'lp-names', 'none'], default: 'none' },
+    admin: { type: Boolean },
+    active: { type: Boolean },
+    subscriber: { type: Boolean },
+    role: { type: String, enum: ['admin', 'lp-full', 'lp-names', 'none'] },
 
     // Enable this and iLevel links will show on portfolio pages
-    iLevelUser: { type: Boolean, default: false },
+    iLevelUser: { type: Boolean },
 
     person: {
       type: Schema.ObjectId,
@@ -252,42 +251,6 @@ module.exports = function(mongoose, config) {
 
   };
 
-  //Account.pre('save', function(next) {
-  //
-  //  // Encrypt sensitive data
-  //
-  //  if (this.auth) {
-  //    if (this.auth.google) {
-  //      if (this.auth.google.accessToken) this.auth.google.accessToken = crypto.encrypt(this.auth.google.accessToken);
-  //      if (this.auth.google.refreshToken) this.auth.google.refreshToken = crypto.encrypt(this.auth.google.refreshToken);
-  //      if (this.auth.google.params) {
-  //        if (this.auth.google.params.access_token) this.auth.google.params.access_token = crypto.encrypt(this.auth.google.params.access_token);
-  //        if (this.auth.google.params.id_token) this.auth.google.params.id_token = crypto.encrypt(this.auth.google.params.id_token);
-  //      }
-  //    }
-  //  }
-  //
-  //  next();
-  //
-  //});
-  //
-  //Account.post('init', function() {
-  //
-  //  // Decrypt sensitive data
-  //
-  //  if (this.auth) {
-  //    if (this.auth.google) {
-  //      if (this.auth.google.accessToken) this.auth.google.accessToken = crypto.decrypt(this.auth.google.accessToken);
-  //      if (this.auth.google.refreshToken) this.auth.google.refreshToken = crypto.decrypt(this.auth.google.refreshToken);
-  //      if (this.auth.google.params) {
-  //        if (this.auth.google.params.access_token) this.auth.google.params.access_token = crypto.decrypt(this.auth.google.params.access_token);
-  //        if (this.auth.google.params.id_token) this.auth.google.params.id_token = crypto.decrypt(this.auth.google.params.id_token);
-  //      }
-  //    }
-  //  }
-  //
-  //});
-
   Account.post('remove', function(doc) {
     // CalendarEvent.account
     // Person.account

package/lib/CapTable.js

@@ -0,0 +1,397 @@
+"use strict";
+
+///////////////////////////////////////////////////////////////////////////////////////
+// NOTES
+//
+// This is private data
+//
+// Unique-keyed on organization and customer combo
+//
+// These are not referenced in orgs. If you need the cap table for an org, query this
+// collection separately and stitch together as necessary
+//
+///////////////////////////////////////////////////////////////////////////////////////
+
+module.exports = function(mongoose, config) {
+
+  var Schema = mongoose.Schema;
+  var Organization = mongoose.model('Organization');
+  var _ = require('underscore');
+  var async = require('async');
+
+  var CapTable = new Schema({
+
+    // the org this cap table is for
+    organization: { type: Schema.ObjectId, ref: 'Organization', required: true },
+
+    // each customer has their own cap table
+    customer: { type: Schema.ObjectId, ref: 'Organization', required: true },
+
+    // preferably the date in the cap table document, not the date added to our system
+    asOfDate: { type: Date, required: true, default: Date.now },
+
+    // so customers can download full file
+    originalDocumentUrl: { type: String, trim: true },
+
+    // single pool of unissued options for the org
+    unissuedOptions: { type: Number, default: 0 },
+
+    // computed on save (via pre-save hook); don't set directly;
+    fullyDiluted: { type: Number, default: 0 },
+
+    stakeholders: [{
+
+      // Note that name will always be pulled from sheet and used by default when rendering a cap table.
+      // The stakeholder will be programmatically linked to a person or fund in the event of an exact text match on person.name.full or fund.name.
+      // Manual creation and linking of stakeholder and entity will happen within Admin.
+      // The corollary of this is that neither person nor fund is required and the name from the sheet will be used in their absence.
+
+      // verbatim text from the cap table
+      name: { type: String, trim: true, required: true },
+
+      // link stakeholder to a person in our system
+      person: {
+        type: Schema.ObjectId,
+        ref: 'Person',
+        default: null,
+        required: false,
+        validate: {
+          validator: function(v) {
+            if (v && this.fund) return false;
+            else return true;
+          },
+          message: 'A stakeholder can be linked to a person or a fund, but not both'
+        }
+      },
+
+      // link stakeholder to a fund in our system
+      fund: {
+        type: Schema.ObjectId,
+        ref: 'Fund',
+        default: null,
+        required: false,
+        validate: {
+          validator: function(v) {
+            if (v && this.person) return false;
+            else return true;
+          },
+          message: 'A stakeholder can be linked to a person or a fund, but not both'
+        }
+      },
+
+      // Put stakes in a bucket for their type.
+      // Note we are grouping all stakes for the current stakeholder.
+
+      common: [{
+        round: { type: String, trim: true, required: true },
+        shares: { type: Number, default: 0 }
+      }],
+
+      options: [{
+        round: { type: String, trim: true, required: true },
+        shares: { type: Number, default: 0 }
+      }],
+
+      preferred: [{
+        round: { type: String, trim: true, required: true },
+        shares: { type: Number, default: 0 }
+      }],
+
+      warrants: [{
+        round: { type: String, trim: true, required: true },
+        shares: { type: Number, default: 0 }
+      }],
+
+      // computed on save (via pre-save hook); don't set directly;
+      fullyDiluted: { type: Number, default: 0 },
+
+      // computed on save (via pre-save hook); don't set directly;
+      fullyDilutedPercentage: { type: Number, default: 0 }
+
+    }],
+
+    entered: {
+      by: { type: String, trim: true, required: true },
+      on: { type: Date, default: Date.now, required: true }
+    }
+
+  });
+
+
+
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // VIRTUALS
+  // Properties that are not persisted to the database
+  ///////////////////////////////////////////////////////////////////////////////////////
+
+  CapTable.virtual('stakeholdersByRound').get(function () {
+
+    // Returns list of tuples, one for each round on this cap table along with participants in each round
+
+    var self = this;
+
+    var buildRoundList = function buildRoundList(stakeholders) {
+
+      var roundList = [];
+
+      _.each(stakeholders, function(stakeholder) {
+        roundList = roundList.concat(_.pluck(stakeholder.common, 'round'));
+        roundList = roundList.concat(_.pluck(stakeholder.options, 'round'));
+        roundList = roundList.concat(_.pluck(stakeholder.preferred, 'round'));
+        roundList = roundList.concat(_.pluck(stakeholder.warrants, 'round'));
+      });
+
+      roundList = _.uniq(roundList);
+
+      return roundList;
+
+    };
+
+    var matchStakeholderToRound = function matchStakeholderToRound(arr, participants, name, round) {
+      var match = _.find(arr, function(i) { return round == i.round; });
+      if (match) { participants.push(name); }
+    };
+
+    var roundList = buildRoundList(self.stakeholders);
+
+    var stakeholders = [];
+
+    _.each(roundList, function(round) {
+
+      // List of each participant in this round
+      var participants = [];
+
+      _.each(self.stakeholders, function(stakeholder) {
+        matchStakeholderToRound(stakeholder.common, participants, stakeholder.name, round);
+        matchStakeholderToRound(stakeholder.options, participants, stakeholder.name, round);
+        matchStakeholderToRound(stakeholder.preferred, participants, stakeholder.name, round);
+        matchStakeholderToRound(stakeholder.warrants, participants, stakeholder.name, round);
+      });
+
+      participants = _.uniq(participants);
+
+      // return tuple of round name and participants in the round
+      stakeholders.push({
+        round: round,
+        participants: participants
+      });
+
+    });
+
+    return stakeholders;
+
+  });
+
+
+
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // METHODS
+  // Methods operate on a single document that has already been returned
+  // Note that running a method on a document does not save it
+  ///////////////////////////////////////////////////////////////////////////////////////
+
+  CapTable.methods.mapFundsToOrgs = function mapFundsToOrgs(cb) {
+
+    // Check each stakeholder to see if it is a fund, and if so, get the org the fund belongs to
+
+    var self = this;
+    var map = [];
+
+    var getOrg = function getOrg(stakeholder, callback) {
+
+      if (!stakeholder.fund) return callback();
+
+      var fundid = stakeholder.fund._id || stakeholder.fund;
+
+      Organization.getByFund(fundid, function(err, result) {
+
+        if (err) return callback(err);
+        else if (!result) return callback();
+
+        map.push({
+          fund: fundid,
+          org: result
+        });
+
+        return callback();
+
+      });
+
+    };
+
+    async.each(self.stakeholders, getOrg, function(err) {
+      if (err) return cb(err, null);
+      else return cb(null, map);
+    });
+
+  };
+
+
+
+  //////////////////////////////////////////////////////
+  // STATICS
+  // Statics operate on the entire collection
+  //////////////////////////////////////////////////////
+
+  CapTable.statics.delete = function(id, cb) {
+    var self = this;
+    self.findByIdAndRemove(id, cb);
+  };
+
+  CapTable.statics.deleteAllForCustomer = function(customerId, cb) {
+    var self = this;
+    self.remove({ customer: customerId }, cb);
+  };
+
+  CapTable.statics.getAllForCustomer = function getAllForCustomer(customerId, cb) {
+
+    var self = this;
+
+    self
+      .find({customer: customerId })
+      .populate('organization', 'name logoUrl')
+      .exec(cb);
+
+  };
+
+  CapTable.statics.getForCustomer = function getForCustomer(orgId, customerId, cb) {
+
+    var self = this;
+
+    self
+      .findOne({customer: customerId, organization: orgId })
+      .populate('stakeholders.person', 'name avatarUrl title')
+      .populate('stakeholders.fund', 'name shortName')
+      .exec(cb);
+
+  };
+
+  CapTable.statics.insert = function(capTable, username, cb) {
+
+    var self = this;
+
+    if (!capTable) { return cb(new Error('capTable is required'), null); }
+    if (!username) { return cb(new Error('username is required'), null); }
+
+    capTable.constructor.getForCustomer(capTable.organization, capTable.customer, function(err, result) {
+
+      if (err) return cb(err, null);
+      if (result) return cb(new Error('A cap table already exists for this customer/org combo'), null);
+
+      capTable.entered.by = username;
+      capTable.entered.on = new Date();
+
+      self.create(capTable, cb);
+
+    });
+
+  };
+
+  CapTable.statics.replace = function(capTable, username, cb) {
+
+    var self = this;
+
+    if (!capTable) { return cb(new Error('capTable is required'), null); }
+    if (!username) { return cb(new Error('username is required'), null); }
+
+    capTable.entered.by = username;
+    capTable.entered.on = new Date();
+
+    self.update(
+      { '_id': capTable._id },
+      capTable,
+      { upsert: false, multi: false, overwrite: true },
+      cb
+    );
+
+  };
+
+  CapTable.statics.updateOriginalDocumentUrl = function updateOriginalDocumentUrl(id, originalDocumentUrl, cb) {
+
+    var self = this;
+
+    self
+      .findByIdAndUpdate(
+        id,
+        { $set: { originalDocumentUrl: originalDocumentUrl } },
+        { new: true, upsert: false },
+        cb
+      );
+
+  };
+
+
+
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // HOOKS
+  // Pre-save: fired on every document before it is saved
+  ///////////////////////////////////////////////////////////////////////////////////////
+
+  CapTable.pre('save', function(next) {
+
+    var self = this;
+
+    // Sum each stakeholders fully diluted shares
+    _.each(self.stakeholders, function(stakeholder) {
+
+      var common = _.reduce(stakeholder.common, function(memo, i) {
+        return memo + i.shares;
+      }, 0);
+
+      var options = _.reduce(stakeholder.options, function(memo, i) {
+        return memo + i.shares;
+      }, 0);
+
+      var preferred = _.reduce(stakeholder.preferred, function(memo, i) {
+        return memo + i.shares;
+      }, 0);
+
+      var warrants = _.reduce(stakeholder.warrants, function(memo, i) {
+        return memo + i.shares;
+      }, 0);
+
+      stakeholder.fullyDiluted = common + options + preferred + warrants;
+
+    });
+
+    // Sum total fully diluted
+    self.fullyDiluted = _.reduce(self.stakeholders, function(memo, stakeholder) {
+      return memo + stakeholder.fullyDiluted;
+    }, 0);
+    self.fullyDiluted = self.fullyDiluted + self.unissuedOptions;
+
+    // Calculate each stakeholders fully diluted percentage
+    _.each(self.stakeholders, function(stakeholder) {
+      if (self.fullyDiluted == 0) { stakeholder.fullyDiluted = 0; }
+      else { stakeholder.fullyDilutedPercentage = ((stakeholder.fullyDiluted / self.fullyDiluted) * 100).toFixed(2); }
+    });
+
+    return next();
+
+  });
+
+  CapTable.post('init', function(doc, next) {
+
+    doc.stakeholders = _.sortBy(doc.stakeholders, 'fullyDilutedPercentage').reverse();
+
+    return next();
+
+  });
+
+
+
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // CONFIG
+  ///////////////////////////////////////////////////////////////////////////////////////
+
+  CapTable.set('toJSON', { virtuals: true });
+  CapTable.set('autoIndex', true);
+
+  CapTable.index({ organization: 1,  customer: 1 }, { unique: true, sparse: true });
+  CapTable.on('index', function(err) { console.log('error building CapTable indexes: ' + err); });
+
+  mongoose.model('CapTable', CapTable);
+
+};
+
+

package/lib/Fund.js

@@ -2,12 +2,14 @@
 
 module.exports = function(mongoose, config) {
 
-  var Schema = mongoose.Schema
+  var Schema = mongoose.Schema;
+  var Round = mongoose.model('Round');
+  var _ = require('underscore');
   var env = process.env.NODE_ENV || 'development';
 
   var Fund = new Schema({
 
-    name: { type: String, required: true },
+    name: { type: String, required: true, unique: true },
     slug: { type: String, required: true, unique: true },
     shortName: { type: String, required: true },
     spv: { type: Boolean, default: false },
@@ -68,37 +70,79 @@ module.exports = function(mongoose, config) {
 
   ///////////////////////////////////////
 
-  Fund.statics.getById = function (id, cb) {
+  Fund.statics.findBySlugs = function findBySlugs(slugs, cb) {
     this
-      .findById(id)
+      .find({ 'slug': { $in : slugs }})
       .exec(cb);
   };
 
-  Fund.statics.getBySlug = function (slug, cb) {
+  Fund.statics.getById = function getById(id, cb) {
     this
-      .find({slug: slug})
+      .findById(id)
       .exec(cb);
   };
 
-  Fund.statics.findBySlugs = function (slugs, cb) {
+  Fund.statics.getBySlug = function getBySlug(slug, cb) {
     this
-      .find({ 'slug': { $in : slugs }})
+      .find({slug: slug})
       .exec(cb);
   };
 
-  Fund.statics.getCount = function (cb) {
+  Fund.statics.getCount = function getCount(cb) {
     this
       .count({})
       .exec(cb);
   };
 
-  Fund.statics.list = function (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()
       .exec(cb);
   };
 
-  Fund.statics.search = function (query, options, cb) {
+  Fund.statics.search = function search(query, options, cb) {
 
     if (!cb) throw new Error('cb is required');
     if (!query) return cb(null, []);
@@ -115,7 +159,7 @@ module.exports = function(mongoose, config) {
 
   };
 
-  Fund.statics.upsert = function(fund, username, cb) {
+  Fund.statics.upsert = function upsert(fund, username, cb) {
 
     if (!fund) { return cb(new Error('Fund is required'), null); }
     if (!username) { return cb(new Error('Username is required'), null); }