@dhyasama/totem-models 12.3.0 → 12.4.0

package/lib/Message.js

@@ -50,39 +50,44 @@ module.exports = function(mongoose, config) {
 
   };
 
-  Message.statics.delete = function(messageId, customerId, cb) {
-
-    const self = this;
-
-    self.findOneAndDelete({
-      '_id': messageId,
-      'customer': customerId
-    }).then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+  Message.statics.delete = async function(messageId, customerId, cb) {
+
+    try {
+      const result = await this.findOneAndDelete({
+        '_id': messageId,
+        'customer': customerId
+      });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Message.statics.deleteDocument = function(docId, customerId, cb) {
+  Message.statics.deleteDocument = async function(docId, customerId, cb) {
 
     // Delete the doc itself along with any references
 
-    const self = this;
+    try {
+      await new Promise((resolve, reject) => {
+        Document.delete({ CUSTOMER_ID: customerId }, docId, function(err, result) {
+          if (err) return reject(err);
+          resolve(result);
+        });
+      });
 
-    let removeReferences = function removeReferences(callback) {
-      self.updateMany({}, {
+      await this.updateMany({}, {
         $pull: { 'documents' : [docId] }
-      }).then(function(result) { callback(null, result); }).catch(function(err) { callback(err); });
-    };
+      });
 
-    async.series([
-      Document.delete.bind(Document, { CUSTOMER_ID: customerId }, docId),
-      removeReferences
-    ], function(err, results) {
+      return cb(null, null);
+    } catch(err) {
       return cb(err, null);
-    });
+    }
 
   };
 
-  Message.statics.getDocuments = function getDocuments(personIds, options, cb) {
+  Message.statics.getDocuments = async function getDocuments(personIds, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!personIds) { return cb(new Error('personIds is required'), null); }
@@ -90,21 +95,25 @@ 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); }
 
-    const self = this;
-    let query = self.find({ customer: options.CUSTOMER_ID });
+    try {
+      let query = this.find({ customer: options.CUSTOMER_ID });
 
-    query.where({'attendees.external': { $in : personIds }});
-    query.populate({
-      path: 'documents',
-      match: { customer: options.CUSTOMER_ID },
-      populate: { path: 'createdBy', select: 'name avatarUrl title' }
-    });
+      query.where({'attendees.external': { $in : personIds }});
+      query.populate({
+        path: 'documents',
+        match: { customer: options.CUSTOMER_ID },
+        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);
+    }
 
   };
 
-  Message.statics.getById = function getById(id, options, cb) {
+  Message.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); }
@@ -113,50 +122,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); }
 
-    const self = this;
-    let query = self.findOne({
-      _id: id,
-      customer: options.CUSTOMER_ID
-    });
-    query.populate('organization', 'name logoUrl');
-    query.populate('recipients.internal', 'name avatarUrl title doNotDisplay');
-    query.populate('recipients.external', 'name avatarUrl title doNotDisplay');
-    query.populate({
-      path: 'documents',
-      match: { customer: options.CUSTOMER_ID }
-    });
-
-    query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      let query = this.findOne({
+        _id: id,
+        customer: options.CUSTOMER_ID
+      });
+      query.populate('organization', 'name logoUrl');
+      query.populate('recipients.internal', 'name avatarUrl title doNotDisplay');
+      query.populate('recipients.external', 'name avatarUrl title doNotDisplay');
+      query.populate({
+        path: 'documents',
+        match: { customer: options.CUSTOMER_ID }
+      });
+
+      const result = await query;
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Message.statics.getForCustomer = function getForCustomer(customerId, cb) {
+  Message.statics.getForCustomer = async function getForCustomer(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); }
 
-    const self = this;
-    let query = self.find({ customer: customerId });
-
-    query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      let query = this.find({ customer: customerId });
+      const result = await query;
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Message.statics.getForDocument = function getForCustomer(docId, cb) {
+  Message.statics.getForDocument = async function getForCustomer(docId, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!docId) { return cb(new Error('docId is required'), null); }
     if (!mongoose.Types.ObjectId.isValid(docId)) { return cb(new Error('docId is not a valid ObjectId'), null); }
 
-    const self = this;
-    let query = self.findOne({ documents: { $in: [docId] } });
-
-    query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      let query = this.findOne({ documents: { $in: [docId] } });
+      const result = await query;
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Message.statics.getForOrg = function getForOrg(orgId, options, cb) {
+  Message.statics.getForOrg = async function getForOrg(orgId, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!orgId) { return cb(new Error('orgId is required'), null); }
@@ -167,23 +186,26 @@ module.exports = function(mongoose, config) {
 
     // Note - This filters by customer so is NOT usable by admin tools
 
-    const self = this;
-
-    let query = self.find({ customer: options.CUSTOMER_ID, organization: orgId });
-
-    query.populate('recipients.internal', 'name title avatarUrl doNotDisplay');
-    query.populate('recipients.external', 'name title avatarUrl doNotDisplay');
-    query.populate({
-      path: 'documents',
-      match: { customer: options.CUSTOMER_ID },
-      populate: { path: 'createdBy', select: 'name avatarUrl title' }
-    });
-
-    query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      let query = this.find({ customer: options.CUSTOMER_ID, organization: orgId });
+
+      query.populate('recipients.internal', 'name title avatarUrl doNotDisplay');
+      query.populate('recipients.external', 'name title avatarUrl doNotDisplay');
+      query.populate({
+        path: 'documents',
+        match: { customer: options.CUSTOMER_ID },
+        populate: { path: 'createdBy', select: 'name avatarUrl title' }
+      });
+
+      const result = await query;
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Message.statics.getForOrgs = function(orgIds, options, cb) {
+  Message.statics.getForOrgs = async function(orgIds, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!orgIds) { return cb(new Error('orgIds is required'), null); }
@@ -191,27 +213,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); }
 
-    const self = this;
-
-    let query = self.find({ customer: options.CUSTOMER_ID });
-    query.find({ organization: { $in : orgIds }});
-
-    if (options.startDate) {
-      const startDate = options.startDate || moment().subtract(20, 'years').startOf('day').toISOString();
-      query.where('messageDate').gte(startDate)
-    }
-
-    if (options.endDate) {
-      const endDate = options.endDate || moment().toISOString();
-      query.where('messageDate').lte(endDate)
+    try {
+      let query = this.find({ customer: options.CUSTOMER_ID });
+      query.find({ organization: { $in : orgIds }});
+
+      if (options.startDate) {
+        const startDate = options.startDate || moment().subtract(20, 'years').startOf('day').toISOString();
+        query.where('messageDate').gte(startDate)
+      }
+
+      if (options.endDate) {
+        const endDate = options.endDate || moment().toISOString();
+        query.where('messageDate').lte(endDate)
+      }
+
+      query.populate('documents');
+      const result = await query;
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
     }
 
-    query.populate('documents');
-    query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
-
   };
 
-  Message.statics.getMostRecent = function getMostRecent(orgId, personIds, options, cb) {
+  Message.statics.getMostRecent = async function getMostRecent(orgId, personIds, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!orgId) { return cb(new Error('orgId is required'), null); }
@@ -222,29 +247,32 @@ module.exports = function(mongoose, config) {
 
     // Note - This filters by customer so is NOT usable by admin tools
 
-    const self = this;
-
-    // Must match customer
-    let query = self.find({ customer: options.CUSTOMER_ID });
+    try {
+      // Must match customer
+      let query = this.find({ customer: options.CUSTOMER_ID });
 
-    // Match either the org or a list of people
-    query.where({ $or: [{organization: orgId}, {'recipients.external': { $in : personIds }}] });
+      // Match either the org or a list of people
+      query.where({ $or: [{organization: orgId}, {'recipients.external': { $in : personIds }}] });
 
-    // Optionally limit search space to message newer than some timestamp
-    if (options.timestamp) query.where({'messageDate': { $gte: options.timestamp }});
+      // Optionally limit search space to message newer than some timestamp
+      if (options.timestamp) query.where({'messageDate': { $gte: options.timestamp }});
 
-    // Don't need the full raw message
-    query.select({ 'raw': 0 });
+      // Don't need the full raw message
+      query.select({ 'raw': 0 });
 
-    // Only need one
-    query.sort({ 'messageDate': -1 });
-    query.limit(1);
+      // Only need one
+      query.sort({ 'messageDate': -1 });
+      query.limit(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);
+    }
 
   };
 
-  Message.statics.getMostRecent2 = function getMostRecent2(orgId, personIds, options, cb) {
+  Message.statics.getMostRecent2 = async function getMostRecent2(orgId, personIds, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!orgId) { return cb(new Error('orgId is required'), null); }
@@ -255,33 +283,36 @@ module.exports = function(mongoose, config) {
 
     // Note - This filters by customer so is NOT usable by admin tools
 
-    const self = this;
-
-    // Must match customer
-    let query = self.findOne({ customer: options.CUSTOMER_ID });
+    try {
+      // Must match customer
+      let query = this.findOne({ customer: options.CUSTOMER_ID });
 
-    personIds = personIds || [];
+      personIds = personIds || [];
 
-    // Match either the org or a list of people
-    if (personIds.length >= 1) { query.where({ $or: [{organization: orgId}, {'recipients.external': { $in : personIds }}] }); }
+      // Match either the org or a list of people
+      if (personIds.length >= 1) { query.where({ $or: [{organization: orgId}, {'recipients.external': { $in : personIds }}] }); }
 
-    // No people, just do the org
-    else { query.where({ organization: orgId }); }
+      // No people, just do the org
+      else { query.where({ organization: orgId }); }
 
-    // Optionally limit search space to message newer than some timestamp
-    if (options.timestamp) query.where({'messageDate': { $gt: options.timestamp }});
+      // Optionally limit search space to message newer than some timestamp
+      if (options.timestamp) query.where({'messageDate': { $gt: options.timestamp }});
 
-    // Don't need the full raw message
-    query.select({ 'raw': 0 });
+      // Don't need the full raw message
+      query.select({ 'raw': 0 });
 
-    query.sort({ 'startTime': -1 });
-    query.limit(1);
+      query.sort({ 'startTime': -1 });
+      query.limit(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);
+    }
 
   };
 
-  Message.statics.getForPeople = function getForPeople(personIds, options, cb) {
+  Message.statics.getForPeople = async function getForPeople(personIds, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!personIds) { return cb(new Error('personIds is required'), null); }
@@ -291,24 +322,27 @@ module.exports = function(mongoose, config) {
 
     // Note: This filters by customer so is NOT usable by admin tools
 
-    const self = this;
-
-    let query = self.find({ customer: options.CUSTOMER_ID });
-
-    query.where({'recipients.external': { $in : personIds }});
-    query.populate('recipients.internal', 'name title avatarUrl doNotDisplay');
-    query.populate('recipients.external', 'name title avatarUrl doNotDisplay');
-    query.populate({
-      path: 'documents',
-      match: { customer: options.CUSTOMER_ID },
-      populate: { path: 'createdBy', select: 'name avatarUrl title' }
-    });
-
-    query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      let query = this.find({ customer: options.CUSTOMER_ID });
+
+      query.where({'recipients.external': { $in : personIds }});
+      query.populate('recipients.internal', 'name title avatarUrl doNotDisplay');
+      query.populate('recipients.external', 'name title avatarUrl doNotDisplay');
+      query.populate({
+        path: 'documents',
+        match: { customer: options.CUSTOMER_ID },
+        populate: { path: 'createdBy', select: 'name avatarUrl title' }
+      });
+
+      const result = await query;
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Message.statics.getForPeopleLite = function getForPeopleLite(personIds, options, cb) {
+  Message.statics.getForPeopleLite = async function getForPeopleLite(personIds, options, cb) {
 
     // Note - This doesn't filter by customer so is only usable by admin tools
 
@@ -319,49 +353,59 @@ module.exports = function(mongoose, config) {
 
     if (!options.isWorkerProcess) { return cb(null, []); }
 
-    const self = this;
-
-    let query = self.find({'recipients.external': { $in : personIds }});
-
-    query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      let query = this.find({'recipients.external': { $in : personIds }});
+      const result = await query;
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Message.statics.getUnprocessedDeals = function getUnprocessedDeals(customerId, cb) {
-
-    const self = this;
-    let query = self.find({
-      customer: customerId,
-      subtype: 'deals',
-      processed: { $ne: true }
-    });
-    query.populate({
-      path: 'documents',
-      match: { customer: customerId }
-    });
-
-    query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+  Message.statics.getUnprocessedDeals = async function getUnprocessedDeals(customerId, cb) {
+
+    try {
+      let query = this.find({
+        customer: customerId,
+        subtype: 'deals',
+        processed: { $ne: true }
+      });
+      query.populate({
+        path: 'documents',
+        match: { customer: customerId }
+      });
+
+      const result = await query;
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Message.statics.getUnprocessedPortfolio = function getUnprocessedPortfolio(customerId, cb) {
-
-    const self = this;
-    let query = self.find({
-      customer: customerId,
-      subtype: 'portfolio',
-      processed: { $ne: true }
-    });
-    query.populate({
-      path: 'documents',
-      match: { customer: customerId }
-    });
-
-    query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+  Message.statics.getUnprocessedPortfolio = async function getUnprocessedPortfolio(customerId, cb) {
+
+    try {
+      let query = this.find({
+        customer: customerId,
+        subtype: 'portfolio',
+        processed: { $ne: true }
+      });
+      query.populate({
+        path: 'documents',
+        match: { customer: customerId }
+      });
+
+      const result = await query;
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Message.statics.modifyById = function(id, update, cb) {
+  Message.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
@@ -370,16 +414,19 @@ module.exports = function(mongoose, config) {
     if (!id) { return cb(new Error('id is required'), null); }
     if (!update) { return cb(new Error('update is required'), null); }
 
-    const self = this;
-
     // 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);
+    }
 
   };
 
-  Message.statics.upsert = function(message, cb) {
+  Message.statics.upsert = async function(message, cb) {
 
     const timestamp = new Date();
 
@@ -392,7 +439,12 @@ module.exports = function(mongoose, config) {
     // The original message date isn't always contained in the email. In its absence, use created on.
     message.messageDate = message.messageDate || message.originalMessageDate || message.createdOn;
 
-    message.save().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await message.save();
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
@@ -402,4 +454,4 @@ module.exports = function(mongoose, config) {
 
   mongoose.model('Message', Message);
 
-};
+};

package/lib/MessageRecipient.js

@@ -16,7 +16,7 @@ module.exports = function(mongoose, config) {
 
   ///////////////////////////////////////
 
-  MessageRecipient.statics.getMostRecent = function getMostRecent(orgId, customerId, personId, options, cb) {
+  MessageRecipient.statics.getMostRecent = async function getMostRecent(orgId, customerId, personId, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!orgId) { return cb(new Error('orgId is required'), null); }
@@ -26,28 +26,31 @@ module.exports = function(mongoose, config) {
     if (!personId) { return cb(new Error('personId is required'), null); }
     if (!mongoose.Types.ObjectId.isValid(personId)) { return cb(new Error('personId is not a valid ObjectId'), null); }
 
-    const self = this;
-
     options = options || {};
 
-    let query = self.find({
-      customer: options.CUSTOMER_ID,
-      organization: orgId,
-      recipient: personId
-    });
+    try {
+      let query = this.find({
+        customer: options.CUSTOMER_ID,
+        organization: orgId,
+        recipient: personId
+      });
 
-    // Optionally limit search space to message newer than some timestamp
-    if (options.timestamp) query.where({'messageDate': { $gte: options.timestamp }});
+      // Optionally limit search space to message newer than some timestamp
+      if (options.timestamp) query.where({'messageDate': { $gte: options.timestamp }});
 
-    // Only need one
-    query.sort({ 'messageDate': -1 });
-    query.limit(1);
+      // Only need one
+      query.sort({ 'messageDate': -1 });
+      query.limit(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);
+    }
 
   };
 
-  MessageRecipient.statics.getMostRecentBatch = function getMostRecentBatch(orgId, customerId, personIds, options, cb) {
+  MessageRecipient.statics.getMostRecentBatch = async function getMostRecentBatch(orgId, customerId, personIds, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!orgId) { return cb(new Error('orgId is required'), null); }
@@ -57,34 +60,42 @@ module.exports = function(mongoose, config) {
     if (!personIds) { return cb(new Error('personIds is required'), null); }
     if (!Array.isArray(personIds)) { return cb(new Error('personIds must be an array'), null); }
 
-    const self = this;
-
     options = options || {};
 
-    let query = self.find({
-      customer: options.CUSTOMER_ID,
-      organization: orgId
-    });
+    try {
+      let query = this.find({
+        customer: options.CUSTOMER_ID,
+        organization: orgId
+      });
 
-    query.where({ 'recipient': { $in : personIds }});
+      query.where({ 'recipient': { $in : personIds }});
 
-    // Optionally limit search space to message newer than some timestamp
-    if (options.timestamp) query.where({'messageDate': { $gte: options.timestamp }});
+      // Optionally limit search space to message newer than some timestamp
+      if (options.timestamp) query.where({'messageDate': { $gte: options.timestamp }});
 
-    // Only need one
-    query.sort({ 'messageDate': -1 });
-    query.limit(1);
+      // Only need one
+      query.sort({ 'messageDate': -1 });
+      query.limit(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);
+    }
 
   };
 
-  MessageRecipient.statics.upsert = function(message, cb) {
-    message.save().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+  MessageRecipient.statics.upsert = async function(message, cb) {
+    try {
+      const result = await message.save();
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
   };
 
   ///////////////////////////////////////
 
   mongoose.model('MessageRecipient', MessageRecipient);
 
-};
+};