@dhyasama/totem-models 12.3.0 → 12.4.0

package/lib/LimitedPartnerCampaign.js

@@ -39,9 +39,7 @@ module.exports = function(mongoose, config) {
 
   });
 
-  LimitedPartnerCampaign.statics.getById = function getById(campaignId, customerId, options, cb) {
-
-    const self = this;
+  LimitedPartnerCampaign.statics.getById = async function getById(campaignId, customerId, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!campaignId) { return cb(new Error('campaignId is required'), null); }
@@ -49,19 +47,21 @@ module.exports = function(mongoose, config) {
     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 query = self.findOne({
-      _id: campaignId,
-      customer: customerId
-    });
+    try {
+      const query = this.findOne({
+        _id: campaignId,
+        customer: customerId
+      });
 
-    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); }
 
   };
 
   // Scheduled but not sent and not done trying
-  LimitedPartnerCampaign.statics.getUpcoming = function getUpcoming(customerId, options, cb) {
+  LimitedPartnerCampaign.statics.getUpcoming = async function getUpcoming(customerId, options, cb) {
 
-    const self = this;
     const now = new Date();
 
     if (!cb) { throw new Error('cb is required'); }
@@ -70,64 +70,68 @@ module.exports = function(mongoose, config) {
 
     // No need to check send on. If no sentEmailsToQueue then safe to assume sendOn is in the future.
 
-    const query = self.find({
-      customer: customerId,
-      processed: false,
-      numberOfFailedAttempts: { $lt: MAX_PROCESSING_ATTEMPTS }
-    });
+    try {
+      const query = this.find({
+        customer: customerId,
+        processed: false,
+        numberOfFailedAttempts: { $lt: MAX_PROCESSING_ATTEMPTS }
+      });
 
-    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); }
 
   };
 
   // Scheduled and ready to be sent
   // Note this doesn't use customer id because it's for the worker and we want all customers.
-  LimitedPartnerCampaign.statics.getOutbound = function getOutbound(options, cb) {
+  LimitedPartnerCampaign.statics.getOutbound = async function getOutbound(options, cb) {
 
-    const self = this;
     const now = new Date();
 
     if (!cb) { throw new Error('cb is required'); }
 
-    let query = self.find({
-      processed: false,
-      numberOfFailedAttempts: { $lt: MAX_PROCESSING_ATTEMPTS },
-      sendOn: { $lte: now }
-    });
+    try {
+      let query = this.find({
+        processed: false,
+        numberOfFailedAttempts: { $lt: MAX_PROCESSING_ATTEMPTS },
+        sendOn: { $lte: now }
+      });
 
-    query.populate('customer', 'name logoUrl customer');
+      query.populate('customer', 'name logoUrl customer');
 
-    // Earliest first
-    query.sort({ sendOn: 1 });
+      // Earliest first
+      query.sort({ sendOn: 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); }
 
   };
 
   // Scheduled and sent or done trying
-  LimitedPartnerCampaign.statics.getHistorical = function getHistorical(customerId, options, cb) {
-
-    const self = this;
+  LimitedPartnerCampaign.statics.getHistorical = async function getHistorical(customerId, options, 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 query = self.find({
-      customer: customerId,
-      $or: [
-        { processed: true },
-        { numberOfFailedAttempts: { $gt: MAX_PROCESSING_ATTEMPTS } }
-      ]
-    });
+    try {
+      const query = this.find({
+        customer: customerId,
+        $or: [
+          { processed: true },
+          { numberOfFailedAttempts: { $gt: MAX_PROCESSING_ATTEMPTS } }
+        ]
+      });
 
-    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); }
 
   };
 
-  LimitedPartnerCampaign.statics.remove = function remove(campaignId, customerId, options, cb) {
-
-    const self = this;
+  LimitedPartnerCampaign.statics.remove = async function remove(campaignId, customerId, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!campaignId) { return cb(new Error('campaignId is required'), null); }
@@ -135,22 +139,28 @@ module.exports = function(mongoose, config) {
     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 query = self.findOneAndDelete({
-      _id: campaignId,
-      customer: customerId
-    });
+    try {
+      const query = this.findOneAndDelete({
+        _id: campaignId,
+        customer: customerId
+      });
 
-    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); }
 
     // remove associated limited partner communications at the business logic layer
 
   };
 
-  LimitedPartnerCampaign.statics.upsert = function upsert(doc, options, cb) {
+  LimitedPartnerCampaign.statics.upsert = async function upsert(doc, options, cb) {
 
     if (!doc) { return cb(new Error('doc is required'), null); }
 
-    doc.save().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await doc.save();
+      return cb(null, result);
+    } catch(err) { return cb(err); }
 
   };
 
@@ -165,4 +175,4 @@ module.exports = function(mongoose, config) {
 
   mongoose.model('LimitedPartnerCampaign', LimitedPartnerCampaign);
 
-};
+};

package/lib/LimitedPartnerCommunication.js

@@ -48,42 +48,42 @@ module.exports = function(mongoose, config) {
 
   });
 
-  LimitedPartnerCommunication.statics.getByCampaign = function getByCampaign(campaignId, options, cb) {
-
-    const self = this;
+  LimitedPartnerCommunication.statics.getByCampaign = async function getByCampaign(campaignId, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!campaignId) { return cb(new Error('campaignId is required'), null); }
     if (!mongoose.Types.ObjectId.isValid(campaignId)) { return cb(new Error('campaignId is not a valid ObjectId'), null); }
 
-    let query = self.find({
-      campaign: campaignId
-    });
+    try {
+      let query = this.find({
+        campaign: campaignId
+      });
 
-    query.populate('limitedPartner', 'name');
+      query.populate('limitedPartner', 'name');
 
-    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); }
 
   };
 
-  LimitedPartnerCommunication.statics.getByCampaigns = function getByCampaigns(campaignIds, options, cb) {
-
-    const self = this;
+  LimitedPartnerCommunication.statics.getByCampaigns = async function getByCampaigns(campaignIds, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
 
-    const query = self.find({
-      campaign: { $in: campaignIds }
-    });
+    try {
+      const query = this.find({
+        campaign: { $in: campaignIds }
+      });
 
-    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); }
 
   };
 
   // So we can put these on person pages
-  LimitedPartnerCommunication.statics.getByEmail = function getByEmail(email, options, cb) {
-
-    const self = this;
+  LimitedPartnerCommunication.statics.getByEmail = async function getByEmail(email, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!email) { return cb(new Error('email is required'), null); }
@@ -91,35 +91,37 @@ 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({
-      email: email,
-      customer: options.CUSTOMER_ID
-    });
+    try {
+      let query = this.find({
+        email: email,
+        customer: options.CUSTOMER_ID
+      });
 
-    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); }
 
   };
 
-  LimitedPartnerCommunication.statics.getById = function getById(id, options, cb) {
-
-    const self = this;
+  LimitedPartnerCommunication.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); }
     if (!mongoose.Types.ObjectId.isValid(id)) { return cb(new Error('id is not a valid ObjectId'), null); }
 
-    let query = self.find({
-      _id: id
-    });
+    try {
+      let query = this.find({
+        _id: id
+      });
 
-    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); }
 
   };
 
   // So we can put these on lp pages
-  LimitedPartnerCommunication.statics.getForLimitedPartner = function getForLimitedPartner(lpid, options, cb) {
-
-    const self = this;
+  LimitedPartnerCommunication.statics.getForLimitedPartner = async function getForLimitedPartner(lpid, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!lpid) { return cb(new Error('lpid is required'), null); }
@@ -128,106 +130,118 @@ 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({
-      limitedPartner: lpid,
-      customer: options.CUSTOMER_ID
-    });
+    try {
+      let query = this.find({
+        limitedPartner: lpid,
+        customer: options.CUSTOMER_ID
+      });
 
-    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); }
 
   };
 
-  LimitedPartnerCommunication.statics.getByPostmarkMessageId = function getByPostmarkMessageId(postmarkMessageId, cb) {
-
-    const self = this;
+  LimitedPartnerCommunication.statics.getByPostmarkMessageId = async function getByPostmarkMessageId(postmarkMessageId, cb) {
 
-    const query = self.findOne({ postmarkMessageId: postmarkMessageId });
+    try {
+      const query = this.findOne({ postmarkMessageId: postmarkMessageId });
 
-    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); }
 
   };
 
-  LimitedPartnerCommunication.statics.getUnsentByCampaigns = function getUnsentByCampaigns(campaignIds, options, cb) {
-
-    const self = this;
+  LimitedPartnerCommunication.statics.getUnsentByCampaigns = async function getUnsentByCampaigns(campaignIds, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
 
-    const query = self.find({
-      campaign: { $in: campaignIds },
-      $and: [{ sentOn: null }] // matches null or not set
-    });
+    try {
+      const query = this.find({
+        campaign: { $in: campaignIds },
+        $and: [{ sentOn: null }] // matches null or not set
+      });
 
-    query.populate('limitedPartner', 'name');
+      query.populate('limitedPartner', 'name');
 
-    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); }
 
   };
 
-  LimitedPartnerCommunication.statics.modifyById = function modifyById(id, update, options, cb) {
-
-    const self = this;
+  LimitedPartnerCommunication.statics.modifyById = async function modifyById(id, update, options, cb) {
 
     if (!cb) throw new Error('cb is required');
     if (!id) { return cb(new Error('id is required'), null); }
     if (!update) { return cb(new Error('update is required'), null); }
 
-    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); }
 
   };
 
-  LimitedPartnerCommunication.statics.modifyOne = function modifyOne(conditions, update, options, cb) {
-
-    const self = this;
+  LimitedPartnerCommunication.statics.modifyOne = async function modifyOne(conditions, update, options, cb) {
 
     if (!cb) throw new Error('cb is required');
     if (!conditions) { return cb(new Error('conditions is required'), null); }
     if (!update) { return cb(new Error('update is required'), null); }
 
-    const query = self.findOneAndUpdate(conditions, update, { upsert: false, new: true });
+    try {
+      const query = this.findOneAndUpdate(conditions, update, { upsert: false, new: true });
 
-    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); }
 
   };
 
   // Remove all the docs associated with a campaign
-  LimitedPartnerCommunication.statics.removeByCampaign = function removeByCampaign(campaignId, options, cb) {
-
-    const self = this;
+  LimitedPartnerCommunication.statics.removeByCampaign = async function removeByCampaign(campaignId, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!campaignId) { return cb(new Error('campaignId is required'), null); }
     if (!mongoose.Types.ObjectId.isValid(campaignId)) { return cb(new Error('campaignId is not a valid ObjectId'), null); }
 
-    const query = self.deleteMany({
-      campaign: campaignId
-    });
+    try {
+      const query = this.deleteMany({
+        campaign: campaignId
+      });
 
-    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); }
 
   };
 
-  LimitedPartnerCommunication.statics.removeById = function removeById(id, options, cb) {
-
-    const self = this;
+  LimitedPartnerCommunication.statics.removeById = async function removeById(id, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!id) { return cb(new Error('id is required'), null); }
     if (!mongoose.Types.ObjectId.isValid(id)) { return cb(new Error('id is not a valid ObjectId'), null); }
 
-    const query = self.findByIdAndDelete({
-      _id: id
-    });
+    try {
+      const query = this.findByIdAndDelete({
+        _id: id
+      });
 
-    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); }
 
   };
 
-  LimitedPartnerCommunication.statics.upsert = function upsert(doc, options, cb) {
+  LimitedPartnerCommunication.statics.upsert = async function upsert(doc, options, cb) {
 
     if (!doc) { return cb(new Error('doc is required'), null); }
 
-    doc.save().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await doc.save();
+      return cb(null, result);
+    } catch(err) { return cb(err); }
 
   };
 

package/lib/LimitedPartnerContactGroup.js

@@ -5,8 +5,7 @@ module.exports = function(mongoose, config) {
   let
 
     Schema = mongoose.Schema,
-    _ = require('underscore'),
-    async = require('async');
+    _ = require('underscore');
 
   const LimitedPartnerContactGroup = new Schema({
 
@@ -30,9 +29,7 @@ module.exports = function(mongoose, config) {
   });
 
   // Get a contact group
-  LimitedPartnerContactGroup.statics.getById = function (id, options, cb) {
-
-    const self = this;
+  LimitedPartnerContactGroup.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); }
@@ -41,57 +38,58 @@ 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': id,
-      'customer': options.CUSTOMER_ID
-    });
+    try {
+      let query = this.findOne({
+        '_id': id,
+        'customer': options.CUSTOMER_ID
+      });
 
-    query.populate('contacts.limitedPartner', 'name');
+      query.populate('contacts.limitedPartner', 'name');
 
-    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); }
 
   };
 
   // Get all contact groups for a customer
-  LimitedPartnerContactGroup.statics.getForCustomer = function (customerId, options, cb) {
-
-    const self = this;
+  LimitedPartnerContactGroup.statics.getForCustomer = async function (customerId, options, 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.find({
-      'customer': customerId
-    });
+    try {
+      let query = this.find({
+        'customer': customerId
+      });
 
-    query.populate('contacts.limitedPartner', 'name');
+      query.populate('contacts.limitedPartner', 'name');
 
-    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); }
 
   };
 
-  LimitedPartnerContactGroup.statics.removeForCustomer = function removeForCustomer(customerId, cb) {
-
-    let self = this;
-
-    self
-      .find({ customer: customerId })
-      .exec().then(function(groups) {async.each(groups, function(group, callback) {
-          group.deleteOne().then(function() { callback(null, group); }).catch(function(err) { callback(err); });
-        }, function(err) {
-          return cb(err, null);
-        });
+  LimitedPartnerContactGroup.statics.removeForCustomer = async function removeForCustomer(customerId, cb) {
 
-      }).catch(function(err) { cb(err); });
+    try {
+      const groups = await this.find({ customer: customerId });
+      await Promise.all(groups.map(function(group) { return group.deleteOne(); }));
+      return cb(null, null);
+    } catch(err) { return cb(err); }
 
   };
 
-  LimitedPartnerContactGroup.statics.upsert = function upsert(doc, options, cb) {
+  LimitedPartnerContactGroup.statics.upsert = async function upsert(doc, options, cb) {
 
     if (!doc) { return cb(new Error('doc is required'), null); }
 
-    doc.save().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await doc.save();
+      return cb(null, result);
+    } catch(err) { return cb(err); }
 
   };
 

package/lib/LimitedPartnerReportGenerator.js

@@ -51,29 +51,33 @@ module.exports = function(mongoose, config) {
 
   });
 
-  LimitedPartnerReportGenerator.statics.getById = function (id, options, cb) {
-
-    const self = this;
+  LimitedPartnerReportGenerator.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); }
     if (!mongoose.Types.ObjectId.isValid(id)) { return cb(new Error('id is not a valid ObjectId'), null); }
 
-    self.findOne({
-      '_id': id
-    }).exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.findOne({
+        '_id': id
+      });
+      return cb(null, result);
+    } catch(err) { return cb(err); }
 
   };
 
-  LimitedPartnerReportGenerator.statics.upsert = function upsert(doc, options, cb) {
+  LimitedPartnerReportGenerator.statics.upsert = async function upsert(doc, options, cb) {
 
     if (!doc) { return cb(new Error('doc is required'), null); }
 
-    doc.save().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await doc.save();
+      return cb(null, result);
+    } catch(err) { return cb(err); }
 
   };
   LimitedPartnerReportGenerator.set('autoIndex', false);
 
   mongoose.model('LimitedPartnerReportGenerator', LimitedPartnerReportGenerator);
 
-};
+};