@dhyasama/totem-models 12.3.0 → 12.4.0

package/lib/Round.js

@@ -258,12 +258,10 @@ module.exports = function(mongoose, config) {
   // Statics operate on the entire collection
   //////////////////////////////////////////////////////\
 
-  Round.statics.getByOrg = function getByOrg(orgId, options, cb) {
+  Round.statics.getByOrg = async function getByOrg(orgId, options, cb) {
 
     // Gets all the rounds an org has raised
 
-    const self = this;
-
     if (!cb) { throw new Error('cb is required'); }
     if (!orgId) { throw new Error('orgId is required'); }
     if (!mongoose.Types.ObjectId.isValid(orgId)) { return cb(new Error('orgId is not a valid ObjectId'), null); }
@@ -276,25 +274,27 @@ module.exports = function(mongoose, config) {
       if (!mongoose.Types.ObjectId.isValid(options.CUSTOMER_ID)) { return cb(new Error('options.CUSTOMER_ID is not a valid ObjectId'), null); }
     }
 
-    let query = self.find({
-      'deleted': { $ne: true },
-      'organization': orgId
-    });
+    try {
+      let query = this.find({
+        'deleted': { $ne: true },
+        'organization': orgId
+      });
 
-    query.populate('organization', 'name logoUrl website websiteAliases');
-    query.populate('vehicles.fund', 'name shortName');
+      query.populate('organization', 'name logoUrl website websiteAliases');
+      query.populate('vehicles.fund', 'name shortName');
 
-    if (options.isWorkerProcess) {
-      query.populate('vehicles.investments');
-    }
-    else {
-      query.populate({
-        path: 'vehicles.investments',
-        match: { customer: options.CUSTOMER_ID }
-      });
-    }
+      if (options.isWorkerProcess) {
+        query.populate('vehicles.investments');
+      }
+      else {
+        query.populate({
+          path: 'vehicles.investments',
+          match: { customer: options.CUSTOMER_ID }
+        });
+      }
 
-    query.exec().then(function(rounds) {if (!rounds || rounds.length === 0) { return cb(null, []); }
+      let rounds = await query;
+      if (!rounds || rounds.length === 0) { return cb(null, []); }
 
       let error = checkForUnpopulatedData(rounds, 'Round.getByOrg');
       if (error) { return cb(error, null); }
@@ -313,14 +313,13 @@ module.exports = function(mongoose, config) {
       }).reverse();
 
       return cb(null, rounds);
-
-    }).catch(function(err) { cb(err); });
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Round.statics.getByOrgs = function getByOrg(orgIds, options, cb) {
-
-    const self = this;
+  Round.statics.getByOrgs = async function getByOrg(orgIds, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!orgIds) { throw new Error('orgIds is required'); }
@@ -333,25 +332,27 @@ module.exports = function(mongoose, config) {
       if (!mongoose.Types.ObjectId.isValid(options.CUSTOMER_ID)) { return cb(new Error('options.CUSTOMER_ID is not a valid ObjectId'), null); }
     }
 
-    let query = self.find({
-      'deleted': { $ne: true },
-      'organization': { $in: orgIds }
-    });
+    try {
+      let query = this.find({
+        'deleted': { $ne: true },
+        'organization': { $in: orgIds }
+      });
 
-    query.populate('organization', 'name logoUrl website websiteAliases operating');
-    query.populate('vehicles.fund');
+      query.populate('organization', 'name logoUrl website websiteAliases operating');
+      query.populate('vehicles.fund');
 
-    if (options.isWorkerProcess) {
-      query.populate('vehicles.investments');
-    }
-    else {
-      query.populate({
-        path: 'vehicles.investments',
-        match: { customer: options.CUSTOMER_ID }
-      });
-    }
+      if (options.isWorkerProcess) {
+        query.populate('vehicles.investments');
+      }
+      else {
+        query.populate({
+          path: 'vehicles.investments',
+          match: { customer: options.CUSTOMER_ID }
+        });
+      }
 
-    query.exec().then(function(rounds) {if (!rounds || rounds.length === 0) return cb(null, []);
+      let rounds = await query;
+      if (!rounds || rounds.length === 0) return cb(null, []);
 
       let error = checkForUnpopulatedData(rounds, 'Round.getByOrgs');
       if (error) return cb(error, null);
@@ -370,14 +371,13 @@ module.exports = function(mongoose, config) {
       }).reverse();
 
       return cb(null, rounds);
-
-    }).catch(function(err) { cb(err); });
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Round.statics.getByOrgs2 = function getByOrg2(orgIds, options, cb) {
-
-    const self = this;
+  Round.statics.getByOrgs2 = async function getByOrg2(orgIds, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!orgIds) { throw new Error('orgIds is required'); }
@@ -390,29 +390,30 @@ module.exports = function(mongoose, config) {
       if (!mongoose.Types.ObjectId.isValid(options.CUSTOMER_ID)) { return cb(new Error('options.CUSTOMER_ID is not a valid ObjectId'), null); }
     }
 
-    let query = self.find({
-      'organization': { $in: orgIds }
-    });
-
-    if (options.isWorkerProcess) {
-      query.populate('vehicles.investments');
-    }
-    else {
-      query.populate({
-        path: 'vehicles.investments',
-        match: { customer: options.CUSTOMER_ID }
+    try {
+      let query = this.find({
+        'organization': { $in: orgIds }
       });
-    }
 
-    query.exec().then(function(rounds) {return cb(null, rounds);
+      if (options.isWorkerProcess) {
+        query.populate('vehicles.investments');
+      }
+      else {
+        query.populate({
+          path: 'vehicles.investments',
+          match: { customer: options.CUSTOMER_ID }
+        });
+      }
 
-    }).catch(function(err) { cb(err); });
+      const rounds = await query;
+      return cb(null, rounds);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Round.statics.getFundInvestments = function getFundInvestments(fundId, options, cb) {
-
-    const self = this;
+  Round.statics.getFundInvestments = async function getFundInvestments(fundId, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!fundId) { throw new Error('fundId is required'); }
@@ -426,21 +427,23 @@ module.exports = function(mongoose, config) {
       if (!mongoose.Types.ObjectId.isValid(options.CUSTOMER_ID)) { return cb(new Error('options.CUSTOMER_ID is not a valid ObjectId'), null); }
     }
 
-    let query = self.find({ 'vehicles.fund': fundId });
-    query.select('organization roundName vehicles');
-    query.populate('organization', 'name aliases description logoUrl website websiteAliases filters status ipo closed acquired operating');
+    try {
+      let query = this.find({ 'vehicles.fund': fundId });
+      query.select('organization roundName vehicles');
+      query.populate('organization', 'name aliases 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 }
-      });
-    }
+      if (options.isWorkerProcess) {
+        query.populate('vehicles.investments');
+      }
+      else {
+        query.populate({
+          path: 'vehicles.investments',
+          match: { customer: options.CUSTOMER_ID }
+        });
+      }
 
-    query.exec().then(function(rounds) {if (!rounds) return cb(null, []);
+      const rounds = await query;
+      if (!rounds) return cb(null, []);
 
       if (!options.isWorkerProcess) {
         _.each(rounds, function(round) {
@@ -461,14 +464,13 @@ module.exports = function(mongoose, config) {
       });
 
       return cb(null, fundInvestments);
-
-    }).catch(function(err) { cb(err); });
+    } catch(err) {
+      return cb(err);
+    }
 
   };
-  
-  Round.statics.getPortfolioInvestments = function getPortfolioInvestments(options, cb) {
 
-    const self = this;
+  Round.statics.getPortfolioInvestments = async function getPortfolioInvestments(options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!options) { return cb(new Error('options is required'), null); }
@@ -481,7 +483,7 @@ module.exports = function(mongoose, config) {
     }
 
     // First get the customer's fund IDs
-    Organization.getById(options.CUSTOMER_ID, { CUSTOMER_ID: options.CUSTOMER_ID }, function(err, customer) {
+    Organization.getById(options.CUSTOMER_ID, { CUSTOMER_ID: options.CUSTOMER_ID }, async (err, customer) => {
 
       if (err) return cb(err, null);
       if (!customer) return cb(new Error('Customer not found'), null);
@@ -489,21 +491,23 @@ module.exports = function(mongoose, config) {
 
       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');
+      try {
+        let query = this.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 }
-        });
-      }
+        if (options.isWorkerProcess) {
+          query.populate('vehicles.investments');
+        }
+        else {
+          query.populate({
+            path: 'vehicles.investments',
+            match: { customer: options.CUSTOMER_ID }
+          });
+        }
 
-      query.exec().then(function(rounds) {if (!rounds) return cb(null, []);
+        const rounds = await query;
+        if (!rounds) return cb(null, []);
 
         if (!options.isWorkerProcess) {
           _.each(rounds, function(round) {
@@ -524,38 +528,38 @@ module.exports = function(mongoose, config) {
         });
 
         return cb(null, portfolioInvestments);
-
-      }).catch(function(err) { cb(err); });
+      } catch(err) {
+        return cb(err);
+      }
 
     });
 
   };
 
-  Round.statics.getFundPerformance = function getFundPerformance(fundId, options, cb) {
+  Round.statics.getFundPerformance = async function getFundPerformance(fundId, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!fundId) { throw new Error('fundId is required'); }
     if (!mongoose.Types.ObjectId.isValid(fundId)) { return cb(new Error('fundId is not a valid ObjectId'), null); }
 
-    const self = this;
-
-    let query = self.find({ 'vehicles.fund': fundId });
+    try {
+      let query = this.find({ 'vehicles.fund': fundId });
 
-    query.select('organization vehicles');
-    query.populate('organization', 'name slug logoUrl description ');
-    query.populate('vehicles.fund');
+      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 }
-      });
-    }
+      if (options.isWorkerProcess) {
+        query.populate('vehicles.investments');
+      }
+      else {
+        query.populate({
+          path: 'vehicles.investments',
+          match: { customer: options.CUSTOMER_ID }
+        });
+      }
 
-    query.exec().then(function(rounds) {
+      const rounds = await query;
       if (!rounds) return cb(null, null);
       else if (rounds.length === 0) return cb(null, []);
 
@@ -567,14 +571,13 @@ module.exports = function(mongoose, config) {
       }
 
       return cb(null, calculatePerformance(rounds));
-
-    }).catch(function(err) { cb(err); });
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Round.statics.getPortfolioByFund = function getPortfolioByFund(fundId, options, cb) {
-
-    const self = this;
+  Round.statics.getPortfolioByFund = async function getPortfolioByFund(fundId, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!fundId) { throw new Error('fundId is required'); }
@@ -588,23 +591,25 @@ module.exports = function(mongoose, config) {
       if (!mongoose.Types.ObjectId.isValid(options.CUSTOMER_ID)) { return cb(new Error('options.CUSTOMER_ID is not a valid ObjectId'), null); }
     }
 
-    let query = self.find({ 'vehicles.fund': fundId });
+    try {
+      let query = this.find({ 'vehicles.fund': fundId });
 
-    query.select('organization vehicles');
-    query.populate('organization', 'name aliases slug logoUrl description contact filters status ipo closed acquired operating website websiteAliases');
-    query.populate('vehicles.fund');
+      query.select('organization vehicles');
+      query.populate('organization', 'name aliases slug logoUrl description contact filters status ipo closed acquired operating website websiteAliases');
+      query.populate('vehicles.fund');
 
-    if (options.isWorkerProcess) {
-      query.populate('vehicles.investments');
-    }
-    else {
-      query.populate({
-        path: 'vehicles.investments',
-        match: { customer: options.CUSTOMER_ID }
-      });
-    }
+      if (options.isWorkerProcess) {
+        query.populate('vehicles.investments');
+      }
+      else {
+        query.populate({
+          path: 'vehicles.investments',
+          match: { customer: options.CUSTOMER_ID }
+        });
+      }
 
-    query.exec().then(function(rounds) {if (!rounds || rounds.length === 0) return cb(null, []);
+      const rounds = await query;
+      if (!rounds || rounds.length === 0) return cb(null, []);
 
       let error = checkForUnpopulatedData(rounds, 'Round.getPortfolioByFund');
       if (error) return cb(error, null);
@@ -617,18 +622,17 @@ module.exports = function(mongoose, config) {
       }
 
       return cb(null, buildPortfolio(rounds, [fundId]));
-
-    }).catch(function(err) { cb(err); });
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Round.statics.getPortfolioByFunds = function getPortfolioByFunds(fundIds, options, cb) {
+  Round.statics.getPortfolioByFunds = async function getPortfolioByFunds(fundIds, options, cb) {
 
     // Returns a list of orgs that have rounds participated in by the given fund ids
     // Note retrieving multiple funds does not calculate fund stats. Use getPortfolioByFund for that.
 
-    const self = this;
-
     if (!cb) { throw new Error('cb is required'); }
     if (!fundIds) { throw new Error('fundIds is required'); }
     if (!options) { return cb(new Error('options is required'), null); }
@@ -640,30 +644,32 @@ module.exports = function(mongoose, config) {
       if (!mongoose.Types.ObjectId.isValid(options.CUSTOMER_ID)) { return cb(new Error('options.CUSTOMER_ID is not a valid ObjectId'), null); }
     }
 
-    let query = self.find({ 'vehicles.fund': { $in: fundIds } });
+    try {
+      let query = this.find({ 'vehicles.fund': { $in: fundIds } });
 
-    query.select('organization vehicles');
-    query.populate({
-      path: 'organization',
-      select: 'name aliases slug logoUrl description contact chairs filters status ipo closed acquired operating website websiteAliases',
-      populate: [
-        { path: 'chairs.first', select: 'name avatarUrl title doNotDisplay' },
-        { path: 'chairs.second', select: 'name avatarUrl title doNotDisplay' }
-      ]
-    });
-    query.populate('vehicles.fund');
-
-    if (options.isWorkerProcess) {
-      query.populate('vehicles.investments');
-    }
-    else {
+      query.select('organization vehicles');
       query.populate({
-        path: 'vehicles.investments',
-        match: { customer: options.CUSTOMER_ID }
+        path: 'organization',
+        select: 'name aliases slug logoUrl description contact chairs filters status ipo closed acquired operating website websiteAliases',
+        populate: [
+          { path: 'chairs.first', select: 'name avatarUrl title doNotDisplay' },
+          { path: 'chairs.second', select: 'name avatarUrl title doNotDisplay' }
+        ]
       });
-    }
+      query.populate('vehicles.fund');
+
+      if (options.isWorkerProcess) {
+        query.populate('vehicles.investments');
+      }
+      else {
+        query.populate({
+          path: 'vehicles.investments',
+          match: { customer: options.CUSTOMER_ID }
+        });
+      }
 
-    query.exec().then(function(rounds) {if (!rounds || rounds.length === 0) return cb(null, []);
+      const rounds = await query;
+      if (!rounds || rounds.length === 0) return cb(null, []);
 
       let error = checkForUnpopulatedData(rounds, 'Round.getPortfolioByFunds');
       if (error) return cb(error, null);
@@ -676,18 +682,17 @@ module.exports = function(mongoose, config) {
       }
 
       return cb(null, buildPortfolio(rounds, fundIds));
-
-    }).catch(function(err) { cb(err); });
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Round.statics.getPortfolioList = function getPortfolioList(fundIds, options, cb) {
+  Round.statics.getPortfolioList = async function getPortfolioList(fundIds, options, cb) {
 
     // Returns a list of orgs that have rounds participated in by the given fund ids
     // Note retrieving multiple funds does not calculate fund stats. Use getPortfolioByFund for that.
 
-    const self = this;
-
     if (!cb) { throw new Error('cb is required'); }
     if (!fundIds) { throw new Error('fundIds is required'); }
     if (!options) { return cb(new Error('options is required'), null); }
@@ -696,16 +701,21 @@ module.exports = function(mongoose, config) {
 
     options = helpers.getDefaultOptions(options);
 
-    let query = self.find({ 'vehicles.fund': { $in: fundIds } });
+    try {
+      let query = this.find({ 'vehicles.fund': { $in: fundIds } });
 
-    query.select('organization vehicles');
-    query.populate('organization', 'name website status ipo operating people');
+      query.select('organization vehicles');
+      query.populate('organization', 'name website status ipo operating people');
+      query.lean({ virtuals: true });
 
-    query.exec().then(function(rounds) {if (!rounds || rounds.length === 0) return cb(null, []);
+      const rounds = await query;
+      if (!rounds || rounds.length === 0) {
+        process.nextTick(function() { cb(null, []); });
+        return;
+      }
 
       if (!options.isWorkerProcess) {
         _.each(rounds, function(round) {
-          round.organization = round.organization.toObject({ virtuals: true });
           round = helpers.cleanRound(round, fundIds, options.CUSTOMER_ID);
           round.organization = helpers.cleanOrg(round.organization, options.CUSTOMER_ID);
         });
@@ -715,7 +725,7 @@ module.exports = function(mongoose, config) {
       const grouped = _.groupBy(rounds, function(r) { return r.organization._id; });
 
       _.each(grouped, function(rounds) {
-          
+
         var fundList = _.uniq(_.flatten(_.map(rounds, function(round) {
           return round.vehicles ? _.map(round.vehicles, function(vehicle) { return vehicle.fund.toString(); }) : [];
         })));
@@ -734,13 +744,14 @@ module.exports = function(mongoose, config) {
 
       portfolio = _.sortBy(portfolio, function(p) { return p.name.toLowerCase(); });
 
-      return cb(null, portfolio);
-
-    }).catch(function(err) { cb(err); });
+      process.nextTick(function() { cb(null, portfolio); });
+    } catch(err) {
+      process.nextTick(function() { cb(err); });
+    }
 
   };
 
-  Round.statics.removeInvestment = function(investmentId, cb) {
+  Round.statics.removeInvestment = async function(investmentId, cb) {
 
     // Do not call this directly. It will leave an orphaned investment document.
     // The preferred way to delete an investment is to delete it directly and this
@@ -750,48 +761,42 @@ module.exports = function(mongoose, config) {
     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); }
 
-    const self = this;
-
-    let getRounds = function getRounds(callback) {
-      let query = self.find({ 'vehicles.investments': investmentId });
+    try {
+      let query = this.find({ 'vehicles.investments': investmentId });
       query.select('_id');
-      query.exec().then(function(result) { callback(null, result); }).catch(function(err) { callback(err); });
-    };
+      const rounds = await query;
 
-    let updateRounds = function updateRounds(previous, callback) {
-      let query = self.updateMany(
+      let updateQuery = this.updateMany(
         { 'vehicles.investments': investmentId },
-        { $pull : { 'vehicles.$.investments': investmentId } },
-        { multi : true }
+        { $pull : { 'vehicles.$.investments': investmentId } }
       );
-      query.exec().then(function(result) { callback(null, result); }).catch(function(err) { callback(err); });
-    };
+      const result = await updateQuery;
 
-    async.waterfall([
-      getRounds,
-      updateRounds
-    ], cb);
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Round.statics.removeVehicle = function(roundId, fundId, cb) {
-
-    const self = this;
-
-    self
-      .findOneAndUpdate(
-        { '_id': roundId },
-        { $pull : { 'vehicles': { 'fund': fundId } } },
-        { multi : false }
-      )
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+  Round.statics.removeVehicle = async function(roundId, fundId, cb) {
+
+    try {
+      const result = await this
+        .findOneAndUpdate(
+          { '_id': roundId },
+          { $pull : { 'vehicles': { 'fund': fundId } } },
+          { multi : false }
+        );
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Round.statics.getRelated = function getRelated(orgid, options, cb) {
+  Round.statics.getRelated = async 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'); }
@@ -805,109 +810,97 @@ module.exports = function(mongoose, config) {
     var customerFunds = options.customerFunds;
     if (!customerFunds) {
       const Fund = mongoose.model('Fund');
-      return Fund.findByCustomer(options.CUSTOMER_ID, function(err, funds) {
+      return Fund.findByCustomer(options.CUSTOMER_ID, (err, funds) => {
         if (err) return cb(err);
         options.customerFunds = funds;
-        return self.getRelated(orgid, options, cb);
+        return this.getRelated(orgid, options, cb);
       });
     }
 
-    async.parallel([
-      
+    try {
       // 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().then(function(result) { callback(null, result); }).catch(function(err) { callback(err); });
-      },
-      
+      const acquirees = await 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');
+
       // 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().then(function(result) { callback(null, result); }).catch(function(err) { callback(err); });
-      },
-      
+      const merged = await 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');
+
       // Find organizations that acquired this org (acquirers) or merged with this org
-      function(callback) {
-        Organization
-          .findById(orgid)
-          .select('operating')
-          .exec().then(function(mainOrg) {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);
-                  }
-                });
+      const mainOrg = await Organization
+        .findById(orgid)
+        .select('operating');
+
+      let reverseRelated = [];
+      if (mainOrg) {
+        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.merged.public && mainOrg.operating.merged.public.with) {
-                relatedIds.push(mainOrg.operating.merged.public.with);
+            });
+          }
+
+          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 (relatedIds.length === 0) return callback(null, []);
-            
-            Organization
-              .find({
-                '_id': { $in: relatedIds },
-                'deleted': { $ne: true }
-              })
-              .select('name logoUrl')
-              .exec().then(function(result) { callback(null, result); }).catch(function(err) { callback(err); });
-          }).catch(function(err) { callback(err); });
+            });
+          }
+
+          if (mainOrg.operating.merged.public && mainOrg.operating.merged.public.with) {
+            relatedIds.push(mainOrg.operating.merged.public.with);
+          }
+        }
+
+        if (relatedIds.length > 0) {
+          reverseRelated = await Organization
+            .find({
+              '_id': { $in: relatedIds },
+              'deleted': { $ne: true }
+            })
+            .select('name logoUrl');
+        }
       }
-      
-    ], function(err, results) {
-      if (err) return cb(err);
-      
+
       // Flatten and combine all results
       var allResults = [];
-      results.forEach(function(resultSet) {
+      [acquirees, merged, reverseRelated].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());
@@ -916,11 +909,10 @@ module.exports = function(mongoose, config) {
       });
 
       // Now get rounds for each related organization
-      async.map(uniqueResults, function(org, mapCallback) {
-        
+      const relatedWithRounds = await Promise.all(uniqueResults.map(async (org) => {
         var fundIds = customerFunds.map(function(fund) { return fund._id; });
-        
-        self
+
+        let rounds = await this
           .find({
             'organization': org._id,
             'vehicles.fund': { $in: fundIds },
@@ -931,31 +923,37 @@ module.exports = function(mongoose, config) {
           .populate({
             path: 'vehicles.investments',
             match: { customer: options.CUSTOMER_ID }
-          })
-          .exec().then(function(rounds) {// 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 || []
-            });
-          }).catch(function(err) { mapCallback(err); });
-          
-      }, function(err, relatedWithRounds) {
-        if (err) return cb(err);
-        cb(null, relatedWithRounds);
-      });
-    });
+          });
+
+        // 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);
+          });
+        }
+
+        return {
+          org: org,
+          rounds: rounds || []
+        };
+      }));
+
+      return cb(null, relatedWithRounds);
+    } catch(err) {
+      return cb(err);
+    }
   };
 
-  Round.statics.upsert = function(round, cb) {
+  Round.statics.upsert = async function(round, cb) {
 
     if (!round) { return cb(new Error('round is required'), null); }
-    round.save().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+
+    try {
+      const result = await round.save();
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
@@ -970,4 +968,4 @@ module.exports = function(mongoose, config) {
 
   mongoose.model('Round', Round);
 
-};
+};