@dhyasama/totem-models 12.3.0 → 12.4.0

package/lib/LimitedPartner.js

@@ -8,7 +8,6 @@ module.exports = function(mongoose, config) {
     Note = mongoose.model('Note'),
     Organization = mongoose.model('Organization'),
     _ = require('underscore'),
-    async = require('async'),
     helpers = require('../helpers');
 
   let LimitedPartner = new Schema({
@@ -331,30 +330,23 @@ module.exports = function(mongoose, config) {
     Note.createForModel(this, lpId, note, cb);
   };
 
-  LimitedPartner.statics.deleteNote = function(noteId, customerId, cb) {
+  LimitedPartner.statics.deleteNote = async function(noteId, customerId, cb) {
 
     // Delete the note itself along with any references
 
-    const self = this;
-
-    let removeReferences = function removeReferences(callback) {
-      self.updateOne({}, {
+    try {
+      await Note.delete(noteId, customerId);
+      await this.updateOne({}, {
         $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);
+    }
 
   };
 
-  LimitedPartner.statics.getById = function(id, options, cb) {
-
-    const self = this;
+  LimitedPartner.statics.getById = async function(id, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!id) { return cb(new Error('id is required'), null); }
@@ -365,28 +357,29 @@ module.exports = function(mongoose, config) {
 
     options = helpers.getDefaultOptions(options);
 
-    let query;
+    try {
+      let query;
 
-    if (options.isWorkerProcess) {
-      query = self.findById(id, getReadFilterKeys(options.role))
-    }
-    else {
-      query = self.findOne({ '_id': id, customer: options.CUSTOMER_ID }, getReadFilterKeys(options.role));
-    }
+      if (options.isWorkerProcess) {
+        query = this.findById(id, getReadFilterKeys(options.role))
+      }
+      else {
+        query = this.findOne({ '_id': id, customer: options.CUSTOMER_ID }, getReadFilterKeys(options.role));
+      }
 
-    query.populate('transactions.fund');
-    query.populate({
-      path: 'people',
-      populate: { path: 'sources.person', select: 'name avatarUrl title' }
-    });
-    query.populate({
-      path: 'notes',
-      match: { customer: options.CUSTOMER_ID },
-      populate: { path: 'createdBy', select: 'name avatarUrl' }
-    });
-    query.populate('documents');
+      query.populate('transactions.fund');
+      query.populate({
+        path: 'people',
+        populate: { path: 'sources.person', select: 'name avatarUrl title' }
+      });
+      query.populate({
+        path: 'notes',
+        match: { customer: options.CUSTOMER_ID },
+        populate: { path: 'createdBy', select: 'name avatarUrl' }
+      });
+      query.populate('documents');
 
-    query.exec().then(function(lp) {
+      const lp = await query;
       if (!lp) { return cb(null, null); }
 
       lp.people = _.map(lp.people, function(person) {
@@ -409,13 +402,11 @@ module.exports = function(mongoose, config) {
 
       return cb(null, lp);
 
-    }).catch(function(err) { cb(err); });
+    } catch(err) { return cb(err); }
 
   };
 
-  LimitedPartner.statics.getByName = function(lpName, options, cb) {
-
-    const self = this;
+  LimitedPartner.statics.getByName = async function(lpName, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!options) { return cb(new Error('options is required'), null); }
@@ -424,24 +415,20 @@ module.exports = function(mongoose, config) {
 
     options = helpers.getDefaultOptions(options);
 
-    let query;
-
     if (!options.isWorkerProcess) {
       return cb(null, []);
     }
 
-    else {
-      query = self.findOne({'name': lpName, customer: options.CUSTOMER_ID }, getReadFilterKeys(options.role));
-    }
-
-    query.populate('transactions.fund');
-    query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      let query = this.findOne({'name': lpName, customer: options.CUSTOMER_ID }, getReadFilterKeys(options.role));
+      query.populate('transactions.fund');
+      const result = await query;
+      return cb(null, result);
+    } catch(err) { return cb(err); }
 
   };
 
-  LimitedPartner.statics.getByPersonId = function(personId, options, cb) {
-
-    const self = this;
+  LimitedPartner.statics.getByPersonId = async function(personId, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!personId) { return cb(new Error('personId is required'), null); }
@@ -452,30 +439,30 @@ 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); }
     }
-    
+
     options = helpers.getDefaultOptions(options);
 
-    let query;
+    try {
+      let query;
 
-    if (options.isWorkerProcess) {
-      query = self.find({'people': personId}, getReadFilterKeys(options.role));
-    }
-    else {
-      query = self.find({'people': personId, customer: options.CUSTOMER_ID }, getReadFilterKeys(options.role));
-    }
+      if (options.isWorkerProcess) {
+        query = this.find({'people': personId}, getReadFilterKeys(options.role));
+      }
+      else {
+        query = this.find({'people': personId, customer: options.CUSTOMER_ID }, getReadFilterKeys(options.role));
+      }
 
-    query.populate('transactions.fund');
-    query.populate('people', 'name');
+      query.populate('transactions.fund');
+      query.populate('people', 'name');
 
-    query.exec().then(function(lps) {lps = _.sortBy(lps, function(lp) { return lp.name ? lp.name.toLowerCase() : ''; });
+      let lps = await query;
+      lps = _.sortBy(lps, function(lp) { return lp.name ? lp.name.toLowerCase() : ''; });
       return cb(null, lps);
-    }).catch(function(err) { cb(err); });
+    } catch(err) { return cb(err); }
 
   };
 
-  LimitedPartner.statics.getByPersonIds = function(personIds, options, cb) {
-
-    const self = this;
+  LimitedPartner.statics.getByPersonIds = async function(personIds, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!personIds) { return cb(new Error('personIds is required'), null); }
@@ -488,24 +475,24 @@ module.exports = function(mongoose, config) {
 
     options = helpers.getDefaultOptions(options);
 
-    let query;
+    try {
+      let query;
 
-    if (options.isWorkerProcess) {
-      query = self.find({'people': { $in : personIds }}, getReadFilterKeys(options.role));
-    }
-    else {
-      query = self.find({'people': { $in : personIds }, customer: options.CUSTOMER_ID }, getReadFilterKeys(options.role));
-    }
+      if (options.isWorkerProcess) {
+        query = this.find({'people': { $in : personIds }}, getReadFilterKeys(options.role));
+      }
+      else {
+        query = this.find({'people': { $in : personIds }, customer: options.CUSTOMER_ID }, getReadFilterKeys(options.role));
+      }
 
-    query.exec().then(function(lps) {lps = _.sortBy(lps, function(lp) { return lp.name ? lp.name.toLowerCase() : ''; });
+      let lps = await query;
+      lps = _.sortBy(lps, function(lp) { return lp.name ? lp.name.toLowerCase() : ''; });
       return cb(null, lps);
-    }).catch(function(err) { cb(err); });
+    } catch(err) { return cb(err); }
 
   };
 
-  LimitedPartner.statics.getNotes = function getNotes(lpid, options, cb) {
-
-    const self = this;
+  LimitedPartner.statics.getNotes = async function getNotes(lpid, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!lpid) { return cb(new Error('lpid is required'), null); }
@@ -514,23 +501,24 @@ 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.findOne({ '_id': lpid, customer: options.CUSTOMER_ID });
+    try {
+      let query = this.findOne({ '_id': lpid, customer: options.CUSTOMER_ID });
 
-    query.select('notes people');
-    query.populate({
-      path: 'notes',
-      match: { customer: options.CUSTOMER_ID },
-      options: { sort: { createdOn: -1 } },
-      populate: { path: 'createdBy', select: 'name avatarUrl title' }
-    });
+      query.select('notes people');
+      query.populate({
+        path: 'notes',
+        match: { customer: options.CUSTOMER_ID },
+        options: { sort: { createdOn: -1 } },
+        populate: { path: 'createdBy', select: 'name avatarUrl title' }
+      });
 
-    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); }
 
   };
 
-  LimitedPartner.statics.getSources = function(lpid, options, cb) {
-
-    const self = this;
+  LimitedPartner.statics.getSources = async function(lpid, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!lpid) { return cb(new Error('lpid is required'), null); }
@@ -539,54 +527,53 @@ 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(lpid);
-
-    query.populate({
-      path: 'people',
-      select: 'name avatarUrl title doNotDisplay sources',
-      populate: { path: 'sources.person', select: 'name avatarUrl title doNotDisplay' }
-    });
+    try {
+      let query = this.findById(lpid);
 
-    query.exec().then(function(lp) {if (!lp) { return cb(null, null); }
+      query.populate({
+        path: 'people',
+        select: 'name avatarUrl title doNotDisplay sources',
+        populate: { path: 'sources.person', select: 'name avatarUrl title doNotDisplay' }
+      });
 
-      Organization.findById(options.CUSTOMER_ID).then(function(customer) {if (!customer) { return cb(null, null); }
+      const lp = await query;
+      if (!lp) { return cb(null, null); }
 
-        let current = [];
-        let past = [];
-        let all = [];
-        let lpSources = helpers.getPeopleSources(lp.people);
+      const customer = await Organization.findById(options.CUSTOMER_ID);
+      if (!customer) { return cb(null, null); }
 
-        _.each(customer.people, function(p) {
+      let current = [];
+      let past = [];
+      let all = [];
+      let lpSources = helpers.getPeopleSources(lp.people);
 
-          let source = _.find(lpSources, function(ls) {
-            if (!ls || !ls.person || !ls.person._id) return false;
-            return ls.person._id.toString() === p.person.toString();
-          });
+      _.each(customer.people, function(p) {
 
-          if (!source) { return; }
+        let source = _.find(lpSources, function(ls) {
+          if (!ls || !ls.person || !ls.person._id) return false;
+          return ls.person._id.toString() === p.person.toString();
+        });
 
-          if (p.current) { current.push(source); }
-          if (!p.current) { past.push(source); }
-          all.push(source);
+        if (!source) { return; }
 
-        });
+        if (p.current) { current.push(source); }
+        if (!p.current) { past.push(source); }
+        all.push(source);
 
-        // todo - fix sorting
-        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(function(err) { cb(err); });
+      // todo - fix sorting
+      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(function(err) { cb(err); });
+    } catch(err) { return cb(err); }
 
   };
 
-  LimitedPartner.statics.list = function (customerId, options, cb) {
-
-    const self = this;
+  LimitedPartner.statics.list = async function (customerId, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!customerId) { return cb(new Error('customerId is required'), null); }
@@ -595,19 +582,23 @@ module.exports = function(mongoose, config) {
 
     options = helpers.getDefaultOptions(options);
 
-    let query;
+    try {
+      let query;
 
-    if (options.isWorkerProcess) {
-      query = self.find({}, getReadFilterKeys(options.role));
-    }
-    else {
-      query = self.find({ 'transactions.fund': { $in : options.fundids }, customer: customerId }, getReadFilterKeys(options.role));
-    }
+      if (options.isWorkerProcess) {
+        query = this.find({}, getReadFilterKeys(options.role));
+      }
+      else {
+        query = this.find({ 'transactions.fund': { $in : options.fundids }, customer: customerId }, getReadFilterKeys(options.role));
+      }
+
+      query.populate('transactions.fund');
+      query.populate('people');
+      query.sort({ 'name': -1 });
 
-    query.populate('transactions.fund');
-    query.populate('people');
-    query.sort({ 'name': -1 });
-    query.exec().then(function(result) {if (options.fundids) {
+      const result = await query;
+
+      if (options.fundids) {
         _.each(result, function(lp) {
           lp.transactions = _.filter(lp.transactions, function(transaction) {
             return _.find(options.fundids, function(f) {
@@ -619,13 +610,11 @@ module.exports = function(mongoose, config) {
 
       return cb(null, result);
 
-    }).catch(function(err) { cb(err); });
+    } catch(err) { return cb(err); }
 
   };
 
-  LimitedPartner.statics.listByFund = function (fundId, options, cb) {
-
-    const self = this;
+  LimitedPartner.statics.listByFund = async function (fundId, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!fundId) { return cb(new Error('fundId is required'), null); }
@@ -636,15 +625,19 @@ module.exports = function(mongoose, config) {
 
     options = helpers.getDefaultOptions(options);
 
-    let query = self.find({ 'transactions.fund': fundId, customer: options.CUSTOMER_ID }, getReadFilterKeys(options.role));
+    try {
+      let query = this.find({ 'transactions.fund': fundId, customer: options.CUSTOMER_ID }, getReadFilterKeys(options.role));
+
+      query.populate('transactions.fund');
+      query.sort({ 'name': -1 });
 
-    query.populate('transactions.fund');
-    query.sort({ 'name': -1 });
-    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); }
 
   };
 
-  LimitedPartner.statics.modify = function(filter, update, cb) {
+  LimitedPartner.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
@@ -654,17 +647,18 @@ 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); }
 
   };
 
-  LimitedPartner.statics.modifyById = function(id, update, cb) {
+  LimitedPartner.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
@@ -675,73 +669,72 @@ 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); }
 
   };
 
-  LimitedPartner.statics.removeCustomerTransactions = function removeCustomerTransactions(customerId, cb) {
-
-    const self = this;
+  LimitedPartner.statics.removeCustomerTransactions = async function removeCustomerTransactions(customerId, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!customerId) { return cb(new Error('customerId is required'), null); }
     if (!mongoose.Types.ObjectId.isValid(customerId)) { return cb(new Error('customerId is not a valid ObjectId'), null); }
 
-    let query = self.updateMany(
-      { 'customer': customerId },
-      { $set: { transactions: [] } },
-      { multi : true }
-    );
+    try {
+      let query = this.updateMany(
+        { 'customer': customerId },
+        { $set: { transactions: [] } }
+      );
 
-    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); }
 
   };
 
-  LimitedPartner.statics.removeCustomerTags = function removeCustomerTags(customerId, cb) {
-
-    const self = this;
+  LimitedPartner.statics.removeCustomerTags = async function removeCustomerTags(customerId, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!customerId) { return cb(new Error('customerId is required'), null); }
     if (!mongoose.Types.ObjectId.isValid(customerId)) { return cb(new Error('customerId is not a valid ObjectId'), null); }
 
-    let query = self.updateMany(
-      { 'customer': customerId },
-      { $set: { details: [] } },
-      { multi : true }
-    );
+    try {
+      let query = this.updateMany(
+        { 'customer': customerId },
+        { $set: { details: [] } }
+      );
 
-    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); }
 
   };
 
-  LimitedPartner.statics.removeCustomerPeople = function removeCustomerPeople(customerId, cb) {
-
-    const self = this;
+  LimitedPartner.statics.removeCustomerPeople = async function removeCustomerPeople(customerId, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!customerId) { return cb(new Error('customerId is required'), null); }
     if (!mongoose.Types.ObjectId.isValid(customerId)) { return cb(new Error('customerId is not a valid ObjectId'), null); }
 
-    let query = self.updateOne(
-      { 'customer': customerId },
-      { $set: { people: [] } },
-      { multi : true }
-    );
+    try {
+      let query = this.updateMany(
+        { 'customer': customerId },
+        { $set: { people: [] } }
+      );
 
-    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); }
 
   };
 
-  LimitedPartner.statics.search = function (terms, options, cb) {
-
-    const self = this;
+  LimitedPartner.statics.search = async function (terms, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!terms) { return cb(new Error('terms is required'), null); }
@@ -751,26 +744,28 @@ module.exports = function(mongoose, config) {
 
     options = helpers.getDefaultOptions(options);
 
-    let query;
-
     if (options.role === 'none') { return cb(null, []); }
 
-    if (options.isWorkerProcess) {
-      query = self.find({'name': new RegExp(terms, 'i')}, getReadFilterKeys(options.role));
-    }
-    else {
-      query = self.find({ 'name': new RegExp(terms, 'i'), customer: options.CUSTOMER_ID }, getReadFilterKeys(options.role));
-    }
+    try {
+      let query;
+
+      if (options.isWorkerProcess) {
+        query = this.find({'name': new RegExp(terms, 'i')}, getReadFilterKeys(options.role));
+      }
+      else {
+        query = this.find({ 'name': new RegExp(terms, 'i'), customer: options.CUSTOMER_ID }, getReadFilterKeys(options.role));
+      }
 
-    query.populate('transactions.fund');
-    query.sort({ 'name': -1 });
-    query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+      query.populate('transactions.fund');
+      query.sort({ 'name': -1 });
 
-  };
+      const result = await query;
+      return cb(null, result);
+    } catch(err) { return cb(err); }
 
-  LimitedPartner.statics.search2 = function search2(value, options, cb) {
+  };
 
-    const self = this;
+  LimitedPartner.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); }
@@ -787,51 +782,54 @@ module.exports = function(mongoose, config) {
     // combine provided and default options
     options = _.defaults(options || {}, defaultOptions);
 
-    self.aggregate([
-      {
-        "$search": {
-          index: 'default',
-          compound: {
-            should: [
-              {
-                text: {
-                  query: value,
-                  path: [
-                    'name',
-                    'stakeholders',
-                    'details.value'
-                  ],
-                  fuzzy: {
-                    maxEdits: options.maxEdits,
-                    maxExpansions: options.maxExpansions
-                  },
-                  score: { boost: { value: 3 } }
+    try {
+      const result = await this.aggregate([
+        {
+          "$search": {
+            index: 'default',
+            compound: {
+              should: [
+                {
+                  text: {
+                    query: value,
+                    path: [
+                      'name',
+                      'stakeholders',
+                      'details.value'
+                    ],
+                    fuzzy: {
+                      maxEdits: options.maxEdits,
+                      maxExpansions: options.maxExpansions
+                    },
+                    score: { boost: { value: 3 } }
+                  }
                 }
-              }
-            ],
-            must: [
-              {
-                equals: {
-                  path: 'customer',
-                  value: new mongoose.Types.ObjectId(options.CUSTOMER_ID)
+              ],
+              must: [
+                {
+                  equals: {
+                    path: 'customer',
+                    value: new mongoose.Types.ObjectId(options.CUSTOMER_ID)
+                  }
                 }
-              }
-            ],
-            minimumShouldMatch: 1
+              ],
+              minimumShouldMatch: 1
+            }
+          }
+        },
+        {
+          $limit: options.limit,
+        },
+        {
+          $project: {
+            name: 1,
+            transactions: 1,
+            score: { $meta: "searchScore" }
           }
         }
-      },
-      {
-        $limit: options.limit,
-      },
-      {
-        $project: {
-          name: 1,
-          transactions: 1,
-          score: { $meta: "searchScore" }
-        }
-      }
-    ]).exec().then(function(result) {_.each(result, function(item) {
+      ]);
+
+      _.each(result, function(item) {
         item.commitment = calculateTotalCommitment(item.transactions);
         item.contribution = calculateTotalContribution(item.transactions);
         delete item.transactions;
@@ -839,12 +837,11 @@ module.exports = function(mongoose, config) {
 
       return cb(null, result);
 
-
-    }).catch(function(err) { cb(err); });
+    } catch(err) { return cb(err); }
 
   };
 
-  LimitedPartner.statics.upsert = function(lp, username, options, cb) {
+  LimitedPartner.statics.upsert = async function(lp, username, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!lp) { return cb(new Error('lp is required'), null); }
@@ -860,7 +857,10 @@ module.exports = function(mongoose, config) {
     lp.markModified('details');
     lp.markModified('customFields');
 
-    lp.save().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await lp.save();
+      return cb(null, result);
+    } catch(err) { return cb(err); }
 
   };