@dhyasama/totem-models 11.86.0 → 11.88.0

package/lib/Financials.js

@@ -19,6 +19,9 @@ module.exports = function(mongoose, config) {
 
     customer: { type: Schema.ObjectId, ref: 'Organization', required: true, index: true },
 
+    // the date the financial is as of (not the date added to our system)
+    asOfDate: { type: Date },
+
     fiscal: {
       month: { type: Number, default: 1 },
       day: { type: Number, default: 1 },

package/lib/Round.js

@@ -258,16 +258,6 @@ module.exports = function(mongoose, config) {
   // Statics operate on the entire collection
   //////////////////////////////////////////////////////\
 
-  Round.statics.getAllOrgs = function getAllOrgs(cb) {
-
-    const self = this;
-
-    if (!cb) { throw new Error('cb is required'); }
-
-    self.distinct('organization', cb);
-
-  };
-
   Round.statics.getByOrg = function getByOrg(orgId, options, cb) {
 
     // Gets all the rounds an org has raised
@@ -351,7 +341,7 @@ module.exports = function(mongoose, config) {
       'organization': { $in: orgIds }
     });
 
-    query.populate('organization', 'name logoUrl website websiteAliases');
+    query.populate('organization', 'name logoUrl website websiteAliases operating');
     query.populate('vehicles.fund');
 
     if (options.isWorkerProcess) {
@@ -487,6 +477,74 @@ module.exports = function(mongoose, config) {
     });
 
   };
+  
+  Round.statics.getPortfolioInvestments = function getPortfolioInvestments(options, cb) {
+
+    const self = this;
+
+    if (!cb) { throw new Error('cb is required'); }
+    if (!options) { return cb(new Error('options is required'), null); }
+
+    options = helpers.getDefaultOptions(options);
+
+    if (!options.isWorkerProcess) {
+      if (!options.CUSTOMER_ID) { return cb(new Error('options.CUSTOMER_ID is required'), null); }
+      if (!mongoose.Types.ObjectId.isValid(options.CUSTOMER_ID)) { return cb(new Error('options.CUSTOMER_ID is not a valid ObjectId'), null); }
+    }
+
+    // First get the customer's fund IDs
+    Organization.getById(options.CUSTOMER_ID, { CUSTOMER_ID: options.CUSTOMER_ID }, function(err, customer) {
+
+      if (err) return cb(err, null);
+      if (!customer) return cb(new Error('Customer not found'), null);
+      if (!customer.funds || customer.funds.length === 0) return cb(null, []);
+
+      const fundIds = _.pluck(customer.funds, '_id');
+
+      let query = self.find({ 'vehicles.fund': { $in: fundIds } });
+      query.select('organization roundName vehicles');
+      query.populate('organization', 'name description logoUrl website websiteAliases filters status ipo closed acquired operating');
+
+      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);
+        if (!rounds) return cb(null, []);
+
+        if (!options.isWorkerProcess) {
+          _.each(rounds, function(round) {
+            round = helpers.cleanRound(round, fundIds, options.CUSTOMER_ID);
+            round.organization = helpers.cleanOrg(round.organization, options.CUSTOMER_ID);
+          });
+        }
+
+        let portfolioInvestments = [];
+        _.each(rounds, function(round) {
+          _.each(round.vehicles, function(vehicle) {
+            _.each(vehicle.investments, function(investment) {
+              investment.organization = round.organization;
+              investment.roundName = round.roundName;
+              portfolioInvestments.push(investment);
+            });
+          });
+        });
+
+        return cb(null, portfolioInvestments);
+
+      });
+
+    });
+
+  };
 
   Round.statics.getFundPerformance = function getFundPerformance(fundId, options, cb) {
 
@@ -696,6 +754,7 @@ module.exports = function(mongoose, config) {
           website: rounds[0].organization.website,
           status: rounds[0].organization.status,
           people: rounds[0].organization.people,
+          operating: rounds[0].organization.operating,
           funds: fundList
         });
 
@@ -757,6 +816,175 @@ module.exports = function(mongoose, config) {
 
   };
 
+  Round.statics.getRelated = function getRelated(orgid, options, cb) {
+
+    const self = this;
+    const async = require('async');
+    const Organization = mongoose.model('Organization');
+
+    if (!cb) { throw new Error('cb is required'); }
+    if (!orgid) { return cb(new Error('orgid is required'), null); }
+    if (!mongoose.Types.ObjectId.isValid(orgid)) { return cb(new Error('orgid is not a valid ObjectId'), null); }
+    if (!options) { return cb(new Error('options is required'), null); }
+    if (!options.CUSTOMER_ID) { return cb(new Error('options.CUSTOMER_ID is required'), null); }
+    if (!mongoose.Types.ObjectId.isValid(options.CUSTOMER_ID)) { return cb(new Error('options.CUSTOMER_ID is not a valid ObjectId'), null); }
+
+    // We need customerFunds to filter rounds - extract from options or get all customer funds
+    var customerFunds = options.customerFunds;
+    if (!customerFunds) {
+      const Fund = mongoose.model('Fund');
+      return Fund.findByCustomer(options.CUSTOMER_ID, function(err, funds) {
+        if (err) return cb(err);
+        options.customerFunds = funds;
+        return self.getRelated(orgid, options, cb);
+      });
+    }
+
+    async.parallel([
+      
+      // Find organizations acquired by this org (acquirees)
+      function(callback) {
+        Organization
+          .find({
+            $or: [
+              { 'operating.acquired.private.by': orgid, 'operating.acquired.private.customer': options.CUSTOMER_ID, 'deleted': { $ne: true } },
+              { 'operating.acquired.public.by': orgid, 'deleted': { $ne: true } }
+            ]
+          })
+          .select('name logoUrl')
+          .exec(callback);
+      },
+      
+      // Find organizations merged with this org
+      function(callback) {
+        Organization
+          .find({
+            $or: [
+              { 'operating.merged.private.with': orgid, 'operating.merged.private.customer': options.CUSTOMER_ID, 'deleted': { $ne: true } },
+              { 'operating.merged.public.with': orgid, 'deleted': { $ne: true } }
+            ]
+          })
+          .select('name logoUrl')
+          .exec(callback);
+      },
+      
+      // Find organizations that acquired this org (acquirers) or merged with this org
+      function(callback) {
+        Organization
+          .findById(orgid)
+          .select('operating')
+          .exec(function(err, mainOrg) {
+            if (err) return callback(err);
+            if (!mainOrg) return callback(null, []);
+            
+            var relatedIds = [];
+            
+            // Check for acquirer
+            if (mainOrg.operating && mainOrg.operating.acquired) {
+              // acquired.private is an array, iterate through it
+              if (mainOrg.operating.acquired.private && Array.isArray(mainOrg.operating.acquired.private)) {
+                mainOrg.operating.acquired.private.forEach(function(acquiredEntry) {
+                  if (acquiredEntry && acquiredEntry.by) {
+                    relatedIds.push(acquiredEntry.by);
+                  }
+                });
+              }
+              
+              if (mainOrg.operating.acquired.public && mainOrg.operating.acquired.public.by) {
+                relatedIds.push(mainOrg.operating.acquired.public.by);
+              }
+            }
+            
+            // Check for merger partner
+            if (mainOrg.operating && mainOrg.operating.merged) {
+              // merged.private is an array, iterate through it
+              if (mainOrg.operating.merged.private && Array.isArray(mainOrg.operating.merged.private)) {
+                mainOrg.operating.merged.private.forEach(function(mergedEntry) {
+                  if (mergedEntry && mergedEntry.with) {
+                    relatedIds.push(mergedEntry.with);
+                  }
+                });
+              }
+              
+              if (mainOrg.operating.merged.public && mainOrg.operating.merged.public.with) {
+                relatedIds.push(mainOrg.operating.merged.public.with);
+              }
+            }
+            
+            if (relatedIds.length === 0) return callback(null, []);
+            
+            Organization
+              .find({
+                '_id': { $in: relatedIds },
+                'deleted': { $ne: true }
+              })
+              .select('name logoUrl')
+              .exec(callback);
+          });
+      }
+      
+    ], function(err, results) {
+      if (err) return cb(err);
+      
+      // Flatten and combine all results
+      var allResults = [];
+      results.forEach(function(resultSet) {
+        if (Array.isArray(resultSet)) {
+          allResults = allResults.concat(resultSet);
+        }
+      });
+      
+      // Remove duplicates and the org itself
+      var uniqueResults = [];
+      var seenIds = new Set();
+      
+      allResults.forEach(function(org) {
+        if (!seenIds.has(org._id.toString()) && org._id.toString() !== orgid.toString()) {
+          seenIds.add(org._id.toString());
+          uniqueResults.push(org);
+        }
+      });
+
+      // Now get rounds for each related organization
+      async.map(uniqueResults, function(org, mapCallback) {
+        
+        var fundIds = customerFunds.map(function(fund) { return fund._id; });
+        
+        self
+          .find({
+            'organization': org._id,
+            'vehicles.fund': { $in: fundIds },
+            'deleted': { $ne: true }
+          })
+          .populate('vehicles.fund', 'name shortName hexColorCode abbreviation closeDate')
+          .populate('organization', 'name logoUrl')
+          .populate({
+            path: 'vehicles.investments',
+            match: { customer: options.CUSTOMER_ID }
+          })
+          .exec(function(err, rounds) {
+            if (err) return mapCallback(err);
+            
+            // Clean rounds to only show vehicles for customer funds
+            if (rounds && !options.isWorkerProcess) {
+              rounds = rounds.map(function(round) {
+                return helpers.cleanRound(round, fundIds, options.CUSTOMER_ID);
+              });
+            }
+            
+            mapCallback(null, {
+              org: org,
+              rounds: rounds || []
+            });
+          });
+          
+      }, function(err, relatedWithRounds) {
+        if (err) return cb(err);
+        cb(null, relatedWithRounds);
+      });
+    });
+  };
+
   Round.statics.upsert = function(round, cb) {
 
     if (!round) { return cb(new Error('round is required'), null); }

package/package.json

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