@dhyasama/totem-models 12.3.0 → 12.4.0

package/lib/Organization.js

@@ -5,7 +5,6 @@ module.exports = function(mongoose, config) {
   let
 
     _ = require('underscore'),
-    async = require('async'),
     utilities = require('@dhyasama/totem-utilities'),
     helpers = require('../helpers'),
     Schema = mongoose.Schema,
@@ -1040,30 +1039,30 @@ module.exports = function(mongoose, config) {
     Note.createForModel(this, organizationId, note, cb);
   };
 
-  Organization.statics.deleteNote = function(noteId, customerId, cb) {
+  Organization.statics.deleteNote = async function(noteId, customerId, cb) {
 
     // Delete the note itself along with any references
 
-    const self = this;
+    try {
+      await new Promise(function(resolve, reject) {
+        Note.delete(noteId, customerId, function(err, result) {
+          if (err) return reject(err);
+          resolve(result);
+        });
+      });
 
-    let removeReferences = function removeReferences(callback) {
-      self.updateMany({}, {
+      await this.updateMany({}, {
         $pull: { 'notes' : [noteId] }
-      }).then(function(result) { callback(null, result); }).catch(function(err) { callback(err); });
-    };
+      });
 
-    async.series([
-      Note.delete.bind(Note, noteId, customerId),
-      removeReferences
-    ], function(err, results) {
-      return cb(err, null);
-    });
+      return cb(null, null);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Organization.statics.findByDomains = function findByDomains(domains, options, cb) {
-
-    const self = this;
+  Organization.statics.findByDomains = async function findByDomains(domains, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!domains) { return cb(new Error('domains is required'), null); }
@@ -1099,34 +1098,38 @@ module.exports = function(mongoose, config) {
 
     domains = domains.concat(alternativeDomains);
 
-    let query = self.find({ $or: [ {'website': { $in : domains }}, {'websiteAliases': { $in : domains }} ], 'deleted': {$ne: true} });
+    try {
+      let query = this.find({ $or: [ {'website': { $in : domains }}, {'websiteAliases': { $in : domains }} ], 'deleted': {$ne: true} });
 
-    query.exec().then(function(orgs) {
+      const orgs = await query;
       if (!orgs) { return cb(null, []); }
 
+      let result = orgs;
       if (!options.isWorkerProcess) {
-        orgs = _.map(orgs, function(org) {
+        result = _.map(orgs, function(org) {
           return helpers.cleanOrg(org, options.CUSTOMER_ID);
         });
       }
 
-      return cb(null, orgs);
-
-    }).catch(function(err) { cb(err); });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Organization.statics.findByFunds = function findByFunds(fundids, cb) {
-    const self = this;
-    self
-      .find({ 'funds': { $in : fundids }, 'deleted': {$ne: true} })
-      .select('name logoUrl funds contact')
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+  Organization.statics.findByFunds = async function findByFunds(fundids, cb) {
+    try {
+      const result = await this
+        .find({ 'funds': { $in : fundids }, 'deleted': {$ne: true} })
+        .select('name logoUrl funds contact');
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
   };
 
-  Organization.statics.findByIdsUnpopulated = function findByIdsUnpopulated(ids, options, cb) {
-
-    const self = this;
+  Organization.statics.findByIdsUnpopulated = async function findByIdsUnpopulated(ids, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!ids) { return cb(new Error('ids is required'), null); }
@@ -1139,26 +1142,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); }
     }
 
-    self
-      .find({ '_id': { $in : ids }})
-      .exec().then(function(orgs) {
+    try {
+      const orgs = await this.find({ '_id': { $in : ids }});
       if (!orgs) { return cb(null, []); }
 
-        if (!options.isWorkerProcess) {
-          orgs = _.map(orgs, function(org) {
-            return helpers.cleanOrg(org, options.CUSTOMER_ID);
-          });
-        }
-
-        return cb(null, orgs);
+      let result = orgs;
+      if (!options.isWorkerProcess) {
+        result = _.map(orgs, function(org) {
+          return helpers.cleanOrg(org, options.CUSTOMER_ID);
+        });
+      }
 
-      }).catch(function(err) { cb(err); });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Organization.statics.findByIds = function findByIds(ids, options, cb) {
-
-    const self = this;
+  Organization.statics.findByIds = async function findByIds(ids, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!ids) { return cb(new Error('ids is required'), null); }
@@ -1166,98 +1168,112 @@ module.exports = function(mongoose, config) {
     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); }
 
-    self
-      .find({ '_id': { $in : ids }})
-      .populate({
-        path: 'people.person',
-        select: 'name avatarUrl title doNotDisplay sources',
-        populate: [
-          { path: 'sources.person', select: 'name avatarUrl title doNotDisplay' }
-        ]
-      })
-      .populate('related', 'name logoUrl')
-      .populate('chairs.first', 'name avatarUrl title')
-      .populate('chairs.second', 'name avatarUrl title')
-      .populate('funds', 'name hexColorCode abbreviation')
-      .exec().then(function(orgs) {
+    try {
+      const orgs = await this
+        .find({ '_id': { $in : ids }})
+        .populate({
+          path: 'people.person',
+          select: 'name avatarUrl title doNotDisplay sources',
+          populate: [
+            { path: 'sources.person', select: 'name avatarUrl title doNotDisplay' }
+          ]
+        })
+        .populate('related', 'name logoUrl')
+        .populate('chairs.first', 'name avatarUrl title')
+        .populate('chairs.second', 'name avatarUrl title')
+        .populate('funds', 'name hexColorCode abbreviation');
       if (!orgs) { return cb(null, []); }
 
-        orgs = _.map(orgs, function(org) {
-          return helpers.cleanOrg(org, options.CUSTOMER_ID);
-        });
-
-        return cb(null, orgs);
+      const result = _.map(orgs, function(org) {
+        return helpers.cleanOrg(org, options.CUSTOMER_ID);
+      });
 
-      }).catch(function(err) { cb(err); });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Organization.statics.findByLimitedPartner = function findByLimitedPartner(lpid, options, cb) {
-
-    const self = this;
+  Organization.statics.findByLimitedPartner = async function findByLimitedPartner(lpid, options, cb) {
 
     options = helpers.getDefaultOptions(options);
 
     if (options.role === 'none') { return cb(new Error('Access denied'), null); }
 
-    self
-      .find({ 'lps': lpid, 'deleted': {$ne: true} })
-      .select('name logoUrl')
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this
+        .find({ 'lps': lpid, 'deleted': {$ne: true} })
+        .select('name logoUrl');
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Organization.statics.findByPerson = function findByPerson(personId, cb) {
+  Organization.statics.findByPerson = async function findByPerson(personId, cb) {
 
     // Given a person id, get all organizations with that person
 
-    const self = this;
-
     if (!cb) { throw new Error('cb is required'); }
     if (!personId) { return cb(new Error('ids is required'), null); }
     if (!mongoose.Types.ObjectId.isValid(personId)) { return cb(new Error('personId is not a valid ObjectId'), null); }
 
-    self
-      .find({ $or:
-          [
-            { 'people.person': personId },
-            { 'chairs.first': personId },
-            { 'chairs.second': personId }
-          ],
-        'deleted': { $ne: true }
-      })
-      .select('-sources -customer')
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this
+        .find({ $or:
+            [
+              { 'people.person': personId },
+              { 'chairs.first': personId },
+              { 'chairs.second': personId }
+            ],
+          'deleted': { $ne: true }
+        })
+        .select('-sources -customer');
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Organization.statics.getByPersonIds = function getByPersonIds(personIds, cb) {
-
-    const self = this;
+  Organization.statics.getByPersonIds = async function getByPersonIds(personIds, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!personIds) { return cb(new Error('personIds is required'), null); }
 
-    self
-      .find({'people.person':  { $in : personIds } })
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.find({'people.person':  { $in : personIds } });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Organization.statics.findBySlug = function findBySlug(slug, cb) {
-    this.findOne({ slug: slug, 'deleted': {$ne: true} }).exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+  Organization.statics.findBySlug = async function findBySlug(slug, cb) {
+    try {
+      const result = await this.findOne({ slug: slug, 'deleted': {$ne: true} });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
   };
 
-  Organization.statics.findBySlugs = function findBySlugs(slugs, cb) {
-    this.find({ 'slug': { $in : slugs } }).exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+  Organization.statics.findBySlugs = async function findBySlugs(slugs, cb) {
+    try {
+      const result = await this.find({ 'slug': { $in : slugs } });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
   };
 
-  Organization.statics.findBySocial2 = function findBySocial2(value, options, cb) {
+  Organization.statics.findBySocial2 = async function findBySocial2(value, options, cb) {
 
     // Extract stand-alone username and append it to our standardized domains
 
-    const self = this;
-
     if (!cb) { throw new Error('cb is required'); }
     if (!value) { return cb(new Error('value is required'), null); }
     if (!options) { return cb(new Error('options is required'), null); }
@@ -1270,71 +1286,73 @@ module.exports = function(mongoose, config) {
 
     if (!username) { return cb(null, []); }
 
-    self.aggregate([
-      {
-        "$search": {
-          index: 'organizations_search_autocomplete',
-          compound: {
-            should: [
-              {
-                autocomplete: {
-                  query: username,
-                  path: 'social_handle.facebook',
-                  fuzzy: {
-                    maxEdits: defaultMaxEdits,
-                    maxExpansions: defaultMaxExpansions
+    try {
+      const orgs = await this.aggregate([
+        {
+          "$search": {
+            index: 'organizations_search_autocomplete',
+            compound: {
+              should: [
+                {
+                  autocomplete: {
+                    query: username,
+                    path: 'social_handle.facebook',
+                    fuzzy: {
+                      maxEdits: defaultMaxEdits,
+                      maxExpansions: defaultMaxExpansions
+                    }
                   }
-                }
-              },
-              {
-                autocomplete: {
-                  query: username,
-                  path: 'social_handle.linkedin',
-                  fuzzy: {
-                    maxEdits: defaultMaxEdits,
-                    maxExpansions: defaultMaxExpansions
+                },
+                {
+                  autocomplete: {
+                    query: username,
+                    path: 'social_handle.linkedin',
+                    fuzzy: {
+                      maxEdits: defaultMaxEdits,
+                      maxExpansions: defaultMaxExpansions
+                    }
                   }
-                }
-              },
-              {
-                autocomplete: {
-                  query: username,
-                  path: 'social_handle.twitter',
-                  fuzzy: {
-                    maxEdits: defaultMaxEdits,
-                    maxExpansions: defaultMaxExpansions
+                },
+                {
+                  autocomplete: {
+                    query: username,
+                    path: 'social_handle.twitter',
+                    fuzzy: {
+                      maxEdits: defaultMaxEdits,
+                      maxExpansions: defaultMaxExpansions
+                    }
                   }
                 }
-              }
-            ],
-            must: [
-              {
-                equals: {
-                  path: 'deleted',
-                  value: false
+              ],
+              must: [
+                {
+                  equals: {
+                    path: 'deleted',
+                    value: false
+                  }
                 }
-              }
-            ],
-            minimumShouldMatch: 1
+              ],
+              minimumShouldMatch: 1
+            }
           }
         }
-      }
-    ]).exec().then(function(orgs) {orgs = _.map(orgs, function(org) {
+      ]);
+
+      const result = _.map(orgs, function(org) {
         return helpers.cleanOrg(org, options.CUSTOMER_ID);
       });
 
-      return cb(null, orgs);
-
-    }).catch(function(err) { cb(err); });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Organization.statics.findBySocial = function findBySocial(value, options, cb) {
+  Organization.statics.findBySocial = async function findBySocial(value, options, cb) {
 
     // Extract stand-alone username and append it to our standardized domains
 
-    const self = this;
-
     if (!cb) { throw new Error('cb is required'); }
     if (!value) { return cb(new Error('value is required'), null); }
     if (!options) { return cb(new Error('options is required'), null); }
@@ -1345,33 +1363,34 @@ module.exports = function(mongoose, config) {
 
     if (!username) { return cb(null, []); }
 
-    self
-      .find({ $or:
-          [
-            { 'social.facebook': new RegExp('facebook.com/' + username + '\/?$', 'i') },
-            { 'social.linkedin': new RegExp('linkedin.com/company/' + username + '\/?$', 'i') },
-            { 'social.twitter': new RegExp('twitter.com/' + username + '\/?$', 'i') },
-            { 'crunchbase.url': new RegExp('crunchbase.com/organization/' + username + '\/?$', 'i') },
-            { 'pitchbook.url': new RegExp('pitchbook.com/company/' + username + '\/?$', 'i') },
-          ],
-        'deleted': { $ne: true }
-      })
-      .exec().then(function(orgs) {orgs = _.map(orgs, function(org) {
-          return helpers.cleanOrg(org, options.CUSTOMER_ID);
+    try {
+      const orgs = await this
+        .find({ $or:
+            [
+              { 'social.facebook': new RegExp('facebook.com/' + username + '\/?$', 'i') },
+              { 'social.linkedin': new RegExp('linkedin.com/company/' + username + '\/?$', 'i') },
+              { 'social.twitter': new RegExp('twitter.com/' + username + '\/?$', 'i') },
+              { 'crunchbase.url': new RegExp('crunchbase.com/organization/' + username + '\/?$', 'i') },
+              { 'pitchbook.url': new RegExp('pitchbook.com/company/' + username + '\/?$', 'i') },
+            ],
+          'deleted': { $ne: true }
         });
 
-        return cb(null, orgs);
+      const result = _.map(orgs, function(org) {
+        return helpers.cleanOrg(org, options.CUSTOMER_ID);
+      });
 
-      }).catch(function(err) { cb(err); });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Organization.statics.findBySocials = function findBySocials(values, options, cb) {
+  Organization.statics.findBySocials = async function findBySocials(values, options, cb) {
 
     // Extract usernames and append it to our standardized domains
 
-    const self = this;
-
     if (!cb) { throw new Error('cb is required'); }
     if (!values) { return cb(new Error('values is required'), null); }
     if (!options) { return cb(new Error('options is required'), null); }
@@ -1384,37 +1403,49 @@ module.exports = function(mongoose, config) {
     let crunchbaseRegexes = _.map(values, function(value) { return new RegExp('crunchbase.com/organization/' + utilities.getUsernameFromUrl(value) + '\/?$', 'i') });
     let pitchbookRegexes = _.map(values, function(value) { return new RegExp('pitchbook.com/company/' + utilities.getUsernameFromUrl(value) + '\/?$', 'i') });
 
-    self
-      .find({ $or:
-          [
-            { 'social.facebook': {$in: facebookRegexes }},
-            { 'social.linkedin': {$in: linkedinRegexes }},
-            { 'social.twitter': {$in: twitterRegexes }},
-            { 'crunchbase.url': {$in: crunchbaseRegexes }},
-            { 'pitchbook.url': {$in: pitchbookRegexes }}
-          ],
-        'deleted': { $ne: true }
-      }).exec().then(function(orgs) {orgs = _.map(orgs, function(org) {
+    try {
+      const orgs = await this
+        .find({ $or:
+            [
+              { 'social.facebook': {$in: facebookRegexes }},
+              { 'social.linkedin': {$in: linkedinRegexes }},
+              { 'social.twitter': {$in: twitterRegexes }},
+              { 'crunchbase.url': {$in: crunchbaseRegexes }},
+              { 'pitchbook.url': {$in: pitchbookRegexes }}
+            ],
+          'deleted': { $ne: true }
+        });
+
+      const result = _.map(orgs, function(org) {
         return helpers.cleanOrg(org, options.CUSTOMER_ID);
       });
 
-      return cb(null, orgs);
-
-    }).catch(function(err) { cb(err); });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Organization.statics.findByDocument = function findByDocument(id, cb) {
-    this.findOne({ 'documents': id }).exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+  Organization.statics.findByDocument = async function findByDocument(id, cb) {
+    try {
+      const result = await this.findOne({ 'documents': id });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
   };
 
-  Organization.statics.findByTotemUrl = function findByTotemUrl(url, cb) {
-    this.findOne({ 'customer.totemUrl': url }).exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+  Organization.statics.findByTotemUrl = async function findByTotemUrl(url, cb) {
+    try {
+      const result = await this.findOne({ 'customer.totemUrl': url });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
   };
 
-  Organization.statics.getAcquisitions = function getAcquisitions(orgid, options, cb) {
-
-    const self = this;
+  Organization.statics.getAcquisitions = async function getAcquisitions(orgid, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!orgid) { return cb(new Error('orgid is required'), null); }
@@ -1423,48 +1454,55 @@ module.exports = function(mongoose, config) {
     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); }
 
-    self
-      .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) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this
+        .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');
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
   };
 
-  Organization.statics.getBoardsOfPerson = function getBoardsOfPerson(personId, cb) {
-
-    var self = this;
-
-    self
-      .find({
-        'deleted': { $ne: true },
-        'people': {
-          $elemMatch: {
-            'person': personId,
-            'board': { $in: ['chairman', 'director', 'observer'] },
-            'current': true
+  Organization.statics.getBoardsOfPerson = async function getBoardsOfPerson(personId, cb) {
+
+    try {
+      const result = await this
+        .find({
+          'deleted': { $ne: true },
+          'people': {
+            $elemMatch: {
+              'person': personId,
+              'board': { $in: ['chairman', 'director', 'observer'] },
+              'current': true
+            }
           }
-        }
-      })
-      .select('name logoUrl people')
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+        })
+        .select('name logoUrl people');
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Organization.statics.getByFund = function getByFund(id, cb) {
-    var self = this;
-    self
-      .findOne({ 'funds': id, 'deleted': {$ne: true} })
-      .select('name logoUrl')
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+  Organization.statics.getByFund = async function getByFund(id, cb) {
+    try {
+      const result = await this
+        .findOne({ 'funds': id, 'deleted': {$ne: true} })
+        .select('name logoUrl');
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
   };
 
-  Organization.statics.getById = function getById(id, options, cb) {
-
-    const self = this;
+  Organization.statics.getById = async function getById(id, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!id) { return cb(new Error('id is required'), null); }
@@ -1478,59 +1516,63 @@ 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 lpPopulateOptions = { path: 'lps' };
-    if (!options.isWorkerProcess) { lpPopulateOptions.match = { customer: options.CUSTOMER_ID }; }
-
-    var dealPopulateOptions = { path: 'deals' };
-    if (!options.isWorkerProcess) { dealPopulateOptions.match = { customer: options.CUSTOMER_ID }; }
-
-    let query = self.findById(id);
-
-    query.populate('people.person', 'name avatarUrl title contact doNotDisplay');
-    query.populate('related', 'name logoUrl');
-    query.populate('chairs.first', 'name avatarUrl title');
-    query.populate('chairs.second', 'name avatarUrl title');
-    query.populate('funds', 'name shortName hexColorCode abbreviation closeDate');
-    query.populate('operating.acquired.public.by', 'name logoUrl');
-    query.populate('operating.acquired.private.by', 'name logoUrl');
-    query.populate('operating.merged.public.with', 'name logoUrl');
-    query.populate('operating.merged.private.with', 'name logoUrl');
-    dealPopulateOptions.populate = [
-      { path: 'source.person' },
-      { path: 'history.account' }
-    ];
-    query.populate(dealPopulateOptions);
-    query.populate('documents');
-
-    if (options.role !== 'none') {
-      lpPopulateOptions.populate = { path: 'transactions.fund', select: 'shortName' };
-      query.populate(lpPopulateOptions);
-    }
+    try {
+      let lpPopulateOptions = { path: 'lps' };
+      if (!options.isWorkerProcess) { lpPopulateOptions.match = { customer: options.CUSTOMER_ID }; }
+
+      var dealPopulateOptions = { path: 'deals' };
+      if (!options.isWorkerProcess) { dealPopulateOptions.match = { customer: options.CUSTOMER_ID }; }
+
+      let query = this.findById(id);
+
+      query.populate('people.person', 'name avatarUrl title contact doNotDisplay');
+      query.populate('related', 'name logoUrl');
+      query.populate('chairs.first', 'name avatarUrl title');
+      query.populate('chairs.second', 'name avatarUrl title');
+      query.populate('funds', 'name shortName hexColorCode abbreviation closeDate');
+      query.populate('operating.acquired.public.by', 'name logoUrl');
+      query.populate('operating.acquired.private.by', 'name logoUrl');
+      query.populate('operating.merged.public.with', 'name logoUrl');
+      query.populate('operating.merged.private.with', 'name logoUrl');
+      dealPopulateOptions.populate = [
+        { path: 'source.person' },
+        { path: 'history.account' }
+      ];
+      query.populate(dealPopulateOptions);
+      query.populate('documents');
+
+      if (options.role !== 'none') {
+        lpPopulateOptions.populate = { path: 'transactions.fund', select: 'shortName' };
+        query.populate(lpPopulateOptions);
+      }
 
-    query.exec().then(function(result) {if (options.isWorkerProcess) { return cb(null, result); }
+      const result = await query;
+      if (options.isWorkerProcess) { return cb(null, result); }
       else { return cb(null, helpers.cleanOrg(result, options.CUSTOMER_ID)); }
-
-    }).catch(function(err) { cb(err); });
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Organization.statics.getByIdSkinny = function getByIdSkinny(id, cb) {
-
-    const self = this;
+  Organization.statics.getByIdSkinny = async function getByIdSkinny(id, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!id) { return cb(new Error('id is required'), null); }
 
-    const query = self.findById(id);
-    query.select('name aliases website websiteAliases logoUrl');
+    try {
+      const query = this.findById(id);
+      query.select('name aliases website websiteAliases logoUrl');
 
-    return query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+      const result = await query;
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Organization.statics.getByIds = function getByIds(ids, options, cb) {
-
-    const self = this;
+  Organization.statics.getByIds = async function getByIds(ids, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!ids) { return cb(new Error('ids is required'), null); }
@@ -1543,19 +1585,20 @@ 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( {'_id': { $in : ids } } );
-    query.populate('documents');
+    try {
+      let query = this.find( {'_id': { $in : ids } } );
+      query.populate('documents');
 
-    query.exec().then(function(result) {if (options.isWorkerProcess) { return cb(null, result); }
+      const result = await query;
+      if (options.isWorkerProcess) { return cb(null, result); }
       else { return cb(null, _.map(result, function(r) { return helpers.cleanOrg(r, options.CUSTOMER_ID) })) }
-
-    }).catch(function(err) { cb(err); });
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Organization.statics.getChairsOfPerson = function getChairsOfPerson(personId, options, cb) {
-
-    const self = this;
+  Organization.statics.getChairsOfPerson = async function getChairsOfPerson(personId, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!personId) { return cb(new Error('personId is required'), null); }
@@ -1564,27 +1607,28 @@ module.exports = function(mongoose, config) {
     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); }
 
-    self
-      .find({ $or:
-          [
-            { 'chairs.first': personId },
-            { 'chairs.second': personId }
-          ],
-        'deleted': { $ne: true }
-      })
-      .exec().then(function(orgs) {orgs = _.map(orgs, function(org) {
-          return helpers.cleanOrg(org, options.CUSTOMER_ID);
+    try {
+      const orgs = await this
+        .find({ $or:
+            [
+              { 'chairs.first': personId },
+              { 'chairs.second': personId }
+            ],
+          'deleted': { $ne: true }
         });
 
-        return cb(null, orgs);
+      const result = _.map(orgs, function(org) {
+        return helpers.cleanOrg(org, options.CUSTOMER_ID);
+      });
 
-      }).catch(function(err) { cb(err); });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Organization.statics.getDocumentsForOrgs = function getDocumentsForOrgs(orgIds, customerId, startDate, endDate, options, cb) {
-
-    const self = this;
+  Organization.statics.getDocumentsForOrgs = async function getDocumentsForOrgs(orgIds, customerId, startDate, endDate, options, cb) {
 
     if (!cb) {
       throw new Error('cb is required');
@@ -1605,30 +1649,31 @@ module.exports = function(mongoose, config) {
       return cb(new Error('endDate is required'), null);
     }
 
-    let query = self
-      .find( {'_id': { $in : orgIds } } )
-      .select('_id documents')
-      .populate({
-        path: 'documents',
-        match: {
-          customer: customerId,
-          createdOn: { $gte: startDate, $lte: endDate }
-        },
-      })
+    try {
+      let query = this
+        .find( {'_id': { $in : orgIds } } )
+        .select('_id documents')
+        .populate({
+          path: 'documents',
+          match: {
+            customer: customerId,
+            createdOn: { $gte: startDate, $lte: endDate }
+          },
+        })
 
-    query.exec().then(function(result) {result = _.filter(result, function(org) {
+      const result = await query;
+      const filtered = _.filter(result, function(org) {
         return org.documents.length > 0;
       });
 
-      return cb(null, result);
-
-    }).catch(function(err) { cb(err); });
+      return cb(null, filtered);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Organization.statics.getValuationsForOrgs = function getValuationForOrgs(orgIds, customerId, startDate, endDate, options, cb) {
-
-    const self = this;
+  Organization.statics.getValuationsForOrgs = async function getValuationForOrgs(orgIds, customerId, startDate, endDate, options, cb) {
 
     if (!cb) {
       throw new Error('cb is required');
@@ -1649,23 +1694,24 @@ module.exports = function(mongoose, config) {
       return cb(new Error('endDate is required'), null);
     }
 
-    let query = self
-      .find( {'_id': { $in : orgIds } } )
-      .select('_id valuations');
+    try {
+      let query = this
+        .find( {'_id': { $in : orgIds } } )
+        .select('_id valuations');
 
-    query.exec().then(function(orgs) {orgs = _.map(orgs, function(org) {
+      const orgs = await query;
+      const result = _.map(orgs, function(org) {
         return helpers.cleanOrg(org, customerId);
       });
 
-      return cb(null, orgs);
-
-    }).catch(function(err) { cb(err); });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Organization.statics.getNotesForOrgs = function getNotesForOrgs(orgIds, customerId, startDate, endDate, options, cb) {
-
-    const self = this;
+  Organization.statics.getNotesForOrgs = async function getNotesForOrgs(orgIds, customerId, startDate, endDate, options, cb) {
 
     if (!cb) {
       throw new Error('cb is required');
@@ -1686,46 +1732,49 @@ module.exports = function(mongoose, config) {
       return cb(new Error('endDate is required'), null);
     }
 
-    let query = self
-      .find( {'_id': { $in : orgIds } } )
-      .select('_id notes')
-      .populate({
-        path: 'notes',
-        match: {
-          customer: customerId,
-          createdOn: { $gte: startDate, $lte: endDate }
-        },
-        populate: {
-          path: 'createdBy',
-          select: 'name avatarUrl'
-        }
-      })
+    try {
+      let query = this
+        .find( {'_id': { $in : orgIds } } )
+        .select('_id notes')
+        .populate({
+          path: 'notes',
+          match: {
+            customer: customerId,
+            createdOn: { $gte: startDate, $lte: endDate }
+          },
+          populate: {
+            path: 'createdBy',
+            select: 'name avatarUrl'
+          }
+        })
 
-    query.exec().then(function(result) {result = _.filter(result, function(org) {
+      const result = await query;
+      const filtered = _.filter(result, function(org) {
         return org.notes.length > 0;
       });
 
-      return cb(null, result);
-
-    }).catch(function(err) { cb(err); });
+      return cb(null, filtered);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Organization.statics.getList = function getList(cb) {
+  Organization.statics.getList = async function getList(cb) {
 
-    const self = this;
-
-    self
-      .find({'deleted': {$ne: true}})
-      .select('name website websiteAliases')
-      .lean()
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this
+        .find({'deleted': {$ne: true}})
+        .select('name website websiteAliases')
+        .lean();
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Organization.statics.getLpOrgs = function getLpOrgs(lpids, options, cb) {
-
-    const self = this;
+  Organization.statics.getLpOrgs = async function getLpOrgs(lpids, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!lpids) { return cb(new Error('lpids is required'), null); }
@@ -1733,27 +1782,27 @@ module.exports = function(mongoose, config) {
     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); }
 
-    let query = self.find({ 'lps': { $in : lpids }, 'deleted': {$ne: true} });
+    try {
+      let query = this.find({ 'lps': { $in : lpids }, 'deleted': {$ne: true} });
 
-    query.select('name logoUrl lps');
-    query.populate('lps', 'name customer');
+      query.select('name logoUrl lps');
+      query.populate('lps', 'name customer');
 
-    query.exec().then(function(orgs) {
+      const orgs = await query;
       if (!orgs) { return cb(null, []); }
 
-      orgs = _.map(orgs, function(org) {
+      const result = _.map(orgs, function(org) {
         return helpers.cleanOrg(org, options.CUSTOMER_ID);
       });
 
-      return cb(null, orgs);
-
-    }).catch(function(err) { cb(err); });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Organization.statics.getNotes = function getNotes(orgid, options, cb) {
-
-    const self = this;
+  Organization.statics.getNotes = async function getNotes(orgid, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!orgid) { return cb(new Error('orgid is required'), null); }
@@ -1762,34 +1811,34 @@ module.exports = function(mongoose, config) {
     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); }
 
-    let query = self.findById(orgid);
+    try {
+      let query = this.findById(orgid);
 
-    query.select('notes people.person');
-    query.populate({
-      path: 'people.person',
-      select: 'name avatarUrl title'
-    });
-    query.populate({
-      path: 'notes',
-      match: { customer: options.CUSTOMER_ID },
-      populate: { path: 'createdBy', select: 'name avatarUrl title' }
-    });
-    query.sort({'createdOn':-1});
+      query.select('notes people.person');
+      query.populate({
+        path: 'people.person',
+        select: 'name avatarUrl title'
+      });
+      query.populate({
+        path: 'notes',
+        match: { customer: options.CUSTOMER_ID },
+        populate: { path: 'createdBy', select: 'name avatarUrl title' }
+      });
+      query.sort({'createdOn':-1});
 
-    query.exec().then(function(org) {
+      const org = await query;
       if (!org) { return cb(null, []); }
 
-      org = helpers.cleanOrg(org, options.CUSTOMER_ID);
-
-      return cb(null, org);
+      const result = helpers.cleanOrg(org, options.CUSTOMER_ID);
 
-    }).catch(function(err) { cb(err); });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Organization.statics.getSources = function(id, options, cb) {
-
-    const self = this;
+  Organization.statics.getSources = async function(id, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!id) { return cb(new Error('id is required'), null); }
@@ -1798,58 +1847,60 @@ module.exports = function(mongoose, config) {
     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); }
 
-    let query = self.findById(id);
-    query.select('people');
-    query.populate({
-      path: 'people.person',
-      select: 'name avatarUrl title doNotDisplay sources',
-      populate: { path: 'sources.person', select: 'name avatarUrl title doNotDisplay' }
-    });
+    try {
+      let query = this.findById(id);
+      query.select('people');
+      query.populate({
+        path: 'people.person',
+        select: 'name avatarUrl title doNotDisplay sources',
+        populate: { path: 'sources.person', select: 'name avatarUrl title doNotDisplay' }
+      });
 
-    // get the org requested
-    query.exec().then(function(org) {if (!org) { return cb(null, null); }
+      // get the org requested
+      const org = await query;
+      if (!org) { return cb(null, null); }
 
       // get the customer requesting org
-      self.findById(options.CUSTOMER_ID).then(function(customer) {if (!customer) { return cb(null, null); }
-
-        let current = [];
-        let past = [];
-        let all = [];
-
-        // combined list of sources from each person at org
-        let orgSources = helpers.getPeopleSources(_.pluck(org.people, 'person'));
-
-        // loop through customer's people and categorize sources
-        _.each(customer.people, function(p) {
+      const customer = await this.findById(options.CUSTOMER_ID);
+      if (!customer) { return cb(null, null); }
 
-          var source = _.find(orgSources, function(os) {
-            if (!os || !os.person || !os.person._id) return false;
-            return os.person._id.toString() === p.person.toString();
-          });
+      let current = [];
+      let past = [];
+      let all = [];
 
-          if (!source) return;
+      // combined list of sources from each person at org
+      let orgSources = helpers.getPeopleSources(_.pluck(org.people, 'person'));
 
-          if (p.current) current.push(source);
-          if (!p.current) past.push(source);
-          all.push(source);
+      // loop through customer's people and categorize sources
+      _.each(customer.people, function(p) {
 
+        var source = _.find(orgSources, function(os) {
+          if (!os || !os.person || !os.person._id) return false;
+          return os.person._id.toString() === p.person.toString();
         });
 
-        // todo - fix sorting
-        // return categorized sources
-        return cb(null, {
-          all: all, //helpers.sortPeopleSources(all, options.CUSTOMER_ID),
-          current: current, //helpers.sortPeopleSources(current, options.CUSTOMER_ID),
-          past: past //helpers.sortPeopleSources(past, options.CUSTOMER_ID)
-        });
+        if (!source) return;
 
-      }).catch(function(err) { cb(err); });
+        if (p.current) current.push(source);
+        if (!p.current) past.push(source);
+        all.push(source);
 
-    }).catch(function(err) { cb(err); });
+      });
+
+      // todo - fix sorting
+      // return categorized sources
+      return cb(null, {
+        all: all, //helpers.sortPeopleSources(all, options.CUSTOMER_ID),
+        current: current, //helpers.sortPeopleSources(current, options.CUSTOMER_ID),
+        past: past //helpers.sortPeopleSources(past, options.CUSTOMER_ID)
+      });
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Organization.statics.modify = function(filter, update, cb) {
+  Organization.statics.modify = async function(filter, update, cb) {
 
     // VERY IMPORTANT NOTE
     // findByIdAndUpdate and findOneAndUpdate do not trigger pre-save hook so that code will not run here
@@ -1859,17 +1910,20 @@ module.exports = function(mongoose, config) {
     if (!filter) { return cb(new Error('filter is required'), null); }
     if (!update) { return cb(new Error('update is required'), null); }
 
-    var self = this;
-
     // https://mongoosejs.com/docs/api.html#model_Model.findOneAndUpdate
     // options runValidators defaults false which is ok since we have upsert false
     // new returns the updated document
 
-    self.findOneAndUpdate(filter, update, { upsert: false, new: true }).then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.findOneAndUpdate(filter, update, { upsert: false, new: true });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Organization.statics.modifyById = function(id, update, cb) {
+  Organization.statics.modifyById = async function(id, update, cb) {
 
     // VERY IMPORTANT NOTE
     // findByIdAndUpdate and findOneAndUpdate do not trigger pre-save hook so that code will not run here
@@ -1880,41 +1934,46 @@ module.exports = function(mongoose, config) {
     if (!mongoose.Types.ObjectId.isValid(id)) { return cb(new Error('id is not a valid ObjectId'), null); }
     if (!update) { return cb(new Error('update is required'), null); }
 
-    var self = this;
-
     // https://mongoosejs.com/docs/api.html#model_Model.findOneAndUpdate
     // options runValidators defaults false which is ok since we have upsert false
     // new returns the updated document
 
-    self.findByIdAndUpdate(id, update, { upsert: false, new: true }).then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.findByIdAndUpdate(id, update, { upsert: false, new: true });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Organization.statics.removeCustomerFilters = function(customerId, cb) {
-
-    var self = this;
+  Organization.statics.removeCustomerFilters = async function(customerId, cb) {
 
-    self
-      .updateMany(
-        { 'filters.customer': customerId },
-        { $pull : { 'filters': { 'customer': customerId } } },
-        { multi : true }
-      )
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this
+        .updateMany(
+          { 'filters.customer': customerId },
+          { $pull : { 'filters': { 'customer': customerId } } }
+        );
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Organization.statics.removeCustomerValuations = function(customerId, cb) {
+  Organization.statics.removeCustomerValuations = async function(customerId, cb) {
 
-    var self = this;
-
-    self
-      .updateMany(
-        { 'valuations.customer': customerId },
-        { $pull : { 'valuations': { 'customer': customerId } } },
-        { multi : true }
-      )
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this
+        .updateMany(
+          { 'valuations.customer': customerId },
+          { $pull : { 'valuations': { 'customer': customerId } } }
+        );
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
@@ -1959,7 +2018,7 @@ module.exports = function(mongoose, config) {
   //
   // };
 
-  Organization.statics.search = function search(data, options, cb) {
+  Organization.statics.search = async function search(data, options, cb) {
 
     // search for orgs based on fields provided
     // data format, each field is optional
@@ -2092,31 +2151,27 @@ module.exports = function(mongoose, config) {
 
     var query = buildQuery(data, options);
 
-    this
-      .find(query)
-      .populate('merged')
-      .select('logoUrl name description related website')
-      .exec().then(function(orgs) {
+    try {
+      let orgs = await this
+        .find(query)
+        .populate('merged')
+        .select('logoUrl name description related website');
       if (!orgs) return cb(null, null);
-        else {
-
-          // remove related from top level
-          if (options.removeRelatedFromTopLevel) orgs = removeRelatedFromTopLevel(orgs);
 
-          // sort by name
-          orgs = _.sortBy(orgs, function(orgs) { return orgs.name; });
+      // remove related from top level
+      if (options.removeRelatedFromTopLevel) orgs = removeRelatedFromTopLevel(orgs);
 
-          return cb(null, orgs);
+      // sort by name
+      orgs = _.sortBy(orgs, function(orgs) { return orgs.name; });
 
-        }
-
-      }).catch(function(err) { cb(err); });
+      return cb(null, orgs);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Organization.statics.search2 = function search2(value, options, cb) {
-
-    const self = this;
+  Organization.statics.search2 = async function search2(value, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!value) { return cb(new Error('value is required'), null); }
@@ -2140,66 +2195,70 @@ module.exports = function(mongoose, config) {
       'stakeholders'
     ];
 
-    self.aggregate([
-      {
-        "$search": {
-          index: 'default',
-          compound: {
-            should: [
-              {
-                text: {
-                  query: value,
-                  path: path
-                }
-              },
-              {
-                autocomplete: {
-                  query: value,
-                  path: 'name'
-                }
-              },
-              {
-                autocomplete: {
-                  query: value,
-                  path: 'aliases'
+    try {
+      const orgs = await this.aggregate([
+        {
+          "$search": {
+            index: 'default',
+            compound: {
+              should: [
+                {
+                  text: {
+                    query: value,
+                    path: path
+                  }
+                },
+                {
+                  autocomplete: {
+                    query: value,
+                    path: 'name'
+                  }
+                },
+                {
+                  autocomplete: {
+                    query: value,
+                    path: 'aliases'
+                  }
                 }
-              }
-            ],
-            must: [
-              {
-                equals: {
-                  path: 'deleted',
-                  value: false
+              ],
+              must: [
+                {
+                  equals: {
+                    path: 'deleted',
+                    value: false
+                  }
                 }
-              }
-            ],
-            minimumShouldMatch: 1
+              ],
+              minimumShouldMatch: 1
+            }
+          }
+        },
+        {
+          $limit: options.limit,
+        },
+        {
+          $project: {
+            name: 1,
+            logoUrl: 1,
+            website: 1,
+            websiteAliases: 1,
+            score: { $meta: "searchScore" }
           }
         }
-      },
-      {
-        $limit: options.limit,
-      },
-      {
-        $project: {
-          name: 1,
-          logoUrl: 1,
-          website: 1,
-          websiteAliases: 1,
-          score: { $meta: "searchScore" }
-        }
-      }
-    ]).exec().then(function(orgs) {orgs = _.map(orgs, function(org) {
+    ]);
+
+      const result = _.map(orgs, function(org) {
         return helpers.cleanOrg(org, options.CUSTOMER_ID);
       });
 
-      return cb(null, orgs);
-
-    }).catch(function(err) { cb(err); });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Organization.statics.upsert = function(org, username, cb) {
+  Organization.statics.upsert = async function(org, username, cb) {
 
     if (!org) { return cb(new Error('Organization is required'), null); }
     if (!username) { return cb(new Error('Username is required'), null); }
@@ -2210,7 +2269,12 @@ module.exports = function(mongoose, config) {
     // Clean up missing references
     //org.people = _.reject(org.people, function(item) { return !item.person; });
 
-    org.save().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await org.save();
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };